1 /* Userspace key control operations 2 * 3 * Copyright (C) 2004-5 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/sched.h> 15 #include <linux/slab.h> 16 #include <linux/syscalls.h> 17 #include <linux/key.h> 18 #include <linux/keyctl.h> 19 #include <linux/fs.h> 20 #include <linux/capability.h> 21 #include <linux/string.h> 22 #include <linux/err.h> 23 #include <linux/vmalloc.h> 24 #include <linux/security.h> 25 #include <asm/uaccess.h> 26 #include "internal.h" 27 28 static int key_get_type_from_user(char *type, 29 const char __user *_type, 30 unsigned len) 31 { 32 int ret; 33 34 ret = strncpy_from_user(type, _type, len); 35 if (ret < 0) 36 return ret; 37 if (ret == 0 || ret >= len) 38 return -EINVAL; 39 if (type[0] == '.') 40 return -EPERM; 41 type[len - 1] = '\0'; 42 return 0; 43 } 44 45 /* 46 * Extract the description of a new key from userspace and either add it as a 47 * new key to the specified keyring or update a matching key in that keyring. 48 * 49 * The keyring must be writable so that we can attach the key to it. 50 * 51 * If successful, the new key's serial number is returned, otherwise an error 52 * code is returned. 53 */ 54 SYSCALL_DEFINE5(add_key, const char __user *, _type, 55 const char __user *, _description, 56 const void __user *, _payload, 57 size_t, plen, 58 key_serial_t, ringid) 59 { 60 key_ref_t keyring_ref, key_ref; 61 char type[32], *description; 62 void *payload; 63 long ret; 64 bool vm; 65 66 ret = -EINVAL; 67 if (plen > 1024 * 1024 - 1) 68 goto error; 69 70 /* draw all the data into kernel space */ 71 ret = key_get_type_from_user(type, _type, sizeof(type)); 72 if (ret < 0) 73 goto error; 74 75 description = strndup_user(_description, PAGE_SIZE); 76 if (IS_ERR(description)) { 77 ret = PTR_ERR(description); 78 goto error; 79 } 80 81 /* pull the payload in if one was supplied */ 82 payload = NULL; 83 84 vm = false; 85 if (_payload) { 86 ret = -ENOMEM; 87 payload = kmalloc(plen, GFP_KERNEL | __GFP_NOWARN); 88 if (!payload) { 89 if (plen <= PAGE_SIZE) 90 goto error2; 91 vm = true; 92 payload = vmalloc(plen); 93 if (!payload) 94 goto error2; 95 } 96 97 ret = -EFAULT; 98 if (copy_from_user(payload, _payload, plen) != 0) 99 goto error3; 100 } 101 102 /* find the target keyring (which must be writable) */ 103 keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE); 104 if (IS_ERR(keyring_ref)) { 105 ret = PTR_ERR(keyring_ref); 106 goto error3; 107 } 108 109 /* create or update the requested key and add it to the target 110 * keyring */ 111 key_ref = key_create_or_update(keyring_ref, type, description, 112 payload, plen, KEY_PERM_UNDEF, 113 KEY_ALLOC_IN_QUOTA); 114 if (!IS_ERR(key_ref)) { 115 ret = key_ref_to_ptr(key_ref)->serial; 116 key_ref_put(key_ref); 117 } 118 else { 119 ret = PTR_ERR(key_ref); 120 } 121 122 key_ref_put(keyring_ref); 123 error3: 124 if (!vm) 125 kfree(payload); 126 else 127 vfree(payload); 128 error2: 129 kfree(description); 130 error: 131 return ret; 132 } 133 134 /* 135 * Search the process keyrings and keyring trees linked from those for a 136 * matching key. Keyrings must have appropriate Search permission to be 137 * searched. 138 * 139 * If a key is found, it will be attached to the destination keyring if there's 140 * one specified and the serial number of the key will be returned. 141 * 142 * If no key is found, /sbin/request-key will be invoked if _callout_info is 143 * non-NULL in an attempt to create a key. The _callout_info string will be 144 * passed to /sbin/request-key to aid with completing the request. If the 145 * _callout_info string is "" then it will be changed to "-". 146 */ 147 SYSCALL_DEFINE4(request_key, const char __user *, _type, 148 const char __user *, _description, 149 const char __user *, _callout_info, 150 key_serial_t, destringid) 151 { 152 struct key_type *ktype; 153 struct key *key; 154 key_ref_t dest_ref; 155 size_t callout_len; 156 char type[32], *description, *callout_info; 157 long ret; 158 159 /* pull the type into kernel space */ 160 ret = key_get_type_from_user(type, _type, sizeof(type)); 161 if (ret < 0) 162 goto error; 163 164 /* pull the description into kernel space */ 165 description = strndup_user(_description, PAGE_SIZE); 166 if (IS_ERR(description)) { 167 ret = PTR_ERR(description); 168 goto error; 169 } 170 171 /* pull the callout info into kernel space */ 172 callout_info = NULL; 173 callout_len = 0; 174 if (_callout_info) { 175 callout_info = strndup_user(_callout_info, PAGE_SIZE); 176 if (IS_ERR(callout_info)) { 177 ret = PTR_ERR(callout_info); 178 goto error2; 179 } 180 callout_len = strlen(callout_info); 181 } 182 183 /* get the destination keyring if specified */ 184 dest_ref = NULL; 185 if (destringid) { 186 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE, 187 KEY_WRITE); 188 if (IS_ERR(dest_ref)) { 189 ret = PTR_ERR(dest_ref); 190 goto error3; 191 } 192 } 193 194 /* find the key type */ 195 ktype = key_type_lookup(type); 196 if (IS_ERR(ktype)) { 197 ret = PTR_ERR(ktype); 198 goto error4; 199 } 200 201 /* do the search */ 202 key = request_key_and_link(ktype, description, callout_info, 203 callout_len, NULL, key_ref_to_ptr(dest_ref), 204 KEY_ALLOC_IN_QUOTA); 205 if (IS_ERR(key)) { 206 ret = PTR_ERR(key); 207 goto error5; 208 } 209 210 /* wait for the key to finish being constructed */ 211 ret = wait_for_key_construction(key, 1); 212 if (ret < 0) 213 goto error6; 214 215 ret = key->serial; 216 217 error6: 218 key_put(key); 219 error5: 220 key_type_put(ktype); 221 error4: 222 key_ref_put(dest_ref); 223 error3: 224 kfree(callout_info); 225 error2: 226 kfree(description); 227 error: 228 return ret; 229 } 230 231 /* 232 * Get the ID of the specified process keyring. 233 * 234 * The requested keyring must have search permission to be found. 235 * 236 * If successful, the ID of the requested keyring will be returned. 237 */ 238 long keyctl_get_keyring_ID(key_serial_t id, int create) 239 { 240 key_ref_t key_ref; 241 unsigned long lflags; 242 long ret; 243 244 lflags = create ? KEY_LOOKUP_CREATE : 0; 245 key_ref = lookup_user_key(id, lflags, KEY_SEARCH); 246 if (IS_ERR(key_ref)) { 247 ret = PTR_ERR(key_ref); 248 goto error; 249 } 250 251 ret = key_ref_to_ptr(key_ref)->serial; 252 key_ref_put(key_ref); 253 error: 254 return ret; 255 } 256 257 /* 258 * Join a (named) session keyring. 259 * 260 * Create and join an anonymous session keyring or join a named session 261 * keyring, creating it if necessary. A named session keyring must have Search 262 * permission for it to be joined. Session keyrings without this permit will 263 * be skipped over. 264 * 265 * If successful, the ID of the joined session keyring will be returned. 266 */ 267 long keyctl_join_session_keyring(const char __user *_name) 268 { 269 char *name; 270 long ret; 271 272 /* fetch the name from userspace */ 273 name = NULL; 274 if (_name) { 275 name = strndup_user(_name, PAGE_SIZE); 276 if (IS_ERR(name)) { 277 ret = PTR_ERR(name); 278 goto error; 279 } 280 } 281 282 /* join the session */ 283 ret = join_session_keyring(name); 284 kfree(name); 285 286 error: 287 return ret; 288 } 289 290 /* 291 * Update a key's data payload from the given data. 292 * 293 * The key must grant the caller Write permission and the key type must support 294 * updating for this to work. A negative key can be positively instantiated 295 * with this call. 296 * 297 * If successful, 0 will be returned. If the key type does not support 298 * updating, then -EOPNOTSUPP will be returned. 299 */ 300 long keyctl_update_key(key_serial_t id, 301 const void __user *_payload, 302 size_t plen) 303 { 304 key_ref_t key_ref; 305 void *payload; 306 long ret; 307 308 ret = -EINVAL; 309 if (plen > PAGE_SIZE) 310 goto error; 311 312 /* pull the payload in if one was supplied */ 313 payload = NULL; 314 if (_payload) { 315 ret = -ENOMEM; 316 payload = kmalloc(plen, GFP_KERNEL); 317 if (!payload) 318 goto error; 319 320 ret = -EFAULT; 321 if (copy_from_user(payload, _payload, plen) != 0) 322 goto error2; 323 } 324 325 /* find the target key (which must be writable) */ 326 key_ref = lookup_user_key(id, 0, KEY_WRITE); 327 if (IS_ERR(key_ref)) { 328 ret = PTR_ERR(key_ref); 329 goto error2; 330 } 331 332 /* update the key */ 333 ret = key_update(key_ref, payload, plen); 334 335 key_ref_put(key_ref); 336 error2: 337 kfree(payload); 338 error: 339 return ret; 340 } 341 342 /* 343 * Revoke a key. 344 * 345 * The key must be grant the caller Write or Setattr permission for this to 346 * work. The key type should give up its quota claim when revoked. The key 347 * and any links to the key will be automatically garbage collected after a 348 * certain amount of time (/proc/sys/kernel/keys/gc_delay). 349 * 350 * If successful, 0 is returned. 351 */ 352 long keyctl_revoke_key(key_serial_t id) 353 { 354 key_ref_t key_ref; 355 long ret; 356 357 key_ref = lookup_user_key(id, 0, KEY_WRITE); 358 if (IS_ERR(key_ref)) { 359 ret = PTR_ERR(key_ref); 360 if (ret != -EACCES) 361 goto error; 362 key_ref = lookup_user_key(id, 0, KEY_SETATTR); 363 if (IS_ERR(key_ref)) { 364 ret = PTR_ERR(key_ref); 365 goto error; 366 } 367 } 368 369 key_revoke(key_ref_to_ptr(key_ref)); 370 ret = 0; 371 372 key_ref_put(key_ref); 373 error: 374 return ret; 375 } 376 377 /* 378 * Invalidate a key. 379 * 380 * The key must be grant the caller Invalidate permission for this to work. 381 * The key and any links to the key will be automatically garbage collected 382 * immediately. 383 * 384 * If successful, 0 is returned. 385 */ 386 long keyctl_invalidate_key(key_serial_t id) 387 { 388 key_ref_t key_ref; 389 long ret; 390 391 kenter("%d", id); 392 393 key_ref = lookup_user_key(id, 0, KEY_SEARCH); 394 if (IS_ERR(key_ref)) { 395 ret = PTR_ERR(key_ref); 396 goto error; 397 } 398 399 key_invalidate(key_ref_to_ptr(key_ref)); 400 ret = 0; 401 402 key_ref_put(key_ref); 403 error: 404 kleave(" = %ld", ret); 405 return ret; 406 } 407 408 /* 409 * Clear the specified keyring, creating an empty process keyring if one of the 410 * special keyring IDs is used. 411 * 412 * The keyring must grant the caller Write permission for this to work. If 413 * successful, 0 will be returned. 414 */ 415 long keyctl_keyring_clear(key_serial_t ringid) 416 { 417 key_ref_t keyring_ref; 418 long ret; 419 420 keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE); 421 if (IS_ERR(keyring_ref)) { 422 ret = PTR_ERR(keyring_ref); 423 424 /* Root is permitted to invalidate certain special keyrings */ 425 if (capable(CAP_SYS_ADMIN)) { 426 keyring_ref = lookup_user_key(ringid, 0, 0); 427 if (IS_ERR(keyring_ref)) 428 goto error; 429 if (test_bit(KEY_FLAG_ROOT_CAN_CLEAR, 430 &key_ref_to_ptr(keyring_ref)->flags)) 431 goto clear; 432 goto error_put; 433 } 434 435 goto error; 436 } 437 438 clear: 439 ret = keyring_clear(key_ref_to_ptr(keyring_ref)); 440 error_put: 441 key_ref_put(keyring_ref); 442 error: 443 return ret; 444 } 445 446 /* 447 * Create a link from a keyring to a key if there's no matching key in the 448 * keyring, otherwise replace the link to the matching key with a link to the 449 * new key. 450 * 451 * The key must grant the caller Link permission and the the keyring must grant 452 * the caller Write permission. Furthermore, if an additional link is created, 453 * the keyring's quota will be extended. 454 * 455 * If successful, 0 will be returned. 456 */ 457 long keyctl_keyring_link(key_serial_t id, key_serial_t ringid) 458 { 459 key_ref_t keyring_ref, key_ref; 460 long ret; 461 462 keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE); 463 if (IS_ERR(keyring_ref)) { 464 ret = PTR_ERR(keyring_ref); 465 goto error; 466 } 467 468 key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_LINK); 469 if (IS_ERR(key_ref)) { 470 ret = PTR_ERR(key_ref); 471 goto error2; 472 } 473 474 ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref)); 475 476 key_ref_put(key_ref); 477 error2: 478 key_ref_put(keyring_ref); 479 error: 480 return ret; 481 } 482 483 /* 484 * Unlink a key from a keyring. 485 * 486 * The keyring must grant the caller Write permission for this to work; the key 487 * itself need not grant the caller anything. If the last link to a key is 488 * removed then that key will be scheduled for destruction. 489 * 490 * If successful, 0 will be returned. 491 */ 492 long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid) 493 { 494 key_ref_t keyring_ref, key_ref; 495 long ret; 496 497 keyring_ref = lookup_user_key(ringid, 0, KEY_WRITE); 498 if (IS_ERR(keyring_ref)) { 499 ret = PTR_ERR(keyring_ref); 500 goto error; 501 } 502 503 key_ref = lookup_user_key(id, KEY_LOOKUP_FOR_UNLINK, 0); 504 if (IS_ERR(key_ref)) { 505 ret = PTR_ERR(key_ref); 506 goto error2; 507 } 508 509 ret = key_unlink(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref)); 510 511 key_ref_put(key_ref); 512 error2: 513 key_ref_put(keyring_ref); 514 error: 515 return ret; 516 } 517 518 /* 519 * Return a description of a key to userspace. 520 * 521 * The key must grant the caller View permission for this to work. 522 * 523 * If there's a buffer, we place up to buflen bytes of data into it formatted 524 * in the following way: 525 * 526 * type;uid;gid;perm;description<NUL> 527 * 528 * If successful, we return the amount of description available, irrespective 529 * of how much we may have copied into the buffer. 530 */ 531 long keyctl_describe_key(key_serial_t keyid, 532 char __user *buffer, 533 size_t buflen) 534 { 535 struct key *key, *instkey; 536 key_ref_t key_ref; 537 char *tmpbuf; 538 long ret; 539 540 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_VIEW); 541 if (IS_ERR(key_ref)) { 542 /* viewing a key under construction is permitted if we have the 543 * authorisation token handy */ 544 if (PTR_ERR(key_ref) == -EACCES) { 545 instkey = key_get_instantiation_authkey(keyid); 546 if (!IS_ERR(instkey)) { 547 key_put(instkey); 548 key_ref = lookup_user_key(keyid, 549 KEY_LOOKUP_PARTIAL, 550 0); 551 if (!IS_ERR(key_ref)) 552 goto okay; 553 } 554 } 555 556 ret = PTR_ERR(key_ref); 557 goto error; 558 } 559 560 okay: 561 /* calculate how much description we're going to return */ 562 ret = -ENOMEM; 563 tmpbuf = kmalloc(PAGE_SIZE, GFP_KERNEL); 564 if (!tmpbuf) 565 goto error2; 566 567 key = key_ref_to_ptr(key_ref); 568 569 ret = snprintf(tmpbuf, PAGE_SIZE - 1, 570 "%s;%d;%d;%08x;%s", 571 key->type->name, 572 key->uid, 573 key->gid, 574 key->perm, 575 key->description ?: ""); 576 577 /* include a NUL char at the end of the data */ 578 if (ret > PAGE_SIZE - 1) 579 ret = PAGE_SIZE - 1; 580 tmpbuf[ret] = 0; 581 ret++; 582 583 /* consider returning the data */ 584 if (buffer && buflen > 0) { 585 if (buflen > ret) 586 buflen = ret; 587 588 if (copy_to_user(buffer, tmpbuf, buflen) != 0) 589 ret = -EFAULT; 590 } 591 592 kfree(tmpbuf); 593 error2: 594 key_ref_put(key_ref); 595 error: 596 return ret; 597 } 598 599 /* 600 * Search the specified keyring and any keyrings it links to for a matching 601 * key. Only keyrings that grant the caller Search permission will be searched 602 * (this includes the starting keyring). Only keys with Search permission can 603 * be found. 604 * 605 * If successful, the found key will be linked to the destination keyring if 606 * supplied and the key has Link permission, and the found key ID will be 607 * returned. 608 */ 609 long keyctl_keyring_search(key_serial_t ringid, 610 const char __user *_type, 611 const char __user *_description, 612 key_serial_t destringid) 613 { 614 struct key_type *ktype; 615 key_ref_t keyring_ref, key_ref, dest_ref; 616 char type[32], *description; 617 long ret; 618 619 /* pull the type and description into kernel space */ 620 ret = key_get_type_from_user(type, _type, sizeof(type)); 621 if (ret < 0) 622 goto error; 623 624 description = strndup_user(_description, PAGE_SIZE); 625 if (IS_ERR(description)) { 626 ret = PTR_ERR(description); 627 goto error; 628 } 629 630 /* get the keyring at which to begin the search */ 631 keyring_ref = lookup_user_key(ringid, 0, KEY_SEARCH); 632 if (IS_ERR(keyring_ref)) { 633 ret = PTR_ERR(keyring_ref); 634 goto error2; 635 } 636 637 /* get the destination keyring if specified */ 638 dest_ref = NULL; 639 if (destringid) { 640 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE, 641 KEY_WRITE); 642 if (IS_ERR(dest_ref)) { 643 ret = PTR_ERR(dest_ref); 644 goto error3; 645 } 646 } 647 648 /* find the key type */ 649 ktype = key_type_lookup(type); 650 if (IS_ERR(ktype)) { 651 ret = PTR_ERR(ktype); 652 goto error4; 653 } 654 655 /* do the search */ 656 key_ref = keyring_search(keyring_ref, ktype, description); 657 if (IS_ERR(key_ref)) { 658 ret = PTR_ERR(key_ref); 659 660 /* treat lack or presence of a negative key the same */ 661 if (ret == -EAGAIN) 662 ret = -ENOKEY; 663 goto error5; 664 } 665 666 /* link the resulting key to the destination keyring if we can */ 667 if (dest_ref) { 668 ret = key_permission(key_ref, KEY_LINK); 669 if (ret < 0) 670 goto error6; 671 672 ret = key_link(key_ref_to_ptr(dest_ref), key_ref_to_ptr(key_ref)); 673 if (ret < 0) 674 goto error6; 675 } 676 677 ret = key_ref_to_ptr(key_ref)->serial; 678 679 error6: 680 key_ref_put(key_ref); 681 error5: 682 key_type_put(ktype); 683 error4: 684 key_ref_put(dest_ref); 685 error3: 686 key_ref_put(keyring_ref); 687 error2: 688 kfree(description); 689 error: 690 return ret; 691 } 692 693 /* 694 * Read a key's payload. 695 * 696 * The key must either grant the caller Read permission, or it must grant the 697 * caller Search permission when searched for from the process keyrings. 698 * 699 * If successful, we place up to buflen bytes of data into the buffer, if one 700 * is provided, and return the amount of data that is available in the key, 701 * irrespective of how much we copied into the buffer. 702 */ 703 long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen) 704 { 705 struct key *key; 706 key_ref_t key_ref; 707 long ret; 708 709 /* find the key first */ 710 key_ref = lookup_user_key(keyid, 0, 0); 711 if (IS_ERR(key_ref)) { 712 ret = -ENOKEY; 713 goto error; 714 } 715 716 key = key_ref_to_ptr(key_ref); 717 718 /* see if we can read it directly */ 719 ret = key_permission(key_ref, KEY_READ); 720 if (ret == 0) 721 goto can_read_key; 722 if (ret != -EACCES) 723 goto error; 724 725 /* we can't; see if it's searchable from this process's keyrings 726 * - we automatically take account of the fact that it may be 727 * dangling off an instantiation key 728 */ 729 if (!is_key_possessed(key_ref)) { 730 ret = -EACCES; 731 goto error2; 732 } 733 734 /* the key is probably readable - now try to read it */ 735 can_read_key: 736 ret = key_validate(key); 737 if (ret == 0) { 738 ret = -EOPNOTSUPP; 739 if (key->type->read) { 740 /* read the data with the semaphore held (since we 741 * might sleep) */ 742 down_read(&key->sem); 743 ret = key->type->read(key, buffer, buflen); 744 up_read(&key->sem); 745 } 746 } 747 748 error2: 749 key_put(key); 750 error: 751 return ret; 752 } 753 754 /* 755 * Change the ownership of a key 756 * 757 * The key must grant the caller Setattr permission for this to work, though 758 * the key need not be fully instantiated yet. For the UID to be changed, or 759 * for the GID to be changed to a group the caller is not a member of, the 760 * caller must have sysadmin capability. If either uid or gid is -1 then that 761 * attribute is not changed. 762 * 763 * If the UID is to be changed, the new user must have sufficient quota to 764 * accept the key. The quota deduction will be removed from the old user to 765 * the new user should the attribute be changed. 766 * 767 * If successful, 0 will be returned. 768 */ 769 long keyctl_chown_key(key_serial_t id, uid_t uid, gid_t gid) 770 { 771 struct key_user *newowner, *zapowner = NULL; 772 struct key *key; 773 key_ref_t key_ref; 774 long ret; 775 776 ret = 0; 777 if (uid == (uid_t) -1 && gid == (gid_t) -1) 778 goto error; 779 780 key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 781 KEY_SETATTR); 782 if (IS_ERR(key_ref)) { 783 ret = PTR_ERR(key_ref); 784 goto error; 785 } 786 787 key = key_ref_to_ptr(key_ref); 788 789 /* make the changes with the locks held to prevent chown/chown races */ 790 ret = -EACCES; 791 down_write(&key->sem); 792 793 if (!capable(CAP_SYS_ADMIN)) { 794 /* only the sysadmin can chown a key to some other UID */ 795 if (uid != (uid_t) -1 && key->uid != uid) 796 goto error_put; 797 798 /* only the sysadmin can set the key's GID to a group other 799 * than one of those that the current process subscribes to */ 800 if (gid != (gid_t) -1 && gid != key->gid && !in_group_p(gid)) 801 goto error_put; 802 } 803 804 /* change the UID */ 805 if (uid != (uid_t) -1 && uid != key->uid) { 806 ret = -ENOMEM; 807 newowner = key_user_lookup(uid, current_user_ns()); 808 if (!newowner) 809 goto error_put; 810 811 /* transfer the quota burden to the new user */ 812 if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) { 813 unsigned maxkeys = (uid == 0) ? 814 key_quota_root_maxkeys : key_quota_maxkeys; 815 unsigned maxbytes = (uid == 0) ? 816 key_quota_root_maxbytes : key_quota_maxbytes; 817 818 spin_lock(&newowner->lock); 819 if (newowner->qnkeys + 1 >= maxkeys || 820 newowner->qnbytes + key->quotalen >= maxbytes || 821 newowner->qnbytes + key->quotalen < 822 newowner->qnbytes) 823 goto quota_overrun; 824 825 newowner->qnkeys++; 826 newowner->qnbytes += key->quotalen; 827 spin_unlock(&newowner->lock); 828 829 spin_lock(&key->user->lock); 830 key->user->qnkeys--; 831 key->user->qnbytes -= key->quotalen; 832 spin_unlock(&key->user->lock); 833 } 834 835 atomic_dec(&key->user->nkeys); 836 atomic_inc(&newowner->nkeys); 837 838 if (test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) { 839 atomic_dec(&key->user->nikeys); 840 atomic_inc(&newowner->nikeys); 841 } 842 843 zapowner = key->user; 844 key->user = newowner; 845 key->uid = uid; 846 } 847 848 /* change the GID */ 849 if (gid != (gid_t) -1) 850 key->gid = gid; 851 852 ret = 0; 853 854 error_put: 855 up_write(&key->sem); 856 key_put(key); 857 if (zapowner) 858 key_user_put(zapowner); 859 error: 860 return ret; 861 862 quota_overrun: 863 spin_unlock(&newowner->lock); 864 zapowner = newowner; 865 ret = -EDQUOT; 866 goto error_put; 867 } 868 869 /* 870 * Change the permission mask on a key. 871 * 872 * The key must grant the caller Setattr permission for this to work, though 873 * the key need not be fully instantiated yet. If the caller does not have 874 * sysadmin capability, it may only change the permission on keys that it owns. 875 */ 876 long keyctl_setperm_key(key_serial_t id, key_perm_t perm) 877 { 878 struct key *key; 879 key_ref_t key_ref; 880 long ret; 881 882 ret = -EINVAL; 883 if (perm & ~(KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL)) 884 goto error; 885 886 key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 887 KEY_SETATTR); 888 if (IS_ERR(key_ref)) { 889 ret = PTR_ERR(key_ref); 890 goto error; 891 } 892 893 key = key_ref_to_ptr(key_ref); 894 895 /* make the changes with the locks held to prevent chown/chmod races */ 896 ret = -EACCES; 897 down_write(&key->sem); 898 899 /* if we're not the sysadmin, we can only change a key that we own */ 900 if (capable(CAP_SYS_ADMIN) || key->uid == current_fsuid()) { 901 key->perm = perm; 902 ret = 0; 903 } 904 905 up_write(&key->sem); 906 key_put(key); 907 error: 908 return ret; 909 } 910 911 /* 912 * Get the destination keyring for instantiation and check that the caller has 913 * Write permission on it. 914 */ 915 static long get_instantiation_keyring(key_serial_t ringid, 916 struct request_key_auth *rka, 917 struct key **_dest_keyring) 918 { 919 key_ref_t dkref; 920 921 *_dest_keyring = NULL; 922 923 /* just return a NULL pointer if we weren't asked to make a link */ 924 if (ringid == 0) 925 return 0; 926 927 /* if a specific keyring is nominated by ID, then use that */ 928 if (ringid > 0) { 929 dkref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE); 930 if (IS_ERR(dkref)) 931 return PTR_ERR(dkref); 932 *_dest_keyring = key_ref_to_ptr(dkref); 933 return 0; 934 } 935 936 if (ringid == KEY_SPEC_REQKEY_AUTH_KEY) 937 return -EINVAL; 938 939 /* otherwise specify the destination keyring recorded in the 940 * authorisation key (any KEY_SPEC_*_KEYRING) */ 941 if (ringid >= KEY_SPEC_REQUESTOR_KEYRING) { 942 *_dest_keyring = key_get(rka->dest_keyring); 943 return 0; 944 } 945 946 return -ENOKEY; 947 } 948 949 /* 950 * Change the request_key authorisation key on the current process. 951 */ 952 static int keyctl_change_reqkey_auth(struct key *key) 953 { 954 struct cred *new; 955 956 new = prepare_creds(); 957 if (!new) 958 return -ENOMEM; 959 960 key_put(new->request_key_auth); 961 new->request_key_auth = key_get(key); 962 963 return commit_creds(new); 964 } 965 966 /* 967 * Copy the iovec data from userspace 968 */ 969 static long copy_from_user_iovec(void *buffer, const struct iovec *iov, 970 unsigned ioc) 971 { 972 for (; ioc > 0; ioc--) { 973 if (copy_from_user(buffer, iov->iov_base, iov->iov_len) != 0) 974 return -EFAULT; 975 buffer += iov->iov_len; 976 iov++; 977 } 978 return 0; 979 } 980 981 /* 982 * Instantiate a key with the specified payload and link the key into the 983 * destination keyring if one is given. 984 * 985 * The caller must have the appropriate instantiation permit set for this to 986 * work (see keyctl_assume_authority). No other permissions are required. 987 * 988 * If successful, 0 will be returned. 989 */ 990 long keyctl_instantiate_key_common(key_serial_t id, 991 const struct iovec *payload_iov, 992 unsigned ioc, 993 size_t plen, 994 key_serial_t ringid) 995 { 996 const struct cred *cred = current_cred(); 997 struct request_key_auth *rka; 998 struct key *instkey, *dest_keyring; 999 void *payload; 1000 long ret; 1001 bool vm = false; 1002 1003 kenter("%d,,%zu,%d", id, plen, ringid); 1004 1005 ret = -EINVAL; 1006 if (plen > 1024 * 1024 - 1) 1007 goto error; 1008 1009 /* the appropriate instantiation authorisation key must have been 1010 * assumed before calling this */ 1011 ret = -EPERM; 1012 instkey = cred->request_key_auth; 1013 if (!instkey) 1014 goto error; 1015 1016 rka = instkey->payload.data; 1017 if (rka->target_key->serial != id) 1018 goto error; 1019 1020 /* pull the payload in if one was supplied */ 1021 payload = NULL; 1022 1023 if (payload_iov) { 1024 ret = -ENOMEM; 1025 payload = kmalloc(plen, GFP_KERNEL); 1026 if (!payload) { 1027 if (plen <= PAGE_SIZE) 1028 goto error; 1029 vm = true; 1030 payload = vmalloc(plen); 1031 if (!payload) 1032 goto error; 1033 } 1034 1035 ret = copy_from_user_iovec(payload, payload_iov, ioc); 1036 if (ret < 0) 1037 goto error2; 1038 } 1039 1040 /* find the destination keyring amongst those belonging to the 1041 * requesting task */ 1042 ret = get_instantiation_keyring(ringid, rka, &dest_keyring); 1043 if (ret < 0) 1044 goto error2; 1045 1046 /* instantiate the key and link it into a keyring */ 1047 ret = key_instantiate_and_link(rka->target_key, payload, plen, 1048 dest_keyring, instkey); 1049 1050 key_put(dest_keyring); 1051 1052 /* discard the assumed authority if it's just been disabled by 1053 * instantiation of the key */ 1054 if (ret == 0) 1055 keyctl_change_reqkey_auth(NULL); 1056 1057 error2: 1058 if (!vm) 1059 kfree(payload); 1060 else 1061 vfree(payload); 1062 error: 1063 return ret; 1064 } 1065 1066 /* 1067 * Instantiate a key with the specified payload and link the key into the 1068 * destination keyring if one is given. 1069 * 1070 * The caller must have the appropriate instantiation permit set for this to 1071 * work (see keyctl_assume_authority). No other permissions are required. 1072 * 1073 * If successful, 0 will be returned. 1074 */ 1075 long keyctl_instantiate_key(key_serial_t id, 1076 const void __user *_payload, 1077 size_t plen, 1078 key_serial_t ringid) 1079 { 1080 if (_payload && plen) { 1081 struct iovec iov[1] = { 1082 [0].iov_base = (void __user *)_payload, 1083 [0].iov_len = plen 1084 }; 1085 1086 return keyctl_instantiate_key_common(id, iov, 1, plen, ringid); 1087 } 1088 1089 return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid); 1090 } 1091 1092 /* 1093 * Instantiate a key with the specified multipart payload and link the key into 1094 * the destination keyring if one is given. 1095 * 1096 * The caller must have the appropriate instantiation permit set for this to 1097 * work (see keyctl_assume_authority). No other permissions are required. 1098 * 1099 * If successful, 0 will be returned. 1100 */ 1101 long keyctl_instantiate_key_iov(key_serial_t id, 1102 const struct iovec __user *_payload_iov, 1103 unsigned ioc, 1104 key_serial_t ringid) 1105 { 1106 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1107 long ret; 1108 1109 if (!_payload_iov || !ioc) 1110 goto no_payload; 1111 1112 ret = rw_copy_check_uvector(WRITE, _payload_iov, ioc, 1113 ARRAY_SIZE(iovstack), iovstack, &iov); 1114 if (ret < 0) 1115 return ret; 1116 if (ret == 0) 1117 goto no_payload_free; 1118 1119 ret = keyctl_instantiate_key_common(id, iov, ioc, ret, ringid); 1120 1121 if (iov != iovstack) 1122 kfree(iov); 1123 return ret; 1124 1125 no_payload_free: 1126 if (iov != iovstack) 1127 kfree(iov); 1128 no_payload: 1129 return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid); 1130 } 1131 1132 /* 1133 * Negatively instantiate the key with the given timeout (in seconds) and link 1134 * the key into the destination keyring if one is given. 1135 * 1136 * The caller must have the appropriate instantiation permit set for this to 1137 * work (see keyctl_assume_authority). No other permissions are required. 1138 * 1139 * The key and any links to the key will be automatically garbage collected 1140 * after the timeout expires. 1141 * 1142 * Negative keys are used to rate limit repeated request_key() calls by causing 1143 * them to return -ENOKEY until the negative key expires. 1144 * 1145 * If successful, 0 will be returned. 1146 */ 1147 long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid) 1148 { 1149 return keyctl_reject_key(id, timeout, ENOKEY, ringid); 1150 } 1151 1152 /* 1153 * Negatively instantiate the key with the given timeout (in seconds) and error 1154 * code and link the key into the destination keyring if one is given. 1155 * 1156 * The caller must have the appropriate instantiation permit set for this to 1157 * work (see keyctl_assume_authority). No other permissions are required. 1158 * 1159 * The key and any links to the key will be automatically garbage collected 1160 * after the timeout expires. 1161 * 1162 * Negative keys are used to rate limit repeated request_key() calls by causing 1163 * them to return the specified error code until the negative key expires. 1164 * 1165 * If successful, 0 will be returned. 1166 */ 1167 long keyctl_reject_key(key_serial_t id, unsigned timeout, unsigned error, 1168 key_serial_t ringid) 1169 { 1170 const struct cred *cred = current_cred(); 1171 struct request_key_auth *rka; 1172 struct key *instkey, *dest_keyring; 1173 long ret; 1174 1175 kenter("%d,%u,%u,%d", id, timeout, error, ringid); 1176 1177 /* must be a valid error code and mustn't be a kernel special */ 1178 if (error <= 0 || 1179 error >= MAX_ERRNO || 1180 error == ERESTARTSYS || 1181 error == ERESTARTNOINTR || 1182 error == ERESTARTNOHAND || 1183 error == ERESTART_RESTARTBLOCK) 1184 return -EINVAL; 1185 1186 /* the appropriate instantiation authorisation key must have been 1187 * assumed before calling this */ 1188 ret = -EPERM; 1189 instkey = cred->request_key_auth; 1190 if (!instkey) 1191 goto error; 1192 1193 rka = instkey->payload.data; 1194 if (rka->target_key->serial != id) 1195 goto error; 1196 1197 /* find the destination keyring if present (which must also be 1198 * writable) */ 1199 ret = get_instantiation_keyring(ringid, rka, &dest_keyring); 1200 if (ret < 0) 1201 goto error; 1202 1203 /* instantiate the key and link it into a keyring */ 1204 ret = key_reject_and_link(rka->target_key, timeout, error, 1205 dest_keyring, instkey); 1206 1207 key_put(dest_keyring); 1208 1209 /* discard the assumed authority if it's just been disabled by 1210 * instantiation of the key */ 1211 if (ret == 0) 1212 keyctl_change_reqkey_auth(NULL); 1213 1214 error: 1215 return ret; 1216 } 1217 1218 /* 1219 * Read or set the default keyring in which request_key() will cache keys and 1220 * return the old setting. 1221 * 1222 * If a process keyring is specified then this will be created if it doesn't 1223 * yet exist. The old setting will be returned if successful. 1224 */ 1225 long keyctl_set_reqkey_keyring(int reqkey_defl) 1226 { 1227 struct cred *new; 1228 int ret, old_setting; 1229 1230 old_setting = current_cred_xxx(jit_keyring); 1231 1232 if (reqkey_defl == KEY_REQKEY_DEFL_NO_CHANGE) 1233 return old_setting; 1234 1235 new = prepare_creds(); 1236 if (!new) 1237 return -ENOMEM; 1238 1239 switch (reqkey_defl) { 1240 case KEY_REQKEY_DEFL_THREAD_KEYRING: 1241 ret = install_thread_keyring_to_cred(new); 1242 if (ret < 0) 1243 goto error; 1244 goto set; 1245 1246 case KEY_REQKEY_DEFL_PROCESS_KEYRING: 1247 ret = install_process_keyring_to_cred(new); 1248 if (ret < 0) { 1249 if (ret != -EEXIST) 1250 goto error; 1251 ret = 0; 1252 } 1253 goto set; 1254 1255 case KEY_REQKEY_DEFL_DEFAULT: 1256 case KEY_REQKEY_DEFL_SESSION_KEYRING: 1257 case KEY_REQKEY_DEFL_USER_KEYRING: 1258 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING: 1259 case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: 1260 goto set; 1261 1262 case KEY_REQKEY_DEFL_NO_CHANGE: 1263 case KEY_REQKEY_DEFL_GROUP_KEYRING: 1264 default: 1265 ret = -EINVAL; 1266 goto error; 1267 } 1268 1269 set: 1270 new->jit_keyring = reqkey_defl; 1271 commit_creds(new); 1272 return old_setting; 1273 error: 1274 abort_creds(new); 1275 return ret; 1276 } 1277 1278 /* 1279 * Set or clear the timeout on a key. 1280 * 1281 * Either the key must grant the caller Setattr permission or else the caller 1282 * must hold an instantiation authorisation token for the key. 1283 * 1284 * The timeout is either 0 to clear the timeout, or a number of seconds from 1285 * the current time. The key and any links to the key will be automatically 1286 * garbage collected after the timeout expires. 1287 * 1288 * If successful, 0 is returned. 1289 */ 1290 long keyctl_set_timeout(key_serial_t id, unsigned timeout) 1291 { 1292 struct key *key, *instkey; 1293 key_ref_t key_ref; 1294 long ret; 1295 1296 key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 1297 KEY_SETATTR); 1298 if (IS_ERR(key_ref)) { 1299 /* setting the timeout on a key under construction is permitted 1300 * if we have the authorisation token handy */ 1301 if (PTR_ERR(key_ref) == -EACCES) { 1302 instkey = key_get_instantiation_authkey(id); 1303 if (!IS_ERR(instkey)) { 1304 key_put(instkey); 1305 key_ref = lookup_user_key(id, 1306 KEY_LOOKUP_PARTIAL, 1307 0); 1308 if (!IS_ERR(key_ref)) 1309 goto okay; 1310 } 1311 } 1312 1313 ret = PTR_ERR(key_ref); 1314 goto error; 1315 } 1316 1317 okay: 1318 key = key_ref_to_ptr(key_ref); 1319 key_set_timeout(key, timeout); 1320 key_put(key); 1321 1322 ret = 0; 1323 error: 1324 return ret; 1325 } 1326 1327 /* 1328 * Assume (or clear) the authority to instantiate the specified key. 1329 * 1330 * This sets the authoritative token currently in force for key instantiation. 1331 * This must be done for a key to be instantiated. It has the effect of making 1332 * available all the keys from the caller of the request_key() that created a 1333 * key to request_key() calls made by the caller of this function. 1334 * 1335 * The caller must have the instantiation key in their process keyrings with a 1336 * Search permission grant available to the caller. 1337 * 1338 * If the ID given is 0, then the setting will be cleared and 0 returned. 1339 * 1340 * If the ID given has a matching an authorisation key, then that key will be 1341 * set and its ID will be returned. The authorisation key can be read to get 1342 * the callout information passed to request_key(). 1343 */ 1344 long keyctl_assume_authority(key_serial_t id) 1345 { 1346 struct key *authkey; 1347 long ret; 1348 1349 /* special key IDs aren't permitted */ 1350 ret = -EINVAL; 1351 if (id < 0) 1352 goto error; 1353 1354 /* we divest ourselves of authority if given an ID of 0 */ 1355 if (id == 0) { 1356 ret = keyctl_change_reqkey_auth(NULL); 1357 goto error; 1358 } 1359 1360 /* attempt to assume the authority temporarily granted to us whilst we 1361 * instantiate the specified key 1362 * - the authorisation key must be in the current task's keyrings 1363 * somewhere 1364 */ 1365 authkey = key_get_instantiation_authkey(id); 1366 if (IS_ERR(authkey)) { 1367 ret = PTR_ERR(authkey); 1368 goto error; 1369 } 1370 1371 ret = keyctl_change_reqkey_auth(authkey); 1372 if (ret < 0) 1373 goto error; 1374 key_put(authkey); 1375 1376 ret = authkey->serial; 1377 error: 1378 return ret; 1379 } 1380 1381 /* 1382 * Get a key's the LSM security label. 1383 * 1384 * The key must grant the caller View permission for this to work. 1385 * 1386 * If there's a buffer, then up to buflen bytes of data will be placed into it. 1387 * 1388 * If successful, the amount of information available will be returned, 1389 * irrespective of how much was copied (including the terminal NUL). 1390 */ 1391 long keyctl_get_security(key_serial_t keyid, 1392 char __user *buffer, 1393 size_t buflen) 1394 { 1395 struct key *key, *instkey; 1396 key_ref_t key_ref; 1397 char *context; 1398 long ret; 1399 1400 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_VIEW); 1401 if (IS_ERR(key_ref)) { 1402 if (PTR_ERR(key_ref) != -EACCES) 1403 return PTR_ERR(key_ref); 1404 1405 /* viewing a key under construction is also permitted if we 1406 * have the authorisation token handy */ 1407 instkey = key_get_instantiation_authkey(keyid); 1408 if (IS_ERR(instkey)) 1409 return PTR_ERR(instkey); 1410 key_put(instkey); 1411 1412 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, 0); 1413 if (IS_ERR(key_ref)) 1414 return PTR_ERR(key_ref); 1415 } 1416 1417 key = key_ref_to_ptr(key_ref); 1418 ret = security_key_getsecurity(key, &context); 1419 if (ret == 0) { 1420 /* if no information was returned, give userspace an empty 1421 * string */ 1422 ret = 1; 1423 if (buffer && buflen > 0 && 1424 copy_to_user(buffer, "", 1) != 0) 1425 ret = -EFAULT; 1426 } else if (ret > 0) { 1427 /* return as much data as there's room for */ 1428 if (buffer && buflen > 0) { 1429 if (buflen > ret) 1430 buflen = ret; 1431 1432 if (copy_to_user(buffer, context, buflen) != 0) 1433 ret = -EFAULT; 1434 } 1435 1436 kfree(context); 1437 } 1438 1439 key_ref_put(key_ref); 1440 return ret; 1441 } 1442 1443 /* 1444 * Attempt to install the calling process's session keyring on the process's 1445 * parent process. 1446 * 1447 * The keyring must exist and must grant the caller LINK permission, and the 1448 * parent process must be single-threaded and must have the same effective 1449 * ownership as this process and mustn't be SUID/SGID. 1450 * 1451 * The keyring will be emplaced on the parent when it next resumes userspace. 1452 * 1453 * If successful, 0 will be returned. 1454 */ 1455 long keyctl_session_to_parent(void) 1456 { 1457 struct task_struct *me, *parent; 1458 const struct cred *mycred, *pcred; 1459 struct callback_head *newwork, *oldwork; 1460 key_ref_t keyring_r; 1461 struct cred *cred; 1462 int ret; 1463 1464 keyring_r = lookup_user_key(KEY_SPEC_SESSION_KEYRING, 0, KEY_LINK); 1465 if (IS_ERR(keyring_r)) 1466 return PTR_ERR(keyring_r); 1467 1468 ret = -ENOMEM; 1469 1470 /* our parent is going to need a new cred struct, a new tgcred struct 1471 * and new security data, so we allocate them here to prevent ENOMEM in 1472 * our parent */ 1473 cred = cred_alloc_blank(); 1474 if (!cred) 1475 goto error_keyring; 1476 newwork = &cred->rcu; 1477 1478 cred->tgcred->session_keyring = key_ref_to_ptr(keyring_r); 1479 init_task_work(newwork, key_change_session_keyring); 1480 1481 me = current; 1482 rcu_read_lock(); 1483 write_lock_irq(&tasklist_lock); 1484 1485 ret = -EPERM; 1486 oldwork = NULL; 1487 parent = me->real_parent; 1488 1489 task_lock(parent); 1490 /* the parent mustn't be init and mustn't be a kernel thread */ 1491 if (parent->pid <= 1 || !parent->mm) 1492 goto unlock; 1493 1494 /* the parent must be single threaded */ 1495 if (!thread_group_empty(parent)) 1496 goto unlock; 1497 1498 /* the parent and the child must have different session keyrings or 1499 * there's no point */ 1500 mycred = current_cred(); 1501 pcred = __task_cred(parent); 1502 if (mycred == pcred || 1503 mycred->tgcred->session_keyring == pcred->tgcred->session_keyring) { 1504 ret = 0; 1505 goto unlock; 1506 } 1507 1508 /* the parent must have the same effective ownership and mustn't be 1509 * SUID/SGID */ 1510 if (pcred->uid != mycred->euid || 1511 pcred->euid != mycred->euid || 1512 pcred->suid != mycred->euid || 1513 pcred->gid != mycred->egid || 1514 pcred->egid != mycred->egid || 1515 pcred->sgid != mycred->egid) 1516 goto unlock; 1517 1518 /* the keyrings must have the same UID */ 1519 if ((pcred->tgcred->session_keyring && 1520 pcred->tgcred->session_keyring->uid != mycred->euid) || 1521 mycred->tgcred->session_keyring->uid != mycred->euid) 1522 goto unlock; 1523 1524 /* cancel an already pending keyring replacement */ 1525 oldwork = task_work_cancel(parent, key_change_session_keyring); 1526 1527 /* the replacement session keyring is applied just prior to userspace 1528 * restarting */ 1529 ret = task_work_add(parent, newwork, true); 1530 if (!ret) 1531 newwork = NULL; 1532 unlock: 1533 task_unlock(parent); 1534 write_unlock_irq(&tasklist_lock); 1535 rcu_read_unlock(); 1536 if (oldwork) 1537 put_cred(container_of(oldwork, struct cred, rcu)); 1538 if (newwork) 1539 put_cred(cred); 1540 return ret; 1541 1542 error_keyring: 1543 key_ref_put(keyring_r); 1544 return ret; 1545 } 1546 1547 /* 1548 * The key control system call 1549 */ 1550 SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3, 1551 unsigned long, arg4, unsigned long, arg5) 1552 { 1553 switch (option) { 1554 case KEYCTL_GET_KEYRING_ID: 1555 return keyctl_get_keyring_ID((key_serial_t) arg2, 1556 (int) arg3); 1557 1558 case KEYCTL_JOIN_SESSION_KEYRING: 1559 return keyctl_join_session_keyring((const char __user *) arg2); 1560 1561 case KEYCTL_UPDATE: 1562 return keyctl_update_key((key_serial_t) arg2, 1563 (const void __user *) arg3, 1564 (size_t) arg4); 1565 1566 case KEYCTL_REVOKE: 1567 return keyctl_revoke_key((key_serial_t) arg2); 1568 1569 case KEYCTL_DESCRIBE: 1570 return keyctl_describe_key((key_serial_t) arg2, 1571 (char __user *) arg3, 1572 (unsigned) arg4); 1573 1574 case KEYCTL_CLEAR: 1575 return keyctl_keyring_clear((key_serial_t) arg2); 1576 1577 case KEYCTL_LINK: 1578 return keyctl_keyring_link((key_serial_t) arg2, 1579 (key_serial_t) arg3); 1580 1581 case KEYCTL_UNLINK: 1582 return keyctl_keyring_unlink((key_serial_t) arg2, 1583 (key_serial_t) arg3); 1584 1585 case KEYCTL_SEARCH: 1586 return keyctl_keyring_search((key_serial_t) arg2, 1587 (const char __user *) arg3, 1588 (const char __user *) arg4, 1589 (key_serial_t) arg5); 1590 1591 case KEYCTL_READ: 1592 return keyctl_read_key((key_serial_t) arg2, 1593 (char __user *) arg3, 1594 (size_t) arg4); 1595 1596 case KEYCTL_CHOWN: 1597 return keyctl_chown_key((key_serial_t) arg2, 1598 (uid_t) arg3, 1599 (gid_t) arg4); 1600 1601 case KEYCTL_SETPERM: 1602 return keyctl_setperm_key((key_serial_t) arg2, 1603 (key_perm_t) arg3); 1604 1605 case KEYCTL_INSTANTIATE: 1606 return keyctl_instantiate_key((key_serial_t) arg2, 1607 (const void __user *) arg3, 1608 (size_t) arg4, 1609 (key_serial_t) arg5); 1610 1611 case KEYCTL_NEGATE: 1612 return keyctl_negate_key((key_serial_t) arg2, 1613 (unsigned) arg3, 1614 (key_serial_t) arg4); 1615 1616 case KEYCTL_SET_REQKEY_KEYRING: 1617 return keyctl_set_reqkey_keyring(arg2); 1618 1619 case KEYCTL_SET_TIMEOUT: 1620 return keyctl_set_timeout((key_serial_t) arg2, 1621 (unsigned) arg3); 1622 1623 case KEYCTL_ASSUME_AUTHORITY: 1624 return keyctl_assume_authority((key_serial_t) arg2); 1625 1626 case KEYCTL_GET_SECURITY: 1627 return keyctl_get_security((key_serial_t) arg2, 1628 (char __user *) arg3, 1629 (size_t) arg4); 1630 1631 case KEYCTL_SESSION_TO_PARENT: 1632 return keyctl_session_to_parent(); 1633 1634 case KEYCTL_REJECT: 1635 return keyctl_reject_key((key_serial_t) arg2, 1636 (unsigned) arg3, 1637 (unsigned) arg4, 1638 (key_serial_t) arg5); 1639 1640 case KEYCTL_INSTANTIATE_IOV: 1641 return keyctl_instantiate_key_iov( 1642 (key_serial_t) arg2, 1643 (const struct iovec __user *) arg3, 1644 (unsigned) arg4, 1645 (key_serial_t) arg5); 1646 1647 case KEYCTL_INVALIDATE: 1648 return keyctl_invalidate_key((key_serial_t) arg2); 1649 1650 default: 1651 return -EOPNOTSUPP; 1652 } 1653 } 1654