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