Thomas Gleixner | 457c899 | 2019-05-19 13:08:55 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * linux/net/sunrpc/svcauth.c |
| 4 | * |
| 5 | * The generic interface for RPC authentication on the server side. |
YOSHIFUJI Hideaki | cca5172 | 2007-02-09 15:38:13 -0800 | [diff] [blame] | 6 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> |
| 8 | * |
| 9 | * CHANGES |
| 10 | * 19-Apr-2000 Chris Evans - Security fix |
| 11 | */ |
| 12 | |
| 13 | #include <linux/types.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/module.h> |
| 15 | #include <linux/sunrpc/types.h> |
| 16 | #include <linux/sunrpc/xdr.h> |
| 17 | #include <linux/sunrpc/svcsock.h> |
| 18 | #include <linux/sunrpc/svcauth.h> |
| 19 | #include <linux/err.h> |
| 20 | #include <linux/hash.h> |
| 21 | |
Chuck Lever | ff27e9f | 2019-10-24 09:34:10 -0400 | [diff] [blame] | 22 | #include <trace/events/sunrpc.h> |
| 23 | |
NeilBrown | f45db2b | 2020-05-22 12:01:32 +1000 | [diff] [blame] | 24 | #include "sunrpc.h" |
| 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #define RPCDBG_FACILITY RPCDBG_AUTH |
| 27 | |
| 28 | |
| 29 | /* |
| 30 | * Table of authenticators |
| 31 | */ |
| 32 | extern struct auth_ops svcauth_null; |
| 33 | extern struct auth_ops svcauth_unix; |
Chuck Lever | 74aaf96 | 2022-02-22 13:10:52 -0500 | [diff] [blame] | 34 | extern struct auth_ops svcauth_tls; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 36 | static struct auth_ops __rcu *authtab[RPC_AUTH_MAXFLAVOR] = { |
| 37 | [RPC_AUTH_NULL] = (struct auth_ops __force __rcu *)&svcauth_null, |
| 38 | [RPC_AUTH_UNIX] = (struct auth_ops __force __rcu *)&svcauth_unix, |
Chuck Lever | 74aaf96 | 2022-02-22 13:10:52 -0500 | [diff] [blame] | 39 | [RPC_AUTH_TLS] = (struct auth_ops __force __rcu *)&svcauth_tls, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | }; |
| 41 | |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 42 | static struct auth_ops * |
| 43 | svc_get_auth_ops(rpc_authflavor_t flavor) |
| 44 | { |
| 45 | struct auth_ops *aops; |
| 46 | |
| 47 | if (flavor >= RPC_AUTH_MAXFLAVOR) |
| 48 | return NULL; |
| 49 | rcu_read_lock(); |
| 50 | aops = rcu_dereference(authtab[flavor]); |
| 51 | if (aops != NULL && !try_module_get(aops->owner)) |
| 52 | aops = NULL; |
| 53 | rcu_read_unlock(); |
| 54 | return aops; |
| 55 | } |
| 56 | |
| 57 | static void |
| 58 | svc_put_auth_ops(struct auth_ops *aops) |
| 59 | { |
| 60 | module_put(aops->owner); |
| 61 | } |
| 62 | |
Chuck Lever | 78c542f | 2023-07-29 20:58:54 -0400 | [diff] [blame] | 63 | /** |
| 64 | * svc_authenticate - Initialize an outgoing credential |
| 65 | * @rqstp: RPC execution context |
| 66 | * |
| 67 | * Return values: |
| 68 | * %SVC_OK: XDR encoding of the result can begin |
| 69 | * %SVC_DENIED: Credential or verifier is not valid |
| 70 | * %SVC_GARBAGE: Failed to decode credential or verifier |
| 71 | * %SVC_COMPLETE: GSS context lifetime event; no further action |
| 72 | * %SVC_DROP: Drop this request; no further action |
| 73 | * %SVC_CLOSE: Like drop, but also close transport connection |
| 74 | */ |
| 75 | enum svc_auth_status svc_authenticate(struct svc_rqst *rqstp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | { |
Chuck Lever | 6898b47 | 2023-01-02 12:07:32 -0500 | [diff] [blame] | 77 | struct auth_ops *aops; |
| 78 | u32 flavor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
Chuck Lever | 438623a | 2021-07-15 15:52:06 -0400 | [diff] [blame] | 80 | rqstp->rq_auth_stat = rpc_auth_ok; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | |
Chuck Lever | 6898b47 | 2023-01-02 12:07:32 -0500 | [diff] [blame] | 82 | /* |
| 83 | * Decode the Call credential's flavor field. The credential's |
| 84 | * body field is decoded in the chosen ->accept method below. |
| 85 | */ |
| 86 | if (xdr_stream_decode_u32(&rqstp->rq_arg_stream, &flavor) < 0) |
| 87 | return SVC_GARBAGE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 89 | aops = svc_get_auth_ops(flavor); |
| 90 | if (aops == NULL) { |
Chuck Lever | 438623a | 2021-07-15 15:52:06 -0400 | [diff] [blame] | 91 | rqstp->rq_auth_stat = rpc_autherr_badcred; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | return SVC_DENIED; |
| 93 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | |
J. Bruce Fields | a5cddc8 | 2014-05-12 18:10:58 -0400 | [diff] [blame] | 95 | rqstp->rq_auth_slack = 0; |
J. Bruce Fields | 6496500c | 2015-11-20 15:45:35 -0500 | [diff] [blame] | 96 | init_svc_cred(&rqstp->rq_cred); |
J. Bruce Fields | a5cddc8 | 2014-05-12 18:10:58 -0400 | [diff] [blame] | 97 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | rqstp->rq_authop = aops; |
Chuck Lever | 438623a | 2021-07-15 15:52:06 -0400 | [diff] [blame] | 99 | return aops->accept(rqstp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 101 | EXPORT_SYMBOL_GPL(svc_authenticate); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
Chuck Lever | 78c542f | 2023-07-29 20:58:54 -0400 | [diff] [blame] | 103 | /** |
| 104 | * svc_set_client - Assign an appropriate 'auth_domain' as the client |
| 105 | * @rqstp: RPC execution context |
| 106 | * |
| 107 | * Return values: |
| 108 | * %SVC_OK: Client was found and assigned |
| 109 | * %SVC_DENY: Client was explicitly denied |
| 110 | * %SVC_DROP: Ignore this request |
| 111 | * %SVC_CLOSE: Ignore this request and close the connection |
| 112 | */ |
| 113 | enum svc_auth_status svc_set_client(struct svc_rqst *rqstp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | { |
J. Bruce Fields | 6496500c | 2015-11-20 15:45:35 -0500 | [diff] [blame] | 115 | rqstp->rq_client = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | return rqstp->rq_authop->set_client(rqstp); |
| 117 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 118 | EXPORT_SYMBOL_GPL(svc_set_client); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | |
Chuck Lever | 78c542f | 2023-07-29 20:58:54 -0400 | [diff] [blame] | 120 | /** |
| 121 | * svc_authorise - Finalize credentials/verifier and release resources |
| 122 | * @rqstp: RPC execution context |
| 123 | * |
| 124 | * Returns zero on success, or a negative errno. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | */ |
| 126 | int svc_authorise(struct svc_rqst *rqstp) |
| 127 | { |
| 128 | struct auth_ops *aops = rqstp->rq_authop; |
| 129 | int rv = 0; |
| 130 | |
| 131 | rqstp->rq_authop = NULL; |
YOSHIFUJI Hideaki | cca5172 | 2007-02-09 15:38:13 -0800 | [diff] [blame] | 132 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | if (aops) { |
| 134 | rv = aops->release(rqstp); |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 135 | svc_put_auth_ops(aops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | } |
| 137 | return rv; |
| 138 | } |
| 139 | |
| 140 | int |
| 141 | svc_auth_register(rpc_authflavor_t flavor, struct auth_ops *aops) |
| 142 | { |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 143 | struct auth_ops *old; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | int rv = -EINVAL; |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 145 | |
| 146 | if (flavor < RPC_AUTH_MAXFLAVOR) { |
| 147 | old = cmpxchg((struct auth_ops ** __force)&authtab[flavor], NULL, aops); |
| 148 | if (old == NULL || old == aops) |
| 149 | rv = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | return rv; |
| 152 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 153 | EXPORT_SYMBOL_GPL(svc_auth_register); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | |
| 155 | void |
| 156 | svc_auth_unregister(rpc_authflavor_t flavor) |
| 157 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | if (flavor < RPC_AUTH_MAXFLAVOR) |
Trond Myklebust | 30382d6 | 2018-10-01 10:41:43 -0400 | [diff] [blame] | 159 | rcu_assign_pointer(authtab[flavor], NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 161 | EXPORT_SYMBOL_GPL(svc_auth_unregister); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | |
Chuck Lever | deb7042 | 2023-11-17 17:14:27 -0500 | [diff] [blame] | 163 | /** |
| 164 | * svc_auth_flavor - return RPC transaction's RPC_AUTH flavor |
| 165 | * @rqstp: RPC transaction context |
| 166 | * |
| 167 | * Returns an RPC flavor or GSS pseudoflavor. |
| 168 | */ |
| 169 | rpc_authflavor_t svc_auth_flavor(struct svc_rqst *rqstp) |
| 170 | { |
| 171 | struct auth_ops *aops = rqstp->rq_authop; |
| 172 | |
| 173 | if (!aops->pseudoflavor) |
| 174 | return aops->flavour; |
| 175 | return aops->pseudoflavor(rqstp); |
| 176 | } |
| 177 | EXPORT_SYMBOL_GPL(svc_auth_flavor); |
| 178 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | /************************************************** |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 180 | * 'auth_domains' are stored in a hash table indexed by name. |
| 181 | * When the last reference to an 'auth_domain' is dropped, |
| 182 | * the object is unhashed and freed. |
| 183 | * If auth_domain_lookup fails to find an entry, it will return |
| 184 | * it's second argument 'new'. If this is non-null, it will |
| 185 | * have been atomically linked into the table. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | */ |
| 187 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | #define DN_HASHBITS 6 |
| 189 | #define DN_HASHMAX (1<<DN_HASHBITS) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 191 | static struct hlist_head auth_domain_table[DN_HASHMAX]; |
Fabian Frederick | 3eb15f2 | 2016-12-04 13:45:28 +0100 | [diff] [blame] | 192 | static DEFINE_SPINLOCK(auth_domain_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | |
Peter Zijlstra | 0a13cd1 | 2016-11-14 18:03:11 +0100 | [diff] [blame] | 194 | static void auth_domain_release(struct kref *kref) |
Trond Myklebust | 608a0ab | 2018-10-01 10:41:44 -0400 | [diff] [blame] | 195 | __releases(&auth_domain_lock) |
Peter Zijlstra | 0a13cd1 | 2016-11-14 18:03:11 +0100 | [diff] [blame] | 196 | { |
| 197 | struct auth_domain *dom = container_of(kref, struct auth_domain, ref); |
| 198 | |
Trond Myklebust | 608a0ab | 2018-10-01 10:41:44 -0400 | [diff] [blame] | 199 | hlist_del_rcu(&dom->hash); |
Peter Zijlstra | 0a13cd1 | 2016-11-14 18:03:11 +0100 | [diff] [blame] | 200 | dom->flavour->domain_release(dom); |
| 201 | spin_unlock(&auth_domain_lock); |
| 202 | } |
| 203 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | void auth_domain_put(struct auth_domain *dom) |
| 205 | { |
Peter Zijlstra | 0a13cd1 | 2016-11-14 18:03:11 +0100 | [diff] [blame] | 206 | kref_put_lock(&dom->ref, auth_domain_release, &auth_domain_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 208 | EXPORT_SYMBOL_GPL(auth_domain_put); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | |
| 210 | struct auth_domain * |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 211 | auth_domain_lookup(char *name, struct auth_domain *new) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | { |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 213 | struct auth_domain *hp; |
| 214 | struct hlist_head *head; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 216 | head = &auth_domain_table[hash_str(name, DN_HASHBITS)]; |
| 217 | |
| 218 | spin_lock(&auth_domain_lock); |
| 219 | |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 220 | hlist_for_each_entry(hp, head, hash) { |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 221 | if (strcmp(hp->name, name)==0) { |
| 222 | kref_get(&hp->ref); |
| 223 | spin_unlock(&auth_domain_lock); |
| 224 | return hp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | } |
Neil Brown | d6740df | 2006-10-29 22:46:45 -0800 | [diff] [blame] | 227 | if (new) |
Trond Myklebust | 608a0ab | 2018-10-01 10:41:44 -0400 | [diff] [blame] | 228 | hlist_add_head_rcu(&new->hash, head); |
NeilBrown | efc36aa | 2006-03-27 01:14:59 -0800 | [diff] [blame] | 229 | spin_unlock(&auth_domain_lock); |
| 230 | return new; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 232 | EXPORT_SYMBOL_GPL(auth_domain_lookup); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | |
| 234 | struct auth_domain *auth_domain_find(char *name) |
| 235 | { |
Trond Myklebust | 608a0ab | 2018-10-01 10:41:44 -0400 | [diff] [blame] | 236 | struct auth_domain *hp; |
| 237 | struct hlist_head *head; |
| 238 | |
| 239 | head = &auth_domain_table[hash_str(name, DN_HASHBITS)]; |
| 240 | |
| 241 | rcu_read_lock(); |
| 242 | hlist_for_each_entry_rcu(hp, head, hash) { |
| 243 | if (strcmp(hp->name, name)==0) { |
| 244 | if (!kref_get_unless_zero(&hp->ref)) |
| 245 | hp = NULL; |
| 246 | rcu_read_unlock(); |
| 247 | return hp; |
| 248 | } |
| 249 | } |
| 250 | rcu_read_unlock(); |
| 251 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | } |
Trond Myklebust | 24c3767 | 2008-12-23 16:30:12 -0500 | [diff] [blame] | 253 | EXPORT_SYMBOL_GPL(auth_domain_find); |
NeilBrown | f45db2b | 2020-05-22 12:01:32 +1000 | [diff] [blame] | 254 | |
| 255 | /** |
| 256 | * auth_domain_cleanup - check that the auth_domain table is empty |
| 257 | * |
| 258 | * On module unload the auth_domain_table must be empty. To make it |
| 259 | * easier to catch bugs which don't clean up domains properly, we |
| 260 | * warn if anything remains in the table at cleanup time. |
| 261 | * |
| 262 | * Note that we cannot proactively remove the domains at this stage. |
| 263 | * The ->release() function might be in a module that has already been |
| 264 | * unloaded. |
| 265 | */ |
| 266 | |
| 267 | void auth_domain_cleanup(void) |
| 268 | { |
| 269 | int h; |
| 270 | struct auth_domain *hp; |
| 271 | |
| 272 | for (h = 0; h < DN_HASHMAX; h++) |
| 273 | hlist_for_each_entry(hp, &auth_domain_table[h], hash) |
| 274 | pr_warn("svc: domain %s still present at module unload.\n", |
| 275 | hp->name); |
| 276 | } |