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
);
62 * request userspace finish the construction of a key
63 * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
65 static int call_sbin_request_key(struct key_construction
*cons
,
69 struct task_struct
*tsk
= current
;
70 const struct cred
*cred
= current_cred();
71 key_serial_t prkey
, sskey
;
72 struct key
*key
= cons
->key
, *authkey
= cons
->authkey
, *keyring
;
73 char *argv
[9], *envp
[3], uid_str
[12], gid_str
[12];
74 char key_str
[12], keyring_str
[3][12];
78 kenter("{%d},{%d},%s", key
->serial
, authkey
->serial
, op
);
80 ret
= install_user_keyrings();
84 /* allocate a new session keyring */
85 sprintf(desc
, "_req.%u", key
->serial
);
87 keyring
= keyring_alloc(desc
, current_fsuid(), current_fsgid(), current
,
88 KEY_ALLOC_QUOTA_OVERRUN
, NULL
);
89 if (IS_ERR(keyring
)) {
90 ret
= PTR_ERR(keyring
);
94 /* attach the auth key to the session keyring */
95 ret
= __key_link(keyring
, authkey
);
99 /* record the UID and GID */
100 sprintf(uid_str
, "%d", cred
->fsuid
);
101 sprintf(gid_str
, "%d", cred
->fsgid
);
103 /* we say which key is under construction */
104 sprintf(key_str
, "%d", key
->serial
);
106 /* we specify the process's default keyrings */
107 sprintf(keyring_str
[0], "%d",
108 cred
->thread_keyring
?
109 cred
->thread_keyring
->serial
: 0);
112 if (tsk
->signal
->process_keyring
)
113 prkey
= tsk
->signal
->process_keyring
->serial
;
115 sprintf(keyring_str
[1], "%d", prkey
);
117 if (tsk
->signal
->session_keyring
) {
119 sskey
= rcu_dereference(tsk
->signal
->session_keyring
)->serial
;
122 sskey
= cred
->user
->session_keyring
->serial
;
125 sprintf(keyring_str
[2], "%d", sskey
);
127 /* set up a minimal environment */
129 envp
[i
++] = "HOME=/";
130 envp
[i
++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
133 /* set up the argument list */
135 argv
[i
++] = "/sbin/request-key";
136 argv
[i
++] = (char *) op
;
140 argv
[i
++] = keyring_str
[0];
141 argv
[i
++] = keyring_str
[1];
142 argv
[i
++] = keyring_str
[2];
146 ret
= call_usermodehelper_keys(argv
[0], argv
, envp
, keyring
,
148 kdebug("usermode -> 0x%x", ret
);
150 /* ret is the exit/wait code */
151 if (test_bit(KEY_FLAG_USER_CONSTRUCT
, &key
->flags
) ||
152 key_validate(key
) < 0)
155 /* ignore any errors from userspace if the key was
164 kleave(" = %d", ret
);
165 complete_request_key(cons
, ret
);
170 * call out to userspace for key construction
171 * - we ignore program failure and go on key status instead
173 static int construct_key(struct key
*key
, const void *callout_info
,
174 size_t callout_len
, void *aux
,
175 struct key
*dest_keyring
)
177 struct key_construction
*cons
;
178 request_key_actor_t actor
;
182 kenter("%d,%p,%zu,%p", key
->serial
, callout_info
, callout_len
, aux
);
184 cons
= kmalloc(sizeof(*cons
), GFP_KERNEL
);
188 /* allocate an authorisation key */
189 authkey
= request_key_auth_new(key
, callout_info
, callout_len
,
191 if (IS_ERR(authkey
)) {
193 ret
= PTR_ERR(authkey
);
196 cons
->authkey
= key_get(authkey
);
197 cons
->key
= key_get(key
);
200 actor
= call_sbin_request_key
;
201 if (key
->type
->request_key
)
202 actor
= key
->type
->request_key
;
204 ret
= actor(cons
, "create", aux
);
206 /* check that the actor called complete_request_key() prior to
207 * returning an error */
209 !test_bit(KEY_FLAG_REVOKED
, &authkey
->flags
));
213 kleave(" = %d", ret
);
218 * get the appropriate destination keyring for the request
219 * - we return whatever keyring we select with an extra reference upon it which
220 * the caller must release
222 static void construct_get_dest_keyring(struct key
**_dest_keyring
)
224 struct request_key_auth
*rka
;
225 struct task_struct
*tsk
= current
;
226 struct key
*dest_keyring
= *_dest_keyring
, *authkey
;
228 kenter("%p", dest_keyring
);
230 /* find the appropriate keyring */
232 /* the caller supplied one */
233 key_get(dest_keyring
);
235 /* use a default keyring; falling through the cases until we
236 * find one that we actually have */
237 switch (tsk
->cred
->jit_keyring
) {
238 case KEY_REQKEY_DEFL_DEFAULT
:
239 case KEY_REQKEY_DEFL_REQUESTOR_KEYRING
:
240 if (tsk
->cred
->request_key_auth
) {
241 authkey
= tsk
->cred
->request_key_auth
;
242 down_read(&authkey
->sem
);
243 rka
= authkey
->payload
.data
;
244 if (!test_bit(KEY_FLAG_REVOKED
,
247 key_get(rka
->dest_keyring
);
248 up_read(&authkey
->sem
);
253 case KEY_REQKEY_DEFL_THREAD_KEYRING
:
254 dest_keyring
= key_get(tsk
->cred
->thread_keyring
);
258 case KEY_REQKEY_DEFL_PROCESS_KEYRING
:
259 dest_keyring
= key_get(tsk
->signal
->process_keyring
);
263 case KEY_REQKEY_DEFL_SESSION_KEYRING
:
265 dest_keyring
= key_get(
266 rcu_dereference(tsk
->signal
->session_keyring
));
272 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING
:
274 key_get(tsk
->cred
->user
->session_keyring
);
277 case KEY_REQKEY_DEFL_USER_KEYRING
:
278 dest_keyring
= key_get(tsk
->cred
->user
->uid_keyring
);
281 case KEY_REQKEY_DEFL_GROUP_KEYRING
:
287 *_dest_keyring
= dest_keyring
;
288 kleave(" [dk %d]", key_serial(dest_keyring
));
293 * allocate a new key in under-construction state and attempt to link it in to
294 * the requested place
295 * - may return a key that's already under construction instead
297 static int construct_alloc_key(struct key_type
*type
,
298 const char *description
,
299 struct key
*dest_keyring
,
301 struct key_user
*user
,
307 kenter("%s,%s,,,", type
->name
, description
);
309 mutex_lock(&user
->cons_lock
);
311 key
= key_alloc(type
, description
,
312 current_fsuid(), current_fsgid(), current
, KEY_POS_ALL
,
317 set_bit(KEY_FLAG_USER_CONSTRUCT
, &key
->flags
);
319 down_write(&dest_keyring
->sem
);
321 /* attach the key to the destination keyring under lock, but we do need
322 * to do another check just in case someone beat us to it whilst we
323 * waited for locks */
324 mutex_lock(&key_construction_mutex
);
326 key_ref
= search_process_keyrings(type
, description
, type
->match
,
328 if (!IS_ERR(key_ref
))
329 goto key_already_present
;
331 __key_link(dest_keyring
, key
);
333 mutex_unlock(&key_construction_mutex
);
334 up_write(&dest_keyring
->sem
);
335 mutex_unlock(&user
->cons_lock
);
337 kleave(" = 0 [%d]", key_serial(key
));
341 mutex_unlock(&key_construction_mutex
);
343 up_write(&dest_keyring
->sem
);
344 mutex_unlock(&user
->cons_lock
);
346 *_key
= key
= key_ref_to_ptr(key_ref
);
347 kleave(" = -EINPROGRESS [%d]", key_serial(key
));
351 mutex_unlock(&user
->cons_lock
);
353 kleave(" = %ld", PTR_ERR(key
));
358 * commence key construction
360 static struct key
*construct_key_and_link(struct key_type
*type
,
361 const char *description
,
362 const char *callout_info
,
365 struct key
*dest_keyring
,
368 struct key_user
*user
;
372 user
= key_user_lookup(current_fsuid());
374 return ERR_PTR(-ENOMEM
);
376 construct_get_dest_keyring(&dest_keyring
);
378 ret
= construct_alloc_key(type
, description
, dest_keyring
, flags
, user
,
383 ret
= construct_key(key
, callout_info
, callout_len
, aux
,
386 goto construction_failed
;
389 key_put(dest_keyring
);
393 key_negate_and_link(key
, key_negative_timeout
, NULL
, NULL
);
395 key_put(dest_keyring
);
401 * - search the process's keyrings
402 * - check the list of keys being created or updated
403 * - call out to userspace for a key if supplementary info was provided
404 * - cache the key in an appropriate keyring
406 struct key
*request_key_and_link(struct key_type
*type
,
407 const char *description
,
408 const void *callout_info
,
411 struct key
*dest_keyring
,
417 kenter("%s,%s,%p,%zu,%p,%p,%lx",
418 type
->name
, description
, callout_info
, callout_len
, aux
,
419 dest_keyring
, flags
);
421 /* search all the process keyrings for a key */
422 key_ref
= search_process_keyrings(type
, description
, type
->match
,
425 if (!IS_ERR(key_ref
)) {
426 key
= key_ref_to_ptr(key_ref
);
427 } else if (PTR_ERR(key_ref
) != -EAGAIN
) {
428 key
= ERR_CAST(key_ref
);
430 /* the search failed, but the keyrings were searchable, so we
431 * should consult userspace if we can */
432 key
= ERR_PTR(-ENOKEY
);
436 key
= construct_key_and_link(type
, description
, callout_info
,
437 callout_len
, aux
, dest_keyring
,
442 kleave(" = %p", key
);
447 * wait for construction of a key to complete
449 int wait_for_key_construction(struct key
*key
, bool intr
)
453 ret
= wait_on_bit(&key
->flags
, KEY_FLAG_USER_CONSTRUCT
,
454 intr
? key_wait_bit_intr
: key_wait_bit
,
455 intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
458 return key_validate(key
);
460 EXPORT_SYMBOL(wait_for_key_construction
);
464 * - search the process's keyrings
465 * - check the list of keys being created or updated
466 * - call out to userspace for a key if supplementary info was provided
467 * - waits uninterruptible for creation to complete
469 struct key
*request_key(struct key_type
*type
,
470 const char *description
,
471 const char *callout_info
)
474 size_t callout_len
= 0;
478 callout_len
= strlen(callout_info
);
479 key
= request_key_and_link(type
, description
, callout_info
, callout_len
,
480 NULL
, NULL
, KEY_ALLOC_IN_QUOTA
);
482 ret
= wait_for_key_construction(key
, false);
490 EXPORT_SYMBOL(request_key
);
493 * request a key with auxiliary data for the upcaller
494 * - search the process's keyrings
495 * - check the list of keys being created or updated
496 * - call out to userspace for a key if supplementary info was provided
497 * - waits uninterruptible for creation to complete
499 struct key
*request_key_with_auxdata(struct key_type
*type
,
500 const char *description
,
501 const void *callout_info
,
508 key
= request_key_and_link(type
, description
, callout_info
, callout_len
,
509 aux
, NULL
, KEY_ALLOC_IN_QUOTA
);
511 ret
= wait_for_key_construction(key
, false);
519 EXPORT_SYMBOL(request_key_with_auxdata
);
522 * request a key (allow async construction)
523 * - search the process's keyrings
524 * - check the list of keys being created or updated
525 * - call out to userspace for a key if supplementary info was provided
527 struct key
*request_key_async(struct key_type
*type
,
528 const char *description
,
529 const void *callout_info
,
532 return request_key_and_link(type
, description
, callout_info
,
533 callout_len
, NULL
, NULL
,
536 EXPORT_SYMBOL(request_key_async
);
539 * request a key with auxiliary data for the upcaller (allow async construction)
540 * - search the process's keyrings
541 * - check the list of keys being created or updated
542 * - call out to userspace for a key if supplementary info was provided
544 struct key
*request_key_async_with_auxdata(struct key_type
*type
,
545 const char *description
,
546 const void *callout_info
,
550 return request_key_and_link(type
, description
, callout_info
,
551 callout_len
, aux
, NULL
, KEY_ALLOC_IN_QUOTA
);
553 EXPORT_SYMBOL(request_key_async_with_auxdata
);