Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
svcauth_gss.c
Go to the documentation of this file.
1 /*
2  * Neil Brown <[email protected]>
3  * J. Bruce Fields <[email protected]>
4  * Andy Adamson <[email protected]>
5  * Dug Song <[email protected]>
6  *
7  * RPCSEC_GSS server authentication.
8  * This implements RPCSEC_GSS as defined in rfc2203 (rpcsec_gss) and rfc2078
9  * (gssapi)
10  *
11  * The RPCSEC_GSS involves three stages:
12  * 1/ context creation
13  * 2/ data exchange
14  * 3/ context destruction
15  *
16  * Context creation is handled largely by upcalls to user-space.
17  * In particular, GSS_Accept_sec_context is handled by an upcall
18  * Data exchange is handled entirely within the kernel
19  * In particular, GSS_GetMIC, GSS_VerifyMIC, GSS_Seal, GSS_Unseal are in-kernel.
20  * Context destruction is handled in-kernel
21  * GSS_Delete_sec_context is in-kernel
22  *
23  * Context creation is initiated by a RPCSEC_GSS_INIT request arriving.
24  * The context handle and gss_token are used as a key into the rpcsec_init cache.
25  * The content of this cache includes some of the outputs of GSS_Accept_sec_context,
26  * being major_status, minor_status, context_handle, reply_token.
27  * These are sent back to the client.
28  * Sequence window management is handled by the kernel. The window size if currently
29  * a compile time constant.
30  *
31  * When user-space is happy that a context is established, it places an entry
32  * in the rpcsec_context cache. The key for this cache is the context_handle.
33  * The content includes:
34  * uid/gidlist - for determining access rights
35  * mechanism type
36  * mechanism specific information, such as a key
37  *
38  */
39 
40 #include <linux/slab.h>
41 #include <linux/types.h>
42 #include <linux/module.h>
43 #include <linux/pagemap.h>
44 #include <linux/user_namespace.h>
45 
46 #include <linux/sunrpc/auth_gss.h>
47 #include <linux/sunrpc/gss_err.h>
48 #include <linux/sunrpc/svcauth.h>
50 #include <linux/sunrpc/cache.h>
51 
52 #include "../netns.h"
53 
54 #ifdef RPC_DEBUG
55 # define RPCDBG_FACILITY RPCDBG_AUTH
56 #endif
57 
58 /* The rpcsec_init cache is used for mapping RPCSEC_GSS_{,CONT_}INIT requests
59  * into replies.
60  *
61  * Key is context handle (\x if empty) and gss_token.
62  * Content is major_status minor_status (integers) context_handle, reply_token.
63  *
64  */
65 
66 static int netobj_equal(struct xdr_netobj *a, struct xdr_netobj *b)
67 {
68  return a->len == b->len && 0 == memcmp(a->data, b->data, a->len);
69 }
70 
71 #define RSI_HASHBITS 6
72 #define RSI_HASHMAX (1<<RSI_HASHBITS)
73 
74 struct rsi {
75  struct cache_head h;
76  struct xdr_netobj in_handle, in_token;
77  struct xdr_netobj out_handle, out_token;
79 };
80 
81 static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old);
82 static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item);
83 
84 static void rsi_free(struct rsi *rsii)
85 {
86  kfree(rsii->in_handle.data);
87  kfree(rsii->in_token.data);
88  kfree(rsii->out_handle.data);
89  kfree(rsii->out_token.data);
90 }
91 
92 static void rsi_put(struct kref *ref)
93 {
94  struct rsi *rsii = container_of(ref, struct rsi, h.ref);
95  rsi_free(rsii);
96  kfree(rsii);
97 }
98 
99 static inline int rsi_hash(struct rsi *item)
100 {
101  return hash_mem(item->in_handle.data, item->in_handle.len, RSI_HASHBITS)
102  ^ hash_mem(item->in_token.data, item->in_token.len, RSI_HASHBITS);
103 }
104 
105 static int rsi_match(struct cache_head *a, struct cache_head *b)
106 {
107  struct rsi *item = container_of(a, struct rsi, h);
108  struct rsi *tmp = container_of(b, struct rsi, h);
109  return netobj_equal(&item->in_handle, &tmp->in_handle) &&
110  netobj_equal(&item->in_token, &tmp->in_token);
111 }
112 
113 static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len)
114 {
115  dst->len = len;
116  dst->data = (len ? kmemdup(src, len, GFP_KERNEL) : NULL);
117  if (len && !dst->data)
118  return -ENOMEM;
119  return 0;
120 }
121 
122 static inline int dup_netobj(struct xdr_netobj *dst, struct xdr_netobj *src)
123 {
124  return dup_to_netobj(dst, src->data, src->len);
125 }
126 
127 static void rsi_init(struct cache_head *cnew, struct cache_head *citem)
128 {
129  struct rsi *new = container_of(cnew, struct rsi, h);
130  struct rsi *item = container_of(citem, struct rsi, h);
131 
132  new->out_handle.data = NULL;
133  new->out_handle.len = 0;
134  new->out_token.data = NULL;
135  new->out_token.len = 0;
136  new->in_handle.len = item->in_handle.len;
137  item->in_handle.len = 0;
138  new->in_token.len = item->in_token.len;
139  item->in_token.len = 0;
140  new->in_handle.data = item->in_handle.data;
141  item->in_handle.data = NULL;
142  new->in_token.data = item->in_token.data;
143  item->in_token.data = NULL;
144 }
145 
146 static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
147 {
148  struct rsi *new = container_of(cnew, struct rsi, h);
149  struct rsi *item = container_of(citem, struct rsi, h);
150 
151  BUG_ON(new->out_handle.data || new->out_token.data);
152  new->out_handle.len = item->out_handle.len;
153  item->out_handle.len = 0;
154  new->out_token.len = item->out_token.len;
155  item->out_token.len = 0;
156  new->out_handle.data = item->out_handle.data;
157  item->out_handle.data = NULL;
158  new->out_token.data = item->out_token.data;
159  item->out_token.data = NULL;
160 
161  new->major_status = item->major_status;
162  new->minor_status = item->minor_status;
163 }
164 
165 static struct cache_head *rsi_alloc(void)
166 {
167  struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
168  if (rsii)
169  return &rsii->h;
170  else
171  return NULL;
172 }
173 
174 static void rsi_request(struct cache_detail *cd,
175  struct cache_head *h,
176  char **bpp, int *blen)
177 {
178  struct rsi *rsii = container_of(h, struct rsi, h);
179 
180  qword_addhex(bpp, blen, rsii->in_handle.data, rsii->in_handle.len);
181  qword_addhex(bpp, blen, rsii->in_token.data, rsii->in_token.len);
182  (*bpp)[-1] = '\n';
183 }
184 
185 static int rsi_upcall(struct cache_detail *cd, struct cache_head *h)
186 {
187  return sunrpc_cache_pipe_upcall(cd, h, rsi_request);
188 }
189 
190 
191 static int rsi_parse(struct cache_detail *cd,
192  char *mesg, int mlen)
193 {
194  /* context token expiry major minor context token */
195  char *buf = mesg;
196  char *ep;
197  int len;
198  struct rsi rsii, *rsip = NULL;
199  time_t expiry;
200  int status = -EINVAL;
201 
202  memset(&rsii, 0, sizeof(rsii));
203  /* handle */
204  len = qword_get(&mesg, buf, mlen);
205  if (len < 0)
206  goto out;
207  status = -ENOMEM;
208  if (dup_to_netobj(&rsii.in_handle, buf, len))
209  goto out;
210 
211  /* token */
212  len = qword_get(&mesg, buf, mlen);
213  status = -EINVAL;
214  if (len < 0)
215  goto out;
216  status = -ENOMEM;
217  if (dup_to_netobj(&rsii.in_token, buf, len))
218  goto out;
219 
220  rsip = rsi_lookup(cd, &rsii);
221  if (!rsip)
222  goto out;
223 
224  rsii.h.flags = 0;
225  /* expiry */
226  expiry = get_expiry(&mesg);
227  status = -EINVAL;
228  if (expiry == 0)
229  goto out;
230 
231  /* major/minor */
232  len = qword_get(&mesg, buf, mlen);
233  if (len <= 0)
234  goto out;
235  rsii.major_status = simple_strtoul(buf, &ep, 10);
236  if (*ep)
237  goto out;
238  len = qword_get(&mesg, buf, mlen);
239  if (len <= 0)
240  goto out;
241  rsii.minor_status = simple_strtoul(buf, &ep, 10);
242  if (*ep)
243  goto out;
244 
245  /* out_handle */
246  len = qword_get(&mesg, buf, mlen);
247  if (len < 0)
248  goto out;
249  status = -ENOMEM;
250  if (dup_to_netobj(&rsii.out_handle, buf, len))
251  goto out;
252 
253  /* out_token */
254  len = qword_get(&mesg, buf, mlen);
255  status = -EINVAL;
256  if (len < 0)
257  goto out;
258  status = -ENOMEM;
259  if (dup_to_netobj(&rsii.out_token, buf, len))
260  goto out;
261  rsii.h.expiry_time = expiry;
262  rsip = rsi_update(cd, &rsii, rsip);
263  status = 0;
264 out:
265  rsi_free(&rsii);
266  if (rsip)
267  cache_put(&rsip->h, cd);
268  else
269  status = -ENOMEM;
270  return status;
271 }
272 
273 static struct cache_detail rsi_cache_template = {
274  .owner = THIS_MODULE,
275  .hash_size = RSI_HASHMAX,
276  .name = "auth.rpcsec.init",
277  .cache_put = rsi_put,
278  .cache_upcall = rsi_upcall,
279  .cache_parse = rsi_parse,
280  .match = rsi_match,
281  .init = rsi_init,
282  .update = update_rsi,
283  .alloc = rsi_alloc,
284 };
285 
286 static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item)
287 {
288  struct cache_head *ch;
289  int hash = rsi_hash(item);
290 
291  ch = sunrpc_cache_lookup(cd, &item->h, hash);
292  if (ch)
293  return container_of(ch, struct rsi, h);
294  else
295  return NULL;
296 }
297 
298 static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old)
299 {
300  struct cache_head *ch;
301  int hash = rsi_hash(new);
302 
303  ch = sunrpc_cache_update(cd, &new->h,
304  &old->h, hash);
305  if (ch)
306  return container_of(ch, struct rsi, h);
307  else
308  return NULL;
309 }
310 
311 
312 /*
313  * The rpcsec_context cache is used to store a context that is
314  * used in data exchange.
315  * The key is a context handle. The content is:
316  * uid, gidlist, mechanism, service-set, mech-specific-data
317  */
318 
319 #define RSC_HASHBITS 10
320 #define RSC_HASHMAX (1<<RSC_HASHBITS)
321 
322 #define GSS_SEQ_WIN 128
323 
325  /* highest seq number seen so far: */
326  int sd_max;
327  /* for i such that sd_max-GSS_SEQ_WIN < i <= sd_max, the i-th bit of
328  * sd_win is nonzero iff sequence number i has been seen already: */
331 };
332 
333 struct rsc {
334  struct cache_head h;
335  struct xdr_netobj handle;
336  struct svc_cred cred;
338  struct gss_ctx *mechctx;
339 };
340 
341 static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old);
342 static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item);
343 
344 static void rsc_free(struct rsc *rsci)
345 {
346  kfree(rsci->handle.data);
347  if (rsci->mechctx)
349  free_svc_cred(&rsci->cred);
350 }
351 
352 static void rsc_put(struct kref *ref)
353 {
354  struct rsc *rsci = container_of(ref, struct rsc, h.ref);
355 
356  rsc_free(rsci);
357  kfree(rsci);
358 }
359 
360 static inline int
361 rsc_hash(struct rsc *rsci)
362 {
363  return hash_mem(rsci->handle.data, rsci->handle.len, RSC_HASHBITS);
364 }
365 
366 static int
367 rsc_match(struct cache_head *a, struct cache_head *b)
368 {
369  struct rsc *new = container_of(a, struct rsc, h);
370  struct rsc *tmp = container_of(b, struct rsc, h);
371 
372  return netobj_equal(&new->handle, &tmp->handle);
373 }
374 
375 static void
376 rsc_init(struct cache_head *cnew, struct cache_head *ctmp)
377 {
378  struct rsc *new = container_of(cnew, struct rsc, h);
379  struct rsc *tmp = container_of(ctmp, struct rsc, h);
380 
381  new->handle.len = tmp->handle.len;
382  tmp->handle.len = 0;
383  new->handle.data = tmp->handle.data;
384  tmp->handle.data = NULL;
385  new->mechctx = NULL;
386  new->cred.cr_group_info = NULL;
387  new->cred.cr_principal = NULL;
388 }
389 
390 static void
391 update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
392 {
393  struct rsc *new = container_of(cnew, struct rsc, h);
394  struct rsc *tmp = container_of(ctmp, struct rsc, h);
395 
396  new->mechctx = tmp->mechctx;
397  tmp->mechctx = NULL;
398  memset(&new->seqdata, 0, sizeof(new->seqdata));
399  spin_lock_init(&new->seqdata.sd_lock);
400  new->cred = tmp->cred;
401  tmp->cred.cr_group_info = NULL;
402  new->cred.cr_principal = tmp->cred.cr_principal;
403  tmp->cred.cr_principal = NULL;
404 }
405 
406 static struct cache_head *
407 rsc_alloc(void)
408 {
409  struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
410  if (rsci)
411  return &rsci->h;
412  else
413  return NULL;
414 }
415 
416 static int rsc_parse(struct cache_detail *cd,
417  char *mesg, int mlen)
418 {
419  /* contexthandle expiry [ uid gid N <n gids> mechname ...mechdata... ] */
420  char *buf = mesg;
421  int len, rv;
422  struct rsc rsci, *rscp = NULL;
423  time_t expiry;
424  int status = -EINVAL;
425  struct gss_api_mech *gm = NULL;
426 
427  memset(&rsci, 0, sizeof(rsci));
428  /* context handle */
429  len = qword_get(&mesg, buf, mlen);
430  if (len < 0) goto out;
431  status = -ENOMEM;
432  if (dup_to_netobj(&rsci.handle, buf, len))
433  goto out;
434 
435  rsci.h.flags = 0;
436  /* expiry */
437  expiry = get_expiry(&mesg);
438  status = -EINVAL;
439  if (expiry == 0)
440  goto out;
441 
442  rscp = rsc_lookup(cd, &rsci);
443  if (!rscp)
444  goto out;
445 
446  /* uid, or NEGATIVE */
447  rv = get_int(&mesg, &rsci.cred.cr_uid);
448  if (rv == -EINVAL)
449  goto out;
450  if (rv == -ENOENT)
451  set_bit(CACHE_NEGATIVE, &rsci.h.flags);
452  else {
453  int N, i;
454 
455  /* gid */
456  if (get_int(&mesg, &rsci.cred.cr_gid))
457  goto out;
458 
459  /* number of additional gid's */
460  if (get_int(&mesg, &N))
461  goto out;
462  status = -ENOMEM;
463  rsci.cred.cr_group_info = groups_alloc(N);
464  if (rsci.cred.cr_group_info == NULL)
465  goto out;
466 
467  /* gid's */
468  status = -EINVAL;
469  for (i=0; i<N; i++) {
470  gid_t gid;
471  kgid_t kgid;
472  if (get_int(&mesg, &gid))
473  goto out;
474  kgid = make_kgid(&init_user_ns, gid);
475  if (!gid_valid(kgid))
476  goto out;
477  GROUP_AT(rsci.cred.cr_group_info, i) = kgid;
478  }
479 
480  /* mech name */
481  len = qword_get(&mesg, buf, mlen);
482  if (len < 0)
483  goto out;
484  gm = gss_mech_get_by_name(buf);
485  status = -EOPNOTSUPP;
486  if (!gm)
487  goto out;
488 
489  status = -EINVAL;
490  /* mech-specific data: */
491  len = qword_get(&mesg, buf, mlen);
492  if (len < 0)
493  goto out;
494  status = gss_import_sec_context(buf, len, gm, &rsci.mechctx, GFP_KERNEL);
495  if (status)
496  goto out;
497 
498  /* get client name */
499  len = qword_get(&mesg, buf, mlen);
500  if (len > 0) {
501  rsci.cred.cr_principal = kstrdup(buf, GFP_KERNEL);
502  if (!rsci.cred.cr_principal)
503  goto out;
504  }
505 
506  }
507  rsci.h.expiry_time = expiry;
508  rscp = rsc_update(cd, &rsci, rscp);
509  status = 0;
510 out:
511  gss_mech_put(gm);
512  rsc_free(&rsci);
513  if (rscp)
514  cache_put(&rscp->h, cd);
515  else
516  status = -ENOMEM;
517  return status;
518 }
519 
520 static struct cache_detail rsc_cache_template = {
521  .owner = THIS_MODULE,
522  .hash_size = RSC_HASHMAX,
523  .name = "auth.rpcsec.context",
524  .cache_put = rsc_put,
525  .cache_parse = rsc_parse,
526  .match = rsc_match,
527  .init = rsc_init,
528  .update = update_rsc,
529  .alloc = rsc_alloc,
530 };
531 
532 static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item)
533 {
534  struct cache_head *ch;
535  int hash = rsc_hash(item);
536 
537  ch = sunrpc_cache_lookup(cd, &item->h, hash);
538  if (ch)
539  return container_of(ch, struct rsc, h);
540  else
541  return NULL;
542 }
543 
544 static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old)
545 {
546  struct cache_head *ch;
547  int hash = rsc_hash(new);
548 
549  ch = sunrpc_cache_update(cd, &new->h,
550  &old->h, hash);
551  if (ch)
552  return container_of(ch, struct rsc, h);
553  else
554  return NULL;
555 }
556 
557 
558 static struct rsc *
559 gss_svc_searchbyctx(struct cache_detail *cd, struct xdr_netobj *handle)
560 {
561  struct rsc rsci;
562  struct rsc *found;
563 
564  memset(&rsci, 0, sizeof(rsci));
565  if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
566  return NULL;
567  found = rsc_lookup(cd, &rsci);
568  rsc_free(&rsci);
569  if (!found)
570  return NULL;
571  if (cache_check(cd, &found->h, NULL))
572  return NULL;
573  return found;
574 }
575 
576 /* Implements sequence number algorithm as specified in RFC 2203. */
577 static int
578 gss_check_seq_num(struct rsc *rsci, int seq_num)
579 {
580  struct gss_svc_seq_data *sd = &rsci->seqdata;
581 
582  spin_lock(&sd->sd_lock);
583  if (seq_num > sd->sd_max) {
584  if (seq_num >= sd->sd_max + GSS_SEQ_WIN) {
585  memset(sd->sd_win,0,sizeof(sd->sd_win));
586  sd->sd_max = seq_num;
587  } else while (sd->sd_max < seq_num) {
588  sd->sd_max++;
589  __clear_bit(sd->sd_max % GSS_SEQ_WIN, sd->sd_win);
590  }
591  __set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win);
592  goto ok;
593  } else if (seq_num <= sd->sd_max - GSS_SEQ_WIN) {
594  goto drop;
595  }
596  /* sd_max - GSS_SEQ_WIN < seq_num <= sd_max */
597  if (__test_and_set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win))
598  goto drop;
599 ok:
600  spin_unlock(&sd->sd_lock);
601  return 1;
602 drop:
603  spin_unlock(&sd->sd_lock);
604  return 0;
605 }
606 
607 static inline u32 round_up_to_quad(u32 i)
608 {
609  return (i + 3 ) & ~3;
610 }
611 
612 static inline int
613 svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
614 {
615  int l;
616 
617  if (argv->iov_len < 4)
618  return -1;
619  o->len = svc_getnl(argv);
620  l = round_up_to_quad(o->len);
621  if (argv->iov_len < l)
622  return -1;
623  o->data = argv->iov_base;
624  argv->iov_base += l;
625  argv->iov_len -= l;
626  return 0;
627 }
628 
629 static inline int
630 svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
631 {
632  u8 *p;
633 
634  if (resv->iov_len + 4 > PAGE_SIZE)
635  return -1;
636  svc_putnl(resv, o->len);
637  p = resv->iov_base + resv->iov_len;
638  resv->iov_len += round_up_to_quad(o->len);
639  if (resv->iov_len > PAGE_SIZE)
640  return -1;
641  memcpy(p, o->data, o->len);
642  memset(p + o->len, 0, round_up_to_quad(o->len) - o->len);
643  return 0;
644 }
645 
646 /*
647  * Verify the checksum on the header and return SVC_OK on success.
648  * Otherwise, return SVC_DROP (in the case of a bad sequence number)
649  * or return SVC_DENIED and indicate error in authp.
650  */
651 static int
652 gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
653  __be32 *rpcstart, struct rpc_gss_wire_cred *gc, __be32 *authp)
654 {
655  struct gss_ctx *ctx_id = rsci->mechctx;
656  struct xdr_buf rpchdr;
657  struct xdr_netobj checksum;
658  u32 flavor = 0;
659  struct kvec *argv = &rqstp->rq_arg.head[0];
660  struct kvec iov;
661 
662  /* data to compute the checksum over: */
663  iov.iov_base = rpcstart;
664  iov.iov_len = (u8 *)argv->iov_base - (u8 *)rpcstart;
665  xdr_buf_from_iov(&iov, &rpchdr);
666 
667  *authp = rpc_autherr_badverf;
668  if (argv->iov_len < 4)
669  return SVC_DENIED;
670  flavor = svc_getnl(argv);
671  if (flavor != RPC_AUTH_GSS)
672  return SVC_DENIED;
673  if (svc_safe_getnetobj(argv, &checksum))
674  return SVC_DENIED;
675 
676  if (rqstp->rq_deferred) /* skip verification of revisited request */
677  return SVC_OK;
678  if (gss_verify_mic(ctx_id, &rpchdr, &checksum) != GSS_S_COMPLETE) {
679  *authp = rpcsec_gsserr_credproblem;
680  return SVC_DENIED;
681  }
682 
683  if (gc->gc_seq > MAXSEQ) {
684  dprintk("RPC: svcauth_gss: discarding request with "
685  "large sequence number %d\n", gc->gc_seq);
686  *authp = rpcsec_gsserr_ctxproblem;
687  return SVC_DENIED;
688  }
689  if (!gss_check_seq_num(rsci, gc->gc_seq)) {
690  dprintk("RPC: svcauth_gss: discarding request with "
691  "old sequence number %d\n", gc->gc_seq);
692  return SVC_DROP;
693  }
694  return SVC_OK;
695 }
696 
697 static int
698 gss_write_null_verf(struct svc_rqst *rqstp)
699 {
700  __be32 *p;
701 
702  svc_putnl(rqstp->rq_res.head, RPC_AUTH_NULL);
703  p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
704  /* don't really need to check if head->iov_len > PAGE_SIZE ... */
705  *p++ = 0;
706  if (!xdr_ressize_check(rqstp, p))
707  return -1;
708  return 0;
709 }
710 
711 static int
712 gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
713 {
714  __be32 xdr_seq;
715  u32 maj_stat;
716  struct xdr_buf verf_data;
717  struct xdr_netobj mic;
718  __be32 *p;
719  struct kvec iov;
720 
721  svc_putnl(rqstp->rq_res.head, RPC_AUTH_GSS);
722  xdr_seq = htonl(seq);
723 
724  iov.iov_base = &xdr_seq;
725  iov.iov_len = sizeof(xdr_seq);
726  xdr_buf_from_iov(&iov, &verf_data);
727  p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
728  mic.data = (u8 *)(p + 1);
729  maj_stat = gss_get_mic(ctx_id, &verf_data, &mic);
730  if (maj_stat != GSS_S_COMPLETE)
731  return -1;
732  *p++ = htonl(mic.len);
733  memset((u8 *)p + mic.len, 0, round_up_to_quad(mic.len) - mic.len);
734  p += XDR_QUADLEN(mic.len);
735  if (!xdr_ressize_check(rqstp, p))
736  return -1;
737  return 0;
738 }
739 
740 struct gss_domain {
741  struct auth_domain h;
743 };
744 
745 static struct auth_domain *
746 find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
747 {
748  char *name;
749 
750  name = gss_service_to_auth_domain_name(ctx->mech_type, svc);
751  if (!name)
752  return NULL;
753  return auth_domain_find(name);
754 }
755 
756 static struct auth_ops svcauthops_gss;
757 
758 u32 svcauth_gss_flavor(struct auth_domain *dom)
759 {
760  struct gss_domain *gd = container_of(dom, struct gss_domain, h);
761 
762  return gd->pseudoflavor;
763 }
764 
766 
767 int
769 {
770  struct gss_domain *new;
771  struct auth_domain *test;
772  int stat = -ENOMEM;
773 
774  new = kmalloc(sizeof(*new), GFP_KERNEL);
775  if (!new)
776  goto out;
777  kref_init(&new->h.ref);
778  new->h.name = kstrdup(name, GFP_KERNEL);
779  if (!new->h.name)
780  goto out_free_dom;
781  new->h.flavour = &svcauthops_gss;
782  new->pseudoflavor = pseudoflavor;
783 
784  stat = 0;
785  test = auth_domain_lookup(name, &new->h);
786  if (test != &new->h) { /* Duplicate registration */
787  auth_domain_put(test);
788  kfree(new->h.name);
789  goto out_free_dom;
790  }
791  return 0;
792 
793 out_free_dom:
794  kfree(new);
795 out:
796  return stat;
797 }
798 
800 
801 static inline int
802 read_u32_from_xdr_buf(struct xdr_buf *buf, int base, u32 *obj)
803 {
804  __be32 raw;
805  int status;
806 
807  status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
808  if (status)
809  return status;
810  *obj = ntohl(raw);
811  return 0;
812 }
813 
814 /* It would be nice if this bit of code could be shared with the client.
815  * Obstacles:
816  * The client shouldn't malloc(), would have to pass in own memory.
817  * The server uses base of head iovec as read pointer, while the
818  * client uses separate pointer. */
819 static int
820 unwrap_integ_data(struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
821 {
822  int stat = -EINVAL;
823  u32 integ_len, maj_stat;
824  struct xdr_netobj mic;
825  struct xdr_buf integ_buf;
826 
827  integ_len = svc_getnl(&buf->head[0]);
828  if (integ_len & 3)
829  return stat;
830  if (integ_len > buf->len)
831  return stat;
832  if (xdr_buf_subsegment(buf, &integ_buf, 0, integ_len))
833  BUG();
834  /* copy out mic... */
835  if (read_u32_from_xdr_buf(buf, integ_len, &mic.len))
836  BUG();
837  if (mic.len > RPC_MAX_AUTH_SIZE)
838  return stat;
839  mic.data = kmalloc(mic.len, GFP_KERNEL);
840  if (!mic.data)
841  return stat;
842  if (read_bytes_from_xdr_buf(buf, integ_len + 4, mic.data, mic.len))
843  goto out;
844  maj_stat = gss_verify_mic(ctx, &integ_buf, &mic);
845  if (maj_stat != GSS_S_COMPLETE)
846  goto out;
847  if (svc_getnl(&buf->head[0]) != seq)
848  goto out;
849  stat = 0;
850 out:
851  kfree(mic.data);
852  return stat;
853 }
854 
855 static inline int
856 total_buf_len(struct xdr_buf *buf)
857 {
858  return buf->head[0].iov_len + buf->page_len + buf->tail[0].iov_len;
859 }
860 
861 static void
862 fix_priv_head(struct xdr_buf *buf, int pad)
863 {
864  if (buf->page_len == 0) {
865  /* We need to adjust head and buf->len in tandem in this
866  * case to make svc_defer() work--it finds the original
867  * buffer start using buf->len - buf->head[0].iov_len. */
868  buf->head[0].iov_len -= pad;
869  }
870 }
871 
872 static int
873 unwrap_priv_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
874 {
875  u32 priv_len, maj_stat;
876  int pad, saved_len, remaining_len, offset;
877 
878  rqstp->rq_splice_ok = 0;
879 
880  priv_len = svc_getnl(&buf->head[0]);
881  if (rqstp->rq_deferred) {
882  /* Already decrypted last time through! The sequence number
883  * check at out_seq is unnecessary but harmless: */
884  goto out_seq;
885  }
886  /* buf->len is the number of bytes from the original start of the
887  * request to the end, where head[0].iov_len is just the bytes
888  * not yet read from the head, so these two values are different: */
889  remaining_len = total_buf_len(buf);
890  if (priv_len > remaining_len)
891  return -EINVAL;
892  pad = remaining_len - priv_len;
893  buf->len -= pad;
894  fix_priv_head(buf, pad);
895 
896  /* Maybe it would be better to give gss_unwrap a length parameter: */
897  saved_len = buf->len;
898  buf->len = priv_len;
899  maj_stat = gss_unwrap(ctx, 0, buf);
900  pad = priv_len - buf->len;
901  buf->len = saved_len;
902  buf->len -= pad;
903  /* The upper layers assume the buffer is aligned on 4-byte boundaries.
904  * In the krb5p case, at least, the data ends up offset, so we need to
905  * move it around. */
906  /* XXX: This is very inefficient. It would be better to either do
907  * this while we encrypt, or maybe in the receive code, if we can peak
908  * ahead and work out the service and mechanism there. */
909  offset = buf->head[0].iov_len % 4;
910  if (offset) {
911  buf->buflen = RPCSVC_MAXPAYLOAD;
912  xdr_shift_buf(buf, offset);
913  fix_priv_head(buf, pad);
914  }
915  if (maj_stat != GSS_S_COMPLETE)
916  return -EINVAL;
917 out_seq:
918  if (svc_getnl(&buf->head[0]) != seq)
919  return -EINVAL;
920  return 0;
921 }
922 
923 struct gss_svc_data {
924  /* decoded gss client cred: */
925  struct rpc_gss_wire_cred clcred;
926  /* save a pointer to the beginning of the encoded verifier,
927  * for use in encryption/checksumming in svcauth_gss_release: */
929  struct rsc *rsci;
930 };
931 
932 static int
933 svcauth_gss_set_client(struct svc_rqst *rqstp)
934 {
935  struct gss_svc_data *svcdata = rqstp->rq_auth_data;
936  struct rsc *rsci = svcdata->rsci;
937  struct rpc_gss_wire_cred *gc = &svcdata->clcred;
938  int stat;
939 
940  /*
941  * A gss export can be specified either by:
942  * export *(sec=krb5,rw)
943  * or by
944  * export gss/krb5(rw)
945  * The latter is deprecated; but for backwards compatibility reasons
946  * the nfsd code will still fall back on trying it if the former
947  * doesn't work; so we try to make both available to nfsd, below.
948  */
949  rqstp->rq_gssclient = find_gss_auth_domain(rsci->mechctx, gc->gc_svc);
950  if (rqstp->rq_gssclient == NULL)
951  return SVC_DENIED;
952  stat = svcauth_unix_set_client(rqstp);
953  if (stat == SVC_DROP || stat == SVC_CLOSE)
954  return stat;
955  return SVC_OK;
956 }
957 
958 static inline int
959 gss_write_init_verf(struct cache_detail *cd, struct svc_rqst *rqstp,
960  struct xdr_netobj *out_handle, int *major_status)
961 {
962  struct rsc *rsci;
963  int rc;
964 
965  if (*major_status != GSS_S_COMPLETE)
966  return gss_write_null_verf(rqstp);
967  rsci = gss_svc_searchbyctx(cd, out_handle);
968  if (rsci == NULL) {
969  *major_status = GSS_S_NO_CONTEXT;
970  return gss_write_null_verf(rqstp);
971  }
972  rc = gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
973  cache_put(&rsci->h, cd);
974  return rc;
975 }
976 
977 static inline int
978 gss_read_verf(struct rpc_gss_wire_cred *gc,
979  struct kvec *argv, __be32 *authp,
980  struct xdr_netobj *in_handle,
981  struct xdr_netobj *in_token)
982 {
983  struct xdr_netobj tmpobj;
984 
985  /* Read the verifier; should be NULL: */
986  *authp = rpc_autherr_badverf;
987  if (argv->iov_len < 2 * 4)
988  return SVC_DENIED;
989  if (svc_getnl(argv) != RPC_AUTH_NULL)
990  return SVC_DENIED;
991  if (svc_getnl(argv) != 0)
992  return SVC_DENIED;
993  /* Martial context handle and token for upcall: */
994  *authp = rpc_autherr_badcred;
995  if (gc->gc_proc == RPC_GSS_PROC_INIT && gc->gc_ctx.len != 0)
996  return SVC_DENIED;
997  if (dup_netobj(in_handle, &gc->gc_ctx))
998  return SVC_CLOSE;
999  *authp = rpc_autherr_badverf;
1000  if (svc_safe_getnetobj(argv, &tmpobj)) {
1001  kfree(in_handle->data);
1002  return SVC_DENIED;
1003  }
1004  if (dup_netobj(in_token, &tmpobj)) {
1005  kfree(in_handle->data);
1006  return SVC_CLOSE;
1007  }
1008 
1009  return 0;
1010 }
1011 
1012 static inline int
1013 gss_write_resv(struct kvec *resv, size_t size_limit,
1014  struct xdr_netobj *out_handle, struct xdr_netobj *out_token,
1015  int major_status, int minor_status)
1016 {
1017  if (resv->iov_len + 4 > size_limit)
1018  return -1;
1019  svc_putnl(resv, RPC_SUCCESS);
1020  if (svc_safe_putnetobj(resv, out_handle))
1021  return -1;
1022  if (resv->iov_len + 3 * 4 > size_limit)
1023  return -1;
1024  svc_putnl(resv, major_status);
1025  svc_putnl(resv, minor_status);
1026  svc_putnl(resv, GSS_SEQ_WIN);
1027  if (svc_safe_putnetobj(resv, out_token))
1028  return -1;
1029  return 0;
1030 }
1031 
1032 /*
1033  * Having read the cred already and found we're in the context
1034  * initiation case, read the verifier and initiate (or check the results
1035  * of) upcalls to userspace for help with context initiation. If
1036  * the upcall results are available, write the verifier and result.
1037  * Otherwise, drop the request pending an answer to the upcall.
1038  */
1039 static int svcauth_gss_handle_init(struct svc_rqst *rqstp,
1040  struct rpc_gss_wire_cred *gc, __be32 *authp)
1041 {
1042  struct kvec *argv = &rqstp->rq_arg.head[0];
1043  struct kvec *resv = &rqstp->rq_res.head[0];
1044  struct rsi *rsip, rsikey;
1045  int ret;
1046  struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
1047 
1048  memset(&rsikey, 0, sizeof(rsikey));
1049  ret = gss_read_verf(gc, argv, authp,
1050  &rsikey.in_handle, &rsikey.in_token);
1051  if (ret)
1052  return ret;
1053 
1054  /* Perform upcall, or find upcall result: */
1055  rsip = rsi_lookup(sn->rsi_cache, &rsikey);
1056  rsi_free(&rsikey);
1057  if (!rsip)
1058  return SVC_CLOSE;
1059  if (cache_check(sn->rsi_cache, &rsip->h, &rqstp->rq_chandle) < 0)
1060  /* No upcall result: */
1061  return SVC_CLOSE;
1062 
1063  ret = SVC_CLOSE;
1064  /* Got an answer to the upcall; use it: */
1065  if (gss_write_init_verf(sn->rsc_cache, rqstp,
1066  &rsip->out_handle, &rsip->major_status))
1067  goto out;
1068  if (gss_write_resv(resv, PAGE_SIZE,
1069  &rsip->out_handle, &rsip->out_token,
1070  rsip->major_status, rsip->minor_status))
1071  goto out;
1072 
1073  ret = SVC_COMPLETE;
1074 out:
1075  cache_put(&rsip->h, sn->rsi_cache);
1076  return ret;
1077 }
1078 
1079 /*
1080  * Accept an rpcsec packet.
1081  * If context establishment, punt to user space
1082  * If data exchange, verify/decrypt
1083  * If context destruction, handle here
1084  * In the context establishment and destruction case we encode
1085  * response here and return SVC_COMPLETE.
1086  */
1087 static int
1088 svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
1089 {
1090  struct kvec *argv = &rqstp->rq_arg.head[0];
1091  struct kvec *resv = &rqstp->rq_res.head[0];
1092  u32 crlen;
1093  struct gss_svc_data *svcdata = rqstp->rq_auth_data;
1094  struct rpc_gss_wire_cred *gc;
1095  struct rsc *rsci = NULL;
1096  __be32 *rpcstart;
1097  __be32 *reject_stat = resv->iov_base + resv->iov_len;
1098  int ret;
1099  struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
1100 
1101  dprintk("RPC: svcauth_gss: argv->iov_len = %zd\n",
1102  argv->iov_len);
1103 
1104  *authp = rpc_autherr_badcred;
1105  if (!svcdata)
1106  svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
1107  if (!svcdata)
1108  goto auth_err;
1109  rqstp->rq_auth_data = svcdata;
1110  svcdata->verf_start = NULL;
1111  svcdata->rsci = NULL;
1112  gc = &svcdata->clcred;
1113 
1114  /* start of rpc packet is 7 u32's back from here:
1115  * xid direction rpcversion prog vers proc flavour
1116  */
1117  rpcstart = argv->iov_base;
1118  rpcstart -= 7;
1119 
1120  /* credential is:
1121  * version(==1), proc(0,1,2,3), seq, service (1,2,3), handle
1122  * at least 5 u32s, and is preceded by length, so that makes 6.
1123  */
1124 
1125  if (argv->iov_len < 5 * 4)
1126  goto auth_err;
1127  crlen = svc_getnl(argv);
1128  if (svc_getnl(argv) != RPC_GSS_VERSION)
1129  goto auth_err;
1130  gc->gc_proc = svc_getnl(argv);
1131  gc->gc_seq = svc_getnl(argv);
1132  gc->gc_svc = svc_getnl(argv);
1133  if (svc_safe_getnetobj(argv, &gc->gc_ctx))
1134  goto auth_err;
1135  if (crlen != round_up_to_quad(gc->gc_ctx.len) + 5 * 4)
1136  goto auth_err;
1137 
1138  if ((gc->gc_proc != RPC_GSS_PROC_DATA) && (rqstp->rq_proc != 0))
1139  goto auth_err;
1140 
1141  *authp = rpc_autherr_badverf;
1142  switch (gc->gc_proc) {
1143  case RPC_GSS_PROC_INIT:
1144  case RPC_GSS_PROC_CONTINUE_INIT:
1145  return svcauth_gss_handle_init(rqstp, gc, authp);
1146  case RPC_GSS_PROC_DATA:
1147  case RPC_GSS_PROC_DESTROY:
1148  /* Look up the context, and check the verifier: */
1149  *authp = rpcsec_gsserr_credproblem;
1150  rsci = gss_svc_searchbyctx(sn->rsc_cache, &gc->gc_ctx);
1151  if (!rsci)
1152  goto auth_err;
1153  switch (gss_verify_header(rqstp, rsci, rpcstart, gc, authp)) {
1154  case SVC_OK:
1155  break;
1156  case SVC_DENIED:
1157  goto auth_err;
1158  case SVC_DROP:
1159  goto drop;
1160  }
1161  break;
1162  default:
1163  *authp = rpc_autherr_rejectedcred;
1164  goto auth_err;
1165  }
1166 
1167  /* now act upon the command: */
1168  switch (gc->gc_proc) {
1169  case RPC_GSS_PROC_DESTROY:
1170  if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1171  goto auth_err;
1172  rsci->h.expiry_time = get_seconds();
1173  set_bit(CACHE_NEGATIVE, &rsci->h.flags);
1174  if (resv->iov_len + 4 > PAGE_SIZE)
1175  goto drop;
1176  svc_putnl(resv, RPC_SUCCESS);
1177  goto complete;
1178  case RPC_GSS_PROC_DATA:
1179  *authp = rpcsec_gsserr_ctxproblem;
1180  svcdata->verf_start = resv->iov_base + resv->iov_len;
1181  if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1182  goto auth_err;
1183  rqstp->rq_cred = rsci->cred;
1184  get_group_info(rsci->cred.cr_group_info);
1185  *authp = rpc_autherr_badcred;
1186  switch (gc->gc_svc) {
1187  case RPC_GSS_SVC_NONE:
1188  break;
1189  case RPC_GSS_SVC_INTEGRITY:
1190  /* placeholders for length and seq. number: */
1191  svc_putnl(resv, 0);
1192  svc_putnl(resv, 0);
1193  if (unwrap_integ_data(&rqstp->rq_arg,
1194  gc->gc_seq, rsci->mechctx))
1195  goto garbage_args;
1196  break;
1197  case RPC_GSS_SVC_PRIVACY:
1198  /* placeholders for length and seq. number: */
1199  svc_putnl(resv, 0);
1200  svc_putnl(resv, 0);
1201  if (unwrap_priv_data(rqstp, &rqstp->rq_arg,
1202  gc->gc_seq, rsci->mechctx))
1203  goto garbage_args;
1204  break;
1205  default:
1206  goto auth_err;
1207  }
1208  svcdata->rsci = rsci;
1209  cache_get(&rsci->h);
1210  rqstp->rq_cred.cr_flavor = gss_svc_to_pseudoflavor(
1211  rsci->mechctx->mech_type, gc->gc_svc);
1212  ret = SVC_OK;
1213  goto out;
1214  }
1215 garbage_args:
1216  ret = SVC_GARBAGE;
1217  goto out;
1218 auth_err:
1219  /* Restore write pointer to its original value: */
1220  xdr_ressize_check(rqstp, reject_stat);
1221  ret = SVC_DENIED;
1222  goto out;
1223 complete:
1224  ret = SVC_COMPLETE;
1225  goto out;
1226 drop:
1227  ret = SVC_DROP;
1228 out:
1229  if (rsci)
1230  cache_put(&rsci->h, sn->rsc_cache);
1231  return ret;
1232 }
1233 
1234 static __be32 *
1235 svcauth_gss_prepare_to_wrap(struct xdr_buf *resbuf, struct gss_svc_data *gsd)
1236 {
1237  __be32 *p;
1238  u32 verf_len;
1239 
1240  p = gsd->verf_start;
1241  gsd->verf_start = NULL;
1242 
1243  /* If the reply stat is nonzero, don't wrap: */
1244  if (*(p-1) != rpc_success)
1245  return NULL;
1246  /* Skip the verifier: */
1247  p += 1;
1248  verf_len = ntohl(*p++);
1249  p += XDR_QUADLEN(verf_len);
1250  /* move accept_stat to right place: */
1251  memcpy(p, p + 2, 4);
1252  /* Also don't wrap if the accept stat is nonzero: */
1253  if (*p != rpc_success) {
1254  resbuf->head[0].iov_len -= 2 * 4;
1255  return NULL;
1256  }
1257  p++;
1258  return p;
1259 }
1260 
1261 static inline int
1262 svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
1263 {
1264  struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1265  struct rpc_gss_wire_cred *gc = &gsd->clcred;
1266  struct xdr_buf *resbuf = &rqstp->rq_res;
1267  struct xdr_buf integ_buf;
1268  struct xdr_netobj mic;
1269  struct kvec *resv;
1270  __be32 *p;
1271  int integ_offset, integ_len;
1272  int stat = -EINVAL;
1273 
1274  p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1275  if (p == NULL)
1276  goto out;
1277  integ_offset = (u8 *)(p + 1) - (u8 *)resbuf->head[0].iov_base;
1278  integ_len = resbuf->len - integ_offset;
1279  BUG_ON(integ_len % 4);
1280  *p++ = htonl(integ_len);
1281  *p++ = htonl(gc->gc_seq);
1282  if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset,
1283  integ_len))
1284  BUG();
1285  if (resbuf->tail[0].iov_base == NULL) {
1286  if (resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1287  goto out_err;
1288  resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1289  + resbuf->head[0].iov_len;
1290  resbuf->tail[0].iov_len = 0;
1291  resv = &resbuf->tail[0];
1292  } else {
1293  resv = &resbuf->tail[0];
1294  }
1295  mic.data = (u8 *)resv->iov_base + resv->iov_len + 4;
1296  if (gss_get_mic(gsd->rsci->mechctx, &integ_buf, &mic))
1297  goto out_err;
1298  svc_putnl(resv, mic.len);
1299  memset(mic.data + mic.len, 0,
1300  round_up_to_quad(mic.len) - mic.len);
1301  resv->iov_len += XDR_QUADLEN(mic.len) << 2;
1302  /* not strictly required: */
1303  resbuf->len += XDR_QUADLEN(mic.len) << 2;
1304  BUG_ON(resv->iov_len > PAGE_SIZE);
1305 out:
1306  stat = 0;
1307 out_err:
1308  return stat;
1309 }
1310 
1311 static inline int
1312 svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
1313 {
1314  struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1315  struct rpc_gss_wire_cred *gc = &gsd->clcred;
1316  struct xdr_buf *resbuf = &rqstp->rq_res;
1317  struct page **inpages = NULL;
1318  __be32 *p, *len;
1319  int offset;
1320  int pad;
1321 
1322  p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1323  if (p == NULL)
1324  return 0;
1325  len = p++;
1326  offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base;
1327  *p++ = htonl(gc->gc_seq);
1328  inpages = resbuf->pages;
1329  /* XXX: Would be better to write some xdr helper functions for
1330  * nfs{2,3,4}xdr.c that place the data right, instead of copying: */
1331 
1332  /*
1333  * If there is currently tail data, make sure there is
1334  * room for the head, tail, and 2 * RPC_MAX_AUTH_SIZE in
1335  * the page, and move the current tail data such that
1336  * there is RPC_MAX_AUTH_SIZE slack space available in
1337  * both the head and tail.
1338  */
1339  if (resbuf->tail[0].iov_base) {
1340  BUG_ON(resbuf->tail[0].iov_base >= resbuf->head[0].iov_base
1341  + PAGE_SIZE);
1342  BUG_ON(resbuf->tail[0].iov_base < resbuf->head[0].iov_base);
1343  if (resbuf->tail[0].iov_len + resbuf->head[0].iov_len
1344  + 2 * RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1345  return -ENOMEM;
1346  memmove(resbuf->tail[0].iov_base + RPC_MAX_AUTH_SIZE,
1347  resbuf->tail[0].iov_base,
1348  resbuf->tail[0].iov_len);
1349  resbuf->tail[0].iov_base += RPC_MAX_AUTH_SIZE;
1350  }
1351  /*
1352  * If there is no current tail data, make sure there is
1353  * room for the head data, and 2 * RPC_MAX_AUTH_SIZE in the
1354  * allotted page, and set up tail information such that there
1355  * is RPC_MAX_AUTH_SIZE slack space available in both the
1356  * head and tail.
1357  */
1358  if (resbuf->tail[0].iov_base == NULL) {
1359  if (resbuf->head[0].iov_len + 2*RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1360  return -ENOMEM;
1361  resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1362  + resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE;
1363  resbuf->tail[0].iov_len = 0;
1364  }
1365  if (gss_wrap(gsd->rsci->mechctx, offset, resbuf, inpages))
1366  return -ENOMEM;
1367  *len = htonl(resbuf->len - offset);
1368  pad = 3 - ((resbuf->len - offset - 1)&3);
1369  p = (__be32 *)(resbuf->tail[0].iov_base + resbuf->tail[0].iov_len);
1370  memset(p, 0, pad);
1371  resbuf->tail[0].iov_len += pad;
1372  resbuf->len += pad;
1373  return 0;
1374 }
1375 
1376 static int
1377 svcauth_gss_release(struct svc_rqst *rqstp)
1378 {
1379  struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1380  struct rpc_gss_wire_cred *gc = &gsd->clcred;
1381  struct xdr_buf *resbuf = &rqstp->rq_res;
1382  int stat = -EINVAL;
1383  struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
1384 
1385  if (gc->gc_proc != RPC_GSS_PROC_DATA)
1386  goto out;
1387  /* Release can be called twice, but we only wrap once. */
1388  if (gsd->verf_start == NULL)
1389  goto out;
1390  /* normally not set till svc_send, but we need it here: */
1391  /* XXX: what for? Do we mess it up the moment we call svc_putu32
1392  * or whatever? */
1393  resbuf->len = total_buf_len(resbuf);
1394  switch (gc->gc_svc) {
1395  case RPC_GSS_SVC_NONE:
1396  break;
1397  case RPC_GSS_SVC_INTEGRITY:
1398  stat = svcauth_gss_wrap_resp_integ(rqstp);
1399  if (stat)
1400  goto out_err;
1401  break;
1402  case RPC_GSS_SVC_PRIVACY:
1403  stat = svcauth_gss_wrap_resp_priv(rqstp);
1404  if (stat)
1405  goto out_err;
1406  break;
1407  /*
1408  * For any other gc_svc value, svcauth_gss_accept() already set
1409  * the auth_error appropriately; just fall through:
1410  */
1411  }
1412 
1413 out:
1414  stat = 0;
1415 out_err:
1416  if (rqstp->rq_client)
1417  auth_domain_put(rqstp->rq_client);
1418  rqstp->rq_client = NULL;
1419  if (rqstp->rq_gssclient)
1420  auth_domain_put(rqstp->rq_gssclient);
1421  rqstp->rq_gssclient = NULL;
1422  if (rqstp->rq_cred.cr_group_info)
1423  put_group_info(rqstp->rq_cred.cr_group_info);
1424  rqstp->rq_cred.cr_group_info = NULL;
1425  if (gsd->rsci)
1426  cache_put(&gsd->rsci->h, sn->rsc_cache);
1427  gsd->rsci = NULL;
1428 
1429  return stat;
1430 }
1431 
1432 static void
1433 svcauth_gss_domain_release(struct auth_domain *dom)
1434 {
1435  struct gss_domain *gd = container_of(dom, struct gss_domain, h);
1436 
1437  kfree(dom->name);
1438  kfree(gd);
1439 }
1440 
1441 static struct auth_ops svcauthops_gss = {
1442  .name = "rpcsec_gss",
1443  .owner = THIS_MODULE,
1444  .flavour = RPC_AUTH_GSS,
1445  .accept = svcauth_gss_accept,
1446  .release = svcauth_gss_release,
1447  .domain_release = svcauth_gss_domain_release,
1448  .set_client = svcauth_gss_set_client,
1449 };
1450 
1451 static int rsi_cache_create_net(struct net *net)
1452 {
1453  struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1454  struct cache_detail *cd;
1455  int err;
1456 
1457  cd = cache_create_net(&rsi_cache_template, net);
1458  if (IS_ERR(cd))
1459  return PTR_ERR(cd);
1460  err = cache_register_net(cd, net);
1461  if (err) {
1462  cache_destroy_net(cd, net);
1463  return err;
1464  }
1465  sn->rsi_cache = cd;
1466  return 0;
1467 }
1468 
1469 static void rsi_cache_destroy_net(struct net *net)
1470 {
1471  struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1472  struct cache_detail *cd = sn->rsi_cache;
1473 
1474  sn->rsi_cache = NULL;
1475  cache_purge(cd);
1476  cache_unregister_net(cd, net);
1477  cache_destroy_net(cd, net);
1478 }
1479 
1480 static int rsc_cache_create_net(struct net *net)
1481 {
1482  struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1483  struct cache_detail *cd;
1484  int err;
1485 
1486  cd = cache_create_net(&rsc_cache_template, net);
1487  if (IS_ERR(cd))
1488  return PTR_ERR(cd);
1489  err = cache_register_net(cd, net);
1490  if (err) {
1491  cache_destroy_net(cd, net);
1492  return err;
1493  }
1494  sn->rsc_cache = cd;
1495  return 0;
1496 }
1497 
1498 static void rsc_cache_destroy_net(struct net *net)
1499 {
1500  struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1501  struct cache_detail *cd = sn->rsc_cache;
1502 
1503  sn->rsc_cache = NULL;
1504  cache_purge(cd);
1505  cache_unregister_net(cd, net);
1506  cache_destroy_net(cd, net);
1507 }
1508 
1509 int
1510 gss_svc_init_net(struct net *net)
1511 {
1512  int rv;
1513 
1514  rv = rsc_cache_create_net(net);
1515  if (rv)
1516  return rv;
1517  rv = rsi_cache_create_net(net);
1518  if (rv)
1519  goto out1;
1520  return 0;
1521 out1:
1522  rsc_cache_destroy_net(net);
1523  return rv;
1524 }
1525 
1526 void
1527 gss_svc_shutdown_net(struct net *net)
1528 {
1529  rsi_cache_destroy_net(net);
1530  rsc_cache_destroy_net(net);
1531 }
1532 
1533 int
1535 {
1536  return svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
1537 }
1538 
1539 void
1541 {
1542  svc_auth_unregister(RPC_AUTH_GSS);
1543 }