1 /* Request a key from userspace
3 * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
11 * See Documentation/keys-request-key.txt
14 #include <linux/module.h>
15 #include <linux/sched.h>
16 #include <linux/kmod.h>
17 #include <linux/err.h>
18 #include <linux/keyctl.h>
19 #include <linux/slab.h>
22 #define key_negative_timeout 60 /* default timeout on a negative key's existence */
25 * wait_on_bit() sleep function for uninterruptible waiting
27 static int key_wait_bit(void *flags
)
34 * wait_on_bit() sleep function for interruptible waiting
36 static int key_wait_bit_intr(void *flags
)
39 return signal_pending(current
) ? -ERESTARTSYS
: 0;
43 * call to complete the construction of a key
45 void complete_request_key(struct key_construction
*cons
, int error
)
47 kenter("{%d,%d},%d", cons
->key
->serial
, cons
->authkey
->serial
, error
);
50 key_negate_and_link(cons
->key
, key_negative_timeout
, NULL
,
53 key_revoke(cons
->authkey
);
56 key_put(cons
->authkey
);
59 EXPORT_SYMBOL(complete_request_key
);
61 static int umh_keys_init(struct subprocess_info
*info
)
63 struct cred
*cred
= (struct cred
*)current_cred();
64 struct key
*keyring
= info
->data
;
66 * This is called in context of freshly forked kthread before
67 * kernel_execve(), we can just change our ->session_keyring.
69 return install_session_keyring_to_cred(cred
, keyring
);
72 static void umh_keys_cleanup(struct subprocess_info
*info
)
74 struct key
*keyring
= info
->data
;
78 static int call_usermodehelper_keys(char *path
, char **argv
, char **envp
,
79 struct key
*session_keyring
, enum umh_wait wait
)
81 gfp_t gfp_mask
= (wait
== UMH_NO_WAIT
) ? GFP_ATOMIC
: GFP_KERNEL
;
82 struct subprocess_info
*info
=
83 call_usermodehelper_setup(path
, argv
, envp
, gfp_mask
);
88 call_usermodehelper_setfns(info
, umh_keys_init
, umh_keys_cleanup
,
89 key_get(session_keyring
));
90 return call_usermodehelper_exec(info
, wait
);
94 * request userspace finish the construction of a key
95 * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
97 static int call_sbin_request_key(struct key_construction
*cons
,
101 const struct cred
*cred
= current_cred();
102 key_serial_t prkey
, sskey
;
103 struct key
*key
= cons
->key
, *authkey
= cons
->authkey
, *keyring
,
105 char *argv
[9], *envp
[3], uid_str
[12], gid_str
[12];
106 char key_str
[12], keyring_str
[3][12];
110 kenter("{%d},{%d},%s", key
->serial
, authkey
->serial
, op
);
112 ret
= install_user_keyrings();
116 /* allocate a new session keyring */
117 sprintf(desc
, "_req.%u", key
->serial
);
119 cred
= get_current_cred();
120 keyring
= keyring_alloc(desc
, cred
->fsuid
, cred
->fsgid
, cred
,
121 KEY_ALLOC_QUOTA_OVERRUN
, NULL
);
123 if (IS_ERR(keyring
)) {
124 ret
= PTR_ERR(keyring
);
128 /* attach the auth key to the session keyring */
129 ret
= key_link(keyring
, authkey
);
133 /* record the UID and GID */
134 sprintf(uid_str
, "%d", cred
->fsuid
);
135 sprintf(gid_str
, "%d", cred
->fsgid
);
137 /* we say which key is under construction */
138 sprintf(key_str
, "%d", key
->serial
);
140 /* we specify the process's default keyrings */
141 sprintf(keyring_str
[0], "%d",
142 cred
->thread_keyring
? cred
->thread_keyring
->serial
: 0);
145 if (cred
->tgcred
->process_keyring
)
146 prkey
= cred
->tgcred
->process_keyring
->serial
;
149 session
= rcu_dereference(cred
->tgcred
->session_keyring
);
151 session
= cred
->user
->session_keyring
;
152 sskey
= session
->serial
;
155 sprintf(keyring_str
[2], "%d", sskey
);
157 /* set up a minimal environment */
159 envp
[i
++] = "HOME=/";
160 envp
[i
++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
163 /* set up the argument list */
165 argv
[i
++] = "/sbin/request-key";
166 argv
[i
++] = (char *) op
;
170 argv
[i
++] = keyring_str
[0];
171 argv
[i
++] = keyring_str
[1];
172 argv
[i
++] = keyring_str
[2];
176 ret
= call_usermodehelper_keys(argv
[0], argv
, envp
, keyring
,
178 kdebug("usermode -> 0x%x", ret
);
180 /* ret is the exit/wait code */
181 if (test_bit(KEY_FLAG_USER_CONSTRUCT
, &key
->flags
) ||
182 key_validate(key
) < 0)
185 /* ignore any errors from userspace if the key was
194 complete_request_key(cons
, ret
);
195 kleave(" = %d", ret
);
200 * call out to userspace for key construction
201 * - we ignore program failure and go on key status instead
203 static int construct_key(struct key
*key
, const void *callout_info
,
204 size_t callout_len
, void *aux
,
205 struct key
*dest_keyring
)
207 struct key_construction
*cons
;
208 request_key_actor_t actor
;
212 kenter("%d,%p,%zu,%p", key
->serial
, callout_info
, callout_len
, aux
);
214 cons
= kmalloc(sizeof(*cons
), GFP_KERNEL
);
218 /* allocate an authorisation key */
219 authkey
= request_key_auth_new(key
, callout_info
, callout_len
,
221 if (IS_ERR(authkey
)) {
223 ret
= PTR_ERR(authkey
);
226 cons
->authkey
= key_get(authkey
);
227 cons
->key
= key_get(key
);
230 actor
= call_sbin_request_key
;
231 if (key
->type
->request_key
)
232 actor
= key
->type
->request_key
;
234 ret
= actor(cons
, "create", aux
);
236 /* check that the actor called complete_request_key() prior to
237 * returning an error */
239 !test_bit(KEY_FLAG_REVOKED
, &authkey
->flags
));
243 kleave(" = %d", ret
);
248 * get the appropriate destination keyring for the request
249 * - we return whatever keyring we select with an extra reference upon it which
250 * the caller must release
252 static void construct_get_dest_keyring(struct key
**_dest_keyring
)
254 struct request_key_auth
*rka
;
255 const struct cred
*cred
= current_cred();
256 struct key
*dest_keyring
= *_dest_keyring
, *authkey
;
258 kenter("%p", dest_keyring
);
260 /* find the appropriate keyring */
262 /* the caller supplied one */
263 key_get(dest_keyring
);
265 /* use a default keyring; falling through the cases until we
266 * find one that we actually have */
267 switch (cred
->jit_keyring
) {
268 case KEY_REQKEY_DEFL_DEFAULT
:
269 case KEY_REQKEY_DEFL_REQUESTOR_KEYRING
:
270 if (cred
->request_key_auth
) {
271 authkey
= cred
->request_key_auth
;
272 down_read(&authkey
->sem
);
273 rka
= authkey
->payload
.data
;
274 if (!test_bit(KEY_FLAG_REVOKED
,
277 key_get(rka
->dest_keyring
);
278 up_read(&authkey
->sem
);
283 case KEY_REQKEY_DEFL_THREAD_KEYRING
:
284 dest_keyring
= key_get(cred
->thread_keyring
);
288 case KEY_REQKEY_DEFL_PROCESS_KEYRING
:
289 dest_keyring
= key_get(cred
->tgcred
->process_keyring
);
293 case KEY_REQKEY_DEFL_SESSION_KEYRING
:
295 dest_keyring
= key_get(
296 rcu_dereference(cred
->tgcred
->session_keyring
));
302 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING
:
304 key_get(cred
->user
->session_keyring
);
307 case KEY_REQKEY_DEFL_USER_KEYRING
:
308 dest_keyring
= key_get(cred
->user
->uid_keyring
);
311 case KEY_REQKEY_DEFL_GROUP_KEYRING
:
317 *_dest_keyring
= dest_keyring
;
318 kleave(" [dk %d]", key_serial(dest_keyring
));
323 * allocate a new key in under-construction state and attempt to link it in to
324 * the requested place
325 * - may return a key that's already under construction instead
327 static int construct_alloc_key(struct key_type
*type
,
328 const char *description
,
329 struct key
*dest_keyring
,
331 struct key_user
*user
,
334 struct keyring_list
*prealloc
;
335 const struct cred
*cred
= current_cred();
340 kenter("%s,%s,,,", type
->name
, description
);
343 mutex_lock(&user
->cons_lock
);
345 key
= key_alloc(type
, description
, cred
->fsuid
, cred
->fsgid
, cred
,
350 set_bit(KEY_FLAG_USER_CONSTRUCT
, &key
->flags
);
353 ret
= __key_link_begin(dest_keyring
, type
, description
,
356 goto link_prealloc_failed
;
359 /* attach the key to the destination keyring under lock, but we do need
360 * to do another check just in case someone beat us to it whilst we
361 * waited for locks */
362 mutex_lock(&key_construction_mutex
);
364 key_ref
= search_process_keyrings(type
, description
, type
->match
, cred
);
365 if (!IS_ERR(key_ref
))
366 goto key_already_present
;
369 __key_link(dest_keyring
, key
, &prealloc
);
371 mutex_unlock(&key_construction_mutex
);
373 __key_link_end(dest_keyring
, type
, prealloc
);
374 mutex_unlock(&user
->cons_lock
);
376 kleave(" = 0 [%d]", key_serial(key
));
379 /* the key is now present - we tell the caller that we found it by
380 * returning -EINPROGRESS */
383 mutex_unlock(&key_construction_mutex
);
384 key
= key_ref_to_ptr(key_ref
);
386 ret
= __key_link_check_live_key(dest_keyring
, key
);
388 __key_link(dest_keyring
, key
, &prealloc
);
389 __key_link_end(dest_keyring
, type
, prealloc
);
391 goto link_check_failed
;
393 mutex_unlock(&user
->cons_lock
);
395 kleave(" = -EINPROGRESS [%d]", key_serial(key
));
399 mutex_unlock(&user
->cons_lock
);
401 kleave(" = %d [linkcheck]", ret
);
404 link_prealloc_failed
:
405 up_write(&dest_keyring
->sem
);
406 mutex_unlock(&user
->cons_lock
);
407 kleave(" = %d [prelink]", ret
);
411 mutex_unlock(&user
->cons_lock
);
412 kleave(" = %ld", PTR_ERR(key
));
417 * commence key construction
419 static struct key
*construct_key_and_link(struct key_type
*type
,
420 const char *description
,
421 const char *callout_info
,
424 struct key
*dest_keyring
,
427 struct key_user
*user
;
433 user
= key_user_lookup(current_fsuid(), current_user_ns());
435 return ERR_PTR(-ENOMEM
);
437 construct_get_dest_keyring(&dest_keyring
);
439 ret
= construct_alloc_key(type
, description
, dest_keyring
, flags
, user
,
444 ret
= construct_key(key
, callout_info
, callout_len
, aux
,
447 kdebug("cons failed");
448 goto construction_failed
;
450 } else if (ret
== -EINPROGRESS
) {
456 key_put(dest_keyring
);
457 kleave(" = key %d", key_serial(key
));
461 key_negate_and_link(key
, key_negative_timeout
, NULL
, NULL
);
463 key_put(dest_keyring
);
464 kleave(" = %d", ret
);
470 * - search the process's keyrings
471 * - check the list of keys being created or updated
472 * - call out to userspace for a key if supplementary info was provided
473 * - cache the key in an appropriate keyring
475 struct key
*request_key_and_link(struct key_type
*type
,
476 const char *description
,
477 const void *callout_info
,
480 struct key
*dest_keyring
,
483 const struct cred
*cred
= current_cred();
488 kenter("%s,%s,%p,%zu,%p,%p,%lx",
489 type
->name
, description
, callout_info
, callout_len
, aux
,
490 dest_keyring
, flags
);
492 /* search all the process keyrings for a key */
493 key_ref
= search_process_keyrings(type
, description
, type
->match
,
496 if (!IS_ERR(key_ref
)) {
497 key
= key_ref_to_ptr(key_ref
);
499 construct_get_dest_keyring(&dest_keyring
);
500 ret
= key_link(dest_keyring
, key
);
501 key_put(dest_keyring
);
508 } else if (PTR_ERR(key_ref
) != -EAGAIN
) {
509 key
= ERR_CAST(key_ref
);
511 /* the search failed, but the keyrings were searchable, so we
512 * should consult userspace if we can */
513 key
= ERR_PTR(-ENOKEY
);
517 key
= construct_key_and_link(type
, description
, callout_info
,
518 callout_len
, aux
, dest_keyring
,
523 kleave(" = %p", key
);
528 * wait for construction of a key to complete
530 int wait_for_key_construction(struct key
*key
, bool intr
)
534 ret
= wait_on_bit(&key
->flags
, KEY_FLAG_USER_CONSTRUCT
,
535 intr
? key_wait_bit_intr
: key_wait_bit
,
536 intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
539 return key_validate(key
);
541 EXPORT_SYMBOL(wait_for_key_construction
);
545 * - search the process's keyrings
546 * - check the list of keys being created or updated
547 * - call out to userspace for a key if supplementary info was provided
548 * - waits uninterruptible for creation to complete
550 struct key
*request_key(struct key_type
*type
,
551 const char *description
,
552 const char *callout_info
)
555 size_t callout_len
= 0;
559 callout_len
= strlen(callout_info
);
560 key
= request_key_and_link(type
, description
, callout_info
, callout_len
,
561 NULL
, NULL
, KEY_ALLOC_IN_QUOTA
);
563 ret
= wait_for_key_construction(key
, false);
571 EXPORT_SYMBOL(request_key
);
574 * request a key with auxiliary data for the upcaller
575 * - search the process's keyrings
576 * - check the list of keys being created or updated
577 * - call out to userspace for a key if supplementary info was provided
578 * - waits uninterruptible for creation to complete
580 struct key
*request_key_with_auxdata(struct key_type
*type
,
581 const char *description
,
582 const void *callout_info
,
589 key
= request_key_and_link(type
, description
, callout_info
, callout_len
,
590 aux
, NULL
, KEY_ALLOC_IN_QUOTA
);
592 ret
= wait_for_key_construction(key
, false);
600 EXPORT_SYMBOL(request_key_with_auxdata
);
603 * request a key (allow async construction)
604 * - search the process's keyrings
605 * - check the list of keys being created or updated
606 * - call out to userspace for a key if supplementary info was provided
608 struct key
*request_key_async(struct key_type
*type
,
609 const char *description
,
610 const void *callout_info
,
613 return request_key_and_link(type
, description
, callout_info
,
614 callout_len
, NULL
, NULL
,
617 EXPORT_SYMBOL(request_key_async
);
620 * request a key with auxiliary data for the upcaller (allow async construction)
621 * - search the process's keyrings
622 * - check the list of keys being created or updated
623 * - call out to userspace for a key if supplementary info was provided
625 struct key
*request_key_async_with_auxdata(struct key_type
*type
,
626 const char *description
,
627 const void *callout_info
,
631 return request_key_and_link(type
, description
, callout_info
,
632 callout_len
, aux
, NULL
, KEY_ALLOC_IN_QUOTA
);
634 EXPORT_SYMBOL(request_key_async_with_auxdata
);