auth_gss.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255
  1. /*
  2. * linux/net/sunrpc/auth_gss/auth_gss.c
  3. *
  4. * RPCSEC_GSS client authentication.
  5. *
  6. * Copyright (c) 2000 The Regents of the University of Michigan.
  7. * All rights reserved.
  8. *
  9. * Dug Song <dugsong@monkey.org>
  10. * Andy Adamson <andros@umich.edu>
  11. *
  12. * Redistribution and use in source and binary forms, with or without
  13. * modification, are permitted provided that the following conditions
  14. * are met:
  15. *
  16. * 1. Redistributions of source code must retain the above copyright
  17. * notice, this list of conditions and the following disclaimer.
  18. * 2. Redistributions in binary form must reproduce the above copyright
  19. * notice, this list of conditions and the following disclaimer in the
  20. * documentation and/or other materials provided with the distribution.
  21. * 3. Neither the name of the University nor the names of its
  22. * contributors may be used to endorse or promote products derived
  23. * from this software without specific prior written permission.
  24. *
  25. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36. *
  37. * $Id$
  38. */
  39. #include <linux/module.h>
  40. #include <linux/init.h>
  41. #include <linux/types.h>
  42. #include <linux/slab.h>
  43. #include <linux/sched.h>
  44. #include <linux/pagemap.h>
  45. #include <linux/sunrpc/clnt.h>
  46. #include <linux/sunrpc/auth.h>
  47. #include <linux/sunrpc/auth_gss.h>
  48. #include <linux/sunrpc/svcauth_gss.h>
  49. #include <linux/sunrpc/gss_err.h>
  50. #include <linux/workqueue.h>
  51. #include <linux/sunrpc/rpc_pipe_fs.h>
  52. #include <linux/sunrpc/gss_api.h>
  53. #include <asm/uaccess.h>
  54. static struct rpc_authops authgss_ops;
  55. static struct rpc_credops gss_credops;
  56. #ifdef RPC_DEBUG
  57. # define RPCDBG_FACILITY RPCDBG_AUTH
  58. #endif
  59. #define NFS_NGROUPS 16
  60. #define GSS_CRED_EXPIRE (60 * HZ) /* XXX: reasonable? */
  61. #define GSS_CRED_SLACK 1024 /* XXX: unused */
  62. /* length of a krb5 verifier (48), plus data added before arguments when
  63. * using integrity (two 4-byte integers): */
  64. #define GSS_VERF_SLACK 100
  65. /* XXX this define must match the gssd define
  66. * as it is passed to gssd to signal the use of
  67. * machine creds should be part of the shared rpc interface */
  68. #define CA_RUN_AS_MACHINE 0x00000200
  69. /* dump the buffer in `emacs-hexl' style */
  70. #define isprint(c) ((c > 0x1f) && (c < 0x7f))
  71. static DEFINE_RWLOCK(gss_ctx_lock);
  72. struct gss_auth {
  73. struct rpc_auth rpc_auth;
  74. struct gss_api_mech *mech;
  75. enum rpc_gss_svc service;
  76. struct rpc_clnt *client;
  77. struct dentry *dentry;
  78. };
  79. static void gss_destroy_ctx(struct gss_cl_ctx *);
  80. static struct rpc_pipe_ops gss_upcall_ops;
  81. static inline struct gss_cl_ctx *
  82. gss_get_ctx(struct gss_cl_ctx *ctx)
  83. {
  84. atomic_inc(&ctx->count);
  85. return ctx;
  86. }
  87. static inline void
  88. gss_put_ctx(struct gss_cl_ctx *ctx)
  89. {
  90. if (atomic_dec_and_test(&ctx->count))
  91. gss_destroy_ctx(ctx);
  92. }
  93. static void
  94. gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
  95. {
  96. struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
  97. struct gss_cl_ctx *old;
  98. write_lock(&gss_ctx_lock);
  99. old = gss_cred->gc_ctx;
  100. gss_cred->gc_ctx = ctx;
  101. cred->cr_flags |= RPCAUTH_CRED_UPTODATE;
  102. cred->cr_flags &= ~RPCAUTH_CRED_NEW;
  103. write_unlock(&gss_ctx_lock);
  104. if (old)
  105. gss_put_ctx(old);
  106. }
  107. static int
  108. gss_cred_is_uptodate_ctx(struct rpc_cred *cred)
  109. {
  110. struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
  111. int res = 0;
  112. read_lock(&gss_ctx_lock);
  113. if ((cred->cr_flags & RPCAUTH_CRED_UPTODATE) && gss_cred->gc_ctx)
  114. res = 1;
  115. read_unlock(&gss_ctx_lock);
  116. return res;
  117. }
  118. static const void *
  119. simple_get_bytes(const void *p, const void *end, void *res, size_t len)
  120. {
  121. const void *q = (const void *)((const char *)p + len);
  122. if (unlikely(q > end || q < p))
  123. return ERR_PTR(-EFAULT);
  124. memcpy(res, p, len);
  125. return q;
  126. }
  127. static inline const void *
  128. simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)
  129. {
  130. const void *q;
  131. unsigned int len;
  132. p = simple_get_bytes(p, end, &len, sizeof(len));
  133. if (IS_ERR(p))
  134. return p;
  135. q = (const void *)((const char *)p + len);
  136. if (unlikely(q > end || q < p))
  137. return ERR_PTR(-EFAULT);
  138. dest->data = kmemdup(p, len, GFP_KERNEL);
  139. if (unlikely(dest->data == NULL))
  140. return ERR_PTR(-ENOMEM);
  141. dest->len = len;
  142. return q;
  143. }
  144. static struct gss_cl_ctx *
  145. gss_cred_get_ctx(struct rpc_cred *cred)
  146. {
  147. struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
  148. struct gss_cl_ctx *ctx = NULL;
  149. read_lock(&gss_ctx_lock);
  150. if (gss_cred->gc_ctx)
  151. ctx = gss_get_ctx(gss_cred->gc_ctx);
  152. read_unlock(&gss_ctx_lock);
  153. return ctx;
  154. }
  155. static struct gss_cl_ctx *
  156. gss_alloc_context(void)
  157. {
  158. struct gss_cl_ctx *ctx;
  159. ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
  160. if (ctx != NULL) {
  161. ctx->gc_proc = RPC_GSS_PROC_DATA;
  162. ctx->gc_seq = 1; /* NetApp 6.4R1 doesn't accept seq. no. 0 */
  163. spin_lock_init(&ctx->gc_seq_lock);
  164. atomic_set(&ctx->count,1);
  165. }
  166. return ctx;
  167. }
  168. #define GSSD_MIN_TIMEOUT (60 * 60)
  169. static const void *
  170. gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)
  171. {
  172. const void *q;
  173. unsigned int seclen;
  174. unsigned int timeout;
  175. u32 window_size;
  176. int ret;
  177. /* First unsigned int gives the lifetime (in seconds) of the cred */
  178. p = simple_get_bytes(p, end, &timeout, sizeof(timeout));
  179. if (IS_ERR(p))
  180. goto err;
  181. if (timeout == 0)
  182. timeout = GSSD_MIN_TIMEOUT;
  183. ctx->gc_expiry = jiffies + (unsigned long)timeout * HZ * 3 / 4;
  184. /* Sequence number window. Determines the maximum number of simultaneous requests */
  185. p = simple_get_bytes(p, end, &window_size, sizeof(window_size));
  186. if (IS_ERR(p))
  187. goto err;
  188. ctx->gc_win = window_size;
  189. /* gssd signals an error by passing ctx->gc_win = 0: */
  190. if (ctx->gc_win == 0) {
  191. /* in which case, p points to an error code which we ignore */
  192. p = ERR_PTR(-EACCES);
  193. goto err;
  194. }
  195. /* copy the opaque wire context */
  196. p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);
  197. if (IS_ERR(p))
  198. goto err;
  199. /* import the opaque security context */
  200. p = simple_get_bytes(p, end, &seclen, sizeof(seclen));
  201. if (IS_ERR(p))
  202. goto err;
  203. q = (const void *)((const char *)p + seclen);
  204. if (unlikely(q > end || q < p)) {
  205. p = ERR_PTR(-EFAULT);
  206. goto err;
  207. }
  208. ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx);
  209. if (ret < 0) {
  210. p = ERR_PTR(ret);
  211. goto err;
  212. }
  213. return q;
  214. err:
  215. dprintk("RPC: gss_fill_context returning %ld\n", -PTR_ERR(p));
  216. return p;
  217. }
  218. struct gss_upcall_msg {
  219. atomic_t count;
  220. uid_t uid;
  221. struct rpc_pipe_msg msg;
  222. struct list_head list;
  223. struct gss_auth *auth;
  224. struct rpc_wait_queue rpc_waitqueue;
  225. wait_queue_head_t waitqueue;
  226. struct gss_cl_ctx *ctx;
  227. };
  228. static void
  229. gss_release_msg(struct gss_upcall_msg *gss_msg)
  230. {
  231. if (!atomic_dec_and_test(&gss_msg->count))
  232. return;
  233. BUG_ON(!list_empty(&gss_msg->list));
  234. if (gss_msg->ctx != NULL)
  235. gss_put_ctx(gss_msg->ctx);
  236. kfree(gss_msg);
  237. }
  238. static struct gss_upcall_msg *
  239. __gss_find_upcall(struct rpc_inode *rpci, uid_t uid)
  240. {
  241. struct gss_upcall_msg *pos;
  242. list_for_each_entry(pos, &rpci->in_downcall, list) {
  243. if (pos->uid != uid)
  244. continue;
  245. atomic_inc(&pos->count);
  246. dprintk("RPC: gss_find_upcall found msg %p\n", pos);
  247. return pos;
  248. }
  249. dprintk("RPC: gss_find_upcall found nothing\n");
  250. return NULL;
  251. }
  252. /* Try to add a upcall to the pipefs queue.
  253. * If an upcall owned by our uid already exists, then we return a reference
  254. * to that upcall instead of adding the new upcall.
  255. */
  256. static inline struct gss_upcall_msg *
  257. gss_add_msg(struct gss_auth *gss_auth, struct gss_upcall_msg *gss_msg)
  258. {
  259. struct inode *inode = gss_auth->dentry->d_inode;
  260. struct rpc_inode *rpci = RPC_I(inode);
  261. struct gss_upcall_msg *old;
  262. spin_lock(&inode->i_lock);
  263. old = __gss_find_upcall(rpci, gss_msg->uid);
  264. if (old == NULL) {
  265. atomic_inc(&gss_msg->count);
  266. list_add(&gss_msg->list, &rpci->in_downcall);
  267. } else
  268. gss_msg = old;
  269. spin_unlock(&inode->i_lock);
  270. return gss_msg;
  271. }
  272. static void
  273. __gss_unhash_msg(struct gss_upcall_msg *gss_msg)
  274. {
  275. list_del_init(&gss_msg->list);
  276. rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
  277. wake_up_all(&gss_msg->waitqueue);
  278. atomic_dec(&gss_msg->count);
  279. }
  280. static void
  281. gss_unhash_msg(struct gss_upcall_msg *gss_msg)
  282. {
  283. struct gss_auth *gss_auth = gss_msg->auth;
  284. struct inode *inode = gss_auth->dentry->d_inode;
  285. if (list_empty(&gss_msg->list))
  286. return;
  287. spin_lock(&inode->i_lock);
  288. if (!list_empty(&gss_msg->list))
  289. __gss_unhash_msg(gss_msg);
  290. spin_unlock(&inode->i_lock);
  291. }
  292. static void
  293. gss_upcall_callback(struct rpc_task *task)
  294. {
  295. struct gss_cred *gss_cred = container_of(task->tk_msg.rpc_cred,
  296. struct gss_cred, gc_base);
  297. struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;
  298. struct inode *inode = gss_msg->auth->dentry->d_inode;
  299. if (gss_msg->ctx)
  300. gss_cred_set_ctx(task->tk_msg.rpc_cred, gss_get_ctx(gss_msg->ctx));
  301. else
  302. task->tk_status = gss_msg->msg.errno;
  303. spin_lock(&inode->i_lock);
  304. gss_cred->gc_upcall = NULL;
  305. rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
  306. spin_unlock(&inode->i_lock);
  307. gss_release_msg(gss_msg);
  308. }
  309. static inline struct gss_upcall_msg *
  310. gss_alloc_msg(struct gss_auth *gss_auth, uid_t uid)
  311. {
  312. struct gss_upcall_msg *gss_msg;
  313. gss_msg = kzalloc(sizeof(*gss_msg), GFP_KERNEL);
  314. if (gss_msg != NULL) {
  315. INIT_LIST_HEAD(&gss_msg->list);
  316. rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
  317. init_waitqueue_head(&gss_msg->waitqueue);
  318. atomic_set(&gss_msg->count, 1);
  319. gss_msg->msg.data = &gss_msg->uid;
  320. gss_msg->msg.len = sizeof(gss_msg->uid);
  321. gss_msg->uid = uid;
  322. gss_msg->auth = gss_auth;
  323. }
  324. return gss_msg;
  325. }
  326. static struct gss_upcall_msg *
  327. gss_setup_upcall(struct rpc_clnt *clnt, struct gss_auth *gss_auth, struct rpc_cred *cred)
  328. {
  329. struct gss_upcall_msg *gss_new, *gss_msg;
  330. gss_new = gss_alloc_msg(gss_auth, cred->cr_uid);
  331. if (gss_new == NULL)
  332. return ERR_PTR(-ENOMEM);
  333. gss_msg = gss_add_msg(gss_auth, gss_new);
  334. if (gss_msg == gss_new) {
  335. int res = rpc_queue_upcall(gss_auth->dentry->d_inode, &gss_new->msg);
  336. if (res) {
  337. gss_unhash_msg(gss_new);
  338. gss_msg = ERR_PTR(res);
  339. }
  340. } else
  341. gss_release_msg(gss_new);
  342. return gss_msg;
  343. }
  344. static inline int
  345. gss_refresh_upcall(struct rpc_task *task)
  346. {
  347. struct rpc_cred *cred = task->tk_msg.rpc_cred;
  348. struct gss_auth *gss_auth = container_of(cred->cr_auth,
  349. struct gss_auth, rpc_auth);
  350. struct gss_cred *gss_cred = container_of(cred,
  351. struct gss_cred, gc_base);
  352. struct gss_upcall_msg *gss_msg;
  353. struct inode *inode = gss_auth->dentry->d_inode;
  354. int err = 0;
  355. dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,
  356. cred->cr_uid);
  357. gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred);
  358. if (IS_ERR(gss_msg)) {
  359. err = PTR_ERR(gss_msg);
  360. goto out;
  361. }
  362. spin_lock(&inode->i_lock);
  363. if (gss_cred->gc_upcall != NULL)
  364. rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL, NULL);
  365. else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {
  366. task->tk_timeout = 0;
  367. gss_cred->gc_upcall = gss_msg;
  368. /* gss_upcall_callback will release the reference to gss_upcall_msg */
  369. atomic_inc(&gss_msg->count);
  370. rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback, NULL);
  371. } else
  372. err = gss_msg->msg.errno;
  373. spin_unlock(&inode->i_lock);
  374. gss_release_msg(gss_msg);
  375. out:
  376. dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",
  377. task->tk_pid, cred->cr_uid, err);
  378. return err;
  379. }
  380. static inline int
  381. gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
  382. {
  383. struct inode *inode = gss_auth->dentry->d_inode;
  384. struct rpc_cred *cred = &gss_cred->gc_base;
  385. struct gss_upcall_msg *gss_msg;
  386. DEFINE_WAIT(wait);
  387. int err = 0;
  388. dprintk("RPC: gss_upcall for uid %u\n", cred->cr_uid);
  389. gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);
  390. if (IS_ERR(gss_msg)) {
  391. err = PTR_ERR(gss_msg);
  392. goto out;
  393. }
  394. for (;;) {
  395. prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_INTERRUPTIBLE);
  396. spin_lock(&inode->i_lock);
  397. if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {
  398. spin_unlock(&inode->i_lock);
  399. break;
  400. }
  401. spin_unlock(&inode->i_lock);
  402. if (signalled()) {
  403. err = -ERESTARTSYS;
  404. goto out_intr;
  405. }
  406. schedule();
  407. }
  408. if (gss_msg->ctx)
  409. gss_cred_set_ctx(cred, gss_get_ctx(gss_msg->ctx));
  410. else
  411. err = gss_msg->msg.errno;
  412. out_intr:
  413. finish_wait(&gss_msg->waitqueue, &wait);
  414. gss_release_msg(gss_msg);
  415. out:
  416. dprintk("RPC: gss_create_upcall for uid %u result %d\n",
  417. cred->cr_uid, err);
  418. return err;
  419. }
  420. static ssize_t
  421. gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
  422. char __user *dst, size_t buflen)
  423. {
  424. char *data = (char *)msg->data + msg->copied;
  425. ssize_t mlen = msg->len;
  426. ssize_t left;
  427. if (mlen > buflen)
  428. mlen = buflen;
  429. left = copy_to_user(dst, data, mlen);
  430. if (left < 0) {
  431. msg->errno = left;
  432. return left;
  433. }
  434. mlen -= left;
  435. msg->copied += mlen;
  436. msg->errno = 0;
  437. return mlen;
  438. }
  439. #define MSG_BUF_MAXSIZE 1024
  440. static ssize_t
  441. gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
  442. {
  443. const void *p, *end;
  444. void *buf;
  445. struct rpc_clnt *clnt;
  446. struct gss_upcall_msg *gss_msg;
  447. struct inode *inode = filp->f_path.dentry->d_inode;
  448. struct gss_cl_ctx *ctx;
  449. uid_t uid;
  450. ssize_t err = -EFBIG;
  451. if (mlen > MSG_BUF_MAXSIZE)
  452. goto out;
  453. err = -ENOMEM;
  454. buf = kmalloc(mlen, GFP_KERNEL);
  455. if (!buf)
  456. goto out;
  457. clnt = RPC_I(inode)->private;
  458. err = -EFAULT;
  459. if (copy_from_user(buf, src, mlen))
  460. goto err;
  461. end = (const void *)((char *)buf + mlen);
  462. p = simple_get_bytes(buf, end, &uid, sizeof(uid));
  463. if (IS_ERR(p)) {
  464. err = PTR_ERR(p);
  465. goto err;
  466. }
  467. err = -ENOMEM;
  468. ctx = gss_alloc_context();
  469. if (ctx == NULL)
  470. goto err;
  471. err = -ENOENT;
  472. /* Find a matching upcall */
  473. spin_lock(&inode->i_lock);
  474. gss_msg = __gss_find_upcall(RPC_I(inode), uid);
  475. if (gss_msg == NULL) {
  476. spin_unlock(&inode->i_lock);
  477. goto err_put_ctx;
  478. }
  479. list_del_init(&gss_msg->list);
  480. spin_unlock(&inode->i_lock);
  481. p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
  482. if (IS_ERR(p)) {
  483. err = PTR_ERR(p);
  484. gss_msg->msg.errno = (err == -EACCES) ? -EACCES : -EAGAIN;
  485. goto err_release_msg;
  486. }
  487. gss_msg->ctx = gss_get_ctx(ctx);
  488. err = mlen;
  489. err_release_msg:
  490. spin_lock(&inode->i_lock);
  491. __gss_unhash_msg(gss_msg);
  492. spin_unlock(&inode->i_lock);
  493. gss_release_msg(gss_msg);
  494. err_put_ctx:
  495. gss_put_ctx(ctx);
  496. err:
  497. kfree(buf);
  498. out:
  499. dprintk("RPC: gss_pipe_downcall returning %Zd\n", err);
  500. return err;
  501. }
  502. static void
  503. gss_pipe_release(struct inode *inode)
  504. {
  505. struct rpc_inode *rpci = RPC_I(inode);
  506. struct gss_upcall_msg *gss_msg;
  507. spin_lock(&inode->i_lock);
  508. while (!list_empty(&rpci->in_downcall)) {
  509. gss_msg = list_entry(rpci->in_downcall.next,
  510. struct gss_upcall_msg, list);
  511. gss_msg->msg.errno = -EPIPE;
  512. atomic_inc(&gss_msg->count);
  513. __gss_unhash_msg(gss_msg);
  514. spin_unlock(&inode->i_lock);
  515. gss_release_msg(gss_msg);
  516. spin_lock(&inode->i_lock);
  517. }
  518. spin_unlock(&inode->i_lock);
  519. }
  520. static void
  521. gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
  522. {
  523. struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);
  524. static unsigned long ratelimit;
  525. if (msg->errno < 0) {
  526. dprintk("RPC: gss_pipe_destroy_msg releasing msg %p\n",
  527. gss_msg);
  528. atomic_inc(&gss_msg->count);
  529. gss_unhash_msg(gss_msg);
  530. if (msg->errno == -ETIMEDOUT) {
  531. unsigned long now = jiffies;
  532. if (time_after(now, ratelimit)) {
  533. printk(KERN_WARNING "RPC: AUTH_GSS upcall timed out.\n"
  534. "Please check user daemon is running!\n");
  535. ratelimit = now + 15*HZ;
  536. }
  537. }
  538. gss_release_msg(gss_msg);
  539. }
  540. }
  541. /*
  542. * NOTE: we have the opportunity to use different
  543. * parameters based on the input flavor (which must be a pseudoflavor)
  544. */
  545. static struct rpc_auth *
  546. gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
  547. {
  548. struct gss_auth *gss_auth;
  549. struct rpc_auth * auth;
  550. int err = -ENOMEM; /* XXX? */
  551. dprintk("RPC: creating GSS authenticator for client %p\n", clnt);
  552. if (!try_module_get(THIS_MODULE))
  553. return ERR_PTR(err);
  554. if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
  555. goto out_dec;
  556. gss_auth->client = clnt;
  557. err = -EINVAL;
  558. gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);
  559. if (!gss_auth->mech) {
  560. printk(KERN_WARNING "%s: Pseudoflavor %d not found!",
  561. __FUNCTION__, flavor);
  562. goto err_free;
  563. }
  564. gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);
  565. if (gss_auth->service == 0)
  566. goto err_put_mech;
  567. auth = &gss_auth->rpc_auth;
  568. auth->au_cslack = GSS_CRED_SLACK >> 2;
  569. auth->au_rslack = GSS_VERF_SLACK >> 2;
  570. auth->au_ops = &authgss_ops;
  571. auth->au_flavor = flavor;
  572. atomic_set(&auth->au_count, 1);
  573. gss_auth->dentry = rpc_mkpipe(clnt->cl_dentry, gss_auth->mech->gm_name,
  574. clnt, &gss_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
  575. if (IS_ERR(gss_auth->dentry)) {
  576. err = PTR_ERR(gss_auth->dentry);
  577. goto err_put_mech;
  578. }
  579. err = rpcauth_init_credcache(auth, GSS_CRED_EXPIRE);
  580. if (err)
  581. goto err_unlink_pipe;
  582. return auth;
  583. err_unlink_pipe:
  584. rpc_unlink(gss_auth->dentry);
  585. err_put_mech:
  586. gss_mech_put(gss_auth->mech);
  587. err_free:
  588. kfree(gss_auth);
  589. out_dec:
  590. module_put(THIS_MODULE);
  591. return ERR_PTR(err);
  592. }
  593. static void
  594. gss_destroy(struct rpc_auth *auth)
  595. {
  596. struct gss_auth *gss_auth;
  597. dprintk("RPC: destroying GSS authenticator %p flavor %d\n",
  598. auth, auth->au_flavor);
  599. rpcauth_destroy_credcache(auth);
  600. gss_auth = container_of(auth, struct gss_auth, rpc_auth);
  601. rpc_unlink(gss_auth->dentry);
  602. gss_auth->dentry = NULL;
  603. gss_mech_put(gss_auth->mech);
  604. kfree(gss_auth);
  605. module_put(THIS_MODULE);
  606. }
  607. /* gss_destroy_cred (and gss_destroy_ctx) are used to clean up after failure
  608. * to create a new cred or context, so they check that things have been
  609. * allocated before freeing them. */
  610. static void
  611. gss_destroy_ctx(struct gss_cl_ctx *ctx)
  612. {
  613. dprintk("RPC: gss_destroy_ctx\n");
  614. if (ctx->gc_gss_ctx)
  615. gss_delete_sec_context(&ctx->gc_gss_ctx);
  616. kfree(ctx->gc_wire_ctx.data);
  617. kfree(ctx);
  618. }
  619. static void
  620. gss_destroy_cred(struct rpc_cred *rc)
  621. {
  622. struct gss_cred *cred = container_of(rc, struct gss_cred, gc_base);
  623. dprintk("RPC: gss_destroy_cred \n");
  624. if (cred->gc_ctx)
  625. gss_put_ctx(cred->gc_ctx);
  626. kfree(cred);
  627. }
  628. /*
  629. * Lookup RPCSEC_GSS cred for the current process
  630. */
  631. static struct rpc_cred *
  632. gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
  633. {
  634. return rpcauth_lookup_credcache(auth, acred, flags);
  635. }
  636. static struct rpc_cred *
  637. gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
  638. {
  639. struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
  640. struct gss_cred *cred = NULL;
  641. int err = -ENOMEM;
  642. dprintk("RPC: gss_create_cred for uid %d, flavor %d\n",
  643. acred->uid, auth->au_flavor);
  644. if (!(cred = kzalloc(sizeof(*cred), GFP_KERNEL)))
  645. goto out_err;
  646. atomic_set(&cred->gc_count, 1);
  647. cred->gc_uid = acred->uid;
  648. /*
  649. * Note: in order to force a call to call_refresh(), we deliberately
  650. * fail to flag the credential as RPCAUTH_CRED_UPTODATE.
  651. */
  652. cred->gc_flags = 0;
  653. cred->gc_base.cr_auth = auth;
  654. cred->gc_base.cr_ops = &gss_credops;
  655. cred->gc_base.cr_flags = RPCAUTH_CRED_NEW;
  656. cred->gc_service = gss_auth->service;
  657. return &cred->gc_base;
  658. out_err:
  659. dprintk("RPC: gss_create_cred failed with error %d\n", err);
  660. return ERR_PTR(err);
  661. }
  662. static int
  663. gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred)
  664. {
  665. struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
  666. struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base);
  667. int err;
  668. do {
  669. err = gss_create_upcall(gss_auth, gss_cred);
  670. } while (err == -EAGAIN);
  671. return err;
  672. }
  673. static int
  674. gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags)
  675. {
  676. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
  677. /*
  678. * If the searchflags have set RPCAUTH_LOOKUP_NEW, then
  679. * we don't really care if the credential has expired or not,
  680. * since the caller should be prepared to reinitialise it.
  681. */
  682. if ((flags & RPCAUTH_LOOKUP_NEW) && (rc->cr_flags & RPCAUTH_CRED_NEW))
  683. goto out;
  684. /* Don't match with creds that have expired. */
  685. if (gss_cred->gc_ctx && time_after(jiffies, gss_cred->gc_ctx->gc_expiry))
  686. return 0;
  687. out:
  688. return (rc->cr_uid == acred->uid);
  689. }
  690. /*
  691. * Marshal credentials.
  692. * Maybe we should keep a cached credential for performance reasons.
  693. */
  694. static __be32 *
  695. gss_marshal(struct rpc_task *task, __be32 *p)
  696. {
  697. struct rpc_cred *cred = task->tk_msg.rpc_cred;
  698. struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
  699. gc_base);
  700. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
  701. __be32 *cred_len;
  702. struct rpc_rqst *req = task->tk_rqstp;
  703. u32 maj_stat = 0;
  704. struct xdr_netobj mic;
  705. struct kvec iov;
  706. struct xdr_buf verf_buf;
  707. dprintk("RPC: %5u gss_marshal\n", task->tk_pid);
  708. *p++ = htonl(RPC_AUTH_GSS);
  709. cred_len = p++;
  710. spin_lock(&ctx->gc_seq_lock);
  711. req->rq_seqno = ctx->gc_seq++;
  712. spin_unlock(&ctx->gc_seq_lock);
  713. *p++ = htonl((u32) RPC_GSS_VERSION);
  714. *p++ = htonl((u32) ctx->gc_proc);
  715. *p++ = htonl((u32) req->rq_seqno);
  716. *p++ = htonl((u32) gss_cred->gc_service);
  717. p = xdr_encode_netobj(p, &ctx->gc_wire_ctx);
  718. *cred_len = htonl((p - (cred_len + 1)) << 2);
  719. /* We compute the checksum for the verifier over the xdr-encoded bytes
  720. * starting with the xid and ending at the end of the credential: */
  721. iov.iov_base = xprt_skip_transport_header(task->tk_xprt,
  722. req->rq_snd_buf.head[0].iov_base);
  723. iov.iov_len = (u8 *)p - (u8 *)iov.iov_base;
  724. xdr_buf_from_iov(&iov, &verf_buf);
  725. /* set verifier flavor*/
  726. *p++ = htonl(RPC_AUTH_GSS);
  727. mic.data = (u8 *)(p + 1);
  728. maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
  729. if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
  730. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  731. } else if (maj_stat != 0) {
  732. printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);
  733. goto out_put_ctx;
  734. }
  735. p = xdr_encode_opaque(p, NULL, mic.len);
  736. gss_put_ctx(ctx);
  737. return p;
  738. out_put_ctx:
  739. gss_put_ctx(ctx);
  740. return NULL;
  741. }
  742. /*
  743. * Refresh credentials. XXX - finish
  744. */
  745. static int
  746. gss_refresh(struct rpc_task *task)
  747. {
  748. if (!gss_cred_is_uptodate_ctx(task->tk_msg.rpc_cred))
  749. return gss_refresh_upcall(task);
  750. return 0;
  751. }
  752. static __be32 *
  753. gss_validate(struct rpc_task *task, __be32 *p)
  754. {
  755. struct rpc_cred *cred = task->tk_msg.rpc_cred;
  756. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
  757. __be32 seq;
  758. struct kvec iov;
  759. struct xdr_buf verf_buf;
  760. struct xdr_netobj mic;
  761. u32 flav,len;
  762. u32 maj_stat;
  763. dprintk("RPC: %5u gss_validate\n", task->tk_pid);
  764. flav = ntohl(*p++);
  765. if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
  766. goto out_bad;
  767. if (flav != RPC_AUTH_GSS)
  768. goto out_bad;
  769. seq = htonl(task->tk_rqstp->rq_seqno);
  770. iov.iov_base = &seq;
  771. iov.iov_len = sizeof(seq);
  772. xdr_buf_from_iov(&iov, &verf_buf);
  773. mic.data = (u8 *)p;
  774. mic.len = len;
  775. maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
  776. if (maj_stat == GSS_S_CONTEXT_EXPIRED)
  777. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  778. if (maj_stat)
  779. goto out_bad;
  780. /* We leave it to unwrap to calculate au_rslack. For now we just
  781. * calculate the length of the verifier: */
  782. task->tk_auth->au_verfsize = XDR_QUADLEN(len) + 2;
  783. gss_put_ctx(ctx);
  784. dprintk("RPC: %5u gss_validate: gss_verify_mic succeeded.\n",
  785. task->tk_pid);
  786. return p + XDR_QUADLEN(len);
  787. out_bad:
  788. gss_put_ctx(ctx);
  789. dprintk("RPC: %5u gss_validate failed.\n", task->tk_pid);
  790. return NULL;
  791. }
  792. static inline int
  793. gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
  794. kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
  795. {
  796. struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
  797. struct xdr_buf integ_buf;
  798. __be32 *integ_len = NULL;
  799. struct xdr_netobj mic;
  800. u32 offset;
  801. __be32 *q;
  802. struct kvec *iov;
  803. u32 maj_stat = 0;
  804. int status = -EIO;
  805. integ_len = p++;
  806. offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
  807. *p++ = htonl(rqstp->rq_seqno);
  808. status = encode(rqstp, p, obj);
  809. if (status)
  810. return status;
  811. if (xdr_buf_subsegment(snd_buf, &integ_buf,
  812. offset, snd_buf->len - offset))
  813. return status;
  814. *integ_len = htonl(integ_buf.len);
  815. /* guess whether we're in the head or the tail: */
  816. if (snd_buf->page_len || snd_buf->tail[0].iov_len)
  817. iov = snd_buf->tail;
  818. else
  819. iov = snd_buf->head;
  820. p = iov->iov_base + iov->iov_len;
  821. mic.data = (u8 *)(p + 1);
  822. maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
  823. status = -EIO; /* XXX? */
  824. if (maj_stat == GSS_S_CONTEXT_EXPIRED)
  825. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  826. else if (maj_stat)
  827. return status;
  828. q = xdr_encode_opaque(p, NULL, mic.len);
  829. offset = (u8 *)q - (u8 *)p;
  830. iov->iov_len += offset;
  831. snd_buf->len += offset;
  832. return 0;
  833. }
  834. static void
  835. priv_release_snd_buf(struct rpc_rqst *rqstp)
  836. {
  837. int i;
  838. for (i=0; i < rqstp->rq_enc_pages_num; i++)
  839. __free_page(rqstp->rq_enc_pages[i]);
  840. kfree(rqstp->rq_enc_pages);
  841. }
  842. static int
  843. alloc_enc_pages(struct rpc_rqst *rqstp)
  844. {
  845. struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
  846. int first, last, i;
  847. if (snd_buf->page_len == 0) {
  848. rqstp->rq_enc_pages_num = 0;
  849. return 0;
  850. }
  851. first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
  852. last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_CACHE_SHIFT;
  853. rqstp->rq_enc_pages_num = last - first + 1 + 1;
  854. rqstp->rq_enc_pages
  855. = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *),
  856. GFP_NOFS);
  857. if (!rqstp->rq_enc_pages)
  858. goto out;
  859. for (i=0; i < rqstp->rq_enc_pages_num; i++) {
  860. rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS);
  861. if (rqstp->rq_enc_pages[i] == NULL)
  862. goto out_free;
  863. }
  864. rqstp->rq_release_snd_buf = priv_release_snd_buf;
  865. return 0;
  866. out_free:
  867. for (i--; i >= 0; i--) {
  868. __free_page(rqstp->rq_enc_pages[i]);
  869. }
  870. out:
  871. return -EAGAIN;
  872. }
  873. static inline int
  874. gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
  875. kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
  876. {
  877. struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
  878. u32 offset;
  879. u32 maj_stat;
  880. int status;
  881. __be32 *opaque_len;
  882. struct page **inpages;
  883. int first;
  884. int pad;
  885. struct kvec *iov;
  886. char *tmp;
  887. opaque_len = p++;
  888. offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
  889. *p++ = htonl(rqstp->rq_seqno);
  890. status = encode(rqstp, p, obj);
  891. if (status)
  892. return status;
  893. status = alloc_enc_pages(rqstp);
  894. if (status)
  895. return status;
  896. first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
  897. inpages = snd_buf->pages + first;
  898. snd_buf->pages = rqstp->rq_enc_pages;
  899. snd_buf->page_base -= first << PAGE_CACHE_SHIFT;
  900. /* Give the tail its own page, in case we need extra space in the
  901. * head when wrapping: */
  902. if (snd_buf->page_len || snd_buf->tail[0].iov_len) {
  903. tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]);
  904. memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len);
  905. snd_buf->tail[0].iov_base = tmp;
  906. }
  907. maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages);
  908. /* RPC_SLACK_SPACE should prevent this ever happening: */
  909. BUG_ON(snd_buf->len > snd_buf->buflen);
  910. status = -EIO;
  911. /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was
  912. * done anyway, so it's safe to put the request on the wire: */
  913. if (maj_stat == GSS_S_CONTEXT_EXPIRED)
  914. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  915. else if (maj_stat)
  916. return status;
  917. *opaque_len = htonl(snd_buf->len - offset);
  918. /* guess whether we're in the head or the tail: */
  919. if (snd_buf->page_len || snd_buf->tail[0].iov_len)
  920. iov = snd_buf->tail;
  921. else
  922. iov = snd_buf->head;
  923. p = iov->iov_base + iov->iov_len;
  924. pad = 3 - ((snd_buf->len - offset - 1) & 3);
  925. memset(p, 0, pad);
  926. iov->iov_len += pad;
  927. snd_buf->len += pad;
  928. return 0;
  929. }
  930. static int
  931. gss_wrap_req(struct rpc_task *task,
  932. kxdrproc_t encode, void *rqstp, __be32 *p, void *obj)
  933. {
  934. struct rpc_cred *cred = task->tk_msg.rpc_cred;
  935. struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
  936. gc_base);
  937. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
  938. int status = -EIO;
  939. dprintk("RPC: %5u gss_wrap_req\n", task->tk_pid);
  940. if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
  941. /* The spec seems a little ambiguous here, but I think that not
  942. * wrapping context destruction requests makes the most sense.
  943. */
  944. status = encode(rqstp, p, obj);
  945. goto out;
  946. }
  947. switch (gss_cred->gc_service) {
  948. case RPC_GSS_SVC_NONE:
  949. status = encode(rqstp, p, obj);
  950. break;
  951. case RPC_GSS_SVC_INTEGRITY:
  952. status = gss_wrap_req_integ(cred, ctx, encode,
  953. rqstp, p, obj);
  954. break;
  955. case RPC_GSS_SVC_PRIVACY:
  956. status = gss_wrap_req_priv(cred, ctx, encode,
  957. rqstp, p, obj);
  958. break;
  959. }
  960. out:
  961. gss_put_ctx(ctx);
  962. dprintk("RPC: %5u gss_wrap_req returning %d\n", task->tk_pid, status);
  963. return status;
  964. }
  965. static inline int
  966. gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
  967. struct rpc_rqst *rqstp, __be32 **p)
  968. {
  969. struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
  970. struct xdr_buf integ_buf;
  971. struct xdr_netobj mic;
  972. u32 data_offset, mic_offset;
  973. u32 integ_len;
  974. u32 maj_stat;
  975. int status = -EIO;
  976. integ_len = ntohl(*(*p)++);
  977. if (integ_len & 3)
  978. return status;
  979. data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
  980. mic_offset = integ_len + data_offset;
  981. if (mic_offset > rcv_buf->len)
  982. return status;
  983. if (ntohl(*(*p)++) != rqstp->rq_seqno)
  984. return status;
  985. if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset,
  986. mic_offset - data_offset))
  987. return status;
  988. if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset))
  989. return status;
  990. maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
  991. if (maj_stat == GSS_S_CONTEXT_EXPIRED)
  992. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  993. if (maj_stat != GSS_S_COMPLETE)
  994. return status;
  995. return 0;
  996. }
  997. static inline int
  998. gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
  999. struct rpc_rqst *rqstp, __be32 **p)
  1000. {
  1001. struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
  1002. u32 offset;
  1003. u32 opaque_len;
  1004. u32 maj_stat;
  1005. int status = -EIO;
  1006. opaque_len = ntohl(*(*p)++);
  1007. offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
  1008. if (offset + opaque_len > rcv_buf->len)
  1009. return status;
  1010. /* remove padding: */
  1011. rcv_buf->len = offset + opaque_len;
  1012. maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);
  1013. if (maj_stat == GSS_S_CONTEXT_EXPIRED)
  1014. cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
  1015. if (maj_stat != GSS_S_COMPLETE)
  1016. return status;
  1017. if (ntohl(*(*p)++) != rqstp->rq_seqno)
  1018. return status;
  1019. return 0;
  1020. }
  1021. static int
  1022. gss_unwrap_resp(struct rpc_task *task,
  1023. kxdrproc_t decode, void *rqstp, __be32 *p, void *obj)
  1024. {
  1025. struct rpc_cred *cred = task->tk_msg.rpc_cred;
  1026. struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
  1027. gc_base);
  1028. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
  1029. __be32 *savedp = p;
  1030. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;
  1031. int savedlen = head->iov_len;
  1032. int status = -EIO;
  1033. if (ctx->gc_proc != RPC_GSS_PROC_DATA)
  1034. goto out_decode;
  1035. switch (gss_cred->gc_service) {
  1036. case RPC_GSS_SVC_NONE:
  1037. break;
  1038. case RPC_GSS_SVC_INTEGRITY:
  1039. status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p);
  1040. if (status)
  1041. goto out;
  1042. break;
  1043. case RPC_GSS_SVC_PRIVACY:
  1044. status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p);
  1045. if (status)
  1046. goto out;
  1047. break;
  1048. }
  1049. /* take into account extra slack for integrity and privacy cases: */
  1050. task->tk_auth->au_rslack = task->tk_auth->au_verfsize + (p - savedp)
  1051. + (savedlen - head->iov_len);
  1052. out_decode:
  1053. status = decode(rqstp, p, obj);
  1054. out:
  1055. gss_put_ctx(ctx);
  1056. dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid,
  1057. status);
  1058. return status;
  1059. }
  1060. static struct rpc_authops authgss_ops = {
  1061. .owner = THIS_MODULE,
  1062. .au_flavor = RPC_AUTH_GSS,
  1063. #ifdef RPC_DEBUG
  1064. .au_name = "RPCSEC_GSS",
  1065. #endif
  1066. .create = gss_create,
  1067. .destroy = gss_destroy,
  1068. .lookup_cred = gss_lookup_cred,
  1069. .crcreate = gss_create_cred
  1070. };
  1071. static struct rpc_credops gss_credops = {
  1072. .cr_name = "AUTH_GSS",
  1073. .crdestroy = gss_destroy_cred,
  1074. .cr_init = gss_cred_init,
  1075. .crmatch = gss_match,
  1076. .crmarshal = gss_marshal,
  1077. .crrefresh = gss_refresh,
  1078. .crvalidate = gss_validate,
  1079. .crwrap_req = gss_wrap_req,
  1080. .crunwrap_resp = gss_unwrap_resp,
  1081. };
  1082. static struct rpc_pipe_ops gss_upcall_ops = {
  1083. .upcall = gss_pipe_upcall,
  1084. .downcall = gss_pipe_downcall,
  1085. .destroy_msg = gss_pipe_destroy_msg,
  1086. .release_pipe = gss_pipe_release,
  1087. };
  1088. /*
  1089. * Initialize RPCSEC_GSS module
  1090. */
  1091. static int __init init_rpcsec_gss(void)
  1092. {
  1093. int err = 0;
  1094. err = rpcauth_register(&authgss_ops);
  1095. if (err)
  1096. goto out;
  1097. err = gss_svc_init();
  1098. if (err)
  1099. goto out_unregister;
  1100. return 0;
  1101. out_unregister:
  1102. rpcauth_unregister(&authgss_ops);
  1103. out:
  1104. return err;
  1105. }
  1106. static void __exit exit_rpcsec_gss(void)
  1107. {
  1108. gss_svc_shutdown();
  1109. rpcauth_unregister(&authgss_ops);
  1110. }
  1111. MODULE_LICENSE("GPL");
  1112. module_init(init_rpcsec_gss)
  1113. module_exit(exit_rpcsec_gss)