KEYS: Do preallocation for __key_link()
[linux-3.10.git] / security / keys / key.c
1 /* Basic authentication token and access key management
2  *
3  * Copyright (C) 2004-2008 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/poison.h>
15 #include <linux/sched.h>
16 #include <linux/slab.h>
17 #include <linux/security.h>
18 #include <linux/workqueue.h>
19 #include <linux/random.h>
20 #include <linux/err.h>
21 #include <linux/user_namespace.h>
22 #include "internal.h"
23
24 static struct kmem_cache        *key_jar;
25 struct rb_root          key_serial_tree; /* tree of keys indexed by serial */
26 DEFINE_SPINLOCK(key_serial_lock);
27
28 struct rb_root  key_user_tree; /* tree of quota records indexed by UID */
29 DEFINE_SPINLOCK(key_user_lock);
30
31 unsigned int key_quota_root_maxkeys = 200;      /* root's key count quota */
32 unsigned int key_quota_root_maxbytes = 20000;   /* root's key space quota */
33 unsigned int key_quota_maxkeys = 200;           /* general key count quota */
34 unsigned int key_quota_maxbytes = 20000;        /* general key space quota */
35
36 static LIST_HEAD(key_types_list);
37 static DECLARE_RWSEM(key_types_sem);
38
39 static void key_cleanup(struct work_struct *work);
40 static DECLARE_WORK(key_cleanup_task, key_cleanup);
41
42 /* we serialise key instantiation and link */
43 DEFINE_MUTEX(key_construction_mutex);
44
45 /* any key who's type gets unegistered will be re-typed to this */
46 static struct key_type key_type_dead = {
47         .name           = "dead",
48 };
49
50 #ifdef KEY_DEBUGGING
51 void __key_check(const struct key *key)
52 {
53         printk("__key_check: key %p {%08x} should be {%08x}\n",
54                key, key->magic, KEY_DEBUG_MAGIC);
55         BUG();
56 }
57 #endif
58
59 /*****************************************************************************/
60 /*
61  * get the key quota record for a user, allocating a new record if one doesn't
62  * already exist
63  */
64 struct key_user *key_user_lookup(uid_t uid, struct user_namespace *user_ns)
65 {
66         struct key_user *candidate = NULL, *user;
67         struct rb_node *parent = NULL;
68         struct rb_node **p;
69
70  try_again:
71         p = &key_user_tree.rb_node;
72         spin_lock(&key_user_lock);
73
74         /* search the tree for a user record with a matching UID */
75         while (*p) {
76                 parent = *p;
77                 user = rb_entry(parent, struct key_user, node);
78
79                 if (uid < user->uid)
80                         p = &(*p)->rb_left;
81                 else if (uid > user->uid)
82                         p = &(*p)->rb_right;
83                 else if (user_ns < user->user_ns)
84                         p = &(*p)->rb_left;
85                 else if (user_ns > user->user_ns)
86                         p = &(*p)->rb_right;
87                 else
88                         goto found;
89         }
90
91         /* if we get here, we failed to find a match in the tree */
92         if (!candidate) {
93                 /* allocate a candidate user record if we don't already have
94                  * one */
95                 spin_unlock(&key_user_lock);
96
97                 user = NULL;
98                 candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL);
99                 if (unlikely(!candidate))
100                         goto out;
101
102                 /* the allocation may have scheduled, so we need to repeat the
103                  * search lest someone else added the record whilst we were
104                  * asleep */
105                 goto try_again;
106         }
107
108         /* if we get here, then the user record still hadn't appeared on the
109          * second pass - so we use the candidate record */
110         atomic_set(&candidate->usage, 1);
111         atomic_set(&candidate->nkeys, 0);
112         atomic_set(&candidate->nikeys, 0);
113         candidate->uid = uid;
114         candidate->user_ns = get_user_ns(user_ns);
115         candidate->qnkeys = 0;
116         candidate->qnbytes = 0;
117         spin_lock_init(&candidate->lock);
118         mutex_init(&candidate->cons_lock);
119
120         rb_link_node(&candidate->node, parent, p);
121         rb_insert_color(&candidate->node, &key_user_tree);
122         spin_unlock(&key_user_lock);
123         user = candidate;
124         goto out;
125
126         /* okay - we found a user record for this UID */
127  found:
128         atomic_inc(&user->usage);
129         spin_unlock(&key_user_lock);
130         kfree(candidate);
131  out:
132         return user;
133
134 } /* end key_user_lookup() */
135
136 /*****************************************************************************/
137 /*
138  * dispose of a user structure
139  */
140 void key_user_put(struct key_user *user)
141 {
142         if (atomic_dec_and_lock(&user->usage, &key_user_lock)) {
143                 rb_erase(&user->node, &key_user_tree);
144                 spin_unlock(&key_user_lock);
145                 put_user_ns(user->user_ns);
146
147                 kfree(user);
148         }
149
150 } /* end key_user_put() */
151
152 /*****************************************************************************/
153 /*
154  * assign a key the next unique serial number
155  * - these are assigned randomly to avoid security issues through covert
156  *   channel problems
157  */
158 static inline void key_alloc_serial(struct key *key)
159 {
160         struct rb_node *parent, **p;
161         struct key *xkey;
162
163         /* propose a random serial number and look for a hole for it in the
164          * serial number tree */
165         do {
166                 get_random_bytes(&key->serial, sizeof(key->serial));
167
168                 key->serial >>= 1; /* negative numbers are not permitted */
169         } while (key->serial < 3);
170
171         spin_lock(&key_serial_lock);
172
173 attempt_insertion:
174         parent = NULL;
175         p = &key_serial_tree.rb_node;
176
177         while (*p) {
178                 parent = *p;
179                 xkey = rb_entry(parent, struct key, serial_node);
180
181                 if (key->serial < xkey->serial)
182                         p = &(*p)->rb_left;
183                 else if (key->serial > xkey->serial)
184                         p = &(*p)->rb_right;
185                 else
186                         goto serial_exists;
187         }
188
189         /* we've found a suitable hole - arrange for this key to occupy it */
190         rb_link_node(&key->serial_node, parent, p);
191         rb_insert_color(&key->serial_node, &key_serial_tree);
192
193         spin_unlock(&key_serial_lock);
194         return;
195
196         /* we found a key with the proposed serial number - walk the tree from
197          * that point looking for the next unused serial number */
198 serial_exists:
199         for (;;) {
200                 key->serial++;
201                 if (key->serial < 3) {
202                         key->serial = 3;
203                         goto attempt_insertion;
204                 }
205
206                 parent = rb_next(parent);
207                 if (!parent)
208                         goto attempt_insertion;
209
210                 xkey = rb_entry(parent, struct key, serial_node);
211                 if (key->serial < xkey->serial)
212                         goto attempt_insertion;
213         }
214
215 } /* end key_alloc_serial() */
216
217 /*****************************************************************************/
218 /*
219  * allocate a key of the specified type
220  * - update the user's quota to reflect the existence of the key
221  * - called from a key-type operation with key_types_sem read-locked by
222  *   key_create_or_update()
223  *   - this prevents unregistration of the key type
224  * - upon return the key is as yet uninstantiated; the caller needs to either
225  *   instantiate the key or discard it before returning
226  */
227 struct key *key_alloc(struct key_type *type, const char *desc,
228                       uid_t uid, gid_t gid, const struct cred *cred,
229                       key_perm_t perm, unsigned long flags)
230 {
231         struct key_user *user = NULL;
232         struct key *key;
233         size_t desclen, quotalen;
234         int ret;
235
236         key = ERR_PTR(-EINVAL);
237         if (!desc || !*desc)
238                 goto error;
239
240         desclen = strlen(desc) + 1;
241         quotalen = desclen + type->def_datalen;
242
243         /* get hold of the key tracking for this user */
244         user = key_user_lookup(uid, cred->user->user_ns);
245         if (!user)
246                 goto no_memory_1;
247
248         /* check that the user's quota permits allocation of another key and
249          * its description */
250         if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
251                 unsigned maxkeys = (uid == 0) ?
252                         key_quota_root_maxkeys : key_quota_maxkeys;
253                 unsigned maxbytes = (uid == 0) ?
254                         key_quota_root_maxbytes : key_quota_maxbytes;
255
256                 spin_lock(&user->lock);
257                 if (!(flags & KEY_ALLOC_QUOTA_OVERRUN)) {
258                         if (user->qnkeys + 1 >= maxkeys ||
259                             user->qnbytes + quotalen >= maxbytes ||
260                             user->qnbytes + quotalen < user->qnbytes)
261                                 goto no_quota;
262                 }
263
264                 user->qnkeys++;
265                 user->qnbytes += quotalen;
266                 spin_unlock(&user->lock);
267         }
268
269         /* allocate and initialise the key and its description */
270         key = kmem_cache_alloc(key_jar, GFP_KERNEL);
271         if (!key)
272                 goto no_memory_2;
273
274         if (desc) {
275                 key->description = kmemdup(desc, desclen, GFP_KERNEL);
276                 if (!key->description)
277                         goto no_memory_3;
278         }
279
280         atomic_set(&key->usage, 1);
281         init_rwsem(&key->sem);
282         key->type = type;
283         key->user = user;
284         key->quotalen = quotalen;
285         key->datalen = type->def_datalen;
286         key->uid = uid;
287         key->gid = gid;
288         key->perm = perm;
289         key->flags = 0;
290         key->expiry = 0;
291         key->payload.data = NULL;
292         key->security = NULL;
293
294         if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
295                 key->flags |= 1 << KEY_FLAG_IN_QUOTA;
296
297         memset(&key->type_data, 0, sizeof(key->type_data));
298
299 #ifdef KEY_DEBUGGING
300         key->magic = KEY_DEBUG_MAGIC;
301 #endif
302
303         /* let the security module know about the key */
304         ret = security_key_alloc(key, cred, flags);
305         if (ret < 0)
306                 goto security_error;
307
308         /* publish the key by giving it a serial number */
309         atomic_inc(&user->nkeys);
310         key_alloc_serial(key);
311
312 error:
313         return key;
314
315 security_error:
316         kfree(key->description);
317         kmem_cache_free(key_jar, key);
318         if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
319                 spin_lock(&user->lock);
320                 user->qnkeys--;
321                 user->qnbytes -= quotalen;
322                 spin_unlock(&user->lock);
323         }
324         key_user_put(user);
325         key = ERR_PTR(ret);
326         goto error;
327
328 no_memory_3:
329         kmem_cache_free(key_jar, key);
330 no_memory_2:
331         if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
332                 spin_lock(&user->lock);
333                 user->qnkeys--;
334                 user->qnbytes -= quotalen;
335                 spin_unlock(&user->lock);
336         }
337         key_user_put(user);
338 no_memory_1:
339         key = ERR_PTR(-ENOMEM);
340         goto error;
341
342 no_quota:
343         spin_unlock(&user->lock);
344         key_user_put(user);
345         key = ERR_PTR(-EDQUOT);
346         goto error;
347
348 } /* end key_alloc() */
349
350 EXPORT_SYMBOL(key_alloc);
351
352 /*****************************************************************************/
353 /*
354  * reserve an amount of quota for the key's payload
355  */
356 int key_payload_reserve(struct key *key, size_t datalen)
357 {
358         int delta = (int)datalen - key->datalen;
359         int ret = 0;
360
361         key_check(key);
362
363         /* contemplate the quota adjustment */
364         if (delta != 0 && test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
365                 unsigned maxbytes = (key->user->uid == 0) ?
366                         key_quota_root_maxbytes : key_quota_maxbytes;
367
368                 spin_lock(&key->user->lock);
369
370                 if (delta > 0 &&
371                     (key->user->qnbytes + delta >= maxbytes ||
372                      key->user->qnbytes + delta < key->user->qnbytes)) {
373                         ret = -EDQUOT;
374                 }
375                 else {
376                         key->user->qnbytes += delta;
377                         key->quotalen += delta;
378                 }
379                 spin_unlock(&key->user->lock);
380         }
381
382         /* change the recorded data length if that didn't generate an error */
383         if (ret == 0)
384                 key->datalen = datalen;
385
386         return ret;
387
388 } /* end key_payload_reserve() */
389
390 EXPORT_SYMBOL(key_payload_reserve);
391
392 /*****************************************************************************/
393 /*
394  * instantiate a key and link it into the target keyring atomically
395  * - called with the target keyring's semaphore writelocked
396  */
397 static int __key_instantiate_and_link(struct key *key,
398                                       const void *data,
399                                       size_t datalen,
400                                       struct key *keyring,
401                                       struct key *authkey,
402                                       struct keyring_list **_prealloc)
403 {
404         int ret, awaken;
405
406         key_check(key);
407         key_check(keyring);
408
409         awaken = 0;
410         ret = -EBUSY;
411
412         mutex_lock(&key_construction_mutex);
413
414         /* can't instantiate twice */
415         if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
416                 /* instantiate the key */
417                 ret = key->type->instantiate(key, data, datalen);
418
419                 if (ret == 0) {
420                         /* mark the key as being instantiated */
421                         atomic_inc(&key->user->nikeys);
422                         set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
423
424                         if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
425                                 awaken = 1;
426
427                         /* and link it into the destination keyring */
428                         if (keyring)
429                                 __key_link(keyring, key, _prealloc);
430
431                         /* disable the authorisation key */
432                         if (authkey)
433                                 key_revoke(authkey);
434                 }
435         }
436
437         mutex_unlock(&key_construction_mutex);
438
439         /* wake up anyone waiting for a key to be constructed */
440         if (awaken)
441                 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
442
443         return ret;
444
445 } /* end __key_instantiate_and_link() */
446
447 /*****************************************************************************/
448 /*
449  * instantiate a key and link it into the target keyring atomically
450  */
451 int key_instantiate_and_link(struct key *key,
452                              const void *data,
453                              size_t datalen,
454                              struct key *keyring,
455                              struct key *authkey)
456 {
457         struct keyring_list *prealloc;
458         int ret;
459
460         if (keyring) {
461                 ret = __key_link_begin(keyring, key->type, key->description,
462                                        &prealloc);
463                 if (ret < 0)
464                         return ret;
465         }
466
467         ret = __key_instantiate_and_link(key, data, datalen, keyring, authkey,
468                                          &prealloc);
469
470         if (keyring)
471                 __key_link_end(keyring, key->type, prealloc);
472
473         return ret;
474
475 } /* end key_instantiate_and_link() */
476
477 EXPORT_SYMBOL(key_instantiate_and_link);
478
479 /*****************************************************************************/
480 /*
481  * negatively instantiate a key and link it into the target keyring atomically
482  */
483 int key_negate_and_link(struct key *key,
484                         unsigned timeout,
485                         struct key *keyring,
486                         struct key *authkey)
487 {
488         struct keyring_list *prealloc;
489         struct timespec now;
490         int ret, awaken, link_ret = 0;
491
492         key_check(key);
493         key_check(keyring);
494
495         awaken = 0;
496         ret = -EBUSY;
497
498         if (keyring)
499                 link_ret = __key_link_begin(keyring, key->type,
500                                             key->description, &prealloc);
501
502         mutex_lock(&key_construction_mutex);
503
504         /* can't instantiate twice */
505         if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
506                 /* mark the key as being negatively instantiated */
507                 atomic_inc(&key->user->nikeys);
508                 set_bit(KEY_FLAG_NEGATIVE, &key->flags);
509                 set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
510                 now = current_kernel_time();
511                 key->expiry = now.tv_sec + timeout;
512                 key_schedule_gc(key->expiry + key_gc_delay);
513
514                 if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
515                         awaken = 1;
516
517                 ret = 0;
518
519                 /* and link it into the destination keyring */
520                 if (keyring && link_ret == 0)
521                         __key_link(keyring, key, &prealloc);
522
523                 /* disable the authorisation key */
524                 if (authkey)
525                         key_revoke(authkey);
526         }
527
528         mutex_unlock(&key_construction_mutex);
529
530         if (keyring)
531                 __key_link_end(keyring, key->type, prealloc);
532
533         /* wake up anyone waiting for a key to be constructed */
534         if (awaken)
535                 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
536
537         return ret == 0 ? link_ret : ret;
538
539 } /* end key_negate_and_link() */
540
541 EXPORT_SYMBOL(key_negate_and_link);
542
543 /*****************************************************************************/
544 /*
545  * do cleaning up in process context so that we don't have to disable
546  * interrupts all over the place
547  */
548 static void key_cleanup(struct work_struct *work)
549 {
550         struct rb_node *_n;
551         struct key *key;
552
553  go_again:
554         /* look for a dead key in the tree */
555         spin_lock(&key_serial_lock);
556
557         for (_n = rb_first(&key_serial_tree); _n; _n = rb_next(_n)) {
558                 key = rb_entry(_n, struct key, serial_node);
559
560                 if (atomic_read(&key->usage) == 0)
561                         goto found_dead_key;
562         }
563
564         spin_unlock(&key_serial_lock);
565         return;
566
567  found_dead_key:
568         /* we found a dead key - once we've removed it from the tree, we can
569          * drop the lock */
570         rb_erase(&key->serial_node, &key_serial_tree);
571         spin_unlock(&key_serial_lock);
572
573         key_check(key);
574
575         security_key_free(key);
576
577         /* deal with the user's key tracking and quota */
578         if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
579                 spin_lock(&key->user->lock);
580                 key->user->qnkeys--;
581                 key->user->qnbytes -= key->quotalen;
582                 spin_unlock(&key->user->lock);
583         }
584
585         atomic_dec(&key->user->nkeys);
586         if (test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
587                 atomic_dec(&key->user->nikeys);
588
589         key_user_put(key->user);
590
591         /* now throw away the key memory */
592         if (key->type->destroy)
593                 key->type->destroy(key);
594
595         kfree(key->description);
596
597 #ifdef KEY_DEBUGGING
598         key->magic = KEY_DEBUG_MAGIC_X;
599 #endif
600         kmem_cache_free(key_jar, key);
601
602         /* there may, of course, be more than one key to destroy */
603         goto go_again;
604
605 } /* end key_cleanup() */
606
607 /*****************************************************************************/
608 /*
609  * dispose of a reference to a key
610  * - when all the references are gone, we schedule the cleanup task to come and
611  *   pull it out of the tree in definite process context
612  */
613 void key_put(struct key *key)
614 {
615         if (key) {
616                 key_check(key);
617
618                 if (atomic_dec_and_test(&key->usage))
619                         schedule_work(&key_cleanup_task);
620         }
621
622 } /* end key_put() */
623
624 EXPORT_SYMBOL(key_put);
625
626 /*****************************************************************************/
627 /*
628  * find a key by its serial number
629  */
630 struct key *key_lookup(key_serial_t id)
631 {
632         struct rb_node *n;
633         struct key *key;
634
635         spin_lock(&key_serial_lock);
636
637         /* search the tree for the specified key */
638         n = key_serial_tree.rb_node;
639         while (n) {
640                 key = rb_entry(n, struct key, serial_node);
641
642                 if (id < key->serial)
643                         n = n->rb_left;
644                 else if (id > key->serial)
645                         n = n->rb_right;
646                 else
647                         goto found;
648         }
649
650  not_found:
651         key = ERR_PTR(-ENOKEY);
652         goto error;
653
654  found:
655         /* pretend it doesn't exist if it is awaiting deletion */
656         if (atomic_read(&key->usage) == 0)
657                 goto not_found;
658
659         /* this races with key_put(), but that doesn't matter since key_put()
660          * doesn't actually change the key
661          */
662         atomic_inc(&key->usage);
663
664  error:
665         spin_unlock(&key_serial_lock);
666         return key;
667
668 } /* end key_lookup() */
669
670 /*****************************************************************************/
671 /*
672  * find and lock the specified key type against removal
673  * - we return with the sem readlocked
674  */
675 struct key_type *key_type_lookup(const char *type)
676 {
677         struct key_type *ktype;
678
679         down_read(&key_types_sem);
680
681         /* look up the key type to see if it's one of the registered kernel
682          * types */
683         list_for_each_entry(ktype, &key_types_list, link) {
684                 if (strcmp(ktype->name, type) == 0)
685                         goto found_kernel_type;
686         }
687
688         up_read(&key_types_sem);
689         ktype = ERR_PTR(-ENOKEY);
690
691  found_kernel_type:
692         return ktype;
693
694 } /* end key_type_lookup() */
695
696 /*****************************************************************************/
697 /*
698  * unlock a key type
699  */
700 void key_type_put(struct key_type *ktype)
701 {
702         up_read(&key_types_sem);
703
704 } /* end key_type_put() */
705
706 /*****************************************************************************/
707 /*
708  * attempt to update an existing key
709  * - the key has an incremented refcount
710  * - we need to put the key if we get an error
711  */
712 static inline key_ref_t __key_update(key_ref_t key_ref,
713                                      const void *payload, size_t plen)
714 {
715         struct key *key = key_ref_to_ptr(key_ref);
716         int ret;
717
718         /* need write permission on the key to update it */
719         ret = key_permission(key_ref, KEY_WRITE);
720         if (ret < 0)
721                 goto error;
722
723         ret = -EEXIST;
724         if (!key->type->update)
725                 goto error;
726
727         down_write(&key->sem);
728
729         ret = key->type->update(key, payload, plen);
730         if (ret == 0)
731                 /* updating a negative key instantiates it */
732                 clear_bit(KEY_FLAG_NEGATIVE, &key->flags);
733
734         up_write(&key->sem);
735
736         if (ret < 0)
737                 goto error;
738 out:
739         return key_ref;
740
741 error:
742         key_put(key);
743         key_ref = ERR_PTR(ret);
744         goto out;
745
746 } /* end __key_update() */
747
748 /*****************************************************************************/
749 /*
750  * search the specified keyring for a key of the same description; if one is
751  * found, update it, otherwise add a new one
752  */
753 key_ref_t key_create_or_update(key_ref_t keyring_ref,
754                                const char *type,
755                                const char *description,
756                                const void *payload,
757                                size_t plen,
758                                key_perm_t perm,
759                                unsigned long flags)
760 {
761         struct keyring_list *prealloc;
762         const struct cred *cred = current_cred();
763         struct key_type *ktype;
764         struct key *keyring, *key = NULL;
765         key_ref_t key_ref;
766         int ret;
767
768         /* look up the key type to see if it's one of the registered kernel
769          * types */
770         ktype = key_type_lookup(type);
771         if (IS_ERR(ktype)) {
772                 key_ref = ERR_PTR(-ENODEV);
773                 goto error;
774         }
775
776         key_ref = ERR_PTR(-EINVAL);
777         if (!ktype->match || !ktype->instantiate)
778                 goto error_2;
779
780         keyring = key_ref_to_ptr(keyring_ref);
781
782         key_check(keyring);
783
784         key_ref = ERR_PTR(-ENOTDIR);
785         if (keyring->type != &key_type_keyring)
786                 goto error_2;
787
788         ret = __key_link_begin(keyring, ktype, description, &prealloc);
789         if (ret < 0)
790                 goto error_2;
791
792         /* if we're going to allocate a new key, we're going to have
793          * to modify the keyring */
794         ret = key_permission(keyring_ref, KEY_WRITE);
795         if (ret < 0) {
796                 key_ref = ERR_PTR(ret);
797                 goto error_3;
798         }
799
800         /* if it's possible to update this type of key, search for an existing
801          * key of the same type and description in the destination keyring and
802          * update that instead if possible
803          */
804         if (ktype->update) {
805                 key_ref = __keyring_search_one(keyring_ref, ktype, description,
806                                                0);
807                 if (!IS_ERR(key_ref))
808                         goto found_matching_key;
809         }
810
811         /* if the client doesn't provide, decide on the permissions we want */
812         if (perm == KEY_PERM_UNDEF) {
813                 perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
814                 perm |= KEY_USR_VIEW | KEY_USR_SEARCH | KEY_USR_LINK | KEY_USR_SETATTR;
815
816                 if (ktype->read)
817                         perm |= KEY_POS_READ | KEY_USR_READ;
818
819                 if (ktype == &key_type_keyring || ktype->update)
820                         perm |= KEY_USR_WRITE;
821         }
822
823         /* allocate a new key */
824         key = key_alloc(ktype, description, cred->fsuid, cred->fsgid, cred,
825                         perm, flags);
826         if (IS_ERR(key)) {
827                 key_ref = ERR_CAST(key);
828                 goto error_3;
829         }
830
831         /* instantiate it and link it into the target keyring */
832         ret = __key_instantiate_and_link(key, payload, plen, keyring, NULL,
833                                          &prealloc);
834         if (ret < 0) {
835                 key_put(key);
836                 key_ref = ERR_PTR(ret);
837                 goto error_3;
838         }
839
840         key_ref = make_key_ref(key, is_key_possessed(keyring_ref));
841
842  error_3:
843         __key_link_end(keyring, ktype, prealloc);
844  error_2:
845         key_type_put(ktype);
846  error:
847         return key_ref;
848
849  found_matching_key:
850         /* we found a matching key, so we're going to try to update it
851          * - we can drop the locks first as we have the key pinned
852          */
853         __key_link_end(keyring, ktype, prealloc);
854         key_type_put(ktype);
855
856         key_ref = __key_update(key_ref, payload, plen);
857         goto error;
858
859 } /* end key_create_or_update() */
860
861 EXPORT_SYMBOL(key_create_or_update);
862
863 /*****************************************************************************/
864 /*
865  * update a key
866  */
867 int key_update(key_ref_t key_ref, const void *payload, size_t plen)
868 {
869         struct key *key = key_ref_to_ptr(key_ref);
870         int ret;
871
872         key_check(key);
873
874         /* the key must be writable */
875         ret = key_permission(key_ref, KEY_WRITE);
876         if (ret < 0)
877                 goto error;
878
879         /* attempt to update it if supported */
880         ret = -EOPNOTSUPP;
881         if (key->type->update) {
882                 down_write(&key->sem);
883
884                 ret = key->type->update(key, payload, plen);
885                 if (ret == 0)
886                         /* updating a negative key instantiates it */
887                         clear_bit(KEY_FLAG_NEGATIVE, &key->flags);
888
889                 up_write(&key->sem);
890         }
891
892  error:
893         return ret;
894
895 } /* end key_update() */
896
897 EXPORT_SYMBOL(key_update);
898
899 /*****************************************************************************/
900 /*
901  * revoke a key
902  */
903 void key_revoke(struct key *key)
904 {
905         struct timespec now;
906         time_t time;
907
908         key_check(key);
909
910         /* make sure no one's trying to change or use the key when we mark it
911          * - we tell lockdep that we might nest because we might be revoking an
912          *   authorisation key whilst holding the sem on a key we've just
913          *   instantiated
914          */
915         down_write_nested(&key->sem, 1);
916         if (!test_and_set_bit(KEY_FLAG_REVOKED, &key->flags) &&
917             key->type->revoke)
918                 key->type->revoke(key);
919
920         /* set the death time to no more than the expiry time */
921         now = current_kernel_time();
922         time = now.tv_sec;
923         if (key->revoked_at == 0 || key->revoked_at > time) {
924                 key->revoked_at = time;
925                 key_schedule_gc(key->revoked_at + key_gc_delay);
926         }
927
928         up_write(&key->sem);
929
930 } /* end key_revoke() */
931
932 EXPORT_SYMBOL(key_revoke);
933
934 /*****************************************************************************/
935 /*
936  * register a type of key
937  */
938 int register_key_type(struct key_type *ktype)
939 {
940         struct key_type *p;
941         int ret;
942
943         ret = -EEXIST;
944         down_write(&key_types_sem);
945
946         /* disallow key types with the same name */
947         list_for_each_entry(p, &key_types_list, link) {
948                 if (strcmp(p->name, ktype->name) == 0)
949                         goto out;
950         }
951
952         /* store the type */
953         list_add(&ktype->link, &key_types_list);
954         ret = 0;
955
956  out:
957         up_write(&key_types_sem);
958         return ret;
959
960 } /* end register_key_type() */
961
962 EXPORT_SYMBOL(register_key_type);
963
964 /*****************************************************************************/
965 /*
966  * unregister a type of key
967  */
968 void unregister_key_type(struct key_type *ktype)
969 {
970         struct rb_node *_n;
971         struct key *key;
972
973         down_write(&key_types_sem);
974
975         /* withdraw the key type */
976         list_del_init(&ktype->link);
977
978         /* mark all the keys of this type dead */
979         spin_lock(&key_serial_lock);
980
981         for (_n = rb_first(&key_serial_tree); _n; _n = rb_next(_n)) {
982                 key = rb_entry(_n, struct key, serial_node);
983
984                 if (key->type == ktype) {
985                         key->type = &key_type_dead;
986                         set_bit(KEY_FLAG_DEAD, &key->flags);
987                 }
988         }
989
990         spin_unlock(&key_serial_lock);
991
992         /* make sure everyone revalidates their keys */
993         synchronize_rcu();
994
995         /* we should now be able to destroy the payloads of all the keys of
996          * this type with impunity */
997         spin_lock(&key_serial_lock);
998
999         for (_n = rb_first(&key_serial_tree); _n; _n = rb_next(_n)) {
1000                 key = rb_entry(_n, struct key, serial_node);
1001
1002                 if (key->type == ktype) {
1003                         if (ktype->destroy)
1004                                 ktype->destroy(key);
1005                         memset(&key->payload, KEY_DESTROY, sizeof(key->payload));
1006                 }
1007         }
1008
1009         spin_unlock(&key_serial_lock);
1010         up_write(&key_types_sem);
1011
1012         key_schedule_gc(0);
1013
1014 } /* end unregister_key_type() */
1015
1016 EXPORT_SYMBOL(unregister_key_type);
1017
1018 /*****************************************************************************/
1019 /*
1020  * initialise the key management stuff
1021  */
1022 void __init key_init(void)
1023 {
1024         /* allocate a slab in which we can store keys */
1025         key_jar = kmem_cache_create("key_jar", sizeof(struct key),
1026                         0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1027
1028         /* add the special key types */
1029         list_add_tail(&key_type_keyring.link, &key_types_list);
1030         list_add_tail(&key_type_dead.link, &key_types_list);
1031         list_add_tail(&key_type_user.link, &key_types_list);
1032
1033         /* record the root user tracking */
1034         rb_link_node(&root_key_user.node,
1035                      NULL,
1036                      &key_user_tree.rb_node);
1037
1038         rb_insert_color(&root_key_user.node,
1039                         &key_user_tree);
1040
1041 } /* end key_init() */