blob: 557500110a13ccd319515a8f96a6d44bc9e13667 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* request_key.c: request a key from userspace
2 *
David Howells4e54f082006-06-29 02:24:28 -07003 * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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 Howellsf1a9bad2005-10-07 15:04:52 +010010 *
11 * See Documentation/keys-request-key.txt
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 */
13
14#include <linux/module.h>
15#include <linux/sched.h>
16#include <linux/kmod.h>
17#include <linux/err.h>
David Howells3e301482005-06-23 22:00:56 -070018#include <linux/keyctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "internal.h"
20
21struct key_construction {
22 struct list_head link; /* link in construction queue */
23 struct key *key; /* key being constructed */
24};
25
26/* when waiting for someone else's keys, you get added to this */
27DECLARE_WAIT_QUEUE_HEAD(request_key_conswq);
28
29/*****************************************************************************/
30/*
31 * request userspace finish the construction of a key
David Howellsb5f545c2006-01-08 01:02:47 -080032 * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 */
David Howellsb5f545c2006-01-08 01:02:47 -080034static int call_sbin_request_key(struct key *key,
35 struct key *authkey,
David Howells4e54f082006-06-29 02:24:28 -070036 const char *op,
37 void *aux)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
39 struct task_struct *tsk = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 key_serial_t prkey, sskey;
David Howellsb5f545c2006-01-08 01:02:47 -080041 struct key *keyring;
42 char *argv[9], *envp[3], uid_str[12], gid_str[12];
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 char key_str[12], keyring_str[3][12];
David Howellsb5f545c2006-01-08 01:02:47 -080044 char desc[20];
David Howells3e301482005-06-23 22:00:56 -070045 int ret, i;
46
David Howellsb5f545c2006-01-08 01:02:47 -080047 kenter("{%d},{%d},%s", key->serial, authkey->serial, op);
David Howells3e301482005-06-23 22:00:56 -070048
David Howellsb5f545c2006-01-08 01:02:47 -080049 /* allocate a new session keyring */
50 sprintf(desc, "_req.%u", key->serial);
51
David Howells7e047ef2006-06-26 00:24:50 -070052 keyring = keyring_alloc(desc, current->fsuid, current->fsgid, current,
53 KEY_ALLOC_QUOTA_OVERRUN, NULL);
David Howellsb5f545c2006-01-08 01:02:47 -080054 if (IS_ERR(keyring)) {
55 ret = PTR_ERR(keyring);
56 goto error_alloc;
David Howells3e301482005-06-23 22:00:56 -070057 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
David Howellsb5f545c2006-01-08 01:02:47 -080059 /* attach the auth key to the session keyring */
60 ret = __key_link(keyring, authkey);
61 if (ret < 0)
62 goto error_link;
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 /* record the UID and GID */
65 sprintf(uid_str, "%d", current->fsuid);
66 sprintf(gid_str, "%d", current->fsgid);
67
68 /* we say which key is under construction */
69 sprintf(key_str, "%d", key->serial);
70
71 /* we specify the process's default keyrings */
72 sprintf(keyring_str[0], "%d",
73 tsk->thread_keyring ? tsk->thread_keyring->serial : 0);
74
75 prkey = 0;
76 if (tsk->signal->process_keyring)
77 prkey = tsk->signal->process_keyring->serial;
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 sprintf(keyring_str[1], "%d", prkey);
David Howells3e301482005-06-23 22:00:56 -070080
81 if (tsk->signal->session_keyring) {
82 rcu_read_lock();
83 sskey = rcu_dereference(tsk->signal->session_keyring)->serial;
84 rcu_read_unlock();
85 }
86 else {
87 sskey = tsk->user->session_keyring->serial;
88 }
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 sprintf(keyring_str[2], "%d", sskey);
91
92 /* set up a minimal environment */
93 i = 0;
94 envp[i++] = "HOME=/";
95 envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
96 envp[i] = NULL;
97
98 /* set up the argument list */
99 i = 0;
100 argv[i++] = "/sbin/request-key";
101 argv[i++] = (char *) op;
102 argv[i++] = key_str;
103 argv[i++] = uid_str;
104 argv[i++] = gid_str;
105 argv[i++] = keyring_str[0];
106 argv[i++] = keyring_str[1];
107 argv[i++] = keyring_str[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 argv[i] = NULL;
109
110 /* do it */
Jeremy Fitzhardinge86313c42007-07-17 18:37:03 -0700111 ret = call_usermodehelper_keys(argv[0], argv, envp, keyring,
112 UMH_WAIT_PROC);
David Howells3e301482005-06-23 22:00:56 -0700113
David Howellsb5f545c2006-01-08 01:02:47 -0800114error_link:
115 key_put(keyring);
David Howells3e301482005-06-23 22:00:56 -0700116
David Howellsb5f545c2006-01-08 01:02:47 -0800117error_alloc:
David Howells3e301482005-06-23 22:00:56 -0700118 kleave(" = %d", ret);
119 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
David Howellsb5f545c2006-01-08 01:02:47 -0800121} /* end call_sbin_request_key() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
123/*****************************************************************************/
124/*
125 * call out to userspace for the key
126 * - called with the construction sem held, but the sem is dropped here
127 * - we ignore program failure and go on key status instead
128 */
129static struct key *__request_key_construction(struct key_type *type,
130 const char *description,
David Howells7e047ef2006-06-26 00:24:50 -0700131 const char *callout_info,
David Howells4e54f082006-06-29 02:24:28 -0700132 void *aux,
David Howells7e047ef2006-06-26 00:24:50 -0700133 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
David Howellsb5f545c2006-01-08 01:02:47 -0800135 request_key_actor_t actor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 struct key_construction cons;
137 struct timespec now;
David Howellsb5f545c2006-01-08 01:02:47 -0800138 struct key *key, *authkey;
David Howells76d8aea2005-06-23 22:00:49 -0700139 int ret, negated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
David Howells7e047ef2006-06-26 00:24:50 -0700141 kenter("%s,%s,%s,%lx", type->name, description, callout_info, flags);
David Howells3e301482005-06-23 22:00:56 -0700142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 /* create a key and add it to the queue */
144 key = key_alloc(type, description,
David Howells7e047ef2006-06-26 00:24:50 -0700145 current->fsuid, current->fsgid, current, KEY_POS_ALL,
146 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 if (IS_ERR(key))
148 goto alloc_failed;
149
David Howells76d8aea2005-06-23 22:00:49 -0700150 set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 cons.key = key;
153 list_add_tail(&cons.link, &key->user->consq);
154
155 /* we drop the construction sem here on behalf of the caller */
156 up_write(&key_construction_sem);
157
David Howellsb5f545c2006-01-08 01:02:47 -0800158 /* allocate an authorisation key */
159 authkey = request_key_auth_new(key, callout_info);
160 if (IS_ERR(authkey)) {
161 ret = PTR_ERR(authkey);
162 authkey = NULL;
163 goto alloc_authkey_failed;
164 }
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 /* make the call */
David Howellsb5f545c2006-01-08 01:02:47 -0800167 actor = call_sbin_request_key;
168 if (type->request_key)
169 actor = type->request_key;
David Howells4e54f082006-06-29 02:24:28 -0700170 ret = actor(key, authkey, "create", aux);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 if (ret < 0)
172 goto request_failed;
173
174 /* if the key wasn't instantiated, then we want to give an error */
175 ret = -ENOKEY;
David Howells76d8aea2005-06-23 22:00:49 -0700176 if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 goto request_failed;
178
David Howellsb5f545c2006-01-08 01:02:47 -0800179 key_revoke(authkey);
180 key_put(authkey);
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 down_write(&key_construction_sem);
183 list_del(&cons.link);
184 up_write(&key_construction_sem);
185
186 /* also give an error if the key was negatively instantiated */
David Howellsb5f545c2006-01-08 01:02:47 -0800187check_not_negative:
David Howells76d8aea2005-06-23 22:00:49 -0700188 if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 key_put(key);
190 key = ERR_PTR(-ENOKEY);
191 }
192
David Howellsb5f545c2006-01-08 01:02:47 -0800193out:
David Howells3e301482005-06-23 22:00:56 -0700194 kleave(" = %p", key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return key;
196
David Howellsb5f545c2006-01-08 01:02:47 -0800197request_failed:
198 key_revoke(authkey);
199 key_put(authkey);
200
201alloc_authkey_failed:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 /* it wasn't instantiated
203 * - remove from construction queue
204 * - mark the key as dead
205 */
David Howells76d8aea2005-06-23 22:00:49 -0700206 negated = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 down_write(&key_construction_sem);
208
209 list_del(&cons.link);
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 /* check it didn't get instantiated between the check and the down */
David Howells76d8aea2005-06-23 22:00:49 -0700212 if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
213 set_bit(KEY_FLAG_NEGATIVE, &key->flags);
214 set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
215 negated = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 }
217
David Howells76d8aea2005-06-23 22:00:49 -0700218 clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 up_write(&key_construction_sem);
221
David Howells76d8aea2005-06-23 22:00:49 -0700222 if (!negated)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 goto check_not_negative; /* surprisingly, the key got
224 * instantiated */
225
226 /* set the timeout and store in the session keyring if we can */
227 now = current_kernel_time();
228 key->expiry = now.tv_sec + key_negative_timeout;
229
230 if (current->signal->session_keyring) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 struct key *keyring;
232
David Howells8589b4e2005-06-23 22:00:53 -0700233 rcu_read_lock();
234 keyring = rcu_dereference(current->signal->session_keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 atomic_inc(&keyring->usage);
David Howells8589b4e2005-06-23 22:00:53 -0700236 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 key_link(keyring, key);
239 key_put(keyring);
240 }
241
242 key_put(key);
243
244 /* notify anyone who was waiting */
245 wake_up_all(&request_key_conswq);
246
247 key = ERR_PTR(ret);
248 goto out;
249
David Howellsb5f545c2006-01-08 01:02:47 -0800250alloc_failed:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 up_write(&key_construction_sem);
252 goto out;
253
254} /* end __request_key_construction() */
255
256/*****************************************************************************/
257/*
258 * call out to userspace to request the key
259 * - we check the construction queue first to see if an appropriate key is
260 * already being constructed by userspace
261 */
262static struct key *request_key_construction(struct key_type *type,
263 const char *description,
David Howells7e047ef2006-06-26 00:24:50 -0700264 const char *callout_info,
David Howells4e54f082006-06-29 02:24:28 -0700265 void *aux,
266 struct key_user *user,
David Howells7e047ef2006-06-26 00:24:50 -0700267 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268{
269 struct key_construction *pcons;
270 struct key *key, *ckey;
271
272 DECLARE_WAITQUEUE(myself, current);
273
David Howells7e047ef2006-06-26 00:24:50 -0700274 kenter("%s,%s,{%d},%s,%lx",
275 type->name, description, user->uid, callout_info, flags);
David Howells3e301482005-06-23 22:00:56 -0700276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 /* see if there's such a key under construction already */
278 down_write(&key_construction_sem);
279
280 list_for_each_entry(pcons, &user->consq, link) {
281 ckey = pcons->key;
282
283 if (ckey->type != type)
284 continue;
285
286 if (type->match(ckey, description))
287 goto found_key_under_construction;
288 }
289
290 /* see about getting userspace to construct the key */
David Howells4e54f082006-06-29 02:24:28 -0700291 key = __request_key_construction(type, description, callout_info, aux,
David Howells7e047ef2006-06-26 00:24:50 -0700292 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 error:
David Howells3e301482005-06-23 22:00:56 -0700294 kleave(" = %p", key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 return key;
296
297 /* someone else has the same key under construction
298 * - we want to keep an eye on their key
299 */
300 found_key_under_construction:
301 atomic_inc(&ckey->usage);
302 up_write(&key_construction_sem);
303
304 /* wait for the key to be completed one way or another */
305 add_wait_queue(&request_key_conswq, &myself);
306
307 for (;;) {
David Howells3e301482005-06-23 22:00:56 -0700308 set_current_state(TASK_INTERRUPTIBLE);
David Howells76d8aea2005-06-23 22:00:49 -0700309 if (!test_bit(KEY_FLAG_USER_CONSTRUCT, &ckey->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 break;
David Howells3e301482005-06-23 22:00:56 -0700311 if (signal_pending(current))
312 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 schedule();
314 }
315
316 set_current_state(TASK_RUNNING);
317 remove_wait_queue(&request_key_conswq, &myself);
318
319 /* we'll need to search this process's keyrings to see if the key is
320 * now there since we can't automatically assume it's also available
321 * there */
322 key_put(ckey);
323 ckey = NULL;
324
325 key = NULL; /* request a retry */
326 goto error;
327
328} /* end request_key_construction() */
329
330/*****************************************************************************/
331/*
David Howells3e301482005-06-23 22:00:56 -0700332 * link a freshly minted key to an appropriate destination keyring
333 */
334static void request_key_link(struct key *key, struct key *dest_keyring)
335{
336 struct task_struct *tsk = current;
337 struct key *drop = NULL;
338
339 kenter("{%d},%p", key->serial, dest_keyring);
340
341 /* find the appropriate keyring */
342 if (!dest_keyring) {
343 switch (tsk->jit_keyring) {
344 case KEY_REQKEY_DEFL_DEFAULT:
345 case KEY_REQKEY_DEFL_THREAD_KEYRING:
346 dest_keyring = tsk->thread_keyring;
347 if (dest_keyring)
348 break;
349
350 case KEY_REQKEY_DEFL_PROCESS_KEYRING:
351 dest_keyring = tsk->signal->process_keyring;
352 if (dest_keyring)
353 break;
354
355 case KEY_REQKEY_DEFL_SESSION_KEYRING:
356 rcu_read_lock();
357 dest_keyring = key_get(
358 rcu_dereference(tsk->signal->session_keyring));
359 rcu_read_unlock();
360 drop = dest_keyring;
361
362 if (dest_keyring)
363 break;
364
365 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
366 dest_keyring = current->user->session_keyring;
367 break;
368
369 case KEY_REQKEY_DEFL_USER_KEYRING:
370 dest_keyring = current->user->uid_keyring;
371 break;
372
373 case KEY_REQKEY_DEFL_GROUP_KEYRING:
374 default:
375 BUG();
376 }
377 }
378
379 /* and attach the key to it */
380 key_link(dest_keyring, key);
381
382 key_put(drop);
383
384 kleave("");
385
386} /* end request_key_link() */
387
388/*****************************************************************************/
389/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 * request a key
391 * - search the process's keyrings
392 * - check the list of keys being created or updated
David Howells3e301482005-06-23 22:00:56 -0700393 * - call out to userspace for a key if supplementary info was provided
394 * - cache the key in an appropriate keyring
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 */
David Howells3e301482005-06-23 22:00:56 -0700396struct key *request_key_and_link(struct key_type *type,
397 const char *description,
398 const char *callout_info,
David Howells4e54f082006-06-29 02:24:28 -0700399 void *aux,
David Howells7e047ef2006-06-26 00:24:50 -0700400 struct key *dest_keyring,
401 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
403 struct key_user *user;
404 struct key *key;
David Howells664cceb2005-09-28 17:03:15 +0100405 key_ref_t key_ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
David Howells4e54f082006-06-29 02:24:28 -0700407 kenter("%s,%s,%s,%p,%p,%lx",
408 type->name, description, callout_info, aux,
409 dest_keyring, flags);
David Howells3e301482005-06-23 22:00:56 -0700410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 /* search all the process keyrings for a key */
David Howells664cceb2005-09-28 17:03:15 +0100412 key_ref = search_process_keyrings(type, description, type->match,
413 current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
David Howells664cceb2005-09-28 17:03:15 +0100415 kdebug("search 1: %p", key_ref);
416
417 if (!IS_ERR(key_ref)) {
418 key = key_ref_to_ptr(key_ref);
419 }
420 else if (PTR_ERR(key_ref) != -EAGAIN) {
421 key = ERR_PTR(PTR_ERR(key_ref));
422 }
423 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 /* the search failed, but the keyrings were searchable, so we
425 * should consult userspace if we can */
426 key = ERR_PTR(-ENOKEY);
427 if (!callout_info)
428 goto error;
429
430 /* - get hold of the user's construction queue */
431 user = key_user_lookup(current->fsuid);
David Howells3e301482005-06-23 22:00:56 -0700432 if (!user)
433 goto nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
David Howells664cceb2005-09-28 17:03:15 +0100435 for (;;) {
David Howells3e301482005-06-23 22:00:56 -0700436 if (signal_pending(current))
437 goto interrupted;
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 /* ask userspace (returns NULL if it waited on a key
440 * being constructed) */
441 key = request_key_construction(type, description,
David Howells4e54f082006-06-29 02:24:28 -0700442 callout_info, aux,
443 user, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 if (key)
445 break;
446
447 /* someone else made the key we want, so we need to
448 * search again as it might now be available to us */
David Howells664cceb2005-09-28 17:03:15 +0100449 key_ref = search_process_keyrings(type, description,
450 type->match,
451 current);
David Howells3e301482005-06-23 22:00:56 -0700452
David Howells664cceb2005-09-28 17:03:15 +0100453 kdebug("search 2: %p", key_ref);
454
455 if (!IS_ERR(key_ref)) {
456 key = key_ref_to_ptr(key_ref);
457 break;
458 }
459
460 if (PTR_ERR(key_ref) != -EAGAIN) {
461 key = ERR_PTR(PTR_ERR(key_ref));
462 break;
463 }
464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 key_user_put(user);
David Howells3e301482005-06-23 22:00:56 -0700467
468 /* link the new key into the appropriate keyring */
David Howells1260f802005-08-04 11:50:01 +0100469 if (!IS_ERR(key))
David Howells3e301482005-06-23 22:00:56 -0700470 request_key_link(key, dest_keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472
David Howells3e301482005-06-23 22:00:56 -0700473error:
474 kleave(" = %p", key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 return key;
476
David Howells3e301482005-06-23 22:00:56 -0700477nomem:
478 key = ERR_PTR(-ENOMEM);
479 goto error;
480
481interrupted:
482 key_user_put(user);
483 key = ERR_PTR(-EINTR);
484 goto error;
485
486} /* end request_key_and_link() */
487
488/*****************************************************************************/
489/*
490 * request a key
491 * - search the process's keyrings
492 * - check the list of keys being created or updated
493 * - call out to userspace for a key if supplementary info was provided
494 */
495struct key *request_key(struct key_type *type,
496 const char *description,
497 const char *callout_info)
498{
David Howells7e047ef2006-06-26 00:24:50 -0700499 return request_key_and_link(type, description, callout_info, NULL,
David Howells4e54f082006-06-29 02:24:28 -0700500 NULL, KEY_ALLOC_IN_QUOTA);
David Howells3e301482005-06-23 22:00:56 -0700501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502} /* end request_key() */
503
504EXPORT_SYMBOL(request_key);
David Howells4e54f082006-06-29 02:24:28 -0700505
506/*****************************************************************************/
507/*
508 * request a key with auxiliary data for the upcaller
509 * - search the process's keyrings
510 * - check the list of keys being created or updated
511 * - call out to userspace for a key if supplementary info was provided
512 */
513struct key *request_key_with_auxdata(struct key_type *type,
514 const char *description,
515 const char *callout_info,
516 void *aux)
517{
518 return request_key_and_link(type, description, callout_info, aux,
519 NULL, KEY_ALLOC_IN_QUOTA);
520
521} /* end request_key_with_auxdata() */
522
523EXPORT_SYMBOL(request_key_with_auxdata);