keys.c
1 /* 2 * Copyright (c) 1997 - 2011 Kungliga Tekniska Högskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "hdb_locl.h" 35 36 /* 37 * free all the memory used by (len, keys) 38 */ 39 40 void 41 hdb_free_keys(krb5_context context, size_t len, Key *keys) 42 { 43 size_t i; 44 45 for (i = 0; i < len; i++) { 46 free(keys[i].mkvno); 47 keys[i].mkvno = NULL; 48 if (keys[i].salt != NULL) { 49 free_Salt(keys[i].salt); 50 free(keys[i].salt); 51 keys[i].salt = NULL; 52 } 53 krb5_free_keyblock_contents(context, &keys[i].key); 54 } 55 free (keys); 56 } 57 58 /* 59 * for each entry in `default_keys' try to parse it as a sequence 60 * of etype:salttype:salt, syntax of this if something like: 61 * [(des|des3|etype):](pw-salt|afs3)[:string], if etype is omitted it 62 * means all etypes, and if string is omitted is means the default 63 * string (for that principal). Additional special values: 64 * v5 == pw-salt, and 65 * v4 == des:pw-salt: 66 * afs or afs3 == des:afs3-salt 67 */ 68 69 static const krb5_enctype des_etypes[] = { 70 KRB5_ENCTYPE_DES_CBC_MD5, 71 KRB5_ENCTYPE_DES_CBC_MD4, 72 KRB5_ENCTYPE_DES_CBC_CRC 73 }; 74 75 static const krb5_enctype all_etypes[] = { 76 KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96, 77 KRB5_ENCTYPE_ARCFOUR_HMAC_MD5, 78 KRB5_ENCTYPE_DES3_CBC_SHA1 79 }; 80 81 static krb5_error_code 82 parse_key_set(krb5_context context, const char *key, 83 krb5_enctype **ret_enctypes, size_t *ret_num_enctypes, 84 krb5_salt *salt, krb5_principal principal) 85 { 86 const char *p; 87 char buf[3][256]; 88 int num_buf = 0; 89 int i, num_enctypes = 0; 90 krb5_enctype e; 91 const krb5_enctype *enctypes = NULL; 92 krb5_error_code ret; 93 94 p = key; 95 96 *ret_enctypes = NULL; 97 *ret_num_enctypes = 0; 98 99 /* split p in a list of :-separated strings */ 100 for(num_buf = 0; num_buf < 3; num_buf++) 101 if(strsep_copy(&p, ":", buf[num_buf], sizeof(buf[num_buf])) == -1) 102 break; 103 104 salt->saltvalue.data = NULL; 105 salt->saltvalue.length = 0; 106 107 for(i = 0; i < num_buf; i++) { 108 if(enctypes == NULL && num_buf > 1) { 109 /* this might be a etype specifier */ 110 /* XXX there should be a string_to_etypes handling 111 special cases like `des' and `all' */ 112 if(strcmp(buf[i], "des") == 0) { 113 enctypes = des_etypes; 114 num_enctypes = sizeof(des_etypes)/sizeof(des_etypes[0]); 115 } else if(strcmp(buf[i], "des3") == 0) { 116 e = KRB5_ENCTYPE_DES3_CBC_SHA1; 117 enctypes = &e; 118 num_enctypes = 1; 119 } else { 120 ret = krb5_string_to_enctype(context, buf[i], &e); 121 if (ret == 0) { 122 enctypes = &e; 123 num_enctypes = 1; 124 } else 125 return ret; 126 } 127 continue; 128 } 129 if(salt->salttype == 0) { 130 /* interpret string as a salt specifier, if no etype 131 is set, this sets default values */ 132 /* XXX should perhaps use string_to_salttype, but that 133 interface sucks */ 134 if(strcmp(buf[i], "pw-salt") == 0) { 135 if(enctypes == NULL) { 136 enctypes = all_etypes; 137 num_enctypes = sizeof(all_etypes)/sizeof(all_etypes[0]); 138 } 139 salt->salttype = KRB5_PW_SALT; 140 } else if(strcmp(buf[i], "afs3-salt") == 0) { 141 if(enctypes == NULL) { 142 enctypes = des_etypes; 143 num_enctypes = sizeof(des_etypes)/sizeof(des_etypes[0]); 144 } 145 salt->salttype = KRB5_AFS3_SALT; 146 } 147 continue; 148 } 149 150 { 151 /* if there is a final string, use it as the string to 152 salt with, this is mostly useful with null salt for 153 v4 compat, and a cell name for afs compat */ 154 salt->saltvalue.data = strdup(buf[i]); 155 if (salt->saltvalue.data == NULL) { 156 krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); 157 return ENOMEM; 158 } 159 salt->saltvalue.length = strlen(buf[i]); 160 } 161 } 162 163 if(enctypes == NULL || salt->salttype == 0) { 164 krb5_set_error_message(context, EINVAL, "bad value for default_keys `%s'", key); 165 return EINVAL; 166 } 167 168 /* if no salt was specified make up default salt */ 169 if(salt->saltvalue.data == NULL) { 170 if(salt->salttype == KRB5_PW_SALT) { 171 ret = krb5_get_pw_salt(context, principal, salt); 172 if (ret) 173 return ret; 174 } else if(salt->salttype == KRB5_AFS3_SALT) { 175 krb5_const_realm realm = krb5_principal_get_realm(context, principal); 176 salt->saltvalue.data = strdup(realm); 177 if(salt->saltvalue.data == NULL) { 178 krb5_set_error_message(context, ENOMEM, 179 "out of memory while " 180 "parsing salt specifiers"); 181 return ENOMEM; 182 } 183 strlwr(salt->saltvalue.data); 184 salt->saltvalue.length = strlen(realm); 185 } 186 } 187 188 *ret_enctypes = malloc(sizeof(enctypes[0]) * num_enctypes); 189 if (*ret_enctypes == NULL) { 190 krb5_free_salt(context, *salt); 191 krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); 192 return ENOMEM; 193 } 194 memcpy(*ret_enctypes, enctypes, sizeof(enctypes[0]) * num_enctypes); 195 *ret_num_enctypes = num_enctypes; 196 197 return 0; 198 } 199 200 201 /** 202 * This function adds an HDB entry's current keyset to the entry's key 203 * history. The current keyset is left alone; the caller is responsible 204 * for freeing it. 205 * 206 * @param context Context 207 * @param entry HDB entry 208 */ 209 krb5_error_code 210 hdb_add_current_keys_to_history(krb5_context context, hdb_entry *entry) 211 { 212 krb5_boolean replace = FALSE; 213 krb5_error_code ret; 214 HDB_extension *ext; 215 hdb_keyset newkeyset; 216 time_t newtime; 217 218 if (entry->keys.len == 0) 219 return 0; /* nothing to do */ 220 221 ext = hdb_find_extension(entry, choice_HDB_extension_data_hist_keys); 222 if (ext == NULL) { 223 replace = TRUE; 224 ext = calloc(1, sizeof (*ext)); 225 if (ext == NULL) 226 return krb5_enomem(context); 227 228 ext->data.element = choice_HDB_extension_data_hist_keys; 229 } 230 231 /* 232 * Copy in newest old keyset 233 */ 234 ret = hdb_entry_get_pw_change_time(entry, &newtime); 235 if (ret) 236 goto out; 237 238 memset(&newkeyset, 0, sizeof(newkeyset)); 239 newkeyset.keys = entry->keys; 240 newkeyset.kvno = entry->kvno; 241 newkeyset.set_time = &newtime; 242 243 ret = add_HDB_Ext_KeySet(&ext->data.u.hist_keys, &newkeyset); 244 if (ret) 245 goto out; 246 247 if (replace) { 248 /* hdb_replace_extension() deep-copies ext; what a waste */ 249 ret = hdb_replace_extension(context, entry, ext); 250 if (ret) 251 goto out; 252 } 253 254 out: 255 if (replace && ext) { 256 free_HDB_extension(ext); 257 free(ext); 258 } 259 return ret; 260 } 261 262 /** 263 * This function adds a key to an HDB entry's key history. 264 * 265 * @param context Context 266 * @param entry HDB entry 267 * @param kvno Key version number of the key to add to the history 268 * @param key The Key to add 269 */ 270 krb5_error_code 271 hdb_add_history_key(krb5_context context, hdb_entry *entry, krb5_kvno kvno, Key *key) 272 { 273 size_t i; 274 hdb_keyset keyset; 275 HDB_Ext_KeySet *hist_keys; 276 HDB_extension ext; 277 HDB_extension *extp; 278 krb5_error_code ret; 279 280 memset(&keyset, 0, sizeof (keyset)); 281 memset(&ext, 0, sizeof (ext)); 282 283 extp = hdb_find_extension(entry, choice_HDB_extension_data_hist_keys); 284 if (extp == NULL) { 285 ext.data.element = choice_HDB_extension_data_hist_keys; 286 extp = &ext; 287 } 288 289 hist_keys = &extp->data.u.hist_keys; 290 291 for (i = 0; i < hist_keys->len; i++) { 292 if (hist_keys->val[i].kvno == kvno) { 293 ret = add_Keys(&hist_keys->val[i].keys, key); 294 goto out; 295 } 296 } 297 298 keyset.kvno = kvno; 299 ret = add_Keys(&keyset.keys, key); 300 if (ret) 301 goto out; 302 ret = add_HDB_Ext_KeySet(hist_keys, &keyset); 303 if (ret) 304 goto out; 305 if (extp == &ext) { 306 ret = hdb_replace_extension(context, entry, &ext); 307 if (ret) 308 goto out; 309 } 310 311 out: 312 free_hdb_keyset(&keyset); 313 free_HDB_extension(&ext); 314 return ret; 315 } 316 317 318 /** 319 * This function changes an hdb_entry's kvno, swapping the current key 320 * set with a historical keyset. If no historical keys are found then 321 * an error is returned (the caller can still set entry->kvno directly). 322 * 323 * @param context krb5_context 324 * @param new_kvno New kvno for the entry 325 * @param entry hdb_entry to modify 326 */ 327 krb5_error_code 328 hdb_change_kvno(krb5_context context, krb5_kvno new_kvno, hdb_entry *entry) 329 { 330 HDB_extension ext; 331 HDB_extension *extp; 332 hdb_keyset keyset; 333 HDB_Ext_KeySet *hist_keys; 334 unsigned int i; 335 int found = 0; 336 krb5_error_code ret; 337 338 if (entry->kvno == new_kvno) 339 return 0; 340 341 extp = hdb_find_extension(entry, choice_HDB_extension_data_hist_keys); 342 if (extp == NULL) { 343 memset(&ext, 0, sizeof (ext)); 344 ext.data.element = choice_HDB_extension_data_hist_keys; 345 extp = &ext; 346 } 347 348 memset(&keyset, 0, sizeof (keyset)); 349 hist_keys = &extp->data.u.hist_keys; 350 for (i = 0; i < hist_keys->len; i++) { 351 if (hist_keys->val[i].kvno == new_kvno) { 352 found = 1; 353 ret = copy_hdb_keyset(&hist_keys->val[i], &keyset); 354 if (ret) 355 goto out; 356 ret = remove_HDB_Ext_KeySet(hist_keys, i); 357 if (ret) 358 goto out; 359 break; 360 } 361 } 362 363 if (!found) 364 return HDB_ERR_KVNO_NOT_FOUND; 365 366 ret = hdb_add_current_keys_to_history(context, entry); 367 if (ret) 368 goto out; 369 370 /* Note: we do nothing with keyset.set_time */ 371 entry->kvno = new_kvno; 372 entry->keys = keyset.keys; /* shortcut */ 373 memset(&keyset.keys, 0, sizeof (keyset.keys)); 374 375 out: 376 free_hdb_keyset(&keyset); 377 return ret; 378 } 379 380 381 static krb5_error_code 382 add_enctype_to_key_set(Key **key_set, size_t *nkeyset, 383 krb5_enctype enctype, krb5_salt *salt) 384 { 385 krb5_error_code ret; 386 Key key, *tmp; 387 388 memset(&key, 0, sizeof(key)); 389 390 tmp = realloc(*key_set, (*nkeyset + 1) * sizeof((*key_set)[0])); 391 if (tmp == NULL) 392 return ENOMEM; 393 394 *key_set = tmp; 395 396 key.key.keytype = enctype; 397 key.key.keyvalue.length = 0; 398 key.key.keyvalue.data = NULL; 399 400 if (salt) { 401 key.salt = calloc(1, sizeof(*key.salt)); 402 if (key.salt == NULL) { 403 free_Key(&key); 404 return ENOMEM; 405 } 406 407 key.salt->type = salt->salttype; 408 krb5_data_zero (&key.salt->salt); 409 410 ret = krb5_data_copy(&key.salt->salt, 411 salt->saltvalue.data, 412 salt->saltvalue.length); 413 if (ret) { 414 free_Key(&key); 415 return ret; 416 } 417 } else 418 key.salt = NULL; 419 420 (*key_set)[*nkeyset] = key; 421 422 *nkeyset += 1; 423 424 return 0; 425 } 426 427 428 static 429 krb5_error_code 430 ks_tuple2str(krb5_context context, int n_ks_tuple, 431 krb5_key_salt_tuple *ks_tuple, char ***ks_tuple_strs) 432 { 433 krb5_error_code rc = KRB5_PROG_ETYPE_NOSUPP; 434 char *ename, *sname; 435 char **ksnames; 436 int i; 437 438 *ks_tuple_strs = NULL; 439 if (n_ks_tuple < 1) 440 return 0; 441 442 if ((ksnames = calloc(n_ks_tuple, sizeof (*ksnames))) == NULL) 443 return (errno); 444 445 for (i = 0; i < n_ks_tuple; i++) { 446 if (krb5_enctype_to_string(context, ks_tuple[i].ks_enctype, &ename)) 447 goto out; 448 if (krb5_salttype_to_string(context, ks_tuple[i].ks_enctype, 449 ks_tuple[i].ks_salttype, &sname)) 450 goto out; 451 452 if (asprintf(&ksnames[i], "%s:%s", ename, sname) == -1) { 453 rc = errno; 454 free(ename); 455 free(sname); 456 goto out; 457 } 458 free(ename); 459 free(sname); 460 } 461 462 *ks_tuple_strs = ksnames; 463 rc = 0; 464 465 out: 466 for (i = 0; i < n_ks_tuple; i++) 467 free(ksnames[i]); 468 free(ksnames); 469 return (rc); 470 } 471 472 /* 473 * Generate the `key_set' from the [kadmin]default_keys statement. If 474 * `no_salt' is set, salt is not important (and will not be set) since 475 * it's random keys that is going to be created. 476 */ 477 478 krb5_error_code 479 hdb_generate_key_set(krb5_context context, krb5_principal principal, 480 int n_ks_tuple, krb5_key_salt_tuple *ks_tuple, 481 Key **ret_key_set, size_t *nkeyset, int no_salt) 482 { 483 char **ktypes = NULL; 484 char **kp; 485 krb5_error_code ret; 486 Key *k, *key_set; 487 size_t i, j; 488 char **ks_tuple_strs; 489 static const char *default_keytypes[] = { 490 "aes256-cts-hmac-sha1-96:pw-salt", 491 "aes128-cts-hmac-sha1-96:pw-salt", 492 "des3-cbc-sha1:pw-salt", 493 NULL 494 }; 495 496 *ret_key_set = key_set = NULL; 497 *nkeyset = 0; 498 499 if ((ret = ks_tuple2str(context, n_ks_tuple, ks_tuple, &ks_tuple_strs))) 500 return ret; 501 502 if (ks_tuple_strs == NULL) 503 ktypes = krb5_config_get_strings(context, NULL, "kadmin", 504 "default_keys", NULL); 505 506 if (ktypes == NULL) 507 ktypes = (char **)(intptr_t)default_keytypes; 508 509 510 ret = 0; 511 512 for(kp = ktypes; kp && *kp; kp++) { 513 const char *p; 514 krb5_salt salt; 515 krb5_enctype *etypes; 516 size_t num_etypes; 517 518 p = *kp; 519 /* check alias */ 520 if(strcmp(p, "v5") == 0) 521 p = "pw-salt"; 522 else if(strcmp(p, "v4") == 0) 523 p = "des:pw-salt:"; 524 else if(strcmp(p, "afs") == 0 || strcmp(p, "afs3") == 0) 525 p = "des:afs3-salt"; 526 else if (strcmp(p, "arcfour-hmac-md5") == 0) 527 p = "arcfour-hmac-md5:pw-salt"; 528 529 memset(&salt, 0, sizeof(salt)); 530 531 ret = parse_key_set(context, p, 532 &etypes, &num_etypes, &salt, principal); 533 if (ret) { 534 krb5_warn(context, ret, "bad value for default_keys `%s'", *kp); 535 ret = 0; 536 continue; 537 } 538 539 for (i = 0; i < num_etypes; i++) { 540 /* find duplicates */ 541 for (j = 0; j < *nkeyset; j++) { 542 543 k = &key_set[j]; 544 545 if (k->key.keytype == etypes[i]) { 546 if (no_salt) 547 break; 548 if (k->salt == NULL && salt.salttype == KRB5_PW_SALT) 549 break; 550 if (k->salt->type == salt.salttype && 551 k->salt->salt.length == salt.saltvalue.length && 552 memcmp(k->salt->salt.data, salt.saltvalue.data, 553 salt.saltvalue.length) == 0) 554 break; 555 } 556 } 557 /* not a duplicate, lets add it */ 558 if (j == *nkeyset) { 559 ret = add_enctype_to_key_set(&key_set, nkeyset, etypes[i], 560 no_salt ? NULL : &salt); 561 if (ret) { 562 free(etypes); 563 krb5_free_salt(context, salt); 564 goto out; 565 } 566 } 567 } 568 free(etypes); 569 krb5_free_salt(context, salt); 570 } 571 572 *ret_key_set = key_set; 573 574 out: 575 if (ktypes != (char **)(intptr_t)default_keytypes) 576 krb5_config_free_strings(ktypes); 577 578 if (ret) { 579 krb5_warn(context, ret, 580 "failed to parse the [kadmin]default_keys values"); 581 582 for (i = 0; i < *nkeyset; i++) 583 free_Key(&key_set[i]); 584 free(key_set); 585 } else if (*nkeyset == 0) { 586 krb5_warnx(context, 587 "failed to parse any of the [kadmin]default_keys values"); 588 ret = EINVAL; /* XXX */ 589 } 590 591 return ret; 592 } 593 594 595 krb5_error_code 596 hdb_generate_key_set_password(krb5_context context, 597 krb5_principal principal, 598 const char *password, 599 int n_ks_tuple, krb5_key_salt_tuple *ks_tuple, 600 Key **keys, size_t *num_keys) 601 { 602 krb5_error_code ret; 603 size_t i; 604 605 *keys = NULL; 606 *num_keys = 0; 607 608 ret = hdb_generate_key_set(context, principal, n_ks_tuple, ks_tuple, 609 keys, num_keys, 0); 610 if (ret) 611 return ret; 612 613 for (i = 0; i < (*num_keys); i++) { 614 krb5_salt salt; 615 616 if ((*keys)[i].salt) { 617 salt.salttype = (*keys)[i].salt->type; 618 salt.saltvalue.length = (*keys)[i].salt->salt.length; 619 salt.saltvalue.data = (*keys)[i].salt->salt.data; 620 } else { 621 memset(&salt, 0, sizeof(salt)); 622 } 623 624 ret = krb5_string_to_key_salt (context, 625 (*keys)[i].key.keytype, 626 password, 627 salt, 628 &(*keys)[i].key); 629 630 if(ret) 631 break; 632 } 633 634 if(ret) { 635 hdb_free_keys (context, *num_keys, *keys); 636 return ret; 637 } 638 return ret; 639 } 640 641 #include <corecrypto/ccsrp.h> 642 643 krb5_error_code 644 hdb_set_srp_verifier(krb5_context context, 645 KRB5_SRP_GROUP group, 646 krb5_const_principal principal, 647 const char *password, 648 uint32_t iterations, 649 hdb_srp *srp) 650 { 651 krb5_error_code ret; 652 const struct _krb5_srp_group *grp; 653 654 grp = _krb5_srp_validate_group(group); 655 if (grp == NULL) 656 return ENOENT; 657 658 /* 659 * Set up param 660 */ 661 662 srp->param.group = group; 663 ret = krb5_data_alloc(&srp->param.salt, 16); 664 if (ret) { 665 return ret; 666 } 667 668 krb5_generate_random_block(srp->param.salt.data, srp->param.salt.length); 669 670 if (iterations == 0) 671 iterations = 4000; 672 srp->param.iterations = iterations; 673 674 /* 675 * Now build verifier 676 */ 677 678 ret = _krb5_srp_create_pa(context, 679 grp, 680 principal, 681 password, 682 &srp->param, 683 &srp->verifier); 684 if (ret) { 685 free_hdb_srp(srp); 686 return ret; 687 } 688 689 return 0; 690 } 691 692 krb5_error_code 693 hdb_entry_set_srp_verifiers(krb5_context context, 694 hdb_entry *entry, 695 const char *password, 696 uint32_t iterations) 697 { 698 HDB_extension ext; 699 int ret; 700 701 memset(&ext, 0, sizeof(ext)); 702 703 ext.mandatory = FALSE; 704 ext.data.element = choice_HDB_extension_data_srp; 705 706 ext.data.u.srp.len = 1; 707 ext.data.u.srp.val = calloc(1, sizeof(ext.data.u.srp.val[0])); 708 if (ext.data.u.srp.val == NULL) 709 return ENOMEM; 710 711 ret = hdb_set_srp_verifier(context, 712 KRB5_SRP_GROUP_RFC5054_4096_PBKDF2_SHA512, 713 entry->principal, 714 password, 715 0, 716 &ext.data.u.srp.val[0]); 717 if (ret) { 718 free_HDB_extension(&ext); 719 return ret; 720 } 721 722 ret = hdb_replace_extension(context, entry, &ext); 723 724 free_HDB_extension(&ext); 725 726 return ret; 727 }