usermodehelper: Tidy up waiting
[linux-3.10.git] / security / keys / request_key.c
1 /* request_key.c: request a key from userspace
2  *
3  * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved.
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.
10  *
11  * See Documentation/keys-request-key.txt
12  */
13
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 "internal.h"
20
21 struct 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 */
27 DECLARE_WAIT_QUEUE_HEAD(request_key_conswq);
28
29 /*****************************************************************************/
30 /*
31  * request userspace finish the construction of a key
32  * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
33  */
34 static int call_sbin_request_key(struct key *key,
35                                  struct key *authkey,
36                                  const char *op,
37                                  void *aux)
38 {
39         struct task_struct *tsk = current;
40         key_serial_t prkey, sskey;
41         struct key *keyring;
42         char *argv[9], *envp[3], uid_str[12], gid_str[12];
43         char key_str[12], keyring_str[3][12];
44         char desc[20];
45         int ret, i;
46
47         kenter("{%d},{%d},%s", key->serial, authkey->serial, op);
48
49         /* allocate a new session keyring */
50         sprintf(desc, "_req.%u", key->serial);
51
52         keyring = keyring_alloc(desc, current->fsuid, current->fsgid, current,
53                                 KEY_ALLOC_QUOTA_OVERRUN, NULL);
54         if (IS_ERR(keyring)) {
55                 ret = PTR_ERR(keyring);
56                 goto error_alloc;
57         }
58
59         /* attach the auth key to the session keyring */
60         ret = __key_link(keyring, authkey);
61         if (ret < 0)
62                 goto error_link;
63
64         /* 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
79         sprintf(keyring_str[1], "%d", prkey);
80
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
90         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];
108         argv[i] = NULL;
109
110         /* do it */
111         ret = call_usermodehelper_keys(argv[0], argv, envp, keyring,
112                                        UMH_WAIT_PROC);
113
114 error_link:
115         key_put(keyring);
116
117 error_alloc:
118         kleave(" = %d", ret);
119         return ret;
120
121 } /* end call_sbin_request_key() */
122
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  */
129 static struct key *__request_key_construction(struct key_type *type,
130                                               const char *description,
131                                               const char *callout_info,
132                                               void *aux,
133                                               unsigned long flags)
134 {
135         request_key_actor_t actor;
136         struct key_construction cons;
137         struct timespec now;
138         struct key *key, *authkey;
139         int ret, negated;
140
141         kenter("%s,%s,%s,%lx", type->name, description, callout_info, flags);
142
143         /* create a key and add it to the queue */
144         key = key_alloc(type, description,
145                         current->fsuid, current->fsgid, current, KEY_POS_ALL,
146                         flags);
147         if (IS_ERR(key))
148                 goto alloc_failed;
149
150         set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
151
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
158         /* 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
166         /* make the call */
167         actor = call_sbin_request_key;
168         if (type->request_key)
169                 actor = type->request_key;
170         ret = actor(key, authkey, "create", aux);
171         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;
176         if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
177                 goto request_failed;
178
179         key_revoke(authkey);
180         key_put(authkey);
181
182         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 */
187 check_not_negative:
188         if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
189                 key_put(key);
190                 key = ERR_PTR(-ENOKEY);
191         }
192
193 out:
194         kleave(" = %p", key);
195         return key;
196
197 request_failed:
198         key_revoke(authkey);
199         key_put(authkey);
200
201 alloc_authkey_failed:
202         /* it wasn't instantiated
203          * - remove from construction queue
204          * - mark the key as dead
205          */
206         negated = 0;
207         down_write(&key_construction_sem);
208
209         list_del(&cons.link);
210
211         /* check it didn't get instantiated between the check and the down */
212         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;
216         }
217
218         clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
219
220         up_write(&key_construction_sem);
221
222         if (!negated)
223                 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) {
231                 struct key *keyring;
232
233                 rcu_read_lock();
234                 keyring = rcu_dereference(current->signal->session_keyring);
235                 atomic_inc(&keyring->usage);
236                 rcu_read_unlock();
237
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
250 alloc_failed:
251         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  */
262 static struct key *request_key_construction(struct key_type *type,
263                                             const char *description,
264                                             const char *callout_info,
265                                             void *aux,
266                                             struct key_user *user,
267                                             unsigned long flags)
268 {
269         struct key_construction *pcons;
270         struct key *key, *ckey;
271
272         DECLARE_WAITQUEUE(myself, current);
273
274         kenter("%s,%s,{%d},%s,%lx",
275                type->name, description, user->uid, callout_info, flags);
276
277         /* 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 */
291         key = __request_key_construction(type, description, callout_info, aux,
292                                          flags);
293  error:
294         kleave(" = %p", key);
295         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 (;;) {
308                 set_current_state(TASK_INTERRUPTIBLE);
309                 if (!test_bit(KEY_FLAG_USER_CONSTRUCT, &ckey->flags))
310                         break;
311                 if (signal_pending(current))
312                         break;
313                 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 /*
332  * link a freshly minted key to an appropriate destination keyring
333  */
334 static 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 /*
390  * request a key
391  * - search the process's keyrings
392  * - check the list of keys being created or updated
393  * - call out to userspace for a key if supplementary info was provided
394  * - cache the key in an appropriate keyring
395  */
396 struct key *request_key_and_link(struct key_type *type,
397                                  const char *description,
398                                  const char *callout_info,
399                                  void *aux,
400                                  struct key *dest_keyring,
401                                  unsigned long flags)
402 {
403         struct key_user *user;
404         struct key *key;
405         key_ref_t key_ref;
406
407         kenter("%s,%s,%s,%p,%p,%lx",
408                type->name, description, callout_info, aux,
409                dest_keyring, flags);
410
411         /* search all the process keyrings for a key */
412         key_ref = search_process_keyrings(type, description, type->match,
413                                           current);
414
415         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  {
424                 /* 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);
432                 if (!user)
433                         goto nomem;
434
435                 for (;;) {
436                         if (signal_pending(current))
437                                 goto interrupted;
438
439                         /* ask userspace (returns NULL if it waited on a key
440                          * being constructed) */
441                         key = request_key_construction(type, description,
442                                                        callout_info, aux,
443                                                        user, flags);
444                         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 */
449                         key_ref = search_process_keyrings(type, description,
450                                                           type->match,
451                                                           current);
452
453                         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                 }
465
466                 key_user_put(user);
467
468                 /* link the new key into the appropriate keyring */
469                 if (!IS_ERR(key))
470                         request_key_link(key, dest_keyring);
471         }
472
473 error:
474         kleave(" = %p", key);
475         return key;
476
477 nomem:
478         key = ERR_PTR(-ENOMEM);
479         goto error;
480
481 interrupted:
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  */
495 struct key *request_key(struct key_type *type,
496                         const char *description,
497                         const char *callout_info)
498 {
499         return request_key_and_link(type, description, callout_info, NULL,
500                                     NULL, KEY_ALLOC_IN_QUOTA);
501
502 } /* end request_key() */
503
504 EXPORT_SYMBOL(request_key);
505
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  */
513 struct 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
523 EXPORT_SYMBOL(request_key_with_auxdata);