1
2
3
4
5
6
7
8#include <linux/export.h>
9#include <linux/init.h>
10#include <linux/poison.h>
11#include <linux/sched.h>
12#include <linux/slab.h>
13#include <linux/security.h>
14#include <linux/workqueue.h>
15#include <linux/random.h>
16#include <linux/ima.h>
17#include <linux/err.h>
18#include "internal.h"
19
20struct kmem_cache *key_jar;
21struct rb_root key_serial_tree;
22DEFINE_SPINLOCK(key_serial_lock);
23
24struct rb_root key_user_tree;
25DEFINE_SPINLOCK(key_user_lock);
26
27unsigned int key_quota_root_maxkeys = 1000000;
28unsigned int key_quota_root_maxbytes = 25000000;
29unsigned int key_quota_maxkeys = 200;
30unsigned int key_quota_maxbytes = 20000;
31
32static LIST_HEAD(key_types_list);
33static DECLARE_RWSEM(key_types_sem);
34
35
36DEFINE_MUTEX(key_construction_mutex);
37
38#ifdef KEY_DEBUGGING
39void __key_check(const struct key *key)
40{
41 printk("__key_check: key %p {%08x} should be {%08x}\n",
42 key, key->magic, KEY_DEBUG_MAGIC);
43 BUG();
44}
45#endif
46
47
48
49
50
51struct key_user *key_user_lookup(kuid_t uid)
52{
53 struct key_user *candidate = NULL, *user;
54 struct rb_node *parent, **p;
55
56try_again:
57 parent = NULL;
58 p = &key_user_tree.rb_node;
59 spin_lock(&key_user_lock);
60
61
62 while (*p) {
63 parent = *p;
64 user = rb_entry(parent, struct key_user, node);
65
66 if (uid_lt(uid, user->uid))
67 p = &(*p)->rb_left;
68 else if (uid_gt(uid, user->uid))
69 p = &(*p)->rb_right;
70 else
71 goto found;
72 }
73
74
75 if (!candidate) {
76
77
78 spin_unlock(&key_user_lock);
79
80 user = NULL;
81 candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL);
82 if (unlikely(!candidate))
83 goto out;
84
85
86
87
88 goto try_again;
89 }
90
91
92
93 refcount_set(&candidate->usage, 1);
94 atomic_set(&candidate->nkeys, 0);
95 atomic_set(&candidate->nikeys, 0);
96 candidate->uid = uid;
97 candidate->qnkeys = 0;
98 candidate->qnbytes = 0;
99 spin_lock_init(&candidate->lock);
100 mutex_init(&candidate->cons_lock);
101
102 rb_link_node(&candidate->node, parent, p);
103 rb_insert_color(&candidate->node, &key_user_tree);
104 spin_unlock(&key_user_lock);
105 user = candidate;
106 goto out;
107
108
109found:
110 refcount_inc(&user->usage);
111 spin_unlock(&key_user_lock);
112 kfree(candidate);
113out:
114 return user;
115}
116
117
118
119
120void key_user_put(struct key_user *user)
121{
122 if (refcount_dec_and_lock(&user->usage, &key_user_lock)) {
123 rb_erase(&user->node, &key_user_tree);
124 spin_unlock(&key_user_lock);
125
126 kfree(user);
127 }
128}
129
130
131
132
133
134static inline void key_alloc_serial(struct key *key)
135{
136 struct rb_node *parent, **p;
137 struct key *xkey;
138
139
140
141 do {
142 get_random_bytes(&key->serial, sizeof(key->serial));
143
144 key->serial >>= 1;
145 } while (key->serial < 3);
146
147 spin_lock(&key_serial_lock);
148
149attempt_insertion:
150 parent = NULL;
151 p = &key_serial_tree.rb_node;
152
153 while (*p) {
154 parent = *p;
155 xkey = rb_entry(parent, struct key, serial_node);
156
157 if (key->serial < xkey->serial)
158 p = &(*p)->rb_left;
159 else if (key->serial > xkey->serial)
160 p = &(*p)->rb_right;
161 else
162 goto serial_exists;
163 }
164
165
166 rb_link_node(&key->serial_node, parent, p);
167 rb_insert_color(&key->serial_node, &key_serial_tree);
168
169 spin_unlock(&key_serial_lock);
170 return;
171
172
173
174serial_exists:
175 for (;;) {
176 key->serial++;
177 if (key->serial < 3) {
178 key->serial = 3;
179 goto attempt_insertion;
180 }
181
182 parent = rb_next(parent);
183 if (!parent)
184 goto attempt_insertion;
185
186 xkey = rb_entry(parent, struct key, serial_node);
187 if (key->serial < xkey->serial)
188 goto attempt_insertion;
189 }
190}
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225struct key *key_alloc(struct key_type *type, const char *desc,
226 kuid_t uid, kgid_t gid, const struct cred *cred,
227 key_perm_t perm, unsigned long flags,
228 struct key_restriction *restrict_link)
229{
230 struct key_user *user = NULL;
231 struct key *key;
232 size_t desclen, quotalen;
233 int ret;
234
235 key = ERR_PTR(-EINVAL);
236 if (!desc || !*desc)
237 goto error;
238
239 if (type->vet_description) {
240 ret = type->vet_description(desc);
241 if (ret < 0) {
242 key = ERR_PTR(ret);
243 goto error;
244 }
245 }
246
247 desclen = strlen(desc);
248 quotalen = desclen + 1 + type->def_datalen;
249
250
251 user = key_user_lookup(uid);
252 if (!user)
253 goto no_memory_1;
254
255
256
257 if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
258 unsigned maxkeys = uid_eq(uid, GLOBAL_ROOT_UID) ?
259 key_quota_root_maxkeys : key_quota_maxkeys;
260 unsigned maxbytes = uid_eq(uid, GLOBAL_ROOT_UID) ?
261 key_quota_root_maxbytes : key_quota_maxbytes;
262
263 spin_lock(&user->lock);
264 if (!(flags & KEY_ALLOC_QUOTA_OVERRUN)) {
265 if (user->qnkeys + 1 > maxkeys ||
266 user->qnbytes + quotalen > maxbytes ||
267 user->qnbytes + quotalen < user->qnbytes)
268 goto no_quota;
269 }
270
271 user->qnkeys++;
272 user->qnbytes += quotalen;
273 spin_unlock(&user->lock);
274 }
275
276
277 key = kmem_cache_zalloc(key_jar, GFP_KERNEL);
278 if (!key)
279 goto no_memory_2;
280
281 key->index_key.desc_len = desclen;
282 key->index_key.description = kmemdup(desc, desclen + 1, GFP_KERNEL);
283 if (!key->index_key.description)
284 goto no_memory_3;
285 key->index_key.type = type;
286 key_set_index_key(&key->index_key);
287
288 refcount_set(&key->usage, 1);
289 init_rwsem(&key->sem);
290 lockdep_set_class(&key->sem, &type->lock_class);
291 key->user = user;
292 key->quotalen = quotalen;
293 key->datalen = type->def_datalen;
294 key->uid = uid;
295 key->gid = gid;
296 key->perm = perm;
297 key->restrict_link = restrict_link;
298 key->last_used_at = ktime_get_real_seconds();
299
300 if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
301 key->flags |= 1 << KEY_FLAG_IN_QUOTA;
302 if (flags & KEY_ALLOC_BUILT_IN)
303 key->flags |= 1 << KEY_FLAG_BUILTIN;
304 if (flags & KEY_ALLOC_UID_KEYRING)
305 key->flags |= 1 << KEY_FLAG_UID_KEYRING;
306 if (flags & KEY_ALLOC_SET_KEEP)
307 key->flags |= 1 << KEY_FLAG_KEEP;
308
309#ifdef KEY_DEBUGGING
310 key->magic = KEY_DEBUG_MAGIC;
311#endif
312
313
314 ret = security_key_alloc(key, cred, flags);
315 if (ret < 0)
316 goto security_error;
317
318
319 refcount_inc(&key->domain_tag->usage);
320 atomic_inc(&user->nkeys);
321 key_alloc_serial(key);
322
323error:
324 return key;
325
326security_error:
327 kfree(key->description);
328 kmem_cache_free(key_jar, key);
329 if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
330 spin_lock(&user->lock);
331 user->qnkeys--;
332 user->qnbytes -= quotalen;
333 spin_unlock(&user->lock);
334 }
335 key_user_put(user);
336 key = ERR_PTR(ret);
337 goto error;
338
339no_memory_3:
340 kmem_cache_free(key_jar, key);
341no_memory_2:
342 if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
343 spin_lock(&user->lock);
344 user->qnkeys--;
345 user->qnbytes -= quotalen;
346 spin_unlock(&user->lock);
347 }
348 key_user_put(user);
349no_memory_1:
350 key = ERR_PTR(-ENOMEM);
351 goto error;
352
353no_quota:
354 spin_unlock(&user->lock);
355 key_user_put(user);
356 key = ERR_PTR(-EDQUOT);
357 goto error;
358}
359EXPORT_SYMBOL(key_alloc);
360
361
362
363
364
365
366
367
368
369
370
371
372int key_payload_reserve(struct key *key, size_t datalen)
373{
374 int delta = (int)datalen - key->datalen;
375 int ret = 0;
376
377 key_check(key);
378
379
380 if (delta != 0 && test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
381 unsigned maxbytes = uid_eq(key->user->uid, GLOBAL_ROOT_UID) ?
382 key_quota_root_maxbytes : key_quota_maxbytes;
383
384 spin_lock(&key->user->lock);
385
386 if (delta > 0 &&
387 (key->user->qnbytes + delta > maxbytes ||
388 key->user->qnbytes + delta < key->user->qnbytes)) {
389 ret = -EDQUOT;
390 }
391 else {
392 key->user->qnbytes += delta;
393 key->quotalen += delta;
394 }
395 spin_unlock(&key->user->lock);
396 }
397
398
399 if (ret == 0)
400 key->datalen = datalen;
401
402 return ret;
403}
404EXPORT_SYMBOL(key_payload_reserve);
405
406
407
408
409static void mark_key_instantiated(struct key *key, int reject_error)
410{
411
412
413
414 smp_store_release(&key->state,
415 (reject_error < 0) ? reject_error : KEY_IS_POSITIVE);
416}
417
418
419
420
421
422
423
424static int __key_instantiate_and_link(struct key *key,
425 struct key_preparsed_payload *prep,
426 struct key *keyring,
427 struct key *authkey,
428 struct assoc_array_edit **_edit)
429{
430 int ret, awaken;
431
432 key_check(key);
433 key_check(keyring);
434
435 awaken = 0;
436 ret = -EBUSY;
437
438 mutex_lock(&key_construction_mutex);
439
440
441 if (key->state == KEY_IS_UNINSTANTIATED) {
442
443 ret = key->type->instantiate(key, prep);
444
445 if (ret == 0) {
446
447 atomic_inc(&key->user->nikeys);
448 mark_key_instantiated(key, 0);
449 notify_key(key, NOTIFY_KEY_INSTANTIATED, 0);
450
451 if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
452 awaken = 1;
453
454
455 if (keyring) {
456 if (test_bit(KEY_FLAG_KEEP, &keyring->flags))
457 set_bit(KEY_FLAG_KEEP, &key->flags);
458
459 __key_link(keyring, key, _edit);
460 }
461
462
463 if (authkey)
464 key_invalidate(authkey);
465
466 if (prep->expiry != TIME64_MAX) {
467 key->expiry = prep->expiry;
468 key_schedule_gc(prep->expiry + key_gc_delay);
469 }
470 }
471 }
472
473 mutex_unlock(&key_construction_mutex);
474
475
476 if (awaken)
477 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
478
479 return ret;
480}
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498int key_instantiate_and_link(struct key *key,
499 const void *data,
500 size_t datalen,
501 struct key *keyring,
502 struct key *authkey)
503{
504 struct key_preparsed_payload prep;
505 struct assoc_array_edit *edit = NULL;
506 int ret;
507
508 memset(&prep, 0, sizeof(prep));
509 prep.orig_description = key->description;
510 prep.data = data;
511 prep.datalen = datalen;
512 prep.quotalen = key->type->def_datalen;
513 prep.expiry = TIME64_MAX;
514 if (key->type->preparse) {
515 ret = key->type->preparse(&prep);
516 if (ret < 0)
517 goto error;
518 }
519
520 if (keyring) {
521 ret = __key_link_lock(keyring, &key->index_key);
522 if (ret < 0)
523 goto error;
524
525 ret = __key_link_begin(keyring, &key->index_key, &edit);
526 if (ret < 0)
527 goto error_link_end;
528
529 if (keyring->restrict_link && keyring->restrict_link->check) {
530 struct key_restriction *keyres = keyring->restrict_link;
531
532 ret = keyres->check(keyring, key->type, &prep.payload,
533 keyres->key);
534 if (ret < 0)
535 goto error_link_end;
536 }
537 }
538
539 ret = __key_instantiate_and_link(key, &prep, keyring, authkey, &edit);
540
541error_link_end:
542 if (keyring)
543 __key_link_end(keyring, &key->index_key, edit);
544
545error:
546 if (key->type->preparse)
547 key->type->free_preparse(&prep);
548 return ret;
549}
550
551EXPORT_SYMBOL(key_instantiate_and_link);
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574int key_reject_and_link(struct key *key,
575 unsigned timeout,
576 unsigned error,
577 struct key *keyring,
578 struct key *authkey)
579{
580 struct assoc_array_edit *edit = NULL;
581 int ret, awaken, link_ret = 0;
582
583 key_check(key);
584 key_check(keyring);
585
586 awaken = 0;
587 ret = -EBUSY;
588
589 if (keyring) {
590 if (keyring->restrict_link)
591 return -EPERM;
592
593 link_ret = __key_link_lock(keyring, &key->index_key);
594 if (link_ret == 0) {
595 link_ret = __key_link_begin(keyring, &key->index_key, &edit);
596 if (link_ret < 0)
597 __key_link_end(keyring, &key->index_key, edit);
598 }
599 }
600
601 mutex_lock(&key_construction_mutex);
602
603
604 if (key->state == KEY_IS_UNINSTANTIATED) {
605
606 atomic_inc(&key->user->nikeys);
607 mark_key_instantiated(key, -error);
608 notify_key(key, NOTIFY_KEY_INSTANTIATED, -error);
609 key->expiry = ktime_get_real_seconds() + timeout;
610 key_schedule_gc(key->expiry + key_gc_delay);
611
612 if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
613 awaken = 1;
614
615 ret = 0;
616
617
618 if (keyring && link_ret == 0)
619 __key_link(keyring, key, &edit);
620
621
622 if (authkey)
623 key_invalidate(authkey);
624 }
625
626 mutex_unlock(&key_construction_mutex);
627
628 if (keyring && link_ret == 0)
629 __key_link_end(keyring, &key->index_key, edit);
630
631
632 if (awaken)
633 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
634
635 return ret == 0 ? link_ret : ret;
636}
637EXPORT_SYMBOL(key_reject_and_link);
638
639
640
641
642
643
644
645
646
647void key_put(struct key *key)
648{
649 if (key) {
650 key_check(key);
651
652 if (refcount_dec_and_test(&key->usage))
653 schedule_work(&key_gc_work);
654 }
655}
656EXPORT_SYMBOL(key_put);
657
658
659
660
661struct key *key_lookup(key_serial_t id)
662{
663 struct rb_node *n;
664 struct key *key;
665
666 spin_lock(&key_serial_lock);
667
668
669 n = key_serial_tree.rb_node;
670 while (n) {
671 key = rb_entry(n, struct key, serial_node);
672
673 if (id < key->serial)
674 n = n->rb_left;
675 else if (id > key->serial)
676 n = n->rb_right;
677 else
678 goto found;
679 }
680
681not_found:
682 key = ERR_PTR(-ENOKEY);
683 goto error;
684
685found:
686
687
688
689 if (!refcount_inc_not_zero(&key->usage))
690 goto not_found;
691
692error:
693 spin_unlock(&key_serial_lock);
694 return key;
695}
696
697
698
699
700
701
702
703struct key_type *key_type_lookup(const char *type)
704{
705 struct key_type *ktype;
706
707 down_read(&key_types_sem);
708
709
710
711 list_for_each_entry(ktype, &key_types_list, link) {
712 if (strcmp(ktype->name, type) == 0)
713 goto found_kernel_type;
714 }
715
716 up_read(&key_types_sem);
717 ktype = ERR_PTR(-ENOKEY);
718
719found_kernel_type:
720 return ktype;
721}
722
723void key_set_timeout(struct key *key, unsigned timeout)
724{
725 time64_t expiry = 0;
726
727
728 down_write(&key->sem);
729
730 if (timeout > 0)
731 expiry = ktime_get_real_seconds() + timeout;
732
733 key->expiry = expiry;
734 key_schedule_gc(key->expiry + key_gc_delay);
735
736 up_write(&key->sem);
737}
738EXPORT_SYMBOL_GPL(key_set_timeout);
739
740
741
742
743void key_type_put(struct key_type *ktype)
744{
745 up_read(&key_types_sem);
746}
747
748
749
750
751
752
753
754static inline key_ref_t __key_update(key_ref_t key_ref,
755 struct key_preparsed_payload *prep)
756{
757 struct key *key = key_ref_to_ptr(key_ref);
758 int ret;
759
760
761 ret = key_permission(key_ref, KEY_NEED_WRITE);
762 if (ret < 0)
763 goto error;
764
765 ret = -EEXIST;
766 if (!key->type->update)
767 goto error;
768
769 down_write(&key->sem);
770
771 ret = key->type->update(key, prep);
772 if (ret == 0) {
773
774 mark_key_instantiated(key, 0);
775 notify_key(key, NOTIFY_KEY_UPDATED, 0);
776 }
777
778 up_write(&key->sem);
779
780 if (ret < 0)
781 goto error;
782out:
783 return key_ref;
784
785error:
786 key_put(key);
787 key_ref = ERR_PTR(ret);
788 goto out;
789}
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816key_ref_t key_create_or_update(key_ref_t keyring_ref,
817 const char *type,
818 const char *description,
819 const void *payload,
820 size_t plen,
821 key_perm_t perm,
822 unsigned long flags)
823{
824 struct keyring_index_key index_key = {
825 .description = description,
826 };
827 struct key_preparsed_payload prep;
828 struct assoc_array_edit *edit = NULL;
829 const struct cred *cred = current_cred();
830 struct key *keyring, *key = NULL;
831 key_ref_t key_ref;
832 int ret;
833 struct key_restriction *restrict_link = NULL;
834
835
836
837 index_key.type = key_type_lookup(type);
838 if (IS_ERR(index_key.type)) {
839 key_ref = ERR_PTR(-ENODEV);
840 goto error;
841 }
842
843 key_ref = ERR_PTR(-EINVAL);
844 if (!index_key.type->instantiate ||
845 (!index_key.description && !index_key.type->preparse))
846 goto error_put_type;
847
848 keyring = key_ref_to_ptr(keyring_ref);
849
850 key_check(keyring);
851
852 if (!(flags & KEY_ALLOC_BYPASS_RESTRICTION))
853 restrict_link = keyring->restrict_link;
854
855 key_ref = ERR_PTR(-ENOTDIR);
856 if (keyring->type != &key_type_keyring)
857 goto error_put_type;
858
859 memset(&prep, 0, sizeof(prep));
860 prep.orig_description = description;
861 prep.data = payload;
862 prep.datalen = plen;
863 prep.quotalen = index_key.type->def_datalen;
864 prep.expiry = TIME64_MAX;
865 if (index_key.type->preparse) {
866 ret = index_key.type->preparse(&prep);
867 if (ret < 0) {
868 key_ref = ERR_PTR(ret);
869 goto error_free_prep;
870 }
871 if (!index_key.description)
872 index_key.description = prep.description;
873 key_ref = ERR_PTR(-EINVAL);
874 if (!index_key.description)
875 goto error_free_prep;
876 }
877 index_key.desc_len = strlen(index_key.description);
878 key_set_index_key(&index_key);
879
880 ret = __key_link_lock(keyring, &index_key);
881 if (ret < 0) {
882 key_ref = ERR_PTR(ret);
883 goto error_free_prep;
884 }
885
886 ret = __key_link_begin(keyring, &index_key, &edit);
887 if (ret < 0) {
888 key_ref = ERR_PTR(ret);
889 goto error_link_end;
890 }
891
892 if (restrict_link && restrict_link->check) {
893 ret = restrict_link->check(keyring, index_key.type,
894 &prep.payload, restrict_link->key);
895 if (ret < 0) {
896 key_ref = ERR_PTR(ret);
897 goto error_link_end;
898 }
899 }
900
901
902
903 ret = key_permission(keyring_ref, KEY_NEED_WRITE);
904 if (ret < 0) {
905 key_ref = ERR_PTR(ret);
906 goto error_link_end;
907 }
908
909
910
911
912
913 if (index_key.type->update) {
914 key_ref = find_key_to_update(keyring_ref, &index_key);
915 if (key_ref)
916 goto found_matching_key;
917 }
918
919
920 if (perm == KEY_PERM_UNDEF) {
921 perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
922 perm |= KEY_USR_VIEW;
923
924 if (index_key.type->read)
925 perm |= KEY_POS_READ;
926
927 if (index_key.type == &key_type_keyring ||
928 index_key.type->update)
929 perm |= KEY_POS_WRITE;
930 }
931
932
933 key = key_alloc(index_key.type, index_key.description,
934 cred->fsuid, cred->fsgid, cred, perm, flags, NULL);
935 if (IS_ERR(key)) {
936 key_ref = ERR_CAST(key);
937 goto error_link_end;
938 }
939
940
941 ret = __key_instantiate_and_link(key, &prep, keyring, NULL, &edit);
942 if (ret < 0) {
943 key_put(key);
944 key_ref = ERR_PTR(ret);
945 goto error_link_end;
946 }
947
948 ima_post_key_create_or_update(keyring, key, payload, plen,
949 flags, true);
950
951 key_ref = make_key_ref(key, is_key_possessed(keyring_ref));
952
953error_link_end:
954 __key_link_end(keyring, &index_key, edit);
955error_free_prep:
956 if (index_key.type->preparse)
957 index_key.type->free_preparse(&prep);
958error_put_type:
959 key_type_put(index_key.type);
960error:
961 return key_ref;
962
963 found_matching_key:
964
965
966
967 __key_link_end(keyring, &index_key, edit);
968
969 key = key_ref_to_ptr(key_ref);
970 if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags)) {
971 ret = wait_for_key_construction(key, true);
972 if (ret < 0) {
973 key_ref_put(key_ref);
974 key_ref = ERR_PTR(ret);
975 goto error_free_prep;
976 }
977 }
978
979 key_ref = __key_update(key_ref, &prep);
980
981 if (!IS_ERR(key_ref))
982 ima_post_key_create_or_update(keyring, key,
983 payload, plen,
984 flags, false);
985
986 goto error_free_prep;
987}
988EXPORT_SYMBOL(key_create_or_update);
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003int key_update(key_ref_t key_ref, const void *payload, size_t plen)
1004{
1005 struct key_preparsed_payload prep;
1006 struct key *key = key_ref_to_ptr(key_ref);
1007 int ret;
1008
1009 key_check(key);
1010
1011
1012 ret = key_permission(key_ref, KEY_NEED_WRITE);
1013 if (ret < 0)
1014 return ret;
1015
1016
1017 if (!key->type->update)
1018 return -EOPNOTSUPP;
1019
1020 memset(&prep, 0, sizeof(prep));
1021 prep.data = payload;
1022 prep.datalen = plen;
1023 prep.quotalen = key->type->def_datalen;
1024 prep.expiry = TIME64_MAX;
1025 if (key->type->preparse) {
1026 ret = key->type->preparse(&prep);
1027 if (ret < 0)
1028 goto error;
1029 }
1030
1031 down_write(&key->sem);
1032
1033 ret = key->type->update(key, &prep);
1034 if (ret == 0) {
1035
1036 mark_key_instantiated(key, 0);
1037 notify_key(key, NOTIFY_KEY_UPDATED, 0);
1038 }
1039
1040 up_write(&key->sem);
1041
1042error:
1043 if (key->type->preparse)
1044 key->type->free_preparse(&prep);
1045 return ret;
1046}
1047EXPORT_SYMBOL(key_update);
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058void key_revoke(struct key *key)
1059{
1060 time64_t time;
1061
1062 key_check(key);
1063
1064
1065
1066
1067
1068
1069 down_write_nested(&key->sem, 1);
1070 if (!test_and_set_bit(KEY_FLAG_REVOKED, &key->flags)) {
1071 notify_key(key, NOTIFY_KEY_REVOKED, 0);
1072 if (key->type->revoke)
1073 key->type->revoke(key);
1074
1075
1076 time = ktime_get_real_seconds();
1077 if (key->revoked_at == 0 || key->revoked_at > time) {
1078 key->revoked_at = time;
1079 key_schedule_gc(key->revoked_at + key_gc_delay);
1080 }
1081 }
1082
1083 up_write(&key->sem);
1084}
1085EXPORT_SYMBOL(key_revoke);
1086
1087
1088
1089
1090
1091
1092
1093
1094void key_invalidate(struct key *key)
1095{
1096 kenter("%d", key_serial(key));
1097
1098 key_check(key);
1099
1100 if (!test_bit(KEY_FLAG_INVALIDATED, &key->flags)) {
1101 down_write_nested(&key->sem, 1);
1102 if (!test_and_set_bit(KEY_FLAG_INVALIDATED, &key->flags)) {
1103 notify_key(key, NOTIFY_KEY_INVALIDATED, 0);
1104 key_schedule_gc_links();
1105 }
1106 up_write(&key->sem);
1107 }
1108}
1109EXPORT_SYMBOL(key_invalidate);
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121int generic_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
1122{
1123 int ret;
1124
1125 pr_devel("==>%s()\n", __func__);
1126
1127 ret = key_payload_reserve(key, prep->quotalen);
1128 if (ret == 0) {
1129 rcu_assign_keypointer(key, prep->payload.data[0]);
1130 key->payload.data[1] = prep->payload.data[1];
1131 key->payload.data[2] = prep->payload.data[2];
1132 key->payload.data[3] = prep->payload.data[3];
1133 prep->payload.data[0] = NULL;
1134 prep->payload.data[1] = NULL;
1135 prep->payload.data[2] = NULL;
1136 prep->payload.data[3] = NULL;
1137 }
1138 pr_devel("<==%s() = %d\n", __func__, ret);
1139 return ret;
1140}
1141EXPORT_SYMBOL(generic_key_instantiate);
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151int register_key_type(struct key_type *ktype)
1152{
1153 struct key_type *p;
1154 int ret;
1155
1156 memset(&ktype->lock_class, 0, sizeof(ktype->lock_class));
1157
1158 ret = -EEXIST;
1159 down_write(&key_types_sem);
1160
1161
1162 list_for_each_entry(p, &key_types_list, link) {
1163 if (strcmp(p->name, ktype->name) == 0)
1164 goto out;
1165 }
1166
1167
1168 list_add(&ktype->link, &key_types_list);
1169
1170 pr_notice("Key type %s registered\n", ktype->name);
1171 ret = 0;
1172
1173out:
1174 up_write(&key_types_sem);
1175 return ret;
1176}
1177EXPORT_SYMBOL(register_key_type);
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187void unregister_key_type(struct key_type *ktype)
1188{
1189 down_write(&key_types_sem);
1190 list_del_init(&ktype->link);
1191 downgrade_write(&key_types_sem);
1192 key_gc_keytype(ktype);
1193 pr_notice("Key type %s unregistered\n", ktype->name);
1194 up_read(&key_types_sem);
1195}
1196EXPORT_SYMBOL(unregister_key_type);
1197
1198
1199
1200
1201void __init key_init(void)
1202{
1203
1204 key_jar = kmem_cache_create("key_jar", sizeof(struct key),
1205 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1206
1207
1208 list_add_tail(&key_type_keyring.link, &key_types_list);
1209 list_add_tail(&key_type_dead.link, &key_types_list);
1210 list_add_tail(&key_type_user.link, &key_types_list);
1211 list_add_tail(&key_type_logon.link, &key_types_list);
1212
1213
1214 rb_link_node(&root_key_user.node,
1215 NULL,
1216 &key_user_tree.rb_node);
1217
1218 rb_insert_color(&root_key_user.node,
1219 &key_user_tree);
1220}
1221