Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* Request a key from userspace
3 : : *
4 : : * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
5 : : * Written by David Howells (dhowells@redhat.com)
6 : : *
7 : : * See Documentation/security/keys/request-key.rst
8 : : */
9 : :
10 : : #include <linux/export.h>
11 : : #include <linux/sched.h>
12 : : #include <linux/kmod.h>
13 : : #include <linux/err.h>
14 : : #include <linux/keyctl.h>
15 : : #include <linux/slab.h>
16 : : #include <net/net_namespace.h>
17 : : #include "internal.h"
18 : : #include <keys/request_key_auth-type.h>
19 : :
20 : : #define key_negative_timeout 60 /* default timeout on a negative key's existence */
21 : :
22 : : static struct key *check_cached_key(struct keyring_search_context *ctx)
23 : : {
24 : : #ifdef CONFIG_KEYS_REQUEST_CACHE
25 : : struct key *key = current->cached_requested_key;
26 : :
27 : : if (key &&
28 : : ctx->match_data.cmp(key, &ctx->match_data) &&
29 : : !(key->flags & ((1 << KEY_FLAG_INVALIDATED) |
30 : : (1 << KEY_FLAG_REVOKED))))
31 : : return key_get(key);
32 : : #endif
33 : : return NULL;
34 : : }
35 : :
36 : : static void cache_requested_key(struct key *key)
37 : : {
38 : : #ifdef CONFIG_KEYS_REQUEST_CACHE
39 : : struct task_struct *t = current;
40 : :
41 : : key_put(t->cached_requested_key);
42 : : t->cached_requested_key = key_get(key);
43 : : set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
44 : : #endif
45 : : }
46 : :
47 : : /**
48 : : * complete_request_key - Complete the construction of a key.
49 : : * @authkey: The authorisation key.
50 : : * @error: The success or failute of the construction.
51 : : *
52 : : * Complete the attempt to construct a key. The key will be negated
53 : : * if an error is indicated. The authorisation key will be revoked
54 : : * unconditionally.
55 : : */
56 : 0 : void complete_request_key(struct key *authkey, int error)
57 : : {
58 : : struct request_key_auth *rka = get_request_key_auth(authkey);
59 : 0 : struct key *key = rka->target_key;
60 : :
61 : : kenter("%d{%d},%d", authkey->serial, key->serial, error);
62 : :
63 [ # # ]: 0 : if (error < 0)
64 : : key_negate_and_link(key, key_negative_timeout, NULL, authkey);
65 : : else
66 : 0 : key_revoke(authkey);
67 : 0 : }
68 : : EXPORT_SYMBOL(complete_request_key);
69 : :
70 : : /*
71 : : * Initialise a usermode helper that is going to have a specific session
72 : : * keyring.
73 : : *
74 : : * This is called in context of freshly forked kthread before kernel_execve(),
75 : : * so we can simply install the desired session_keyring at this point.
76 : : */
77 : 0 : static int umh_keys_init(struct subprocess_info *info, struct cred *cred)
78 : : {
79 : 0 : struct key *keyring = info->data;
80 : :
81 : 0 : return install_session_keyring_to_cred(cred, keyring);
82 : : }
83 : :
84 : : /*
85 : : * Clean up a usermode helper with session keyring.
86 : : */
87 : 0 : static void umh_keys_cleanup(struct subprocess_info *info)
88 : : {
89 : 0 : struct key *keyring = info->data;
90 : 0 : key_put(keyring);
91 : 0 : }
92 : :
93 : : /*
94 : : * Call a usermode helper with a specific session keyring.
95 : : */
96 : 0 : static int call_usermodehelper_keys(const char *path, char **argv, char **envp,
97 : : struct key *session_keyring, int wait)
98 : : {
99 : : struct subprocess_info *info;
100 : :
101 : 0 : info = call_usermodehelper_setup(path, argv, envp, GFP_KERNEL,
102 : : umh_keys_init, umh_keys_cleanup,
103 : : session_keyring);
104 [ # # ]: 0 : if (!info)
105 : : return -ENOMEM;
106 : :
107 : : key_get(session_keyring);
108 : 0 : return call_usermodehelper_exec(info, wait);
109 : : }
110 : :
111 : : /*
112 : : * Request userspace finish the construction of a key
113 : : * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
114 : : */
115 : 0 : static int call_sbin_request_key(struct key *authkey, void *aux)
116 : : {
117 : : static char const request_key[] = "/sbin/request-key";
118 : : struct request_key_auth *rka = get_request_key_auth(authkey);
119 : : const struct cred *cred = current_cred();
120 : : key_serial_t prkey, sskey;
121 : 0 : struct key *key = rka->target_key, *keyring, *session, *user_session;
122 : : char *argv[9], *envp[3], uid_str[12], gid_str[12];
123 : : char key_str[12], keyring_str[3][12];
124 : : char desc[20];
125 : : int ret, i;
126 : :
127 : : kenter("{%d},{%d},%s", key->serial, authkey->serial, rka->op);
128 : :
129 : 0 : ret = look_up_user_keyrings(NULL, &user_session);
130 [ # # ]: 0 : if (ret < 0)
131 : : goto error_us;
132 : :
133 : : /* allocate a new session keyring */
134 : 0 : sprintf(desc, "_req.%u", key->serial);
135 : :
136 : 0 : cred = get_current_cred();
137 : 0 : keyring = keyring_alloc(desc, cred->fsuid, cred->fsgid, cred,
138 : : KEY_POS_ALL | KEY_USR_VIEW | KEY_USR_READ,
139 : : KEY_ALLOC_QUOTA_OVERRUN, NULL, NULL);
140 : 0 : put_cred(cred);
141 [ # # ]: 0 : if (IS_ERR(keyring)) {
142 : : ret = PTR_ERR(keyring);
143 : 0 : goto error_alloc;
144 : : }
145 : :
146 : : /* attach the auth key to the session keyring */
147 : 0 : ret = key_link(keyring, authkey);
148 [ # # ]: 0 : if (ret < 0)
149 : : goto error_link;
150 : :
151 : : /* record the UID and GID */
152 : 0 : sprintf(uid_str, "%d", from_kuid(&init_user_ns, cred->fsuid));
153 : 0 : sprintf(gid_str, "%d", from_kgid(&init_user_ns, cred->fsgid));
154 : :
155 : : /* we say which key is under construction */
156 : 0 : sprintf(key_str, "%d", key->serial);
157 : :
158 : : /* we specify the process's default keyrings */
159 [ # # ]: 0 : sprintf(keyring_str[0], "%d",
160 : 0 : cred->thread_keyring ? cred->thread_keyring->serial : 0);
161 : :
162 : : prkey = 0;
163 [ # # ]: 0 : if (cred->process_keyring)
164 : 0 : prkey = cred->process_keyring->serial;
165 : 0 : sprintf(keyring_str[1], "%d", prkey);
166 : :
167 : 0 : session = cred->session_keyring;
168 [ # # ]: 0 : if (!session)
169 : 0 : session = user_session;
170 : 0 : sskey = session->serial;
171 : :
172 : 0 : sprintf(keyring_str[2], "%d", sskey);
173 : :
174 : : /* set up a minimal environment */
175 : : i = 0;
176 : 0 : envp[i++] = "HOME=/";
177 : 0 : envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
178 : 0 : envp[i] = NULL;
179 : :
180 : : /* set up the argument list */
181 : : i = 0;
182 : 0 : argv[i++] = (char *)request_key;
183 : 0 : argv[i++] = (char *)rka->op;
184 : 0 : argv[i++] = key_str;
185 : 0 : argv[i++] = uid_str;
186 : 0 : argv[i++] = gid_str;
187 : 0 : argv[i++] = keyring_str[0];
188 : 0 : argv[i++] = keyring_str[1];
189 : 0 : argv[i++] = keyring_str[2];
190 : 0 : argv[i] = NULL;
191 : :
192 : : /* do it */
193 : 0 : ret = call_usermodehelper_keys(request_key, argv, envp, keyring,
194 : : UMH_WAIT_PROC);
195 : : kdebug("usermode -> 0x%x", ret);
196 [ # # ]: 0 : if (ret >= 0) {
197 : : /* ret is the exit/wait code */
198 [ # # # # ]: 0 : if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags) ||
199 : 0 : key_validate(key) < 0)
200 : : ret = -ENOKEY;
201 : : else
202 : : /* ignore any errors from userspace if the key was
203 : : * instantiated */
204 : : ret = 0;
205 : : }
206 : :
207 : : error_link:
208 : 0 : key_put(keyring);
209 : :
210 : : error_alloc:
211 : 0 : key_put(user_session);
212 : : error_us:
213 : 0 : complete_request_key(authkey, ret);
214 : : kleave(" = %d", ret);
215 : 0 : return ret;
216 : : }
217 : :
218 : : /*
219 : : * Call out to userspace for key construction.
220 : : *
221 : : * Program failure is ignored in favour of key status.
222 : : */
223 : 0 : static int construct_key(struct key *key, const void *callout_info,
224 : : size_t callout_len, void *aux,
225 : : struct key *dest_keyring)
226 : : {
227 : : request_key_actor_t actor;
228 : : struct key *authkey;
229 : : int ret;
230 : :
231 : : kenter("%d,%p,%zu,%p", key->serial, callout_info, callout_len, aux);
232 : :
233 : : /* allocate an authorisation key */
234 : 0 : authkey = request_key_auth_new(key, "create", callout_info, callout_len,
235 : : dest_keyring);
236 [ # # ]: 0 : if (IS_ERR(authkey))
237 : 0 : return PTR_ERR(authkey);
238 : :
239 : : /* Make the call */
240 : : actor = call_sbin_request_key;
241 [ # # ]: 0 : if (key->type->request_key)
242 : : actor = key->type->request_key;
243 : :
244 : 0 : ret = actor(authkey, aux);
245 : :
246 : : /* check that the actor called complete_request_key() prior to
247 : : * returning an error */
248 [ # # # # : 0 : WARN_ON(ret < 0 &&
# # ]
249 : : !test_bit(KEY_FLAG_INVALIDATED, &authkey->flags));
250 : :
251 : 0 : key_put(authkey);
252 : : kleave(" = %d", ret);
253 : 0 : return ret;
254 : : }
255 : :
256 : : /*
257 : : * Get the appropriate destination keyring for the request.
258 : : *
259 : : * The keyring selected is returned with an extra reference upon it which the
260 : : * caller must release.
261 : : */
262 : 0 : static int construct_get_dest_keyring(struct key **_dest_keyring)
263 : : {
264 : : struct request_key_auth *rka;
265 : 0 : const struct cred *cred = current_cred();
266 : 0 : struct key *dest_keyring = *_dest_keyring, *authkey;
267 : : int ret;
268 : :
269 : : kenter("%p", dest_keyring);
270 : :
271 : : /* find the appropriate keyring */
272 [ # # ]: 0 : if (dest_keyring) {
273 : : /* the caller supplied one */
274 : : key_get(dest_keyring);
275 : : } else {
276 : : bool do_perm_check = true;
277 : :
278 : : /* use a default keyring; falling through the cases until we
279 : : * find one that we actually have */
280 [ # # # # : 0 : switch (cred->jit_keyring) {
# # # ]
281 : : case KEY_REQKEY_DEFL_DEFAULT:
282 : : case KEY_REQKEY_DEFL_REQUESTOR_KEYRING:
283 [ # # ]: 0 : if (cred->request_key_auth) {
284 : : authkey = cred->request_key_auth;
285 : 0 : down_read(&authkey->sem);
286 : : rka = get_request_key_auth(authkey);
287 [ # # ]: 0 : if (!test_bit(KEY_FLAG_REVOKED,
288 : : &authkey->flags))
289 : 0 : dest_keyring =
290 : 0 : key_get(rka->dest_keyring);
291 : 0 : up_read(&authkey->sem);
292 [ # # ]: 0 : if (dest_keyring) {
293 : : do_perm_check = false;
294 : : break;
295 : : }
296 : : }
297 : :
298 : : /* fall through */
299 : : case KEY_REQKEY_DEFL_THREAD_KEYRING:
300 : 0 : dest_keyring = key_get(cred->thread_keyring);
301 [ # # ]: 0 : if (dest_keyring)
302 : : break;
303 : :
304 : : /* fall through */
305 : : case KEY_REQKEY_DEFL_PROCESS_KEYRING:
306 : 0 : dest_keyring = key_get(cred->process_keyring);
307 [ # # ]: 0 : if (dest_keyring)
308 : : break;
309 : :
310 : : /* fall through */
311 : : case KEY_REQKEY_DEFL_SESSION_KEYRING:
312 : 0 : dest_keyring = key_get(cred->session_keyring);
313 : :
314 [ # # ]: 0 : if (dest_keyring)
315 : : break;
316 : :
317 : : /* fall through */
318 : : case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
319 : 0 : ret = look_up_user_keyrings(NULL, &dest_keyring);
320 [ # # ]: 0 : if (ret < 0)
321 : : return ret;
322 : : break;
323 : :
324 : : case KEY_REQKEY_DEFL_USER_KEYRING:
325 : 0 : ret = look_up_user_keyrings(&dest_keyring, NULL);
326 [ # # ]: 0 : if (ret < 0)
327 : : return ret;
328 : : break;
329 : :
330 : : case KEY_REQKEY_DEFL_GROUP_KEYRING:
331 : : default:
332 : 0 : BUG();
333 : : }
334 : :
335 : : /*
336 : : * Require Write permission on the keyring. This is essential
337 : : * because the default keyring may be the session keyring, and
338 : : * joining a keyring only requires Search permission.
339 : : *
340 : : * However, this check is skipped for the "requestor keyring" so
341 : : * that /sbin/request-key can itself use request_key() to add
342 : : * keys to the original requestor's destination keyring.
343 : : */
344 [ # # # # ]: 0 : if (dest_keyring && do_perm_check) {
345 : : ret = key_permission(make_key_ref(dest_keyring, 1),
346 : : KEY_NEED_WRITE);
347 [ # # ]: 0 : if (ret) {
348 : 0 : key_put(dest_keyring);
349 : 0 : return ret;
350 : : }
351 : : }
352 : : }
353 : :
354 : 0 : *_dest_keyring = dest_keyring;
355 : : kleave(" [dk %d]", key_serial(dest_keyring));
356 : 0 : return 0;
357 : : }
358 : :
359 : : /*
360 : : * Allocate a new key in under-construction state and attempt to link it in to
361 : : * the requested keyring.
362 : : *
363 : : * May return a key that's already under construction instead if there was a
364 : : * race between two thread calling request_key().
365 : : */
366 : 0 : static int construct_alloc_key(struct keyring_search_context *ctx,
367 : : struct key *dest_keyring,
368 : : unsigned long flags,
369 : : struct key_user *user,
370 : : struct key **_key)
371 : : {
372 : 0 : struct assoc_array_edit *edit = NULL;
373 : : struct key *key;
374 : : key_perm_t perm;
375 : : key_ref_t key_ref;
376 : : int ret;
377 : :
378 : : kenter("%s,%s,,,",
379 : : ctx->index_key.type->name, ctx->index_key.description);
380 : :
381 : 0 : *_key = NULL;
382 : 0 : mutex_lock(&user->cons_lock);
383 : :
384 : : perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
385 : : perm |= KEY_USR_VIEW;
386 [ # # ]: 0 : if (ctx->index_key.type->read)
387 : : perm |= KEY_POS_READ;
388 [ # # # # ]: 0 : if (ctx->index_key.type == &key_type_keyring ||
389 : 0 : ctx->index_key.type->update)
390 : 0 : perm |= KEY_POS_WRITE;
391 : :
392 : 0 : key = key_alloc(ctx->index_key.type, ctx->index_key.description,
393 : : ctx->cred->fsuid, ctx->cred->fsgid, ctx->cred,
394 : : perm, flags, NULL);
395 [ # # ]: 0 : if (IS_ERR(key))
396 : : goto alloc_failed;
397 : :
398 : 0 : set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
399 : :
400 [ # # ]: 0 : if (dest_keyring) {
401 : 0 : ret = __key_link_lock(dest_keyring, &ctx->index_key);
402 [ # # ]: 0 : if (ret < 0)
403 : : goto link_lock_failed;
404 : 0 : ret = __key_link_begin(dest_keyring, &ctx->index_key, &edit);
405 [ # # ]: 0 : if (ret < 0)
406 : : goto link_prealloc_failed;
407 : : }
408 : :
409 : : /* attach the key to the destination keyring under lock, but we do need
410 : : * to do another check just in case someone beat us to it whilst we
411 : : * waited for locks */
412 : 0 : mutex_lock(&key_construction_mutex);
413 : :
414 : : rcu_read_lock();
415 : 0 : key_ref = search_process_keyrings_rcu(ctx);
416 : : rcu_read_unlock();
417 [ # # ]: 0 : if (!IS_ERR(key_ref))
418 : : goto key_already_present;
419 : :
420 [ # # ]: 0 : if (dest_keyring)
421 : 0 : __key_link(key, &edit);
422 : :
423 : 0 : mutex_unlock(&key_construction_mutex);
424 [ # # ]: 0 : if (dest_keyring)
425 : 0 : __key_link_end(dest_keyring, &ctx->index_key, edit);
426 : 0 : mutex_unlock(&user->cons_lock);
427 : 0 : *_key = key;
428 : : kleave(" = 0 [%d]", key_serial(key));
429 : 0 : return 0;
430 : :
431 : : /* the key is now present - we tell the caller that we found it by
432 : : * returning -EINPROGRESS */
433 : : key_already_present:
434 : 0 : key_put(key);
435 : 0 : mutex_unlock(&key_construction_mutex);
436 : : key = key_ref_to_ptr(key_ref);
437 [ # # ]: 0 : if (dest_keyring) {
438 : 0 : ret = __key_link_check_live_key(dest_keyring, key);
439 [ # # ]: 0 : if (ret == 0)
440 : 0 : __key_link(key, &edit);
441 : 0 : __key_link_end(dest_keyring, &ctx->index_key, edit);
442 [ # # ]: 0 : if (ret < 0)
443 : : goto link_check_failed;
444 : : }
445 : 0 : mutex_unlock(&user->cons_lock);
446 : 0 : *_key = key;
447 : : kleave(" = -EINPROGRESS [%d]", key_serial(key));
448 : 0 : return -EINPROGRESS;
449 : :
450 : : link_check_failed:
451 : 0 : mutex_unlock(&user->cons_lock);
452 : 0 : key_put(key);
453 : : kleave(" = %d [linkcheck]", ret);
454 : 0 : return ret;
455 : :
456 : : link_prealloc_failed:
457 : 0 : __key_link_end(dest_keyring, &ctx->index_key, edit);
458 : : link_lock_failed:
459 : 0 : mutex_unlock(&user->cons_lock);
460 : 0 : key_put(key);
461 : : kleave(" = %d [prelink]", ret);
462 : 0 : return ret;
463 : :
464 : : alloc_failed:
465 : 0 : mutex_unlock(&user->cons_lock);
466 : : kleave(" = %ld", PTR_ERR(key));
467 : 0 : return PTR_ERR(key);
468 : : }
469 : :
470 : : /*
471 : : * Commence key construction.
472 : : */
473 : 0 : static struct key *construct_key_and_link(struct keyring_search_context *ctx,
474 : : const char *callout_info,
475 : : size_t callout_len,
476 : : void *aux,
477 : : struct key *dest_keyring,
478 : : unsigned long flags)
479 : : {
480 : : struct key_user *user;
481 : : struct key *key;
482 : : int ret;
483 : :
484 : : kenter("");
485 : :
486 [ # # ]: 0 : if (ctx->index_key.type == &key_type_keyring)
487 : : return ERR_PTR(-EPERM);
488 : :
489 : 0 : ret = construct_get_dest_keyring(&dest_keyring);
490 [ # # ]: 0 : if (ret)
491 : : goto error;
492 : :
493 : 0 : user = key_user_lookup(current_fsuid());
494 [ # # ]: 0 : if (!user) {
495 : : ret = -ENOMEM;
496 : : goto error_put_dest_keyring;
497 : : }
498 : :
499 : 0 : ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key);
500 : 0 : key_user_put(user);
501 : :
502 [ # # ]: 0 : if (ret == 0) {
503 : 0 : ret = construct_key(key, callout_info, callout_len, aux,
504 : : dest_keyring);
505 [ # # ]: 0 : if (ret < 0) {
506 : : kdebug("cons failed");
507 : : goto construction_failed;
508 : : }
509 [ # # ]: 0 : } else if (ret == -EINPROGRESS) {
510 : : ret = 0;
511 : : } else {
512 : : goto error_put_dest_keyring;
513 : : }
514 : :
515 : 0 : key_put(dest_keyring);
516 : : kleave(" = key %d", key_serial(key));
517 : 0 : return key;
518 : :
519 : : construction_failed:
520 : 0 : key_negate_and_link(key, key_negative_timeout, NULL, NULL);
521 : 0 : key_put(key);
522 : : error_put_dest_keyring:
523 : 0 : key_put(dest_keyring);
524 : : error:
525 : : kleave(" = %d", ret);
526 : 0 : return ERR_PTR(ret);
527 : : }
528 : :
529 : : /**
530 : : * request_key_and_link - Request a key and cache it in a keyring.
531 : : * @type: The type of key we want.
532 : : * @description: The searchable description of the key.
533 : : * @domain_tag: The domain in which the key operates.
534 : : * @callout_info: The data to pass to the instantiation upcall (or NULL).
535 : : * @callout_len: The length of callout_info.
536 : : * @aux: Auxiliary data for the upcall.
537 : : * @dest_keyring: Where to cache the key.
538 : : * @flags: Flags to key_alloc().
539 : : *
540 : : * A key matching the specified criteria (type, description, domain_tag) is
541 : : * searched for in the process's keyrings and returned with its usage count
542 : : * incremented if found. Otherwise, if callout_info is not NULL, a key will be
543 : : * allocated and some service (probably in userspace) will be asked to
544 : : * instantiate it.
545 : : *
546 : : * If successfully found or created, the key will be linked to the destination
547 : : * keyring if one is provided.
548 : : *
549 : : * Returns a pointer to the key if successful; -EACCES, -ENOKEY, -EKEYREVOKED
550 : : * or -EKEYEXPIRED if an inaccessible, negative, revoked or expired key was
551 : : * found; -ENOKEY if no key was found and no @callout_info was given; -EDQUOT
552 : : * if insufficient key quota was available to create a new key; or -ENOMEM if
553 : : * insufficient memory was available.
554 : : *
555 : : * If the returned key was created, then it may still be under construction,
556 : : * and wait_for_key_construction() should be used to wait for that to complete.
557 : : */
558 : 0 : struct key *request_key_and_link(struct key_type *type,
559 : : const char *description,
560 : : struct key_tag *domain_tag,
561 : : const void *callout_info,
562 : : size_t callout_len,
563 : : void *aux,
564 : : struct key *dest_keyring,
565 : : unsigned long flags)
566 : : {
567 : 0 : struct keyring_search_context ctx = {
568 : : .index_key.type = type,
569 : : .index_key.domain_tag = domain_tag,
570 : : .index_key.description = description,
571 : 0 : .index_key.desc_len = strlen(description),
572 : 0 : .cred = current_cred(),
573 : : .match_data.cmp = key_default_cmp,
574 : : .match_data.raw_data = description,
575 : : .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT,
576 : : .flags = (KEYRING_SEARCH_DO_STATE_CHECK |
577 : : KEYRING_SEARCH_SKIP_EXPIRED |
578 : : KEYRING_SEARCH_RECURSE),
579 : : };
580 : : struct key *key;
581 : : key_ref_t key_ref;
582 : : int ret;
583 : :
584 : : kenter("%s,%s,%p,%zu,%p,%p,%lx",
585 : : ctx.index_key.type->name, ctx.index_key.description,
586 : : callout_info, callout_len, aux, dest_keyring, flags);
587 : :
588 [ # # ]: 0 : if (type->match_preparse) {
589 : 0 : ret = type->match_preparse(&ctx.match_data);
590 [ # # ]: 0 : if (ret < 0) {
591 : : key = ERR_PTR(ret);
592 : 0 : goto error;
593 : : }
594 : : }
595 : :
596 : : key = check_cached_key(&ctx);
597 : : if (key)
598 : : goto error_free;
599 : :
600 : : /* search all the process keyrings for a key */
601 : : rcu_read_lock();
602 : 0 : key_ref = search_process_keyrings_rcu(&ctx);
603 : : rcu_read_unlock();
604 : :
605 [ # # ]: 0 : if (!IS_ERR(key_ref)) {
606 [ # # ]: 0 : if (dest_keyring) {
607 : 0 : ret = key_task_permission(key_ref, current_cred(),
608 : : KEY_NEED_LINK);
609 [ # # ]: 0 : if (ret < 0) {
610 : : key_ref_put(key_ref);
611 : : key = ERR_PTR(ret);
612 : 0 : goto error_free;
613 : : }
614 : : }
615 : :
616 : : key = key_ref_to_ptr(key_ref);
617 [ # # ]: 0 : if (dest_keyring) {
618 : 0 : ret = key_link(dest_keyring, key);
619 [ # # ]: 0 : if (ret < 0) {
620 : 0 : key_put(key);
621 : : key = ERR_PTR(ret);
622 : 0 : goto error_free;
623 : : }
624 : : }
625 : :
626 : : /* Only cache the key on immediate success */
627 : : cache_requested_key(key);
628 [ # # ]: 0 : } else if (PTR_ERR(key_ref) != -EAGAIN) {
629 : : key = ERR_CAST(key_ref);
630 : : } else {
631 : : /* the search failed, but the keyrings were searchable, so we
632 : : * should consult userspace if we can */
633 : : key = ERR_PTR(-ENOKEY);
634 [ # # ]: 0 : if (!callout_info)
635 : : goto error_free;
636 : :
637 : 0 : key = construct_key_and_link(&ctx, callout_info, callout_len,
638 : : aux, dest_keyring, flags);
639 : : }
640 : :
641 : : error_free:
642 [ # # ]: 0 : if (type->match_free)
643 : 0 : type->match_free(&ctx.match_data);
644 : : error:
645 : : kleave(" = %p", key);
646 : 0 : return key;
647 : : }
648 : :
649 : : /**
650 : : * wait_for_key_construction - Wait for construction of a key to complete
651 : : * @key: The key being waited for.
652 : : * @intr: Whether to wait interruptibly.
653 : : *
654 : : * Wait for a key to finish being constructed.
655 : : *
656 : : * Returns 0 if successful; -ERESTARTSYS if the wait was interrupted; -ENOKEY
657 : : * if the key was negated; or -EKEYREVOKED or -EKEYEXPIRED if the key was
658 : : * revoked or expired.
659 : : */
660 : 15534 : int wait_for_key_construction(struct key *key, bool intr)
661 : : {
662 : : int ret;
663 : :
664 [ - + ]: 15534 : ret = wait_on_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT,
665 : : intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
666 [ + - ]: 15534 : if (ret)
667 : : return -ERESTARTSYS;
668 : 15534 : ret = key_read_state(key);
669 [ + + ]: 15534 : if (ret < 0)
670 : : return ret;
671 : 15533 : return key_validate(key);
672 : : }
673 : : EXPORT_SYMBOL(wait_for_key_construction);
674 : :
675 : : /**
676 : : * request_key_tag - Request a key and wait for construction
677 : : * @type: Type of key.
678 : : * @description: The searchable description of the key.
679 : : * @domain_tag: The domain in which the key operates.
680 : : * @callout_info: The data to pass to the instantiation upcall (or NULL).
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,
684 : : * the callout_info must be a NUL-terminated string and no auxiliary data can
685 : : * be passed.
686 : : *
687 : : * Furthermore, it then works as wait_for_key_construction() to wait for the
688 : : * completion of keys undergoing construction with a non-interruptible wait.
689 : : */
690 : 0 : struct key *request_key_tag(struct key_type *type,
691 : : const char *description,
692 : : struct key_tag *domain_tag,
693 : : const char *callout_info)
694 : : {
695 : : struct key *key;
696 : : size_t callout_len = 0;
697 : : int ret;
698 : :
699 [ # # ]: 0 : if (callout_info)
700 : 0 : callout_len = strlen(callout_info);
701 : 0 : key = request_key_and_link(type, description, domain_tag,
702 : : callout_info, callout_len,
703 : : NULL, NULL, KEY_ALLOC_IN_QUOTA);
704 [ # # ]: 0 : if (!IS_ERR(key)) {
705 : 0 : ret = wait_for_key_construction(key, false);
706 [ # # ]: 0 : if (ret < 0) {
707 : 0 : key_put(key);
708 : 0 : return ERR_PTR(ret);
709 : : }
710 : : }
711 : 0 : return key;
712 : : }
713 : : EXPORT_SYMBOL(request_key_tag);
714 : :
715 : : /**
716 : : * request_key_with_auxdata - Request a key with auxiliary data for the upcaller
717 : : * @type: The type of key we want.
718 : : * @description: The searchable description of the key.
719 : : * @domain_tag: The domain in which the key operates.
720 : : * @callout_info: The data to pass to the instantiation upcall (or NULL).
721 : : * @callout_len: The length of callout_info.
722 : : * @aux: Auxiliary data for the upcall.
723 : : *
724 : : * As for request_key_and_link() except that it does not add the returned key
725 : : * to a keyring if found and new keys are always allocated in the user's quota.
726 : : *
727 : : * Furthermore, it then works as wait_for_key_construction() to wait for the
728 : : * completion of keys undergoing construction with a non-interruptible wait.
729 : : */
730 : 0 : struct key *request_key_with_auxdata(struct key_type *type,
731 : : const char *description,
732 : : struct key_tag *domain_tag,
733 : : const void *callout_info,
734 : : size_t callout_len,
735 : : void *aux)
736 : : {
737 : : struct key *key;
738 : : int ret;
739 : :
740 : 0 : key = request_key_and_link(type, description, domain_tag,
741 : : callout_info, callout_len,
742 : : aux, NULL, KEY_ALLOC_IN_QUOTA);
743 [ # # ]: 0 : if (!IS_ERR(key)) {
744 : 0 : ret = wait_for_key_construction(key, false);
745 [ # # ]: 0 : if (ret < 0) {
746 : 0 : key_put(key);
747 : 0 : return ERR_PTR(ret);
748 : : }
749 : : }
750 : 0 : return key;
751 : : }
752 : : EXPORT_SYMBOL(request_key_with_auxdata);
753 : :
754 : : /**
755 : : * request_key_rcu - Request key from RCU-read-locked context
756 : : * @type: The type of key we want.
757 : : * @description: The name of the key we want.
758 : : * @domain_tag: The domain in which the key operates.
759 : : *
760 : : * Request a key from a context that we may not sleep in (such as RCU-mode
761 : : * pathwalk). Keys under construction are ignored.
762 : : *
763 : : * Return a pointer to the found key if successful, -ENOKEY if we couldn't find
764 : : * a key or some other error if the key found was unsuitable or inaccessible.
765 : : */
766 : 0 : struct key *request_key_rcu(struct key_type *type,
767 : : const char *description,
768 : : struct key_tag *domain_tag)
769 : : {
770 : 0 : struct keyring_search_context ctx = {
771 : : .index_key.type = type,
772 : : .index_key.domain_tag = domain_tag,
773 : : .index_key.description = description,
774 : 0 : .index_key.desc_len = strlen(description),
775 : 0 : .cred = current_cred(),
776 : : .match_data.cmp = key_default_cmp,
777 : : .match_data.raw_data = description,
778 : : .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT,
779 : : .flags = (KEYRING_SEARCH_DO_STATE_CHECK |
780 : : KEYRING_SEARCH_SKIP_EXPIRED),
781 : : };
782 : : struct key *key;
783 : : key_ref_t key_ref;
784 : :
785 : : kenter("%s,%s", type->name, description);
786 : :
787 : : key = check_cached_key(&ctx);
788 : : if (key)
789 : : return key;
790 : :
791 : : /* search all the process keyrings for a key */
792 : 0 : key_ref = search_process_keyrings_rcu(&ctx);
793 [ # # ]: 0 : if (IS_ERR(key_ref)) {
794 : : key = ERR_CAST(key_ref);
795 [ # # ]: 0 : if (PTR_ERR(key_ref) == -EAGAIN)
796 : : key = ERR_PTR(-ENOKEY);
797 : : } else {
798 : : key = key_ref_to_ptr(key_ref);
799 : : cache_requested_key(key);
800 : : }
801 : :
802 : : kleave(" = %p", key);
803 : : return key;
804 : : }
805 : : EXPORT_SYMBOL(request_key_rcu);
|
