Branch data Line data Source code
1 : : // SPDX-License-Identifier: BSD-3-Clause
2 : : /*
3 : : * linux/net/sunrpc/auth_gss/auth_gss.c
4 : : *
5 : : * RPCSEC_GSS client authentication.
6 : : *
7 : : * Copyright (c) 2000 The Regents of the University of Michigan.
8 : : * All rights reserved.
9 : : *
10 : : * Dug Song <dugsong@monkey.org>
11 : : * Andy Adamson <andros@umich.edu>
12 : : */
13 : :
14 : : #include <linux/module.h>
15 : : #include <linux/init.h>
16 : : #include <linux/types.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/sched.h>
19 : : #include <linux/pagemap.h>
20 : : #include <linux/sunrpc/clnt.h>
21 : : #include <linux/sunrpc/auth.h>
22 : : #include <linux/sunrpc/auth_gss.h>
23 : : #include <linux/sunrpc/svcauth_gss.h>
24 : : #include <linux/sunrpc/gss_err.h>
25 : : #include <linux/workqueue.h>
26 : : #include <linux/sunrpc/rpc_pipe_fs.h>
27 : : #include <linux/sunrpc/gss_api.h>
28 : : #include <linux/uaccess.h>
29 : : #include <linux/hashtable.h>
30 : :
31 : : #include "../netns.h"
32 : :
33 : : #include <trace/events/rpcgss.h>
34 : :
35 : : static const struct rpc_authops authgss_ops;
36 : :
37 : : static const struct rpc_credops gss_credops;
38 : : static const struct rpc_credops gss_nullops;
39 : :
40 : : #define GSS_RETRY_EXPIRED 5
41 : : static unsigned int gss_expired_cred_retry_delay = GSS_RETRY_EXPIRED;
42 : :
43 : : #define GSS_KEY_EXPIRE_TIMEO 240
44 : : static unsigned int gss_key_expire_timeo = GSS_KEY_EXPIRE_TIMEO;
45 : :
46 : : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
47 : : # define RPCDBG_FACILITY RPCDBG_AUTH
48 : : #endif
49 : :
50 : : #define GSS_CRED_SLACK (RPC_MAX_AUTH_SIZE * 2)
51 : : /* length of a krb5 verifier (48), plus data added before arguments when
52 : : * using integrity (two 4-byte integers): */
53 : : #define GSS_VERF_SLACK 100
54 : :
55 : : static DEFINE_HASHTABLE(gss_auth_hash_table, 4);
56 : : static DEFINE_SPINLOCK(gss_auth_hash_lock);
57 : :
58 : : struct gss_pipe {
59 : : struct rpc_pipe_dir_object pdo;
60 : : struct rpc_pipe *pipe;
61 : : struct rpc_clnt *clnt;
62 : : const char *name;
63 : : struct kref kref;
64 : : };
65 : :
66 : : struct gss_auth {
67 : : struct kref kref;
68 : : struct hlist_node hash;
69 : : struct rpc_auth rpc_auth;
70 : : struct gss_api_mech *mech;
71 : : enum rpc_gss_svc service;
72 : : struct rpc_clnt *client;
73 : : struct net *net;
74 : : /*
75 : : * There are two upcall pipes; dentry[1], named "gssd", is used
76 : : * for the new text-based upcall; dentry[0] is named after the
77 : : * mechanism (for example, "krb5") and exists for
78 : : * backwards-compatibility with older gssd's.
79 : : */
80 : : struct gss_pipe *gss_pipe[2];
81 : : const char *target_name;
82 : : };
83 : :
84 : : /* pipe_version >= 0 if and only if someone has a pipe open. */
85 : : static DEFINE_SPINLOCK(pipe_version_lock);
86 : : static struct rpc_wait_queue pipe_version_rpc_waitqueue;
87 : : static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue);
88 : : static void gss_put_auth(struct gss_auth *gss_auth);
89 : :
90 : : static void gss_free_ctx(struct gss_cl_ctx *);
91 : : static const struct rpc_pipe_ops gss_upcall_ops_v0;
92 : : static const struct rpc_pipe_ops gss_upcall_ops_v1;
93 : :
94 : : static inline struct gss_cl_ctx *
95 : 0 : gss_get_ctx(struct gss_cl_ctx *ctx)
96 : : {
97 : 0 : refcount_inc(&ctx->count);
98 : 0 : return ctx;
99 : : }
100 : :
101 : : static inline void
102 : 0 : gss_put_ctx(struct gss_cl_ctx *ctx)
103 : : {
104 [ # # ]: 0 : if (refcount_dec_and_test(&ctx->count))
105 : 0 : gss_free_ctx(ctx);
106 : 0 : }
107 : :
108 : : /* gss_cred_set_ctx:
109 : : * called by gss_upcall_callback and gss_create_upcall in order
110 : : * to set the gss context. The actual exchange of an old context
111 : : * and a new one is protected by the pipe->lock.
112 : : */
113 : : static void
114 : 0 : gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
115 : : {
116 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
117 : :
118 [ # # ]: 0 : if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
119 : : return;
120 : 0 : gss_get_ctx(ctx);
121 : 0 : rcu_assign_pointer(gss_cred->gc_ctx, ctx);
122 : 0 : set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
123 : 0 : smp_mb__before_atomic();
124 : 0 : clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);
125 : : }
126 : :
127 : : static const void *
128 : 0 : simple_get_bytes(const void *p, const void *end, void *res, size_t len)
129 : : {
130 : 0 : const void *q = (const void *)((const char *)p + len);
131 : 0 : if (unlikely(q > end || q < p))
132 : : return ERR_PTR(-EFAULT);
133 : 0 : memcpy(res, p, len);
134 : 0 : return q;
135 : : }
136 : :
137 : : static inline const void *
138 : : simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)
139 : : {
140 : : const void *q;
141 : : unsigned int len;
142 : :
143 : : p = simple_get_bytes(p, end, &len, sizeof(len));
144 : : if (IS_ERR(p))
145 : : return p;
146 : : q = (const void *)((const char *)p + len);
147 : : if (unlikely(q > end || q < p))
148 : : return ERR_PTR(-EFAULT);
149 : : dest->data = kmemdup(p, len, GFP_NOFS);
150 : : if (unlikely(dest->data == NULL))
151 : : return ERR_PTR(-ENOMEM);
152 : : dest->len = len;
153 : : return q;
154 : : }
155 : :
156 : : static struct gss_cl_ctx *
157 : 0 : gss_cred_get_ctx(struct rpc_cred *cred)
158 : : {
159 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
160 : 0 : struct gss_cl_ctx *ctx = NULL;
161 : :
162 : 0 : rcu_read_lock();
163 [ # # # # : 0 : ctx = rcu_dereference(gss_cred->gc_ctx);
# # # # #
# ]
164 [ # # # # : 0 : if (ctx)
# # # # #
# ]
165 : 0 : gss_get_ctx(ctx);
166 : 0 : rcu_read_unlock();
167 : 0 : return ctx;
168 : : }
169 : :
170 : : static struct gss_cl_ctx *
171 : 0 : gss_alloc_context(void)
172 : : {
173 : 0 : struct gss_cl_ctx *ctx;
174 : :
175 : 0 : ctx = kzalloc(sizeof(*ctx), GFP_NOFS);
176 [ # # ]: 0 : if (ctx != NULL) {
177 : 0 : ctx->gc_proc = RPC_GSS_PROC_DATA;
178 : 0 : ctx->gc_seq = 1; /* NetApp 6.4R1 doesn't accept seq. no. 0 */
179 : 0 : spin_lock_init(&ctx->gc_seq_lock);
180 : 0 : refcount_set(&ctx->count,1);
181 : : }
182 : 0 : return ctx;
183 : : }
184 : :
185 : : #define GSSD_MIN_TIMEOUT (60 * 60)
186 : : static const void *
187 : 0 : gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)
188 : : {
189 : 0 : const void *q;
190 : 0 : unsigned int seclen;
191 : 0 : unsigned int timeout;
192 : 0 : unsigned long now = jiffies;
193 : 0 : u32 window_size;
194 : 0 : int ret;
195 : :
196 : : /* First unsigned int gives the remaining lifetime in seconds of the
197 : : * credential - e.g. the remaining TGT lifetime for Kerberos or
198 : : * the -t value passed to GSSD.
199 : : */
200 [ # # ]: 0 : p = simple_get_bytes(p, end, &timeout, sizeof(timeout));
201 [ # # ]: 0 : if (IS_ERR(p))
202 : 0 : goto err;
203 [ # # ]: 0 : if (timeout == 0)
204 : 0 : timeout = GSSD_MIN_TIMEOUT;
205 : 0 : ctx->gc_expiry = now + ((unsigned long)timeout * HZ);
206 : : /* Sequence number window. Determines the maximum number of
207 : : * simultaneous requests
208 : : */
209 [ # # ]: 0 : p = simple_get_bytes(p, end, &window_size, sizeof(window_size));
210 [ # # ]: 0 : if (IS_ERR(p))
211 : 0 : goto err;
212 : 0 : ctx->gc_win = window_size;
213 : : /* gssd signals an error by passing ctx->gc_win = 0: */
214 [ # # ]: 0 : if (ctx->gc_win == 0) {
215 : : /*
216 : : * in which case, p points to an error code. Anything other
217 : : * than -EKEYEXPIRED gets converted to -EACCES.
218 : : */
219 [ # # ]: 0 : p = simple_get_bytes(p, end, &ret, sizeof(ret));
220 [ # # ]: 0 : if (!IS_ERR(p))
221 [ # # ]: 0 : p = (ret == -EKEYEXPIRED) ? ERR_PTR(-EKEYEXPIRED) :
222 : : ERR_PTR(-EACCES);
223 : 0 : goto err;
224 : : }
225 : : /* copy the opaque wire context */
226 : 0 : p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);
227 [ # # ]: 0 : if (IS_ERR(p))
228 : 0 : goto err;
229 : : /* import the opaque security context */
230 [ # # ]: 0 : p = simple_get_bytes(p, end, &seclen, sizeof(seclen));
231 [ # # ]: 0 : if (IS_ERR(p))
232 : 0 : goto err;
233 : 0 : q = (const void *)((const char *)p + seclen);
234 [ # # ]: 0 : if (unlikely(q > end || q < p)) {
235 : 0 : p = ERR_PTR(-EFAULT);
236 : 0 : goto err;
237 : : }
238 : 0 : ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx, NULL, GFP_NOFS);
239 [ # # ]: 0 : if (ret < 0) {
240 : 0 : trace_rpcgss_import_ctx(ret);
241 : 0 : p = ERR_PTR(ret);
242 : 0 : goto err;
243 : : }
244 : :
245 : : /* is there any trailing data? */
246 [ # # ]: 0 : if (q == end) {
247 : 0 : p = q;
248 : 0 : goto done;
249 : : }
250 : :
251 : : /* pull in acceptor name (if there is one) */
252 : 0 : p = simple_get_netobj(q, end, &ctx->gc_acceptor);
253 [ # # ]: 0 : if (IS_ERR(p))
254 : 0 : goto err;
255 : 0 : done:
256 : 0 : trace_rpcgss_context(ctx->gc_expiry, now, timeout,
257 : 0 : ctx->gc_acceptor.len, ctx->gc_acceptor.data);
258 : 0 : err:
259 : 0 : return p;
260 : : }
261 : :
262 : : /* XXX: Need some documentation about why UPCALL_BUF_LEN is so small.
263 : : * Is user space expecting no more than UPCALL_BUF_LEN bytes?
264 : : * Note that there are now _two_ NI_MAXHOST sized data items
265 : : * being passed in this string.
266 : : */
267 : : #define UPCALL_BUF_LEN 256
268 : :
269 : : struct gss_upcall_msg {
270 : : refcount_t count;
271 : : kuid_t uid;
272 : : const char *service_name;
273 : : struct rpc_pipe_msg msg;
274 : : struct list_head list;
275 : : struct gss_auth *auth;
276 : : struct rpc_pipe *pipe;
277 : : struct rpc_wait_queue rpc_waitqueue;
278 : : wait_queue_head_t waitqueue;
279 : : struct gss_cl_ctx *ctx;
280 : : char databuf[UPCALL_BUF_LEN];
281 : : };
282 : :
283 : 0 : static int get_pipe_version(struct net *net)
284 : : {
285 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
286 : 0 : int ret;
287 : :
288 : 0 : spin_lock(&pipe_version_lock);
289 [ # # ]: 0 : if (sn->pipe_version >= 0) {
290 : 0 : atomic_inc(&sn->pipe_users);
291 : 0 : ret = sn->pipe_version;
292 : : } else
293 : : ret = -EAGAIN;
294 : 0 : spin_unlock(&pipe_version_lock);
295 : 0 : return ret;
296 : : }
297 : :
298 : 0 : static void put_pipe_version(struct net *net)
299 : : {
300 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
301 : :
302 [ # # ]: 0 : if (atomic_dec_and_lock(&sn->pipe_users, &pipe_version_lock)) {
303 : 0 : sn->pipe_version = -1;
304 : 0 : spin_unlock(&pipe_version_lock);
305 : : }
306 : 0 : }
307 : :
308 : : static void
309 : 0 : gss_release_msg(struct gss_upcall_msg *gss_msg)
310 : : {
311 : 0 : struct net *net = gss_msg->auth->net;
312 [ # # ]: 0 : if (!refcount_dec_and_test(&gss_msg->count))
313 : : return;
314 : 0 : put_pipe_version(net);
315 [ # # ]: 0 : BUG_ON(!list_empty(&gss_msg->list));
316 [ # # ]: 0 : if (gss_msg->ctx != NULL)
317 : 0 : gss_put_ctx(gss_msg->ctx);
318 : 0 : rpc_destroy_wait_queue(&gss_msg->rpc_waitqueue);
319 : 0 : gss_put_auth(gss_msg->auth);
320 : 0 : kfree_const(gss_msg->service_name);
321 : 0 : kfree(gss_msg);
322 : : }
323 : :
324 : : static struct gss_upcall_msg *
325 : 0 : __gss_find_upcall(struct rpc_pipe *pipe, kuid_t uid, const struct gss_auth *auth)
326 : : {
327 : 0 : struct gss_upcall_msg *pos;
328 [ # # # # ]: 0 : list_for_each_entry(pos, &pipe->in_downcall, list) {
329 [ # # # # ]: 0 : if (!uid_eq(pos->uid, uid))
330 : 0 : continue;
331 [ # # # # ]: 0 : if (auth && pos->auth->service != auth->service)
332 : 0 : continue;
333 : 0 : refcount_inc(&pos->count);
334 : 0 : return pos;
335 : : }
336 : : return NULL;
337 : : }
338 : :
339 : : /* Try to add an upcall to the pipefs queue.
340 : : * If an upcall owned by our uid already exists, then we return a reference
341 : : * to that upcall instead of adding the new upcall.
342 : : */
343 : : static inline struct gss_upcall_msg *
344 : 0 : gss_add_msg(struct gss_upcall_msg *gss_msg)
345 : : {
346 : 0 : struct rpc_pipe *pipe = gss_msg->pipe;
347 : 0 : struct gss_upcall_msg *old;
348 : :
349 : 0 : spin_lock(&pipe->lock);
350 : 0 : old = __gss_find_upcall(pipe, gss_msg->uid, gss_msg->auth);
351 [ # # ]: 0 : if (old == NULL) {
352 : 0 : refcount_inc(&gss_msg->count);
353 : 0 : list_add(&gss_msg->list, &pipe->in_downcall);
354 : : } else
355 : : gss_msg = old;
356 : 0 : spin_unlock(&pipe->lock);
357 : 0 : return gss_msg;
358 : : }
359 : :
360 : : static void
361 : 0 : __gss_unhash_msg(struct gss_upcall_msg *gss_msg)
362 : : {
363 : 0 : list_del_init(&gss_msg->list);
364 : 0 : rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
365 : 0 : wake_up_all(&gss_msg->waitqueue);
366 : 0 : refcount_dec(&gss_msg->count);
367 : 0 : }
368 : :
369 : : static void
370 : 0 : gss_unhash_msg(struct gss_upcall_msg *gss_msg)
371 : : {
372 : 0 : struct rpc_pipe *pipe = gss_msg->pipe;
373 : :
374 [ # # ]: 0 : if (list_empty(&gss_msg->list))
375 : : return;
376 : 0 : spin_lock(&pipe->lock);
377 [ # # ]: 0 : if (!list_empty(&gss_msg->list))
378 : 0 : __gss_unhash_msg(gss_msg);
379 : 0 : spin_unlock(&pipe->lock);
380 : : }
381 : :
382 : : static void
383 : 0 : gss_handle_downcall_result(struct gss_cred *gss_cred, struct gss_upcall_msg *gss_msg)
384 : : {
385 [ # # # ]: 0 : switch (gss_msg->msg.errno) {
386 : 0 : case 0:
387 [ # # ]: 0 : if (gss_msg->ctx == NULL)
388 : : break;
389 : 0 : clear_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);
390 : 0 : gss_cred_set_ctx(&gss_cred->gc_base, gss_msg->ctx);
391 : 0 : break;
392 : 0 : case -EKEYEXPIRED:
393 : 0 : set_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);
394 : : }
395 : 0 : gss_cred->gc_upcall_timestamp = jiffies;
396 : 0 : gss_cred->gc_upcall = NULL;
397 : 0 : rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
398 : 0 : }
399 : :
400 : : static void
401 : 0 : gss_upcall_callback(struct rpc_task *task)
402 : : {
403 : 0 : struct gss_cred *gss_cred = container_of(task->tk_rqstp->rq_cred,
404 : : struct gss_cred, gc_base);
405 : 0 : struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;
406 : 0 : struct rpc_pipe *pipe = gss_msg->pipe;
407 : :
408 : 0 : spin_lock(&pipe->lock);
409 : 0 : gss_handle_downcall_result(gss_cred, gss_msg);
410 : 0 : spin_unlock(&pipe->lock);
411 : 0 : task->tk_status = gss_msg->msg.errno;
412 : 0 : gss_release_msg(gss_msg);
413 : 0 : }
414 : :
415 : 0 : static void gss_encode_v0_msg(struct gss_upcall_msg *gss_msg,
416 : : const struct cred *cred)
417 : : {
418 : 0 : struct user_namespace *userns = cred->user_ns;
419 : :
420 : 0 : uid_t uid = from_kuid_munged(userns, gss_msg->uid);
421 : 0 : memcpy(gss_msg->databuf, &uid, sizeof(uid));
422 : 0 : gss_msg->msg.data = gss_msg->databuf;
423 : 0 : gss_msg->msg.len = sizeof(uid);
424 : :
425 : 0 : BUILD_BUG_ON(sizeof(uid) > sizeof(gss_msg->databuf));
426 : 0 : }
427 : :
428 : : static ssize_t
429 : 0 : gss_v0_upcall(struct file *file, struct rpc_pipe_msg *msg,
430 : : char __user *buf, size_t buflen)
431 : : {
432 : 0 : struct gss_upcall_msg *gss_msg = container_of(msg,
433 : : struct gss_upcall_msg,
434 : : msg);
435 [ # # ]: 0 : if (msg->copied == 0)
436 [ # # ]: 0 : gss_encode_v0_msg(gss_msg, file->f_cred);
437 : 0 : return rpc_pipe_generic_upcall(file, msg, buf, buflen);
438 : : }
439 : :
440 : : static int gss_encode_v1_msg(struct gss_upcall_msg *gss_msg,
441 : : const char *service_name,
442 : : const char *target_name,
443 : : const struct cred *cred)
444 : : {
445 : : struct user_namespace *userns = cred->user_ns;
446 : : struct gss_api_mech *mech = gss_msg->auth->mech;
447 : : char *p = gss_msg->databuf;
448 : : size_t buflen = sizeof(gss_msg->databuf);
449 : : int len;
450 : :
451 : : len = scnprintf(p, buflen, "mech=%s uid=%d", mech->gm_name,
452 : : from_kuid_munged(userns, gss_msg->uid));
453 : : buflen -= len;
454 : : p += len;
455 : : gss_msg->msg.len = len;
456 : :
457 : : /*
458 : : * target= is a full service principal that names the remote
459 : : * identity that we are authenticating to.
460 : : */
461 : : if (target_name) {
462 : : len = scnprintf(p, buflen, " target=%s", target_name);
463 : : buflen -= len;
464 : : p += len;
465 : : gss_msg->msg.len += len;
466 : : }
467 : :
468 : : /*
469 : : * gssd uses service= and srchost= to select a matching key from
470 : : * the system's keytab to use as the source principal.
471 : : *
472 : : * service= is the service name part of the source principal,
473 : : * or "*" (meaning choose any).
474 : : *
475 : : * srchost= is the hostname part of the source principal. When
476 : : * not provided, gssd uses the local hostname.
477 : : */
478 : : if (service_name) {
479 : : char *c = strchr(service_name, '@');
480 : :
481 : : if (!c)
482 : : len = scnprintf(p, buflen, " service=%s",
483 : : service_name);
484 : : else
485 : : len = scnprintf(p, buflen,
486 : : " service=%.*s srchost=%s",
487 : : (int)(c - service_name),
488 : : service_name, c + 1);
489 : : buflen -= len;
490 : : p += len;
491 : : gss_msg->msg.len += len;
492 : : }
493 : :
494 : : if (mech->gm_upcall_enctypes) {
495 : : len = scnprintf(p, buflen, " enctypes=%s",
496 : : mech->gm_upcall_enctypes);
497 : : buflen -= len;
498 : : p += len;
499 : : gss_msg->msg.len += len;
500 : : }
501 : : trace_rpcgss_upcall_msg(gss_msg->databuf);
502 : : len = scnprintf(p, buflen, "\n");
503 : : if (len == 0)
504 : : goto out_overflow;
505 : : gss_msg->msg.len += len;
506 : : gss_msg->msg.data = gss_msg->databuf;
507 : : return 0;
508 : : out_overflow:
509 : : WARN_ON_ONCE(1);
510 : : return -ENOMEM;
511 : : }
512 : :
513 : : static ssize_t
514 : 0 : gss_v1_upcall(struct file *file, struct rpc_pipe_msg *msg,
515 : : char __user *buf, size_t buflen)
516 : : {
517 : 0 : struct gss_upcall_msg *gss_msg = container_of(msg,
518 : : struct gss_upcall_msg,
519 : : msg);
520 : 0 : int err;
521 [ # # ]: 0 : if (msg->copied == 0) {
522 : 0 : err = gss_encode_v1_msg(gss_msg,
523 : : gss_msg->service_name,
524 : 0 : gss_msg->auth->target_name,
525 : : file->f_cred);
526 [ # # ]: 0 : if (err)
527 : 0 : return err;
528 : : }
529 : 0 : return rpc_pipe_generic_upcall(file, msg, buf, buflen);
530 : : }
531 : :
532 : : static struct gss_upcall_msg *
533 : 0 : gss_alloc_msg(struct gss_auth *gss_auth,
534 : : kuid_t uid, const char *service_name)
535 : : {
536 : 0 : struct gss_upcall_msg *gss_msg;
537 : 0 : int vers;
538 : 0 : int err = -ENOMEM;
539 : :
540 : 0 : gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);
541 [ # # ]: 0 : if (gss_msg == NULL)
542 : 0 : goto err;
543 : 0 : vers = get_pipe_version(gss_auth->net);
544 : 0 : err = vers;
545 [ # # ]: 0 : if (err < 0)
546 : 0 : goto err_free_msg;
547 : 0 : gss_msg->pipe = gss_auth->gss_pipe[vers]->pipe;
548 : 0 : INIT_LIST_HEAD(&gss_msg->list);
549 : 0 : rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
550 : 0 : init_waitqueue_head(&gss_msg->waitqueue);
551 : 0 : refcount_set(&gss_msg->count, 1);
552 : 0 : gss_msg->uid = uid;
553 : 0 : gss_msg->auth = gss_auth;
554 : 0 : kref_get(&gss_auth->kref);
555 [ # # ]: 0 : if (service_name) {
556 : 0 : gss_msg->service_name = kstrdup_const(service_name, GFP_NOFS);
557 [ # # ]: 0 : if (!gss_msg->service_name) {
558 : 0 : err = -ENOMEM;
559 : 0 : goto err_put_pipe_version;
560 : : }
561 : : }
562 : : return gss_msg;
563 : : err_put_pipe_version:
564 : 0 : put_pipe_version(gss_auth->net);
565 : 0 : err_free_msg:
566 : 0 : kfree(gss_msg);
567 : 0 : err:
568 : 0 : return ERR_PTR(err);
569 : : }
570 : :
571 : : static struct gss_upcall_msg *
572 : 0 : gss_setup_upcall(struct gss_auth *gss_auth, struct rpc_cred *cred)
573 : : {
574 : 0 : struct gss_cred *gss_cred = container_of(cred,
575 : : struct gss_cred, gc_base);
576 : 0 : struct gss_upcall_msg *gss_new, *gss_msg;
577 : 0 : kuid_t uid = cred->cr_cred->fsuid;
578 : :
579 : 0 : gss_new = gss_alloc_msg(gss_auth, uid, gss_cred->gc_principal);
580 [ # # ]: 0 : if (IS_ERR(gss_new))
581 : : return gss_new;
582 : 0 : gss_msg = gss_add_msg(gss_new);
583 [ # # ]: 0 : if (gss_msg == gss_new) {
584 : 0 : int res;
585 : 0 : refcount_inc(&gss_msg->count);
586 : 0 : res = rpc_queue_upcall(gss_new->pipe, &gss_new->msg);
587 [ # # ]: 0 : if (res) {
588 : 0 : gss_unhash_msg(gss_new);
589 : 0 : refcount_dec(&gss_msg->count);
590 : 0 : gss_release_msg(gss_new);
591 : 0 : gss_msg = ERR_PTR(res);
592 : : }
593 : : } else
594 : 0 : gss_release_msg(gss_new);
595 : : return gss_msg;
596 : : }
597 : :
598 : 0 : static void warn_gssd(void)
599 : : {
600 : 0 : dprintk("AUTH_GSS upcall failed. Please check user daemon is running.\n");
601 : : }
602 : :
603 : : static inline int
604 : 0 : gss_refresh_upcall(struct rpc_task *task)
605 : : {
606 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
607 : 0 : struct gss_auth *gss_auth = container_of(cred->cr_auth,
608 : : struct gss_auth, rpc_auth);
609 : 0 : struct gss_cred *gss_cred = container_of(cred,
610 : : struct gss_cred, gc_base);
611 : 0 : struct gss_upcall_msg *gss_msg;
612 : 0 : struct rpc_pipe *pipe;
613 : 0 : int err = 0;
614 : :
615 : 0 : gss_msg = gss_setup_upcall(gss_auth, cred);
616 [ # # ]: 0 : if (PTR_ERR(gss_msg) == -EAGAIN) {
617 : : /* XXX: warning on the first, under the assumption we
618 : : * shouldn't normally hit this case on a refresh. */
619 : 0 : warn_gssd();
620 : 0 : rpc_sleep_on_timeout(&pipe_version_rpc_waitqueue,
621 : : task, NULL, jiffies + (15 * HZ));
622 : 0 : err = -EAGAIN;
623 : 0 : goto out;
624 : : }
625 [ # # ]: 0 : if (IS_ERR(gss_msg)) {
626 : 0 : err = PTR_ERR(gss_msg);
627 : 0 : goto out;
628 : : }
629 : 0 : pipe = gss_msg->pipe;
630 : 0 : spin_lock(&pipe->lock);
631 [ # # ]: 0 : if (gss_cred->gc_upcall != NULL)
632 : 0 : rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL);
633 [ # # # # ]: 0 : else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {
634 : 0 : gss_cred->gc_upcall = gss_msg;
635 : : /* gss_upcall_callback will release the reference to gss_upcall_msg */
636 : 0 : refcount_inc(&gss_msg->count);
637 : 0 : rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback);
638 : : } else {
639 : 0 : gss_handle_downcall_result(gss_cred, gss_msg);
640 : 0 : err = gss_msg->msg.errno;
641 : : }
642 : 0 : spin_unlock(&pipe->lock);
643 : 0 : gss_release_msg(gss_msg);
644 : 0 : out:
645 : 0 : trace_rpcgss_upcall_result(from_kuid(&init_user_ns,
646 : 0 : cred->cr_cred->fsuid), err);
647 : 0 : return err;
648 : : }
649 : :
650 : : static inline int
651 : 0 : gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
652 : : {
653 : 0 : struct net *net = gss_auth->net;
654 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
655 : 0 : struct rpc_pipe *pipe;
656 : 0 : struct rpc_cred *cred = &gss_cred->gc_base;
657 : 0 : struct gss_upcall_msg *gss_msg;
658 : 0 : DEFINE_WAIT(wait);
659 : 0 : int err;
660 : :
661 : 0 : retry:
662 : 0 : err = 0;
663 : : /* if gssd is down, just skip upcalling altogether */
664 [ # # ]: 0 : if (!gssd_running(net)) {
665 : 0 : warn_gssd();
666 : 0 : err = -EACCES;
667 : 0 : goto out;
668 : : }
669 : 0 : gss_msg = gss_setup_upcall(gss_auth, cred);
670 [ # # ]: 0 : if (PTR_ERR(gss_msg) == -EAGAIN) {
671 [ # # # # : 0 : err = wait_event_interruptible_timeout(pipe_version_waitqueue,
# # # # ]
672 : : sn->pipe_version >= 0, 15 * HZ);
673 [ # # ]: 0 : if (sn->pipe_version < 0) {
674 : : warn_gssd();
675 : : err = -EACCES;
676 : : }
677 [ # # ]: 0 : if (err < 0)
678 : 0 : goto out;
679 : 0 : goto retry;
680 : : }
681 [ # # ]: 0 : if (IS_ERR(gss_msg)) {
682 : 0 : err = PTR_ERR(gss_msg);
683 : 0 : goto out;
684 : : }
685 : 0 : pipe = gss_msg->pipe;
686 : 0 : for (;;) {
687 : 0 : prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_KILLABLE);
688 : 0 : spin_lock(&pipe->lock);
689 [ # # # # ]: 0 : if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {
690 : : break;
691 : : }
692 : 0 : spin_unlock(&pipe->lock);
693 [ # # ]: 0 : if (fatal_signal_pending(current)) {
694 : 0 : err = -ERESTARTSYS;
695 : 0 : goto out_intr;
696 : : }
697 : 0 : schedule();
698 : : }
699 [ # # ]: 0 : if (gss_msg->ctx)
700 : 0 : gss_cred_set_ctx(cred, gss_msg->ctx);
701 : : else
702 : 0 : err = gss_msg->msg.errno;
703 : 0 : spin_unlock(&pipe->lock);
704 : 0 : out_intr:
705 : 0 : finish_wait(&gss_msg->waitqueue, &wait);
706 : 0 : gss_release_msg(gss_msg);
707 : 0 : out:
708 : 0 : trace_rpcgss_upcall_result(from_kuid(&init_user_ns,
709 : 0 : cred->cr_cred->fsuid), err);
710 : 0 : return err;
711 : : }
712 : :
713 : : #define MSG_BUF_MAXSIZE 1024
714 : :
715 : : static ssize_t
716 : 0 : gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
717 : : {
718 : 0 : const void *p, *end;
719 : 0 : void *buf;
720 : 0 : struct gss_upcall_msg *gss_msg;
721 [ # # ]: 0 : struct rpc_pipe *pipe = RPC_I(file_inode(filp))->pipe;
722 : 0 : struct gss_cl_ctx *ctx;
723 : 0 : uid_t id;
724 : 0 : kuid_t uid;
725 : 0 : ssize_t err = -EFBIG;
726 : :
727 [ # # ]: 0 : if (mlen > MSG_BUF_MAXSIZE)
728 : 0 : goto out;
729 : 0 : err = -ENOMEM;
730 [ # # ]: 0 : buf = kmalloc(mlen, GFP_NOFS);
731 [ # # ]: 0 : if (!buf)
732 : 0 : goto out;
733 : :
734 : 0 : err = -EFAULT;
735 [ # # # # ]: 0 : if (copy_from_user(buf, src, mlen))
736 : 0 : goto err;
737 : :
738 : 0 : end = (const void *)((char *)buf + mlen);
739 [ # # ]: 0 : p = simple_get_bytes(buf, end, &id, sizeof(id));
740 [ # # ]: 0 : if (IS_ERR(p)) {
741 : 0 : err = PTR_ERR(p);
742 : 0 : goto err;
743 : : }
744 : :
745 [ # # ]: 0 : uid = make_kuid(current_user_ns(), id);
746 [ # # ]: 0 : if (!uid_valid(uid)) {
747 : 0 : err = -EINVAL;
748 : 0 : goto err;
749 : : }
750 : :
751 : 0 : err = -ENOMEM;
752 : 0 : ctx = gss_alloc_context();
753 [ # # ]: 0 : if (ctx == NULL)
754 : 0 : goto err;
755 : :
756 : 0 : err = -ENOENT;
757 : : /* Find a matching upcall */
758 : 0 : spin_lock(&pipe->lock);
759 : 0 : gss_msg = __gss_find_upcall(pipe, uid, NULL);
760 [ # # ]: 0 : if (gss_msg == NULL) {
761 : 0 : spin_unlock(&pipe->lock);
762 : 0 : goto err_put_ctx;
763 : : }
764 : 0 : list_del_init(&gss_msg->list);
765 : 0 : spin_unlock(&pipe->lock);
766 : :
767 : 0 : p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
768 [ # # ]: 0 : if (IS_ERR(p)) {
769 [ # # # ]: 0 : err = PTR_ERR(p);
770 [ # # # ]: 0 : switch (err) {
771 : 0 : case -EACCES:
772 : : case -EKEYEXPIRED:
773 : 0 : gss_msg->msg.errno = err;
774 : 0 : err = mlen;
775 : 0 : break;
776 : 0 : case -EFAULT:
777 : : case -ENOMEM:
778 : : case -EINVAL:
779 : : case -ENOSYS:
780 : 0 : gss_msg->msg.errno = -EAGAIN;
781 : 0 : break;
782 : 0 : default:
783 : 0 : printk(KERN_CRIT "%s: bad return from "
784 : : "gss_fill_context: %zd\n", __func__, err);
785 : 0 : gss_msg->msg.errno = -EIO;
786 : : }
787 : 0 : goto err_release_msg;
788 : : }
789 : 0 : gss_msg->ctx = gss_get_ctx(ctx);
790 : 0 : err = mlen;
791 : :
792 : 0 : err_release_msg:
793 : 0 : spin_lock(&pipe->lock);
794 : 0 : __gss_unhash_msg(gss_msg);
795 : 0 : spin_unlock(&pipe->lock);
796 : 0 : gss_release_msg(gss_msg);
797 : 0 : err_put_ctx:
798 : 0 : gss_put_ctx(ctx);
799 : 0 : err:
800 : 0 : kfree(buf);
801 : 0 : out:
802 : 0 : return err;
803 : : }
804 : :
805 : : static int gss_pipe_open(struct inode *inode, int new_version)
806 : : {
807 : : struct net *net = inode->i_sb->s_fs_info;
808 : : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
809 : : int ret = 0;
810 : :
811 : : spin_lock(&pipe_version_lock);
812 : : if (sn->pipe_version < 0) {
813 : : /* First open of any gss pipe determines the version: */
814 : : sn->pipe_version = new_version;
815 : : rpc_wake_up(&pipe_version_rpc_waitqueue);
816 : : wake_up(&pipe_version_waitqueue);
817 : : } else if (sn->pipe_version != new_version) {
818 : : /* Trying to open a pipe of a different version */
819 : : ret = -EBUSY;
820 : : goto out;
821 : : }
822 : : atomic_inc(&sn->pipe_users);
823 : : out:
824 : : spin_unlock(&pipe_version_lock);
825 : : return ret;
826 : :
827 : : }
828 : :
829 : 0 : static int gss_pipe_open_v0(struct inode *inode)
830 : : {
831 : 0 : return gss_pipe_open(inode, 0);
832 : : }
833 : :
834 : 0 : static int gss_pipe_open_v1(struct inode *inode)
835 : : {
836 : 0 : return gss_pipe_open(inode, 1);
837 : : }
838 : :
839 : : static void
840 : 0 : gss_pipe_release(struct inode *inode)
841 : : {
842 : 0 : struct net *net = inode->i_sb->s_fs_info;
843 : 0 : struct rpc_pipe *pipe = RPC_I(inode)->pipe;
844 : 0 : struct gss_upcall_msg *gss_msg;
845 : :
846 : 0 : restart:
847 : 0 : spin_lock(&pipe->lock);
848 [ # # ]: 0 : list_for_each_entry(gss_msg, &pipe->in_downcall, list) {
849 : :
850 [ # # ]: 0 : if (!list_empty(&gss_msg->msg.list))
851 : 0 : continue;
852 : 0 : gss_msg->msg.errno = -EPIPE;
853 : 0 : refcount_inc(&gss_msg->count);
854 : 0 : __gss_unhash_msg(gss_msg);
855 : 0 : spin_unlock(&pipe->lock);
856 : 0 : gss_release_msg(gss_msg);
857 : 0 : goto restart;
858 : : }
859 : 0 : spin_unlock(&pipe->lock);
860 : :
861 : 0 : put_pipe_version(net);
862 : 0 : }
863 : :
864 : : static void
865 : 0 : gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
866 : : {
867 : 0 : struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);
868 : :
869 [ # # ]: 0 : if (msg->errno < 0) {
870 : 0 : refcount_inc(&gss_msg->count);
871 : 0 : gss_unhash_msg(gss_msg);
872 : 0 : if (msg->errno == -ETIMEDOUT)
873 : : warn_gssd();
874 : 0 : gss_release_msg(gss_msg);
875 : : }
876 : 0 : gss_release_msg(gss_msg);
877 : 0 : }
878 : :
879 : 0 : static void gss_pipe_dentry_destroy(struct dentry *dir,
880 : : struct rpc_pipe_dir_object *pdo)
881 : : {
882 : 0 : struct gss_pipe *gss_pipe = pdo->pdo_data;
883 : 0 : struct rpc_pipe *pipe = gss_pipe->pipe;
884 : :
885 [ # # ]: 0 : if (pipe->dentry != NULL) {
886 : 0 : rpc_unlink(pipe->dentry);
887 : 0 : pipe->dentry = NULL;
888 : : }
889 : 0 : }
890 : :
891 : 0 : static int gss_pipe_dentry_create(struct dentry *dir,
892 : : struct rpc_pipe_dir_object *pdo)
893 : : {
894 : 0 : struct gss_pipe *p = pdo->pdo_data;
895 : 0 : struct dentry *dentry;
896 : :
897 : 0 : dentry = rpc_mkpipe_dentry(dir, p->name, p->clnt, p->pipe);
898 [ # # ]: 0 : if (IS_ERR(dentry))
899 : 0 : return PTR_ERR(dentry);
900 : 0 : p->pipe->dentry = dentry;
901 : 0 : return 0;
902 : : }
903 : :
904 : : static const struct rpc_pipe_dir_object_ops gss_pipe_dir_object_ops = {
905 : : .create = gss_pipe_dentry_create,
906 : : .destroy = gss_pipe_dentry_destroy,
907 : : };
908 : :
909 : 0 : static struct gss_pipe *gss_pipe_alloc(struct rpc_clnt *clnt,
910 : : const char *name,
911 : : const struct rpc_pipe_ops *upcall_ops)
912 : : {
913 : 0 : struct gss_pipe *p;
914 : 0 : int err = -ENOMEM;
915 : :
916 : 0 : p = kmalloc(sizeof(*p), GFP_KERNEL);
917 [ # # ]: 0 : if (p == NULL)
918 : 0 : goto err;
919 : 0 : p->pipe = rpc_mkpipe_data(upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
920 [ # # ]: 0 : if (IS_ERR(p->pipe)) {
921 : 0 : err = PTR_ERR(p->pipe);
922 : 0 : goto err_free_gss_pipe;
923 : : }
924 : 0 : p->name = name;
925 : 0 : p->clnt = clnt;
926 : 0 : kref_init(&p->kref);
927 : 0 : rpc_init_pipe_dir_object(&p->pdo,
928 : : &gss_pipe_dir_object_ops,
929 : : p);
930 : 0 : return p;
931 : : err_free_gss_pipe:
932 : 0 : kfree(p);
933 : 0 : err:
934 : 0 : return ERR_PTR(err);
935 : : }
936 : :
937 : : struct gss_alloc_pdo {
938 : : struct rpc_clnt *clnt;
939 : : const char *name;
940 : : const struct rpc_pipe_ops *upcall_ops;
941 : : };
942 : :
943 : 0 : static int gss_pipe_match_pdo(struct rpc_pipe_dir_object *pdo, void *data)
944 : : {
945 : 0 : struct gss_pipe *gss_pipe;
946 : 0 : struct gss_alloc_pdo *args = data;
947 : :
948 [ # # ]: 0 : if (pdo->pdo_ops != &gss_pipe_dir_object_ops)
949 : : return 0;
950 : 0 : gss_pipe = container_of(pdo, struct gss_pipe, pdo);
951 [ # # ]: 0 : if (strcmp(gss_pipe->name, args->name) != 0)
952 : : return 0;
953 [ # # ]: 0 : if (!kref_get_unless_zero(&gss_pipe->kref))
954 : 0 : return 0;
955 : : return 1;
956 : : }
957 : :
958 : 0 : static struct rpc_pipe_dir_object *gss_pipe_alloc_pdo(void *data)
959 : : {
960 : 0 : struct gss_pipe *gss_pipe;
961 : 0 : struct gss_alloc_pdo *args = data;
962 : :
963 : 0 : gss_pipe = gss_pipe_alloc(args->clnt, args->name, args->upcall_ops);
964 [ # # ]: 0 : if (!IS_ERR(gss_pipe))
965 : 0 : return &gss_pipe->pdo;
966 : : return NULL;
967 : : }
968 : :
969 : 0 : static struct gss_pipe *gss_pipe_get(struct rpc_clnt *clnt,
970 : : const char *name,
971 : : const struct rpc_pipe_ops *upcall_ops)
972 : : {
973 : 0 : struct net *net = rpc_net_ns(clnt);
974 : 0 : struct rpc_pipe_dir_object *pdo;
975 : 0 : struct gss_alloc_pdo args = {
976 : : .clnt = clnt,
977 : : .name = name,
978 : : .upcall_ops = upcall_ops,
979 : : };
980 : :
981 : 0 : pdo = rpc_find_or_alloc_pipe_dir_object(net,
982 : : &clnt->cl_pipedir_objects,
983 : : gss_pipe_match_pdo,
984 : : gss_pipe_alloc_pdo,
985 : : &args);
986 [ # # ]: 0 : if (pdo != NULL)
987 : 0 : return container_of(pdo, struct gss_pipe, pdo);
988 : : return ERR_PTR(-ENOMEM);
989 : : }
990 : :
991 : 0 : static void __gss_pipe_free(struct gss_pipe *p)
992 : : {
993 : 0 : struct rpc_clnt *clnt = p->clnt;
994 : 0 : struct net *net = rpc_net_ns(clnt);
995 : :
996 : 0 : rpc_remove_pipe_dir_object(net,
997 : : &clnt->cl_pipedir_objects,
998 : : &p->pdo);
999 : 0 : rpc_destroy_pipe_data(p->pipe);
1000 : 0 : kfree(p);
1001 : 0 : }
1002 : :
1003 : 0 : static void __gss_pipe_release(struct kref *kref)
1004 : : {
1005 : 0 : struct gss_pipe *p = container_of(kref, struct gss_pipe, kref);
1006 : :
1007 : 0 : __gss_pipe_free(p);
1008 : 0 : }
1009 : :
1010 : 0 : static void gss_pipe_free(struct gss_pipe *p)
1011 : : {
1012 [ # # ]: 0 : if (p != NULL)
1013 : 0 : kref_put(&p->kref, __gss_pipe_release);
1014 : 0 : }
1015 : :
1016 : : /*
1017 : : * NOTE: we have the opportunity to use different
1018 : : * parameters based on the input flavor (which must be a pseudoflavor)
1019 : : */
1020 : : static struct gss_auth *
1021 : : gss_create_new(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
1022 : : {
1023 : : rpc_authflavor_t flavor = args->pseudoflavor;
1024 : : struct gss_auth *gss_auth;
1025 : : struct gss_pipe *gss_pipe;
1026 : : struct rpc_auth * auth;
1027 : : int err = -ENOMEM; /* XXX? */
1028 : :
1029 : : if (!try_module_get(THIS_MODULE))
1030 : : return ERR_PTR(err);
1031 : : if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
1032 : : goto out_dec;
1033 : : INIT_HLIST_NODE(&gss_auth->hash);
1034 : : gss_auth->target_name = NULL;
1035 : : if (args->target_name) {
1036 : : gss_auth->target_name = kstrdup(args->target_name, GFP_KERNEL);
1037 : : if (gss_auth->target_name == NULL)
1038 : : goto err_free;
1039 : : }
1040 : : gss_auth->client = clnt;
1041 : : gss_auth->net = get_net(rpc_net_ns(clnt));
1042 : : err = -EINVAL;
1043 : : gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);
1044 : : if (!gss_auth->mech)
1045 : : goto err_put_net;
1046 : : gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);
1047 : : if (gss_auth->service == 0)
1048 : : goto err_put_mech;
1049 : : if (!gssd_running(gss_auth->net))
1050 : : goto err_put_mech;
1051 : : auth = &gss_auth->rpc_auth;
1052 : : auth->au_cslack = GSS_CRED_SLACK >> 2;
1053 : : auth->au_rslack = GSS_VERF_SLACK >> 2;
1054 : : auth->au_verfsize = GSS_VERF_SLACK >> 2;
1055 : : auth->au_ralign = GSS_VERF_SLACK >> 2;
1056 : : auth->au_flags = 0;
1057 : : auth->au_ops = &authgss_ops;
1058 : : auth->au_flavor = flavor;
1059 : : if (gss_pseudoflavor_to_datatouch(gss_auth->mech, flavor))
1060 : : auth->au_flags |= RPCAUTH_AUTH_DATATOUCH;
1061 : : refcount_set(&auth->au_count, 1);
1062 : : kref_init(&gss_auth->kref);
1063 : :
1064 : : err = rpcauth_init_credcache(auth);
1065 : : if (err)
1066 : : goto err_put_mech;
1067 : : /*
1068 : : * Note: if we created the old pipe first, then someone who
1069 : : * examined the directory at the right moment might conclude
1070 : : * that we supported only the old pipe. So we instead create
1071 : : * the new pipe first.
1072 : : */
1073 : : gss_pipe = gss_pipe_get(clnt, "gssd", &gss_upcall_ops_v1);
1074 : : if (IS_ERR(gss_pipe)) {
1075 : : err = PTR_ERR(gss_pipe);
1076 : : goto err_destroy_credcache;
1077 : : }
1078 : : gss_auth->gss_pipe[1] = gss_pipe;
1079 : :
1080 : : gss_pipe = gss_pipe_get(clnt, gss_auth->mech->gm_name,
1081 : : &gss_upcall_ops_v0);
1082 : : if (IS_ERR(gss_pipe)) {
1083 : : err = PTR_ERR(gss_pipe);
1084 : : goto err_destroy_pipe_1;
1085 : : }
1086 : : gss_auth->gss_pipe[0] = gss_pipe;
1087 : :
1088 : : return gss_auth;
1089 : : err_destroy_pipe_1:
1090 : : gss_pipe_free(gss_auth->gss_pipe[1]);
1091 : : err_destroy_credcache:
1092 : : rpcauth_destroy_credcache(auth);
1093 : : err_put_mech:
1094 : : gss_mech_put(gss_auth->mech);
1095 : : err_put_net:
1096 : : put_net(gss_auth->net);
1097 : : err_free:
1098 : : kfree(gss_auth->target_name);
1099 : : kfree(gss_auth);
1100 : : out_dec:
1101 : : module_put(THIS_MODULE);
1102 : : trace_rpcgss_createauth(flavor, err);
1103 : : return ERR_PTR(err);
1104 : : }
1105 : :
1106 : : static void
1107 : 0 : gss_free(struct gss_auth *gss_auth)
1108 : : {
1109 : 0 : gss_pipe_free(gss_auth->gss_pipe[0]);
1110 : 0 : gss_pipe_free(gss_auth->gss_pipe[1]);
1111 : 0 : gss_mech_put(gss_auth->mech);
1112 : 0 : put_net(gss_auth->net);
1113 : 0 : kfree(gss_auth->target_name);
1114 : :
1115 : 0 : kfree(gss_auth);
1116 : 0 : module_put(THIS_MODULE);
1117 : 0 : }
1118 : :
1119 : : static void
1120 : 0 : gss_free_callback(struct kref *kref)
1121 : : {
1122 : 0 : struct gss_auth *gss_auth = container_of(kref, struct gss_auth, kref);
1123 : :
1124 : 0 : gss_free(gss_auth);
1125 : 0 : }
1126 : :
1127 : : static void
1128 : 0 : gss_put_auth(struct gss_auth *gss_auth)
1129 : : {
1130 : 0 : kref_put(&gss_auth->kref, gss_free_callback);
1131 : 0 : }
1132 : :
1133 : : static void
1134 : 0 : gss_destroy(struct rpc_auth *auth)
1135 : : {
1136 : 0 : struct gss_auth *gss_auth = container_of(auth,
1137 : : struct gss_auth, rpc_auth);
1138 : :
1139 [ # # ]: 0 : if (hash_hashed(&gss_auth->hash)) {
1140 : 0 : spin_lock(&gss_auth_hash_lock);
1141 [ # # ]: 0 : hash_del(&gss_auth->hash);
1142 : 0 : spin_unlock(&gss_auth_hash_lock);
1143 : : }
1144 : :
1145 : 0 : gss_pipe_free(gss_auth->gss_pipe[0]);
1146 : 0 : gss_auth->gss_pipe[0] = NULL;
1147 : 0 : gss_pipe_free(gss_auth->gss_pipe[1]);
1148 : 0 : gss_auth->gss_pipe[1] = NULL;
1149 : 0 : rpcauth_destroy_credcache(auth);
1150 : :
1151 : 0 : gss_put_auth(gss_auth);
1152 : 0 : }
1153 : :
1154 : : /*
1155 : : * Auths may be shared between rpc clients that were cloned from a
1156 : : * common client with the same xprt, if they also share the flavor and
1157 : : * target_name.
1158 : : *
1159 : : * The auth is looked up from the oldest parent sharing the same
1160 : : * cl_xprt, and the auth itself references only that common parent
1161 : : * (which is guaranteed to last as long as any of its descendants).
1162 : : */
1163 : : static struct gss_auth *
1164 : : gss_auth_find_or_add_hashed(const struct rpc_auth_create_args *args,
1165 : : struct rpc_clnt *clnt,
1166 : : struct gss_auth *new)
1167 : : {
1168 : : struct gss_auth *gss_auth;
1169 : : unsigned long hashval = (unsigned long)clnt;
1170 : :
1171 : : spin_lock(&gss_auth_hash_lock);
1172 : : hash_for_each_possible(gss_auth_hash_table,
1173 : : gss_auth,
1174 : : hash,
1175 : : hashval) {
1176 : : if (gss_auth->client != clnt)
1177 : : continue;
1178 : : if (gss_auth->rpc_auth.au_flavor != args->pseudoflavor)
1179 : : continue;
1180 : : if (gss_auth->target_name != args->target_name) {
1181 : : if (gss_auth->target_name == NULL)
1182 : : continue;
1183 : : if (args->target_name == NULL)
1184 : : continue;
1185 : : if (strcmp(gss_auth->target_name, args->target_name))
1186 : : continue;
1187 : : }
1188 : : if (!refcount_inc_not_zero(&gss_auth->rpc_auth.au_count))
1189 : : continue;
1190 : : goto out;
1191 : : }
1192 : : if (new)
1193 : : hash_add(gss_auth_hash_table, &new->hash, hashval);
1194 : : gss_auth = new;
1195 : : out:
1196 : : spin_unlock(&gss_auth_hash_lock);
1197 : : return gss_auth;
1198 : : }
1199 : :
1200 : : static struct gss_auth *
1201 : 0 : gss_create_hashed(const struct rpc_auth_create_args *args,
1202 : : struct rpc_clnt *clnt)
1203 : : {
1204 : 0 : struct gss_auth *gss_auth;
1205 : 0 : struct gss_auth *new;
1206 : :
1207 : 0 : gss_auth = gss_auth_find_or_add_hashed(args, clnt, NULL);
1208 [ # # ]: 0 : if (gss_auth != NULL)
1209 : 0 : goto out;
1210 : 0 : new = gss_create_new(args, clnt);
1211 [ # # ]: 0 : if (IS_ERR(new))
1212 : : return new;
1213 : 0 : gss_auth = gss_auth_find_or_add_hashed(args, clnt, new);
1214 [ # # ]: 0 : if (gss_auth != new)
1215 : 0 : gss_destroy(&new->rpc_auth);
1216 : 0 : out:
1217 : : return gss_auth;
1218 : : }
1219 : :
1220 : : static struct rpc_auth *
1221 : 0 : gss_create(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
1222 : : {
1223 : 0 : struct gss_auth *gss_auth;
1224 : 0 : struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch);
1225 : :
1226 [ # # ]: 0 : while (clnt != clnt->cl_parent) {
1227 : 0 : struct rpc_clnt *parent = clnt->cl_parent;
1228 : : /* Find the original parent for this transport */
1229 [ # # ]: 0 : if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps)
1230 : : break;
1231 : : clnt = parent;
1232 : : }
1233 : :
1234 : 0 : gss_auth = gss_create_hashed(args, clnt);
1235 [ # # ]: 0 : if (IS_ERR(gss_auth))
1236 : : return ERR_CAST(gss_auth);
1237 : 0 : return &gss_auth->rpc_auth;
1238 : : }
1239 : :
1240 : : static struct gss_cred *
1241 : 0 : gss_dup_cred(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
1242 : : {
1243 : 0 : struct gss_cred *new;
1244 : :
1245 : : /* Make a copy of the cred so that we can reference count it */
1246 : 0 : new = kzalloc(sizeof(*gss_cred), GFP_NOFS);
1247 [ # # ]: 0 : if (new) {
1248 : 0 : struct auth_cred acred = {
1249 : 0 : .cred = gss_cred->gc_base.cr_cred,
1250 : : };
1251 : 0 : struct gss_cl_ctx *ctx =
1252 : 0 : rcu_dereference_protected(gss_cred->gc_ctx, 1);
1253 : :
1254 : 0 : rpcauth_init_cred(&new->gc_base, &acred,
1255 : : &gss_auth->rpc_auth,
1256 : : &gss_nullops);
1257 : 0 : new->gc_base.cr_flags = 1UL << RPCAUTH_CRED_UPTODATE;
1258 : 0 : new->gc_service = gss_cred->gc_service;
1259 : 0 : new->gc_principal = gss_cred->gc_principal;
1260 : 0 : kref_get(&gss_auth->kref);
1261 : 0 : rcu_assign_pointer(new->gc_ctx, ctx);
1262 : 0 : gss_get_ctx(ctx);
1263 : : }
1264 : 0 : return new;
1265 : : }
1266 : :
1267 : : /*
1268 : : * gss_send_destroy_context will cause the RPCSEC_GSS to send a NULL RPC call
1269 : : * to the server with the GSS control procedure field set to
1270 : : * RPC_GSS_PROC_DESTROY. This should normally cause the server to release
1271 : : * all RPCSEC_GSS state associated with that context.
1272 : : */
1273 : : static void
1274 : 0 : gss_send_destroy_context(struct rpc_cred *cred)
1275 : : {
1276 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
1277 : 0 : struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
1278 : 0 : struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);
1279 : 0 : struct gss_cred *new;
1280 : 0 : struct rpc_task *task;
1281 : :
1282 : 0 : new = gss_dup_cred(gss_auth, gss_cred);
1283 [ # # ]: 0 : if (new) {
1284 : 0 : ctx->gc_proc = RPC_GSS_PROC_DESTROY;
1285 : :
1286 : 0 : task = rpc_call_null(gss_auth->client, &new->gc_base,
1287 : : RPC_TASK_ASYNC|RPC_TASK_SOFT);
1288 [ # # ]: 0 : if (!IS_ERR(task))
1289 : 0 : rpc_put_task(task);
1290 : :
1291 : 0 : put_rpccred(&new->gc_base);
1292 : : }
1293 : 0 : }
1294 : :
1295 : : /* gss_destroy_cred (and gss_free_ctx) are used to clean up after failure
1296 : : * to create a new cred or context, so they check that things have been
1297 : : * allocated before freeing them. */
1298 : : static void
1299 : 0 : gss_do_free_ctx(struct gss_cl_ctx *ctx)
1300 : : {
1301 : 0 : gss_delete_sec_context(&ctx->gc_gss_ctx);
1302 : 0 : kfree(ctx->gc_wire_ctx.data);
1303 : 0 : kfree(ctx->gc_acceptor.data);
1304 : 0 : kfree(ctx);
1305 : 0 : }
1306 : :
1307 : : static void
1308 : 0 : gss_free_ctx_callback(struct rcu_head *head)
1309 : : {
1310 : 0 : struct gss_cl_ctx *ctx = container_of(head, struct gss_cl_ctx, gc_rcu);
1311 : 0 : gss_do_free_ctx(ctx);
1312 : 0 : }
1313 : :
1314 : : static void
1315 : 0 : gss_free_ctx(struct gss_cl_ctx *ctx)
1316 : : {
1317 : 0 : call_rcu(&ctx->gc_rcu, gss_free_ctx_callback);
1318 : 0 : }
1319 : :
1320 : : static void
1321 : 0 : gss_free_cred(struct gss_cred *gss_cred)
1322 : : {
1323 : 0 : kfree(gss_cred);
1324 : : }
1325 : :
1326 : : static void
1327 : 0 : gss_free_cred_callback(struct rcu_head *head)
1328 : : {
1329 : 0 : struct gss_cred *gss_cred = container_of(head, struct gss_cred, gc_base.cr_rcu);
1330 : 0 : gss_free_cred(gss_cred);
1331 : 0 : }
1332 : :
1333 : : static void
1334 : 0 : gss_destroy_nullcred(struct rpc_cred *cred)
1335 : : {
1336 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
1337 : 0 : struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
1338 : 0 : struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);
1339 : :
1340 : 0 : RCU_INIT_POINTER(gss_cred->gc_ctx, NULL);
1341 : 0 : put_cred(cred->cr_cred);
1342 : 0 : call_rcu(&cred->cr_rcu, gss_free_cred_callback);
1343 [ # # ]: 0 : if (ctx)
1344 : 0 : gss_put_ctx(ctx);
1345 : 0 : gss_put_auth(gss_auth);
1346 : 0 : }
1347 : :
1348 : : static void
1349 : 0 : gss_destroy_cred(struct rpc_cred *cred)
1350 : : {
1351 : :
1352 [ # # ]: 0 : if (test_and_clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0)
1353 : 0 : gss_send_destroy_context(cred);
1354 : 0 : gss_destroy_nullcred(cred);
1355 : 0 : }
1356 : :
1357 : : static int
1358 : 0 : gss_hash_cred(struct auth_cred *acred, unsigned int hashbits)
1359 : : {
1360 : 0 : return hash_64(from_kuid(&init_user_ns, acred->cred->fsuid), hashbits);
1361 : : }
1362 : :
1363 : : /*
1364 : : * Lookup RPCSEC_GSS cred for the current process
1365 : : */
1366 : : static struct rpc_cred *
1367 : 0 : gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
1368 : : {
1369 : 0 : return rpcauth_lookup_credcache(auth, acred, flags, GFP_NOFS);
1370 : : }
1371 : :
1372 : : static struct rpc_cred *
1373 : 0 : gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags, gfp_t gfp)
1374 : : {
1375 : 0 : struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
1376 : 0 : struct gss_cred *cred = NULL;
1377 : 0 : int err = -ENOMEM;
1378 : :
1379 [ # # ]: 0 : if (!(cred = kzalloc(sizeof(*cred), gfp)))
1380 : 0 : goto out_err;
1381 : :
1382 : 0 : rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops);
1383 : : /*
1384 : : * Note: in order to force a call to call_refresh(), we deliberately
1385 : : * fail to flag the credential as RPCAUTH_CRED_UPTODATE.
1386 : : */
1387 : 0 : cred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_NEW;
1388 : 0 : cred->gc_service = gss_auth->service;
1389 : 0 : cred->gc_principal = acred->principal;
1390 : 0 : kref_get(&gss_auth->kref);
1391 : 0 : return &cred->gc_base;
1392 : :
1393 : : out_err:
1394 : 0 : return ERR_PTR(err);
1395 : : }
1396 : :
1397 : : static int
1398 : 0 : gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred)
1399 : : {
1400 : 0 : struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
1401 : 0 : struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base);
1402 : 0 : int err;
1403 : :
1404 : 0 : do {
1405 : 0 : err = gss_create_upcall(gss_auth, gss_cred);
1406 [ # # ]: 0 : } while (err == -EAGAIN);
1407 : 0 : return err;
1408 : : }
1409 : :
1410 : : static char *
1411 : 0 : gss_stringify_acceptor(struct rpc_cred *cred)
1412 : : {
1413 : 0 : char *string = NULL;
1414 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
1415 : 0 : struct gss_cl_ctx *ctx;
1416 : 0 : unsigned int len;
1417 : 0 : struct xdr_netobj *acceptor;
1418 : :
1419 : 0 : rcu_read_lock();
1420 [ # # ]: 0 : ctx = rcu_dereference(gss_cred->gc_ctx);
1421 [ # # ]: 0 : if (!ctx)
1422 : 0 : goto out;
1423 : :
1424 : 0 : len = ctx->gc_acceptor.len;
1425 : 0 : rcu_read_unlock();
1426 : :
1427 : : /* no point if there's no string */
1428 [ # # ]: 0 : if (!len)
1429 : : return NULL;
1430 : 0 : realloc:
1431 [ # # ]: 0 : string = kmalloc(len + 1, GFP_KERNEL);
1432 [ # # ]: 0 : if (!string)
1433 : : return NULL;
1434 : :
1435 : 0 : rcu_read_lock();
1436 [ # # ]: 0 : ctx = rcu_dereference(gss_cred->gc_ctx);
1437 : :
1438 : : /* did the ctx disappear or was it replaced by one with no acceptor? */
1439 [ # # # # ]: 0 : if (!ctx || !ctx->gc_acceptor.len) {
1440 : 0 : kfree(string);
1441 : 0 : string = NULL;
1442 : 0 : goto out;
1443 : : }
1444 : :
1445 : 0 : acceptor = &ctx->gc_acceptor;
1446 : :
1447 : : /*
1448 : : * Did we find a new acceptor that's longer than the original? Allocate
1449 : : * a longer buffer and try again.
1450 : : */
1451 [ # # ]: 0 : if (len < acceptor->len) {
1452 : 0 : len = acceptor->len;
1453 : 0 : rcu_read_unlock();
1454 : 0 : kfree(string);
1455 : 0 : goto realloc;
1456 : : }
1457 : :
1458 : 0 : memcpy(string, acceptor->data, acceptor->len);
1459 : 0 : string[acceptor->len] = '\0';
1460 : 0 : out:
1461 : 0 : rcu_read_unlock();
1462 : 0 : return string;
1463 : : }
1464 : :
1465 : : /*
1466 : : * Returns -EACCES if GSS context is NULL or will expire within the
1467 : : * timeout (miliseconds)
1468 : : */
1469 : : static int
1470 : 0 : gss_key_timeout(struct rpc_cred *rc)
1471 : : {
1472 : 0 : struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
1473 : 0 : struct gss_cl_ctx *ctx;
1474 : 0 : unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ);
1475 : 0 : int ret = 0;
1476 : :
1477 : 0 : rcu_read_lock();
1478 [ # # ]: 0 : ctx = rcu_dereference(gss_cred->gc_ctx);
1479 [ # # # # ]: 0 : if (!ctx || time_after(timeout, ctx->gc_expiry))
1480 : : ret = -EACCES;
1481 : 0 : rcu_read_unlock();
1482 : :
1483 : 0 : return ret;
1484 : : }
1485 : :
1486 : : static int
1487 : 0 : gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags)
1488 : : {
1489 : 0 : struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
1490 : 0 : struct gss_cl_ctx *ctx;
1491 : 0 : int ret;
1492 : :
1493 [ # # ]: 0 : if (test_bit(RPCAUTH_CRED_NEW, &rc->cr_flags))
1494 : 0 : goto out;
1495 : : /* Don't match with creds that have expired. */
1496 : 0 : rcu_read_lock();
1497 [ # # ]: 0 : ctx = rcu_dereference(gss_cred->gc_ctx);
1498 [ # # # # ]: 0 : if (!ctx || time_after(jiffies, ctx->gc_expiry)) {
1499 : 0 : rcu_read_unlock();
1500 : 0 : return 0;
1501 : : }
1502 : 0 : rcu_read_unlock();
1503 [ # # ]: 0 : if (!test_bit(RPCAUTH_CRED_UPTODATE, &rc->cr_flags))
1504 : : return 0;
1505 : 0 : out:
1506 [ # # ]: 0 : if (acred->principal != NULL) {
1507 [ # # ]: 0 : if (gss_cred->gc_principal == NULL)
1508 : : return 0;
1509 : 0 : ret = strcmp(acred->principal, gss_cred->gc_principal) == 0;
1510 : : } else {
1511 [ # # ]: 0 : if (gss_cred->gc_principal != NULL)
1512 : : return 0;
1513 : 0 : ret = uid_eq(rc->cr_cred->fsuid, acred->cred->fsuid);
1514 : : }
1515 : : return ret;
1516 : : }
1517 : :
1518 : : /*
1519 : : * Marshal credentials.
1520 : : *
1521 : : * The expensive part is computing the verifier. We can't cache a
1522 : : * pre-computed version of the verifier because the seqno, which
1523 : : * is different every time, is included in the MIC.
1524 : : */
1525 : 0 : static int gss_marshal(struct rpc_task *task, struct xdr_stream *xdr)
1526 : : {
1527 : 0 : struct rpc_rqst *req = task->tk_rqstp;
1528 : 0 : struct rpc_cred *cred = req->rq_cred;
1529 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1530 : : gc_base);
1531 : 0 : struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1532 : 0 : __be32 *p, *cred_len;
1533 : 0 : u32 maj_stat = 0;
1534 : 0 : struct xdr_netobj mic;
1535 : 0 : struct kvec iov;
1536 : 0 : struct xdr_buf verf_buf;
1537 : 0 : int status;
1538 : :
1539 : : /* Credential */
1540 : :
1541 : 0 : p = xdr_reserve_space(xdr, 7 * sizeof(*p) +
1542 : 0 : ctx->gc_wire_ctx.len);
1543 [ # # ]: 0 : if (!p)
1544 : 0 : goto marshal_failed;
1545 : 0 : *p++ = rpc_auth_gss;
1546 : 0 : cred_len = p++;
1547 : :
1548 : 0 : spin_lock(&ctx->gc_seq_lock);
1549 [ # # ]: 0 : req->rq_seqno = (ctx->gc_seq < MAXSEQ) ? ctx->gc_seq++ : MAXSEQ;
1550 : 0 : spin_unlock(&ctx->gc_seq_lock);
1551 [ # # ]: 0 : if (req->rq_seqno == MAXSEQ)
1552 : 0 : goto expired;
1553 : 0 : trace_rpcgss_seqno(task);
1554 : :
1555 : 0 : *p++ = cpu_to_be32(RPC_GSS_VERSION);
1556 : 0 : *p++ = cpu_to_be32(ctx->gc_proc);
1557 : 0 : *p++ = cpu_to_be32(req->rq_seqno);
1558 : 0 : *p++ = cpu_to_be32(gss_cred->gc_service);
1559 : 0 : p = xdr_encode_netobj(p, &ctx->gc_wire_ctx);
1560 : 0 : *cred_len = cpu_to_be32((p - (cred_len + 1)) << 2);
1561 : :
1562 : : /* Verifier */
1563 : :
1564 : : /* We compute the checksum for the verifier over the xdr-encoded bytes
1565 : : * starting with the xid and ending at the end of the credential: */
1566 : 0 : iov.iov_base = req->rq_snd_buf.head[0].iov_base;
1567 : 0 : iov.iov_len = (u8 *)p - (u8 *)iov.iov_base;
1568 : 0 : xdr_buf_from_iov(&iov, &verf_buf);
1569 : :
1570 : 0 : p = xdr_reserve_space(xdr, sizeof(*p));
1571 [ # # ]: 0 : if (!p)
1572 : 0 : goto marshal_failed;
1573 : 0 : *p++ = rpc_auth_gss;
1574 : 0 : mic.data = (u8 *)(p + 1);
1575 : 0 : maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
1576 [ # # ]: 0 : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1577 : 0 : goto expired;
1578 [ # # ]: 0 : else if (maj_stat != 0)
1579 : 0 : goto bad_mic;
1580 [ # # ]: 0 : if (xdr_stream_encode_opaque_inline(xdr, (void **)&p, mic.len) < 0)
1581 : 0 : goto marshal_failed;
1582 : : status = 0;
1583 : 0 : out:
1584 : 0 : gss_put_ctx(ctx);
1585 : 0 : return status;
1586 : 0 : expired:
1587 : 0 : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1588 : 0 : status = -EKEYEXPIRED;
1589 : 0 : goto out;
1590 : 0 : marshal_failed:
1591 : 0 : status = -EMSGSIZE;
1592 : 0 : goto out;
1593 : : bad_mic:
1594 : 0 : trace_rpcgss_get_mic(task, maj_stat);
1595 : 0 : status = -EIO;
1596 : 0 : goto out;
1597 : : }
1598 : :
1599 : : static int gss_renew_cred(struct rpc_task *task)
1600 : : {
1601 : : struct rpc_cred *oldcred = task->tk_rqstp->rq_cred;
1602 : : struct gss_cred *gss_cred = container_of(oldcred,
1603 : : struct gss_cred,
1604 : : gc_base);
1605 : : struct rpc_auth *auth = oldcred->cr_auth;
1606 : : struct auth_cred acred = {
1607 : : .cred = oldcred->cr_cred,
1608 : : .principal = gss_cred->gc_principal,
1609 : : };
1610 : : struct rpc_cred *new;
1611 : :
1612 : : new = gss_lookup_cred(auth, &acred, RPCAUTH_LOOKUP_NEW);
1613 : : if (IS_ERR(new))
1614 : : return PTR_ERR(new);
1615 : : task->tk_rqstp->rq_cred = new;
1616 : : put_rpccred(oldcred);
1617 : : return 0;
1618 : : }
1619 : :
1620 : 0 : static int gss_cred_is_negative_entry(struct rpc_cred *cred)
1621 : : {
1622 [ # # ]: 0 : if (test_bit(RPCAUTH_CRED_NEGATIVE, &cred->cr_flags)) {
1623 : 0 : unsigned long now = jiffies;
1624 : 0 : unsigned long begin, expire;
1625 : 0 : struct gss_cred *gss_cred;
1626 : :
1627 : 0 : gss_cred = container_of(cred, struct gss_cred, gc_base);
1628 : 0 : begin = gss_cred->gc_upcall_timestamp;
1629 : 0 : expire = begin + gss_expired_cred_retry_delay * HZ;
1630 : :
1631 [ # # # # ]: 0 : if (time_in_range_open(now, begin, expire))
1632 : 0 : return 1;
1633 : : }
1634 : : return 0;
1635 : : }
1636 : :
1637 : : /*
1638 : : * Refresh credentials. XXX - finish
1639 : : */
1640 : : static int
1641 : 0 : gss_refresh(struct rpc_task *task)
1642 : : {
1643 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
1644 : 0 : int ret = 0;
1645 : :
1646 [ # # ]: 0 : if (gss_cred_is_negative_entry(cred))
1647 : : return -EKEYEXPIRED;
1648 : :
1649 [ # # # # ]: 0 : if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
1650 : : !test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags)) {
1651 : 0 : ret = gss_renew_cred(task);
1652 [ # # ]: 0 : if (ret < 0)
1653 : 0 : goto out;
1654 : 0 : cred = task->tk_rqstp->rq_cred;
1655 : : }
1656 : :
1657 [ # # ]: 0 : if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
1658 : 0 : ret = gss_refresh_upcall(task);
1659 : 0 : out:
1660 : : return ret;
1661 : : }
1662 : :
1663 : : /* Dummy refresh routine: used only when destroying the context */
1664 : : static int
1665 : 0 : gss_refresh_null(struct rpc_task *task)
1666 : : {
1667 : 0 : return 0;
1668 : : }
1669 : :
1670 : : static int
1671 : 0 : gss_validate(struct rpc_task *task, struct xdr_stream *xdr)
1672 : : {
1673 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
1674 : 0 : struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1675 : 0 : __be32 *p, *seq = NULL;
1676 : 0 : struct kvec iov;
1677 : 0 : struct xdr_buf verf_buf;
1678 : 0 : struct xdr_netobj mic;
1679 : 0 : u32 len, maj_stat;
1680 : 0 : int status;
1681 : :
1682 : 0 : p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1683 [ # # ]: 0 : if (!p)
1684 : 0 : goto validate_failed;
1685 [ # # ]: 0 : if (*p++ != rpc_auth_gss)
1686 : 0 : goto validate_failed;
1687 [ # # ]: 0 : len = be32_to_cpup(p);
1688 [ # # ]: 0 : if (len > RPC_MAX_AUTH_SIZE)
1689 : 0 : goto validate_failed;
1690 : 0 : p = xdr_inline_decode(xdr, len);
1691 [ # # ]: 0 : if (!p)
1692 : 0 : goto validate_failed;
1693 : :
1694 : 0 : seq = kmalloc(4, GFP_NOFS);
1695 [ # # ]: 0 : if (!seq)
1696 : 0 : goto validate_failed;
1697 : 0 : *seq = cpu_to_be32(task->tk_rqstp->rq_seqno);
1698 : 0 : iov.iov_base = seq;
1699 : 0 : iov.iov_len = 4;
1700 : 0 : xdr_buf_from_iov(&iov, &verf_buf);
1701 : 0 : mic.data = (u8 *)p;
1702 : 0 : mic.len = len;
1703 : 0 : maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
1704 [ # # ]: 0 : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1705 : 0 : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1706 [ # # ]: 0 : if (maj_stat)
1707 : 0 : goto bad_mic;
1708 : :
1709 : : /* We leave it to unwrap to calculate au_rslack. For now we just
1710 : : * calculate the length of the verifier: */
1711 : 0 : cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2;
1712 : 0 : status = 0;
1713 : 0 : out:
1714 : 0 : gss_put_ctx(ctx);
1715 : 0 : kfree(seq);
1716 : 0 : return status;
1717 : :
1718 : 0 : validate_failed:
1719 : 0 : status = -EIO;
1720 : 0 : goto out;
1721 : : bad_mic:
1722 : 0 : trace_rpcgss_verify_mic(task, maj_stat);
1723 : 0 : status = -EACCES;
1724 : 0 : goto out;
1725 : : }
1726 : :
1727 : : static int gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1728 : : struct rpc_task *task, struct xdr_stream *xdr)
1729 : : {
1730 : : struct rpc_rqst *rqstp = task->tk_rqstp;
1731 : : struct xdr_buf integ_buf, *snd_buf = &rqstp->rq_snd_buf;
1732 : : struct xdr_netobj mic;
1733 : : __be32 *p, *integ_len;
1734 : : u32 offset, maj_stat;
1735 : :
1736 : : p = xdr_reserve_space(xdr, 2 * sizeof(*p));
1737 : : if (!p)
1738 : : goto wrap_failed;
1739 : : integ_len = p++;
1740 : : *p = cpu_to_be32(rqstp->rq_seqno);
1741 : :
1742 : : if (rpcauth_wrap_req_encode(task, xdr))
1743 : : goto wrap_failed;
1744 : :
1745 : : offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1746 : : if (xdr_buf_subsegment(snd_buf, &integ_buf,
1747 : : offset, snd_buf->len - offset))
1748 : : goto wrap_failed;
1749 : : *integ_len = cpu_to_be32(integ_buf.len);
1750 : :
1751 : : p = xdr_reserve_space(xdr, 0);
1752 : : if (!p)
1753 : : goto wrap_failed;
1754 : : mic.data = (u8 *)(p + 1);
1755 : : maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
1756 : : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1757 : : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1758 : : else if (maj_stat)
1759 : : goto bad_mic;
1760 : : /* Check that the trailing MIC fit in the buffer, after the fact */
1761 : : if (xdr_stream_encode_opaque_inline(xdr, (void **)&p, mic.len) < 0)
1762 : : goto wrap_failed;
1763 : : return 0;
1764 : : wrap_failed:
1765 : : return -EMSGSIZE;
1766 : : bad_mic:
1767 : : trace_rpcgss_get_mic(task, maj_stat);
1768 : : return -EIO;
1769 : : }
1770 : :
1771 : : static void
1772 : 0 : priv_release_snd_buf(struct rpc_rqst *rqstp)
1773 : : {
1774 : 0 : int i;
1775 : :
1776 [ # # ]: 0 : for (i=0; i < rqstp->rq_enc_pages_num; i++)
1777 : 0 : __free_page(rqstp->rq_enc_pages[i]);
1778 : 0 : kfree(rqstp->rq_enc_pages);
1779 : 0 : rqstp->rq_release_snd_buf = NULL;
1780 : 0 : }
1781 : :
1782 : : static int
1783 : 0 : alloc_enc_pages(struct rpc_rqst *rqstp)
1784 : : {
1785 : 0 : struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1786 : 0 : int first, last, i;
1787 : :
1788 [ # # ]: 0 : if (rqstp->rq_release_snd_buf)
1789 : 0 : rqstp->rq_release_snd_buf(rqstp);
1790 : :
1791 [ # # ]: 0 : if (snd_buf->page_len == 0) {
1792 : 0 : rqstp->rq_enc_pages_num = 0;
1793 : 0 : return 0;
1794 : : }
1795 : :
1796 : 0 : first = snd_buf->page_base >> PAGE_SHIFT;
1797 : 0 : last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT;
1798 : 0 : rqstp->rq_enc_pages_num = last - first + 1 + 1;
1799 : 0 : rqstp->rq_enc_pages
1800 : 0 : = kmalloc_array(rqstp->rq_enc_pages_num,
1801 : : sizeof(struct page *),
1802 : : GFP_NOFS);
1803 [ # # ]: 0 : if (!rqstp->rq_enc_pages)
1804 : 0 : goto out;
1805 [ # # ]: 0 : for (i=0; i < rqstp->rq_enc_pages_num; i++) {
1806 : 0 : rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS);
1807 [ # # ]: 0 : if (rqstp->rq_enc_pages[i] == NULL)
1808 : 0 : goto out_free;
1809 : : }
1810 : 0 : rqstp->rq_release_snd_buf = priv_release_snd_buf;
1811 : 0 : return 0;
1812 : : out_free:
1813 : 0 : rqstp->rq_enc_pages_num = i;
1814 : 0 : priv_release_snd_buf(rqstp);
1815 : : out:
1816 : : return -EAGAIN;
1817 : : }
1818 : :
1819 : : static int gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1820 : : struct rpc_task *task, struct xdr_stream *xdr)
1821 : : {
1822 : : struct rpc_rqst *rqstp = task->tk_rqstp;
1823 : : struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1824 : : u32 pad, offset, maj_stat;
1825 : : int status;
1826 : : __be32 *p, *opaque_len;
1827 : : struct page **inpages;
1828 : : int first;
1829 : : struct kvec *iov;
1830 : :
1831 : : status = -EIO;
1832 : : p = xdr_reserve_space(xdr, 2 * sizeof(*p));
1833 : : if (!p)
1834 : : goto wrap_failed;
1835 : : opaque_len = p++;
1836 : : *p = cpu_to_be32(rqstp->rq_seqno);
1837 : :
1838 : : if (rpcauth_wrap_req_encode(task, xdr))
1839 : : goto wrap_failed;
1840 : :
1841 : : status = alloc_enc_pages(rqstp);
1842 : : if (unlikely(status))
1843 : : goto wrap_failed;
1844 : : first = snd_buf->page_base >> PAGE_SHIFT;
1845 : : inpages = snd_buf->pages + first;
1846 : : snd_buf->pages = rqstp->rq_enc_pages;
1847 : : snd_buf->page_base -= first << PAGE_SHIFT;
1848 : : /*
1849 : : * Move the tail into its own page, in case gss_wrap needs
1850 : : * more space in the head when wrapping.
1851 : : *
1852 : : * Still... Why can't gss_wrap just slide the tail down?
1853 : : */
1854 : : if (snd_buf->page_len || snd_buf->tail[0].iov_len) {
1855 : : char *tmp;
1856 : :
1857 : : tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]);
1858 : : memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len);
1859 : : snd_buf->tail[0].iov_base = tmp;
1860 : : }
1861 : : offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1862 : : maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages);
1863 : : /* slack space should prevent this ever happening: */
1864 : : if (unlikely(snd_buf->len > snd_buf->buflen))
1865 : : goto wrap_failed;
1866 : : /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was
1867 : : * done anyway, so it's safe to put the request on the wire: */
1868 : : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1869 : : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1870 : : else if (maj_stat)
1871 : : goto bad_wrap;
1872 : :
1873 : : *opaque_len = cpu_to_be32(snd_buf->len - offset);
1874 : : /* guess whether the pad goes into the head or the tail: */
1875 : : if (snd_buf->page_len || snd_buf->tail[0].iov_len)
1876 : : iov = snd_buf->tail;
1877 : : else
1878 : : iov = snd_buf->head;
1879 : : p = iov->iov_base + iov->iov_len;
1880 : : pad = 3 - ((snd_buf->len - offset - 1) & 3);
1881 : : memset(p, 0, pad);
1882 : : iov->iov_len += pad;
1883 : : snd_buf->len += pad;
1884 : :
1885 : : return 0;
1886 : : wrap_failed:
1887 : : return status;
1888 : : bad_wrap:
1889 : : trace_rpcgss_wrap(task, maj_stat);
1890 : : return -EIO;
1891 : : }
1892 : :
1893 : 0 : static int gss_wrap_req(struct rpc_task *task, struct xdr_stream *xdr)
1894 : : {
1895 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
1896 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1897 : : gc_base);
1898 : 0 : struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1899 : 0 : int status;
1900 : :
1901 : 0 : status = -EIO;
1902 [ # # ]: 0 : if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
1903 : : /* The spec seems a little ambiguous here, but I think that not
1904 : : * wrapping context destruction requests makes the most sense.
1905 : : */
1906 : 0 : status = rpcauth_wrap_req_encode(task, xdr);
1907 : 0 : goto out;
1908 : : }
1909 [ # # # # ]: 0 : switch (gss_cred->gc_service) {
1910 : 0 : case RPC_GSS_SVC_NONE:
1911 : 0 : status = rpcauth_wrap_req_encode(task, xdr);
1912 : 0 : break;
1913 : 0 : case RPC_GSS_SVC_INTEGRITY:
1914 : 0 : status = gss_wrap_req_integ(cred, ctx, task, xdr);
1915 : 0 : break;
1916 : 0 : case RPC_GSS_SVC_PRIVACY:
1917 : 0 : status = gss_wrap_req_priv(cred, ctx, task, xdr);
1918 : 0 : break;
1919 : : default:
1920 : : status = -EIO;
1921 : : }
1922 : 0 : out:
1923 : 0 : gss_put_ctx(ctx);
1924 : 0 : return status;
1925 : : }
1926 : :
1927 : : static int
1928 : 0 : gss_unwrap_resp_auth(struct rpc_cred *cred)
1929 : : {
1930 : 0 : struct rpc_auth *auth = cred->cr_auth;
1931 : :
1932 : 0 : auth->au_rslack = auth->au_verfsize;
1933 : 0 : auth->au_ralign = auth->au_verfsize;
1934 : 0 : return 0;
1935 : : }
1936 : :
1937 : : static int
1938 : : gss_unwrap_resp_integ(struct rpc_task *task, struct rpc_cred *cred,
1939 : : struct gss_cl_ctx *ctx, struct rpc_rqst *rqstp,
1940 : : struct xdr_stream *xdr)
1941 : : {
1942 : : struct xdr_buf integ_buf, *rcv_buf = &rqstp->rq_rcv_buf;
1943 : : u32 data_offset, mic_offset, integ_len, maj_stat;
1944 : : struct rpc_auth *auth = cred->cr_auth;
1945 : : struct xdr_netobj mic;
1946 : : __be32 *p;
1947 : :
1948 : : p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1949 : : if (unlikely(!p))
1950 : : goto unwrap_failed;
1951 : : integ_len = be32_to_cpup(p++);
1952 : : if (integ_len & 3)
1953 : : goto unwrap_failed;
1954 : : data_offset = (u8 *)(p) - (u8 *)rcv_buf->head[0].iov_base;
1955 : : mic_offset = integ_len + data_offset;
1956 : : if (mic_offset > rcv_buf->len)
1957 : : goto unwrap_failed;
1958 : : if (be32_to_cpup(p) != rqstp->rq_seqno)
1959 : : goto bad_seqno;
1960 : :
1961 : : if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset, integ_len))
1962 : : goto unwrap_failed;
1963 : : if (xdr_buf_read_mic(rcv_buf, &mic, mic_offset))
1964 : : goto unwrap_failed;
1965 : : maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
1966 : : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1967 : : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1968 : : if (maj_stat != GSS_S_COMPLETE)
1969 : : goto bad_mic;
1970 : :
1971 : : auth->au_rslack = auth->au_verfsize + 2 + 1 + XDR_QUADLEN(mic.len);
1972 : : auth->au_ralign = auth->au_verfsize + 2;
1973 : : return 0;
1974 : : unwrap_failed:
1975 : : trace_rpcgss_unwrap_failed(task);
1976 : : return -EIO;
1977 : : bad_seqno:
1978 : : trace_rpcgss_bad_seqno(task, rqstp->rq_seqno, be32_to_cpup(p));
1979 : : return -EIO;
1980 : : bad_mic:
1981 : : trace_rpcgss_verify_mic(task, maj_stat);
1982 : : return -EIO;
1983 : : }
1984 : :
1985 : : static int
1986 : : gss_unwrap_resp_priv(struct rpc_task *task, struct rpc_cred *cred,
1987 : : struct gss_cl_ctx *ctx, struct rpc_rqst *rqstp,
1988 : : struct xdr_stream *xdr)
1989 : : {
1990 : : struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1991 : : struct kvec *head = rqstp->rq_rcv_buf.head;
1992 : : struct rpc_auth *auth = cred->cr_auth;
1993 : : unsigned int savedlen = rcv_buf->len;
1994 : : u32 offset, opaque_len, maj_stat;
1995 : : __be32 *p;
1996 : :
1997 : : p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1998 : : if (unlikely(!p))
1999 : : goto unwrap_failed;
2000 : : opaque_len = be32_to_cpup(p++);
2001 : : offset = (u8 *)(p) - (u8 *)head->iov_base;
2002 : : if (offset + opaque_len > rcv_buf->len)
2003 : : goto unwrap_failed;
2004 : : rcv_buf->len = offset + opaque_len;
2005 : :
2006 : : maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);
2007 : : if (maj_stat == GSS_S_CONTEXT_EXPIRED)
2008 : : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
2009 : : if (maj_stat != GSS_S_COMPLETE)
2010 : : goto bad_unwrap;
2011 : : /* gss_unwrap decrypted the sequence number */
2012 : : if (be32_to_cpup(p++) != rqstp->rq_seqno)
2013 : : goto bad_seqno;
2014 : :
2015 : : /* gss_unwrap redacts the opaque blob from the head iovec.
2016 : : * rcv_buf has changed, thus the stream needs to be reset.
2017 : : */
2018 : : xdr_init_decode(xdr, rcv_buf, p, rqstp);
2019 : :
2020 : : auth->au_rslack = auth->au_verfsize + 2 +
2021 : : XDR_QUADLEN(savedlen - rcv_buf->len);
2022 : : auth->au_ralign = auth->au_verfsize + 2 +
2023 : : XDR_QUADLEN(savedlen - rcv_buf->len);
2024 : : return 0;
2025 : : unwrap_failed:
2026 : : trace_rpcgss_unwrap_failed(task);
2027 : : return -EIO;
2028 : : bad_seqno:
2029 : : trace_rpcgss_bad_seqno(task, rqstp->rq_seqno, be32_to_cpup(--p));
2030 : : return -EIO;
2031 : : bad_unwrap:
2032 : : trace_rpcgss_unwrap(task, maj_stat);
2033 : : return -EIO;
2034 : : }
2035 : :
2036 : : static bool
2037 : 0 : gss_seq_is_newer(u32 new, u32 old)
2038 : : {
2039 [ # # ]: 0 : return (s32)(new - old) > 0;
2040 : : }
2041 : :
2042 : : static bool
2043 : 0 : gss_xmit_need_reencode(struct rpc_task *task)
2044 : : {
2045 : 0 : struct rpc_rqst *req = task->tk_rqstp;
2046 : 0 : struct rpc_cred *cred = req->rq_cred;
2047 : 0 : struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
2048 : 0 : u32 win, seq_xmit = 0;
2049 : 0 : bool ret = true;
2050 : :
2051 [ # # ]: 0 : if (!ctx)
2052 : 0 : goto out;
2053 : :
2054 [ # # ]: 0 : if (gss_seq_is_newer(req->rq_seqno, READ_ONCE(ctx->gc_seq)))
2055 : 0 : goto out_ctx;
2056 : :
2057 : 0 : seq_xmit = READ_ONCE(ctx->gc_seq_xmit);
2058 [ # # ]: 0 : while (gss_seq_is_newer(req->rq_seqno, seq_xmit)) {
2059 : 0 : u32 tmp = seq_xmit;
2060 : :
2061 : 0 : seq_xmit = cmpxchg(&ctx->gc_seq_xmit, tmp, req->rq_seqno);
2062 [ # # ]: 0 : if (seq_xmit == tmp) {
2063 : 0 : ret = false;
2064 : 0 : goto out_ctx;
2065 : : }
2066 : : }
2067 : :
2068 : 0 : win = ctx->gc_win;
2069 [ # # ]: 0 : if (win > 0)
2070 : 0 : ret = !gss_seq_is_newer(req->rq_seqno, seq_xmit - win);
2071 : :
2072 : 0 : out_ctx:
2073 : 0 : gss_put_ctx(ctx);
2074 : 0 : out:
2075 : 0 : trace_rpcgss_need_reencode(task, seq_xmit, ret);
2076 : 0 : return ret;
2077 : : }
2078 : :
2079 : : static int
2080 : 0 : gss_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr)
2081 : : {
2082 : 0 : struct rpc_rqst *rqstp = task->tk_rqstp;
2083 : 0 : struct rpc_cred *cred = rqstp->rq_cred;
2084 : 0 : struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
2085 : : gc_base);
2086 : 0 : struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
2087 : 0 : int status = -EIO;
2088 : :
2089 [ # # ]: 0 : if (ctx->gc_proc != RPC_GSS_PROC_DATA)
2090 : 0 : goto out_decode;
2091 [ # # # # ]: 0 : switch (gss_cred->gc_service) {
2092 : 0 : case RPC_GSS_SVC_NONE:
2093 : 0 : status = gss_unwrap_resp_auth(cred);
2094 : 0 : break;
2095 : 0 : case RPC_GSS_SVC_INTEGRITY:
2096 : 0 : status = gss_unwrap_resp_integ(task, cred, ctx, rqstp, xdr);
2097 : 0 : break;
2098 : 0 : case RPC_GSS_SVC_PRIVACY:
2099 : 0 : status = gss_unwrap_resp_priv(task, cred, ctx, rqstp, xdr);
2100 : 0 : break;
2101 : : }
2102 [ # # ]: 0 : if (status)
2103 : 0 : goto out;
2104 : :
2105 : 0 : out_decode:
2106 : 0 : status = rpcauth_unwrap_resp_decode(task, xdr);
2107 : 0 : out:
2108 : 0 : gss_put_ctx(ctx);
2109 : 0 : return status;
2110 : : }
2111 : :
2112 : : static const struct rpc_authops authgss_ops = {
2113 : : .owner = THIS_MODULE,
2114 : : .au_flavor = RPC_AUTH_GSS,
2115 : : .au_name = "RPCSEC_GSS",
2116 : : .create = gss_create,
2117 : : .destroy = gss_destroy,
2118 : : .hash_cred = gss_hash_cred,
2119 : : .lookup_cred = gss_lookup_cred,
2120 : : .crcreate = gss_create_cred,
2121 : : .info2flavor = gss_mech_info2flavor,
2122 : : .flavor2info = gss_mech_flavor2info,
2123 : : };
2124 : :
2125 : : static const struct rpc_credops gss_credops = {
2126 : : .cr_name = "AUTH_GSS",
2127 : : .crdestroy = gss_destroy_cred,
2128 : : .cr_init = gss_cred_init,
2129 : : .crmatch = gss_match,
2130 : : .crmarshal = gss_marshal,
2131 : : .crrefresh = gss_refresh,
2132 : : .crvalidate = gss_validate,
2133 : : .crwrap_req = gss_wrap_req,
2134 : : .crunwrap_resp = gss_unwrap_resp,
2135 : : .crkey_timeout = gss_key_timeout,
2136 : : .crstringify_acceptor = gss_stringify_acceptor,
2137 : : .crneed_reencode = gss_xmit_need_reencode,
2138 : : };
2139 : :
2140 : : static const struct rpc_credops gss_nullops = {
2141 : : .cr_name = "AUTH_GSS",
2142 : : .crdestroy = gss_destroy_nullcred,
2143 : : .crmatch = gss_match,
2144 : : .crmarshal = gss_marshal,
2145 : : .crrefresh = gss_refresh_null,
2146 : : .crvalidate = gss_validate,
2147 : : .crwrap_req = gss_wrap_req,
2148 : : .crunwrap_resp = gss_unwrap_resp,
2149 : : .crstringify_acceptor = gss_stringify_acceptor,
2150 : : };
2151 : :
2152 : : static const struct rpc_pipe_ops gss_upcall_ops_v0 = {
2153 : : .upcall = gss_v0_upcall,
2154 : : .downcall = gss_pipe_downcall,
2155 : : .destroy_msg = gss_pipe_destroy_msg,
2156 : : .open_pipe = gss_pipe_open_v0,
2157 : : .release_pipe = gss_pipe_release,
2158 : : };
2159 : :
2160 : : static const struct rpc_pipe_ops gss_upcall_ops_v1 = {
2161 : : .upcall = gss_v1_upcall,
2162 : : .downcall = gss_pipe_downcall,
2163 : : .destroy_msg = gss_pipe_destroy_msg,
2164 : : .open_pipe = gss_pipe_open_v1,
2165 : : .release_pipe = gss_pipe_release,
2166 : : };
2167 : :
2168 : 13 : static __net_init int rpcsec_gss_init_net(struct net *net)
2169 : : {
2170 : 13 : return gss_svc_init_net(net);
2171 : : }
2172 : :
2173 : 0 : static __net_exit void rpcsec_gss_exit_net(struct net *net)
2174 : : {
2175 : 0 : gss_svc_shutdown_net(net);
2176 : 0 : }
2177 : :
2178 : : static struct pernet_operations rpcsec_gss_net_ops = {
2179 : : .init = rpcsec_gss_init_net,
2180 : : .exit = rpcsec_gss_exit_net,
2181 : : };
2182 : :
2183 : : /*
2184 : : * Initialize RPCSEC_GSS module
2185 : : */
2186 : 13 : static int __init init_rpcsec_gss(void)
2187 : : {
2188 : 13 : int err = 0;
2189 : :
2190 : 13 : err = rpcauth_register(&authgss_ops);
2191 [ - + ]: 13 : if (err)
2192 : 0 : goto out;
2193 : 13 : err = gss_svc_init();
2194 [ - + ]: 13 : if (err)
2195 : 0 : goto out_unregister;
2196 : 13 : err = register_pernet_subsys(&rpcsec_gss_net_ops);
2197 [ - + ]: 13 : if (err)
2198 : 0 : goto out_svc_exit;
2199 : 13 : rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version");
2200 : 13 : return 0;
2201 : : out_svc_exit:
2202 : 0 : gss_svc_shutdown();
2203 : 0 : out_unregister:
2204 : 0 : rpcauth_unregister(&authgss_ops);
2205 : : out:
2206 : : return err;
2207 : : }
2208 : :
2209 : 0 : static void __exit exit_rpcsec_gss(void)
2210 : : {
2211 : 0 : unregister_pernet_subsys(&rpcsec_gss_net_ops);
2212 : 0 : gss_svc_shutdown();
2213 : 0 : rpcauth_unregister(&authgss_ops);
2214 : 0 : rcu_barrier(); /* Wait for completion of call_rcu()'s */
2215 : 0 : }
2216 : :
2217 : : MODULE_ALIAS("rpc-auth-6");
2218 : : MODULE_LICENSE("GPL");
2219 : : module_param_named(expired_cred_retry_delay,
2220 : : gss_expired_cred_retry_delay,
2221 : : uint, 0644);
2222 : : MODULE_PARM_DESC(expired_cred_retry_delay, "Timeout (in seconds) until "
2223 : : "the RPC engine retries an expired credential");
2224 : :
2225 : : module_param_named(key_expire_timeo,
2226 : : gss_key_expire_timeo,
2227 : : uint, 0644);
2228 : : MODULE_PARM_DESC(key_expire_timeo, "Time (in seconds) at the end of a "
2229 : : "credential keys lifetime where the NFS layer cleans up "
2230 : : "prior to key expiration");
2231 : :
2232 : : module_init(init_rpcsec_gss)
2233 : : module_exit(exit_rpcsec_gss)
|
