Pull trivial into release branch
[linux-2.6] / net / sunrpc / auth_gss / svcauth_gss.c
1 /*
2  * Neil Brown <neilb@cse.unsw.edu.au>
3  * J. Bruce Fields <bfields@umich.edu>
4  * Andy Adamson <andros@umich.edu>
5  * Dug Song <dugsong@monkey.org>
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/types.h>
41 #include <linux/module.h>
42 #include <linux/pagemap.h>
43
44 #include <linux/sunrpc/auth_gss.h>
45 #include <linux/sunrpc/svcauth.h>
46 #include <linux/sunrpc/gss_err.h>
47 #include <linux/sunrpc/svcauth.h>
48 #include <linux/sunrpc/svcauth_gss.h>
49 #include <linux/sunrpc/cache.h>
50
51 #ifdef RPC_DEBUG
52 # define RPCDBG_FACILITY        RPCDBG_AUTH
53 #endif
54
55 /* The rpcsec_init cache is used for mapping RPCSEC_GSS_{,CONT_}INIT requests
56  * into replies.
57  *
58  * Key is context handle (\x if empty) and gss_token.
59  * Content is major_status minor_status (integers) context_handle, reply_token.
60  *
61  */
62
63 static int netobj_equal(struct xdr_netobj *a, struct xdr_netobj *b)
64 {
65         return a->len == b->len && 0 == memcmp(a->data, b->data, a->len);
66 }
67
68 #define RSI_HASHBITS    6
69 #define RSI_HASHMAX     (1<<RSI_HASHBITS)
70 #define RSI_HASHMASK    (RSI_HASHMAX-1)
71
72 struct rsi {
73         struct cache_head       h;
74         struct xdr_netobj       in_handle, in_token;
75         struct xdr_netobj       out_handle, out_token;
76         int                     major_status, minor_status;
77 };
78
79 static struct cache_head *rsi_table[RSI_HASHMAX];
80 static struct cache_detail rsi_cache;
81 static struct rsi *rsi_update(struct rsi *new, struct rsi *old);
82 static struct rsi *rsi_lookup(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 ? kmalloc(len, GFP_KERNEL) : NULL);
117         if (dst->data)
118                 memcpy(dst->data, src, len);
119         if (len && !dst->data)
120                 return -ENOMEM;
121         return 0;
122 }
123
124 static inline int dup_netobj(struct xdr_netobj *dst, struct xdr_netobj *src)
125 {
126         return dup_to_netobj(dst, src->data, src->len);
127 }
128
129 static void rsi_init(struct cache_head *cnew, struct cache_head *citem)
130 {
131         struct rsi *new = container_of(cnew, struct rsi, h);
132         struct rsi *item = container_of(citem, struct rsi, h);
133
134         new->out_handle.data = NULL;
135         new->out_handle.len = 0;
136         new->out_token.data = NULL;
137         new->out_token.len = 0;
138         new->in_handle.len = item->in_handle.len;
139         item->in_handle.len = 0;
140         new->in_token.len = item->in_token.len;
141         item->in_token.len = 0;
142         new->in_handle.data = item->in_handle.data;
143         item->in_handle.data = NULL;
144         new->in_token.data = item->in_token.data;
145         item->in_token.data = NULL;
146 }
147
148 static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
149 {
150         struct rsi *new = container_of(cnew, struct rsi, h);
151         struct rsi *item = container_of(citem, struct rsi, h);
152
153         BUG_ON(new->out_handle.data || new->out_token.data);
154         new->out_handle.len = item->out_handle.len;
155         item->out_handle.len = 0;
156         new->out_token.len = item->out_token.len;
157         item->out_token.len = 0;
158         new->out_handle.data = item->out_handle.data;
159         item->out_handle.data = NULL;
160         new->out_token.data = item->out_token.data;
161         item->out_token.data = NULL;
162
163         new->major_status = item->major_status;
164         new->minor_status = item->minor_status;
165 }
166
167 static struct cache_head *rsi_alloc(void)
168 {
169         struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
170         if (rsii)
171                 return &rsii->h;
172         else
173                 return NULL;
174 }
175
176 static void rsi_request(struct cache_detail *cd,
177                        struct cache_head *h,
178                        char **bpp, int *blen)
179 {
180         struct rsi *rsii = container_of(h, struct rsi, h);
181
182         qword_addhex(bpp, blen, rsii->in_handle.data, rsii->in_handle.len);
183         qword_addhex(bpp, blen, rsii->in_token.data, rsii->in_token.len);
184         (*bpp)[-1] = '\n';
185 }
186
187
188 static int rsi_parse(struct cache_detail *cd,
189                     char *mesg, int mlen)
190 {
191         /* context token expiry major minor context token */
192         char *buf = mesg;
193         char *ep;
194         int len;
195         struct rsi rsii, *rsip = NULL;
196         time_t expiry;
197         int status = -EINVAL;
198
199         memset(&rsii, 0, sizeof(rsii));
200         /* handle */
201         len = qword_get(&mesg, buf, mlen);
202         if (len < 0)
203                 goto out;
204         status = -ENOMEM;
205         if (dup_to_netobj(&rsii.in_handle, buf, len))
206                 goto out;
207
208         /* token */
209         len = qword_get(&mesg, buf, mlen);
210         status = -EINVAL;
211         if (len < 0)
212                 goto out;
213         status = -ENOMEM;
214         if (dup_to_netobj(&rsii.in_token, buf, len))
215                 goto out;
216
217         rsip = rsi_lookup(&rsii);
218         if (!rsip)
219                 goto out;
220
221         rsii.h.flags = 0;
222         /* expiry */
223         expiry = get_expiry(&mesg);
224         status = -EINVAL;
225         if (expiry == 0)
226                 goto out;
227
228         /* major/minor */
229         len = qword_get(&mesg, buf, mlen);
230         if (len < 0)
231                 goto out;
232         if (len == 0) {
233                 goto out;
234         } else {
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         }
262         rsii.h.expiry_time = expiry;
263         rsip = rsi_update(&rsii, rsip);
264         status = 0;
265 out:
266         rsi_free(&rsii);
267         if (rsip)
268                 cache_put(&rsip->h, &rsi_cache);
269         else
270                 status = -ENOMEM;
271         return status;
272 }
273
274 static struct cache_detail rsi_cache = {
275         .owner          = THIS_MODULE,
276         .hash_size      = RSI_HASHMAX,
277         .hash_table     = rsi_table,
278         .name           = "auth.rpcsec.init",
279         .cache_put      = rsi_put,
280         .cache_request  = rsi_request,
281         .cache_parse    = rsi_parse,
282         .match          = rsi_match,
283         .init           = rsi_init,
284         .update         = update_rsi,
285         .alloc          = rsi_alloc,
286 };
287
288 static struct rsi *rsi_lookup(struct rsi *item)
289 {
290         struct cache_head *ch;
291         int hash = rsi_hash(item);
292
293         ch = sunrpc_cache_lookup(&rsi_cache, &item->h, hash);
294         if (ch)
295                 return container_of(ch, struct rsi, h);
296         else
297                 return NULL;
298 }
299
300 static struct rsi *rsi_update(struct rsi *new, struct rsi *old)
301 {
302         struct cache_head *ch;
303         int hash = rsi_hash(new);
304
305         ch = sunrpc_cache_update(&rsi_cache, &new->h,
306                                  &old->h, hash);
307         if (ch)
308                 return container_of(ch, struct rsi, h);
309         else
310                 return NULL;
311 }
312
313
314 /*
315  * The rpcsec_context cache is used to store a context that is
316  * used in data exchange.
317  * The key is a context handle. The content is:
318  *  uid, gidlist, mechanism, service-set, mech-specific-data
319  */
320
321 #define RSC_HASHBITS    10
322 #define RSC_HASHMAX     (1<<RSC_HASHBITS)
323 #define RSC_HASHMASK    (RSC_HASHMAX-1)
324
325 #define GSS_SEQ_WIN     128
326
327 struct gss_svc_seq_data {
328         /* highest seq number seen so far: */
329         int                     sd_max;
330         /* for i such that sd_max-GSS_SEQ_WIN < i <= sd_max, the i-th bit of
331          * sd_win is nonzero iff sequence number i has been seen already: */
332         unsigned long           sd_win[GSS_SEQ_WIN/BITS_PER_LONG];
333         spinlock_t              sd_lock;
334 };
335
336 struct rsc {
337         struct cache_head       h;
338         struct xdr_netobj       handle;
339         struct svc_cred         cred;
340         struct gss_svc_seq_data seqdata;
341         struct gss_ctx          *mechctx;
342 };
343
344 static struct cache_head *rsc_table[RSC_HASHMAX];
345 static struct cache_detail rsc_cache;
346 static struct rsc *rsc_update(struct rsc *new, struct rsc *old);
347 static struct rsc *rsc_lookup(struct rsc *item);
348
349 static void rsc_free(struct rsc *rsci)
350 {
351         kfree(rsci->handle.data);
352         if (rsci->mechctx)
353                 gss_delete_sec_context(&rsci->mechctx);
354         if (rsci->cred.cr_group_info)
355                 put_group_info(rsci->cred.cr_group_info);
356 }
357
358 static void rsc_put(struct kref *ref)
359 {
360         struct rsc *rsci = container_of(ref, struct rsc, h.ref);
361
362         rsc_free(rsci);
363         kfree(rsci);
364 }
365
366 static inline int
367 rsc_hash(struct rsc *rsci)
368 {
369         return hash_mem(rsci->handle.data, rsci->handle.len, RSC_HASHBITS);
370 }
371
372 static int
373 rsc_match(struct cache_head *a, struct cache_head *b)
374 {
375         struct rsc *new = container_of(a, struct rsc, h);
376         struct rsc *tmp = container_of(b, struct rsc, h);
377
378         return netobj_equal(&new->handle, &tmp->handle);
379 }
380
381 static void
382 rsc_init(struct cache_head *cnew, struct cache_head *ctmp)
383 {
384         struct rsc *new = container_of(cnew, struct rsc, h);
385         struct rsc *tmp = container_of(ctmp, struct rsc, h);
386
387         new->handle.len = tmp->handle.len;
388         tmp->handle.len = 0;
389         new->handle.data = tmp->handle.data;
390         tmp->handle.data = NULL;
391         new->mechctx = NULL;
392         new->cred.cr_group_info = NULL;
393 }
394
395 static void
396 update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
397 {
398         struct rsc *new = container_of(cnew, struct rsc, h);
399         struct rsc *tmp = container_of(ctmp, struct rsc, h);
400
401         new->mechctx = tmp->mechctx;
402         tmp->mechctx = NULL;
403         memset(&new->seqdata, 0, sizeof(new->seqdata));
404         spin_lock_init(&new->seqdata.sd_lock);
405         new->cred = tmp->cred;
406         tmp->cred.cr_group_info = NULL;
407 }
408
409 static struct cache_head *
410 rsc_alloc(void)
411 {
412         struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
413         if (rsci)
414                 return &rsci->h;
415         else
416                 return NULL;
417 }
418
419 static int rsc_parse(struct cache_detail *cd,
420                      char *mesg, int mlen)
421 {
422         /* contexthandle expiry [ uid gid N <n gids> mechname ...mechdata... ] */
423         char *buf = mesg;
424         int len, rv;
425         struct rsc rsci, *rscp = NULL;
426         time_t expiry;
427         int status = -EINVAL;
428
429         memset(&rsci, 0, sizeof(rsci));
430         /* context handle */
431         len = qword_get(&mesg, buf, mlen);
432         if (len < 0) goto out;
433         status = -ENOMEM;
434         if (dup_to_netobj(&rsci.handle, buf, len))
435                 goto out;
436
437         rsci.h.flags = 0;
438         /* expiry */
439         expiry = get_expiry(&mesg);
440         status = -EINVAL;
441         if (expiry == 0)
442                 goto out;
443
444         rscp = rsc_lookup(&rsci);
445         if (!rscp)
446                 goto out;
447
448         /* uid, or NEGATIVE */
449         rv = get_int(&mesg, &rsci.cred.cr_uid);
450         if (rv == -EINVAL)
451                 goto out;
452         if (rv == -ENOENT)
453                 set_bit(CACHE_NEGATIVE, &rsci.h.flags);
454         else {
455                 int N, i;
456                 struct gss_api_mech *gm;
457
458                 /* gid */
459                 if (get_int(&mesg, &rsci.cred.cr_gid))
460                         goto out;
461
462                 /* number of additional gid's */
463                 if (get_int(&mesg, &N))
464                         goto out;
465                 status = -ENOMEM;
466                 rsci.cred.cr_group_info = groups_alloc(N);
467                 if (rsci.cred.cr_group_info == NULL)
468                         goto out;
469
470                 /* gid's */
471                 status = -EINVAL;
472                 for (i=0; i<N; i++) {
473                         gid_t gid;
474                         if (get_int(&mesg, &gid))
475                                 goto out;
476                         GROUP_AT(rsci.cred.cr_group_info, i) = gid;
477                 }
478
479                 /* mech name */
480                 len = qword_get(&mesg, buf, mlen);
481                 if (len < 0)
482                         goto out;
483                 gm = gss_mech_get_by_name(buf);
484                 status = -EOPNOTSUPP;
485                 if (!gm)
486                         goto out;
487
488                 status = -EINVAL;
489                 /* mech-specific data: */
490                 len = qword_get(&mesg, buf, mlen);
491                 if (len < 0) {
492                         gss_mech_put(gm);
493                         goto out;
494                 }
495                 status = gss_import_sec_context(buf, len, gm, &rsci.mechctx);
496                 if (status) {
497                         gss_mech_put(gm);
498                         goto out;
499                 }
500                 gss_mech_put(gm);
501         }
502         rsci.h.expiry_time = expiry;
503         rscp = rsc_update(&rsci, rscp);
504         status = 0;
505 out:
506         rsc_free(&rsci);
507         if (rscp)
508                 cache_put(&rscp->h, &rsc_cache);
509         else
510                 status = -ENOMEM;
511         return status;
512 }
513
514 static struct cache_detail rsc_cache = {
515         .owner          = THIS_MODULE,
516         .hash_size      = RSC_HASHMAX,
517         .hash_table     = rsc_table,
518         .name           = "auth.rpcsec.context",
519         .cache_put      = rsc_put,
520         .cache_parse    = rsc_parse,
521         .match          = rsc_match,
522         .init           = rsc_init,
523         .update         = update_rsc,
524         .alloc          = rsc_alloc,
525 };
526
527 static struct rsc *rsc_lookup(struct rsc *item)
528 {
529         struct cache_head *ch;
530         int hash = rsc_hash(item);
531
532         ch = sunrpc_cache_lookup(&rsc_cache, &item->h, hash);
533         if (ch)
534                 return container_of(ch, struct rsc, h);
535         else
536                 return NULL;
537 }
538
539 static struct rsc *rsc_update(struct rsc *new, struct rsc *old)
540 {
541         struct cache_head *ch;
542         int hash = rsc_hash(new);
543
544         ch = sunrpc_cache_update(&rsc_cache, &new->h,
545                                  &old->h, hash);
546         if (ch)
547                 return container_of(ch, struct rsc, h);
548         else
549                 return NULL;
550 }
551
552
553 static struct rsc *
554 gss_svc_searchbyctx(struct xdr_netobj *handle)
555 {
556         struct rsc rsci;
557         struct rsc *found;
558
559         memset(&rsci, 0, sizeof(rsci));
560         if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
561                 return NULL;
562         found = rsc_lookup(&rsci);
563         rsc_free(&rsci);
564         if (!found)
565                 return NULL;
566         if (cache_check(&rsc_cache, &found->h, NULL))
567                 return NULL;
568         return found;
569 }
570
571 /* Implements sequence number algorithm as specified in RFC 2203. */
572 static int
573 gss_check_seq_num(struct rsc *rsci, int seq_num)
574 {
575         struct gss_svc_seq_data *sd = &rsci->seqdata;
576
577         spin_lock(&sd->sd_lock);
578         if (seq_num > sd->sd_max) {
579                 if (seq_num >= sd->sd_max + GSS_SEQ_WIN) {
580                         memset(sd->sd_win,0,sizeof(sd->sd_win));
581                         sd->sd_max = seq_num;
582                 } else while (sd->sd_max < seq_num) {
583                         sd->sd_max++;
584                         __clear_bit(sd->sd_max % GSS_SEQ_WIN, sd->sd_win);
585                 }
586                 __set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win);
587                 goto ok;
588         } else if (seq_num <= sd->sd_max - GSS_SEQ_WIN) {
589                 goto drop;
590         }
591         /* sd_max - GSS_SEQ_WIN < seq_num <= sd_max */
592         if (__test_and_set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win))
593                 goto drop;
594 ok:
595         spin_unlock(&sd->sd_lock);
596         return 1;
597 drop:
598         spin_unlock(&sd->sd_lock);
599         return 0;
600 }
601
602 static inline u32 round_up_to_quad(u32 i)
603 {
604         return (i + 3 ) & ~3;
605 }
606
607 static inline int
608 svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
609 {
610         int l;
611
612         if (argv->iov_len < 4)
613                 return -1;
614         o->len = ntohl(svc_getu32(argv));
615         l = round_up_to_quad(o->len);
616         if (argv->iov_len < l)
617                 return -1;
618         o->data = argv->iov_base;
619         argv->iov_base += l;
620         argv->iov_len -= l;
621         return 0;
622 }
623
624 static inline int
625 svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
626 {
627         u32 *p;
628
629         if (resv->iov_len + 4 > PAGE_SIZE)
630                 return -1;
631         svc_putu32(resv, htonl(o->len));
632         p = resv->iov_base + resv->iov_len;
633         resv->iov_len += round_up_to_quad(o->len);
634         if (resv->iov_len > PAGE_SIZE)
635                 return -1;
636         memcpy(p, o->data, o->len);
637         memset((u8 *)p + o->len, 0, round_up_to_quad(o->len) - o->len);
638         return 0;
639 }
640
641 /* Verify the checksum on the header and return SVC_OK on success.
642  * Otherwise, return SVC_DROP (in the case of a bad sequence number)
643  * or return SVC_DENIED and indicate error in authp.
644  */
645 static int
646 gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
647                   u32 *rpcstart, struct rpc_gss_wire_cred *gc, u32 *authp)
648 {
649         struct gss_ctx          *ctx_id = rsci->mechctx;
650         struct xdr_buf          rpchdr;
651         struct xdr_netobj       checksum;
652         u32                     flavor = 0;
653         struct kvec             *argv = &rqstp->rq_arg.head[0];
654         struct kvec             iov;
655
656         /* data to compute the checksum over: */
657         iov.iov_base = rpcstart;
658         iov.iov_len = (u8 *)argv->iov_base - (u8 *)rpcstart;
659         xdr_buf_from_iov(&iov, &rpchdr);
660
661         *authp = rpc_autherr_badverf;
662         if (argv->iov_len < 4)
663                 return SVC_DENIED;
664         flavor = ntohl(svc_getu32(argv));
665         if (flavor != RPC_AUTH_GSS)
666                 return SVC_DENIED;
667         if (svc_safe_getnetobj(argv, &checksum))
668                 return SVC_DENIED;
669
670         if (rqstp->rq_deferred) /* skip verification of revisited request */
671                 return SVC_OK;
672         if (gss_verify_mic(ctx_id, &rpchdr, &checksum) != GSS_S_COMPLETE) {
673                 *authp = rpcsec_gsserr_credproblem;
674                 return SVC_DENIED;
675         }
676
677         if (gc->gc_seq > MAXSEQ) {
678                 dprintk("RPC:      svcauth_gss: discarding request with large sequence number %d\n",
679                                 gc->gc_seq);
680                 *authp = rpcsec_gsserr_ctxproblem;
681                 return SVC_DENIED;
682         }
683         if (!gss_check_seq_num(rsci, gc->gc_seq)) {
684                 dprintk("RPC:      svcauth_gss: discarding request with old sequence number %d\n",
685                                 gc->gc_seq);
686                 return SVC_DROP;
687         }
688         return SVC_OK;
689 }
690
691 static int
692 gss_write_null_verf(struct svc_rqst *rqstp)
693 {
694         u32     *p;
695
696         svc_putu32(rqstp->rq_res.head, htonl(RPC_AUTH_NULL));
697         p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
698         /* don't really need to check if head->iov_len > PAGE_SIZE ... */
699         *p++ = 0;
700         if (!xdr_ressize_check(rqstp, p))
701                 return -1;
702         return 0;
703 }
704
705 static int
706 gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
707 {
708         u32                     xdr_seq;
709         u32                     maj_stat;
710         struct xdr_buf          verf_data;
711         struct xdr_netobj       mic;
712         u32                     *p;
713         struct kvec             iov;
714
715         svc_putu32(rqstp->rq_res.head, htonl(RPC_AUTH_GSS));
716         xdr_seq = htonl(seq);
717
718         iov.iov_base = &xdr_seq;
719         iov.iov_len = sizeof(xdr_seq);
720         xdr_buf_from_iov(&iov, &verf_data);
721         p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
722         mic.data = (u8 *)(p + 1);
723         maj_stat = gss_get_mic(ctx_id, &verf_data, &mic);
724         if (maj_stat != GSS_S_COMPLETE)
725                 return -1;
726         *p++ = htonl(mic.len);
727         memset((u8 *)p + mic.len, 0, round_up_to_quad(mic.len) - mic.len);
728         p += XDR_QUADLEN(mic.len);
729         if (!xdr_ressize_check(rqstp, p))
730                 return -1;
731         return 0;
732 }
733
734 struct gss_domain {
735         struct auth_domain      h;
736         u32                     pseudoflavor;
737 };
738
739 static struct auth_domain *
740 find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
741 {
742         char *name;
743
744         name = gss_service_to_auth_domain_name(ctx->mech_type, svc);
745         if (!name)
746                 return NULL;
747         return auth_domain_find(name);
748 }
749
750 static struct auth_ops svcauthops_gss;
751
752 int
753 svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
754 {
755         struct gss_domain       *new;
756         struct auth_domain      *test;
757         int                     stat = -ENOMEM;
758
759         new = kmalloc(sizeof(*new), GFP_KERNEL);
760         if (!new)
761                 goto out;
762         kref_init(&new->h.ref);
763         new->h.name = kmalloc(strlen(name) + 1, GFP_KERNEL);
764         if (!new->h.name)
765                 goto out_free_dom;
766         strcpy(new->h.name, name);
767         new->h.flavour = &svcauthops_gss;
768         new->pseudoflavor = pseudoflavor;
769
770         test = auth_domain_lookup(name, &new->h);
771         if (test != &new->h) { /* XXX Duplicate registration? */
772                 auth_domain_put(&new->h);
773                 /* dangling ref-count... */
774                 goto out;
775         }
776         return 0;
777
778 out_free_dom:
779         kfree(new);
780 out:
781         return stat;
782 }
783
784 EXPORT_SYMBOL(svcauth_gss_register_pseudoflavor);
785
786 static inline int
787 read_u32_from_xdr_buf(struct xdr_buf *buf, int base, u32 *obj)
788 {
789         u32     raw;
790         int     status;
791
792         status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
793         if (status)
794                 return status;
795         *obj = ntohl(raw);
796         return 0;
797 }
798
799 /* It would be nice if this bit of code could be shared with the client.
800  * Obstacles:
801  *      The client shouldn't malloc(), would have to pass in own memory.
802  *      The server uses base of head iovec as read pointer, while the
803  *      client uses separate pointer. */
804 static int
805 unwrap_integ_data(struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
806 {
807         int stat = -EINVAL;
808         u32 integ_len, maj_stat;
809         struct xdr_netobj mic;
810         struct xdr_buf integ_buf;
811
812         integ_len = ntohl(svc_getu32(&buf->head[0]));
813         if (integ_len & 3)
814                 goto out;
815         if (integ_len > buf->len)
816                 goto out;
817         if (xdr_buf_subsegment(buf, &integ_buf, 0, integ_len))
818                 BUG();
819         /* copy out mic... */
820         if (read_u32_from_xdr_buf(buf, integ_len, &mic.len))
821                 BUG();
822         if (mic.len > RPC_MAX_AUTH_SIZE)
823                 goto out;
824         mic.data = kmalloc(mic.len, GFP_KERNEL);
825         if (!mic.data)
826                 goto out;
827         if (read_bytes_from_xdr_buf(buf, integ_len + 4, mic.data, mic.len))
828                 goto out;
829         maj_stat = gss_verify_mic(ctx, &integ_buf, &mic);
830         if (maj_stat != GSS_S_COMPLETE)
831                 goto out;
832         if (ntohl(svc_getu32(&buf->head[0])) != seq)
833                 goto out;
834         stat = 0;
835 out:
836         return stat;
837 }
838
839 struct gss_svc_data {
840         /* decoded gss client cred: */
841         struct rpc_gss_wire_cred        clcred;
842         /* pointer to the beginning of the procedure-specific results,
843          * which may be encrypted/checksummed in svcauth_gss_release: */
844         u32                             *body_start;
845         struct rsc                      *rsci;
846 };
847
848 static int
849 svcauth_gss_set_client(struct svc_rqst *rqstp)
850 {
851         struct gss_svc_data *svcdata = rqstp->rq_auth_data;
852         struct rsc *rsci = svcdata->rsci;
853         struct rpc_gss_wire_cred *gc = &svcdata->clcred;
854
855         rqstp->rq_client = find_gss_auth_domain(rsci->mechctx, gc->gc_svc);
856         if (rqstp->rq_client == NULL)
857                 return SVC_DENIED;
858         return SVC_OK;
859 }
860
861 static inline int
862 gss_write_init_verf(struct svc_rqst *rqstp, struct rsi *rsip)
863 {
864         struct rsc *rsci;
865
866         if (rsip->major_status != GSS_S_COMPLETE)
867                 return gss_write_null_verf(rqstp);
868         rsci = gss_svc_searchbyctx(&rsip->out_handle);
869         if (rsci == NULL) {
870                 rsip->major_status = GSS_S_NO_CONTEXT;
871                 return gss_write_null_verf(rqstp);
872         }
873         return gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
874 }
875
876 /*
877  * Accept an rpcsec packet.
878  * If context establishment, punt to user space
879  * If data exchange, verify/decrypt
880  * If context destruction, handle here
881  * In the context establishment and destruction case we encode
882  * response here and return SVC_COMPLETE.
883  */
884 static int
885 svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
886 {
887         struct kvec     *argv = &rqstp->rq_arg.head[0];
888         struct kvec     *resv = &rqstp->rq_res.head[0];
889         u32             crlen;
890         struct xdr_netobj tmpobj;
891         struct gss_svc_data *svcdata = rqstp->rq_auth_data;
892         struct rpc_gss_wire_cred *gc;
893         struct rsc      *rsci = NULL;
894         struct rsi      *rsip, rsikey;
895         u32             *rpcstart;
896         u32             *reject_stat = resv->iov_base + resv->iov_len;
897         int             ret;
898
899         dprintk("RPC:      svcauth_gss: argv->iov_len = %zd\n",argv->iov_len);
900
901         *authp = rpc_autherr_badcred;
902         if (!svcdata)
903                 svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
904         if (!svcdata)
905                 goto auth_err;
906         rqstp->rq_auth_data = svcdata;
907         svcdata->body_start = NULL;
908         svcdata->rsci = NULL;
909         gc = &svcdata->clcred;
910
911         /* start of rpc packet is 7 u32's back from here:
912          * xid direction rpcversion prog vers proc flavour
913          */
914         rpcstart = argv->iov_base;
915         rpcstart -= 7;
916
917         /* credential is:
918          *   version(==1), proc(0,1,2,3), seq, service (1,2,3), handle
919          * at least 5 u32s, and is preceeded by length, so that makes 6.
920          */
921
922         if (argv->iov_len < 5 * 4)
923                 goto auth_err;
924         crlen = ntohl(svc_getu32(argv));
925         if (ntohl(svc_getu32(argv)) != RPC_GSS_VERSION)
926                 goto auth_err;
927         gc->gc_proc = ntohl(svc_getu32(argv));
928         gc->gc_seq = ntohl(svc_getu32(argv));
929         gc->gc_svc = ntohl(svc_getu32(argv));
930         if (svc_safe_getnetobj(argv, &gc->gc_ctx))
931                 goto auth_err;
932         if (crlen != round_up_to_quad(gc->gc_ctx.len) + 5 * 4)
933                 goto auth_err;
934
935         if ((gc->gc_proc != RPC_GSS_PROC_DATA) && (rqstp->rq_proc != 0))
936                 goto auth_err;
937
938         /*
939          * We've successfully parsed the credential. Let's check out the
940          * verifier.  An AUTH_NULL verifier is allowed (and required) for
941          * INIT and CONTINUE_INIT requests. AUTH_RPCSEC_GSS is required for
942          * PROC_DATA and PROC_DESTROY.
943          *
944          * AUTH_NULL verifier is 0 (AUTH_NULL), 0 (length).
945          * AUTH_RPCSEC_GSS verifier is:
946          *   6 (AUTH_RPCSEC_GSS), length, checksum.
947          * checksum is calculated over rpcheader from xid up to here.
948          */
949         *authp = rpc_autherr_badverf;
950         switch (gc->gc_proc) {
951         case RPC_GSS_PROC_INIT:
952         case RPC_GSS_PROC_CONTINUE_INIT:
953                 if (argv->iov_len < 2 * 4)
954                         goto auth_err;
955                 if (ntohl(svc_getu32(argv)) != RPC_AUTH_NULL)
956                         goto auth_err;
957                 if (ntohl(svc_getu32(argv)) != 0)
958                         goto auth_err;
959                 break;
960         case RPC_GSS_PROC_DATA:
961         case RPC_GSS_PROC_DESTROY:
962                 *authp = rpcsec_gsserr_credproblem;
963                 rsci = gss_svc_searchbyctx(&gc->gc_ctx);
964                 if (!rsci)
965                         goto auth_err;
966                 switch (gss_verify_header(rqstp, rsci, rpcstart, gc, authp)) {
967                 case SVC_OK:
968                         break;
969                 case SVC_DENIED:
970                         goto auth_err;
971                 case SVC_DROP:
972                         goto drop;
973                 }
974                 break;
975         default:
976                 *authp = rpc_autherr_rejectedcred;
977                 goto auth_err;
978         }
979
980         /* now act upon the command: */
981         switch (gc->gc_proc) {
982         case RPC_GSS_PROC_INIT:
983         case RPC_GSS_PROC_CONTINUE_INIT:
984                 *authp = rpc_autherr_badcred;
985                 if (gc->gc_proc == RPC_GSS_PROC_INIT && gc->gc_ctx.len != 0)
986                         goto auth_err;
987                 memset(&rsikey, 0, sizeof(rsikey));
988                 if (dup_netobj(&rsikey.in_handle, &gc->gc_ctx))
989                         goto drop;
990                 *authp = rpc_autherr_badverf;
991                 if (svc_safe_getnetobj(argv, &tmpobj)) {
992                         kfree(rsikey.in_handle.data);
993                         goto auth_err;
994                 }
995                 if (dup_netobj(&rsikey.in_token, &tmpobj)) {
996                         kfree(rsikey.in_handle.data);
997                         goto drop;
998                 }
999
1000                 rsip = rsi_lookup(&rsikey);
1001                 rsi_free(&rsikey);
1002                 if (!rsip) {
1003                         goto drop;
1004                 }
1005                 switch(cache_check(&rsi_cache, &rsip->h, &rqstp->rq_chandle)) {
1006                 case -EAGAIN:
1007                         goto drop;
1008                 case -ENOENT:
1009                         goto drop;
1010                 case 0:
1011                         if (gss_write_init_verf(rqstp, rsip))
1012                                 goto drop;
1013                         if (resv->iov_len + 4 > PAGE_SIZE)
1014                                 goto drop;
1015                         svc_putu32(resv, rpc_success);
1016                         if (svc_safe_putnetobj(resv, &rsip->out_handle))
1017                                 goto drop;
1018                         if (resv->iov_len + 3 * 4 > PAGE_SIZE)
1019                                 goto drop;
1020                         svc_putu32(resv, htonl(rsip->major_status));
1021                         svc_putu32(resv, htonl(rsip->minor_status));
1022                         svc_putu32(resv, htonl(GSS_SEQ_WIN));
1023                         if (svc_safe_putnetobj(resv, &rsip->out_token))
1024                                 goto drop;
1025                         rqstp->rq_client = NULL;
1026                 }
1027                 goto complete;
1028         case RPC_GSS_PROC_DESTROY:
1029                 set_bit(CACHE_NEGATIVE, &rsci->h.flags);
1030                 if (resv->iov_len + 4 > PAGE_SIZE)
1031                         goto drop;
1032                 svc_putu32(resv, rpc_success);
1033                 goto complete;
1034         case RPC_GSS_PROC_DATA:
1035                 *authp = rpcsec_gsserr_ctxproblem;
1036                 if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1037                         goto auth_err;
1038                 rqstp->rq_cred = rsci->cred;
1039                 get_group_info(rsci->cred.cr_group_info);
1040                 *authp = rpc_autherr_badcred;
1041                 switch (gc->gc_svc) {
1042                 case RPC_GSS_SVC_NONE:
1043                         break;
1044                 case RPC_GSS_SVC_INTEGRITY:
1045                         if (unwrap_integ_data(&rqstp->rq_arg,
1046                                         gc->gc_seq, rsci->mechctx))
1047                                 goto auth_err;
1048                         /* placeholders for length and seq. number: */
1049                         svcdata->body_start = resv->iov_base + resv->iov_len;
1050                         svc_putu32(resv, 0);
1051                         svc_putu32(resv, 0);
1052                         break;
1053                 case RPC_GSS_SVC_PRIVACY:
1054                         /* currently unsupported */
1055                 default:
1056                         goto auth_err;
1057                 }
1058                 svcdata->rsci = rsci;
1059                 cache_get(&rsci->h);
1060                 ret = SVC_OK;
1061                 goto out;
1062         }
1063 auth_err:
1064         /* Restore write pointer to original value: */
1065         xdr_ressize_check(rqstp, reject_stat);
1066         ret = SVC_DENIED;
1067         goto out;
1068 complete:
1069         ret = SVC_COMPLETE;
1070         goto out;
1071 drop:
1072         ret = SVC_DROP;
1073 out:
1074         if (rsci)
1075                 cache_put(&rsci->h, &rsc_cache);
1076         return ret;
1077 }
1078
1079 static int
1080 svcauth_gss_release(struct svc_rqst *rqstp)
1081 {
1082         struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1083         struct rpc_gss_wire_cred *gc = &gsd->clcred;
1084         struct xdr_buf *resbuf = &rqstp->rq_res;
1085         struct xdr_buf integ_buf;
1086         struct xdr_netobj mic;
1087         struct kvec *resv;
1088         u32 *p;
1089         int integ_offset, integ_len;
1090         int stat = -EINVAL;
1091
1092         if (gc->gc_proc != RPC_GSS_PROC_DATA)
1093                 goto out;
1094         /* Release can be called twice, but we only wrap once. */
1095         if (gsd->body_start == NULL)
1096                 goto out;
1097         /* normally not set till svc_send, but we need it here: */
1098         resbuf->len = resbuf->head[0].iov_len
1099                 + resbuf->page_len + resbuf->tail[0].iov_len;
1100         switch (gc->gc_svc) {
1101         case RPC_GSS_SVC_NONE:
1102                 break;
1103         case RPC_GSS_SVC_INTEGRITY:
1104                 p = gsd->body_start;
1105                 gsd->body_start = NULL;
1106                 /* move accept_stat to right place: */
1107                 memcpy(p, p + 2, 4);
1108                 /* don't wrap in failure case: */
1109                 /* Note: counting on not getting here if call was not even
1110                  * accepted! */
1111                 if (*p != rpc_success) {
1112                         resbuf->head[0].iov_len -= 2 * 4;
1113                         goto out;
1114                 }
1115                 p++;
1116                 integ_offset = (u8 *)(p + 1) - (u8 *)resbuf->head[0].iov_base;
1117                 integ_len = resbuf->len - integ_offset;
1118                 BUG_ON(integ_len % 4);
1119                 *p++ = htonl(integ_len);
1120                 *p++ = htonl(gc->gc_seq);
1121                 if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset,
1122                                         integ_len))
1123                         BUG();
1124                 if (resbuf->page_len == 0
1125                         && resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE
1126                                 < PAGE_SIZE) {
1127                         BUG_ON(resbuf->tail[0].iov_len);
1128                         /* Use head for everything */
1129                         resv = &resbuf->head[0];
1130                 } else if (resbuf->tail[0].iov_base == NULL) {
1131                         if (resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE
1132                                         > PAGE_SIZE)
1133                                 goto out_err;
1134                         resbuf->tail[0].iov_base =
1135                                 resbuf->head[0].iov_base
1136                                 + resbuf->head[0].iov_len;
1137                         resbuf->tail[0].iov_len = 0;
1138                         rqstp->rq_restailpage = 0;
1139                         resv = &resbuf->tail[0];
1140                 } else {
1141                         resv = &resbuf->tail[0];
1142                 }
1143                 mic.data = (u8 *)resv->iov_base + resv->iov_len + 4;
1144                 if (gss_get_mic(gsd->rsci->mechctx, &integ_buf, &mic))
1145                         goto out_err;
1146                 svc_putu32(resv, htonl(mic.len));
1147                 memset(mic.data + mic.len, 0,
1148                                 round_up_to_quad(mic.len) - mic.len);
1149                 resv->iov_len += XDR_QUADLEN(mic.len) << 2;
1150                 /* not strictly required: */
1151                 resbuf->len += XDR_QUADLEN(mic.len) << 2;
1152                 BUG_ON(resv->iov_len > PAGE_SIZE);
1153                 break;
1154         case RPC_GSS_SVC_PRIVACY:
1155         default:
1156                 goto out_err;
1157         }
1158
1159 out:
1160         stat = 0;
1161 out_err:
1162         if (rqstp->rq_client)
1163                 auth_domain_put(rqstp->rq_client);
1164         rqstp->rq_client = NULL;
1165         if (rqstp->rq_cred.cr_group_info)
1166                 put_group_info(rqstp->rq_cred.cr_group_info);
1167         rqstp->rq_cred.cr_group_info = NULL;
1168         if (gsd->rsci)
1169                 cache_put(&gsd->rsci->h, &rsc_cache);
1170         gsd->rsci = NULL;
1171
1172         return stat;
1173 }
1174
1175 static void
1176 svcauth_gss_domain_release(struct auth_domain *dom)
1177 {
1178         struct gss_domain *gd = container_of(dom, struct gss_domain, h);
1179
1180         kfree(dom->name);
1181         kfree(gd);
1182 }
1183
1184 static struct auth_ops svcauthops_gss = {
1185         .name           = "rpcsec_gss",
1186         .owner          = THIS_MODULE,
1187         .flavour        = RPC_AUTH_GSS,
1188         .accept         = svcauth_gss_accept,
1189         .release        = svcauth_gss_release,
1190         .domain_release = svcauth_gss_domain_release,
1191         .set_client     = svcauth_gss_set_client,
1192 };
1193
1194 int
1195 gss_svc_init(void)
1196 {
1197         int rv = svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
1198         if (rv == 0) {
1199                 cache_register(&rsc_cache);
1200                 cache_register(&rsi_cache);
1201         }
1202         return rv;
1203 }
1204
1205 void
1206 gss_svc_shutdown(void)
1207 {
1208         if (cache_unregister(&rsc_cache))
1209                 printk(KERN_ERR "auth_rpcgss: failed to unregister rsc cache\n");
1210         if (cache_unregister(&rsi_cache))
1211                 printk(KERN_ERR "auth_rpcgss: failed to unregister rsi cache\n");
1212         svc_auth_unregister(RPC_AUTH_GSS);
1213 }