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