1/* Request a key from userspace 2 * 3 * Copyright (C) 2004-2007 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 * See Documentation/keys-request-key.txt 12 */ 13 14#include <linux/module.h> 15#include <linux/sched.h> 16#include <linux/kmod.h> 17#include <linux/err.h> 18#include <linux/keyctl.h> 19#include <linux/slab.h> 20#include "internal.h" 21 22#define key_negative_timeout 60 /* default timeout on a negative key's existence */ 23 24/* 25 * wait_on_bit() sleep function for uninterruptible waiting 26 */ 27static int key_wait_bit(void *flags) 28{ 29 schedule(); 30 return 0; 31} 32 33/* 34 * wait_on_bit() sleep function for interruptible waiting 35 */ 36static int key_wait_bit_intr(void *flags) 37{ 38 schedule(); 39 return signal_pending(current) ? -ERESTARTSYS : 0; 40} 41 42/* 43 * call to complete the construction of a key 44 */ 45void complete_request_key(struct key_construction *cons, int error) 46{ 47 kenter("{%d,%d},%d", cons->key->serial, cons->authkey->serial, error); 48 49 if (error < 0) 50 key_negate_and_link(cons->key, key_negative_timeout, NULL, 51 cons->authkey); 52 else 53 key_revoke(cons->authkey); 54 55 key_put(cons->key); 56 key_put(cons->authkey); 57 kfree(cons); 58} 59EXPORT_SYMBOL(complete_request_key); 60 61static int umh_keys_init(struct subprocess_info *info) 62{ 63 struct cred *cred = (struct cred*)current_cred(); 64 struct key *keyring = info->data; 65 /* 66 * This is called in context of freshly forked kthread before 67 * kernel_execve(), we can just change our ->session_keyring. 68 */ 69 return install_session_keyring_to_cred(cred, keyring); 70} 71 72static void umh_keys_cleanup(struct subprocess_info *info) 73{ 74 struct key *keyring = info->data; 75 key_put(keyring); 76} 77 78static int call_usermodehelper_keys(char *path, char **argv, char **envp, 79 struct key *session_keyring, enum umh_wait wait) 80{ 81 gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL; 82 struct subprocess_info *info = 83 call_usermodehelper_setup(path, argv, envp, gfp_mask); 84 85 if (!info) 86 return -ENOMEM; 87 88 call_usermodehelper_setfns(info, umh_keys_init, umh_keys_cleanup, 89 key_get(session_keyring)); 90 return call_usermodehelper_exec(info, wait); 91} 92 93/* 94 * request userspace finish the construction of a key 95 * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>" 96 */ 97static int call_sbin_request_key(struct key_construction *cons, 98 const char *op, 99 void *aux) 100{ 101 const struct cred *cred = current_cred(); 102 key_serial_t prkey, sskey; 103 struct key *key = cons->key, *authkey = cons->authkey, *keyring, 104 *session; 105 char *argv[9], *envp[3], uid_str[12], gid_str[12]; 106 char key_str[12], keyring_str[3][12]; 107 char desc[20]; 108 int ret, i; 109 110 kenter("{%d},{%d},%s", key->serial, authkey->serial, op); 111 112 ret = install_user_keyrings(); 113 if (ret < 0) 114 goto error_alloc; 115 116 /* allocate a new session keyring */ 117 sprintf(desc, "_req.%u", key->serial); 118 119 cred = get_current_cred(); 120 keyring = keyring_alloc(desc, cred->fsuid, cred->fsgid, cred, 121 KEY_ALLOC_QUOTA_OVERRUN, NULL); 122 put_cred(cred); 123 if (IS_ERR(keyring)) { 124 ret = PTR_ERR(keyring); 125 goto error_alloc; 126 } 127 128 /* attach the auth key to the session keyring */ 129 ret = key_link(keyring, authkey); 130 if (ret < 0) 131 goto error_link; 132 133 /* record the UID and GID */ 134 sprintf(uid_str, "%d", cred->fsuid); 135 sprintf(gid_str, "%d", cred->fsgid); 136 137 /* we say which key is under construction */ 138 sprintf(key_str, "%d", key->serial); 139 140 /* we specify the process's default keyrings */ 141 sprintf(keyring_str[0], "%d", 142 cred->thread_keyring ? cred->thread_keyring->serial : 0); 143 144 prkey = 0; 145 if (cred->tgcred->process_keyring) 146 prkey = cred->tgcred->process_keyring->serial; 147 sprintf(keyring_str[1], "%d", prkey); 148 149 rcu_read_lock(); 150 session = rcu_dereference(cred->tgcred->session_keyring); 151 if (!session) 152 session = cred->user->session_keyring; 153 sskey = session->serial; 154 rcu_read_unlock(); 155 156 sprintf(keyring_str[2], "%d", sskey); 157 158 /* set up a minimal environment */ 159 i = 0; 160 envp[i++] = "HOME=/"; 161 envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; 162 envp[i] = NULL; 163 164 /* set up the argument list */ 165 i = 0; 166 argv[i++] = "/sbin/request-key"; 167 argv[i++] = (char *) op; 168 argv[i++] = key_str; 169 argv[i++] = uid_str; 170 argv[i++] = gid_str; 171 argv[i++] = keyring_str[0]; 172 argv[i++] = keyring_str[1]; 173 argv[i++] = keyring_str[2]; 174 argv[i] = NULL; 175 176 /* do it */ 177 ret = call_usermodehelper_keys(argv[0], argv, envp, keyring, 178 UMH_WAIT_PROC); 179 kdebug("usermode -> 0x%x", ret); 180 if (ret >= 0) { 181 /* ret is the exit/wait code */ 182 if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags) || 183 key_validate(key) < 0) 184 ret = -ENOKEY; 185 else 186 /* ignore any errors from userspace if the key was 187 * instantiated */ 188 ret = 0; 189 } 190 191error_link: 192 key_put(keyring); 193 194error_alloc: 195 complete_request_key(cons, ret); 196 kleave(" = %d", ret); 197 return ret; 198} 199 200/* 201 * call out to userspace for key construction 202 * - we ignore program failure and go on key status instead 203 */ 204static int construct_key(struct key *key, const void *callout_info, 205 size_t callout_len, void *aux, 206 struct key *dest_keyring) 207{ 208 struct key_construction *cons; 209 request_key_actor_t actor; 210 struct key *authkey; 211 int ret; 212 213 kenter("%d,%p,%zu,%p", key->serial, callout_info, callout_len, aux); 214 215 cons = kmalloc(sizeof(*cons), GFP_KERNEL); 216 if (!cons) 217 return -ENOMEM; 218 219 /* allocate an authorisation key */ 220 authkey = request_key_auth_new(key, callout_info, callout_len, 221 dest_keyring); 222 if (IS_ERR(authkey)) { 223 kfree(cons); 224 ret = PTR_ERR(authkey); 225 authkey = NULL; 226 } else { 227 cons->authkey = key_get(authkey); 228 cons->key = key_get(key); 229 230 /* make the call */ 231 actor = call_sbin_request_key; 232 if (key->type->request_key) 233 actor = key->type->request_key; 234 235 ret = actor(cons, "create", aux); 236 237 /* check that the actor called complete_request_key() prior to 238 * returning an error */ 239 WARN_ON(ret < 0 && 240 !test_bit(KEY_FLAG_REVOKED, &authkey->flags)); 241 key_put(authkey); 242 } 243 244 kleave(" = %d", ret); 245 return ret; 246} 247 248/* 249 * get the appropriate destination keyring for the request 250 * - we return whatever keyring we select with an extra reference upon it which 251 * the caller must release 252 */ 253static void construct_get_dest_keyring(struct key **_dest_keyring) 254{ 255 struct request_key_auth *rka; 256 const struct cred *cred = current_cred(); 257 struct key *dest_keyring = *_dest_keyring, *authkey; 258 259 kenter("%p", dest_keyring); 260 261 /* find the appropriate keyring */ 262 if (dest_keyring) { 263 /* the caller supplied one */ 264 key_get(dest_keyring); 265 } else { 266 /* use a default keyring; falling through the cases until we 267 * find one that we actually have */ 268 switch (cred->jit_keyring) { 269 case KEY_REQKEY_DEFL_DEFAULT: 270 case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: 271 if (cred->request_key_auth) { 272 authkey = cred->request_key_auth; 273 down_read(&authkey->sem); 274 rka = authkey->payload.data; 275 if (!test_bit(KEY_FLAG_REVOKED, 276 &authkey->flags)) 277 dest_keyring = 278 key_get(rka->dest_keyring); 279 up_read(&authkey->sem); 280 if (dest_keyring) 281 break; 282 } 283 284 case KEY_REQKEY_DEFL_THREAD_KEYRING: 285 dest_keyring = key_get(cred->thread_keyring); 286 if (dest_keyring) 287 break; 288 289 case KEY_REQKEY_DEFL_PROCESS_KEYRING: 290 dest_keyring = key_get(cred->tgcred->process_keyring); 291 if (dest_keyring) 292 break; 293 294 case KEY_REQKEY_DEFL_SESSION_KEYRING: 295 rcu_read_lock(); 296 dest_keyring = key_get( 297 rcu_dereference(cred->tgcred->session_keyring)); 298 rcu_read_unlock(); 299 300 if (dest_keyring) 301 break; 302 303 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING: 304 dest_keyring = 305 key_get(cred->user->session_keyring); 306 break; 307 308 case KEY_REQKEY_DEFL_USER_KEYRING: 309 dest_keyring = key_get(cred->user->uid_keyring); 310 break; 311 312 case KEY_REQKEY_DEFL_GROUP_KEYRING: 313 default: 314 BUG(); 315 } 316 } 317 318 *_dest_keyring = dest_keyring; 319 kleave(" [dk %d]", key_serial(dest_keyring)); 320 return; 321} 322 323/* 324 * allocate a new key in under-construction state and attempt to link it in to 325 * the requested place 326 * - may return a key that's already under construction instead 327 */ 328static int construct_alloc_key(struct key_type *type, 329 const char *description, 330 struct key *dest_keyring, 331 unsigned long flags, 332 struct key_user *user, 333 struct key **_key) 334{ 335 struct keyring_list *prealloc; 336 const struct cred *cred = current_cred(); 337 struct key *key; 338 key_ref_t key_ref; 339 int ret; 340 341 kenter("%s,%s,,,", type->name, description); 342 343 *_key = NULL; 344 mutex_lock(&user->cons_lock); 345 346 key = key_alloc(type, description, cred->fsuid, cred->fsgid, cred, 347 KEY_POS_ALL, flags); 348 if (IS_ERR(key)) 349 goto alloc_failed; 350 351 set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags); 352 353 if (dest_keyring) { 354 ret = __key_link_begin(dest_keyring, type, description, 355 &prealloc); 356 if (ret < 0) 357 goto link_prealloc_failed; 358 } 359 360 /* attach the key to the destination keyring under lock, but we do need 361 * to do another check just in case someone beat us to it whilst we 362 * waited for locks */ 363 mutex_lock(&key_construction_mutex); 364 365 key_ref = search_process_keyrings(type, description, type->match, cred); 366 if (!IS_ERR(key_ref)) 367 goto key_already_present; 368 369 if (dest_keyring) 370 __key_link(dest_keyring, key, &prealloc); 371 372 mutex_unlock(&key_construction_mutex); 373 if (dest_keyring) 374 __key_link_end(dest_keyring, type, prealloc); 375 mutex_unlock(&user->cons_lock); 376 *_key = key; 377 kleave(" = 0 [%d]", key_serial(key)); 378 return 0; 379 380 /* the key is now present - we tell the caller that we found it by 381 * returning -EINPROGRESS */ 382key_already_present: 383 key_put(key); 384 mutex_unlock(&key_construction_mutex); 385 key = key_ref_to_ptr(key_ref); 386 if (dest_keyring) { 387 ret = __key_link_check_live_key(dest_keyring, key); 388 if (ret == 0) 389 __key_link(dest_keyring, key, &prealloc); 390 __key_link_end(dest_keyring, type, prealloc); 391 if (ret < 0) 392 goto link_check_failed; 393 } 394 mutex_unlock(&user->cons_lock); 395 *_key = key; 396 kleave(" = -EINPROGRESS [%d]", key_serial(key)); 397 return -EINPROGRESS; 398 399link_check_failed: 400 mutex_unlock(&user->cons_lock); 401 key_put(key); 402 kleave(" = %d [linkcheck]", ret); 403 return ret; 404 405link_prealloc_failed: 406 mutex_unlock(&user->cons_lock); 407 kleave(" = %d [prelink]", ret); 408 return ret; 409 410alloc_failed: 411 mutex_unlock(&user->cons_lock); 412 kleave(" = %ld", PTR_ERR(key)); 413 return PTR_ERR(key); 414} 415 416/* 417 * commence key construction 418 */ 419static struct key *construct_key_and_link(struct key_type *type, 420 const char *description, 421 const char *callout_info, 422 size_t callout_len, 423 void *aux, 424 struct key *dest_keyring, 425 unsigned long flags) 426{ 427 struct key_user *user; 428 struct key *key; 429 int ret; 430 431 kenter(""); 432 433 user = key_user_lookup(current_fsuid(), current_user_ns()); 434 if (!user) 435 return ERR_PTR(-ENOMEM); 436 437 construct_get_dest_keyring(&dest_keyring); 438 439 ret = construct_alloc_key(type, description, dest_keyring, flags, user, 440 &key); 441 key_user_put(user); 442 443 if (ret == 0) { 444 ret = construct_key(key, callout_info, callout_len, aux, 445 dest_keyring); 446 if (ret < 0) { 447 kdebug("cons failed"); 448 goto construction_failed; 449 } 450 } else if (ret == -EINPROGRESS) { 451 ret = 0; 452 } else { 453 key = ERR_PTR(ret); 454 } 455 456 key_put(dest_keyring); 457 kleave(" = key %d", key_serial(key)); 458 return key; 459 460construction_failed: 461 key_negate_and_link(key, key_negative_timeout, NULL, NULL); 462 key_put(key); 463 key_put(dest_keyring); 464 kleave(" = %d", ret); 465 return ERR_PTR(ret); 466} 467 468/* 469 * request a key 470 * - search the process's keyrings 471 * - check the list of keys being created or updated 472 * - call out to userspace for a key if supplementary info was provided 473 * - cache the key in an appropriate keyring 474 */ 475struct key *request_key_and_link(struct key_type *type, 476 const char *description, 477 const void *callout_info, 478 size_t callout_len, 479 void *aux, 480 struct key *dest_keyring, 481 unsigned long flags) 482{ 483 const struct cred *cred = current_cred(); 484 struct key *key; 485 key_ref_t key_ref; 486 int ret; 487 488 kenter("%s,%s,%p,%zu,%p,%p,%lx", 489 type->name, description, callout_info, callout_len, aux, 490 dest_keyring, flags); 491 492 /* search all the process keyrings for a key */ 493 key_ref = search_process_keyrings(type, description, type->match, 494 cred); 495 496 if (!IS_ERR(key_ref)) { 497 key = key_ref_to_ptr(key_ref); 498 if (dest_keyring) { 499 construct_get_dest_keyring(&dest_keyring); 500 ret = key_link(dest_keyring, key); 501 key_put(dest_keyring); 502 if (ret < 0) { 503 key_put(key); 504 key = ERR_PTR(ret); 505 goto error; 506 } 507 } 508 } else if (PTR_ERR(key_ref) != -EAGAIN) { 509 key = ERR_CAST(key_ref); 510 } else { 511 /* the search failed, but the keyrings were searchable, so we 512 * should consult userspace if we can */ 513 key = ERR_PTR(-ENOKEY); 514 if (!callout_info) 515 goto error; 516 517 key = construct_key_and_link(type, description, callout_info, 518 callout_len, aux, dest_keyring, 519 flags); 520 } 521 522error: 523 kleave(" = %p", key); 524 return key; 525} 526 527/* 528 * wait for construction of a key to complete 529 */ 530int wait_for_key_construction(struct key *key, bool intr) 531{ 532 int ret; 533 534 ret = wait_on_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT, 535 intr ? key_wait_bit_intr : key_wait_bit, 536 intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE); 537 if (ret < 0) 538 return ret; 539 if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) 540 return -ENOKEY; 541 return key_validate(key); 542} 543EXPORT_SYMBOL(wait_for_key_construction); 544 545/* 546 * request a key 547 * - search the process's keyrings 548 * - check the list of keys being created or updated 549 * - call out to userspace for a key if supplementary info was provided 550 * - waits uninterruptible for creation to complete 551 */ 552struct key *request_key(struct key_type *type, 553 const char *description, 554 const char *callout_info) 555{ 556 struct key *key; 557 size_t callout_len = 0; 558 int ret; 559 560 if (callout_info) 561 callout_len = strlen(callout_info); 562 key = request_key_and_link(type, description, callout_info, callout_len, 563 NULL, NULL, KEY_ALLOC_IN_QUOTA); 564 if (!IS_ERR(key)) { 565 ret = wait_for_key_construction(key, false); 566 if (ret < 0) { 567 key_put(key); 568 return ERR_PTR(ret); 569 } 570 } 571 return key; 572} 573EXPORT_SYMBOL(request_key); 574 575/* 576 * request a key with auxiliary data for the upcaller 577 * - search the process's keyrings 578 * - check the list of keys being created or updated 579 * - call out to userspace for a key if supplementary info was provided 580 * - waits uninterruptible for creation to complete 581 */ 582struct key *request_key_with_auxdata(struct key_type *type, 583 const char *description, 584 const void *callout_info, 585 size_t callout_len, 586 void *aux) 587{ 588 struct key *key; 589 int ret; 590 591 key = request_key_and_link(type, description, callout_info, callout_len, 592 aux, NULL, KEY_ALLOC_IN_QUOTA); 593 if (!IS_ERR(key)) { 594 ret = wait_for_key_construction(key, false); 595 if (ret < 0) { 596 key_put(key); 597 return ERR_PTR(ret); 598 } 599 } 600 return key; 601} 602EXPORT_SYMBOL(request_key_with_auxdata); 603 604/* 605 * request a key (allow async construction) 606 * - search the process's keyrings 607 * - check the list of keys being created or updated 608 * - call out to userspace for a key if supplementary info was provided 609 */ 610struct key *request_key_async(struct key_type *type, 611 const char *description, 612 const void *callout_info, 613 size_t callout_len) 614{ 615 return request_key_and_link(type, description, callout_info, 616 callout_len, NULL, NULL, 617 KEY_ALLOC_IN_QUOTA); 618} 619EXPORT_SYMBOL(request_key_async); 620 621/* 622 * request a key with auxiliary data for the upcaller (allow async construction) 623 * - search the process's keyrings 624 * - check the list of keys being created or updated 625 * - call out to userspace for a key if supplementary info was provided 626 */ 627struct key *request_key_async_with_auxdata(struct key_type *type, 628 const char *description, 629 const void *callout_info, 630 size_t callout_len, 631 void *aux) 632{ 633 return request_key_and_link(type, description, callout_info, 634 callout_len, aux, NULL, KEY_ALLOC_IN_QUOTA); 635} 636EXPORT_SYMBOL(request_key_async_with_auxdata); 637