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