David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 1 | /* Request a key from userspace |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 3 | * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Written by David Howells (dhowells@redhat.com) |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * as published by the Free Software Foundation; either version |
| 9 | * 2 of the License, or (at your option) any later version. |
David Howells | f1a9bad | 2005-10-07 15:04:52 +0100 | [diff] [blame] | 10 | * |
Randy Dunlap | d410fa4 | 2011-05-19 15:59:38 -0700 | [diff] [blame] | 11 | * See Documentation/security/keys-request-key.txt |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | */ |
| 13 | |
| 14 | #include <linux/module.h> |
| 15 | #include <linux/sched.h> |
| 16 | #include <linux/kmod.h> |
| 17 | #include <linux/err.h> |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 18 | #include <linux/keyctl.h> |
Robert P. J. Day | fdb89bc | 2008-04-29 01:01:32 -0700 | [diff] [blame] | 19 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include "internal.h" |
| 21 | |
David Howells | e9e349b | 2008-11-14 10:39:13 +1100 | [diff] [blame] | 22 | #define key_negative_timeout 60 /* default timeout on a negative key's existence */ |
| 23 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 24 | /** |
| 25 | * complete_request_key - Complete the construction of a key. |
| 26 | * @cons: The key construction record. |
| 27 | * @error: The success or failute of the construction. |
| 28 | * |
| 29 | * Complete the attempt to construct a key. The key will be negated |
| 30 | * if an error is indicated. The authorisation key will be revoked |
| 31 | * unconditionally. |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 32 | */ |
| 33 | void complete_request_key(struct key_construction *cons, int error) |
| 34 | { |
| 35 | kenter("{%d,%d},%d", cons->key->serial, cons->authkey->serial, error); |
| 36 | |
| 37 | if (error < 0) |
| 38 | key_negate_and_link(cons->key, key_negative_timeout, NULL, |
| 39 | cons->authkey); |
| 40 | else |
| 41 | key_revoke(cons->authkey); |
| 42 | |
| 43 | key_put(cons->key); |
| 44 | key_put(cons->authkey); |
| 45 | kfree(cons); |
| 46 | } |
| 47 | EXPORT_SYMBOL(complete_request_key); |
| 48 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 49 | /* |
| 50 | * Initialise a usermode helper that is going to have a specific session |
| 51 | * keyring. |
| 52 | * |
| 53 | * This is called in context of freshly forked kthread before kernel_execve(), |
| 54 | * so we can simply install the desired session_keyring at this point. |
| 55 | */ |
David Howells | 8796699 | 2011-06-17 11:25:59 +0100 | [diff] [blame] | 56 | static int umh_keys_init(struct subprocess_info *info, struct cred *cred) |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 57 | { |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 58 | struct key *keyring = info->data; |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 59 | |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 60 | return install_session_keyring_to_cred(cred, keyring); |
| 61 | } |
| 62 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 63 | /* |
| 64 | * Clean up a usermode helper with session keyring. |
| 65 | */ |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 66 | static void umh_keys_cleanup(struct subprocess_info *info) |
| 67 | { |
| 68 | struct key *keyring = info->data; |
| 69 | key_put(keyring); |
| 70 | } |
| 71 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 72 | /* |
| 73 | * Call a usermode helper with a specific session keyring. |
| 74 | */ |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 75 | static int call_usermodehelper_keys(char *path, char **argv, char **envp, |
Oleg Nesterov | 9d944ef | 2012-03-23 15:02:48 -0700 | [diff] [blame] | 76 | struct key *session_keyring, int wait) |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 77 | { |
Lucas De Marchi | 93997f6 | 2013-04-30 15:28:05 -0700 | [diff] [blame] | 78 | struct subprocess_info *info; |
| 79 | |
| 80 | info = call_usermodehelper_setup(path, argv, envp, GFP_KERNEL, |
| 81 | umh_keys_init, umh_keys_cleanup, |
| 82 | session_keyring); |
| 83 | if (!info) |
| 84 | return -ENOMEM; |
| 85 | |
| 86 | key_get(session_keyring); |
| 87 | return call_usermodehelper_exec(info, wait); |
Oleg Nesterov | 685bfd2 | 2010-05-26 14:43:00 -0700 | [diff] [blame] | 88 | } |
| 89 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 91 | * Request userspace finish the construction of a key |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 92 | * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | */ |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 94 | static int call_sbin_request_key(struct key_construction *cons, |
David Howells | 4e54f08 | 2006-06-29 02:24:28 -0700 | [diff] [blame] | 95 | const char *op, |
| 96 | void *aux) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | { |
David Howells | 86a264a | 2008-11-14 10:39:18 +1100 | [diff] [blame] | 98 | const struct cred *cred = current_cred(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | key_serial_t prkey, sskey; |
David Howells | 93b4a44 | 2010-04-23 13:18:00 -0400 | [diff] [blame] | 100 | struct key *key = cons->key, *authkey = cons->authkey, *keyring, |
| 101 | *session; |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 102 | char *argv[9], *envp[3], uid_str[12], gid_str[12]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | char key_str[12], keyring_str[3][12]; |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 104 | char desc[20]; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 105 | int ret, i; |
| 106 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 107 | kenter("{%d},{%d},%s", key->serial, authkey->serial, op); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 108 | |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 109 | ret = install_user_keyrings(); |
| 110 | if (ret < 0) |
| 111 | goto error_alloc; |
| 112 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 113 | /* allocate a new session keyring */ |
| 114 | sprintf(desc, "_req.%u", key->serial); |
| 115 | |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 116 | cred = get_current_cred(); |
| 117 | keyring = keyring_alloc(desc, cred->fsuid, cred->fsgid, cred, |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 118 | KEY_POS_ALL | KEY_USR_VIEW | KEY_USR_READ, |
David Howells | 7e047ef | 2006-06-26 00:24:50 -0700 | [diff] [blame] | 119 | KEY_ALLOC_QUOTA_OVERRUN, NULL); |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 120 | put_cred(cred); |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 121 | if (IS_ERR(keyring)) { |
| 122 | ret = PTR_ERR(keyring); |
| 123 | goto error_alloc; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 124 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 126 | /* attach the auth key to the session keyring */ |
David Howells | 896903c | 2010-04-30 14:32:23 +0100 | [diff] [blame] | 127 | ret = key_link(keyring, authkey); |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 128 | if (ret < 0) |
| 129 | goto error_link; |
| 130 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | /* record the UID and GID */ |
Eric W. Biederman | 9a56c2d | 2012-02-08 07:53:04 -0800 | [diff] [blame] | 132 | sprintf(uid_str, "%d", from_kuid(&init_user_ns, cred->fsuid)); |
| 133 | sprintf(gid_str, "%d", from_kgid(&init_user_ns, cred->fsgid)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | |
| 135 | /* we say which key is under construction */ |
| 136 | sprintf(key_str, "%d", key->serial); |
| 137 | |
| 138 | /* we specify the process's default keyrings */ |
| 139 | sprintf(keyring_str[0], "%d", |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 140 | cred->thread_keyring ? cred->thread_keyring->serial : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | |
| 142 | prkey = 0; |
David Howells | 3a50597 | 2012-10-02 19:24:29 +0100 | [diff] [blame] | 143 | if (cred->process_keyring) |
| 144 | prkey = cred->process_keyring->serial; |
Justin P. Mattock | 5ad18a0 | 2010-06-30 10:39:11 +0100 | [diff] [blame] | 145 | sprintf(keyring_str[1], "%d", prkey); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | |
David Howells | 93b4a44 | 2010-04-23 13:18:00 -0400 | [diff] [blame] | 147 | rcu_read_lock(); |
David Howells | 3a50597 | 2012-10-02 19:24:29 +0100 | [diff] [blame] | 148 | session = rcu_dereference(cred->session_keyring); |
David Howells | 93b4a44 | 2010-04-23 13:18:00 -0400 | [diff] [blame] | 149 | if (!session) |
| 150 | session = cred->user->session_keyring; |
| 151 | sskey = session->serial; |
| 152 | rcu_read_unlock(); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 153 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | sprintf(keyring_str[2], "%d", sskey); |
| 155 | |
| 156 | /* set up a minimal environment */ |
| 157 | i = 0; |
| 158 | envp[i++] = "HOME=/"; |
| 159 | envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; |
| 160 | envp[i] = NULL; |
| 161 | |
| 162 | /* set up the argument list */ |
| 163 | i = 0; |
| 164 | argv[i++] = "/sbin/request-key"; |
| 165 | argv[i++] = (char *) op; |
| 166 | argv[i++] = key_str; |
| 167 | argv[i++] = uid_str; |
| 168 | argv[i++] = gid_str; |
| 169 | argv[i++] = keyring_str[0]; |
| 170 | argv[i++] = keyring_str[1]; |
| 171 | argv[i++] = keyring_str[2]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | argv[i] = NULL; |
| 173 | |
| 174 | /* do it */ |
Jeremy Fitzhardinge | 86313c4 | 2007-07-17 18:37:03 -0700 | [diff] [blame] | 175 | ret = call_usermodehelper_keys(argv[0], argv, envp, keyring, |
| 176 | UMH_WAIT_PROC); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 177 | kdebug("usermode -> 0x%x", ret); |
| 178 | if (ret >= 0) { |
| 179 | /* ret is the exit/wait code */ |
| 180 | if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags) || |
| 181 | key_validate(key) < 0) |
| 182 | ret = -ENOKEY; |
| 183 | else |
| 184 | /* ignore any errors from userspace if the key was |
| 185 | * instantiated */ |
| 186 | ret = 0; |
| 187 | } |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 188 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 189 | error_link: |
| 190 | key_put(keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 191 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 192 | error_alloc: |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 193 | complete_request_key(cons, ret); |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 194 | kleave(" = %d", ret); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 195 | return ret; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 196 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 199 | * Call out to userspace for key construction. |
| 200 | * |
| 201 | * Program failure is ignored in favour of key status. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | */ |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 203 | static int construct_key(struct key *key, const void *callout_info, |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 204 | size_t callout_len, void *aux, |
| 205 | struct key *dest_keyring) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | { |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 207 | struct key_construction *cons; |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 208 | request_key_actor_t actor; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 209 | struct key *authkey; |
| 210 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 212 | kenter("%d,%p,%zu,%p", key->serial, callout_info, callout_len, aux); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 213 | |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 214 | cons = kmalloc(sizeof(*cons), GFP_KERNEL); |
| 215 | if (!cons) |
| 216 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 218 | /* allocate an authorisation key */ |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 219 | authkey = request_key_auth_new(key, callout_info, callout_len, |
| 220 | dest_keyring); |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 221 | if (IS_ERR(authkey)) { |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 222 | kfree(cons); |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 223 | ret = PTR_ERR(authkey); |
| 224 | authkey = NULL; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 225 | } else { |
| 226 | cons->authkey = key_get(authkey); |
| 227 | cons->key = key_get(key); |
| 228 | |
| 229 | /* make the call */ |
| 230 | actor = call_sbin_request_key; |
| 231 | if (key->type->request_key) |
| 232 | actor = key->type->request_key; |
| 233 | |
| 234 | ret = actor(cons, "create", aux); |
| 235 | |
| 236 | /* check that the actor called complete_request_key() prior to |
| 237 | * returning an error */ |
| 238 | WARN_ON(ret < 0 && |
| 239 | !test_bit(KEY_FLAG_REVOKED, &authkey->flags)); |
| 240 | key_put(authkey); |
David Howells | b5f545c | 2006-01-08 01:02:47 -0800 | [diff] [blame] | 241 | } |
| 242 | |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 243 | kleave(" = %d", ret); |
| 244 | return ret; |
| 245 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 248 | * Get the appropriate destination keyring for the request. |
| 249 | * |
| 250 | * The keyring selected is returned with an extra reference upon it which the |
| 251 | * caller must release. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | */ |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 253 | static void construct_get_dest_keyring(struct key **_dest_keyring) |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 254 | { |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 255 | struct request_key_auth *rka; |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 256 | const struct cred *cred = current_cred(); |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 257 | struct key *dest_keyring = *_dest_keyring, *authkey; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 258 | |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 259 | kenter("%p", dest_keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 260 | |
| 261 | /* find the appropriate keyring */ |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 262 | if (dest_keyring) { |
| 263 | /* the caller supplied one */ |
| 264 | key_get(dest_keyring); |
| 265 | } else { |
| 266 | /* use a default keyring; falling through the cases until we |
| 267 | * find one that we actually have */ |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 268 | switch (cred->jit_keyring) { |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 269 | case KEY_REQKEY_DEFL_DEFAULT: |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 270 | case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 271 | if (cred->request_key_auth) { |
| 272 | authkey = cred->request_key_auth; |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 273 | down_read(&authkey->sem); |
| 274 | rka = authkey->payload.data; |
| 275 | if (!test_bit(KEY_FLAG_REVOKED, |
| 276 | &authkey->flags)) |
| 277 | dest_keyring = |
| 278 | key_get(rka->dest_keyring); |
| 279 | up_read(&authkey->sem); |
| 280 | if (dest_keyring) |
| 281 | break; |
| 282 | } |
| 283 | |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 284 | case KEY_REQKEY_DEFL_THREAD_KEYRING: |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 285 | dest_keyring = key_get(cred->thread_keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 286 | if (dest_keyring) |
| 287 | break; |
| 288 | |
| 289 | case KEY_REQKEY_DEFL_PROCESS_KEYRING: |
David Howells | 3a50597 | 2012-10-02 19:24:29 +0100 | [diff] [blame] | 290 | dest_keyring = key_get(cred->process_keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 291 | if (dest_keyring) |
| 292 | break; |
| 293 | |
| 294 | case KEY_REQKEY_DEFL_SESSION_KEYRING: |
| 295 | rcu_read_lock(); |
| 296 | dest_keyring = key_get( |
David Howells | 3a50597 | 2012-10-02 19:24:29 +0100 | [diff] [blame] | 297 | rcu_dereference(cred->session_keyring)); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 298 | rcu_read_unlock(); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 299 | |
| 300 | if (dest_keyring) |
| 301 | break; |
| 302 | |
| 303 | case KEY_REQKEY_DEFL_USER_SESSION_KEYRING: |
David Howells | b6dff3e | 2008-11-14 10:39:16 +1100 | [diff] [blame] | 304 | dest_keyring = |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 305 | key_get(cred->user->session_keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 306 | break; |
| 307 | |
| 308 | case KEY_REQKEY_DEFL_USER_KEYRING: |
David Howells | bb952bb | 2008-11-14 10:39:20 +1100 | [diff] [blame] | 309 | dest_keyring = key_get(cred->user->uid_keyring); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 310 | break; |
| 311 | |
| 312 | case KEY_REQKEY_DEFL_GROUP_KEYRING: |
| 313 | default: |
| 314 | BUG(); |
| 315 | } |
| 316 | } |
| 317 | |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 318 | *_dest_keyring = dest_keyring; |
| 319 | kleave(" [dk %d]", key_serial(dest_keyring)); |
| 320 | return; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 321 | } |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 322 | |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 323 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 324 | * Allocate a new key in under-construction state and attempt to link it in to |
| 325 | * the requested keyring. |
| 326 | * |
| 327 | * May return a key that's already under construction instead if there was a |
| 328 | * race between two thread calling request_key(). |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 329 | */ |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 330 | static int construct_alloc_key(struct keyring_search_context *ctx, |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 331 | struct key *dest_keyring, |
| 332 | unsigned long flags, |
| 333 | struct key_user *user, |
| 334 | struct key **_key) |
| 335 | { |
David Howells | b2a4df2 | 2013-09-24 10:35:18 +0100 | [diff] [blame] | 336 | struct assoc_array_edit *edit; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 337 | struct key *key; |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 338 | key_perm_t perm; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 339 | key_ref_t key_ref; |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 340 | int ret; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 341 | |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 342 | kenter("%s,%s,,,", |
| 343 | ctx->index_key.type->name, ctx->index_key.description); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 344 | |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 345 | *_key = NULL; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 346 | mutex_lock(&user->cons_lock); |
| 347 | |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 348 | perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR; |
| 349 | perm |= KEY_USR_VIEW; |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 350 | if (ctx->index_key.type->read) |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 351 | perm |= KEY_POS_READ; |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 352 | if (ctx->index_key.type == &key_type_keyring || |
| 353 | ctx->index_key.type->update) |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 354 | perm |= KEY_POS_WRITE; |
| 355 | |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 356 | key = key_alloc(ctx->index_key.type, ctx->index_key.description, |
| 357 | ctx->cred->fsuid, ctx->cred->fsgid, ctx->cred, |
David Howells | 96b5c8f | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 358 | perm, flags); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 359 | if (IS_ERR(key)) |
| 360 | goto alloc_failed; |
| 361 | |
| 362 | set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags); |
| 363 | |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 364 | if (dest_keyring) { |
David Howells | b2a4df2 | 2013-09-24 10:35:18 +0100 | [diff] [blame] | 365 | ret = __key_link_begin(dest_keyring, &ctx->index_key, &edit); |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 366 | if (ret < 0) |
| 367 | goto link_prealloc_failed; |
| 368 | } |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 369 | |
| 370 | /* attach the key to the destination keyring under lock, but we do need |
| 371 | * to do another check just in case someone beat us to it whilst we |
| 372 | * waited for locks */ |
| 373 | mutex_lock(&key_construction_mutex); |
| 374 | |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 375 | key_ref = search_process_keyrings(ctx); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 376 | if (!IS_ERR(key_ref)) |
| 377 | goto key_already_present; |
| 378 | |
David Howells | 34574dd | 2009-04-09 17:14:05 +0100 | [diff] [blame] | 379 | if (dest_keyring) |
David Howells | b2a4df2 | 2013-09-24 10:35:18 +0100 | [diff] [blame] | 380 | __key_link(key, &edit); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 381 | |
| 382 | mutex_unlock(&key_construction_mutex); |
David Howells | 34574dd | 2009-04-09 17:14:05 +0100 | [diff] [blame] | 383 | if (dest_keyring) |
David Howells | b2a4df2 | 2013-09-24 10:35:18 +0100 | [diff] [blame] | 384 | __key_link_end(dest_keyring, &ctx->index_key, edit); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 385 | mutex_unlock(&user->cons_lock); |
| 386 | *_key = key; |
| 387 | kleave(" = 0 [%d]", key_serial(key)); |
| 388 | return 0; |
| 389 | |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 390 | /* the key is now present - we tell the caller that we found it by |
| 391 | * returning -EINPROGRESS */ |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 392 | key_already_present: |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 393 | key_put(key); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 394 | mutex_unlock(&key_construction_mutex); |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 395 | key = key_ref_to_ptr(key_ref); |
David Howells | 03449cd | 2010-04-27 13:13:08 -0700 | [diff] [blame] | 396 | if (dest_keyring) { |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 397 | ret = __key_link_check_live_key(dest_keyring, key); |
| 398 | if (ret == 0) |
David Howells | b2a4df2 | 2013-09-24 10:35:18 +0100 | [diff] [blame] | 399 | __key_link(key, &edit); |
| 400 | __key_link_end(dest_keyring, &ctx->index_key, edit); |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 401 | if (ret < 0) |
| 402 | goto link_check_failed; |
David Howells | 03449cd | 2010-04-27 13:13:08 -0700 | [diff] [blame] | 403 | } |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 404 | mutex_unlock(&user->cons_lock); |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 405 | *_key = key; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 406 | kleave(" = -EINPROGRESS [%d]", key_serial(key)); |
| 407 | return -EINPROGRESS; |
| 408 | |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 409 | link_check_failed: |
| 410 | mutex_unlock(&user->cons_lock); |
| 411 | key_put(key); |
| 412 | kleave(" = %d [linkcheck]", ret); |
| 413 | return ret; |
| 414 | |
| 415 | link_prealloc_failed: |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 416 | mutex_unlock(&user->cons_lock); |
David Jeffery | d0709f1 | 2015-02-12 16:45:31 +0000 | [diff] [blame^] | 417 | key_put(key); |
David Howells | f70e2e0 | 2010-04-30 14:32:39 +0100 | [diff] [blame] | 418 | kleave(" = %d [prelink]", ret); |
| 419 | return ret; |
| 420 | |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 421 | alloc_failed: |
| 422 | mutex_unlock(&user->cons_lock); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 423 | kleave(" = %ld", PTR_ERR(key)); |
| 424 | return PTR_ERR(key); |
| 425 | } |
| 426 | |
| 427 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 428 | * Commence key construction. |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 429 | */ |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 430 | static struct key *construct_key_and_link(struct keyring_search_context *ctx, |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 431 | const char *callout_info, |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 432 | size_t callout_len, |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 433 | void *aux, |
| 434 | struct key *dest_keyring, |
| 435 | unsigned long flags) |
| 436 | { |
| 437 | struct key_user *user; |
| 438 | struct key *key; |
| 439 | int ret; |
| 440 | |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 441 | kenter(""); |
| 442 | |
Eric W. Biederman | 9a56c2d | 2012-02-08 07:53:04 -0800 | [diff] [blame] | 443 | user = key_user_lookup(current_fsuid()); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 444 | if (!user) |
| 445 | return ERR_PTR(-ENOMEM); |
| 446 | |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 447 | construct_get_dest_keyring(&dest_keyring); |
| 448 | |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 449 | ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 450 | key_user_put(user); |
| 451 | |
| 452 | if (ret == 0) { |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 453 | ret = construct_key(key, callout_info, callout_len, aux, |
| 454 | dest_keyring); |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 455 | if (ret < 0) { |
| 456 | kdebug("cons failed"); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 457 | goto construction_failed; |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 458 | } |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 459 | } else if (ret == -EINPROGRESS) { |
| 460 | ret = 0; |
| 461 | } else { |
David Howells | b1d7dd8 | 2011-06-21 14:32:05 +0100 | [diff] [blame] | 462 | goto couldnt_alloc_key; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 463 | } |
| 464 | |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 465 | key_put(dest_keyring); |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 466 | kleave(" = key %d", key_serial(key)); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 467 | return key; |
| 468 | |
| 469 | construction_failed: |
| 470 | key_negate_and_link(key, key_negative_timeout, NULL, NULL); |
| 471 | key_put(key); |
David Howells | b1d7dd8 | 2011-06-21 14:32:05 +0100 | [diff] [blame] | 472 | couldnt_alloc_key: |
David Howells | 8bbf4976 | 2008-11-14 10:39:14 +1100 | [diff] [blame] | 473 | key_put(dest_keyring); |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 474 | kleave(" = %d", ret); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 475 | return ERR_PTR(ret); |
| 476 | } |
| 477 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 478 | /** |
| 479 | * request_key_and_link - Request a key and cache it in a keyring. |
| 480 | * @type: The type of key we want. |
| 481 | * @description: The searchable description of the key. |
| 482 | * @callout_info: The data to pass to the instantiation upcall (or NULL). |
| 483 | * @callout_len: The length of callout_info. |
| 484 | * @aux: Auxiliary data for the upcall. |
| 485 | * @dest_keyring: Where to cache the key. |
| 486 | * @flags: Flags to key_alloc(). |
| 487 | * |
| 488 | * A key matching the specified criteria is searched for in the process's |
| 489 | * keyrings and returned with its usage count incremented if found. Otherwise, |
| 490 | * if callout_info is not NULL, a key will be allocated and some service |
| 491 | * (probably in userspace) will be asked to instantiate it. |
| 492 | * |
| 493 | * If successfully found or created, the key will be linked to the destination |
| 494 | * keyring if one is provided. |
| 495 | * |
| 496 | * Returns a pointer to the key if successful; -EACCES, -ENOKEY, -EKEYREVOKED |
| 497 | * or -EKEYEXPIRED if an inaccessible, negative, revoked or expired key was |
| 498 | * found; -ENOKEY if no key was found and no @callout_info was given; -EDQUOT |
| 499 | * if insufficient key quota was available to create a new key; or -ENOMEM if |
| 500 | * insufficient memory was available. |
| 501 | * |
| 502 | * If the returned key was created, then it may still be under construction, |
| 503 | * and wait_for_key_construction() should be used to wait for that to complete. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 504 | */ |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 505 | struct key *request_key_and_link(struct key_type *type, |
| 506 | const char *description, |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 507 | const void *callout_info, |
| 508 | size_t callout_len, |
David Howells | 4e54f08 | 2006-06-29 02:24:28 -0700 | [diff] [blame] | 509 | void *aux, |
David Howells | 7e047ef | 2006-06-26 00:24:50 -0700 | [diff] [blame] | 510 | struct key *dest_keyring, |
| 511 | unsigned long flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | { |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 513 | struct keyring_search_context ctx = { |
| 514 | .index_key.type = type, |
| 515 | .index_key.description = description, |
| 516 | .cred = current_cred(), |
David Howells | c06cfb0 | 2014-09-16 17:36:06 +0100 | [diff] [blame] | 517 | .match_data.cmp = key_default_cmp, |
David Howells | 4629195 | 2014-09-16 17:36:02 +0100 | [diff] [blame] | 518 | .match_data.raw_data = description, |
| 519 | .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT, |
David Howells | 0b0a841 | 2014-12-01 22:52:53 +0000 | [diff] [blame] | 520 | .flags = (KEYRING_SEARCH_DO_STATE_CHECK | |
| 521 | KEYRING_SEARCH_SKIP_EXPIRED), |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 522 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | struct key *key; |
David Howells | 664cceb | 2005-09-28 17:03:15 +0100 | [diff] [blame] | 524 | key_ref_t key_ref; |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 525 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 527 | kenter("%s,%s,%p,%zu,%p,%p,%lx", |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 528 | ctx.index_key.type->name, ctx.index_key.description, |
| 529 | callout_info, callout_len, aux, dest_keyring, flags); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 530 | |
David Howells | 4629195 | 2014-09-16 17:36:02 +0100 | [diff] [blame] | 531 | if (type->match_preparse) { |
| 532 | ret = type->match_preparse(&ctx.match_data); |
| 533 | if (ret < 0) { |
| 534 | key = ERR_PTR(ret); |
| 535 | goto error; |
| 536 | } |
| 537 | } |
| 538 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 539 | /* search all the process keyrings for a key */ |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 540 | key_ref = search_process_keyrings(&ctx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | |
David Howells | 664cceb | 2005-09-28 17:03:15 +0100 | [diff] [blame] | 542 | if (!IS_ERR(key_ref)) { |
| 543 | key = key_ref_to_ptr(key_ref); |
David Howells | 03449cd | 2010-04-27 13:13:08 -0700 | [diff] [blame] | 544 | if (dest_keyring) { |
| 545 | construct_get_dest_keyring(&dest_keyring); |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 546 | ret = key_link(dest_keyring, key); |
David Howells | 03449cd | 2010-04-27 13:13:08 -0700 | [diff] [blame] | 547 | key_put(dest_keyring); |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 548 | if (ret < 0) { |
| 549 | key_put(key); |
| 550 | key = ERR_PTR(ret); |
David Howells | 4629195 | 2014-09-16 17:36:02 +0100 | [diff] [blame] | 551 | goto error_free; |
David Howells | 2b9e468 | 2010-04-30 14:32:34 +0100 | [diff] [blame] | 552 | } |
David Howells | 03449cd | 2010-04-27 13:13:08 -0700 | [diff] [blame] | 553 | } |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 554 | } else if (PTR_ERR(key_ref) != -EAGAIN) { |
David Howells | e231c2e | 2008-02-07 00:15:26 -0800 | [diff] [blame] | 555 | key = ERR_CAST(key_ref); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 556 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 557 | /* the search failed, but the keyrings were searchable, so we |
| 558 | * should consult userspace if we can */ |
| 559 | key = ERR_PTR(-ENOKEY); |
| 560 | if (!callout_info) |
David Howells | 4629195 | 2014-09-16 17:36:02 +0100 | [diff] [blame] | 561 | goto error_free; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | |
David Howells | 4bdf0bc | 2013-09-24 10:35:15 +0100 | [diff] [blame] | 563 | key = construct_key_and_link(&ctx, callout_info, callout_len, |
| 564 | aux, dest_keyring, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 565 | } |
| 566 | |
David Howells | 4629195 | 2014-09-16 17:36:02 +0100 | [diff] [blame] | 567 | error_free: |
| 568 | if (type->match_free) |
| 569 | type->match_free(&ctx.match_data); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 570 | error: |
| 571 | kleave(" = %p", key); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 572 | return key; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 573 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 575 | /** |
| 576 | * wait_for_key_construction - Wait for construction of a key to complete |
| 577 | * @key: The key being waited for. |
| 578 | * @intr: Whether to wait interruptibly. |
| 579 | * |
| 580 | * Wait for a key to finish being constructed. |
| 581 | * |
| 582 | * Returns 0 if successful; -ERESTARTSYS if the wait was interrupted; -ENOKEY |
| 583 | * if the key was negated; or -EKEYREVOKED or -EKEYEXPIRED if the key was |
| 584 | * revoked or expired. |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 585 | */ |
| 586 | int wait_for_key_construction(struct key *key, bool intr) |
| 587 | { |
| 588 | int ret; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 589 | |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 590 | ret = wait_on_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT, |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 591 | intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE); |
NeilBrown | 7431620 | 2014-07-07 15:16:04 +1000 | [diff] [blame] | 592 | if (ret) |
| 593 | return -ERESTARTSYS; |
David Howells | 74792b0 | 2013-10-30 11:15:24 +0000 | [diff] [blame] | 594 | if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) { |
| 595 | smp_rmb(); |
David Howells | fdd1b94 | 2011-03-07 15:06:09 +0000 | [diff] [blame] | 596 | return key->type_data.reject_error; |
David Howells | 74792b0 | 2013-10-30 11:15:24 +0000 | [diff] [blame] | 597 | } |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 598 | return key_validate(key); |
| 599 | } |
| 600 | EXPORT_SYMBOL(wait_for_key_construction); |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 601 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 602 | /** |
| 603 | * request_key - Request a key and wait for construction |
| 604 | * @type: Type of key. |
| 605 | * @description: The searchable description of the key. |
| 606 | * @callout_info: The data to pass to the instantiation upcall (or NULL). |
| 607 | * |
| 608 | * As for request_key_and_link() except that it does not add the returned key |
| 609 | * to a keyring if found, new keys are always allocated in the user's quota, |
| 610 | * the callout_info must be a NUL-terminated string and no auxiliary data can |
| 611 | * be passed. |
| 612 | * |
| 613 | * Furthermore, it then works as wait_for_key_construction() to wait for the |
| 614 | * completion of keys undergoing construction with a non-interruptible wait. |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 615 | */ |
| 616 | struct key *request_key(struct key_type *type, |
| 617 | const char *description, |
| 618 | const char *callout_info) |
| 619 | { |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 620 | struct key *key; |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 621 | size_t callout_len = 0; |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 622 | int ret; |
David Howells | 3e30148 | 2005-06-23 22:00:56 -0700 | [diff] [blame] | 623 | |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 624 | if (callout_info) |
| 625 | callout_len = strlen(callout_info); |
| 626 | key = request_key_and_link(type, description, callout_info, callout_len, |
| 627 | NULL, NULL, KEY_ALLOC_IN_QUOTA); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 628 | if (!IS_ERR(key)) { |
| 629 | ret = wait_for_key_construction(key, false); |
| 630 | if (ret < 0) { |
| 631 | key_put(key); |
| 632 | return ERR_PTR(ret); |
| 633 | } |
| 634 | } |
| 635 | return key; |
| 636 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 637 | EXPORT_SYMBOL(request_key); |
David Howells | 4e54f08 | 2006-06-29 02:24:28 -0700 | [diff] [blame] | 638 | |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 639 | /** |
| 640 | * request_key_with_auxdata - Request a key with auxiliary data for the upcaller |
| 641 | * @type: The type of key we want. |
| 642 | * @description: The searchable description of the key. |
| 643 | * @callout_info: The data to pass to the instantiation upcall (or NULL). |
| 644 | * @callout_len: The length of callout_info. |
| 645 | * @aux: Auxiliary data for the upcall. |
| 646 | * |
| 647 | * As for request_key_and_link() except that it does not add the returned key |
| 648 | * to a keyring if found and new keys are always allocated in the user's quota. |
| 649 | * |
| 650 | * Furthermore, it then works as wait_for_key_construction() to wait for the |
| 651 | * completion of keys undergoing construction with a non-interruptible wait. |
David Howells | 4e54f08 | 2006-06-29 02:24:28 -0700 | [diff] [blame] | 652 | */ |
| 653 | struct key *request_key_with_auxdata(struct key_type *type, |
| 654 | const char *description, |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 655 | const void *callout_info, |
| 656 | size_t callout_len, |
David Howells | 4e54f08 | 2006-06-29 02:24:28 -0700 | [diff] [blame] | 657 | void *aux) |
| 658 | { |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 659 | struct key *key; |
| 660 | int ret; |
| 661 | |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 662 | key = request_key_and_link(type, description, callout_info, callout_len, |
| 663 | aux, NULL, KEY_ALLOC_IN_QUOTA); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 664 | if (!IS_ERR(key)) { |
| 665 | ret = wait_for_key_construction(key, false); |
| 666 | if (ret < 0) { |
| 667 | key_put(key); |
| 668 | return ERR_PTR(ret); |
| 669 | } |
| 670 | } |
| 671 | return key; |
| 672 | } |
| 673 | EXPORT_SYMBOL(request_key_with_auxdata); |
| 674 | |
| 675 | /* |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 676 | * request_key_async - Request a key (allow async construction) |
| 677 | * @type: Type of key. |
| 678 | * @description: The searchable description of the key. |
| 679 | * @callout_info: The data to pass to the instantiation upcall (or NULL). |
| 680 | * @callout_len: The length of callout_info. |
| 681 | * |
| 682 | * As for request_key_and_link() except that it does not add the returned key |
| 683 | * to a keyring if found, new keys are always allocated in the user's quota and |
| 684 | * no auxiliary data can be passed. |
| 685 | * |
| 686 | * The caller should call wait_for_key_construction() to wait for the |
| 687 | * completion of the returned key if it is still undergoing construction. |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 688 | */ |
| 689 | struct key *request_key_async(struct key_type *type, |
| 690 | const char *description, |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 691 | const void *callout_info, |
| 692 | size_t callout_len) |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 693 | { |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 694 | return request_key_and_link(type, description, callout_info, |
| 695 | callout_len, NULL, NULL, |
| 696 | KEY_ALLOC_IN_QUOTA); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 697 | } |
| 698 | EXPORT_SYMBOL(request_key_async); |
| 699 | |
| 700 | /* |
| 701 | * request a key with auxiliary data for the upcaller (allow async construction) |
David Howells | 973c9f4 | 2011-01-20 16:38:33 +0000 | [diff] [blame] | 702 | * @type: Type of key. |
| 703 | * @description: The searchable description of the key. |
| 704 | * @callout_info: The data to pass to the instantiation upcall (or NULL). |
| 705 | * @callout_len: The length of callout_info. |
| 706 | * @aux: Auxiliary data for the upcall. |
| 707 | * |
| 708 | * As for request_key_and_link() except that it does not add the returned key |
| 709 | * to a keyring if found and new keys are always allocated in the user's quota. |
| 710 | * |
| 711 | * The caller should call wait_for_key_construction() to wait for the |
| 712 | * completion of the returned key if it is still undergoing construction. |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 713 | */ |
| 714 | struct key *request_key_async_with_auxdata(struct key_type *type, |
| 715 | const char *description, |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 716 | const void *callout_info, |
| 717 | size_t callout_len, |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 718 | void *aux) |
| 719 | { |
David Howells | 4a38e12 | 2008-04-29 01:01:24 -0700 | [diff] [blame] | 720 | return request_key_and_link(type, description, callout_info, |
| 721 | callout_len, aux, NULL, KEY_ALLOC_IN_QUOTA); |
David Howells | 76181c1 | 2007-10-16 23:29:46 -0700 | [diff] [blame] | 722 | } |
| 723 | EXPORT_SYMBOL(request_key_async_with_auxdata); |