blob: 3dfd769dc5b51a724f20273eb0c52e5d6e25e9f1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Uwe Zeisbergerf30c2262006-10-03 23:01:26 +02002 * linux/net/sunrpc/auth_gss/auth_gss.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * RPCSEC_GSS client authentication.
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (c) 2000 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Dug Song <dugsong@monkey.org>
10 * Andy Adamson <andros@umich.edu>
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 */
37
38
39#include <linux/module.h>
40#include <linux/init.h>
41#include <linux/types.h>
42#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/sched.h>
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -040044#include <linux/pagemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/sunrpc/clnt.h>
46#include <linux/sunrpc/auth.h>
47#include <linux/sunrpc/auth_gss.h>
48#include <linux/sunrpc/svcauth_gss.h>
49#include <linux/sunrpc/gss_err.h>
50#include <linux/workqueue.h>
51#include <linux/sunrpc/rpc_pipe_fs.h>
52#include <linux/sunrpc/gss_api.h>
53#include <asm/uaccess.h>
Trond Myklebusteb6dc192013-08-28 15:26:25 -040054#include <linux/hashtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Trond Myklebustabfdbd52013-05-15 11:28:54 -070056#include "../netns.h"
57
Trond Myklebustf1c0a862007-06-23 20:17:58 -040058static const struct rpc_authops authgss_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Trond Myklebustf1c0a862007-06-23 20:17:58 -040060static const struct rpc_credops gss_credops;
Trond Myklebust0df7fb72007-06-26 17:04:57 -040061static const struct rpc_credops gss_nullops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Trond Myklebust126e2162010-05-13 12:55:38 -040063#define GSS_RETRY_EXPIRED 5
64static unsigned int gss_expired_cred_retry_delay = GSS_RETRY_EXPIRED;
65
Andy Adamson4de6caa2013-08-14 11:59:15 -040066#define GSS_KEY_EXPIRE_TIMEO 240
67static unsigned int gss_key_expire_timeo = GSS_KEY_EXPIRE_TIMEO;
68
Jeff Laytonf895b252014-11-17 16:58:04 -050069#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070# define RPCDBG_FACILITY RPCDBG_AUTH
71#endif
72
Kevin Coffman725f2862010-03-17 13:02:46 -040073#define GSS_CRED_SLACK (RPC_MAX_AUTH_SIZE * 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/* length of a krb5 verifier (48), plus data added before arguments when
75 * using integrity (two 4-byte integers): */
Olga Kornievskaiaadeb8132006-12-04 20:22:34 -050076#define GSS_VERF_SLACK 100
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Trond Myklebust23c323a2013-09-12 10:16:31 -040078static DEFINE_HASHTABLE(gss_auth_hash_table, 4);
Trond Myklebusteb6dc192013-08-28 15:26:25 -040079static DEFINE_SPINLOCK(gss_auth_hash_lock);
80
Trond Myklebust19172282013-08-26 16:44:42 -040081struct gss_pipe {
82 struct rpc_pipe_dir_object pdo;
83 struct rpc_pipe *pipe;
84 struct rpc_clnt *clnt;
85 const char *name;
Trond Myklebust414a6292013-08-27 16:52:16 -040086 struct kref kref;
Trond Myklebust19172282013-08-26 16:44:42 -040087};
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089struct gss_auth {
Trond Myklebust0285ed12007-06-27 14:29:12 -040090 struct kref kref;
Trond Myklebusteb6dc192013-08-28 15:26:25 -040091 struct hlist_node hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 struct rpc_auth rpc_auth;
93 struct gss_api_mech *mech;
94 enum rpc_gss_svc service;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 struct rpc_clnt *client;
Trond Myklebuste726340a2013-08-23 14:42:29 -040096 struct net *net;
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -050097 /*
98 * There are two upcall pipes; dentry[1], named "gssd", is used
99 * for the new text-based upcall; dentry[0] is named after the
100 * mechanism (for example, "krb5") and exists for
101 * backwards-compatibility with older gssd's.
102 */
Trond Myklebust19172282013-08-26 16:44:42 -0400103 struct gss_pipe *gss_pipe[2];
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400104 const char *target_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500107/* pipe_version >= 0 if and only if someone has a pipe open. */
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500108static DEFINE_SPINLOCK(pipe_version_lock);
109static struct rpc_wait_queue pipe_version_rpc_waitqueue;
110static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue);
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -0500111static void gss_put_auth(struct gss_auth *gss_auth);
\"J. Bruce Fields\cf819392008-12-23 16:10:19 -0500112
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400113static void gss_free_ctx(struct gss_cl_ctx *);
Trond Myklebustb693ba42009-08-09 15:14:15 -0400114static const struct rpc_pipe_ops gss_upcall_ops_v0;
115static const struct rpc_pipe_ops gss_upcall_ops_v1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117static inline struct gss_cl_ctx *
118gss_get_ctx(struct gss_cl_ctx *ctx)
119{
120 atomic_inc(&ctx->count);
121 return ctx;
122}
123
124static inline void
125gss_put_ctx(struct gss_cl_ctx *ctx)
126{
127 if (atomic_dec_and_test(&ctx->count))
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400128 gss_free_ctx(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400131/* gss_cred_set_ctx:
132 * called by gss_upcall_callback and gss_create_upcall in order
133 * to set the gss context. The actual exchange of an old context
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300134 * and a new one is protected by the pipe->lock.
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400135 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136static void
137gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
138{
139 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400140
Trond Myklebustcd019f72008-04-17 17:03:58 -0400141 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
142 return;
Trond Myklebust7b6962b2008-04-17 16:53:01 -0400143 gss_get_ctx(ctx);
Eric Dumazetcf778b02012-01-12 04:41:32 +0000144 rcu_assign_pointer(gss_cred->gc_ctx, ctx);
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400145 set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +0100146 smp_mb__before_atomic();
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400147 clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
150static const void *
151simple_get_bytes(const void *p, const void *end, void *res, size_t len)
152{
153 const void *q = (const void *)((const char *)p + len);
154 if (unlikely(q > end || q < p))
155 return ERR_PTR(-EFAULT);
156 memcpy(res, p, len);
157 return q;
158}
159
160static inline const void *
161simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)
162{
163 const void *q;
164 unsigned int len;
165
166 p = simple_get_bytes(p, end, &len, sizeof(len));
167 if (IS_ERR(p))
168 return p;
169 q = (const void *)((const char *)p + len);
170 if (unlikely(q > end || q < p))
171 return ERR_PTR(-EFAULT);
Trond Myklebust0f38b872008-06-10 18:31:01 -0400172 dest->data = kmemdup(p, len, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (unlikely(dest->data == NULL))
174 return ERR_PTR(-ENOMEM);
175 dest->len = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return q;
177}
178
179static struct gss_cl_ctx *
180gss_cred_get_ctx(struct rpc_cred *cred)
181{
182 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
183 struct gss_cl_ctx *ctx = NULL;
184
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400185 rcu_read_lock();
Jeff Laytonc5e6aec2014-07-16 06:52:19 -0400186 ctx = rcu_dereference(gss_cred->gc_ctx);
187 if (ctx)
188 gss_get_ctx(ctx);
Trond Myklebust5d28dc82007-06-26 19:18:38 -0400189 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 return ctx;
191}
192
193static struct gss_cl_ctx *
194gss_alloc_context(void)
195{
196 struct gss_cl_ctx *ctx;
197
Trond Myklebust0f38b872008-06-10 18:31:01 -0400198 ctx = kzalloc(sizeof(*ctx), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 if (ctx != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 ctx->gc_proc = RPC_GSS_PROC_DATA;
201 ctx->gc_seq = 1; /* NetApp 6.4R1 doesn't accept seq. no. 0 */
202 spin_lock_init(&ctx->gc_seq_lock);
203 atomic_set(&ctx->count,1);
204 }
205 return ctx;
206}
207
208#define GSSD_MIN_TIMEOUT (60 * 60)
209static const void *
210gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)
211{
212 const void *q;
213 unsigned int seclen;
214 unsigned int timeout;
Andy Adamson620038f2012-11-27 10:34:20 -0500215 unsigned long now = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 u32 window_size;
217 int ret;
218
Andy Adamson620038f2012-11-27 10:34:20 -0500219 /* First unsigned int gives the remaining lifetime in seconds of the
220 * credential - e.g. the remaining TGT lifetime for Kerberos or
221 * the -t value passed to GSSD.
222 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 p = simple_get_bytes(p, end, &timeout, sizeof(timeout));
224 if (IS_ERR(p))
225 goto err;
226 if (timeout == 0)
227 timeout = GSSD_MIN_TIMEOUT;
Andy Adamson620038f2012-11-27 10:34:20 -0500228 ctx->gc_expiry = now + ((unsigned long)timeout * HZ);
229 /* Sequence number window. Determines the maximum number of
230 * simultaneous requests
231 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 p = simple_get_bytes(p, end, &window_size, sizeof(window_size));
233 if (IS_ERR(p))
234 goto err;
235 ctx->gc_win = window_size;
236 /* gssd signals an error by passing ctx->gc_win = 0: */
237 if (ctx->gc_win == 0) {
Jeff Laytondc5ddce2010-01-07 09:42:02 -0500238 /*
239 * in which case, p points to an error code. Anything other
240 * than -EKEYEXPIRED gets converted to -EACCES.
241 */
242 p = simple_get_bytes(p, end, &ret, sizeof(ret));
243 if (!IS_ERR(p))
244 p = (ret == -EKEYEXPIRED) ? ERR_PTR(-EKEYEXPIRED) :
245 ERR_PTR(-EACCES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 goto err;
247 }
248 /* copy the opaque wire context */
249 p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);
250 if (IS_ERR(p))
251 goto err;
252 /* import the opaque security context */
253 p = simple_get_bytes(p, end, &seclen, sizeof(seclen));
254 if (IS_ERR(p))
255 goto err;
256 q = (const void *)((const char *)p + seclen);
257 if (unlikely(q > end || q < p)) {
258 p = ERR_PTR(-EFAULT);
259 goto err;
260 }
Simo Sorce400f26b2012-05-25 18:09:53 -0400261 ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx, NULL, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 if (ret < 0) {
263 p = ERR_PTR(ret);
264 goto err;
265 }
Jeff Layton2004c722014-06-21 20:52:15 -0400266
267 /* is there any trailing data? */
268 if (q == end) {
269 p = q;
270 goto done;
271 }
272
273 /* pull in acceptor name (if there is one) */
274 p = simple_get_netobj(q, end, &ctx->gc_acceptor);
275 if (IS_ERR(p))
276 goto err;
277done:
278 dprintk("RPC: %s Success. gc_expiry %lu now %lu timeout %u acceptor %.*s\n",
279 __func__, ctx->gc_expiry, now, timeout, ctx->gc_acceptor.len,
280 ctx->gc_acceptor.data);
281 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282err:
Jeff Layton173db302013-02-07 10:29:06 -0500283 dprintk("RPC: %s returns error %ld\n", __func__, -PTR_ERR(p));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return p;
285}
286
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500287#define UPCALL_BUF_LEN 128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289struct gss_upcall_msg {
290 atomic_t count;
Eric W. Biederman7eaf0402013-02-01 16:31:17 -0800291 kuid_t uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 struct rpc_pipe_msg msg;
293 struct list_head list;
294 struct gss_auth *auth;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300295 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 struct rpc_wait_queue rpc_waitqueue;
297 wait_queue_head_t waitqueue;
298 struct gss_cl_ctx *ctx;
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500299 char databuf[UPCALL_BUF_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300};
301
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700302static int get_pipe_version(struct net *net)
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500303{
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700304 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500305 int ret;
306
307 spin_lock(&pipe_version_lock);
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700308 if (sn->pipe_version >= 0) {
309 atomic_inc(&sn->pipe_users);
310 ret = sn->pipe_version;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500311 } else
312 ret = -EAGAIN;
313 spin_unlock(&pipe_version_lock);
314 return ret;
315}
316
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700317static void put_pipe_version(struct net *net)
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500318{
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700319 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
320
321 if (atomic_dec_and_lock(&sn->pipe_users, &pipe_version_lock)) {
322 sn->pipe_version = -1;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500323 spin_unlock(&pipe_version_lock);
324 }
325}
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327static void
328gss_release_msg(struct gss_upcall_msg *gss_msg)
329{
Trond Myklebuste726340a2013-08-23 14:42:29 -0400330 struct net *net = gss_msg->auth->net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 if (!atomic_dec_and_test(&gss_msg->count))
332 return;
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700333 put_pipe_version(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 BUG_ON(!list_empty(&gss_msg->list));
335 if (gss_msg->ctx != NULL)
336 gss_put_ctx(gss_msg->ctx);
Trond Myklebustf6a1cc82008-02-22 17:06:55 -0500337 rpc_destroy_wait_queue(&gss_msg->rpc_waitqueue);
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -0500338 gss_put_auth(gss_msg->auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 kfree(gss_msg);
340}
341
342static struct gss_upcall_msg *
Olga Kornievskaia9130b8d2016-08-03 20:19:48 -0400343__gss_find_upcall(struct rpc_pipe *pipe, kuid_t uid, const struct gss_auth *auth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344{
345 struct gss_upcall_msg *pos;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300346 list_for_each_entry(pos, &pipe->in_downcall, list) {
Eric W. Biederman0b4d51b2013-02-01 16:39:32 -0800347 if (!uid_eq(pos->uid, uid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 continue;
Olga Kornievskaia9130b8d2016-08-03 20:19:48 -0400349 if (auth && pos->auth->service != auth->service)
350 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 atomic_inc(&pos->count);
Chuck Lever632f0d02012-09-14 17:23:43 -0400352 dprintk("RPC: %s found msg %p\n", __func__, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return pos;
354 }
Chuck Lever632f0d02012-09-14 17:23:43 -0400355 dprintk("RPC: %s found nothing\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return NULL;
357}
358
\\\"J. Bruce Fields\\\720b8f22008-06-09 16:51:33 -0400359/* Try to add an upcall to the pipefs queue.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 * If an upcall owned by our uid already exists, then we return a reference
361 * to that upcall instead of adding the new upcall.
362 */
363static inline struct gss_upcall_msg *
Suresh Jayaraman053e3242009-12-09 23:15:22 +0530364gss_add_msg(struct gss_upcall_msg *gss_msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300366 struct rpc_pipe *pipe = gss_msg->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 struct gss_upcall_msg *old;
368
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300369 spin_lock(&pipe->lock);
Olga Kornievskaia9130b8d2016-08-03 20:19:48 -0400370 old = __gss_find_upcall(pipe, gss_msg->uid, gss_msg->auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (old == NULL) {
372 atomic_inc(&gss_msg->count);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300373 list_add(&gss_msg->list, &pipe->in_downcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 } else
375 gss_msg = old;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300376 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return gss_msg;
378}
379
380static void
381__gss_unhash_msg(struct gss_upcall_msg *gss_msg)
382{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 list_del_init(&gss_msg->list);
384 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
385 wake_up_all(&gss_msg->waitqueue);
386 atomic_dec(&gss_msg->count);
387}
388
389static void
390gss_unhash_msg(struct gss_upcall_msg *gss_msg)
391{
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300392 struct rpc_pipe *pipe = gss_msg->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400394 if (list_empty(&gss_msg->list))
395 return;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300396 spin_lock(&pipe->lock);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400397 if (!list_empty(&gss_msg->list))
398 __gss_unhash_msg(gss_msg);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300399 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400}
401
402static void
Trond Myklebust126e2162010-05-13 12:55:38 -0400403gss_handle_downcall_result(struct gss_cred *gss_cred, struct gss_upcall_msg *gss_msg)
404{
405 switch (gss_msg->msg.errno) {
406 case 0:
407 if (gss_msg->ctx == NULL)
408 break;
409 clear_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);
410 gss_cred_set_ctx(&gss_cred->gc_base, gss_msg->ctx);
411 break;
412 case -EKEYEXPIRED:
413 set_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);
414 }
415 gss_cred->gc_upcall_timestamp = jiffies;
416 gss_cred->gc_upcall = NULL;
417 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
418}
419
420static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421gss_upcall_callback(struct rpc_task *task)
422{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400423 struct gss_cred *gss_cred = container_of(task->tk_rqstp->rq_cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 struct gss_cred, gc_base);
425 struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300426 struct rpc_pipe *pipe = gss_msg->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300428 spin_lock(&pipe->lock);
Trond Myklebust126e2162010-05-13 12:55:38 -0400429 gss_handle_downcall_result(gss_cred, gss_msg);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300430 spin_unlock(&pipe->lock);
Trond Myklebust126e2162010-05-13 12:55:38 -0400431 task->tk_status = gss_msg->msg.errno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 gss_release_msg(gss_msg);
433}
434
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500435static void gss_encode_v0_msg(struct gss_upcall_msg *gss_msg)
436{
Eric W. Biederman90602c72013-02-02 00:25:43 -0800437 uid_t uid = from_kuid(&init_user_ns, gss_msg->uid);
438 memcpy(gss_msg->databuf, &uid, sizeof(uid));
439 gss_msg->msg.data = gss_msg->databuf;
440 gss_msg->msg.len = sizeof(uid);
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400441
442 BUILD_BUG_ON(sizeof(uid) > sizeof(gss_msg->databuf));
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500443}
444
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400445static int gss_encode_v1_msg(struct gss_upcall_msg *gss_msg,
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400446 const char *service_name,
447 const char *target_name)
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500448{
Trond Myklebust683ac662010-04-08 14:09:58 -0400449 struct gss_api_mech *mech = gss_msg->auth->mech;
Olga Kornievskaia8b1c7bf2008-12-23 16:19:26 -0500450 char *p = gss_msg->databuf;
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400451 size_t buflen = sizeof(gss_msg->databuf);
452 int len;
Olga Kornievskaia8b1c7bf2008-12-23 16:19:26 -0500453
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400454 len = scnprintf(p, buflen, "mech=%s uid=%d ", mech->gm_name,
455 from_kuid(&init_user_ns, gss_msg->uid));
456 buflen -= len;
457 p += len;
458 gss_msg->msg.len = len;
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400459 if (target_name) {
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400460 len = scnprintf(p, buflen, "target=%s ", target_name);
461 buflen -= len;
Olga Kornievskaia8b1c7bf2008-12-23 16:19:26 -0500462 p += len;
463 gss_msg->msg.len += len;
464 }
Trond Myklebust68c97152012-01-03 13:22:46 -0500465 if (service_name != NULL) {
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400466 len = scnprintf(p, buflen, "service=%s ", service_name);
467 buflen -= len;
Olga Kornievskaia2efef702008-12-23 16:19:56 -0500468 p += len;
469 gss_msg->msg.len += len;
470 }
Trond Myklebust683ac662010-04-08 14:09:58 -0400471 if (mech->gm_upcall_enctypes) {
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400472 len = scnprintf(p, buflen, "enctypes=%s ",
473 mech->gm_upcall_enctypes);
474 buflen -= len;
Trond Myklebust683ac662010-04-08 14:09:58 -0400475 p += len;
476 gss_msg->msg.len += len;
477 }
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400478 len = scnprintf(p, buflen, "\n");
479 if (len == 0)
480 goto out_overflow;
Olga Kornievskaia8b1c7bf2008-12-23 16:19:26 -0500481 gss_msg->msg.len += len;
482
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500483 gss_msg->msg.data = gss_msg->databuf;
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400484 return 0;
485out_overflow:
486 WARN_ON_ONCE(1);
487 return -ENOMEM;
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500488}
489
Trond Myklebust68c97152012-01-03 13:22:46 -0500490static struct gss_upcall_msg *
Trond Myklebuste726340a2013-08-23 14:42:29 -0400491gss_alloc_msg(struct gss_auth *gss_auth,
Eric W. Biederman7eaf0402013-02-01 16:31:17 -0800492 kuid_t uid, const char *service_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
494 struct gss_upcall_msg *gss_msg;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500495 int vers;
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400496 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Trond Myklebust0f38b872008-06-10 18:31:01 -0400498 gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);
\"J. Bruce Fields\db75b3d2008-12-23 16:07:13 -0500499 if (gss_msg == NULL)
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400500 goto err;
Trond Myklebuste726340a2013-08-23 14:42:29 -0400501 vers = get_pipe_version(gss_auth->net);
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400502 err = vers;
503 if (err < 0)
504 goto err_free_msg;
Trond Myklebust19172282013-08-26 16:44:42 -0400505 gss_msg->pipe = gss_auth->gss_pipe[vers]->pipe;
\"J. Bruce Fields\db75b3d2008-12-23 16:07:13 -0500506 INIT_LIST_HEAD(&gss_msg->list);
507 rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
508 init_waitqueue_head(&gss_msg->waitqueue);
509 atomic_set(&gss_msg->count, 1);
\"J. Bruce Fields\db75b3d2008-12-23 16:07:13 -0500510 gss_msg->uid = uid;
511 gss_msg->auth = gss_auth;
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400512 switch (vers) {
513 case 0:
514 gss_encode_v0_msg(gss_msg);
Trond Myklebust5fccc5b2013-10-28 18:41:44 -0400515 break;
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400516 default:
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400517 err = gss_encode_v1_msg(gss_msg, service_name, gss_auth->target_name);
518 if (err)
Trond Myklebuste9776d02014-02-16 13:28:01 -0500519 goto err_put_pipe_version;
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400520 };
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -0500521 kref_get(&gss_auth->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 return gss_msg;
Trond Myklebuste9776d02014-02-16 13:28:01 -0500523err_put_pipe_version:
524 put_pipe_version(gss_auth->net);
Trond Myklebust9d3a2262013-10-28 18:18:00 -0400525err_free_msg:
526 kfree(gss_msg);
527err:
528 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529}
530
531static struct gss_upcall_msg *
Trond Myklebuste726340a2013-08-23 14:42:29 -0400532gss_setup_upcall(struct gss_auth *gss_auth, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
Trond Myklebust7c67db32008-04-07 20:50:11 -0400534 struct gss_cred *gss_cred = container_of(cred,
535 struct gss_cred, gc_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 struct gss_upcall_msg *gss_new, *gss_msg;
Eric W. Biederman7eaf0402013-02-01 16:31:17 -0800537 kuid_t uid = cred->cr_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Trond Myklebuste726340a2013-08-23 14:42:29 -0400539 gss_new = gss_alloc_msg(gss_auth, uid, gss_cred->gc_principal);
\"J. Bruce Fields\db75b3d2008-12-23 16:07:13 -0500540 if (IS_ERR(gss_new))
541 return gss_new;
Suresh Jayaraman053e3242009-12-09 23:15:22 +0530542 gss_msg = gss_add_msg(gss_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (gss_msg == gss_new) {
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300544 int res = rpc_queue_upcall(gss_new->pipe, &gss_new->msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 if (res) {
546 gss_unhash_msg(gss_new);
547 gss_msg = ERR_PTR(res);
548 }
549 } else
550 gss_release_msg(gss_new);
551 return gss_msg;
552}
553
\"J. Bruce Fields\b03568c2008-12-23 16:06:55 -0500554static void warn_gssd(void)
555{
Jeff Layton0ea9de02014-01-27 14:53:27 -0500556 dprintk("AUTH_GSS upcall failed. Please check user daemon is running.\n");
\"J. Bruce Fields\b03568c2008-12-23 16:06:55 -0500557}
558
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559static inline int
560gss_refresh_upcall(struct rpc_task *task)
561{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400562 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebust4a8c1342007-06-07 10:14:14 -0400563 struct gss_auth *gss_auth = container_of(cred->cr_auth,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 struct gss_auth, rpc_auth);
565 struct gss_cred *gss_cred = container_of(cred,
566 struct gss_cred, gc_base);
567 struct gss_upcall_msg *gss_msg;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300568 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 int err = 0;
570
Chuck Lever632f0d02012-09-14 17:23:43 -0400571 dprintk("RPC: %5u %s for uid %u\n",
Eric W. Biedermancdba3212013-02-01 17:10:52 -0800572 task->tk_pid, __func__, from_kuid(&init_user_ns, cred->cr_uid));
Trond Myklebuste726340a2013-08-23 14:42:29 -0400573 gss_msg = gss_setup_upcall(gss_auth, cred);
Roel Kluin480e3242009-12-08 13:13:03 -0500574 if (PTR_ERR(gss_msg) == -EAGAIN) {
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500575 /* XXX: warning on the first, under the assumption we
576 * shouldn't normally hit this case on a refresh. */
577 warn_gssd();
578 task->tk_timeout = 15*HZ;
579 rpc_sleep_on(&pipe_version_rpc_waitqueue, task, NULL);
Bryan Schumakerd1a80162011-04-13 14:31:28 -0400580 return -EAGAIN;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500581 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 if (IS_ERR(gss_msg)) {
583 err = PTR_ERR(gss_msg);
584 goto out;
585 }
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300586 pipe = gss_msg->pipe;
587 spin_lock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (gss_cred->gc_upcall != NULL)
Trond Myklebust5d008372008-02-22 16:34:17 -0500589 rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL);
Trond Myklebust126e2162010-05-13 12:55:38 -0400590 else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 task->tk_timeout = 0;
592 gss_cred->gc_upcall = gss_msg;
593 /* gss_upcall_callback will release the reference to gss_upcall_msg */
594 atomic_inc(&gss_msg->count);
Trond Myklebust5d008372008-02-22 16:34:17 -0500595 rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback);
Trond Myklebust126e2162010-05-13 12:55:38 -0400596 } else {
597 gss_handle_downcall_result(gss_cred, gss_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 err = gss_msg->msg.errno;
Trond Myklebust126e2162010-05-13 12:55:38 -0400599 }
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300600 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 gss_release_msg(gss_msg);
602out:
Chuck Lever632f0d02012-09-14 17:23:43 -0400603 dprintk("RPC: %5u %s for uid %u result %d\n",
Eric W. Biedermancdba3212013-02-01 17:10:52 -0800604 task->tk_pid, __func__,
605 from_kuid(&init_user_ns, cred->cr_uid), err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 return err;
607}
608
609static inline int
610gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
611{
Trond Myklebuste726340a2013-08-23 14:42:29 -0400612 struct net *net = gss_auth->net;
Trond Myklebustabfdbd52013-05-15 11:28:54 -0700613 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300614 struct rpc_pipe *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 struct rpc_cred *cred = &gss_cred->gc_base;
616 struct gss_upcall_msg *gss_msg;
617 DEFINE_WAIT(wait);
Trond Myklebustd36ccb92013-05-15 10:46:33 -0700618 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Eric W. Biedermancdba3212013-02-01 17:10:52 -0800620 dprintk("RPC: %s for uid %u\n",
621 __func__, from_kuid(&init_user_ns, cred->cr_uid));
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500622retry:
Trond Myklebustd36ccb92013-05-15 10:46:33 -0700623 err = 0;
Jeff Layton89f84242013-11-14 07:25:18 -0500624 /* if gssd is down, just skip upcalling altogether */
625 if (!gssd_running(net)) {
626 warn_gssd();
627 return -EACCES;
628 }
Trond Myklebuste726340a2013-08-23 14:42:29 -0400629 gss_msg = gss_setup_upcall(gss_auth, cred);
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500630 if (PTR_ERR(gss_msg) == -EAGAIN) {
631 err = wait_event_interruptible_timeout(pipe_version_waitqueue,
Jeff Layton89f84242013-11-14 07:25:18 -0500632 sn->pipe_version >= 0, 15 * HZ);
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700633 if (sn->pipe_version < 0) {
Bryan Schumakerd1a80162011-04-13 14:31:28 -0400634 warn_gssd();
635 err = -EACCES;
636 }
Trond Myklebustd36ccb92013-05-15 10:46:33 -0700637 if (err < 0)
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500638 goto out;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500639 goto retry;
640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 if (IS_ERR(gss_msg)) {
642 err = PTR_ERR(gss_msg);
643 goto out;
644 }
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300645 pipe = gss_msg->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 for (;;) {
Trond Myklebust5afa9132011-06-17 10:14:59 -0400647 prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_KILLABLE);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300648 spin_lock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 break;
651 }
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300652 spin_unlock(&pipe->lock);
Trond Myklebust5afa9132011-06-17 10:14:59 -0400653 if (fatal_signal_pending(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 err = -ERESTARTSYS;
655 goto out_intr;
656 }
657 schedule();
658 }
659 if (gss_msg->ctx)
Trond Myklebust7b6962b2008-04-17 16:53:01 -0400660 gss_cred_set_ctx(cred, gss_msg->ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 else
662 err = gss_msg->msg.errno;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300663 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664out_intr:
665 finish_wait(&gss_msg->waitqueue, &wait);
666 gss_release_msg(gss_msg);
667out:
Chuck Lever632f0d02012-09-14 17:23:43 -0400668 dprintk("RPC: %s for uid %u result %d\n",
Eric W. Biedermancdba3212013-02-01 17:10:52 -0800669 __func__, from_kuid(&init_user_ns, cred->cr_uid), err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return err;
671}
672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673#define MSG_BUF_MAXSIZE 1024
674
675static ssize_t
676gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
677{
678 const void *p, *end;
679 void *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 struct gss_upcall_msg *gss_msg;
Al Viro496ad9a2013-01-23 17:07:38 -0500681 struct rpc_pipe *pipe = RPC_I(file_inode(filp))->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 struct gss_cl_ctx *ctx;
Eric W. Biederman90602c72013-02-02 00:25:43 -0800683 uid_t id;
684 kuid_t uid;
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400685 ssize_t err = -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 if (mlen > MSG_BUF_MAXSIZE)
688 goto out;
689 err = -ENOMEM;
Trond Myklebust0f38b872008-06-10 18:31:01 -0400690 buf = kmalloc(mlen, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 if (!buf)
692 goto out;
693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 err = -EFAULT;
695 if (copy_from_user(buf, src, mlen))
696 goto err;
697
698 end = (const void *)((char *)buf + mlen);
Eric W. Biederman90602c72013-02-02 00:25:43 -0800699 p = simple_get_bytes(buf, end, &id, sizeof(id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (IS_ERR(p)) {
701 err = PTR_ERR(p);
702 goto err;
703 }
704
Eric W. Biederman90602c72013-02-02 00:25:43 -0800705 uid = make_kuid(&init_user_ns, id);
706 if (!uid_valid(uid)) {
707 err = -EINVAL;
708 goto err;
709 }
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 err = -ENOMEM;
712 ctx = gss_alloc_context();
713 if (ctx == NULL)
714 goto err;
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400715
716 err = -ENOENT;
717 /* Find a matching upcall */
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300718 spin_lock(&pipe->lock);
Olga Kornievskaia9130b8d2016-08-03 20:19:48 -0400719 gss_msg = __gss_find_upcall(pipe, uid, NULL);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400720 if (gss_msg == NULL) {
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300721 spin_unlock(&pipe->lock);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400722 goto err_put_ctx;
723 }
724 list_del_init(&gss_msg->list);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300725 spin_unlock(&pipe->lock);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400726
Trond Myklebust6e84c7b2007-06-07 15:31:36 -0400727 p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 if (IS_ERR(p)) {
729 err = PTR_ERR(p);
Jeff Layton486bad22009-12-18 16:28:20 -0500730 switch (err) {
731 case -EACCES:
Jeff Laytondc5ddce2010-01-07 09:42:02 -0500732 case -EKEYEXPIRED:
Jeff Layton486bad22009-12-18 16:28:20 -0500733 gss_msg->msg.errno = err;
734 err = mlen;
735 break;
736 case -EFAULT:
737 case -ENOMEM:
738 case -EINVAL:
739 case -ENOSYS:
740 gss_msg->msg.errno = -EAGAIN;
741 break;
742 default:
743 printk(KERN_CRIT "%s: bad return from "
Randy Dunlap6c853092010-01-06 17:26:27 -0500744 "gss_fill_context: %zd\n", __func__, err);
Scott Mayhew437b3002016-02-16 16:20:25 -0500745 gss_msg->msg.errno = -EIO;
Jeff Layton486bad22009-12-18 16:28:20 -0500746 }
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400747 goto err_release_msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400749 gss_msg->ctx = gss_get_ctx(ctx);
750 err = mlen;
751
752err_release_msg:
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300753 spin_lock(&pipe->lock);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400754 __gss_unhash_msg(gss_msg);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300755 spin_unlock(&pipe->lock);
Trond Myklebust3b68aae2007-06-07 10:14:15 -0400756 gss_release_msg(gss_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757err_put_ctx:
758 gss_put_ctx(ctx);
759err:
760 kfree(buf);
761out:
Chuck Lever632f0d02012-09-14 17:23:43 -0400762 dprintk("RPC: %s returning %Zd\n", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 return err;
764}
765
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500766static int gss_pipe_open(struct inode *inode, int new_version)
\"J. Bruce Fields\cf819392008-12-23 16:10:19 -0500767{
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700768 struct net *net = inode->i_sb->s_fs_info;
769 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500770 int ret = 0;
771
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500772 spin_lock(&pipe_version_lock);
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700773 if (sn->pipe_version < 0) {
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500774 /* First open of any gss pipe determines the version: */
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700775 sn->pipe_version = new_version;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500776 rpc_wake_up(&pipe_version_rpc_waitqueue);
777 wake_up(&pipe_version_waitqueue);
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700778 } else if (sn->pipe_version != new_version) {
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500779 /* Trying to open a pipe of a different version */
780 ret = -EBUSY;
781 goto out;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500782 }
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700783 atomic_inc(&sn->pipe_users);
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500784out:
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -0500785 spin_unlock(&pipe_version_lock);
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -0500786 return ret;
787
788}
789
790static int gss_pipe_open_v0(struct inode *inode)
791{
792 return gss_pipe_open(inode, 0);
793}
794
795static int gss_pipe_open_v1(struct inode *inode)
796{
797 return gss_pipe_open(inode, 1);
\"J. Bruce Fields\cf819392008-12-23 16:10:19 -0500798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800static void
801gss_pipe_release(struct inode *inode)
802{
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700803 struct net *net = inode->i_sb->s_fs_info;
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300804 struct rpc_pipe *pipe = RPC_I(inode)->pipe;
Trond Myklebust6e84c7b2007-06-07 15:31:36 -0400805 struct gss_upcall_msg *gss_msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Trond Myklebust5a676572010-09-12 19:55:25 -0400807restart:
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300808 spin_lock(&pipe->lock);
809 list_for_each_entry(gss_msg, &pipe->in_downcall, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Trond Myklebust5a676572010-09-12 19:55:25 -0400811 if (!list_empty(&gss_msg->msg.list))
812 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 gss_msg->msg.errno = -EPIPE;
814 atomic_inc(&gss_msg->count);
815 __gss_unhash_msg(gss_msg);
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300816 spin_unlock(&pipe->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 gss_release_msg(gss_msg);
Trond Myklebust5a676572010-09-12 19:55:25 -0400818 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 }
Stanislav Kinsbursky9beae462011-12-26 15:43:57 +0300820 spin_unlock(&pipe->lock);
\"J. Bruce Fields\cf819392008-12-23 16:10:19 -0500821
Trond Myklebust2aed8b42013-05-15 10:27:32 -0700822 put_pipe_version(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824
825static void
826gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
827{
828 struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 if (msg->errno < 0) {
Chuck Lever632f0d02012-09-14 17:23:43 -0400831 dprintk("RPC: %s releasing msg %p\n",
832 __func__, gss_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 atomic_inc(&gss_msg->count);
834 gss_unhash_msg(gss_msg);
\"J. Bruce Fields\b03568c2008-12-23 16:06:55 -0500835 if (msg->errno == -ETIMEDOUT)
836 warn_gssd();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 gss_release_msg(gss_msg);
838 }
839}
840
Trond Myklebust19172282013-08-26 16:44:42 -0400841static void gss_pipe_dentry_destroy(struct dentry *dir,
842 struct rpc_pipe_dir_object *pdo)
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400843{
Trond Myklebust19172282013-08-26 16:44:42 -0400844 struct gss_pipe *gss_pipe = pdo->pdo_data;
845 struct rpc_pipe *pipe = gss_pipe->pipe;
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400846
Trond Myklebust19172282013-08-26 16:44:42 -0400847 if (pipe->dentry != NULL) {
848 rpc_unlink(pipe->dentry);
849 pipe->dentry = NULL;
Trond Myklebust6b2fddd2013-08-26 16:05:11 -0400850 }
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400851}
852
Trond Myklebust19172282013-08-26 16:44:42 -0400853static int gss_pipe_dentry_create(struct dentry *dir,
854 struct rpc_pipe_dir_object *pdo)
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400855{
Trond Myklebust19172282013-08-26 16:44:42 -0400856 struct gss_pipe *p = pdo->pdo_data;
Trond Myklebust6b2fddd2013-08-26 16:05:11 -0400857 struct dentry *dentry;
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400858
Trond Myklebust19172282013-08-26 16:44:42 -0400859 dentry = rpc_mkpipe_dentry(dir, p->name, p->clnt, p->pipe);
860 if (IS_ERR(dentry))
861 return PTR_ERR(dentry);
862 p->pipe->dentry = dentry;
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400863 return 0;
Trond Myklebust19172282013-08-26 16:44:42 -0400864}
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400865
Trond Myklebust19172282013-08-26 16:44:42 -0400866static const struct rpc_pipe_dir_object_ops gss_pipe_dir_object_ops = {
867 .create = gss_pipe_dentry_create,
868 .destroy = gss_pipe_dentry_destroy,
869};
870
871static struct gss_pipe *gss_pipe_alloc(struct rpc_clnt *clnt,
872 const char *name,
873 const struct rpc_pipe_ops *upcall_ops)
874{
Trond Myklebust19172282013-08-26 16:44:42 -0400875 struct gss_pipe *p;
876 int err = -ENOMEM;
877
878 p = kmalloc(sizeof(*p), GFP_KERNEL);
879 if (p == NULL)
880 goto err;
881 p->pipe = rpc_mkpipe_data(upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
882 if (IS_ERR(p->pipe)) {
883 err = PTR_ERR(p->pipe);
884 goto err_free_gss_pipe;
885 }
886 p->name = name;
887 p->clnt = clnt;
Trond Myklebust414a6292013-08-27 16:52:16 -0400888 kref_init(&p->kref);
Trond Myklebust19172282013-08-26 16:44:42 -0400889 rpc_init_pipe_dir_object(&p->pdo,
890 &gss_pipe_dir_object_ops,
891 p);
Trond Myklebust414a6292013-08-27 16:52:16 -0400892 return p;
Trond Myklebust19172282013-08-26 16:44:42 -0400893err_free_gss_pipe:
894 kfree(p);
Trond Myklebust6b2fddd2013-08-26 16:05:11 -0400895err:
Trond Myklebust19172282013-08-26 16:44:42 -0400896 return ERR_PTR(err);
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400897}
898
Trond Myklebust414a6292013-08-27 16:52:16 -0400899struct gss_alloc_pdo {
900 struct rpc_clnt *clnt;
901 const char *name;
902 const struct rpc_pipe_ops *upcall_ops;
903};
904
905static int gss_pipe_match_pdo(struct rpc_pipe_dir_object *pdo, void *data)
906{
907 struct gss_pipe *gss_pipe;
908 struct gss_alloc_pdo *args = data;
909
910 if (pdo->pdo_ops != &gss_pipe_dir_object_ops)
911 return 0;
912 gss_pipe = container_of(pdo, struct gss_pipe, pdo);
913 if (strcmp(gss_pipe->name, args->name) != 0)
914 return 0;
915 if (!kref_get_unless_zero(&gss_pipe->kref))
916 return 0;
917 return 1;
918}
919
920static struct rpc_pipe_dir_object *gss_pipe_alloc_pdo(void *data)
921{
922 struct gss_pipe *gss_pipe;
923 struct gss_alloc_pdo *args = data;
924
925 gss_pipe = gss_pipe_alloc(args->clnt, args->name, args->upcall_ops);
926 if (!IS_ERR(gss_pipe))
927 return &gss_pipe->pdo;
928 return NULL;
929}
930
931static struct gss_pipe *gss_pipe_get(struct rpc_clnt *clnt,
932 const char *name,
933 const struct rpc_pipe_ops *upcall_ops)
934{
935 struct net *net = rpc_net_ns(clnt);
936 struct rpc_pipe_dir_object *pdo;
937 struct gss_alloc_pdo args = {
938 .clnt = clnt,
939 .name = name,
940 .upcall_ops = upcall_ops,
941 };
942
943 pdo = rpc_find_or_alloc_pipe_dir_object(net,
944 &clnt->cl_pipedir_objects,
945 gss_pipe_match_pdo,
946 gss_pipe_alloc_pdo,
947 &args);
948 if (pdo != NULL)
949 return container_of(pdo, struct gss_pipe, pdo);
950 return ERR_PTR(-ENOMEM);
951}
952
Trond Myklebust19172282013-08-26 16:44:42 -0400953static void __gss_pipe_free(struct gss_pipe *p)
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400954{
Trond Myklebust19172282013-08-26 16:44:42 -0400955 struct rpc_clnt *clnt = p->clnt;
956 struct net *net = rpc_net_ns(clnt);
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400957
Trond Myklebust19172282013-08-26 16:44:42 -0400958 rpc_remove_pipe_dir_object(net,
959 &clnt->cl_pipedir_objects,
960 &p->pdo);
961 rpc_destroy_pipe_data(p->pipe);
962 kfree(p);
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400963}
964
Trond Myklebust414a6292013-08-27 16:52:16 -0400965static void __gss_pipe_release(struct kref *kref)
966{
967 struct gss_pipe *p = container_of(kref, struct gss_pipe, kref);
968
969 __gss_pipe_free(p);
970}
971
Trond Myklebust19172282013-08-26 16:44:42 -0400972static void gss_pipe_free(struct gss_pipe *p)
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400973{
Trond Myklebust19172282013-08-26 16:44:42 -0400974 if (p != NULL)
Trond Myklebust414a6292013-08-27 16:52:16 -0400975 kref_put(&p->kref, __gss_pipe_release);
Stanislav Kinsburskyccdc28f2012-01-11 19:18:09 +0400976}
977
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800978/*
979 * NOTE: we have the opportunity to use different
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 * parameters based on the input flavor (which must be a pseudoflavor)
981 */
Trond Myklebusteb6dc192013-08-28 15:26:25 -0400982static struct gss_auth *
983gss_create_new(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Trond Myklebustc2190662013-08-26 19:23:04 -0400985 rpc_authflavor_t flavor = args->pseudoflavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 struct gss_auth *gss_auth;
Trond Myklebust19172282013-08-26 16:44:42 -0400987 struct gss_pipe *gss_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 struct rpc_auth * auth;
J. Bruce Fields6a192752005-06-22 17:16:23 +0000989 int err = -ENOMEM; /* XXX? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Chuck Lever8885cb32007-01-31 12:14:05 -0500991 dprintk("RPC: creating GSS authenticator for client %p\n", clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 if (!try_module_get(THIS_MODULE))
J. Bruce Fields6a192752005-06-22 17:16:23 +0000994 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
996 goto out_dec;
Trond Myklebusteb6dc192013-08-28 15:26:25 -0400997 INIT_HLIST_NODE(&gss_auth->hash);
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -0400998 gss_auth->target_name = NULL;
Trond Myklebustc2190662013-08-26 19:23:04 -0400999 if (args->target_name) {
1000 gss_auth->target_name = kstrdup(args->target_name, GFP_KERNEL);
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -04001001 if (gss_auth->target_name == NULL)
1002 goto err_free;
1003 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 gss_auth->client = clnt;
Trond Myklebuste726340a2013-08-23 14:42:29 -04001005 gss_auth->net = get_net(rpc_net_ns(clnt));
J. Bruce Fields6a192752005-06-22 17:16:23 +00001006 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);
1008 if (!gss_auth->mech) {
Trond Myklebust9b1d75b2013-05-01 09:17:50 -04001009 dprintk("RPC: Pseudoflavor %d not found!\n", flavor);
Trond Myklebuste726340a2013-08-23 14:42:29 -04001010 goto err_put_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
1012 gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);
J. Bruce Fields438b6fd2005-06-22 17:16:23 +00001013 if (gss_auth->service == 0)
1014 goto err_put_mech;
Trond Myklebusta699d652014-02-10 16:28:52 -05001015 if (!gssd_running(gss_auth->net))
1016 goto err_put_mech;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 auth = &gss_auth->rpc_auth;
1018 auth->au_cslack = GSS_CRED_SLACK >> 2;
1019 auth->au_rslack = GSS_VERF_SLACK >> 2;
Scott Mayhewce52914e2016-06-07 15:14:48 -04001020 auth->au_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 auth->au_ops = &authgss_ops;
1022 auth->au_flavor = flavor;
Chuck Lever65b80172016-06-29 13:55:06 -04001023 if (gss_pseudoflavor_to_datatouch(gss_auth->mech, flavor))
1024 auth->au_flags |= RPCAUTH_AUTH_DATATOUCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 atomic_set(&auth->au_count, 1);
Trond Myklebust0285ed12007-06-27 14:29:12 -04001026 kref_init(&gss_auth->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Trond Myklebust19172282013-08-26 16:44:42 -04001028 err = rpcauth_init_credcache(auth);
1029 if (err)
1030 goto err_put_mech;
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -05001031 /*
1032 * Note: if we created the old pipe first, then someone who
1033 * examined the directory at the right moment might conclude
1034 * that we supported only the old pipe. So we instead create
1035 * the new pipe first.
1036 */
Trond Myklebust414a6292013-08-27 16:52:16 -04001037 gss_pipe = gss_pipe_get(clnt, "gssd", &gss_upcall_ops_v1);
Trond Myklebust19172282013-08-26 16:44:42 -04001038 if (IS_ERR(gss_pipe)) {
1039 err = PTR_ERR(gss_pipe);
1040 goto err_destroy_credcache;
J. Bruce Fields6a192752005-06-22 17:16:23 +00001041 }
Trond Myklebust19172282013-08-26 16:44:42 -04001042 gss_auth->gss_pipe[1] = gss_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Trond Myklebust414a6292013-08-27 16:52:16 -04001044 gss_pipe = gss_pipe_get(clnt, gss_auth->mech->gm_name,
Trond Myklebust19172282013-08-26 16:44:42 -04001045 &gss_upcall_ops_v0);
1046 if (IS_ERR(gss_pipe)) {
1047 err = PTR_ERR(gss_pipe);
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +03001048 goto err_destroy_pipe_1;
1049 }
Trond Myklebust19172282013-08-26 16:44:42 -04001050 gss_auth->gss_pipe[0] = gss_pipe;
Trond Myklebust07a2bf12007-06-09 15:42:01 -04001051
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001052 return gss_auth;
Stanislav Kinsburskyc239d832011-12-26 15:44:06 +03001053err_destroy_pipe_1:
Trond Myklebust414a6292013-08-27 16:52:16 -04001054 gss_pipe_free(gss_auth->gss_pipe[1]);
Trond Myklebust19172282013-08-26 16:44:42 -04001055err_destroy_credcache:
1056 rpcauth_destroy_credcache(auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057err_put_mech:
1058 gss_mech_put(gss_auth->mech);
Trond Myklebuste726340a2013-08-23 14:42:29 -04001059err_put_net:
1060 put_net(gss_auth->net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061err_free:
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -04001062 kfree(gss_auth->target_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 kfree(gss_auth);
1064out_dec:
1065 module_put(THIS_MODULE);
J. Bruce Fields6a192752005-06-22 17:16:23 +00001066 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067}
1068
1069static void
Trond Myklebust0285ed12007-06-27 14:29:12 -04001070gss_free(struct gss_auth *gss_auth)
1071{
Trond Myklebust19172282013-08-26 16:44:42 -04001072 gss_pipe_free(gss_auth->gss_pipe[0]);
1073 gss_pipe_free(gss_auth->gss_pipe[1]);
Trond Myklebust0285ed12007-06-27 14:29:12 -04001074 gss_mech_put(gss_auth->mech);
Trond Myklebuste726340a2013-08-23 14:42:29 -04001075 put_net(gss_auth->net);
Trond Myklebustbd4a3eb2013-08-23 14:02:24 -04001076 kfree(gss_auth->target_name);
Trond Myklebust0285ed12007-06-27 14:29:12 -04001077
1078 kfree(gss_auth);
1079 module_put(THIS_MODULE);
1080}
1081
1082static void
1083gss_free_callback(struct kref *kref)
1084{
1085 struct gss_auth *gss_auth = container_of(kref, struct gss_auth, kref);
1086
1087 gss_free(gss_auth);
1088}
1089
1090static void
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -05001091gss_put_auth(struct gss_auth *gss_auth)
1092{
1093 kref_put(&gss_auth->kref, gss_free_callback);
1094}
1095
1096static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097gss_destroy(struct rpc_auth *auth)
1098{
Trond Myklebust19172282013-08-26 16:44:42 -04001099 struct gss_auth *gss_auth = container_of(auth,
1100 struct gss_auth, rpc_auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Chuck Lever8885cb32007-01-31 12:14:05 -05001102 dprintk("RPC: destroying GSS authenticator %p flavor %d\n",
1103 auth, auth->au_flavor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001105 if (hash_hashed(&gss_auth->hash)) {
1106 spin_lock(&gss_auth_hash_lock);
1107 hash_del(&gss_auth->hash);
1108 spin_unlock(&gss_auth_hash_lock);
1109 }
1110
Trond Myklebust19172282013-08-26 16:44:42 -04001111 gss_pipe_free(gss_auth->gss_pipe[0]);
1112 gss_auth->gss_pipe[0] = NULL;
1113 gss_pipe_free(gss_auth->gss_pipe[1]);
1114 gss_auth->gss_pipe[1] = NULL;
Trond Myklebust3ab9bb72007-06-09 15:41:42 -04001115 rpcauth_destroy_credcache(auth);
1116
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -05001117 gss_put_auth(gss_auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118}
1119
J. Bruce Fieldsa0f6ed82013-09-18 11:16:03 -04001120/*
1121 * Auths may be shared between rpc clients that were cloned from a
1122 * common client with the same xprt, if they also share the flavor and
1123 * target_name.
1124 *
1125 * The auth is looked up from the oldest parent sharing the same
1126 * cl_xprt, and the auth itself references only that common parent
1127 * (which is guaranteed to last as long as any of its descendants).
1128 */
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001129static struct gss_auth *
1130gss_auth_find_or_add_hashed(struct rpc_auth_create_args *args,
1131 struct rpc_clnt *clnt,
1132 struct gss_auth *new)
1133{
1134 struct gss_auth *gss_auth;
1135 unsigned long hashval = (unsigned long)clnt;
1136
1137 spin_lock(&gss_auth_hash_lock);
1138 hash_for_each_possible(gss_auth_hash_table,
1139 gss_auth,
1140 hash,
1141 hashval) {
J. Bruce Fieldsa0f6ed82013-09-18 11:16:03 -04001142 if (gss_auth->client != clnt)
1143 continue;
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001144 if (gss_auth->rpc_auth.au_flavor != args->pseudoflavor)
1145 continue;
1146 if (gss_auth->target_name != args->target_name) {
1147 if (gss_auth->target_name == NULL)
1148 continue;
1149 if (args->target_name == NULL)
1150 continue;
1151 if (strcmp(gss_auth->target_name, args->target_name))
1152 continue;
1153 }
1154 if (!atomic_inc_not_zero(&gss_auth->rpc_auth.au_count))
1155 continue;
1156 goto out;
1157 }
1158 if (new)
1159 hash_add(gss_auth_hash_table, &new->hash, hashval);
1160 gss_auth = new;
1161out:
1162 spin_unlock(&gss_auth_hash_lock);
1163 return gss_auth;
1164}
1165
1166static struct gss_auth *
1167gss_create_hashed(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
1168{
1169 struct gss_auth *gss_auth;
1170 struct gss_auth *new;
1171
1172 gss_auth = gss_auth_find_or_add_hashed(args, clnt, NULL);
1173 if (gss_auth != NULL)
1174 goto out;
1175 new = gss_create_new(args, clnt);
1176 if (IS_ERR(new))
1177 return new;
1178 gss_auth = gss_auth_find_or_add_hashed(args, clnt, new);
1179 if (gss_auth != new)
1180 gss_destroy(&new->rpc_auth);
1181out:
1182 return gss_auth;
1183}
1184
1185static struct rpc_auth *
1186gss_create(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
1187{
1188 struct gss_auth *gss_auth;
Trond Myklebustad01b2c2016-01-30 14:17:26 -05001189 struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch);
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001190
1191 while (clnt != clnt->cl_parent) {
1192 struct rpc_clnt *parent = clnt->cl_parent;
1193 /* Find the original parent for this transport */
Trond Myklebustad01b2c2016-01-30 14:17:26 -05001194 if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps)
Trond Myklebusteb6dc192013-08-28 15:26:25 -04001195 break;
1196 clnt = parent;
1197 }
1198
1199 gss_auth = gss_create_hashed(args, clnt);
1200 if (IS_ERR(gss_auth))
1201 return ERR_CAST(gss_auth);
1202 return &gss_auth->rpc_auth;
1203}
1204
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001205/*
1206 * gss_destroying_context will cause the RPCSEC_GSS to send a NULL RPC call
1207 * to the server with the GSS control procedure field set to
1208 * RPC_GSS_PROC_DESTROY. This should normally cause the server to release
1209 * all RPCSEC_GSS state associated with that context.
1210 */
1211static int
1212gss_destroying_context(struct rpc_cred *cred)
1213{
1214 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
1215 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001216 struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001217 struct rpc_task *task;
1218
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001219 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) == 0)
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001220 return 0;
1221
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001222 ctx->gc_proc = RPC_GSS_PROC_DESTROY;
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001223 cred->cr_ops = &gss_nullops;
1224
1225 /* Take a reference to ensure the cred will be destroyed either
1226 * by the RPC call or by the put_rpccred() below */
1227 get_rpccred(cred);
1228
Trond Myklebust080a1f12008-04-19 14:22:31 -04001229 task = rpc_call_null(gss_auth->client, cred, RPC_TASK_ASYNC|RPC_TASK_SOFT);
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001230 if (!IS_ERR(task))
1231 rpc_put_task(task);
1232
1233 put_rpccred(cred);
1234 return 1;
1235}
1236
1237/* gss_destroy_cred (and gss_free_ctx) are used to clean up after failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 * to create a new cred or context, so they check that things have been
1239 * allocated before freeing them. */
1240static void
Trond Myklebust5d28dc82007-06-26 19:18:38 -04001241gss_do_free_ctx(struct gss_cl_ctx *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
Chuck Lever632f0d02012-09-14 17:23:43 -04001243 dprintk("RPC: %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Trond Myklebust0d8a3742010-08-01 20:14:55 -04001245 gss_delete_sec_context(&ctx->gc_gss_ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 kfree(ctx->gc_wire_ctx.data);
Jeff Layton2004c722014-06-21 20:52:15 -04001247 kfree(ctx->gc_acceptor.data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 kfree(ctx);
1249}
1250
1251static void
Trond Myklebust5d28dc82007-06-26 19:18:38 -04001252gss_free_ctx_callback(struct rcu_head *head)
1253{
1254 struct gss_cl_ctx *ctx = container_of(head, struct gss_cl_ctx, gc_rcu);
1255 gss_do_free_ctx(ctx);
1256}
1257
1258static void
1259gss_free_ctx(struct gss_cl_ctx *ctx)
1260{
1261 call_rcu(&ctx->gc_rcu, gss_free_ctx_callback);
1262}
1263
1264static void
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001265gss_free_cred(struct gss_cred *gss_cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266{
Chuck Lever632f0d02012-09-14 17:23:43 -04001267 dprintk("RPC: %s cred=%p\n", __func__, gss_cred);
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001268 kfree(gss_cred);
1269}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001271static void
1272gss_free_cred_callback(struct rcu_head *head)
1273{
1274 struct gss_cred *gss_cred = container_of(head, struct gss_cred, gc_base.cr_rcu);
1275 gss_free_cred(gss_cred);
1276}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001278static void
Jeff Layton6dcd3922008-12-23 15:21:57 -05001279gss_destroy_nullcred(struct rpc_cred *cred)
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001280{
Trond Myklebust5d28dc82007-06-26 19:18:38 -04001281 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
Trond Myklebust0285ed12007-06-27 14:29:12 -04001282 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001283 struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);
Trond Myklebust5d28dc82007-06-26 19:18:38 -04001284
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001285 RCU_INIT_POINTER(gss_cred->gc_ctx, NULL);
Trond Myklebust31be5bf2007-06-24 15:55:26 -04001286 call_rcu(&cred->cr_rcu, gss_free_cred_callback);
Trond Myklebust5d28dc82007-06-26 19:18:38 -04001287 if (ctx)
1288 gss_put_ctx(ctx);
Trond Myklebust9eb2ddb2014-02-16 12:14:13 -05001289 gss_put_auth(gss_auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290}
1291
Jeff Layton6dcd3922008-12-23 15:21:57 -05001292static void
1293gss_destroy_cred(struct rpc_cred *cred)
1294{
1295
1296 if (gss_destroying_context(cred))
1297 return;
1298 gss_destroy_nullcred(cred);
1299}
1300
Frank Sorensona960f8d2016-09-29 10:44:40 -05001301static int
1302gss_hash_cred(struct auth_cred *acred, unsigned int hashbits)
1303{
1304 return hash_64(from_kuid(&init_user_ns, acred->uid), hashbits);
1305}
1306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307/*
1308 * Lookup RPCSEC_GSS cred for the current process
1309 */
1310static struct rpc_cred *
Trond Myklebust8a317762006-02-01 12:18:36 -05001311gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312{
Jeff Layton3c6e0bc2016-04-21 20:51:54 -04001313 return rpcauth_lookup_credcache(auth, acred, flags, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
1315
1316static struct rpc_cred *
Jeff Layton3c6e0bc2016-04-21 20:51:54 -04001317gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
1319 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
1320 struct gss_cred *cred = NULL;
1321 int err = -ENOMEM;
1322
Chuck Lever632f0d02012-09-14 17:23:43 -04001323 dprintk("RPC: %s for uid %d, flavor %d\n",
Eric W. Biedermancdba3212013-02-01 17:10:52 -08001324 __func__, from_kuid(&init_user_ns, acred->uid),
1325 auth->au_flavor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Jeff Layton3c6e0bc2016-04-21 20:51:54 -04001327 if (!(cred = kzalloc(sizeof(*cred), gfp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 goto out_err;
1329
Trond Myklebust5fe47552007-06-23 19:55:31 -04001330 rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 /*
1332 * Note: in order to force a call to call_refresh(), we deliberately
1333 * fail to flag the credential as RPCAUTH_CRED_UPTODATE.
1334 */
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001335 cred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_NEW;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 cred->gc_service = gss_auth->service;
Trond Myklebust68c97152012-01-03 13:22:46 -05001337 cred->gc_principal = NULL;
1338 if (acred->machine_cred)
1339 cred->gc_principal = acred->principal;
Trond Myklebust0285ed12007-06-27 14:29:12 -04001340 kref_get(&gss_auth->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 return &cred->gc_base;
1342
1343out_err:
Chuck Lever632f0d02012-09-14 17:23:43 -04001344 dprintk("RPC: %s failed with error %d\n", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 return ERR_PTR(err);
1346}
1347
1348static int
Trond Myklebustfba3bad2006-02-01 12:19:27 -05001349gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred)
1350{
1351 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
1352 struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base);
1353 int err;
1354
1355 do {
1356 err = gss_create_upcall(gss_auth, gss_cred);
1357 } while (err == -EAGAIN);
1358 return err;
1359}
1360
Jeff Laytona0337d12014-06-21 20:52:16 -04001361static char *
1362gss_stringify_acceptor(struct rpc_cred *cred)
1363{
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001364 char *string = NULL;
Jeff Laytona0337d12014-06-21 20:52:16 -04001365 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001366 struct gss_cl_ctx *ctx;
Jeff Laytonb3ecba02014-11-13 07:30:46 -05001367 unsigned int len;
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001368 struct xdr_netobj *acceptor;
1369
1370 rcu_read_lock();
1371 ctx = rcu_dereference(gss_cred->gc_ctx);
1372 if (!ctx)
1373 goto out;
1374
Jeff Laytonb3ecba02014-11-13 07:30:46 -05001375 len = ctx->gc_acceptor.len;
1376 rcu_read_unlock();
Jeff Laytona0337d12014-06-21 20:52:16 -04001377
1378 /* no point if there's no string */
Jeff Laytonb3ecba02014-11-13 07:30:46 -05001379 if (!len)
1380 return NULL;
1381realloc:
1382 string = kmalloc(len + 1, GFP_KERNEL);
Jeff Laytona0337d12014-06-21 20:52:16 -04001383 if (!string)
Jeff Laytonb3ecba02014-11-13 07:30:46 -05001384 return NULL;
1385
1386 rcu_read_lock();
1387 ctx = rcu_dereference(gss_cred->gc_ctx);
1388
1389 /* did the ctx disappear or was it replaced by one with no acceptor? */
1390 if (!ctx || !ctx->gc_acceptor.len) {
1391 kfree(string);
1392 string = NULL;
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001393 goto out;
Jeff Laytonb3ecba02014-11-13 07:30:46 -05001394 }
1395
1396 acceptor = &ctx->gc_acceptor;
1397
1398 /*
1399 * Did we find a new acceptor that's longer than the original? Allocate
1400 * a longer buffer and try again.
1401 */
1402 if (len < acceptor->len) {
1403 len = acceptor->len;
1404 rcu_read_unlock();
1405 kfree(string);
1406 goto realloc;
1407 }
Jeff Laytona0337d12014-06-21 20:52:16 -04001408
1409 memcpy(string, acceptor->data, acceptor->len);
1410 string[acceptor->len] = '\0';
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001411out:
1412 rcu_read_unlock();
Jeff Laytona0337d12014-06-21 20:52:16 -04001413 return string;
1414}
1415
Andy Adamson4de6caa2013-08-14 11:59:15 -04001416/*
1417 * Returns -EACCES if GSS context is NULL or will expire within the
1418 * timeout (miliseconds)
1419 */
1420static int
1421gss_key_timeout(struct rpc_cred *rc)
1422{
1423 struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001424 struct gss_cl_ctx *ctx;
Arnd Bergmanncc6a7aa2015-10-09 16:13:45 +02001425 unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ);
1426 int ret = 0;
Andy Adamson4de6caa2013-08-14 11:59:15 -04001427
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001428 rcu_read_lock();
1429 ctx = rcu_dereference(gss_cred->gc_ctx);
Arnd Bergmanncc6a7aa2015-10-09 16:13:45 +02001430 if (!ctx || time_after(timeout, ctx->gc_expiry))
1431 ret = -EACCES;
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001432 rcu_read_unlock();
Arnd Bergmanncc6a7aa2015-10-09 16:13:45 +02001433
1434 return ret;
Andy Adamson4de6caa2013-08-14 11:59:15 -04001435}
1436
Trond Myklebustfba3bad2006-02-01 12:19:27 -05001437static int
Trond Myklebust8a317762006-02-01 12:18:36 -05001438gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439{
1440 struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001441 struct gss_cl_ctx *ctx;
Andy Adamson4de6caa2013-08-14 11:59:15 -04001442 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
Trond Myklebustcd019f72008-04-17 17:03:58 -04001444 if (test_bit(RPCAUTH_CRED_NEW, &rc->cr_flags))
Trond Myklebust8a317762006-02-01 12:18:36 -05001445 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 /* Don't match with creds that have expired. */
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001447 rcu_read_lock();
1448 ctx = rcu_dereference(gss_cred->gc_ctx);
1449 if (!ctx || time_after(jiffies, ctx->gc_expiry)) {
1450 rcu_read_unlock();
Trond Myklebustcd019f72008-04-17 17:03:58 -04001451 return 0;
Jeff Laytonc5e6aec2014-07-16 06:52:19 -04001452 }
1453 rcu_read_unlock();
Trond Myklebustcd019f72008-04-17 17:03:58 -04001454 if (!test_bit(RPCAUTH_CRED_UPTODATE, &rc->cr_flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 return 0;
Trond Myklebust8a317762006-02-01 12:18:36 -05001456out:
Trond Myklebust68c97152012-01-03 13:22:46 -05001457 if (acred->principal != NULL) {
1458 if (gss_cred->gc_principal == NULL)
1459 return 0;
Andy Adamson4de6caa2013-08-14 11:59:15 -04001460 ret = strcmp(acred->principal, gss_cred->gc_principal) == 0;
1461 goto check_expire;
Trond Myklebust68c97152012-01-03 13:22:46 -05001462 }
1463 if (gss_cred->gc_principal != NULL)
Trond Myklebust7c67db32008-04-07 20:50:11 -04001464 return 0;
Andy Adamson4de6caa2013-08-14 11:59:15 -04001465 ret = uid_eq(rc->cr_uid, acred->uid);
1466
1467check_expire:
1468 if (ret == 0)
1469 return ret;
1470
1471 /* Notify acred users of GSS context expiration timeout */
1472 if (test_bit(RPC_CRED_NOTIFY_TIMEOUT, &acred->ac_flags) &&
1473 (gss_key_timeout(rc) != 0)) {
1474 /* test will now be done from generic cred */
1475 test_and_clear_bit(RPC_CRED_NOTIFY_TIMEOUT, &acred->ac_flags);
1476 /* tell NFS layer that key will expire soon */
1477 set_bit(RPC_CRED_KEY_EXPIRE_SOON, &acred->ac_flags);
1478 }
1479 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480}
1481
1482/*
1483* Marshal credentials.
1484* Maybe we should keep a cached credential for performance reasons.
1485*/
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001486static __be32 *
1487gss_marshal(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001489 struct rpc_rqst *req = task->tk_rqstp;
1490 struct rpc_cred *cred = req->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1492 gc_base);
1493 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001494 __be32 *cred_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 u32 maj_stat = 0;
1496 struct xdr_netobj mic;
1497 struct kvec iov;
1498 struct xdr_buf verf_buf;
1499
Chuck Lever632f0d02012-09-14 17:23:43 -04001500 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502 *p++ = htonl(RPC_AUTH_GSS);
1503 cred_len = p++;
1504
1505 spin_lock(&ctx->gc_seq_lock);
1506 req->rq_seqno = ctx->gc_seq++;
1507 spin_unlock(&ctx->gc_seq_lock);
1508
1509 *p++ = htonl((u32) RPC_GSS_VERSION);
1510 *p++ = htonl((u32) ctx->gc_proc);
1511 *p++ = htonl((u32) req->rq_seqno);
1512 *p++ = htonl((u32) gss_cred->gc_service);
1513 p = xdr_encode_netobj(p, &ctx->gc_wire_ctx);
1514 *cred_len = htonl((p - (cred_len + 1)) << 2);
1515
1516 /* We compute the checksum for the verifier over the xdr-encoded bytes
1517 * starting with the xid and ending at the end of the credential: */
Trond Myklebusta4f08352013-01-08 09:10:21 -05001518 iov.iov_base = xprt_skip_transport_header(req->rq_xprt,
Chuck Lever808012f2005-08-25 16:25:49 -07001519 req->rq_snd_buf.head[0].iov_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 iov.iov_len = (u8 *)p - (u8 *)iov.iov_base;
1521 xdr_buf_from_iov(&iov, &verf_buf);
1522
1523 /* set verifier flavor*/
1524 *p++ = htonl(RPC_AUTH_GSS);
1525
1526 mic.data = (u8 *)(p + 1);
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001527 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001529 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 } else if (maj_stat != 0) {
1531 printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);
1532 goto out_put_ctx;
1533 }
1534 p = xdr_encode_opaque(p, NULL, mic.len);
1535 gss_put_ctx(ctx);
1536 return p;
1537out_put_ctx:
1538 gss_put_ctx(ctx);
1539 return NULL;
1540}
1541
Trond Myklebustcd019f72008-04-17 17:03:58 -04001542static int gss_renew_cred(struct rpc_task *task)
1543{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001544 struct rpc_cred *oldcred = task->tk_rqstp->rq_cred;
Trond Myklebustcd019f72008-04-17 17:03:58 -04001545 struct gss_cred *gss_cred = container_of(oldcred,
1546 struct gss_cred,
1547 gc_base);
1548 struct rpc_auth *auth = oldcred->cr_auth;
1549 struct auth_cred acred = {
1550 .uid = oldcred->cr_uid,
Trond Myklebust68c97152012-01-03 13:22:46 -05001551 .principal = gss_cred->gc_principal,
1552 .machine_cred = (gss_cred->gc_principal != NULL ? 1 : 0),
Trond Myklebustcd019f72008-04-17 17:03:58 -04001553 };
1554 struct rpc_cred *new;
1555
1556 new = gss_lookup_cred(auth, &acred, RPCAUTH_LOOKUP_NEW);
1557 if (IS_ERR(new))
1558 return PTR_ERR(new);
Trond Myklebusta17c2152010-07-31 14:29:08 -04001559 task->tk_rqstp->rq_cred = new;
Trond Myklebustcd019f72008-04-17 17:03:58 -04001560 put_rpccred(oldcred);
1561 return 0;
1562}
1563
Trond Myklebust126e2162010-05-13 12:55:38 -04001564static int gss_cred_is_negative_entry(struct rpc_cred *cred)
1565{
1566 if (test_bit(RPCAUTH_CRED_NEGATIVE, &cred->cr_flags)) {
1567 unsigned long now = jiffies;
1568 unsigned long begin, expire;
1569 struct gss_cred *gss_cred;
1570
1571 gss_cred = container_of(cred, struct gss_cred, gc_base);
1572 begin = gss_cred->gc_upcall_timestamp;
1573 expire = begin + gss_expired_cred_retry_delay * HZ;
1574
1575 if (time_in_range_open(now, begin, expire))
1576 return 1;
1577 }
1578 return 0;
1579}
1580
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581/*
1582* Refresh credentials. XXX - finish
1583*/
1584static int
1585gss_refresh(struct rpc_task *task)
1586{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001587 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustcd019f72008-04-17 17:03:58 -04001588 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Trond Myklebust126e2162010-05-13 12:55:38 -04001590 if (gss_cred_is_negative_entry(cred))
1591 return -EKEYEXPIRED;
1592
Trond Myklebustcd019f72008-04-17 17:03:58 -04001593 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
1594 !test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags)) {
1595 ret = gss_renew_cred(task);
1596 if (ret < 0)
1597 goto out;
Trond Myklebusta17c2152010-07-31 14:29:08 -04001598 cred = task->tk_rqstp->rq_cred;
Trond Myklebustcd019f72008-04-17 17:03:58 -04001599 }
1600
1601 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
1602 ret = gss_refresh_upcall(task);
1603out:
1604 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605}
1606
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001607/* Dummy refresh routine: used only when destroying the context */
1608static int
1609gss_refresh_null(struct rpc_task *task)
1610{
Andy Adamsonc297c8b2013-11-20 13:00:17 -05001611 return 0;
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001612}
1613
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001614static __be32 *
1615gss_validate(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001617 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
J. Bruce Fields2876a342016-10-18 16:30:09 -04001619 __be32 *seq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 struct kvec iov;
1621 struct xdr_buf verf_buf;
1622 struct xdr_netobj mic;
1623 u32 flav,len;
1624 u32 maj_stat;
Andy Adamson35fa5f72013-08-14 11:59:17 -04001625 __be32 *ret = ERR_PTR(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Chuck Lever632f0d02012-09-14 17:23:43 -04001627 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
1629 flav = ntohl(*p++);
1630 if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001631 goto out_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 if (flav != RPC_AUTH_GSS)
1633 goto out_bad;
J. Bruce Fields2876a342016-10-18 16:30:09 -04001634 seq = kmalloc(4, GFP_NOFS);
1635 if (!seq)
1636 goto out_bad;
1637 *seq = htonl(task->tk_rqstp->rq_seqno);
1638 iov.iov_base = seq;
1639 iov.iov_len = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 xdr_buf_from_iov(&iov, &verf_buf);
1641 mic.data = (u8 *)p;
1642 mic.len = len;
1643
Andy Adamson35fa5f72013-08-14 11:59:17 -04001644 ret = ERR_PTR(-EACCES);
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001645 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001647 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001648 if (maj_stat) {
Chuck Lever632f0d02012-09-14 17:23:43 -04001649 dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n",
1650 task->tk_pid, __func__, maj_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto out_bad;
Trond Myklebust0df7fb72007-06-26 17:04:57 -04001652 }
J. Bruce Fields24b26052005-10-13 16:54:53 -04001653 /* We leave it to unwrap to calculate au_rslack. For now we just
1654 * calculate the length of the verifier: */
Trond Myklebust1be27f32007-06-27 14:29:04 -04001655 cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 gss_put_ctx(ctx);
Chuck Lever632f0d02012-09-14 17:23:43 -04001657 dprintk("RPC: %5u %s: gss_verify_mic succeeded.\n",
1658 task->tk_pid, __func__);
J. Bruce Fields2876a342016-10-18 16:30:09 -04001659 kfree(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 return p + XDR_QUADLEN(len);
1661out_bad:
1662 gss_put_ctx(ctx);
Andy Adamson35fa5f72013-08-14 11:59:17 -04001663 dprintk("RPC: %5u %s failed ret %ld.\n", task->tk_pid, __func__,
1664 PTR_ERR(ret));
J. Bruce Fields2876a342016-10-18 16:30:09 -04001665 kfree(seq);
Andy Adamson35fa5f72013-08-14 11:59:17 -04001666 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667}
1668
Chuck Lever9f06c712010-12-14 14:59:18 +00001669static void gss_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
1670 __be32 *p, void *obj)
1671{
1672 struct xdr_stream xdr;
1673
1674 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, p);
1675 encode(rqstp, &xdr, obj);
1676}
1677
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678static inline int
1679gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
Chuck Lever9f06c712010-12-14 14:59:18 +00001680 kxdreproc_t encode, struct rpc_rqst *rqstp,
1681 __be32 *p, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1684 struct xdr_buf integ_buf;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001685 __be32 *integ_len = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 struct xdr_netobj mic;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001687 u32 offset;
1688 __be32 *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 struct kvec *iov;
1690 u32 maj_stat = 0;
1691 int status = -EIO;
1692
1693 integ_len = p++;
1694 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1695 *p++ = htonl(rqstp->rq_seqno);
1696
Chuck Lever9f06c712010-12-14 14:59:18 +00001697 gss_wrap_req_encode(encode, rqstp, p, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698
1699 if (xdr_buf_subsegment(snd_buf, &integ_buf,
1700 offset, snd_buf->len - offset))
1701 return status;
1702 *integ_len = htonl(integ_buf.len);
1703
1704 /* guess whether we're in the head or the tail: */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001705 if (snd_buf->page_len || snd_buf->tail[0].iov_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 iov = snd_buf->tail;
1707 else
1708 iov = snd_buf->head;
1709 p = iov->iov_base + iov->iov_len;
1710 mic.data = (u8 *)(p + 1);
1711
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001712 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 status = -EIO; /* XXX? */
1714 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001715 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 else if (maj_stat)
1717 return status;
1718 q = xdr_encode_opaque(p, NULL, mic.len);
1719
1720 offset = (u8 *)q - (u8 *)p;
1721 iov->iov_len += offset;
1722 snd_buf->len += offset;
1723 return 0;
1724}
1725
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001726static void
1727priv_release_snd_buf(struct rpc_rqst *rqstp)
1728{
1729 int i;
1730
1731 for (i=0; i < rqstp->rq_enc_pages_num; i++)
1732 __free_page(rqstp->rq_enc_pages[i]);
1733 kfree(rqstp->rq_enc_pages);
1734}
1735
1736static int
1737alloc_enc_pages(struct rpc_rqst *rqstp)
1738{
1739 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1740 int first, last, i;
1741
1742 if (snd_buf->page_len == 0) {
1743 rqstp->rq_enc_pages_num = 0;
1744 return 0;
1745 }
1746
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001747 first = snd_buf->page_base >> PAGE_SHIFT;
1748 last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT;
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001749 rqstp->rq_enc_pages_num = last - first + 1 + 1;
1750 rqstp->rq_enc_pages
1751 = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *),
1752 GFP_NOFS);
1753 if (!rqstp->rq_enc_pages)
1754 goto out;
1755 for (i=0; i < rqstp->rq_enc_pages_num; i++) {
1756 rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS);
1757 if (rqstp->rq_enc_pages[i] == NULL)
1758 goto out_free;
1759 }
1760 rqstp->rq_release_snd_buf = priv_release_snd_buf;
1761 return 0;
1762out_free:
Trond Myklebustcdead7c2010-03-19 15:36:22 -04001763 rqstp->rq_enc_pages_num = i;
1764 priv_release_snd_buf(rqstp);
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001765out:
1766 return -EAGAIN;
1767}
1768
1769static inline int
1770gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
Chuck Lever9f06c712010-12-14 14:59:18 +00001771 kxdreproc_t encode, struct rpc_rqst *rqstp,
1772 __be32 *p, void *obj)
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001773{
1774 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1775 u32 offset;
1776 u32 maj_stat;
1777 int status;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001778 __be32 *opaque_len;
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001779 struct page **inpages;
1780 int first;
1781 int pad;
1782 struct kvec *iov;
1783 char *tmp;
1784
1785 opaque_len = p++;
1786 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1787 *p++ = htonl(rqstp->rq_seqno);
1788
Chuck Lever9f06c712010-12-14 14:59:18 +00001789 gss_wrap_req_encode(encode, rqstp, p, obj);
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001790
1791 status = alloc_enc_pages(rqstp);
1792 if (status)
1793 return status;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001794 first = snd_buf->page_base >> PAGE_SHIFT;
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001795 inpages = snd_buf->pages + first;
1796 snd_buf->pages = rqstp->rq_enc_pages;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001797 snd_buf->page_base -= first << PAGE_SHIFT;
Kevin Coffman75610422010-03-17 13:02:47 -04001798 /*
1799 * Give the tail its own page, in case we need extra space in the
1800 * head when wrapping:
1801 *
1802 * call_allocate() allocates twice the slack space required
1803 * by the authentication flavor to rq_callsize.
1804 * For GSS, slack is GSS_CRED_SLACK.
1805 */
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001806 if (snd_buf->page_len || snd_buf->tail[0].iov_len) {
1807 tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]);
1808 memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len);
1809 snd_buf->tail[0].iov_base = tmp;
1810 }
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001811 maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages);
Kevin Coffman75610422010-03-17 13:02:47 -04001812 /* slack space should prevent this ever happening: */
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001813 BUG_ON(snd_buf->len > snd_buf->buflen);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001814 status = -EIO;
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001815 /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was
1816 * done anyway, so it's safe to put the request on the wire: */
1817 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001818 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001819 else if (maj_stat)
1820 return status;
1821
1822 *opaque_len = htonl(snd_buf->len - offset);
1823 /* guess whether we're in the head or the tail: */
1824 if (snd_buf->page_len || snd_buf->tail[0].iov_len)
1825 iov = snd_buf->tail;
1826 else
1827 iov = snd_buf->head;
1828 p = iov->iov_base + iov->iov_len;
1829 pad = 3 - ((snd_buf->len - offset - 1) & 3);
1830 memset(p, 0, pad);
1831 iov->iov_len += pad;
1832 snd_buf->len += pad;
1833
1834 return 0;
1835}
1836
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837static int
1838gss_wrap_req(struct rpc_task *task,
Chuck Lever9f06c712010-12-14 14:59:18 +00001839 kxdreproc_t encode, void *rqstp, __be32 *p, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001841 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1843 gc_base);
1844 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1845 int status = -EIO;
1846
Chuck Lever632f0d02012-09-14 17:23:43 -04001847 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
1849 /* The spec seems a little ambiguous here, but I think that not
1850 * wrapping context destruction requests makes the most sense.
1851 */
Chuck Lever9f06c712010-12-14 14:59:18 +00001852 gss_wrap_req_encode(encode, rqstp, p, obj);
1853 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 goto out;
1855 }
1856 switch (gss_cred->gc_service) {
Joe Perches89f0e4f2011-07-01 09:43:12 +00001857 case RPC_GSS_SVC_NONE:
1858 gss_wrap_req_encode(encode, rqstp, p, obj);
1859 status = 0;
1860 break;
1861 case RPC_GSS_SVC_INTEGRITY:
1862 status = gss_wrap_req_integ(cred, ctx, encode, rqstp, p, obj);
1863 break;
1864 case RPC_GSS_SVC_PRIVACY:
1865 status = gss_wrap_req_priv(cred, ctx, encode, rqstp, p, obj);
1866 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 }
1868out:
1869 gss_put_ctx(ctx);
Chuck Lever632f0d02012-09-14 17:23:43 -04001870 dprintk("RPC: %5u %s returning %d\n", task->tk_pid, __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 return status;
1872}
1873
1874static inline int
1875gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001876 struct rpc_rqst *rqstp, __be32 **p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
1878 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1879 struct xdr_buf integ_buf;
1880 struct xdr_netobj mic;
1881 u32 data_offset, mic_offset;
1882 u32 integ_len;
1883 u32 maj_stat;
1884 int status = -EIO;
1885
1886 integ_len = ntohl(*(*p)++);
1887 if (integ_len & 3)
1888 return status;
1889 data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1890 mic_offset = integ_len + data_offset;
1891 if (mic_offset > rcv_buf->len)
1892 return status;
1893 if (ntohl(*(*p)++) != rqstp->rq_seqno)
1894 return status;
1895
1896 if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset,
1897 mic_offset - data_offset))
1898 return status;
1899
1900 if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset))
1901 return status;
1902
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001903 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001905 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 if (maj_stat != GSS_S_COMPLETE)
1907 return status;
1908 return 0;
1909}
1910
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001911static inline int
1912gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001913 struct rpc_rqst *rqstp, __be32 **p)
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001914{
1915 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1916 u32 offset;
1917 u32 opaque_len;
1918 u32 maj_stat;
1919 int status = -EIO;
1920
1921 opaque_len = ntohl(*(*p)++);
1922 offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1923 if (offset + opaque_len > rcv_buf->len)
1924 return status;
1925 /* remove padding: */
1926 rcv_buf->len = offset + opaque_len;
1927
J. Bruce Fields00fd6e12005-10-13 16:55:18 -04001928 maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001929 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
Trond Myklebustfc432dd2007-06-25 10:15:15 -04001930 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001931 if (maj_stat != GSS_S_COMPLETE)
1932 return status;
1933 if (ntohl(*(*p)++) != rqstp->rq_seqno)
1934 return status;
1935
1936 return 0;
1937}
1938
Chuck Leverbf269552010-12-14 14:59:29 +00001939static int
1940gss_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
1941 __be32 *p, void *obj)
1942{
1943 struct xdr_stream xdr;
1944
1945 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
1946 return decode(rqstp, &xdr, obj);
1947}
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001948
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949static int
1950gss_unwrap_resp(struct rpc_task *task,
Chuck Leverbf269552010-12-14 14:59:29 +00001951 kxdrdproc_t decode, void *rqstp, __be32 *p, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952{
Trond Myklebusta17c2152010-07-31 14:29:08 -04001953 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1955 gc_base);
1956 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001957 __be32 *savedp = p;
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001958 struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;
1959 int savedlen = head->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 int status = -EIO;
1961
1962 if (ctx->gc_proc != RPC_GSS_PROC_DATA)
1963 goto out_decode;
1964 switch (gss_cred->gc_service) {
Joe Perches89f0e4f2011-07-01 09:43:12 +00001965 case RPC_GSS_SVC_NONE:
1966 break;
1967 case RPC_GSS_SVC_INTEGRITY:
1968 status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p);
1969 if (status)
1970 goto out;
1971 break;
1972 case RPC_GSS_SVC_PRIVACY:
1973 status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p);
1974 if (status)
1975 goto out;
1976 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 }
J. Bruce Fields24b26052005-10-13 16:54:53 -04001978 /* take into account extra slack for integrity and privacy cases: */
Trond Myklebust1be27f32007-06-27 14:29:04 -04001979 cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp)
J. Bruce Fields2d2da60c2005-10-13 16:54:58 -04001980 + (savedlen - head->iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981out_decode:
Chuck Leverbf269552010-12-14 14:59:29 +00001982 status = gss_unwrap_req_decode(decode, rqstp, p, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983out:
1984 gss_put_ctx(ctx);
Chuck Lever632f0d02012-09-14 17:23:43 -04001985 dprintk("RPC: %5u %s returning %d\n",
1986 task->tk_pid, __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 return status;
1988}
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001989
Trond Myklebustf1c0a862007-06-23 20:17:58 -04001990static const struct rpc_authops authgss_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 .owner = THIS_MODULE,
1992 .au_flavor = RPC_AUTH_GSS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 .au_name = "RPCSEC_GSS",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 .create = gss_create,
1995 .destroy = gss_destroy,
Frank Sorensona960f8d2016-09-29 10:44:40 -05001996 .hash_cred = gss_hash_cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 .lookup_cred = gss_lookup_cred,
Stanislav Kinsbursky80df9d22012-01-11 19:18:17 +04001998 .crcreate = gss_create_cred,
Chuck Lever6a1a1e32012-07-11 16:31:08 -04001999 .list_pseudoflavors = gss_mech_list_pseudoflavors,
Chuck Lever9568c5e2013-03-16 15:54:43 -04002000 .info2flavor = gss_mech_info2flavor,
Chuck Levera77c8062013-03-16 15:55:10 -04002001 .flavor2info = gss_mech_flavor2info,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002};
2003
Trond Myklebustf1c0a862007-06-23 20:17:58 -04002004static const struct rpc_credops gss_credops = {
Jeff Laytona0337d12014-06-21 20:52:16 -04002005 .cr_name = "AUTH_GSS",
2006 .crdestroy = gss_destroy_cred,
2007 .cr_init = gss_cred_init,
2008 .crbind = rpcauth_generic_bind_cred,
2009 .crmatch = gss_match,
2010 .crmarshal = gss_marshal,
2011 .crrefresh = gss_refresh,
2012 .crvalidate = gss_validate,
2013 .crwrap_req = gss_wrap_req,
2014 .crunwrap_resp = gss_unwrap_resp,
2015 .crkey_timeout = gss_key_timeout,
2016 .crstringify_acceptor = gss_stringify_acceptor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017};
2018
Trond Myklebust0df7fb72007-06-26 17:04:57 -04002019static const struct rpc_credops gss_nullops = {
Jeff Laytona0337d12014-06-21 20:52:16 -04002020 .cr_name = "AUTH_GSS",
2021 .crdestroy = gss_destroy_nullcred,
2022 .crbind = rpcauth_generic_bind_cred,
2023 .crmatch = gss_match,
2024 .crmarshal = gss_marshal,
2025 .crrefresh = gss_refresh_null,
2026 .crvalidate = gss_validate,
2027 .crwrap_req = gss_wrap_req,
2028 .crunwrap_resp = gss_unwrap_resp,
2029 .crstringify_acceptor = gss_stringify_acceptor,
Trond Myklebust0df7fb72007-06-26 17:04:57 -04002030};
2031
Trond Myklebustb693ba42009-08-09 15:14:15 -04002032static const struct rpc_pipe_ops gss_upcall_ops_v0 = {
Peng Taoc1225152011-09-22 21:50:10 -04002033 .upcall = rpc_pipe_generic_upcall,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 .downcall = gss_pipe_downcall,
2035 .destroy_msg = gss_pipe_destroy_msg,
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -05002036 .open_pipe = gss_pipe_open_v0,
2037 .release_pipe = gss_pipe_release,
2038};
2039
Trond Myklebustb693ba42009-08-09 15:14:15 -04002040static const struct rpc_pipe_ops gss_upcall_ops_v1 = {
Peng Taoc1225152011-09-22 21:50:10 -04002041 .upcall = rpc_pipe_generic_upcall,
\"J. Bruce Fields\34769fc2008-12-23 16:16:37 -05002042 .downcall = gss_pipe_downcall,
2043 .destroy_msg = gss_pipe_destroy_msg,
2044 .open_pipe = gss_pipe_open_v1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 .release_pipe = gss_pipe_release,
2046};
2047
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04002048static __net_init int rpcsec_gss_init_net(struct net *net)
2049{
2050 return gss_svc_init_net(net);
2051}
2052
2053static __net_exit void rpcsec_gss_exit_net(struct net *net)
2054{
2055 gss_svc_shutdown_net(net);
2056}
2057
2058static struct pernet_operations rpcsec_gss_net_ops = {
2059 .init = rpcsec_gss_init_net,
2060 .exit = rpcsec_gss_exit_net,
2061};
2062
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063/*
2064 * Initialize RPCSEC_GSS module
2065 */
2066static int __init init_rpcsec_gss(void)
2067{
2068 int err = 0;
2069
2070 err = rpcauth_register(&authgss_ops);
2071 if (err)
2072 goto out;
2073 err = gss_svc_init();
2074 if (err)
2075 goto out_unregister;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04002076 err = register_pernet_subsys(&rpcsec_gss_net_ops);
2077 if (err)
2078 goto out_svc_exit;
\"J. Bruce Fields\79a3f202008-12-23 16:10:52 -05002079 rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 return 0;
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04002081out_svc_exit:
2082 gss_svc_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083out_unregister:
2084 rpcauth_unregister(&authgss_ops);
2085out:
2086 return err;
2087}
2088
2089static void __exit exit_rpcsec_gss(void)
2090{
Stanislav Kinsburskya1db4102012-01-19 21:42:37 +04002091 unregister_pernet_subsys(&rpcsec_gss_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 gss_svc_shutdown();
2093 rpcauth_unregister(&authgss_ops);
Jesper Dangaard Brouerbf126912009-06-08 03:11:48 +00002094 rcu_barrier(); /* Wait for completion of call_rcu()'s */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095}
2096
Chuck Lever71afa852013-03-16 15:54:16 -04002097MODULE_ALIAS("rpc-auth-6");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098MODULE_LICENSE("GPL");
Trond Myklebust126e2162010-05-13 12:55:38 -04002099module_param_named(expired_cred_retry_delay,
2100 gss_expired_cred_retry_delay,
2101 uint, 0644);
2102MODULE_PARM_DESC(expired_cred_retry_delay, "Timeout (in seconds) until "
2103 "the RPC engine retries an expired credential");
2104
Andy Adamson4de6caa2013-08-14 11:59:15 -04002105module_param_named(key_expire_timeo,
2106 gss_key_expire_timeo,
2107 uint, 0644);
2108MODULE_PARM_DESC(key_expire_timeo, "Time (in seconds) at the end of a "
2109 "credential keys lifetime where the NFS layer cleans up "
2110 "prior to key expiration");
2111
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112module_init(init_rpcsec_gss)
2113module_exit(exit_rpcsec_gss)