Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* Basic authentication token and access key management
3 : : *
4 : : * Copyright (C) 2004-2008 Red Hat, Inc. All Rights Reserved.
5 : : * Written by David Howells (dhowells@redhat.com)
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 : :
20 : : struct kmem_cache *key_jar;
21 : : struct rb_root key_serial_tree; /* tree of keys indexed by serial */
22 : : DEFINE_SPINLOCK(key_serial_lock);
23 : :
24 : : struct rb_root key_user_tree; /* tree of quota records indexed by UID */
25 : : DEFINE_SPINLOCK(key_user_lock);
26 : :
27 : : unsigned int key_quota_root_maxkeys = 1000000; /* root's key count quota */
28 : : unsigned int key_quota_root_maxbytes = 25000000; /* root's key space quota */
29 : : unsigned int key_quota_maxkeys = 200; /* general key count quota */
30 : : unsigned int key_quota_maxbytes = 20000; /* general key space quota */
31 : :
32 : : static LIST_HEAD(key_types_list);
33 : : static DECLARE_RWSEM(key_types_sem);
34 : :
35 : : /* We serialise key instantiation and link */
36 : : DEFINE_MUTEX(key_construction_mutex);
37 : :
38 : : #ifdef KEY_DEBUGGING
39 : : void __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 : : * Get the key quota record for a user, allocating a new record if one doesn't
49 : : * already exist.
50 : : */
51 : 192 : struct key_user *key_user_lookup(kuid_t uid)
52 : : {
53 : 192 : struct key_user *candidate = NULL, *user;
54 : 195 : struct rb_node *parent, **p;
55 : :
56 : 195 : try_again:
57 : 195 : parent = NULL;
58 : 195 : p = &key_user_tree.rb_node;
59 : 195 : spin_lock(&key_user_lock);
60 : :
61 : : /* search the tree for a user record with a matching UID */
62 [ + + ]: 201 : while (*p) {
63 : 195 : parent = *p;
64 : 195 : user = rb_entry(parent, struct key_user, node);
65 : :
66 [ - + ]: 195 : if (uid_lt(uid, user->uid))
67 : 0 : p = &(*p)->rb_left;
68 [ + + ]: 195 : else if (uid_gt(uid, user->uid))
69 : 6 : p = &(*p)->rb_right;
70 : : else
71 : 189 : goto found;
72 : : }
73 : :
74 : : /* if we get here, we failed to find a match in the tree */
75 [ + + ]: 6 : if (!candidate) {
76 : : /* allocate a candidate user record if we don't already have
77 : : * one */
78 : 3 : spin_unlock(&key_user_lock);
79 : :
80 : 3 : user = NULL;
81 : 3 : candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL);
82 [ - + ]: 3 : if (unlikely(!candidate))
83 : 0 : goto out;
84 : :
85 : : /* the allocation may have scheduled, so we need to repeat the
86 : : * search lest someone else added the record whilst we were
87 : : * asleep */
88 : 3 : goto try_again;
89 : : }
90 : :
91 : : /* if we get here, then the user record still hadn't appeared on the
92 : : * second pass - so we use the candidate record */
93 : 3 : refcount_set(&candidate->usage, 1);
94 : 3 : atomic_set(&candidate->nkeys, 0);
95 : 3 : atomic_set(&candidate->nikeys, 0);
96 : 3 : candidate->uid = uid;
97 : 3 : candidate->qnkeys = 0;
98 : 3 : candidate->qnbytes = 0;
99 : 3 : spin_lock_init(&candidate->lock);
100 : 3 : mutex_init(&candidate->cons_lock);
101 : :
102 : 3 : rb_link_node(&candidate->node, parent, p);
103 : 3 : rb_insert_color(&candidate->node, &key_user_tree);
104 : 3 : spin_unlock(&key_user_lock);
105 : 3 : user = candidate;
106 : 3 : goto out;
107 : :
108 : : /* okay - we found a user record for this UID */
109 : : found:
110 : 189 : refcount_inc(&user->usage);
111 : 189 : spin_unlock(&key_user_lock);
112 : 189 : kfree(candidate);
113 : 192 : out:
114 : 192 : return user;
115 : : }
116 : :
117 : : /*
118 : : * Dispose of a user structure
119 : : */
120 : 126 : void key_user_put(struct key_user *user)
121 : : {
122 [ - + ]: 126 : if (refcount_dec_and_lock(&user->usage, &key_user_lock)) {
123 : 0 : rb_erase(&user->node, &key_user_tree);
124 : 0 : spin_unlock(&key_user_lock);
125 : :
126 : 0 : kfree(user);
127 : : }
128 : 126 : }
129 : :
130 : : /*
131 : : * Allocate a serial number for a key. These are assigned randomly to avoid
132 : : * security issues through covert channel problems.
133 : : */
134 : 192 : static inline void key_alloc_serial(struct key *key)
135 : : {
136 : 400 : struct rb_node *parent, **p;
137 : 400 : struct key *xkey;
138 : :
139 : : /* propose a random serial number and look for a hole for it in the
140 : : * serial number tree */
141 : 400 : do {
142 : 400 : get_random_bytes(&key->serial, sizeof(key->serial));
143 : :
144 : 400 : key->serial >>= 1; /* negative numbers are not permitted */
145 [ + + ]: 400 : } while (key->serial < 3);
146 : :
147 : 192 : spin_lock(&key_serial_lock);
148 : :
149 : : attempt_insertion:
150 : 192 : parent = NULL;
151 : 192 : p = &key_serial_tree.rb_node;
152 : :
153 [ + + ]: 932 : while (*p) {
154 : 740 : parent = *p;
155 : 740 : xkey = rb_entry(parent, struct key, serial_node);
156 : :
157 [ + + ]: 740 : if (key->serial < xkey->serial)
158 : 364 : p = &(*p)->rb_left;
159 [ + - ]: 376 : else if (key->serial > xkey->serial)
160 : 376 : p = &(*p)->rb_right;
161 : : else
162 : 0 : goto serial_exists;
163 : : }
164 : :
165 : : /* we've found a suitable hole - arrange for this key to occupy it */
166 : 192 : rb_link_node(&key->serial_node, parent, p);
167 : 192 : rb_insert_color(&key->serial_node, &key_serial_tree);
168 : :
169 : 192 : spin_unlock(&key_serial_lock);
170 : 192 : return;
171 : :
172 : : /* we found a key with the proposed serial number - walk the tree from
173 : : * that point looking for the next unused serial number */
174 : 0 : serial_exists:
175 : 0 : for (;;) {
176 : 0 : key->serial++;
177 [ # # ]: 0 : if (key->serial < 3) {
178 : 0 : key->serial = 3;
179 : 0 : goto attempt_insertion;
180 : : }
181 : :
182 : 0 : parent = rb_next(parent);
183 [ # # ]: 0 : if (!parent)
184 : 0 : goto attempt_insertion;
185 : :
186 : 0 : xkey = rb_entry(parent, struct key, serial_node);
187 [ # # ]: 0 : if (key->serial < xkey->serial)
188 : 0 : goto attempt_insertion;
189 : : }
190 : : }
191 : :
192 : : /**
193 : : * key_alloc - Allocate a key of the specified type.
194 : : * @type: The type of key to allocate.
195 : : * @desc: The key description to allow the key to be searched out.
196 : : * @uid: The owner of the new key.
197 : : * @gid: The group ID for the new key's group permissions.
198 : : * @cred: The credentials specifying UID namespace.
199 : : * @perm: The permissions mask of the new key.
200 : : * @flags: Flags specifying quota properties.
201 : : * @restrict_link: Optional link restriction for new keyrings.
202 : : *
203 : : * Allocate a key of the specified type with the attributes given. The key is
204 : : * returned in an uninstantiated state and the caller needs to instantiate the
205 : : * key before returning.
206 : : *
207 : : * The restrict_link structure (if not NULL) will be freed when the
208 : : * keyring is destroyed, so it must be dynamically allocated.
209 : : *
210 : : * The user's key count quota is updated to reflect the creation of the key and
211 : : * the user's key data quota has the default for the key type reserved. The
212 : : * instantiation function should amend this as necessary. If insufficient
213 : : * quota is available, -EDQUOT will be returned.
214 : : *
215 : : * The LSM security modules can prevent a key being created, in which case
216 : : * -EACCES will be returned.
217 : : *
218 : : * Returns a pointer to the new key if successful and an error code otherwise.
219 : : *
220 : : * Note that the caller needs to ensure the key type isn't uninstantiated.
221 : : * Internally this can be done by locking key_types_sem. Externally, this can
222 : : * be done by either never unregistering the key type, or making sure
223 : : * key_alloc() calls don't race with module unloading.
224 : : */
225 : 192 : struct 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 : 192 : struct key_user *user = NULL;
231 : 192 : struct key *key;
232 : 192 : size_t desclen, quotalen;
233 : 192 : int ret;
234 : :
235 [ + - ]: 192 : key = ERR_PTR(-EINVAL);
236 [ + - - + ]: 192 : if (!desc || !*desc)
237 : 0 : goto error;
238 : :
239 [ - + ]: 192 : if (type->vet_description) {
240 : 0 : ret = type->vet_description(desc);
241 [ # # ]: 0 : if (ret < 0) {
242 : 0 : key = ERR_PTR(ret);
243 : 0 : goto error;
244 : : }
245 : : }
246 : :
247 : 192 : desclen = strlen(desc);
248 : 192 : quotalen = desclen + 1 + type->def_datalen;
249 : :
250 : : /* get hold of the key tracking for this user */
251 : 192 : user = key_user_lookup(uid);
252 [ - + ]: 192 : if (!user)
253 : 0 : goto no_memory_1;
254 : :
255 : : /* check that the user's quota permits allocation of another key and
256 : : * its description */
257 [ + + ]: 192 : if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
258 [ + + ]: 177 : unsigned maxkeys = uid_eq(uid, GLOBAL_ROOT_UID) ?
259 [ + + ]: 177 : key_quota_root_maxkeys : key_quota_maxkeys;
260 [ + + ]: 177 : unsigned maxbytes = uid_eq(uid, GLOBAL_ROOT_UID) ?
261 [ + + ]: 177 : key_quota_root_maxbytes : key_quota_maxbytes;
262 : :
263 : 177 : spin_lock(&user->lock);
264 [ + + ]: 177 : if (!(flags & KEY_ALLOC_QUOTA_OVERRUN)) {
265 [ + - ]: 93 : if (user->qnkeys + 1 > maxkeys ||
266 [ + - - + ]: 93 : user->qnbytes + quotalen > maxbytes ||
267 : : user->qnbytes + quotalen < user->qnbytes)
268 : 0 : goto no_quota;
269 : : }
270 : :
271 : 177 : user->qnkeys++;
272 : 177 : user->qnbytes += quotalen;
273 : 177 : spin_unlock(&user->lock);
274 : : }
275 : :
276 : : /* allocate and initialise the key and its description */
277 : 192 : key = kmem_cache_zalloc(key_jar, GFP_KERNEL);
278 [ - + ]: 192 : if (!key)
279 : 0 : goto no_memory_2;
280 : :
281 : 192 : key->index_key.desc_len = desclen;
282 : 192 : key->index_key.description = kmemdup(desc, desclen + 1, GFP_KERNEL);
283 [ - + ]: 192 : if (!key->index_key.description)
284 : 0 : goto no_memory_3;
285 : 192 : key->index_key.type = type;
286 : 192 : key_set_index_key(&key->index_key);
287 : :
288 : 192 : refcount_set(&key->usage, 1);
289 : 192 : init_rwsem(&key->sem);
290 : 192 : lockdep_set_class(&key->sem, &type->lock_class);
291 : 192 : key->user = user;
292 : 192 : key->quotalen = quotalen;
293 : 192 : key->datalen = type->def_datalen;
294 : 192 : key->uid = uid;
295 : 192 : key->gid = gid;
296 : 192 : key->perm = perm;
297 : 192 : key->restrict_link = restrict_link;
298 : 192 : key->last_used_at = ktime_get_real_seconds();
299 : :
300 [ + + ]: 192 : if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
301 : 177 : key->flags |= 1 << KEY_FLAG_IN_QUOTA;
302 [ + + ]: 192 : if (flags & KEY_ALLOC_BUILT_IN)
303 : 3 : key->flags |= 1 << KEY_FLAG_BUILTIN;
304 [ + + ]: 192 : if (flags & KEY_ALLOC_UID_KEYRING)
305 : 6 : key->flags |= 1 << KEY_FLAG_UID_KEYRING;
306 : :
307 : : #ifdef KEY_DEBUGGING
308 : : key->magic = KEY_DEBUG_MAGIC;
309 : : #endif
310 : :
311 : : /* let the security module know about the key */
312 : 192 : ret = security_key_alloc(key, cred, flags);
313 [ - + ]: 192 : if (ret < 0)
314 : 0 : goto security_error;
315 : :
316 : : /* publish the key by giving it a serial number */
317 : 192 : refcount_inc(&key->domain_tag->usage);
318 : 192 : atomic_inc(&user->nkeys);
319 : 192 : key_alloc_serial(key);
320 : :
321 : 192 : error:
322 : 192 : return key;
323 : :
324 : : security_error:
325 : 0 : kfree(key->description);
326 : 0 : kmem_cache_free(key_jar, key);
327 [ # # ]: 0 : if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
328 : 0 : spin_lock(&user->lock);
329 : 0 : user->qnkeys--;
330 : 0 : user->qnbytes -= quotalen;
331 : 0 : spin_unlock(&user->lock);
332 : : }
333 : 0 : key_user_put(user);
334 : 0 : key = ERR_PTR(ret);
335 : 0 : goto error;
336 : :
337 : : no_memory_3:
338 : 0 : kmem_cache_free(key_jar, key);
339 : 0 : no_memory_2:
340 [ # # ]: 0 : if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
341 : 0 : spin_lock(&user->lock);
342 : 0 : user->qnkeys--;
343 : 0 : user->qnbytes -= quotalen;
344 : 0 : spin_unlock(&user->lock);
345 : : }
346 : 0 : key_user_put(user);
347 : 0 : no_memory_1:
348 : 0 : key = ERR_PTR(-ENOMEM);
349 : 0 : goto error;
350 : :
351 : : no_quota:
352 : 0 : spin_unlock(&user->lock);
353 : 0 : key_user_put(user);
354 : 0 : key = ERR_PTR(-EDQUOT);
355 : 0 : goto error;
356 : : }
357 : : EXPORT_SYMBOL(key_alloc);
358 : :
359 : : /**
360 : : * key_payload_reserve - Adjust data quota reservation for the key's payload
361 : : * @key: The key to make the reservation for.
362 : : * @datalen: The amount of data payload the caller now wants.
363 : : *
364 : : * Adjust the amount of the owning user's key data quota that a key reserves.
365 : : * If the amount is increased, then -EDQUOT may be returned if there isn't
366 : : * enough free quota available.
367 : : *
368 : : * If successful, 0 is returned.
369 : : */
370 : 198 : int key_payload_reserve(struct key *key, size_t datalen)
371 : : {
372 : 198 : int delta = (int)datalen - key->datalen;
373 : 198 : int ret = 0;
374 : :
375 : 198 : key_check(key);
376 : :
377 : : /* contemplate the quota adjustment */
378 [ + - + + ]: 198 : if (delta != 0 && test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
379 [ + + ]: 192 : unsigned maxbytes = uid_eq(key->user->uid, GLOBAL_ROOT_UID) ?
380 [ + + ]: 192 : key_quota_root_maxbytes : key_quota_maxbytes;
381 : :
382 : 192 : spin_lock(&key->user->lock);
383 : :
384 [ + - ]: 192 : if (delta > 0 &&
385 [ + - + - ]: 192 : (key->user->qnbytes + delta >= maxbytes ||
386 : : key->user->qnbytes + delta < key->user->qnbytes)) {
387 : : ret = -EDQUOT;
388 : : }
389 : : else {
390 : 192 : key->user->qnbytes += delta;
391 : 192 : key->quotalen += delta;
392 : : }
393 : 192 : spin_unlock(&key->user->lock);
394 : : }
395 : :
396 : : /* change the recorded data length if that didn't generate an error */
397 [ + - ]: 192 : if (ret == 0)
398 : 198 : key->datalen = datalen;
399 : :
400 : 198 : return ret;
401 : : }
402 : : EXPORT_SYMBOL(key_payload_reserve);
403 : :
404 : : /*
405 : : * Change the key state to being instantiated.
406 : : */
407 : 192 : static void mark_key_instantiated(struct key *key, int reject_error)
408 : : {
409 : : /* Commit the payload before setting the state; barrier versus
410 : : * key_read_state().
411 : : */
412 [ - - ]: 192 : smp_store_release(&key->state,
413 : : (reject_error < 0) ? reject_error : KEY_IS_POSITIVE);
414 : 0 : }
415 : :
416 : : /*
417 : : * Instantiate a key and link it into the target keyring atomically. Must be
418 : : * called with the target keyring's semaphore writelocked. The target key's
419 : : * semaphore need not be locked as instantiation is serialised by
420 : : * key_construction_mutex.
421 : : */
422 : 192 : static int __key_instantiate_and_link(struct key *key,
423 : : struct key_preparsed_payload *prep,
424 : : struct key *keyring,
425 : : struct key *authkey,
426 : : struct assoc_array_edit **_edit)
427 : : {
428 : 192 : int ret, awaken;
429 : :
430 : 192 : key_check(key);
431 : 192 : key_check(keyring);
432 : :
433 : 192 : awaken = 0;
434 : 192 : ret = -EBUSY;
435 : :
436 : 192 : mutex_lock(&key_construction_mutex);
437 : :
438 : : /* can't instantiate twice */
439 [ + - ]: 192 : if (key->state == KEY_IS_UNINSTANTIATED) {
440 : : /* instantiate the key */
441 : 192 : ret = key->type->instantiate(key, prep);
442 : :
443 [ + - ]: 192 : if (ret == 0) {
444 : : /* mark the key as being instantiated */
445 : 192 : atomic_inc(&key->user->nikeys);
446 : 192 : mark_key_instantiated(key, 0);
447 : :
448 [ - + ]: 192 : if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
449 : 0 : awaken = 1;
450 : :
451 : : /* and link it into the destination keyring */
452 [ + + ]: 192 : if (keyring) {
453 [ - + ]: 90 : if (test_bit(KEY_FLAG_KEEP, &keyring->flags))
454 : 0 : set_bit(KEY_FLAG_KEEP, &key->flags);
455 : :
456 : 90 : __key_link(key, _edit);
457 : : }
458 : :
459 : : /* disable the authorisation key */
460 [ - + ]: 192 : if (authkey)
461 : 0 : key_invalidate(authkey);
462 : :
463 [ - + ]: 192 : if (prep->expiry != TIME64_MAX) {
464 : 0 : key->expiry = prep->expiry;
465 : 0 : key_schedule_gc(prep->expiry + key_gc_delay);
466 : : }
467 : : }
468 : : }
469 : :
470 : 192 : mutex_unlock(&key_construction_mutex);
471 : :
472 : : /* wake up anyone waiting for a key to be constructed */
473 [ - + ]: 192 : if (awaken)
474 : 0 : wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
475 : :
476 : 192 : return ret;
477 : : }
478 : :
479 : : /**
480 : : * key_instantiate_and_link - Instantiate a key and link it into the keyring.
481 : : * @key: The key to instantiate.
482 : : * @data: The data to use to instantiate the keyring.
483 : : * @datalen: The length of @data.
484 : : * @keyring: Keyring to create a link in on success (or NULL).
485 : : * @authkey: The authorisation token permitting instantiation.
486 : : *
487 : : * Instantiate a key that's in the uninstantiated state using the provided data
488 : : * and, if successful, link it in to the destination keyring if one is
489 : : * supplied.
490 : : *
491 : : * If successful, 0 is returned, the authorisation token is revoked and anyone
492 : : * waiting for the key is woken up. If the key was already instantiated,
493 : : * -EBUSY will be returned.
494 : : */
495 : 105 : int key_instantiate_and_link(struct key *key,
496 : : const void *data,
497 : : size_t datalen,
498 : : struct key *keyring,
499 : : struct key *authkey)
500 : : {
501 : 105 : struct key_preparsed_payload prep;
502 : 105 : struct assoc_array_edit *edit = NULL;
503 : 105 : int ret;
504 : :
505 : 105 : memset(&prep, 0, sizeof(prep));
506 : 105 : prep.data = data;
507 : 105 : prep.datalen = datalen;
508 : 105 : prep.quotalen = key->type->def_datalen;
509 : 105 : prep.expiry = TIME64_MAX;
510 [ + - ]: 105 : if (key->type->preparse) {
511 : 105 : ret = key->type->preparse(&prep);
512 [ - + ]: 105 : if (ret < 0)
513 : 0 : goto error;
514 : : }
515 : :
516 [ + + ]: 105 : if (keyring) {
517 : 3 : ret = __key_link_lock(keyring, &key->index_key);
518 [ - + ]: 3 : if (ret < 0)
519 : 0 : goto error;
520 : :
521 : 3 : ret = __key_link_begin(keyring, &key->index_key, &edit);
522 [ - + ]: 3 : if (ret < 0)
523 : 0 : goto error_link_end;
524 : :
525 [ - + - - ]: 3 : if (keyring->restrict_link && keyring->restrict_link->check) {
526 : 0 : struct key_restriction *keyres = keyring->restrict_link;
527 : :
528 : 0 : ret = keyres->check(keyring, key->type, &prep.payload,
529 : : keyres->key);
530 [ # # ]: 0 : if (ret < 0)
531 : 0 : goto error_link_end;
532 : : }
533 : : }
534 : :
535 : 105 : ret = __key_instantiate_and_link(key, &prep, keyring, authkey, &edit);
536 : :
537 : 105 : error_link_end:
538 [ + + ]: 105 : if (keyring)
539 : 3 : __key_link_end(keyring, &key->index_key, edit);
540 : :
541 : 102 : error:
542 [ + - ]: 105 : if (key->type->preparse)
543 : 105 : key->type->free_preparse(&prep);
544 : 105 : return ret;
545 : : }
546 : :
547 : : EXPORT_SYMBOL(key_instantiate_and_link);
548 : :
549 : : /**
550 : : * key_reject_and_link - Negatively instantiate a key and link it into the keyring.
551 : : * @key: The key to instantiate.
552 : : * @timeout: The timeout on the negative key.
553 : : * @error: The error to return when the key is hit.
554 : : * @keyring: Keyring to create a link in on success (or NULL).
555 : : * @authkey: The authorisation token permitting instantiation.
556 : : *
557 : : * Negatively instantiate a key that's in the uninstantiated state and, if
558 : : * successful, set its timeout and stored error and link it in to the
559 : : * destination keyring if one is supplied. The key and any links to the key
560 : : * will be automatically garbage collected after the timeout expires.
561 : : *
562 : : * Negative keys are used to rate limit repeated request_key() calls by causing
563 : : * them to return the stored error code (typically ENOKEY) until the negative
564 : : * key expires.
565 : : *
566 : : * If successful, 0 is returned, the authorisation token is revoked and anyone
567 : : * waiting for the key is woken up. If the key was already instantiated,
568 : : * -EBUSY will be returned.
569 : : */
570 : 0 : int key_reject_and_link(struct key *key,
571 : : unsigned timeout,
572 : : unsigned error,
573 : : struct key *keyring,
574 : : struct key *authkey)
575 : : {
576 : 0 : struct assoc_array_edit *edit = NULL;
577 : 0 : int ret, awaken, link_ret = 0;
578 : :
579 : 0 : key_check(key);
580 : 0 : key_check(keyring);
581 : :
582 : 0 : awaken = 0;
583 : 0 : ret = -EBUSY;
584 : :
585 [ # # ]: 0 : if (keyring) {
586 [ # # ]: 0 : if (keyring->restrict_link)
587 : : return -EPERM;
588 : :
589 : 0 : link_ret = __key_link_lock(keyring, &key->index_key);
590 [ # # ]: 0 : if (link_ret == 0) {
591 : 0 : link_ret = __key_link_begin(keyring, &key->index_key, &edit);
592 [ # # ]: 0 : if (link_ret < 0)
593 : 0 : __key_link_end(keyring, &key->index_key, edit);
594 : : }
595 : : }
596 : :
597 : 0 : mutex_lock(&key_construction_mutex);
598 : :
599 : : /* can't instantiate twice */
600 [ # # ]: 0 : if (key->state == KEY_IS_UNINSTANTIATED) {
601 : : /* mark the key as being negatively instantiated */
602 : 0 : atomic_inc(&key->user->nikeys);
603 : 0 : mark_key_instantiated(key, -error);
604 : 0 : key->expiry = ktime_get_real_seconds() + timeout;
605 : 0 : key_schedule_gc(key->expiry + key_gc_delay);
606 : :
607 [ # # ]: 0 : if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
608 : 0 : awaken = 1;
609 : :
610 : 0 : ret = 0;
611 : :
612 : : /* and link it into the destination keyring */
613 [ # # ]: 0 : if (keyring && link_ret == 0)
614 : 0 : __key_link(key, &edit);
615 : :
616 : : /* disable the authorisation key */
617 [ # # ]: 0 : if (authkey)
618 : 0 : key_invalidate(authkey);
619 : : }
620 : :
621 : 0 : mutex_unlock(&key_construction_mutex);
622 : :
623 [ # # ]: 0 : if (keyring && link_ret == 0)
624 : 0 : __key_link_end(keyring, &key->index_key, edit);
625 : :
626 : : /* wake up anyone waiting for a key to be constructed */
627 [ # # ]: 0 : if (awaken)
628 : 0 : wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
629 : :
630 [ # # ]: 0 : return ret == 0 ? link_ret : ret;
631 : : }
632 : : EXPORT_SYMBOL(key_reject_and_link);
633 : :
634 : : /**
635 : : * key_put - Discard a reference to a key.
636 : : * @key: The key to discard a reference from.
637 : : *
638 : : * Discard a reference to a key, and when all the references are gone, we
639 : : * schedule the cleanup task to come and pull it out of the tree in process
640 : : * context at some later time.
641 : : */
642 : 142161 : void key_put(struct key *key)
643 : : {
644 [ + + ]: 142161 : if (key) {
645 : 27964 : key_check(key);
646 : :
647 [ + + ]: 27964 : if (refcount_dec_and_test(&key->usage))
648 : 126 : schedule_work(&key_gc_work);
649 : : }
650 : 142161 : }
651 : : EXPORT_SYMBOL(key_put);
652 : :
653 : : /*
654 : : * Find a key by its serial number.
655 : : */
656 : 84 : struct key *key_lookup(key_serial_t id)
657 : : {
658 : 84 : struct rb_node *n;
659 : 84 : struct key *key;
660 : :
661 : 84 : spin_lock(&key_serial_lock);
662 : :
663 : : /* search the tree for the specified key */
664 : 84 : n = key_serial_tree.rb_node;
665 [ + - ]: 397 : while (n) {
666 : 397 : key = rb_entry(n, struct key, serial_node);
667 : :
668 [ + + ]: 397 : if (id < key->serial)
669 : 152 : n = n->rb_left;
670 [ + + ]: 245 : else if (id > key->serial)
671 : 161 : n = n->rb_right;
672 : : else
673 : 84 : goto found;
674 : : }
675 : :
676 : 0 : not_found:
677 : 0 : key = ERR_PTR(-ENOKEY);
678 : 0 : goto error;
679 : :
680 : : found:
681 : : /* A key is allowed to be looked up only if someone still owns a
682 : : * reference to it - otherwise it's awaiting the gc.
683 : : */
684 [ - + ]: 84 : if (!refcount_inc_not_zero(&key->usage))
685 : 0 : goto not_found;
686 : :
687 : 84 : error:
688 : 84 : spin_unlock(&key_serial_lock);
689 : 84 : return key;
690 : : }
691 : :
692 : : /*
693 : : * Find and lock the specified key type against removal.
694 : : *
695 : : * We return with the sem read-locked if successful. If the type wasn't
696 : : * available -ENOKEY is returned instead.
697 : : */
698 : 87 : struct key_type *key_type_lookup(const char *type)
699 : : {
700 : 87 : struct key_type *ktype;
701 : :
702 : 87 : down_read(&key_types_sem);
703 : :
704 : : /* look up the key type to see if it's one of the registered kernel
705 : : * types */
706 [ + - ]: 594 : list_for_each_entry(ktype, &key_types_list, link) {
707 [ + + ]: 594 : if (strcmp(ktype->name, type) == 0)
708 : 87 : goto found_kernel_type;
709 : : }
710 : :
711 : 0 : up_read(&key_types_sem);
712 : 0 : ktype = ERR_PTR(-ENOKEY);
713 : :
714 : 87 : found_kernel_type:
715 : 87 : return ktype;
716 : : }
717 : :
718 : 0 : void key_set_timeout(struct key *key, unsigned timeout)
719 : : {
720 : 0 : time64_t expiry = 0;
721 : :
722 : : /* make the changes with the locks held to prevent races */
723 : 0 : down_write(&key->sem);
724 : :
725 [ # # ]: 0 : if (timeout > 0)
726 : 0 : expiry = ktime_get_real_seconds() + timeout;
727 : :
728 : 0 : key->expiry = expiry;
729 : 0 : key_schedule_gc(key->expiry + key_gc_delay);
730 : :
731 : 0 : up_write(&key->sem);
732 : 0 : }
733 : : EXPORT_SYMBOL_GPL(key_set_timeout);
734 : :
735 : : /*
736 : : * Unlock a key type locked by key_type_lookup().
737 : : */
738 : 87 : void key_type_put(struct key_type *ktype)
739 : : {
740 : 0 : up_read(&key_types_sem);
741 : 87 : }
742 : :
743 : : /*
744 : : * Attempt to update an existing key.
745 : : *
746 : : * The key is given to us with an incremented refcount that we need to discard
747 : : * if we get an error.
748 : : */
749 : 0 : static inline key_ref_t __key_update(key_ref_t key_ref,
750 : : struct key_preparsed_payload *prep)
751 : : {
752 : 0 : struct key *key = key_ref_to_ptr(key_ref);
753 : 0 : int ret;
754 : :
755 : : /* need write permission on the key to update it */
756 : 0 : ret = key_permission(key_ref, KEY_NEED_WRITE);
757 [ # # ]: 0 : if (ret < 0)
758 : 0 : goto error;
759 : :
760 : 0 : ret = -EEXIST;
761 [ # # ]: 0 : if (!key->type->update)
762 : 0 : goto error;
763 : :
764 : 0 : down_write(&key->sem);
765 : :
766 : 0 : ret = key->type->update(key, prep);
767 [ # # ]: 0 : if (ret == 0)
768 : : /* Updating a negative key positively instantiates it */
769 : 0 : mark_key_instantiated(key, 0);
770 : :
771 : 0 : up_write(&key->sem);
772 : :
773 [ # # ]: 0 : if (ret < 0)
774 : 0 : goto error;
775 : 0 : out:
776 : 0 : return key_ref;
777 : :
778 : 0 : error:
779 : 0 : key_put(key);
780 : 0 : key_ref = ERR_PTR(ret);
781 : 0 : goto out;
782 : : }
783 : :
784 : : /**
785 : : * key_create_or_update - Update or create and instantiate a key.
786 : : * @keyring_ref: A pointer to the destination keyring with possession flag.
787 : : * @type: The type of key.
788 : : * @description: The searchable description for the key.
789 : : * @payload: The data to use to instantiate or update the key.
790 : : * @plen: The length of @payload.
791 : : * @perm: The permissions mask for a new key.
792 : : * @flags: The quota flags for a new key.
793 : : *
794 : : * Search the destination keyring for a key of the same description and if one
795 : : * is found, update it, otherwise create and instantiate a new one and create a
796 : : * link to it from that keyring.
797 : : *
798 : : * If perm is KEY_PERM_UNDEF then an appropriate key permissions mask will be
799 : : * concocted.
800 : : *
801 : : * Returns a pointer to the new key if successful, -ENODEV if the key type
802 : : * wasn't available, -ENOTDIR if the keyring wasn't a keyring, -EACCES if the
803 : : * caller isn't permitted to modify the keyring or the LSM did not permit
804 : : * creation of the key.
805 : : *
806 : : * On success, the possession flag from the keyring ref will be tacked on to
807 : : * the key ref before it is returned.
808 : : */
809 : 87 : key_ref_t key_create_or_update(key_ref_t keyring_ref,
810 : : const char *type,
811 : : const char *description,
812 : : const void *payload,
813 : : size_t plen,
814 : : key_perm_t perm,
815 : : unsigned long flags)
816 : : {
817 : 87 : struct keyring_index_key index_key = {
818 : : .description = description,
819 : : };
820 : 87 : struct key_preparsed_payload prep;
821 : 87 : struct assoc_array_edit *edit = NULL;
822 : 87 : const struct cred *cred = current_cred();
823 : 87 : struct key *keyring, *key = NULL;
824 : 87 : key_ref_t key_ref;
825 : 87 : int ret;
826 : 87 : struct key_restriction *restrict_link = NULL;
827 : :
828 : : /* look up the key type to see if it's one of the registered kernel
829 : : * types */
830 : 87 : index_key.type = key_type_lookup(type);
831 [ - + ]: 87 : if (IS_ERR(index_key.type)) {
832 : 0 : key_ref = ERR_PTR(-ENODEV);
833 : 0 : goto error;
834 : : }
835 : :
836 [ + - ]: 87 : key_ref = ERR_PTR(-EINVAL);
837 [ + - ]: 87 : if (!index_key.type->instantiate ||
838 [ + + - + ]: 87 : (!index_key.description && !index_key.type->preparse))
839 : 0 : goto error_put_type;
840 : :
841 [ + + ]: 87 : keyring = key_ref_to_ptr(keyring_ref);
842 : :
843 : 87 : key_check(keyring);
844 : :
845 [ + + ]: 87 : if (!(flags & KEY_ALLOC_BYPASS_RESTRICTION))
846 : 84 : restrict_link = keyring->restrict_link;
847 : :
848 [ - + ]: 87 : key_ref = ERR_PTR(-ENOTDIR);
849 [ - + ]: 87 : if (keyring->type != &key_type_keyring)
850 : 0 : goto error_put_type;
851 : :
852 : 87 : memset(&prep, 0, sizeof(prep));
853 : 87 : prep.data = payload;
854 : 87 : prep.datalen = plen;
855 : 87 : prep.quotalen = index_key.type->def_datalen;
856 : 87 : prep.expiry = TIME64_MAX;
857 [ + - ]: 87 : if (index_key.type->preparse) {
858 : 87 : ret = index_key.type->preparse(&prep);
859 [ - + ]: 87 : if (ret < 0) {
860 : 0 : key_ref = ERR_PTR(ret);
861 : 0 : goto error_free_prep;
862 : : }
863 [ + + ]: 87 : if (!index_key.description)
864 : 3 : index_key.description = prep.description;
865 [ - + ]: 87 : key_ref = ERR_PTR(-EINVAL);
866 [ - + ]: 87 : if (!index_key.description)
867 : 0 : goto error_free_prep;
868 : : }
869 : 87 : index_key.desc_len = strlen(index_key.description);
870 : 87 : key_set_index_key(&index_key);
871 : :
872 : 87 : ret = __key_link_lock(keyring, &index_key);
873 [ - + ]: 87 : if (ret < 0) {
874 : 0 : key_ref = ERR_PTR(ret);
875 : 0 : goto error_free_prep;
876 : : }
877 : :
878 : 87 : ret = __key_link_begin(keyring, &index_key, &edit);
879 [ - + ]: 87 : if (ret < 0) {
880 : 0 : key_ref = ERR_PTR(ret);
881 : 0 : goto error_link_end;
882 : : }
883 : :
884 [ - + - - ]: 87 : if (restrict_link && restrict_link->check) {
885 : 0 : ret = restrict_link->check(keyring, index_key.type,
886 : : &prep.payload, restrict_link->key);
887 [ # # ]: 0 : if (ret < 0) {
888 : 0 : key_ref = ERR_PTR(ret);
889 : 0 : goto error_link_end;
890 : : }
891 : : }
892 : :
893 : : /* if we're going to allocate a new key, we're going to have
894 : : * to modify the keyring */
895 : 87 : ret = key_permission(keyring_ref, KEY_NEED_WRITE);
896 [ - + ]: 87 : if (ret < 0) {
897 : 0 : key_ref = ERR_PTR(ret);
898 : 0 : goto error_link_end;
899 : : }
900 : :
901 : : /* if it's possible to update this type of key, search for an existing
902 : : * key of the same type and description in the destination keyring and
903 : : * update that instead if possible
904 : : */
905 [ + + ]: 87 : if (index_key.type->update) {
906 : 84 : key_ref = find_key_to_update(keyring_ref, &index_key);
907 [ - + ]: 84 : if (key_ref)
908 : 0 : goto found_matching_key;
909 : : }
910 : :
911 : : /* if the client doesn't provide, decide on the permissions we want */
912 [ + + ]: 87 : if (perm == KEY_PERM_UNDEF) {
913 : 84 : perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
914 : 84 : perm |= KEY_USR_VIEW;
915 : :
916 [ + - ]: 84 : if (index_key.type->read)
917 : 84 : perm |= KEY_POS_READ;
918 : :
919 [ + - ]: 84 : if (index_key.type == &key_type_keyring ||
920 [ + - ]: 84 : index_key.type->update)
921 : 84 : perm |= KEY_POS_WRITE;
922 : : }
923 : :
924 : : /* allocate a new key */
925 : 87 : key = key_alloc(index_key.type, index_key.description,
926 : : cred->fsuid, cred->fsgid, cred, perm, flags, NULL);
927 [ - + ]: 87 : if (IS_ERR(key)) {
928 : 0 : key_ref = ERR_CAST(key);
929 : 0 : goto error_link_end;
930 : : }
931 : :
932 : : /* instantiate it and link it into the target keyring */
933 : 87 : ret = __key_instantiate_and_link(key, &prep, keyring, NULL, &edit);
934 [ - + ]: 87 : if (ret < 0) {
935 : 0 : key_put(key);
936 : 0 : key_ref = ERR_PTR(ret);
937 : 0 : goto error_link_end;
938 : : }
939 : :
940 : 87 : ima_post_key_create_or_update(keyring, key, payload, plen,
941 : : flags, true);
942 : :
943 : 87 : key_ref = make_key_ref(key, is_key_possessed(keyring_ref));
944 : :
945 : 87 : error_link_end:
946 : 87 : __key_link_end(keyring, &index_key, edit);
947 : 87 : error_free_prep:
948 [ - + ]: 87 : if (index_key.type->preparse)
949 : 87 : index_key.type->free_preparse(&prep);
950 : 0 : error_put_type:
951 : 87 : key_type_put(index_key.type);
952 : 87 : error:
953 : 87 : return key_ref;
954 : :
955 : : found_matching_key:
956 : : /* we found a matching key, so we're going to try to update it
957 : : * - we can drop the locks first as we have the key pinned
958 : : */
959 : 0 : __key_link_end(keyring, &index_key, edit);
960 : :
961 : 0 : key = key_ref_to_ptr(key_ref);
962 [ # # ]: 0 : if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags)) {
963 : 0 : ret = wait_for_key_construction(key, true);
964 [ # # ]: 0 : if (ret < 0) {
965 : 0 : key_ref_put(key_ref);
966 : 0 : key_ref = ERR_PTR(ret);
967 : 0 : goto error_free_prep;
968 : : }
969 : : }
970 : :
971 : 0 : key_ref = __key_update(key_ref, &prep);
972 : :
973 : 0 : if (!IS_ERR(key_ref))
974 : : ima_post_key_create_or_update(keyring, key,
975 : : payload, plen,
976 : : flags, false);
977 : :
978 : 0 : goto error_free_prep;
979 : : }
980 : : EXPORT_SYMBOL(key_create_or_update);
981 : :
982 : : /**
983 : : * key_update - Update a key's contents.
984 : : * @key_ref: The pointer (plus possession flag) to the key.
985 : : * @payload: The data to be used to update the key.
986 : : * @plen: The length of @payload.
987 : : *
988 : : * Attempt to update the contents of a key with the given payload data. The
989 : : * caller must be granted Write permission on the key. Negative keys can be
990 : : * instantiated by this method.
991 : : *
992 : : * Returns 0 on success, -EACCES if not permitted and -EOPNOTSUPP if the key
993 : : * type does not support updating. The key type may return other errors.
994 : : */
995 : 0 : int key_update(key_ref_t key_ref, const void *payload, size_t plen)
996 : : {
997 : 0 : struct key_preparsed_payload prep;
998 : 0 : struct key *key = key_ref_to_ptr(key_ref);
999 : 0 : int ret;
1000 : :
1001 : 0 : key_check(key);
1002 : :
1003 : : /* the key must be writable */
1004 : 0 : ret = key_permission(key_ref, KEY_NEED_WRITE);
1005 [ # # ]: 0 : if (ret < 0)
1006 : : return ret;
1007 : :
1008 : : /* attempt to update it if supported */
1009 [ # # ]: 0 : if (!key->type->update)
1010 : : return -EOPNOTSUPP;
1011 : :
1012 : 0 : memset(&prep, 0, sizeof(prep));
1013 : 0 : prep.data = payload;
1014 : 0 : prep.datalen = plen;
1015 : 0 : prep.quotalen = key->type->def_datalen;
1016 : 0 : prep.expiry = TIME64_MAX;
1017 [ # # ]: 0 : if (key->type->preparse) {
1018 : 0 : ret = key->type->preparse(&prep);
1019 [ # # ]: 0 : if (ret < 0)
1020 : 0 : goto error;
1021 : : }
1022 : :
1023 : 0 : down_write(&key->sem);
1024 : :
1025 : 0 : ret = key->type->update(key, &prep);
1026 [ # # ]: 0 : if (ret == 0)
1027 : : /* Updating a negative key positively instantiates it */
1028 : 0 : mark_key_instantiated(key, 0);
1029 : :
1030 : 0 : up_write(&key->sem);
1031 : :
1032 : 0 : error:
1033 [ # # ]: 0 : if (key->type->preparse)
1034 : 0 : key->type->free_preparse(&prep);
1035 : : return ret;
1036 : : }
1037 : : EXPORT_SYMBOL(key_update);
1038 : :
1039 : : /**
1040 : : * key_revoke - Revoke a key.
1041 : : * @key: The key to be revoked.
1042 : : *
1043 : : * Mark a key as being revoked and ask the type to free up its resources. The
1044 : : * revocation timeout is set and the key and all its links will be
1045 : : * automatically garbage collected after key_gc_delay amount of time if they
1046 : : * are not manually dealt with first.
1047 : : */
1048 : 0 : void key_revoke(struct key *key)
1049 : : {
1050 : 0 : time64_t time;
1051 : :
1052 : 0 : key_check(key);
1053 : :
1054 : : /* make sure no one's trying to change or use the key when we mark it
1055 : : * - we tell lockdep that we might nest because we might be revoking an
1056 : : * authorisation key whilst holding the sem on a key we've just
1057 : : * instantiated
1058 : : */
1059 : 0 : down_write_nested(&key->sem, 1);
1060 [ # # ]: 0 : if (!test_and_set_bit(KEY_FLAG_REVOKED, &key->flags) &&
1061 [ # # ]: 0 : key->type->revoke)
1062 : 0 : key->type->revoke(key);
1063 : :
1064 : : /* set the death time to no more than the expiry time */
1065 : 0 : time = ktime_get_real_seconds();
1066 [ # # # # ]: 0 : if (key->revoked_at == 0 || key->revoked_at > time) {
1067 : 0 : key->revoked_at = time;
1068 : 0 : key_schedule_gc(key->revoked_at + key_gc_delay);
1069 : : }
1070 : :
1071 : 0 : up_write(&key->sem);
1072 : 0 : }
1073 : : EXPORT_SYMBOL(key_revoke);
1074 : :
1075 : : /**
1076 : : * key_invalidate - Invalidate a key.
1077 : : * @key: The key to be invalidated.
1078 : : *
1079 : : * Mark a key as being invalidated and have it cleaned up immediately. The key
1080 : : * is ignored by all searches and other operations from this point.
1081 : : */
1082 : 0 : void key_invalidate(struct key *key)
1083 : : {
1084 : 0 : kenter("%d", key_serial(key));
1085 : :
1086 : 0 : key_check(key);
1087 : :
1088 [ # # ]: 0 : if (!test_bit(KEY_FLAG_INVALIDATED, &key->flags)) {
1089 : 0 : down_write_nested(&key->sem, 1);
1090 [ # # ]: 0 : if (!test_and_set_bit(KEY_FLAG_INVALIDATED, &key->flags))
1091 : 0 : key_schedule_gc_links();
1092 : 0 : up_write(&key->sem);
1093 : : }
1094 : 0 : }
1095 : : EXPORT_SYMBOL(key_invalidate);
1096 : :
1097 : : /**
1098 : : * generic_key_instantiate - Simple instantiation of a key from preparsed data
1099 : : * @key: The key to be instantiated
1100 : : * @prep: The preparsed data to load.
1101 : : *
1102 : : * Instantiate a key from preparsed data. We assume we can just copy the data
1103 : : * in directly and clear the old pointers.
1104 : : *
1105 : : * This can be pointed to directly by the key type instantiate op pointer.
1106 : : */
1107 : 87 : int generic_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
1108 : : {
1109 : 87 : int ret;
1110 : :
1111 : 87 : pr_devel("==>%s()\n", __func__);
1112 : :
1113 : 87 : ret = key_payload_reserve(key, prep->quotalen);
1114 [ + - ]: 87 : if (ret == 0) {
1115 : 87 : rcu_assign_keypointer(key, prep->payload.data[0]);
1116 : 87 : key->payload.data[1] = prep->payload.data[1];
1117 : 87 : key->payload.data[2] = prep->payload.data[2];
1118 : 87 : key->payload.data[3] = prep->payload.data[3];
1119 : 87 : prep->payload.data[0] = NULL;
1120 : 87 : prep->payload.data[1] = NULL;
1121 : 87 : prep->payload.data[2] = NULL;
1122 : 87 : prep->payload.data[3] = NULL;
1123 : : }
1124 : 87 : pr_devel("<==%s() = %d\n", __func__, ret);
1125 : 87 : return ret;
1126 : : }
1127 : : EXPORT_SYMBOL(generic_key_instantiate);
1128 : :
1129 : : /**
1130 : : * register_key_type - Register a type of key.
1131 : : * @ktype: The new key type.
1132 : : *
1133 : : * Register a new key type.
1134 : : *
1135 : : * Returns 0 on success or -EEXIST if a type of this name already exists.
1136 : : */
1137 : 12 : int register_key_type(struct key_type *ktype)
1138 : : {
1139 : 12 : struct key_type *p;
1140 : 12 : int ret;
1141 : :
1142 : 12 : memset(&ktype->lock_class, 0, sizeof(ktype->lock_class));
1143 : :
1144 : 12 : ret = -EEXIST;
1145 : 12 : down_write(&key_types_sem);
1146 : :
1147 : : /* disallow key types with the same name */
1148 [ + + ]: 78 : list_for_each_entry(p, &key_types_list, link) {
1149 [ - + ]: 66 : if (strcmp(p->name, ktype->name) == 0)
1150 : 0 : goto out;
1151 : : }
1152 : :
1153 : : /* store the type */
1154 : 12 : list_add(&ktype->link, &key_types_list);
1155 : :
1156 : 12 : pr_notice("Key type %s registered\n", ktype->name);
1157 : 12 : ret = 0;
1158 : :
1159 : 12 : out:
1160 : 12 : up_write(&key_types_sem);
1161 : 12 : return ret;
1162 : : }
1163 : : EXPORT_SYMBOL(register_key_type);
1164 : :
1165 : : /**
1166 : : * unregister_key_type - Unregister a type of key.
1167 : : * @ktype: The key type.
1168 : : *
1169 : : * Unregister a key type and mark all the extant keys of this type as dead.
1170 : : * Those keys of this type are then destroyed to get rid of their payloads and
1171 : : * they and their links will be garbage collected as soon as possible.
1172 : : */
1173 : 0 : void unregister_key_type(struct key_type *ktype)
1174 : : {
1175 : 0 : down_write(&key_types_sem);
1176 : 0 : list_del_init(&ktype->link);
1177 : 0 : downgrade_write(&key_types_sem);
1178 : 0 : key_gc_keytype(ktype);
1179 : 0 : pr_notice("Key type %s unregistered\n", ktype->name);
1180 : 0 : up_read(&key_types_sem);
1181 : 0 : }
1182 : : EXPORT_SYMBOL(unregister_key_type);
1183 : :
1184 : : /*
1185 : : * Initialise the key management state.
1186 : : */
1187 : 3 : void __init key_init(void)
1188 : : {
1189 : : /* allocate a slab in which we can store keys */
1190 : 3 : key_jar = kmem_cache_create("key_jar", sizeof(struct key),
1191 : : 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1192 : :
1193 : : /* add the special key types */
1194 : 3 : list_add_tail(&key_type_keyring.link, &key_types_list);
1195 : 3 : list_add_tail(&key_type_dead.link, &key_types_list);
1196 : 3 : list_add_tail(&key_type_user.link, &key_types_list);
1197 : 3 : list_add_tail(&key_type_logon.link, &key_types_list);
1198 : :
1199 : : /* record the root user tracking */
1200 : 3 : rb_link_node(&root_key_user.node,
1201 : : NULL,
1202 : : &key_user_tree.rb_node);
1203 : :
1204 : 3 : rb_insert_color(&root_key_user.node,
1205 : : &key_user_tree);
1206 : 3 : }
|
