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