blob: 29b4ba93ab3cb795fb8dd307f6e248bfcc3a1495 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/types.h>
42#include <linux/module.h>
43#include <linux/pagemap.h>
Eric W. Biedermanae2975b2011-11-14 15:56:38 -080044#include <linux/user_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include <linux/sunrpc/auth_gss.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/sunrpc/gss_err.h>
48#include <linux/sunrpc/svcauth.h>
49#include <linux/sunrpc/svcauth_gss.h>
50#include <linux/sunrpc/cache.h>
Simo Sorce030d7942012-05-25 18:09:56 -040051#include "gss_rpc_upcall.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +040053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#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
66static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74struct rsi {
75 struct cache_head h;
76 struct xdr_netobj in_handle, in_token;
77 struct xdr_netobj out_handle, out_token;
78 int major_status, minor_status;
79};
80
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +040081static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old);
82static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84static 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
NeilBrownbaab9352006-03-27 01:15:09 -080092static void rsi_put(struct kref *ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
NeilBrownbaab9352006-03-27 01:15:09 -080094 struct rsi *rsii = container_of(ref, struct rsi, h.ref);
95 rsi_free(rsii);
96 kfree(rsii);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
99static 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
NeilBrownd4d11ea2006-03-27 01:15:04 -0800105static int rsi_match(struct cache_head *a, struct cache_head *b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
NeilBrownd4d11ea2006-03-27 01:15:04 -0800107 struct rsi *item = container_of(a, struct rsi, h);
108 struct rsi *tmp = container_of(b, struct rsi, h);
Joe Perchesf64f9e72009-11-29 16:55:45 -0800109 return netobj_equal(&item->in_handle, &tmp->in_handle) &&
110 netobj_equal(&item->in_token, &tmp->in_token);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
113static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len)
114{
115 dst->len = len;
Arnaldo Carvalho de Meloe69062b2006-11-21 01:21:34 -0200116 dst->data = (len ? kmemdup(src, len, GFP_KERNEL) : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 if (len && !dst->data)
118 return -ENOMEM;
119 return 0;
120}
121
122static 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
NeilBrownd4d11ea2006-03-27 01:15:04 -0800127static void rsi_init(struct cache_head *cnew, struct cache_head *citem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
NeilBrownd4d11ea2006-03-27 01:15:04 -0800129 struct rsi *new = container_of(cnew, struct rsi, h);
130 struct rsi *item = container_of(citem, struct rsi, h);
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 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
NeilBrownd4d11ea2006-03-27 01:15:04 -0800146static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
NeilBrownd4d11ea2006-03-27 01:15:04 -0800148 struct rsi *new = container_of(cnew, struct rsi, h);
149 struct rsi *item = container_of(citem, struct rsi, h);
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 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
NeilBrownd4d11ea2006-03-27 01:15:04 -0800165static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174static void rsi_request(struct cache_detail *cd,
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800175 struct cache_head *h,
176 char **bpp, int *blen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185static int rsi_parse(struct cache_detail *cd,
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800186 char *mesg, int mlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
188 /* context token expiry major minor context token */
189 char *buf = mesg;
190 char *ep;
191 int len;
192 struct rsi rsii, *rsip = NULL;
193 time_t expiry;
194 int status = -EINVAL;
195
196 memset(&rsii, 0, sizeof(rsii));
197 /* handle */
198 len = qword_get(&mesg, buf, mlen);
199 if (len < 0)
200 goto out;
201 status = -ENOMEM;
202 if (dup_to_netobj(&rsii.in_handle, buf, len))
203 goto out;
204
205 /* token */
206 len = qword_get(&mesg, buf, mlen);
207 status = -EINVAL;
208 if (len < 0)
209 goto out;
210 status = -ENOMEM;
211 if (dup_to_netobj(&rsii.in_token, buf, len))
212 goto out;
213
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400214 rsip = rsi_lookup(cd, &rsii);
NeilBrownd4d11ea2006-03-27 01:15:04 -0800215 if (!rsip)
216 goto out;
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 rsii.h.flags = 0;
219 /* expiry */
220 expiry = get_expiry(&mesg);
221 status = -EINVAL;
222 if (expiry == 0)
223 goto out;
224
225 /* major/minor */
226 len = qword_get(&mesg, buf, mlen);
J. Bruce Fieldsb39c18f2008-01-06 21:32:37 -0500227 if (len <= 0)
228 goto out;
229 rsii.major_status = simple_strtoul(buf, &ep, 10);
230 if (*ep)
231 goto out;
232 len = qword_get(&mesg, buf, mlen);
233 if (len <= 0)
234 goto out;
235 rsii.minor_status = simple_strtoul(buf, &ep, 10);
236 if (*ep)
237 goto out;
238
239 /* out_handle */
240 len = qword_get(&mesg, buf, mlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (len < 0)
242 goto out;
J. Bruce Fieldsb39c18f2008-01-06 21:32:37 -0500243 status = -ENOMEM;
244 if (dup_to_netobj(&rsii.out_handle, buf, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
J. Bruce Fieldsb39c18f2008-01-06 21:32:37 -0500247 /* out_token */
248 len = qword_get(&mesg, buf, mlen);
249 status = -EINVAL;
250 if (len < 0)
251 goto out;
252 status = -ENOMEM;
253 if (dup_to_netobj(&rsii.out_token, buf, len))
254 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 rsii.h.expiry_time = expiry;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400256 rsip = rsi_update(cd, &rsii, rsip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 status = 0;
258out:
259 rsi_free(&rsii);
260 if (rsip)
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400261 cache_put(&rsip->h, cd);
NeilBrownd4d11ea2006-03-27 01:15:04 -0800262 else
263 status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 return status;
265}
266
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400267static struct cache_detail rsi_cache_template = {
Bruce Allanf35279d2005-09-06 15:17:08 -0700268 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 .hash_size = RSI_HASHMAX,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 .name = "auth.rpcsec.init",
271 .cache_put = rsi_put,
Stanislav Kinsbursky73fb8472013-02-04 14:02:45 +0300272 .cache_request = rsi_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 .cache_parse = rsi_parse,
NeilBrownd4d11ea2006-03-27 01:15:04 -0800274 .match = rsi_match,
275 .init = rsi_init,
276 .update = update_rsi,
277 .alloc = rsi_alloc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278};
279
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400280static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item)
NeilBrownd4d11ea2006-03-27 01:15:04 -0800281{
282 struct cache_head *ch;
283 int hash = rsi_hash(item);
284
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400285 ch = sunrpc_cache_lookup(cd, &item->h, hash);
NeilBrownd4d11ea2006-03-27 01:15:04 -0800286 if (ch)
287 return container_of(ch, struct rsi, h);
288 else
289 return NULL;
290}
291
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400292static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old)
NeilBrownd4d11ea2006-03-27 01:15:04 -0800293{
294 struct cache_head *ch;
295 int hash = rsi_hash(new);
296
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400297 ch = sunrpc_cache_update(cd, &new->h,
NeilBrownd4d11ea2006-03-27 01:15:04 -0800298 &old->h, hash);
299 if (ch)
300 return container_of(ch, struct rsi, h);
301 else
302 return NULL;
303}
304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306/*
307 * The rpcsec_context cache is used to store a context that is
308 * used in data exchange.
309 * The key is a context handle. The content is:
310 * uid, gidlist, mechanism, service-set, mech-specific-data
311 */
312
313#define RSC_HASHBITS 10
314#define RSC_HASHMAX (1<<RSC_HASHBITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316#define GSS_SEQ_WIN 128
317
318struct gss_svc_seq_data {
319 /* highest seq number seen so far: */
320 int sd_max;
321 /* for i such that sd_max-GSS_SEQ_WIN < i <= sd_max, the i-th bit of
322 * sd_win is nonzero iff sequence number i has been seen already: */
323 unsigned long sd_win[GSS_SEQ_WIN/BITS_PER_LONG];
324 spinlock_t sd_lock;
325};
326
327struct rsc {
328 struct cache_head h;
329 struct xdr_netobj handle;
330 struct svc_cred cred;
331 struct gss_svc_seq_data seqdata;
332 struct gss_ctx *mechctx;
333};
334
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400335static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old);
336static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338static void rsc_free(struct rsc *rsci)
339{
340 kfree(rsci->handle.data);
341 if (rsci->mechctx)
342 gss_delete_sec_context(&rsci->mechctx);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -0400343 free_svc_cred(&rsci->cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344}
345
NeilBrownbaab9352006-03-27 01:15:09 -0800346static void rsc_put(struct kref *ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
NeilBrownbaab9352006-03-27 01:15:09 -0800348 struct rsc *rsci = container_of(ref, struct rsc, h.ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
NeilBrownbaab9352006-03-27 01:15:09 -0800350 rsc_free(rsci);
351 kfree(rsci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352}
353
354static inline int
355rsc_hash(struct rsc *rsci)
356{
357 return hash_mem(rsci->handle.data, rsci->handle.len, RSC_HASHBITS);
358}
359
NeilBrown17f834b2006-03-27 01:15:05 -0800360static int
361rsc_match(struct cache_head *a, struct cache_head *b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
NeilBrown17f834b2006-03-27 01:15:05 -0800363 struct rsc *new = container_of(a, struct rsc, h);
364 struct rsc *tmp = container_of(b, struct rsc, h);
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 return netobj_equal(&new->handle, &tmp->handle);
367}
368
NeilBrown17f834b2006-03-27 01:15:05 -0800369static void
370rsc_init(struct cache_head *cnew, struct cache_head *ctmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
NeilBrown17f834b2006-03-27 01:15:05 -0800372 struct rsc *new = container_of(cnew, struct rsc, h);
373 struct rsc *tmp = container_of(ctmp, struct rsc, h);
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 new->handle.len = tmp->handle.len;
376 tmp->handle.len = 0;
377 new->handle.data = tmp->handle.data;
378 tmp->handle.data = NULL;
379 new->mechctx = NULL;
380 new->cred.cr_group_info = NULL;
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -0400381 new->cred.cr_principal = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
NeilBrown17f834b2006-03-27 01:15:05 -0800384static void
385update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
NeilBrown17f834b2006-03-27 01:15:05 -0800387 struct rsc *new = container_of(cnew, struct rsc, h);
388 struct rsc *tmp = container_of(ctmp, struct rsc, h);
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 new->mechctx = tmp->mechctx;
391 tmp->mechctx = NULL;
392 memset(&new->seqdata, 0, sizeof(new->seqdata));
393 spin_lock_init(&new->seqdata.sd_lock);
394 new->cred = tmp->cred;
395 tmp->cred.cr_group_info = NULL;
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -0400396 new->cred.cr_principal = tmp->cred.cr_principal;
397 tmp->cred.cr_principal = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
NeilBrown17f834b2006-03-27 01:15:05 -0800400static struct cache_head *
401rsc_alloc(void)
402{
403 struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
404 if (rsci)
405 return &rsci->h;
406 else
407 return NULL;
408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410static int rsc_parse(struct cache_detail *cd,
411 char *mesg, int mlen)
412{
413 /* contexthandle expiry [ uid gid N <n gids> mechname ...mechdata... ] */
414 char *buf = mesg;
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800415 int id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 int len, rv;
417 struct rsc rsci, *rscp = NULL;
418 time_t expiry;
419 int status = -EINVAL;
J. Bruce Fields1df0cad2006-06-30 01:56:16 -0700420 struct gss_api_mech *gm = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
422 memset(&rsci, 0, sizeof(rsci));
423 /* context handle */
424 len = qword_get(&mesg, buf, mlen);
425 if (len < 0) goto out;
426 status = -ENOMEM;
427 if (dup_to_netobj(&rsci.handle, buf, len))
428 goto out;
429
430 rsci.h.flags = 0;
431 /* expiry */
432 expiry = get_expiry(&mesg);
433 status = -EINVAL;
434 if (expiry == 0)
435 goto out;
436
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400437 rscp = rsc_lookup(cd, &rsci);
NeilBrown17f834b2006-03-27 01:15:05 -0800438 if (!rscp)
439 goto out;
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /* uid, or NEGATIVE */
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800442 rv = get_int(&mesg, &id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 if (rv == -EINVAL)
444 goto out;
445 if (rv == -ENOENT)
446 set_bit(CACHE_NEGATIVE, &rsci.h.flags);
447 else {
448 int N, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
J. Bruce Fields3c34ae12013-03-04 08:44:01 -0500450 /*
451 * NOTE: we skip uid_valid()/gid_valid() checks here:
452 * instead, * -1 id's are later mapped to the
453 * (export-specific) anonymous id by nfsd_setuser.
454 *
455 * (But supplementary gid's get no such special
456 * treatment so are checked for validity here.)
457 */
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800458 /* uid */
459 rsci.cred.cr_uid = make_kuid(&init_user_ns, id);
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 /* gid */
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800462 if (get_int(&mesg, &id))
463 goto out;
464 rsci.cred.cr_gid = make_kgid(&init_user_ns, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 /* number of additional gid's */
467 if (get_int(&mesg, &N))
468 goto out;
469 status = -ENOMEM;
470 rsci.cred.cr_group_info = groups_alloc(N);
471 if (rsci.cred.cr_group_info == NULL)
472 goto out;
473
474 /* gid's */
475 status = -EINVAL;
476 for (i=0; i<N; i++) {
Eric W. Biedermanae2975b2011-11-14 15:56:38 -0800477 kgid_t kgid;
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800478 if (get_int(&mesg, &id))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 goto out;
Eric W. Biederman683428fae2013-02-02 01:40:53 -0800480 kgid = make_kgid(&init_user_ns, id);
Eric W. Biedermanae2975b2011-11-14 15:56:38 -0800481 if (!gid_valid(kgid))
482 goto out;
483 GROUP_AT(rsci.cred.cr_group_info, i) = kgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 }
485
486 /* mech name */
487 len = qword_get(&mesg, buf, mlen);
488 if (len < 0)
489 goto out;
490 gm = gss_mech_get_by_name(buf);
491 status = -EOPNOTSUPP;
492 if (!gm)
493 goto out;
494
495 status = -EINVAL;
496 /* mech-specific data: */
497 len = qword_get(&mesg, buf, mlen);
J. Bruce Fields1df0cad2006-06-30 01:56:16 -0700498 if (len < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 goto out;
Simo Sorce400f26b2012-05-25 18:09:53 -0400500 status = gss_import_sec_context(buf, len, gm, &rsci.mechctx,
501 NULL, GFP_KERNEL);
J. Bruce Fields1df0cad2006-06-30 01:56:16 -0700502 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 goto out;
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500504
505 /* get client name */
506 len = qword_get(&mesg, buf, mlen);
507 if (len > 0) {
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -0400508 rsci.cred.cr_principal = kstrdup(buf, GFP_KERNEL);
Wei Yongjun1eb6d622013-04-18 10:49:09 +0800509 if (!rsci.cred.cr_principal) {
510 status = -ENOMEM;
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500511 goto out;
Wei Yongjun1eb6d622013-04-18 10:49:09 +0800512 }
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500513 }
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 }
516 rsci.h.expiry_time = expiry;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400517 rscp = rsc_update(cd, &rsci, rscp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 status = 0;
519out:
J. Bruce Fields1df0cad2006-06-30 01:56:16 -0700520 gss_mech_put(gm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 rsc_free(&rsci);
522 if (rscp)
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400523 cache_put(&rscp->h, cd);
NeilBrown17f834b2006-03-27 01:15:05 -0800524 else
525 status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 return status;
527}
528
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400529static struct cache_detail rsc_cache_template = {
Bruce Allanf35279d2005-09-06 15:17:08 -0700530 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 .hash_size = RSC_HASHMAX,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 .name = "auth.rpcsec.context",
533 .cache_put = rsc_put,
534 .cache_parse = rsc_parse,
NeilBrown17f834b2006-03-27 01:15:05 -0800535 .match = rsc_match,
536 .init = rsc_init,
537 .update = update_rsc,
538 .alloc = rsc_alloc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539};
540
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400541static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item)
NeilBrown17f834b2006-03-27 01:15:05 -0800542{
543 struct cache_head *ch;
544 int hash = rsc_hash(item);
545
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400546 ch = sunrpc_cache_lookup(cd, &item->h, hash);
NeilBrown17f834b2006-03-27 01:15:05 -0800547 if (ch)
548 return container_of(ch, struct rsc, h);
549 else
550 return NULL;
551}
552
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400553static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old)
NeilBrown17f834b2006-03-27 01:15:05 -0800554{
555 struct cache_head *ch;
556 int hash = rsc_hash(new);
557
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400558 ch = sunrpc_cache_update(cd, &new->h,
NeilBrown17f834b2006-03-27 01:15:05 -0800559 &old->h, hash);
560 if (ch)
561 return container_of(ch, struct rsc, h);
562 else
563 return NULL;
564}
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567static struct rsc *
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400568gss_svc_searchbyctx(struct cache_detail *cd, struct xdr_netobj *handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
570 struct rsc rsci;
571 struct rsc *found;
572
573 memset(&rsci, 0, sizeof(rsci));
574 if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
575 return NULL;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400576 found = rsc_lookup(cd, &rsci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 rsc_free(&rsci);
578 if (!found)
579 return NULL;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400580 if (cache_check(cd, &found->h, NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return NULL;
582 return found;
583}
584
585/* Implements sequence number algorithm as specified in RFC 2203. */
586static int
587gss_check_seq_num(struct rsc *rsci, int seq_num)
588{
589 struct gss_svc_seq_data *sd = &rsci->seqdata;
590
591 spin_lock(&sd->sd_lock);
592 if (seq_num > sd->sd_max) {
593 if (seq_num >= sd->sd_max + GSS_SEQ_WIN) {
594 memset(sd->sd_win,0,sizeof(sd->sd_win));
595 sd->sd_max = seq_num;
596 } else while (sd->sd_max < seq_num) {
597 sd->sd_max++;
598 __clear_bit(sd->sd_max % GSS_SEQ_WIN, sd->sd_win);
599 }
600 __set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win);
601 goto ok;
602 } else if (seq_num <= sd->sd_max - GSS_SEQ_WIN) {
603 goto drop;
604 }
605 /* sd_max - GSS_SEQ_WIN < seq_num <= sd_max */
606 if (__test_and_set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win))
607 goto drop;
608ok:
609 spin_unlock(&sd->sd_lock);
610 return 1;
611drop:
612 spin_unlock(&sd->sd_lock);
613 return 0;
614}
615
616static inline u32 round_up_to_quad(u32 i)
617{
618 return (i + 3 ) & ~3;
619}
620
621static inline int
622svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
623{
624 int l;
625
626 if (argv->iov_len < 4)
627 return -1;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700628 o->len = svc_getnl(argv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 l = round_up_to_quad(o->len);
630 if (argv->iov_len < l)
631 return -1;
632 o->data = argv->iov_base;
633 argv->iov_base += l;
634 argv->iov_len -= l;
635 return 0;
636}
637
638static inline int
639svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
640{
Al Viro753ed902006-09-26 22:30:23 -0700641 u8 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 if (resv->iov_len + 4 > PAGE_SIZE)
644 return -1;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700645 svc_putnl(resv, o->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 p = resv->iov_base + resv->iov_len;
647 resv->iov_len += round_up_to_quad(o->len);
648 if (resv->iov_len > PAGE_SIZE)
649 return -1;
650 memcpy(p, o->data, o->len);
Al Viro753ed902006-09-26 22:30:23 -0700651 memset(p + o->len, 0, round_up_to_quad(o->len) - o->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return 0;
653}
654
J. Bruce Fields21fcd022007-08-09 20:16:22 -0400655/*
656 * Verify the checksum on the header and return SVC_OK on success.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 * Otherwise, return SVC_DROP (in the case of a bad sequence number)
658 * or return SVC_DENIED and indicate error in authp.
659 */
660static int
661gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700662 __be32 *rpcstart, struct rpc_gss_wire_cred *gc, __be32 *authp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
664 struct gss_ctx *ctx_id = rsci->mechctx;
665 struct xdr_buf rpchdr;
666 struct xdr_netobj checksum;
667 u32 flavor = 0;
668 struct kvec *argv = &rqstp->rq_arg.head[0];
669 struct kvec iov;
670
671 /* data to compute the checksum over: */
672 iov.iov_base = rpcstart;
673 iov.iov_len = (u8 *)argv->iov_base - (u8 *)rpcstart;
674 xdr_buf_from_iov(&iov, &rpchdr);
675
676 *authp = rpc_autherr_badverf;
677 if (argv->iov_len < 4)
678 return SVC_DENIED;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700679 flavor = svc_getnl(argv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (flavor != RPC_AUTH_GSS)
681 return SVC_DENIED;
682 if (svc_safe_getnetobj(argv, &checksum))
683 return SVC_DENIED;
684
685 if (rqstp->rq_deferred) /* skip verification of revisited request */
686 return SVC_OK;
J. Bruce Fields00fd6e12005-10-13 16:55:18 -0400687 if (gss_verify_mic(ctx_id, &rpchdr, &checksum) != GSS_S_COMPLETE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 *authp = rpcsec_gsserr_credproblem;
689 return SVC_DENIED;
690 }
691
692 if (gc->gc_seq > MAXSEQ) {
Chuck Lever8885cb32007-01-31 12:14:05 -0500693 dprintk("RPC: svcauth_gss: discarding request with "
694 "large sequence number %d\n", gc->gc_seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 *authp = rpcsec_gsserr_ctxproblem;
696 return SVC_DENIED;
697 }
698 if (!gss_check_seq_num(rsci, gc->gc_seq)) {
Chuck Lever8885cb32007-01-31 12:14:05 -0500699 dprintk("RPC: svcauth_gss: discarding request with "
700 "old sequence number %d\n", gc->gc_seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 return SVC_DROP;
702 }
703 return SVC_OK;
704}
705
706static int
Andy Adamson822f1002006-01-18 17:43:24 -0800707gss_write_null_verf(struct svc_rqst *rqstp)
708{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700709 __be32 *p;
Andy Adamson822f1002006-01-18 17:43:24 -0800710
Alexey Dobriyan76994312006-09-26 22:28:46 -0700711 svc_putnl(rqstp->rq_res.head, RPC_AUTH_NULL);
Andy Adamson822f1002006-01-18 17:43:24 -0800712 p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
713 /* don't really need to check if head->iov_len > PAGE_SIZE ... */
714 *p++ = 0;
715 if (!xdr_ressize_check(rqstp, p))
716 return -1;
717 return 0;
718}
719
720static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
722{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700723 __be32 xdr_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 u32 maj_stat;
725 struct xdr_buf verf_data;
726 struct xdr_netobj mic;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700727 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 struct kvec iov;
729
Alexey Dobriyan76994312006-09-26 22:28:46 -0700730 svc_putnl(rqstp->rq_res.head, RPC_AUTH_GSS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 xdr_seq = htonl(seq);
732
733 iov.iov_base = &xdr_seq;
734 iov.iov_len = sizeof(xdr_seq);
735 xdr_buf_from_iov(&iov, &verf_data);
736 p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
737 mic.data = (u8 *)(p + 1);
J. Bruce Fields00fd6e12005-10-13 16:55:18 -0400738 maj_stat = gss_get_mic(ctx_id, &verf_data, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (maj_stat != GSS_S_COMPLETE)
740 return -1;
741 *p++ = htonl(mic.len);
742 memset((u8 *)p + mic.len, 0, round_up_to_quad(mic.len) - mic.len);
743 p += XDR_QUADLEN(mic.len);
744 if (!xdr_ressize_check(rqstp, p))
745 return -1;
746 return 0;
747}
748
749struct gss_domain {
750 struct auth_domain h;
751 u32 pseudoflavor;
752};
753
754static struct auth_domain *
755find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
756{
757 char *name;
758
759 name = gss_service_to_auth_domain_name(ctx->mech_type, svc);
760 if (!name)
761 return NULL;
762 return auth_domain_find(name);
763}
764
NeilBrownefc36aa2006-03-27 01:14:59 -0800765static struct auth_ops svcauthops_gss;
766
J. Bruce Fields4796f452007-07-17 04:04:51 -0700767u32 svcauth_gss_flavor(struct auth_domain *dom)
768{
769 struct gss_domain *gd = container_of(dom, struct gss_domain, h);
770
771 return gd->pseudoflavor;
772}
773
Trond Myklebust7bd88262008-12-23 15:21:32 -0500774EXPORT_SYMBOL_GPL(svcauth_gss_flavor);
J. Bruce Fields4796f452007-07-17 04:04:51 -0700775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776int
777svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
778{
779 struct gss_domain *new;
780 struct auth_domain *test;
781 int stat = -ENOMEM;
782
783 new = kmalloc(sizeof(*new), GFP_KERNEL);
784 if (!new)
785 goto out;
NeilBrownefc36aa2006-03-27 01:14:59 -0800786 kref_init(&new->h.ref);
Arnaldo Carvalho de Meloe69062b2006-11-21 01:21:34 -0200787 new->h.name = kstrdup(name, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 if (!new->h.name)
789 goto out_free_dom;
NeilBrownefc36aa2006-03-27 01:14:59 -0800790 new->h.flavour = &svcauthops_gss;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 new->pseudoflavor = pseudoflavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
J. Bruce Fieldscb276802007-07-23 18:43:52 -0700793 stat = 0;
NeilBrownefc36aa2006-03-27 01:14:59 -0800794 test = auth_domain_lookup(name, &new->h);
J. Bruce Fieldscb276802007-07-23 18:43:52 -0700795 if (test != &new->h) { /* Duplicate registration */
796 auth_domain_put(test);
797 kfree(new->h.name);
798 goto out_free_dom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800 return 0;
801
802out_free_dom:
803 kfree(new);
804out:
805 return stat;
806}
807
Trond Myklebust7bd88262008-12-23 15:21:32 -0500808EXPORT_SYMBOL_GPL(svcauth_gss_register_pseudoflavor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810static inline int
811read_u32_from_xdr_buf(struct xdr_buf *buf, int base, u32 *obj)
812{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700813 __be32 raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 int status;
815
816 status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
817 if (status)
818 return status;
819 *obj = ntohl(raw);
820 return 0;
821}
822
823/* It would be nice if this bit of code could be shared with the client.
824 * Obstacles:
825 * The client shouldn't malloc(), would have to pass in own memory.
826 * The server uses base of head iovec as read pointer, while the
827 * client uses separate pointer. */
828static int
Jeff Layton4c190e22013-02-06 08:28:55 -0500829unwrap_integ_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
831 int stat = -EINVAL;
832 u32 integ_len, maj_stat;
833 struct xdr_netobj mic;
834 struct xdr_buf integ_buf;
835
Jeff Layton4c190e22013-02-06 08:28:55 -0500836 /* Did we already verify the signature on the original pass through? */
837 if (rqstp->rq_deferred)
838 return 0;
839
Alexey Dobriyan76994312006-09-26 22:28:46 -0700840 integ_len = svc_getnl(&buf->head[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (integ_len & 3)
J.Bruce Fieldsb797b5b2006-12-13 00:35:19 -0800842 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (integ_len > buf->len)
J.Bruce Fieldsb797b5b2006-12-13 00:35:19 -0800844 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 if (xdr_buf_subsegment(buf, &integ_buf, 0, integ_len))
846 BUG();
847 /* copy out mic... */
848 if (read_u32_from_xdr_buf(buf, integ_len, &mic.len))
849 BUG();
850 if (mic.len > RPC_MAX_AUTH_SIZE)
J.Bruce Fieldsb797b5b2006-12-13 00:35:19 -0800851 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 mic.data = kmalloc(mic.len, GFP_KERNEL);
853 if (!mic.data)
J.Bruce Fieldsb797b5b2006-12-13 00:35:19 -0800854 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (read_bytes_from_xdr_buf(buf, integ_len + 4, mic.data, mic.len))
856 goto out;
J. Bruce Fields00fd6e12005-10-13 16:55:18 -0400857 maj_stat = gss_verify_mic(ctx, &integ_buf, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 if (maj_stat != GSS_S_COMPLETE)
859 goto out;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700860 if (svc_getnl(&buf->head[0]) != seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 goto out;
Jeff Layton4c190e22013-02-06 08:28:55 -0500862 /* trim off the mic at the end before returning */
863 xdr_buf_trim(buf, mic.len + 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 stat = 0;
865out:
J.Bruce Fieldsb797b5b2006-12-13 00:35:19 -0800866 kfree(mic.data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 return stat;
868}
869
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -0700870static inline int
871total_buf_len(struct xdr_buf *buf)
872{
873 return buf->head[0].iov_len + buf->page_len + buf->tail[0].iov_len;
874}
875
876static void
877fix_priv_head(struct xdr_buf *buf, int pad)
878{
879 if (buf->page_len == 0) {
880 /* We need to adjust head and buf->len in tandem in this
881 * case to make svc_defer() work--it finds the original
882 * buffer start using buf->len - buf->head[0].iov_len. */
883 buf->head[0].iov_len -= pad;
884 }
885}
886
887static int
888unwrap_priv_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
889{
890 u32 priv_len, maj_stat;
891 int pad, saved_len, remaining_len, offset;
892
Jens Axboecf8208d2007-06-12 21:22:14 +0200893 rqstp->rq_splice_ok = 0;
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -0700894
Alexey Dobriyan76994312006-09-26 22:28:46 -0700895 priv_len = svc_getnl(&buf->head[0]);
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -0700896 if (rqstp->rq_deferred) {
897 /* Already decrypted last time through! The sequence number
898 * check at out_seq is unnecessary but harmless: */
899 goto out_seq;
900 }
901 /* buf->len is the number of bytes from the original start of the
902 * request to the end, where head[0].iov_len is just the bytes
903 * not yet read from the head, so these two values are different: */
904 remaining_len = total_buf_len(buf);
905 if (priv_len > remaining_len)
906 return -EINVAL;
907 pad = remaining_len - priv_len;
908 buf->len -= pad;
909 fix_priv_head(buf, pad);
910
911 /* Maybe it would be better to give gss_unwrap a length parameter: */
912 saved_len = buf->len;
913 buf->len = priv_len;
914 maj_stat = gss_unwrap(ctx, 0, buf);
915 pad = priv_len - buf->len;
916 buf->len = saved_len;
917 buf->len -= pad;
918 /* The upper layers assume the buffer is aligned on 4-byte boundaries.
919 * In the krb5p case, at least, the data ends up offset, so we need to
920 * move it around. */
921 /* XXX: This is very inefficient. It would be better to either do
922 * this while we encrypt, or maybe in the receive code, if we can peak
923 * ahead and work out the service and mechanism there. */
924 offset = buf->head[0].iov_len % 4;
925 if (offset) {
926 buf->buflen = RPCSVC_MAXPAYLOAD;
927 xdr_shift_buf(buf, offset);
928 fix_priv_head(buf, pad);
929 }
930 if (maj_stat != GSS_S_COMPLETE)
931 return -EINVAL;
932out_seq:
Alexey Dobriyan76994312006-09-26 22:28:46 -0700933 if (svc_getnl(&buf->head[0]) != seq)
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -0700934 return -EINVAL;
935 return 0;
936}
937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938struct gss_svc_data {
939 /* decoded gss client cred: */
940 struct rpc_gss_wire_cred clcred;
J.Bruce Fields5b304bc2006-10-04 02:16:07 -0700941 /* save a pointer to the beginning of the encoded verifier,
942 * for use in encryption/checksumming in svcauth_gss_release: */
943 __be32 *verf_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 struct rsc *rsci;
945};
946
947static int
948svcauth_gss_set_client(struct svc_rqst *rqstp)
949{
950 struct gss_svc_data *svcdata = rqstp->rq_auth_data;
951 struct rsc *rsci = svcdata->rsci;
952 struct rpc_gss_wire_cred *gc = &svcdata->clcred;
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -0700953 int stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -0700955 /*
956 * A gss export can be specified either by:
957 * export *(sec=krb5,rw)
958 * or by
959 * export gss/krb5(rw)
960 * The latter is deprecated; but for backwards compatibility reasons
961 * the nfsd code will still fall back on trying it if the former
962 * doesn't work; so we try to make both available to nfsd, below.
963 */
964 rqstp->rq_gssclient = find_gss_auth_domain(rsci->mechctx, gc->gc_svc);
965 if (rqstp->rq_gssclient == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 return SVC_DENIED;
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -0700967 stat = svcauth_unix_set_client(rqstp);
NeilBrown1ebede82010-08-12 17:04:07 +1000968 if (stat == SVC_DROP || stat == SVC_CLOSE)
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -0700969 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return SVC_OK;
971}
972
Kevin Coffman91a47622006-01-18 17:43:25 -0800973static inline int
Simo Sorcefc2952a2012-04-17 09:39:06 -0400974gss_write_init_verf(struct cache_detail *cd, struct svc_rqst *rqstp,
975 struct xdr_netobj *out_handle, int *major_status)
Kevin Coffman91a47622006-01-18 17:43:25 -0800976{
977 struct rsc *rsci;
Frank Filz54f92472007-05-09 02:34:53 -0700978 int rc;
Kevin Coffman91a47622006-01-18 17:43:25 -0800979
Simo Sorcefc2952a2012-04-17 09:39:06 -0400980 if (*major_status != GSS_S_COMPLETE)
Kevin Coffman91a47622006-01-18 17:43:25 -0800981 return gss_write_null_verf(rqstp);
Simo Sorcefc2952a2012-04-17 09:39:06 -0400982 rsci = gss_svc_searchbyctx(cd, out_handle);
Kevin Coffman91a47622006-01-18 17:43:25 -0800983 if (rsci == NULL) {
Simo Sorcefc2952a2012-04-17 09:39:06 -0400984 *major_status = GSS_S_NO_CONTEXT;
Kevin Coffman91a47622006-01-18 17:43:25 -0800985 return gss_write_null_verf(rqstp);
986 }
Frank Filz54f92472007-05-09 02:34:53 -0700987 rc = gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +0400988 cache_put(&rsci->h, cd);
Frank Filz54f92472007-05-09 02:34:53 -0700989 return rc;
Kevin Coffman91a47622006-01-18 17:43:25 -0800990}
991
Simo Sorcefc2952a2012-04-17 09:39:06 -0400992static inline int
Simo Sorce030d7942012-05-25 18:09:56 -0400993gss_read_common_verf(struct rpc_gss_wire_cred *gc,
994 struct kvec *argv, __be32 *authp,
995 struct xdr_netobj *in_handle)
Simo Sorcefc2952a2012-04-17 09:39:06 -0400996{
Simo Sorcefc2952a2012-04-17 09:39:06 -0400997 /* Read the verifier; should be NULL: */
998 *authp = rpc_autherr_badverf;
999 if (argv->iov_len < 2 * 4)
1000 return SVC_DENIED;
1001 if (svc_getnl(argv) != RPC_AUTH_NULL)
1002 return SVC_DENIED;
1003 if (svc_getnl(argv) != 0)
1004 return SVC_DENIED;
1005 /* Martial context handle and token for upcall: */
1006 *authp = rpc_autherr_badcred;
1007 if (gc->gc_proc == RPC_GSS_PROC_INIT && gc->gc_ctx.len != 0)
1008 return SVC_DENIED;
1009 if (dup_netobj(in_handle, &gc->gc_ctx))
1010 return SVC_CLOSE;
1011 *authp = rpc_autherr_badverf;
Simo Sorce030d7942012-05-25 18:09:56 -04001012
1013 return 0;
1014}
1015
1016static inline int
1017gss_read_verf(struct rpc_gss_wire_cred *gc,
1018 struct kvec *argv, __be32 *authp,
1019 struct xdr_netobj *in_handle,
1020 struct xdr_netobj *in_token)
1021{
1022 struct xdr_netobj tmpobj;
1023 int res;
1024
1025 res = gss_read_common_verf(gc, argv, authp, in_handle);
1026 if (res)
1027 return res;
1028
Simo Sorcefc2952a2012-04-17 09:39:06 -04001029 if (svc_safe_getnetobj(argv, &tmpobj)) {
1030 kfree(in_handle->data);
1031 return SVC_DENIED;
1032 }
1033 if (dup_netobj(in_token, &tmpobj)) {
1034 kfree(in_handle->data);
1035 return SVC_CLOSE;
1036 }
1037
1038 return 0;
1039}
1040
Simo Sorce030d7942012-05-25 18:09:56 -04001041/* Ok this is really heavily depending on a set of semantics in
1042 * how rqstp is set up by svc_recv and pages laid down by the
1043 * server when reading a request. We are basically guaranteed that
1044 * the token lays all down linearly across a set of pages, starting
1045 * at iov_base in rq_arg.head[0] which happens to be the first of a
1046 * set of pages stored in rq_pages[].
1047 * rq_arg.head[0].iov_base will provide us the page_base to pass
1048 * to the upcall.
1049 */
1050static inline int
1051gss_read_proxy_verf(struct svc_rqst *rqstp,
1052 struct rpc_gss_wire_cred *gc, __be32 *authp,
1053 struct xdr_netobj *in_handle,
1054 struct gssp_in_token *in_token)
1055{
1056 struct kvec *argv = &rqstp->rq_arg.head[0];
1057 u32 inlen;
1058 int res;
1059
1060 res = gss_read_common_verf(gc, argv, authp, in_handle);
1061 if (res)
1062 return res;
1063
1064 inlen = svc_getnl(argv);
1065 if (inlen > (argv->iov_len + rqstp->rq_arg.page_len))
1066 return SVC_DENIED;
1067
1068 in_token->pages = rqstp->rq_pages;
1069 in_token->page_base = (ulong)argv->iov_base & ~PAGE_MASK;
1070 in_token->page_len = inlen;
1071
1072 return 0;
1073}
1074
Simo Sorcefc2952a2012-04-17 09:39:06 -04001075static inline int
1076gss_write_resv(struct kvec *resv, size_t size_limit,
1077 struct xdr_netobj *out_handle, struct xdr_netobj *out_token,
1078 int major_status, int minor_status)
1079{
1080 if (resv->iov_len + 4 > size_limit)
1081 return -1;
1082 svc_putnl(resv, RPC_SUCCESS);
1083 if (svc_safe_putnetobj(resv, out_handle))
1084 return -1;
1085 if (resv->iov_len + 3 * 4 > size_limit)
1086 return -1;
1087 svc_putnl(resv, major_status);
1088 svc_putnl(resv, minor_status);
1089 svc_putnl(resv, GSS_SEQ_WIN);
1090 if (svc_safe_putnetobj(resv, out_token))
1091 return -1;
1092 return 0;
1093}
1094
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095/*
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001096 * Having read the cred already and found we're in the context
1097 * initiation case, read the verifier and initiate (or check the results
1098 * of) upcalls to userspace for help with context initiation. If
1099 * the upcall results are available, write the verifier and result.
1100 * Otherwise, drop the request pending an answer to the upcall.
1101 */
Simo Sorce030d7942012-05-25 18:09:56 -04001102static int svcauth_gss_legacy_init(struct svc_rqst *rqstp,
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001103 struct rpc_gss_wire_cred *gc, __be32 *authp)
1104{
1105 struct kvec *argv = &rqstp->rq_arg.head[0];
1106 struct kvec *resv = &rqstp->rq_res.head[0];
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001107 struct rsi *rsip, rsikey;
J. Bruce Fields980e5a42007-12-12 18:21:17 -05001108 int ret;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001109 struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001110
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001111 memset(&rsikey, 0, sizeof(rsikey));
Simo Sorcefc2952a2012-04-17 09:39:06 -04001112 ret = gss_read_verf(gc, argv, authp,
1113 &rsikey.in_handle, &rsikey.in_token);
1114 if (ret)
1115 return ret;
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001116
1117 /* Perform upcall, or find upcall result: */
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001118 rsip = rsi_lookup(sn->rsi_cache, &rsikey);
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001119 rsi_free(&rsikey);
1120 if (!rsip)
NeilBrown1ebede82010-08-12 17:04:07 +10001121 return SVC_CLOSE;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001122 if (cache_check(sn->rsi_cache, &rsip->h, &rqstp->rq_chandle) < 0)
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001123 /* No upcall result: */
NeilBrown1ebede82010-08-12 17:04:07 +10001124 return SVC_CLOSE;
NeilBrown2ed52822010-08-12 17:04:07 +10001125
1126 ret = SVC_CLOSE;
1127 /* Got an answer to the upcall; use it: */
Simo Sorcefc2952a2012-04-17 09:39:06 -04001128 if (gss_write_init_verf(sn->rsc_cache, rqstp,
1129 &rsip->out_handle, &rsip->major_status))
NeilBrown2ed52822010-08-12 17:04:07 +10001130 goto out;
Simo Sorcefc2952a2012-04-17 09:39:06 -04001131 if (gss_write_resv(resv, PAGE_SIZE,
1132 &rsip->out_handle, &rsip->out_token,
1133 rsip->major_status, rsip->minor_status))
NeilBrown2ed52822010-08-12 17:04:07 +10001134 goto out;
1135
J. Bruce Fields980e5a42007-12-12 18:21:17 -05001136 ret = SVC_COMPLETE;
1137out:
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001138 cache_put(&rsip->h, sn->rsi_cache);
J. Bruce Fields980e5a42007-12-12 18:21:17 -05001139 return ret;
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001140}
1141
Simo Sorce030d7942012-05-25 18:09:56 -04001142static int gss_proxy_save_rsc(struct cache_detail *cd,
1143 struct gssp_upcall_data *ud,
1144 uint64_t *handle)
1145{
1146 struct rsc rsci, *rscp = NULL;
1147 static atomic64_t ctxhctr;
1148 long long ctxh;
1149 struct gss_api_mech *gm = NULL;
1150 time_t expiry;
1151 int status = -EINVAL;
1152
1153 memset(&rsci, 0, sizeof(rsci));
1154 /* context handle */
1155 status = -ENOMEM;
1156 /* the handle needs to be just a unique id,
1157 * use a static counter */
1158 ctxh = atomic64_inc_return(&ctxhctr);
1159
1160 /* make a copy for the caller */
1161 *handle = ctxh;
1162
1163 /* make a copy for the rsc cache */
1164 if (dup_to_netobj(&rsci.handle, (char *)handle, sizeof(uint64_t)))
1165 goto out;
1166 rscp = rsc_lookup(cd, &rsci);
1167 if (!rscp)
1168 goto out;
1169
1170 /* creds */
1171 if (!ud->found_creds) {
1172 /* userspace seem buggy, we should always get at least a
1173 * mapping to nobody */
1174 dprintk("RPC: No creds found, marking Negative!\n");
1175 set_bit(CACHE_NEGATIVE, &rsci.h.flags);
1176 } else {
1177
1178 /* steal creds */
1179 rsci.cred = ud->creds;
1180 memset(&ud->creds, 0, sizeof(struct svc_cred));
1181
1182 status = -EOPNOTSUPP;
1183 /* get mech handle from OID */
1184 gm = gss_mech_get_by_OID(&ud->mech_oid);
1185 if (!gm)
1186 goto out;
1187
1188 status = -EINVAL;
1189 /* mech-specific data: */
1190 status = gss_import_sec_context(ud->out_handle.data,
1191 ud->out_handle.len,
1192 gm, &rsci.mechctx,
1193 &expiry, GFP_KERNEL);
1194 if (status)
1195 goto out;
1196 }
1197
1198 rsci.h.expiry_time = expiry;
1199 rscp = rsc_update(cd, &rsci, rscp);
1200 status = 0;
1201out:
1202 gss_mech_put(gm);
1203 rsc_free(&rsci);
1204 if (rscp)
1205 cache_put(&rscp->h, cd);
1206 else
1207 status = -ENOMEM;
1208 return status;
1209}
1210
1211static int svcauth_gss_proxy_init(struct svc_rqst *rqstp,
1212 struct rpc_gss_wire_cred *gc, __be32 *authp)
1213{
1214 struct kvec *resv = &rqstp->rq_res.head[0];
1215 struct xdr_netobj cli_handle;
1216 struct gssp_upcall_data ud;
1217 uint64_t handle;
1218 int status;
1219 int ret;
1220 struct net *net = rqstp->rq_xprt->xpt_net;
1221 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1222
1223 memset(&ud, 0, sizeof(ud));
1224 ret = gss_read_proxy_verf(rqstp, gc, authp,
1225 &ud.in_handle, &ud.in_token);
1226 if (ret)
1227 return ret;
1228
1229 ret = SVC_CLOSE;
1230
1231 /* Perform synchronous upcall to gss-proxy */
1232 status = gssp_accept_sec_context_upcall(net, &ud);
1233 if (status)
1234 goto out;
1235
1236 dprintk("RPC: svcauth_gss: gss major status = %d\n",
1237 ud.major_status);
1238
1239 switch (ud.major_status) {
1240 case GSS_S_CONTINUE_NEEDED:
1241 cli_handle = ud.out_handle;
1242 break;
1243 case GSS_S_COMPLETE:
1244 status = gss_proxy_save_rsc(sn->rsc_cache, &ud, &handle);
1245 if (status)
1246 goto out;
1247 cli_handle.data = (u8 *)&handle;
1248 cli_handle.len = sizeof(handle);
1249 break;
1250 default:
1251 ret = SVC_CLOSE;
1252 goto out;
1253 }
1254
1255 /* Got an answer to the upcall; use it: */
1256 if (gss_write_init_verf(sn->rsc_cache, rqstp,
1257 &cli_handle, &ud.major_status))
1258 goto out;
1259 if (gss_write_resv(resv, PAGE_SIZE,
1260 &cli_handle, &ud.out_token,
1261 ud.major_status, ud.minor_status))
1262 goto out;
1263
1264 ret = SVC_COMPLETE;
1265out:
1266 gssp_free_upcall_data(&ud);
1267 return ret;
1268}
1269
1270DEFINE_SPINLOCK(use_gssp_lock);
1271
1272static bool use_gss_proxy(struct net *net)
1273{
1274 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1275
1276 if (sn->use_gss_proxy != -1)
1277 return sn->use_gss_proxy;
1278 spin_lock(&use_gssp_lock);
1279 /*
1280 * If you wanted gss-proxy, you should have said so before
1281 * starting to accept requests:
1282 */
1283 sn->use_gss_proxy = 0;
1284 spin_unlock(&use_gssp_lock);
1285 return 0;
1286}
1287
J. Bruce Fields0ff3bab2013-04-29 17:03:31 -04001288#ifdef CONFIG_PROC_FS
1289
Dan Carpenter625cdd72013-05-11 19:13:49 +03001290static int set_gss_proxy(struct net *net, int type)
Simo Sorce030d7942012-05-25 18:09:56 -04001291{
1292 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1293 int ret = 0;
1294
1295 WARN_ON_ONCE(type != 0 && type != 1);
1296 spin_lock(&use_gssp_lock);
1297 if (sn->use_gss_proxy == -1 || sn->use_gss_proxy == type)
1298 sn->use_gss_proxy = type;
1299 else
1300 ret = -EBUSY;
1301 spin_unlock(&use_gssp_lock);
1302 wake_up(&sn->gssp_wq);
1303 return ret;
1304}
1305
1306static inline bool gssp_ready(struct sunrpc_net *sn)
1307{
1308 switch (sn->use_gss_proxy) {
1309 case -1:
1310 return false;
1311 case 0:
1312 return true;
1313 case 1:
1314 return sn->gssp_clnt;
1315 }
1316 WARN_ON_ONCE(1);
1317 return false;
1318}
1319
J. Bruce Fieldsb161c142013-05-24 09:47:49 -04001320static int wait_for_gss_proxy(struct net *net, struct file *file)
Simo Sorce030d7942012-05-25 18:09:56 -04001321{
1322 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1323
J. Bruce Fieldsb161c142013-05-24 09:47:49 -04001324 if (file->f_flags & O_NONBLOCK && !gssp_ready(sn))
1325 return -EAGAIN;
Simo Sorce030d7942012-05-25 18:09:56 -04001326 return wait_event_interruptible(sn->gssp_wq, gssp_ready(sn));
1327}
1328
Simo Sorce030d7942012-05-25 18:09:56 -04001329
1330static ssize_t write_gssp(struct file *file, const char __user *buf,
1331 size_t count, loff_t *ppos)
1332{
Linus Torvalds1db77222013-05-03 10:59:39 -07001333 struct net *net = PDE_DATA(file->f_path.dentry->d_inode);
Simo Sorce030d7942012-05-25 18:09:56 -04001334 char tbuf[20];
1335 unsigned long i;
1336 int res;
1337
1338 if (*ppos || count > sizeof(tbuf)-1)
1339 return -EINVAL;
1340 if (copy_from_user(tbuf, buf, count))
1341 return -EFAULT;
1342
1343 tbuf[count] = 0;
1344 res = kstrtoul(tbuf, 0, &i);
1345 if (res)
1346 return res;
1347 if (i != 1)
1348 return -EINVAL;
1349 res = set_gss_proxy(net, 1);
1350 if (res)
1351 return res;
1352 res = set_gssp_clnt(net);
1353 if (res)
1354 return res;
1355 return count;
1356}
1357
1358static ssize_t read_gssp(struct file *file, char __user *buf,
1359 size_t count, loff_t *ppos)
1360{
Linus Torvalds1db77222013-05-03 10:59:39 -07001361 struct net *net = PDE_DATA(file->f_path.dentry->d_inode);
Simo Sorce030d7942012-05-25 18:09:56 -04001362 unsigned long p = *ppos;
1363 char tbuf[10];
1364 size_t len;
1365 int ret;
1366
J. Bruce Fieldsb161c142013-05-24 09:47:49 -04001367 ret = wait_for_gss_proxy(net, file);
Simo Sorce030d7942012-05-25 18:09:56 -04001368 if (ret)
1369 return ret;
1370
1371 snprintf(tbuf, sizeof(tbuf), "%d\n", use_gss_proxy(net));
1372 len = strlen(tbuf);
1373 if (p >= len)
1374 return 0;
1375 len -= p;
1376 if (len > count)
1377 len = count;
1378 if (copy_to_user(buf, (void *)(tbuf+p), len))
1379 return -EFAULT;
1380 *ppos += len;
1381 return len;
1382}
1383
1384static const struct file_operations use_gss_proxy_ops = {
1385 .open = nonseekable_open,
1386 .write = write_gssp,
1387 .read = read_gssp,
1388};
1389
1390static int create_use_gss_proxy_proc_entry(struct net *net)
1391{
1392 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1393 struct proc_dir_entry **p = &sn->use_gssp_proc;
1394
1395 sn->use_gss_proxy = -1;
1396 *p = proc_create_data("use-gss-proxy", S_IFREG|S_IRUSR|S_IWUSR,
1397 sn->proc_net_rpc,
1398 &use_gss_proxy_ops, net);
1399 if (!*p)
1400 return -ENOMEM;
1401 init_gssp_clnt(sn);
1402 return 0;
1403}
1404
1405static void destroy_use_gss_proxy_proc_entry(struct net *net)
1406{
1407 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1408
1409 if (sn->use_gssp_proc) {
1410 remove_proc_entry("use-gss-proxy", sn->proc_net_rpc);
1411 clear_gssp_clnt(sn);
1412 }
1413}
J. Bruce Fields0ff3bab2013-04-29 17:03:31 -04001414#else /* CONFIG_PROC_FS */
1415
1416static int create_use_gss_proxy_proc_entry(struct net *net)
1417{
1418 return 0;
1419}
1420
1421static void destroy_use_gss_proxy_proc_entry(struct net *net) {}
Simo Sorce030d7942012-05-25 18:09:56 -04001422
1423#endif /* CONFIG_PROC_FS */
1424
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001425/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 * Accept an rpcsec packet.
1427 * If context establishment, punt to user space
1428 * If data exchange, verify/decrypt
1429 * If context destruction, handle here
1430 * In the context establishment and destruction case we encode
1431 * response here and return SVC_COMPLETE.
1432 */
1433static int
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001434svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435{
1436 struct kvec *argv = &rqstp->rq_arg.head[0];
1437 struct kvec *resv = &rqstp->rq_res.head[0];
1438 u32 crlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 struct gss_svc_data *svcdata = rqstp->rq_auth_data;
1440 struct rpc_gss_wire_cred *gc;
1441 struct rsc *rsci = NULL;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001442 __be32 *rpcstart;
1443 __be32 *reject_stat = resv->iov_base + resv->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 int ret;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001445 struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
Chuck Lever8885cb32007-01-31 12:14:05 -05001447 dprintk("RPC: svcauth_gss: argv->iov_len = %zd\n",
1448 argv->iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449
1450 *authp = rpc_autherr_badcred;
1451 if (!svcdata)
1452 svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
1453 if (!svcdata)
1454 goto auth_err;
1455 rqstp->rq_auth_data = svcdata;
J.Bruce Fields5b304bc2006-10-04 02:16:07 -07001456 svcdata->verf_start = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 svcdata->rsci = NULL;
1458 gc = &svcdata->clcred;
1459
1460 /* start of rpc packet is 7 u32's back from here:
1461 * xid direction rpcversion prog vers proc flavour
1462 */
1463 rpcstart = argv->iov_base;
1464 rpcstart -= 7;
1465
1466 /* credential is:
1467 * version(==1), proc(0,1,2,3), seq, service (1,2,3), handle
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001468 * at least 5 u32s, and is preceded by length, so that makes 6.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 */
1470
1471 if (argv->iov_len < 5 * 4)
1472 goto auth_err;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001473 crlen = svc_getnl(argv);
1474 if (svc_getnl(argv) != RPC_GSS_VERSION)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 goto auth_err;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001476 gc->gc_proc = svc_getnl(argv);
1477 gc->gc_seq = svc_getnl(argv);
1478 gc->gc_svc = svc_getnl(argv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (svc_safe_getnetobj(argv, &gc->gc_ctx))
1480 goto auth_err;
1481 if (crlen != round_up_to_quad(gc->gc_ctx.len) + 5 * 4)
1482 goto auth_err;
1483
1484 if ((gc->gc_proc != RPC_GSS_PROC_DATA) && (rqstp->rq_proc != 0))
1485 goto auth_err;
1486
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 *authp = rpc_autherr_badverf;
1488 switch (gc->gc_proc) {
1489 case RPC_GSS_PROC_INIT:
1490 case RPC_GSS_PROC_CONTINUE_INIT:
Simo Sorce030d7942012-05-25 18:09:56 -04001491 if (use_gss_proxy(SVC_NET(rqstp)))
1492 return svcauth_gss_proxy_init(rqstp, gc, authp);
1493 else
1494 return svcauth_gss_legacy_init(rqstp, gc, authp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 case RPC_GSS_PROC_DATA:
1496 case RPC_GSS_PROC_DESTROY:
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001497 /* Look up the context, and check the verifier: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 *authp = rpcsec_gsserr_credproblem;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001499 rsci = gss_svc_searchbyctx(sn->rsc_cache, &gc->gc_ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 if (!rsci)
1501 goto auth_err;
1502 switch (gss_verify_header(rqstp, rsci, rpcstart, gc, authp)) {
1503 case SVC_OK:
1504 break;
1505 case SVC_DENIED:
1506 goto auth_err;
1507 case SVC_DROP:
1508 goto drop;
1509 }
1510 break;
1511 default:
1512 *authp = rpc_autherr_rejectedcred;
1513 goto auth_err;
1514 }
1515
1516 /* now act upon the command: */
1517 switch (gc->gc_proc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 case RPC_GSS_PROC_DESTROY:
Wei Yongjunc5e434c2007-05-09 02:34:54 -07001519 if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1520 goto auth_err;
J. Bruce Fieldscb5c7d62008-01-14 16:05:07 -05001521 rsci->h.expiry_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 set_bit(CACHE_NEGATIVE, &rsci->h.flags);
1523 if (resv->iov_len + 4 > PAGE_SIZE)
1524 goto drop;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001525 svc_putnl(resv, RPC_SUCCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 goto complete;
1527 case RPC_GSS_PROC_DATA:
1528 *authp = rpcsec_gsserr_ctxproblem;
J.Bruce Fields5b304bc2006-10-04 02:16:07 -07001529 svcdata->verf_start = resv->iov_base + resv->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1531 goto auth_err;
1532 rqstp->rq_cred = rsci->cred;
1533 get_group_info(rsci->cred.cr_group_info);
1534 *authp = rpc_autherr_badcred;
1535 switch (gc->gc_svc) {
1536 case RPC_GSS_SVC_NONE:
1537 break;
1538 case RPC_GSS_SVC_INTEGRITY:
J. Bruce Fieldsb6207542008-07-03 15:26:35 -04001539 /* placeholders for length and seq. number: */
1540 svc_putnl(resv, 0);
1541 svc_putnl(resv, 0);
Jeff Layton4c190e22013-02-06 08:28:55 -05001542 if (unwrap_integ_data(rqstp, &rqstp->rq_arg,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 gc->gc_seq, rsci->mechctx))
Harshula Jayasuriyadd352102008-02-20 10:56:56 +11001544 goto garbage_args;
J. Bruce Fieldsb6207542008-07-03 15:26:35 -04001545 break;
1546 case RPC_GSS_SVC_PRIVACY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* placeholders for length and seq. number: */
Alexey Dobriyan76994312006-09-26 22:28:46 -07001548 svc_putnl(resv, 0);
1549 svc_putnl(resv, 0);
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001550 if (unwrap_priv_data(rqstp, &rqstp->rq_arg,
1551 gc->gc_seq, rsci->mechctx))
Harshula Jayasuriyadd352102008-02-20 10:56:56 +11001552 goto garbage_args;
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001553 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 default:
1555 goto auth_err;
1556 }
1557 svcdata->rsci = rsci;
1558 cache_get(&rsci->h);
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001559 rqstp->rq_cred.cr_flavor = gss_svc_to_pseudoflavor(
Chuck Lever83523d02013-03-16 15:55:01 -04001560 rsci->mechctx->mech_type,
1561 GSS_C_QOP_DEFAULT,
1562 gc->gc_svc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 ret = SVC_OK;
1564 goto out;
1565 }
Harshula Jayasuriyadd352102008-02-20 10:56:56 +11001566garbage_args:
Harshula Jayasuriyadd352102008-02-20 10:56:56 +11001567 ret = SVC_GARBAGE;
1568 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569auth_err:
J. Bruce Fields21fcd022007-08-09 20:16:22 -04001570 /* Restore write pointer to its original value: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 xdr_ressize_check(rqstp, reject_stat);
1572 ret = SVC_DENIED;
1573 goto out;
1574complete:
1575 ret = SVC_COMPLETE;
1576 goto out;
1577drop:
1578 ret = SVC_DROP;
1579out:
1580 if (rsci)
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001581 cache_put(&rsci->h, sn->rsc_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 return ret;
1583}
1584
Al Virocfbdbab2006-10-10 22:49:27 +01001585static __be32 *
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001586svcauth_gss_prepare_to_wrap(struct xdr_buf *resbuf, struct gss_svc_data *gsd)
1587{
Al Virocfbdbab2006-10-10 22:49:27 +01001588 __be32 *p;
1589 u32 verf_len;
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001590
J.Bruce Fields5b304bc2006-10-04 02:16:07 -07001591 p = gsd->verf_start;
1592 gsd->verf_start = NULL;
1593
1594 /* If the reply stat is nonzero, don't wrap: */
1595 if (*(p-1) != rpc_success)
1596 return NULL;
1597 /* Skip the verifier: */
1598 p += 1;
1599 verf_len = ntohl(*p++);
1600 p += XDR_QUADLEN(verf_len);
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001601 /* move accept_stat to right place: */
1602 memcpy(p, p + 2, 4);
J.Bruce Fields5b304bc2006-10-04 02:16:07 -07001603 /* Also don't wrap if the accept stat is nonzero: */
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001604 if (*p != rpc_success) {
1605 resbuf->head[0].iov_len -= 2 * 4;
1606 return NULL;
1607 }
1608 p++;
1609 return p;
1610}
1611
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001612static inline int
1613svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
1615 struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1616 struct rpc_gss_wire_cred *gc = &gsd->clcred;
1617 struct xdr_buf *resbuf = &rqstp->rq_res;
1618 struct xdr_buf integ_buf;
1619 struct xdr_netobj mic;
1620 struct kvec *resv;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001621 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 int integ_offset, integ_len;
1623 int stat = -EINVAL;
1624
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001625 p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1626 if (p == NULL)
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001627 goto out;
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001628 integ_offset = (u8 *)(p + 1) - (u8 *)resbuf->head[0].iov_base;
1629 integ_len = resbuf->len - integ_offset;
1630 BUG_ON(integ_len % 4);
1631 *p++ = htonl(integ_len);
1632 *p++ = htonl(gc->gc_seq);
1633 if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset,
1634 integ_len))
1635 BUG();
NeilBrown153e44d2007-05-09 02:34:52 -07001636 if (resbuf->tail[0].iov_base == NULL) {
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001637 if (resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1638 goto out_err;
1639 resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1640 + resbuf->head[0].iov_len;
1641 resbuf->tail[0].iov_len = 0;
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001642 resv = &resbuf->tail[0];
1643 } else {
1644 resv = &resbuf->tail[0];
1645 }
1646 mic.data = (u8 *)resv->iov_base + resv->iov_len + 4;
1647 if (gss_get_mic(gsd->rsci->mechctx, &integ_buf, &mic))
1648 goto out_err;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001649 svc_putnl(resv, mic.len);
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001650 memset(mic.data + mic.len, 0,
1651 round_up_to_quad(mic.len) - mic.len);
1652 resv->iov_len += XDR_QUADLEN(mic.len) << 2;
1653 /* not strictly required: */
1654 resbuf->len += XDR_QUADLEN(mic.len) << 2;
1655 BUG_ON(resv->iov_len > PAGE_SIZE);
1656out:
1657 stat = 0;
1658out_err:
1659 return stat;
1660}
1661
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001662static inline int
1663svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
1664{
1665 struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1666 struct rpc_gss_wire_cred *gc = &gsd->clcred;
1667 struct xdr_buf *resbuf = &rqstp->rq_res;
1668 struct page **inpages = NULL;
Al Viro753ed902006-09-26 22:30:23 -07001669 __be32 *p, *len;
1670 int offset;
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001671 int pad;
1672
J.Bruce Fields3c15a482006-10-04 02:16:06 -07001673 p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1674 if (p == NULL)
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001675 return 0;
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001676 len = p++;
1677 offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base;
1678 *p++ = htonl(gc->gc_seq);
1679 inpages = resbuf->pages;
1680 /* XXX: Would be better to write some xdr helper functions for
1681 * nfs{2,3,4}xdr.c that place the data right, instead of copying: */
Kevin Coffman75610422010-03-17 13:02:47 -04001682
1683 /*
1684 * If there is currently tail data, make sure there is
1685 * room for the head, tail, and 2 * RPC_MAX_AUTH_SIZE in
1686 * the page, and move the current tail data such that
1687 * there is RPC_MAX_AUTH_SIZE slack space available in
1688 * both the head and tail.
1689 */
NeilBrown44524352006-10-04 02:15:46 -07001690 if (resbuf->tail[0].iov_base) {
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001691 BUG_ON(resbuf->tail[0].iov_base >= resbuf->head[0].iov_base
1692 + PAGE_SIZE);
1693 BUG_ON(resbuf->tail[0].iov_base < resbuf->head[0].iov_base);
1694 if (resbuf->tail[0].iov_len + resbuf->head[0].iov_len
1695 + 2 * RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1696 return -ENOMEM;
1697 memmove(resbuf->tail[0].iov_base + RPC_MAX_AUTH_SIZE,
1698 resbuf->tail[0].iov_base,
1699 resbuf->tail[0].iov_len);
1700 resbuf->tail[0].iov_base += RPC_MAX_AUTH_SIZE;
1701 }
Kevin Coffman75610422010-03-17 13:02:47 -04001702 /*
1703 * If there is no current tail data, make sure there is
1704 * room for the head data, and 2 * RPC_MAX_AUTH_SIZE in the
1705 * allotted page, and set up tail information such that there
1706 * is RPC_MAX_AUTH_SIZE slack space available in both the
1707 * head and tail.
1708 */
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001709 if (resbuf->tail[0].iov_base == NULL) {
1710 if (resbuf->head[0].iov_len + 2*RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1711 return -ENOMEM;
1712 resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1713 + resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE;
1714 resbuf->tail[0].iov_len = 0;
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001715 }
1716 if (gss_wrap(gsd->rsci->mechctx, offset, resbuf, inpages))
1717 return -ENOMEM;
1718 *len = htonl(resbuf->len - offset);
1719 pad = 3 - ((resbuf->len - offset - 1)&3);
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001720 p = (__be32 *)(resbuf->tail[0].iov_base + resbuf->tail[0].iov_len);
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001721 memset(p, 0, pad);
1722 resbuf->tail[0].iov_len += pad;
1723 resbuf->len += pad;
1724 return 0;
1725}
1726
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001727static int
1728svcauth_gss_release(struct svc_rqst *rqstp)
1729{
1730 struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1731 struct rpc_gss_wire_cred *gc = &gsd->clcred;
1732 struct xdr_buf *resbuf = &rqstp->rq_res;
1733 int stat = -EINVAL;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001734 struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
J. Bruce Fieldse142ede2006-06-30 01:56:18 -07001735
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 if (gc->gc_proc != RPC_GSS_PROC_DATA)
1737 goto out;
1738 /* Release can be called twice, but we only wrap once. */
J.Bruce Fields5b304bc2006-10-04 02:16:07 -07001739 if (gsd->verf_start == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 goto out;
1741 /* normally not set till svc_send, but we need it here: */
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001742 /* XXX: what for? Do we mess it up the moment we call svc_putu32
1743 * or whatever? */
1744 resbuf->len = total_buf_len(resbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 switch (gc->gc_svc) {
1746 case RPC_GSS_SVC_NONE:
1747 break;
1748 case RPC_GSS_SVC_INTEGRITY:
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001749 stat = svcauth_gss_wrap_resp_integ(rqstp);
1750 if (stat)
1751 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 break;
1753 case RPC_GSS_SVC_PRIVACY:
J. Bruce Fields7c9fdcf2006-06-30 01:56:19 -07001754 stat = svcauth_gss_wrap_resp_priv(rqstp);
1755 if (stat)
1756 goto out_err;
1757 break;
Wei Yongjuneac81732009-08-04 17:27:52 +08001758 /*
1759 * For any other gc_svc value, svcauth_gss_accept() already set
1760 * the auth_error appropriately; just fall through:
1761 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
1763
1764out:
1765 stat = 0;
1766out_err:
1767 if (rqstp->rq_client)
1768 auth_domain_put(rqstp->rq_client);
1769 rqstp->rq_client = NULL;
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -07001770 if (rqstp->rq_gssclient)
1771 auth_domain_put(rqstp->rq_gssclient);
1772 rqstp->rq_gssclient = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 if (rqstp->rq_cred.cr_group_info)
1774 put_group_info(rqstp->rq_cred.cr_group_info);
1775 rqstp->rq_cred.cr_group_info = NULL;
1776 if (gsd->rsci)
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001777 cache_put(&gsd->rsci->h, sn->rsc_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 gsd->rsci = NULL;
1779
1780 return stat;
1781}
1782
1783static void
1784svcauth_gss_domain_release(struct auth_domain *dom)
1785{
1786 struct gss_domain *gd = container_of(dom, struct gss_domain, h);
1787
1788 kfree(dom->name);
1789 kfree(gd);
1790}
1791
1792static struct auth_ops svcauthops_gss = {
1793 .name = "rpcsec_gss",
1794 .owner = THIS_MODULE,
1795 .flavour = RPC_AUTH_GSS,
1796 .accept = svcauth_gss_accept,
1797 .release = svcauth_gss_release,
1798 .domain_release = svcauth_gss_domain_release,
1799 .set_client = svcauth_gss_set_client,
1800};
1801
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001802static int rsi_cache_create_net(struct net *net)
1803{
1804 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1805 struct cache_detail *cd;
1806 int err;
1807
1808 cd = cache_create_net(&rsi_cache_template, net);
1809 if (IS_ERR(cd))
1810 return PTR_ERR(cd);
1811 err = cache_register_net(cd, net);
1812 if (err) {
1813 cache_destroy_net(cd, net);
1814 return err;
1815 }
1816 sn->rsi_cache = cd;
1817 return 0;
1818}
1819
1820static void rsi_cache_destroy_net(struct net *net)
1821{
1822 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1823 struct cache_detail *cd = sn->rsi_cache;
1824
1825 sn->rsi_cache = NULL;
1826 cache_purge(cd);
1827 cache_unregister_net(cd, net);
1828 cache_destroy_net(cd, net);
1829}
1830
1831static int rsc_cache_create_net(struct net *net)
1832{
1833 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1834 struct cache_detail *cd;
1835 int err;
1836
1837 cd = cache_create_net(&rsc_cache_template, net);
1838 if (IS_ERR(cd))
1839 return PTR_ERR(cd);
1840 err = cache_register_net(cd, net);
1841 if (err) {
1842 cache_destroy_net(cd, net);
1843 return err;
1844 }
1845 sn->rsc_cache = cd;
1846 return 0;
1847}
1848
1849static void rsc_cache_destroy_net(struct net *net)
1850{
1851 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1852 struct cache_detail *cd = sn->rsc_cache;
1853
1854 sn->rsc_cache = NULL;
1855 cache_purge(cd);
1856 cache_unregister_net(cd, net);
1857 cache_destroy_net(cd, net);
1858}
1859
1860int
1861gss_svc_init_net(struct net *net)
1862{
1863 int rv;
1864
1865 rv = rsc_cache_create_net(net);
1866 if (rv)
1867 return rv;
1868 rv = rsi_cache_create_net(net);
1869 if (rv)
1870 goto out1;
Simo Sorce030d7942012-05-25 18:09:56 -04001871 rv = create_use_gss_proxy_proc_entry(net);
1872 if (rv)
1873 goto out2;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001874 return 0;
Simo Sorce030d7942012-05-25 18:09:56 -04001875out2:
1876 destroy_use_gss_proxy_proc_entry(net);
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001877out1:
1878 rsc_cache_destroy_net(net);
1879 return rv;
1880}
1881
1882void
1883gss_svc_shutdown_net(struct net *net)
1884{
Simo Sorce030d7942012-05-25 18:09:56 -04001885 destroy_use_gss_proxy_proc_entry(net);
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001886 rsi_cache_destroy_net(net);
1887 rsc_cache_destroy_net(net);
1888}
1889
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890int
1891gss_svc_init(void)
1892{
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04001893 return svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
1896void
1897gss_svc_shutdown(void)
1898{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 svc_auth_unregister(RPC_AUTH_GSS);
1900}