[PATCH] keys: Discard key spinlock and use RCU for key payload
[linux-2.6.git] / security / keys / process_keys.c
1 /* process_keys.c: management of a process's keyrings
2  *
3  * Copyright (C) 2004 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
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/keyctl.h>
17 #include <linux/fs.h>
18 #include <linux/err.h>
19 #include <asm/uaccess.h>
20 #include "internal.h"
21
22 /* session keyring create vs join semaphore */
23 static DECLARE_MUTEX(key_session_sem);
24
25 /* the root user's tracking struct */
26 struct key_user root_key_user = {
27         .usage          = ATOMIC_INIT(3),
28         .consq          = LIST_HEAD_INIT(root_key_user.consq),
29         .lock           = SPIN_LOCK_UNLOCKED,
30         .nkeys          = ATOMIC_INIT(2),
31         .nikeys         = ATOMIC_INIT(2),
32         .uid            = 0,
33 };
34
35 /* the root user's UID keyring */
36 struct key root_user_keyring = {
37         .usage          = ATOMIC_INIT(1),
38         .serial         = 2,
39         .type           = &key_type_keyring,
40         .user           = &root_key_user,
41         .sem            = __RWSEM_INITIALIZER(root_user_keyring.sem),
42         .perm           = KEY_USR_ALL,
43         .flags          = 1 << KEY_FLAG_INSTANTIATED,
44         .description    = "_uid.0",
45 #ifdef KEY_DEBUGGING
46         .magic          = KEY_DEBUG_MAGIC,
47 #endif
48 };
49
50 /* the root user's default session keyring */
51 struct key root_session_keyring = {
52         .usage          = ATOMIC_INIT(1),
53         .serial         = 1,
54         .type           = &key_type_keyring,
55         .user           = &root_key_user,
56         .sem            = __RWSEM_INITIALIZER(root_session_keyring.sem),
57         .perm           = KEY_USR_ALL,
58         .flags          = 1 << KEY_FLAG_INSTANTIATED,
59         .description    = "_uid_ses.0",
60 #ifdef KEY_DEBUGGING
61         .magic          = KEY_DEBUG_MAGIC,
62 #endif
63 };
64
65 /*****************************************************************************/
66 /*
67  * allocate the keyrings to be associated with a UID
68  */
69 int alloc_uid_keyring(struct user_struct *user)
70 {
71         struct key *uid_keyring, *session_keyring;
72         char buf[20];
73         int ret;
74
75         /* concoct a default session keyring */
76         sprintf(buf, "_uid_ses.%u", user->uid);
77
78         session_keyring = keyring_alloc(buf, user->uid, (gid_t) -1, 0, NULL);
79         if (IS_ERR(session_keyring)) {
80                 ret = PTR_ERR(session_keyring);
81                 goto error;
82         }
83
84         /* and a UID specific keyring, pointed to by the default session
85          * keyring */
86         sprintf(buf, "_uid.%u", user->uid);
87
88         uid_keyring = keyring_alloc(buf, user->uid, (gid_t) -1, 0,
89                                     session_keyring);
90         if (IS_ERR(uid_keyring)) {
91                 key_put(session_keyring);
92                 ret = PTR_ERR(uid_keyring);
93                 goto error;
94         }
95
96         /* install the keyrings */
97         user->uid_keyring = uid_keyring;
98         user->session_keyring = session_keyring;
99         ret = 0;
100
101  error:
102         return ret;
103
104 } /* end alloc_uid_keyring() */
105
106 /*****************************************************************************/
107 /*
108  * deal with the UID changing
109  */
110 void switch_uid_keyring(struct user_struct *new_user)
111 {
112 #if 0 /* do nothing for now */
113         struct key *old;
114
115         /* switch to the new user's session keyring if we were running under
116          * root's default session keyring */
117         if (new_user->uid != 0 &&
118             current->session_keyring == &root_session_keyring
119             ) {
120                 atomic_inc(&new_user->session_keyring->usage);
121
122                 task_lock(current);
123                 old = current->session_keyring;
124                 current->session_keyring = new_user->session_keyring;
125                 task_unlock(current);
126
127                 key_put(old);
128         }
129 #endif
130
131 } /* end switch_uid_keyring() */
132
133 /*****************************************************************************/
134 /*
135  * install a fresh thread keyring, discarding the old one
136  */
137 int install_thread_keyring(struct task_struct *tsk)
138 {
139         struct key *keyring, *old;
140         char buf[20];
141         int ret;
142
143         sprintf(buf, "_tid.%u", tsk->pid);
144
145         keyring = keyring_alloc(buf, tsk->uid, tsk->gid, 1, NULL);
146         if (IS_ERR(keyring)) {
147                 ret = PTR_ERR(keyring);
148                 goto error;
149         }
150
151         task_lock(tsk);
152         old = tsk->thread_keyring;
153         tsk->thread_keyring = keyring;
154         task_unlock(tsk);
155
156         ret = 0;
157
158         key_put(old);
159  error:
160         return ret;
161
162 } /* end install_thread_keyring() */
163
164 /*****************************************************************************/
165 /*
166  * make sure a process keyring is installed
167  */
168 static int install_process_keyring(struct task_struct *tsk)
169 {
170         unsigned long flags;
171         struct key *keyring;
172         char buf[20];
173         int ret;
174
175         if (!tsk->signal->process_keyring) {
176                 sprintf(buf, "_pid.%u", tsk->tgid);
177
178                 keyring = keyring_alloc(buf, tsk->uid, tsk->gid, 1, NULL);
179                 if (IS_ERR(keyring)) {
180                         ret = PTR_ERR(keyring);
181                         goto error;
182                 }
183
184                 /* attach or swap keyrings */
185                 spin_lock_irqsave(&tsk->sighand->siglock, flags);
186                 if (!tsk->signal->process_keyring) {
187                         tsk->signal->process_keyring = keyring;
188                         keyring = NULL;
189                 }
190                 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
191
192                 key_put(keyring);
193         }
194
195         ret = 0;
196  error:
197         return ret;
198
199 } /* end install_process_keyring() */
200
201 /*****************************************************************************/
202 /*
203  * install a session keyring, discarding the old one
204  * - if a keyring is not supplied, an empty one is invented
205  */
206 static int install_session_keyring(struct task_struct *tsk,
207                                    struct key *keyring)
208 {
209         unsigned long flags;
210         struct key *old;
211         char buf[20];
212         int ret;
213
214         /* create an empty session keyring */
215         if (!keyring) {
216                 sprintf(buf, "_ses.%u", tsk->tgid);
217
218                 keyring = keyring_alloc(buf, tsk->uid, tsk->gid, 1, NULL);
219                 if (IS_ERR(keyring)) {
220                         ret = PTR_ERR(keyring);
221                         goto error;
222                 }
223         }
224         else {
225                 atomic_inc(&keyring->usage);
226         }
227
228         /* install the keyring */
229         spin_lock_irqsave(&tsk->sighand->siglock, flags);
230         old = tsk->signal->session_keyring;
231         tsk->signal->session_keyring = keyring;
232         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
233
234         ret = 0;
235
236         key_put(old);
237  error:
238         return ret;
239
240 } /* end install_session_keyring() */
241
242 /*****************************************************************************/
243 /*
244  * copy the keys in a thread group for fork without CLONE_THREAD
245  */
246 int copy_thread_group_keys(struct task_struct *tsk)
247 {
248         unsigned long flags;
249
250         key_check(current->thread_group->session_keyring);
251         key_check(current->thread_group->process_keyring);
252
253         /* no process keyring yet */
254         tsk->signal->process_keyring = NULL;
255
256         /* same session keyring */
257         spin_lock_irqsave(&current->sighand->siglock, flags);
258         tsk->signal->session_keyring =
259                 key_get(current->signal->session_keyring);
260         spin_unlock_irqrestore(&current->sighand->siglock, flags);
261
262         return 0;
263
264 } /* end copy_thread_group_keys() */
265
266 /*****************************************************************************/
267 /*
268  * copy the keys for fork
269  */
270 int copy_keys(unsigned long clone_flags, struct task_struct *tsk)
271 {
272         key_check(tsk->thread_keyring);
273
274         /* no thread keyring yet */
275         tsk->thread_keyring = NULL;
276         return 0;
277
278 } /* end copy_keys() */
279
280 /*****************************************************************************/
281 /*
282  * dispose of thread group keys upon thread group destruction
283  */
284 void exit_thread_group_keys(struct signal_struct *tg)
285 {
286         key_put(tg->session_keyring);
287         key_put(tg->process_keyring);
288
289 } /* end exit_thread_group_keys() */
290
291 /*****************************************************************************/
292 /*
293  * dispose of keys upon thread exit
294  */
295 void exit_keys(struct task_struct *tsk)
296 {
297         key_put(tsk->thread_keyring);
298
299 } /* end exit_keys() */
300
301 /*****************************************************************************/
302 /*
303  * deal with execve()
304  */
305 int exec_keys(struct task_struct *tsk)
306 {
307         unsigned long flags;
308         struct key *old;
309
310         /* newly exec'd tasks don't get a thread keyring */
311         task_lock(tsk);
312         old = tsk->thread_keyring;
313         tsk->thread_keyring = NULL;
314         task_unlock(tsk);
315
316         key_put(old);
317
318         /* discard the process keyring from a newly exec'd task */
319         spin_lock_irqsave(&tsk->sighand->siglock, flags);
320         old = tsk->signal->process_keyring;
321         tsk->signal->process_keyring = NULL;
322         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
323
324         key_put(old);
325
326         return 0;
327
328 } /* end exec_keys() */
329
330 /*****************************************************************************/
331 /*
332  * deal with SUID programs
333  * - we might want to make this invent a new session keyring
334  */
335 int suid_keys(struct task_struct *tsk)
336 {
337         return 0;
338
339 } /* end suid_keys() */
340
341 /*****************************************************************************/
342 /*
343  * the filesystem user ID changed
344  */
345 void key_fsuid_changed(struct task_struct *tsk)
346 {
347         /* update the ownership of the thread keyring */
348         if (tsk->thread_keyring) {
349                 down_write(&tsk->thread_keyring->sem);
350                 tsk->thread_keyring->uid = tsk->fsuid;
351                 up_write(&tsk->thread_keyring->sem);
352         }
353
354 } /* end key_fsuid_changed() */
355
356 /*****************************************************************************/
357 /*
358  * the filesystem group ID changed
359  */
360 void key_fsgid_changed(struct task_struct *tsk)
361 {
362         /* update the ownership of the thread keyring */
363         if (tsk->thread_keyring) {
364                 down_write(&tsk->thread_keyring->sem);
365                 tsk->thread_keyring->gid = tsk->fsgid;
366                 up_write(&tsk->thread_keyring->sem);
367         }
368
369 } /* end key_fsgid_changed() */
370
371 /*****************************************************************************/
372 /*
373  * search the process keyrings for the first matching key
374  * - we use the supplied match function to see if the description (or other
375  *   feature of interest) matches
376  * - we return -EAGAIN if we didn't find any matching key
377  * - we return -ENOKEY if we found only negative matching keys
378  */
379 struct key *search_process_keyrings_aux(struct key_type *type,
380                                         const void *description,
381                                         key_match_func_t match)
382 {
383         struct task_struct *tsk = current;
384         unsigned long flags;
385         struct key *key, *ret, *err, *tmp;
386
387         /* we want to return -EAGAIN or -ENOKEY if any of the keyrings were
388          * searchable, but we failed to find a key or we found a negative key;
389          * otherwise we want to return a sample error (probably -EACCES) if
390          * none of the keyrings were searchable
391          *
392          * in terms of priority: success > -ENOKEY > -EAGAIN > other error
393          */
394         key = NULL;
395         ret = NULL;
396         err = ERR_PTR(-EAGAIN);
397
398         /* search the thread keyring first */
399         if (tsk->thread_keyring) {
400                 key = keyring_search_aux(tsk->thread_keyring, type,
401                                          description, match);
402                 if (!IS_ERR(key))
403                         goto found;
404
405                 switch (PTR_ERR(key)) {
406                 case -EAGAIN: /* no key */
407                         if (ret)
408                                 break;
409                 case -ENOKEY: /* negative key */
410                         ret = key;
411                         break;
412                 default:
413                         err = key;
414                         break;
415                 }
416         }
417
418         /* search the process keyring second */
419         if (tsk->signal->process_keyring) {
420                 key = keyring_search_aux(tsk->signal->process_keyring,
421                                          type, description, match);
422                 if (!IS_ERR(key))
423                         goto found;
424
425                 switch (PTR_ERR(key)) {
426                 case -EAGAIN: /* no key */
427                         if (ret)
428                                 break;
429                 case -ENOKEY: /* negative key */
430                         ret = key;
431                         break;
432                 default:
433                         err = key;
434                         break;
435                 }
436         }
437
438         /* search the session keyring last */
439         spin_lock_irqsave(&tsk->sighand->siglock, flags);
440
441         tmp = tsk->signal->session_keyring;
442         if (!tmp)
443                 tmp = tsk->user->session_keyring;
444         atomic_inc(&tmp->usage);
445
446         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
447
448         key = keyring_search_aux(tmp, type, description, match);
449         key_put(tmp);
450         if (!IS_ERR(key))
451                 goto found;
452
453         switch (PTR_ERR(key)) {
454         case -EAGAIN: /* no key */
455                 if (ret)
456                         break;
457         case -ENOKEY: /* negative key */
458                 ret = key;
459                 break;
460         default:
461                 err = key;
462                 break;
463         }
464
465         /* no key - decide on the error we're going to go for */
466         key = ret ? ret : err;
467
468  found:
469         return key;
470
471 } /* end search_process_keyrings_aux() */
472
473 /*****************************************************************************/
474 /*
475  * search the process keyrings for the first matching key
476  * - we return -EAGAIN if we didn't find any matching key
477  * - we return -ENOKEY if we found only negative matching keys
478  */
479 struct key *search_process_keyrings(struct key_type *type,
480                                     const char *description)
481 {
482         return search_process_keyrings_aux(type, description, type->match);
483
484 } /* end search_process_keyrings() */
485
486 /*****************************************************************************/
487 /*
488  * lookup a key given a key ID from userspace with a given permissions mask
489  * - don't create special keyrings unless so requested
490  * - partially constructed keys aren't found unless requested
491  */
492 struct key *lookup_user_key(key_serial_t id, int create, int partial,
493                             key_perm_t perm)
494 {
495         struct task_struct *tsk = current;
496         unsigned long flags;
497         struct key *key;
498         int ret;
499
500         key = ERR_PTR(-ENOKEY);
501
502         switch (id) {
503         case KEY_SPEC_THREAD_KEYRING:
504                 if (!tsk->thread_keyring) {
505                         if (!create)
506                                 goto error;
507
508                         ret = install_thread_keyring(tsk);
509                         if (ret < 0) {
510                                 key = ERR_PTR(ret);
511                                 goto error;
512                         }
513                 }
514
515                 key = tsk->thread_keyring;
516                 atomic_inc(&key->usage);
517                 break;
518
519         case KEY_SPEC_PROCESS_KEYRING:
520                 if (!tsk->signal->process_keyring) {
521                         if (!create)
522                                 goto error;
523
524                         ret = install_process_keyring(tsk);
525                         if (ret < 0) {
526                                 key = ERR_PTR(ret);
527                                 goto error;
528                         }
529                 }
530
531                 key = tsk->signal->process_keyring;
532                 atomic_inc(&key->usage);
533                 break;
534
535         case KEY_SPEC_SESSION_KEYRING:
536                 if (!tsk->signal->session_keyring) {
537                         /* always install a session keyring upon access if one
538                          * doesn't exist yet */
539                         ret = install_session_keyring(
540                                tsk, tsk->user->session_keyring);
541                         if (ret < 0)
542                                 goto error;
543                 }
544
545                 spin_lock_irqsave(&tsk->sighand->siglock, flags);
546                 key = tsk->signal->session_keyring;
547                 atomic_inc(&key->usage);
548                 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
549                 break;
550
551         case KEY_SPEC_USER_KEYRING:
552                 key = tsk->user->uid_keyring;
553                 atomic_inc(&key->usage);
554                 break;
555
556         case KEY_SPEC_USER_SESSION_KEYRING:
557                 key = tsk->user->session_keyring;
558                 atomic_inc(&key->usage);
559                 break;
560
561         case KEY_SPEC_GROUP_KEYRING:
562                 /* group keyrings are not yet supported */
563                 key = ERR_PTR(-EINVAL);
564                 goto error;
565
566         default:
567                 key = ERR_PTR(-EINVAL);
568                 if (id < 1)
569                         goto error;
570
571                 key = key_lookup(id);
572                 if (IS_ERR(key))
573                         goto error;
574                 break;
575         }
576
577         /* check the status and permissions */
578         if (perm) {
579                 ret = key_validate(key);
580                 if (ret < 0)
581                         goto invalid_key;
582         }
583
584         ret = -EIO;
585         if (!partial && !test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
586                 goto invalid_key;
587
588         ret = -EACCES;
589         if (!key_permission(key, perm))
590                 goto invalid_key;
591
592  error:
593         return key;
594
595  invalid_key:
596         key_put(key);
597         key = ERR_PTR(ret);
598         goto error;
599
600 } /* end lookup_user_key() */
601
602 /*****************************************************************************/
603 /*
604  * join the named keyring as the session keyring if possible, or attempt to
605  * create a new one of that name if not
606  * - if the name is NULL, an empty anonymous keyring is installed instead
607  * - named session keyring joining is done with a semaphore held
608  */
609 long join_session_keyring(const char *name)
610 {
611         struct task_struct *tsk = current;
612         unsigned long flags;
613         struct key *keyring;
614         long ret;
615
616         /* if no name is provided, install an anonymous keyring */
617         if (!name) {
618                 ret = install_session_keyring(tsk, NULL);
619                 if (ret < 0)
620                         goto error;
621
622                 spin_lock_irqsave(&tsk->sighand->siglock, flags);
623                 ret = tsk->signal->session_keyring->serial;
624                 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
625                 goto error;
626         }
627
628         /* allow the user to join or create a named keyring */
629         down(&key_session_sem);
630
631         /* look for an existing keyring of this name */
632         keyring = find_keyring_by_name(name, 0);
633         if (PTR_ERR(keyring) == -ENOKEY) {
634                 /* not found - try and create a new one */
635                 keyring = keyring_alloc(name, tsk->uid, tsk->gid, 0, NULL);
636                 if (IS_ERR(keyring)) {
637                         ret = PTR_ERR(keyring);
638                         goto error;
639                 }
640         }
641         else if (IS_ERR(keyring)) {
642                 ret = PTR_ERR(keyring);
643                 goto error2;
644         }
645
646         /* we've got a keyring - now to install it */
647         ret = install_session_keyring(tsk, keyring);
648         if (ret < 0)
649                 goto error2;
650
651         ret = keyring->serial;
652         key_put(keyring);
653
654  error2:
655         up(&key_session_sem);
656  error:
657         return ret;
658
659 } /* end join_session_keyring() */