/contrib/bind9/lib/dns/dst_api.c
C | 1777 lines | 1495 code | 203 blank | 79 comment | 320 complexity | 887f96fca8132c4b81a30f6b53904cc7 MD5 | raw file
1/* 2 * Portions Copyright (C) 2004-2012 Internet Systems Consortium, Inc. ("ISC") 3 * Portions Copyright (C) 1999-2003 Internet Software Consortium. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS 10 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE 12 * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR 15 * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 * 17 * Portions Copyright (C) 1995-2000 by Network Associates, Inc. 18 * 19 * Permission to use, copy, modify, and/or distribute this software for any 20 * purpose with or without fee is hereby granted, provided that the above 21 * copyright notice and this permission notice appear in all copies. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS 24 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 25 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE 26 * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 27 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 28 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR 29 * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 30 */ 31 32/* 33 * Principal Author: Brian Wellington 34 * $Id$ 35 */ 36 37/*! \file */ 38 39#include <config.h> 40 41#include <stdlib.h> 42#include <time.h> 43 44#include <isc/buffer.h> 45#include <isc/dir.h> 46#include <isc/entropy.h> 47#include <isc/fsaccess.h> 48#include <isc/hmacsha.h> 49#include <isc/lex.h> 50#include <isc/mem.h> 51#include <isc/once.h> 52#include <isc/platform.h> 53#include <isc/print.h> 54#include <isc/refcount.h> 55#include <isc/random.h> 56#include <isc/string.h> 57#include <isc/time.h> 58#include <isc/util.h> 59 60#include <dns/fixedname.h> 61#include <dns/keyvalues.h> 62#include <dns/name.h> 63#include <dns/rdata.h> 64#include <dns/rdataclass.h> 65#include <dns/ttl.h> 66#include <dns/types.h> 67 68#include <dst/result.h> 69 70#include "dst_internal.h" 71 72#define DST_AS_STR(t) ((t).value.as_textregion.base) 73 74static dst_func_t *dst_t_func[DST_MAX_ALGS]; 75#ifdef BIND9 76static isc_entropy_t *dst_entropy_pool = NULL; 77#endif 78static unsigned int dst_entropy_flags = 0; 79static isc_boolean_t dst_initialized = ISC_FALSE; 80 81void gss_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3); 82 83isc_mem_t *dst__memory_pool = NULL; 84 85/* 86 * Static functions. 87 */ 88static dst_key_t * get_key_struct(dns_name_t *name, 89 unsigned int alg, 90 unsigned int flags, 91 unsigned int protocol, 92 unsigned int bits, 93 dns_rdataclass_t rdclass, 94 isc_mem_t *mctx); 95static isc_result_t write_public_key(const dst_key_t *key, int type, 96 const char *directory); 97static isc_result_t buildfilename(dns_name_t *name, 98 dns_keytag_t id, 99 unsigned int alg, 100 unsigned int type, 101 const char *directory, 102 isc_buffer_t *out); 103static isc_result_t computeid(dst_key_t *key); 104static isc_result_t frombuffer(dns_name_t *name, 105 unsigned int alg, 106 unsigned int flags, 107 unsigned int protocol, 108 dns_rdataclass_t rdclass, 109 isc_buffer_t *source, 110 isc_mem_t *mctx, 111 dst_key_t **keyp); 112 113static isc_result_t algorithm_status(unsigned int alg); 114 115static isc_result_t addsuffix(char *filename, int len, 116 const char *dirname, const char *ofilename, 117 const char *suffix); 118 119#define RETERR(x) \ 120 do { \ 121 result = (x); \ 122 if (result != ISC_R_SUCCESS) \ 123 goto out; \ 124 } while (0) 125 126#define CHECKALG(alg) \ 127 do { \ 128 isc_result_t _r; \ 129 _r = algorithm_status(alg); \ 130 if (_r != ISC_R_SUCCESS) \ 131 return (_r); \ 132 } while (0); \ 133 134#if defined(OPENSSL) && defined(BIND9) 135static void * 136default_memalloc(void *arg, size_t size) { 137 UNUSED(arg); 138 if (size == 0U) 139 size = 1; 140 return (malloc(size)); 141} 142 143static void 144default_memfree(void *arg, void *ptr) { 145 UNUSED(arg); 146 free(ptr); 147} 148#endif 149 150isc_result_t 151dst_lib_init(isc_mem_t *mctx, isc_entropy_t *ectx, unsigned int eflags) { 152 return (dst_lib_init2(mctx, ectx, NULL, eflags)); 153} 154 155isc_result_t 156dst_lib_init2(isc_mem_t *mctx, isc_entropy_t *ectx, 157 const char *engine, unsigned int eflags) { 158 isc_result_t result; 159 160 REQUIRE(mctx != NULL); 161#ifdef BIND9 162 REQUIRE(ectx != NULL); 163#else 164 UNUSED(ectx); 165#endif 166 REQUIRE(dst_initialized == ISC_FALSE); 167 168#ifndef OPENSSL 169 UNUSED(engine); 170#endif 171 172 dst__memory_pool = NULL; 173 174#if defined(OPENSSL) && defined(BIND9) 175 UNUSED(mctx); 176 /* 177 * When using --with-openssl, there seems to be no good way of not 178 * leaking memory due to the openssl error handling mechanism. 179 * Avoid assertions by using a local memory context and not checking 180 * for leaks on exit. Note: as there are leaks we cannot use 181 * ISC_MEMFLAG_INTERNAL as it will free up memory still being used 182 * by libcrypto. 183 */ 184 result = isc_mem_createx2(0, 0, default_memalloc, default_memfree, 185 NULL, &dst__memory_pool, 0); 186 if (result != ISC_R_SUCCESS) 187 return (result); 188 isc_mem_setname(dst__memory_pool, "dst", NULL); 189#ifndef OPENSSL_LEAKS 190 isc_mem_setdestroycheck(dst__memory_pool, ISC_FALSE); 191#endif 192#else 193 isc_mem_attach(mctx, &dst__memory_pool); 194#endif 195#ifdef BIND9 196 isc_entropy_attach(ectx, &dst_entropy_pool); 197#endif 198 dst_entropy_flags = eflags; 199 200 dst_result_register(); 201 202 memset(dst_t_func, 0, sizeof(dst_t_func)); 203 RETERR(dst__hmacmd5_init(&dst_t_func[DST_ALG_HMACMD5])); 204 RETERR(dst__hmacsha1_init(&dst_t_func[DST_ALG_HMACSHA1])); 205 RETERR(dst__hmacsha224_init(&dst_t_func[DST_ALG_HMACSHA224])); 206 RETERR(dst__hmacsha256_init(&dst_t_func[DST_ALG_HMACSHA256])); 207 RETERR(dst__hmacsha384_init(&dst_t_func[DST_ALG_HMACSHA384])); 208 RETERR(dst__hmacsha512_init(&dst_t_func[DST_ALG_HMACSHA512])); 209#ifdef OPENSSL 210 RETERR(dst__openssl_init(engine)); 211 RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSAMD5], 212 DST_ALG_RSAMD5)); 213 RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA1], 214 DST_ALG_RSASHA1)); 215 RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_NSEC3RSASHA1], 216 DST_ALG_NSEC3RSASHA1)); 217 RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA256], 218 DST_ALG_RSASHA256)); 219 RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA512], 220 DST_ALG_RSASHA512)); 221#ifdef HAVE_OPENSSL_DSA 222 RETERR(dst__openssldsa_init(&dst_t_func[DST_ALG_DSA])); 223 RETERR(dst__openssldsa_init(&dst_t_func[DST_ALG_NSEC3DSA])); 224#endif 225 RETERR(dst__openssldh_init(&dst_t_func[DST_ALG_DH])); 226#ifdef HAVE_OPENSSL_GOST 227 RETERR(dst__opensslgost_init(&dst_t_func[DST_ALG_ECCGOST])); 228#endif 229#endif /* OPENSSL */ 230#ifdef GSSAPI 231 RETERR(dst__gssapi_init(&dst_t_func[DST_ALG_GSSAPI])); 232#endif 233 dst_initialized = ISC_TRUE; 234 return (ISC_R_SUCCESS); 235 236 out: 237 /* avoid immediate crash! */ 238 dst_initialized = ISC_TRUE; 239 dst_lib_destroy(); 240 return (result); 241} 242 243void 244dst_lib_destroy(void) { 245 int i; 246 RUNTIME_CHECK(dst_initialized == ISC_TRUE); 247 dst_initialized = ISC_FALSE; 248 249 for (i = 0; i < DST_MAX_ALGS; i++) 250 if (dst_t_func[i] != NULL && dst_t_func[i]->cleanup != NULL) 251 dst_t_func[i]->cleanup(); 252#ifdef OPENSSL 253 dst__openssl_destroy(); 254#endif 255 if (dst__memory_pool != NULL) 256 isc_mem_detach(&dst__memory_pool); 257#ifdef BIND9 258 if (dst_entropy_pool != NULL) 259 isc_entropy_detach(&dst_entropy_pool); 260#endif 261} 262 263isc_boolean_t 264dst_algorithm_supported(unsigned int alg) { 265 REQUIRE(dst_initialized == ISC_TRUE); 266 267 if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) 268 return (ISC_FALSE); 269 return (ISC_TRUE); 270} 271 272isc_result_t 273dst_context_create(dst_key_t *key, isc_mem_t *mctx, dst_context_t **dctxp) { 274 dst_context_t *dctx; 275 isc_result_t result; 276 277 REQUIRE(dst_initialized == ISC_TRUE); 278 REQUIRE(VALID_KEY(key)); 279 REQUIRE(mctx != NULL); 280 REQUIRE(dctxp != NULL && *dctxp == NULL); 281 282 if (key->func->createctx == NULL) 283 return (DST_R_UNSUPPORTEDALG); 284 if (key->keydata.generic == NULL) 285 return (DST_R_NULLKEY); 286 287 dctx = isc_mem_get(mctx, sizeof(dst_context_t)); 288 if (dctx == NULL) 289 return (ISC_R_NOMEMORY); 290 dctx->key = key; 291 dctx->mctx = mctx; 292 result = key->func->createctx(key, dctx); 293 if (result != ISC_R_SUCCESS) { 294 isc_mem_put(mctx, dctx, sizeof(dst_context_t)); 295 return (result); 296 } 297 dctx->magic = CTX_MAGIC; 298 *dctxp = dctx; 299 return (ISC_R_SUCCESS); 300} 301 302void 303dst_context_destroy(dst_context_t **dctxp) { 304 dst_context_t *dctx; 305 306 REQUIRE(dctxp != NULL && VALID_CTX(*dctxp)); 307 308 dctx = *dctxp; 309 INSIST(dctx->key->func->destroyctx != NULL); 310 dctx->key->func->destroyctx(dctx); 311 dctx->magic = 0; 312 isc_mem_put(dctx->mctx, dctx, sizeof(dst_context_t)); 313 *dctxp = NULL; 314} 315 316isc_result_t 317dst_context_adddata(dst_context_t *dctx, const isc_region_t *data) { 318 REQUIRE(VALID_CTX(dctx)); 319 REQUIRE(data != NULL); 320 INSIST(dctx->key->func->adddata != NULL); 321 322 return (dctx->key->func->adddata(dctx, data)); 323} 324 325isc_result_t 326dst_context_sign(dst_context_t *dctx, isc_buffer_t *sig) { 327 dst_key_t *key; 328 329 REQUIRE(VALID_CTX(dctx)); 330 REQUIRE(sig != NULL); 331 332 key = dctx->key; 333 CHECKALG(key->key_alg); 334 if (key->keydata.generic == NULL) 335 return (DST_R_NULLKEY); 336 337 if (key->func->sign == NULL) 338 return (DST_R_NOTPRIVATEKEY); 339 if (key->func->isprivate == NULL || 340 key->func->isprivate(key) == ISC_FALSE) 341 return (DST_R_NOTPRIVATEKEY); 342 343 return (key->func->sign(dctx, sig)); 344} 345 346isc_result_t 347dst_context_verify(dst_context_t *dctx, isc_region_t *sig) { 348 REQUIRE(VALID_CTX(dctx)); 349 REQUIRE(sig != NULL); 350 351 CHECKALG(dctx->key->key_alg); 352 if (dctx->key->keydata.generic == NULL) 353 return (DST_R_NULLKEY); 354 if (dctx->key->func->verify == NULL) 355 return (DST_R_NOTPUBLICKEY); 356 357 return (dctx->key->func->verify(dctx, sig)); 358} 359 360isc_result_t 361dst_key_computesecret(const dst_key_t *pub, const dst_key_t *priv, 362 isc_buffer_t *secret) 363{ 364 REQUIRE(dst_initialized == ISC_TRUE); 365 REQUIRE(VALID_KEY(pub) && VALID_KEY(priv)); 366 REQUIRE(secret != NULL); 367 368 CHECKALG(pub->key_alg); 369 CHECKALG(priv->key_alg); 370 371 if (pub->keydata.generic == NULL || priv->keydata.generic == NULL) 372 return (DST_R_NULLKEY); 373 374 if (pub->key_alg != priv->key_alg || 375 pub->func->computesecret == NULL || 376 priv->func->computesecret == NULL) 377 return (DST_R_KEYCANNOTCOMPUTESECRET); 378 379 if (dst_key_isprivate(priv) == ISC_FALSE) 380 return (DST_R_NOTPRIVATEKEY); 381 382 return (pub->func->computesecret(pub, priv, secret)); 383} 384 385isc_result_t 386dst_key_tofile(const dst_key_t *key, int type, const char *directory) { 387 isc_result_t ret = ISC_R_SUCCESS; 388 389 REQUIRE(dst_initialized == ISC_TRUE); 390 REQUIRE(VALID_KEY(key)); 391 REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0); 392 393 CHECKALG(key->key_alg); 394 395 if (key->func->tofile == NULL) 396 return (DST_R_UNSUPPORTEDALG); 397 398 if (type & DST_TYPE_PUBLIC) { 399 ret = write_public_key(key, type, directory); 400 if (ret != ISC_R_SUCCESS) 401 return (ret); 402 } 403 404 if ((type & DST_TYPE_PRIVATE) && 405 (key->key_flags & DNS_KEYFLAG_TYPEMASK) != DNS_KEYTYPE_NOKEY) 406 return (key->func->tofile(key, directory)); 407 else 408 return (ISC_R_SUCCESS); 409} 410 411isc_result_t 412dst_key_fromfile(dns_name_t *name, dns_keytag_t id, 413 unsigned int alg, int type, const char *directory, 414 isc_mem_t *mctx, dst_key_t **keyp) 415{ 416 char filename[ISC_DIR_NAMEMAX]; 417 isc_buffer_t b; 418 dst_key_t *key; 419 isc_result_t result; 420 421 REQUIRE(dst_initialized == ISC_TRUE); 422 REQUIRE(dns_name_isabsolute(name)); 423 REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0); 424 REQUIRE(mctx != NULL); 425 REQUIRE(keyp != NULL && *keyp == NULL); 426 427 CHECKALG(alg); 428 429 isc_buffer_init(&b, filename, sizeof(filename)); 430 result = buildfilename(name, id, alg, type, directory, &b); 431 if (result != ISC_R_SUCCESS) 432 return (result); 433 434 key = NULL; 435 result = dst_key_fromnamedfile(filename, NULL, type, mctx, &key); 436 if (result != ISC_R_SUCCESS) 437 return (result); 438 439 result = computeid(key); 440 if (result != ISC_R_SUCCESS) { 441 dst_key_free(&key); 442 return (result); 443 } 444 445 if (!dns_name_equal(name, key->key_name) || id != key->key_id || 446 alg != key->key_alg) { 447 dst_key_free(&key); 448 return (DST_R_INVALIDPRIVATEKEY); 449 } 450 451 *keyp = key; 452 return (ISC_R_SUCCESS); 453} 454 455isc_result_t 456dst_key_fromnamedfile(const char *filename, const char *dirname, 457 int type, isc_mem_t *mctx, dst_key_t **keyp) 458{ 459 isc_result_t result; 460 dst_key_t *pubkey = NULL, *key = NULL; 461 char *newfilename = NULL; 462 int newfilenamelen = 0; 463 isc_lex_t *lex = NULL; 464 465 REQUIRE(dst_initialized == ISC_TRUE); 466 REQUIRE(filename != NULL); 467 REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0); 468 REQUIRE(mctx != NULL); 469 REQUIRE(keyp != NULL && *keyp == NULL); 470 471 /* If an absolute path is specified, don't use the key directory */ 472#ifndef WIN32 473 if (filename[0] == '/') 474 dirname = NULL; 475#else /* WIN32 */ 476 if (filename[0] == '/' || filename[0] == '\\') 477 dirname = NULL; 478#endif 479 480 newfilenamelen = strlen(filename) + 5; 481 if (dirname != NULL) 482 newfilenamelen += strlen(dirname) + 1; 483 newfilename = isc_mem_get(mctx, newfilenamelen); 484 if (newfilename == NULL) 485 return (ISC_R_NOMEMORY); 486 result = addsuffix(newfilename, newfilenamelen, 487 dirname, filename, ".key"); 488 INSIST(result == ISC_R_SUCCESS); 489 490 result = dst_key_read_public(newfilename, type, mctx, &pubkey); 491 isc_mem_put(mctx, newfilename, newfilenamelen); 492 newfilename = NULL; 493 if (result != ISC_R_SUCCESS) 494 return (result); 495 496 if ((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) == DST_TYPE_PUBLIC || 497 (pubkey->key_flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY) { 498 result = computeid(pubkey); 499 if (result != ISC_R_SUCCESS) { 500 dst_key_free(&pubkey); 501 return (result); 502 } 503 504 *keyp = pubkey; 505 return (ISC_R_SUCCESS); 506 } 507 508 result = algorithm_status(pubkey->key_alg); 509 if (result != ISC_R_SUCCESS) { 510 dst_key_free(&pubkey); 511 return (result); 512 } 513 514 key = get_key_struct(pubkey->key_name, pubkey->key_alg, 515 pubkey->key_flags, pubkey->key_proto, 0, 516 pubkey->key_class, mctx); 517 if (key == NULL) { 518 dst_key_free(&pubkey); 519 return (ISC_R_NOMEMORY); 520 } 521 522 if (key->func->parse == NULL) 523 RETERR(DST_R_UNSUPPORTEDALG); 524 525 newfilenamelen = strlen(filename) + 9; 526 if (dirname != NULL) 527 newfilenamelen += strlen(dirname) + 1; 528 newfilename = isc_mem_get(mctx, newfilenamelen); 529 if (newfilename == NULL) 530 RETERR(ISC_R_NOMEMORY); 531 result = addsuffix(newfilename, newfilenamelen, 532 dirname, filename, ".private"); 533 INSIST(result == ISC_R_SUCCESS); 534 535 RETERR(isc_lex_create(mctx, 1500, &lex)); 536 RETERR(isc_lex_openfile(lex, newfilename)); 537 isc_mem_put(mctx, newfilename, newfilenamelen); 538 539 RETERR(key->func->parse(key, lex, pubkey)); 540 isc_lex_destroy(&lex); 541 542 RETERR(computeid(key)); 543 544 if (pubkey->key_id != key->key_id) 545 RETERR(DST_R_INVALIDPRIVATEKEY); 546 dst_key_free(&pubkey); 547 548 *keyp = key; 549 return (ISC_R_SUCCESS); 550 551 out: 552 if (pubkey != NULL) 553 dst_key_free(&pubkey); 554 if (newfilename != NULL) 555 isc_mem_put(mctx, newfilename, newfilenamelen); 556 if (lex != NULL) 557 isc_lex_destroy(&lex); 558 dst_key_free(&key); 559 return (result); 560} 561 562isc_result_t 563dst_key_todns(const dst_key_t *key, isc_buffer_t *target) { 564 REQUIRE(dst_initialized == ISC_TRUE); 565 REQUIRE(VALID_KEY(key)); 566 REQUIRE(target != NULL); 567 568 CHECKALG(key->key_alg); 569 570 if (key->func->todns == NULL) 571 return (DST_R_UNSUPPORTEDALG); 572 573 if (isc_buffer_availablelength(target) < 4) 574 return (ISC_R_NOSPACE); 575 isc_buffer_putuint16(target, (isc_uint16_t)(key->key_flags & 0xffff)); 576 isc_buffer_putuint8(target, (isc_uint8_t)key->key_proto); 577 isc_buffer_putuint8(target, (isc_uint8_t)key->key_alg); 578 579 if (key->key_flags & DNS_KEYFLAG_EXTENDED) { 580 if (isc_buffer_availablelength(target) < 2) 581 return (ISC_R_NOSPACE); 582 isc_buffer_putuint16(target, 583 (isc_uint16_t)((key->key_flags >> 16) 584 & 0xffff)); 585 } 586 587 if (key->keydata.generic == NULL) /*%< NULL KEY */ 588 return (ISC_R_SUCCESS); 589 590 return (key->func->todns(key, target)); 591} 592 593isc_result_t 594dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass, 595 isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) 596{ 597 isc_uint8_t alg, proto; 598 isc_uint32_t flags, extflags; 599 dst_key_t *key = NULL; 600 dns_keytag_t id, rid; 601 isc_region_t r; 602 isc_result_t result; 603 604 REQUIRE(dst_initialized); 605 606 isc_buffer_remainingregion(source, &r); 607 608 if (isc_buffer_remaininglength(source) < 4) 609 return (DST_R_INVALIDPUBLICKEY); 610 flags = isc_buffer_getuint16(source); 611 proto = isc_buffer_getuint8(source); 612 alg = isc_buffer_getuint8(source); 613 614 id = dst_region_computeid(&r, alg); 615 rid = dst_region_computerid(&r, alg); 616 617 if (flags & DNS_KEYFLAG_EXTENDED) { 618 if (isc_buffer_remaininglength(source) < 2) 619 return (DST_R_INVALIDPUBLICKEY); 620 extflags = isc_buffer_getuint16(source); 621 flags |= (extflags << 16); 622 } 623 624 result = frombuffer(name, alg, flags, proto, rdclass, source, 625 mctx, &key); 626 if (result != ISC_R_SUCCESS) 627 return (result); 628 key->key_id = id; 629 key->key_rid = rid; 630 631 *keyp = key; 632 return (ISC_R_SUCCESS); 633} 634 635isc_result_t 636dst_key_frombuffer(dns_name_t *name, unsigned int alg, 637 unsigned int flags, unsigned int protocol, 638 dns_rdataclass_t rdclass, 639 isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) 640{ 641 dst_key_t *key = NULL; 642 isc_result_t result; 643 644 REQUIRE(dst_initialized); 645 646 result = frombuffer(name, alg, flags, protocol, rdclass, source, 647 mctx, &key); 648 if (result != ISC_R_SUCCESS) 649 return (result); 650 651 result = computeid(key); 652 if (result != ISC_R_SUCCESS) { 653 dst_key_free(&key); 654 return (result); 655 } 656 657 *keyp = key; 658 return (ISC_R_SUCCESS); 659} 660 661isc_result_t 662dst_key_tobuffer(const dst_key_t *key, isc_buffer_t *target) { 663 REQUIRE(dst_initialized == ISC_TRUE); 664 REQUIRE(VALID_KEY(key)); 665 REQUIRE(target != NULL); 666 667 CHECKALG(key->key_alg); 668 669 if (key->func->todns == NULL) 670 return (DST_R_UNSUPPORTEDALG); 671 672 return (key->func->todns(key, target)); 673} 674 675isc_result_t 676dst_key_privatefrombuffer(dst_key_t *key, isc_buffer_t *buffer) { 677 isc_lex_t *lex = NULL; 678 isc_result_t result = ISC_R_SUCCESS; 679 680 REQUIRE(dst_initialized == ISC_TRUE); 681 REQUIRE(VALID_KEY(key)); 682 REQUIRE(!dst_key_isprivate(key)); 683 REQUIRE(buffer != NULL); 684 685 if (key->func->parse == NULL) 686 RETERR(DST_R_UNSUPPORTEDALG); 687 688 RETERR(isc_lex_create(key->mctx, 1500, &lex)); 689 RETERR(isc_lex_openbuffer(lex, buffer)); 690 RETERR(key->func->parse(key, lex, NULL)); 691 out: 692 if (lex != NULL) 693 isc_lex_destroy(&lex); 694 return (result); 695} 696 697gss_ctx_id_t 698dst_key_getgssctx(const dst_key_t *key) 699{ 700 REQUIRE(key != NULL); 701 702 return (key->keydata.gssctx); 703} 704 705isc_result_t 706dst_key_fromgssapi(dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx, 707 dst_key_t **keyp, isc_region_t *intoken) 708{ 709 dst_key_t *key; 710 isc_result_t result; 711 712 REQUIRE(gssctx != NULL); 713 REQUIRE(keyp != NULL && *keyp == NULL); 714 715 key = get_key_struct(name, DST_ALG_GSSAPI, 0, DNS_KEYPROTO_DNSSEC, 716 0, dns_rdataclass_in, mctx); 717 if (key == NULL) 718 return (ISC_R_NOMEMORY); 719 720 if (intoken != NULL) { 721 /* 722 * Keep the token for use by external ssu rules. They may need 723 * to examine the PAC in the kerberos ticket. 724 */ 725 RETERR(isc_buffer_allocate(key->mctx, &key->key_tkeytoken, 726 intoken->length)); 727 RETERR(isc_buffer_copyregion(key->key_tkeytoken, intoken)); 728 } 729 730 key->keydata.gssctx = gssctx; 731 *keyp = key; 732 result = ISC_R_SUCCESS; 733out: 734 return result; 735} 736 737isc_result_t 738dst_key_fromlabel(dns_name_t *name, int alg, unsigned int flags, 739 unsigned int protocol, dns_rdataclass_t rdclass, 740 const char *engine, const char *label, const char *pin, 741 isc_mem_t *mctx, dst_key_t **keyp) 742{ 743 dst_key_t *key; 744 isc_result_t result; 745 746 REQUIRE(dst_initialized == ISC_TRUE); 747 REQUIRE(dns_name_isabsolute(name)); 748 REQUIRE(mctx != NULL); 749 REQUIRE(keyp != NULL && *keyp == NULL); 750 REQUIRE(label != NULL); 751 752 CHECKALG(alg); 753 754 key = get_key_struct(name, alg, flags, protocol, 0, rdclass, mctx); 755 if (key == NULL) 756 return (ISC_R_NOMEMORY); 757 758 if (key->func->fromlabel == NULL) { 759 dst_key_free(&key); 760 return (DST_R_UNSUPPORTEDALG); 761 } 762 763 result = key->func->fromlabel(key, engine, label, pin); 764 if (result != ISC_R_SUCCESS) { 765 dst_key_free(&key); 766 return (result); 767 } 768 769 result = computeid(key); 770 if (result != ISC_R_SUCCESS) { 771 dst_key_free(&key); 772 return (result); 773 } 774 775 *keyp = key; 776 return (ISC_R_SUCCESS); 777} 778 779isc_result_t 780dst_key_generate(dns_name_t *name, unsigned int alg, 781 unsigned int bits, unsigned int param, 782 unsigned int flags, unsigned int protocol, 783 dns_rdataclass_t rdclass, 784 isc_mem_t *mctx, dst_key_t **keyp) 785{ 786 return (dst_key_generate2(name, alg, bits, param, flags, protocol, 787 rdclass, mctx, keyp, NULL)); 788} 789 790isc_result_t 791dst_key_generate2(dns_name_t *name, unsigned int alg, 792 unsigned int bits, unsigned int param, 793 unsigned int flags, unsigned int protocol, 794 dns_rdataclass_t rdclass, 795 isc_mem_t *mctx, dst_key_t **keyp, 796 void (*callback)(int)) 797{ 798 dst_key_t *key; 799 isc_result_t ret; 800 801 REQUIRE(dst_initialized == ISC_TRUE); 802 REQUIRE(dns_name_isabsolute(name)); 803 REQUIRE(mctx != NULL); 804 REQUIRE(keyp != NULL && *keyp == NULL); 805 806 CHECKALG(alg); 807 808 key = get_key_struct(name, alg, flags, protocol, bits, rdclass, mctx); 809 if (key == NULL) 810 return (ISC_R_NOMEMORY); 811 812 if (bits == 0) { /*%< NULL KEY */ 813 key->key_flags |= DNS_KEYTYPE_NOKEY; 814 *keyp = key; 815 return (ISC_R_SUCCESS); 816 } 817 818 if (key->func->generate == NULL) { 819 dst_key_free(&key); 820 return (DST_R_UNSUPPORTEDALG); 821 } 822 823 ret = key->func->generate(key, param, callback); 824 if (ret != ISC_R_SUCCESS) { 825 dst_key_free(&key); 826 return (ret); 827 } 828 829 ret = computeid(key); 830 if (ret != ISC_R_SUCCESS) { 831 dst_key_free(&key); 832 return (ret); 833 } 834 835 *keyp = key; 836 return (ISC_R_SUCCESS); 837} 838 839isc_result_t 840dst_key_getnum(const dst_key_t *key, int type, isc_uint32_t *valuep) 841{ 842 REQUIRE(VALID_KEY(key)); 843 REQUIRE(valuep != NULL); 844 REQUIRE(type <= DST_MAX_NUMERIC); 845 if (!key->numset[type]) 846 return (ISC_R_NOTFOUND); 847 *valuep = key->nums[type]; 848 return (ISC_R_SUCCESS); 849} 850 851void 852dst_key_setnum(dst_key_t *key, int type, isc_uint32_t value) 853{ 854 REQUIRE(VALID_KEY(key)); 855 REQUIRE(type <= DST_MAX_NUMERIC); 856 key->nums[type] = value; 857 key->numset[type] = ISC_TRUE; 858} 859 860void 861dst_key_unsetnum(dst_key_t *key, int type) 862{ 863 REQUIRE(VALID_KEY(key)); 864 REQUIRE(type <= DST_MAX_NUMERIC); 865 key->numset[type] = ISC_FALSE; 866} 867 868isc_result_t 869dst_key_gettime(const dst_key_t *key, int type, isc_stdtime_t *timep) { 870 REQUIRE(VALID_KEY(key)); 871 REQUIRE(timep != NULL); 872 REQUIRE(type <= DST_MAX_TIMES); 873 if (!key->timeset[type]) 874 return (ISC_R_NOTFOUND); 875 *timep = key->times[type]; 876 return (ISC_R_SUCCESS); 877} 878 879void 880dst_key_settime(dst_key_t *key, int type, isc_stdtime_t when) { 881 REQUIRE(VALID_KEY(key)); 882 REQUIRE(type <= DST_MAX_TIMES); 883 key->times[type] = when; 884 key->timeset[type] = ISC_TRUE; 885} 886 887void 888dst_key_unsettime(dst_key_t *key, int type) { 889 REQUIRE(VALID_KEY(key)); 890 REQUIRE(type <= DST_MAX_TIMES); 891 key->timeset[type] = ISC_FALSE; 892} 893 894isc_result_t 895dst_key_getprivateformat(const dst_key_t *key, int *majorp, int *minorp) { 896 REQUIRE(VALID_KEY(key)); 897 REQUIRE(majorp != NULL); 898 REQUIRE(minorp != NULL); 899 *majorp = key->fmt_major; 900 *minorp = key->fmt_minor; 901 return (ISC_R_SUCCESS); 902} 903 904void 905dst_key_setprivateformat(dst_key_t *key, int major, int minor) { 906 REQUIRE(VALID_KEY(key)); 907 key->fmt_major = major; 908 key->fmt_minor = minor; 909} 910 911static isc_boolean_t 912comparekeys(const dst_key_t *key1, const dst_key_t *key2, 913 isc_boolean_t match_revoked_key, 914 isc_boolean_t (*compare)(const dst_key_t *key1, 915 const dst_key_t *key2)) 916{ 917 REQUIRE(dst_initialized == ISC_TRUE); 918 REQUIRE(VALID_KEY(key1)); 919 REQUIRE(VALID_KEY(key2)); 920 921 if (key1 == key2) 922 return (ISC_TRUE); 923 924 if (key1 == NULL || key2 == NULL) 925 return (ISC_FALSE); 926 927 if (key1->key_alg != key2->key_alg) 928 return (ISC_FALSE); 929 930 if (key1->key_id != key2->key_id) { 931 if (!match_revoked_key) 932 return (ISC_FALSE); 933 if (key1->key_alg == DST_ALG_RSAMD5) 934 return (ISC_FALSE); 935 if ((key1->key_flags & DNS_KEYFLAG_REVOKE) == 936 (key2->key_flags & DNS_KEYFLAG_REVOKE)) 937 return (ISC_FALSE); 938 if (key1->key_id != key2->key_rid && 939 key1->key_rid != key2->key_id) 940 return (ISC_FALSE); 941 } 942 943 if (compare != NULL) 944 return (compare(key1, key2)); 945 else 946 return (ISC_FALSE); 947} 948 949 950/* 951 * Compares only the public portion of two keys, by converting them 952 * both to wire format and comparing the results. 953 */ 954static isc_boolean_t 955pub_compare(const dst_key_t *key1, const dst_key_t *key2) { 956 isc_result_t result; 957 unsigned char buf1[DST_KEY_MAXSIZE], buf2[DST_KEY_MAXSIZE]; 958 isc_buffer_t b1, b2; 959 isc_region_t r1, r2; 960 961 isc_buffer_init(&b1, buf1, sizeof(buf1)); 962 result = dst_key_todns(key1, &b1); 963 if (result != ISC_R_SUCCESS) 964 return (ISC_FALSE); 965 /* Zero out flags. */ 966 buf1[0] = buf1[1] = 0; 967 if ((key1->key_flags & DNS_KEYFLAG_EXTENDED) != 0) 968 isc_buffer_subtract(&b1, 2); 969 970 isc_buffer_init(&b2, buf2, sizeof(buf2)); 971 result = dst_key_todns(key2, &b2); 972 if (result != ISC_R_SUCCESS) 973 return (ISC_FALSE); 974 /* Zero out flags. */ 975 buf2[0] = buf2[1] = 0; 976 if ((key2->key_flags & DNS_KEYFLAG_EXTENDED) != 0) 977 isc_buffer_subtract(&b2, 2); 978 979 isc_buffer_usedregion(&b1, &r1); 980 /* Remove extended flags. */ 981 if ((key1->key_flags & DNS_KEYFLAG_EXTENDED) != 0) { 982 memmove(&buf1[4], &buf1[6], r1.length - 6); 983 r1.length -= 2; 984 } 985 986 isc_buffer_usedregion(&b2, &r2); 987 /* Remove extended flags. */ 988 if ((key2->key_flags & DNS_KEYFLAG_EXTENDED) != 0) { 989 memmove(&buf2[4], &buf2[6], r2.length - 6); 990 r2.length -= 2; 991 } 992 return (ISC_TF(isc_region_compare(&r1, &r2) == 0)); 993} 994 995isc_boolean_t 996dst_key_compare(const dst_key_t *key1, const dst_key_t *key2) { 997 return (comparekeys(key1, key2, ISC_FALSE, key1->func->compare)); 998} 999 1000isc_boolean_t 1001dst_key_pubcompare(const dst_key_t *key1, const dst_key_t *key2, 1002 isc_boolean_t match_revoked_key) 1003{ 1004 return (comparekeys(key1, key2, match_revoked_key, pub_compare)); 1005} 1006 1007 1008isc_boolean_t 1009dst_key_paramcompare(const dst_key_t *key1, const dst_key_t *key2) { 1010 REQUIRE(dst_initialized == ISC_TRUE); 1011 REQUIRE(VALID_KEY(key1)); 1012 REQUIRE(VALID_KEY(key2)); 1013 1014 if (key1 == key2) 1015 return (ISC_TRUE); 1016 if (key1 == NULL || key2 == NULL) 1017 return (ISC_FALSE); 1018 if (key1->key_alg == key2->key_alg && 1019 key1->func->paramcompare != NULL && 1020 key1->func->paramcompare(key1, key2) == ISC_TRUE) 1021 return (ISC_TRUE); 1022 else 1023 return (ISC_FALSE); 1024} 1025 1026void 1027dst_key_attach(dst_key_t *source, dst_key_t **target) { 1028 1029 REQUIRE(dst_initialized == ISC_TRUE); 1030 REQUIRE(target != NULL && *target == NULL); 1031 REQUIRE(VALID_KEY(source)); 1032 1033 isc_refcount_increment(&source->refs, NULL); 1034 *target = source; 1035} 1036 1037void 1038dst_key_free(dst_key_t **keyp) { 1039 isc_mem_t *mctx; 1040 dst_key_t *key; 1041 unsigned int refs; 1042 1043 REQUIRE(dst_initialized == ISC_TRUE); 1044 REQUIRE(keyp != NULL && VALID_KEY(*keyp)); 1045 1046 key = *keyp; 1047 mctx = key->mctx; 1048 1049 isc_refcount_decrement(&key->refs, &refs); 1050 if (refs != 0) 1051 return; 1052 1053 isc_refcount_destroy(&key->refs); 1054 if (key->keydata.generic != NULL) { 1055 INSIST(key->func->destroy != NULL); 1056 key->func->destroy(key); 1057 } 1058 if (key->engine != NULL) 1059 isc_mem_free(mctx, key->engine); 1060 if (key->label != NULL) 1061 isc_mem_free(mctx, key->label); 1062 dns_name_free(key->key_name, mctx); 1063 isc_mem_put(mctx, key->key_name, sizeof(dns_name_t)); 1064 if (key->key_tkeytoken) { 1065 isc_buffer_free(&key->key_tkeytoken); 1066 } 1067 memset(key, 0, sizeof(dst_key_t)); 1068 isc_mem_put(mctx, key, sizeof(dst_key_t)); 1069 *keyp = NULL; 1070} 1071 1072isc_boolean_t 1073dst_key_isprivate(const dst_key_t *key) { 1074 REQUIRE(VALID_KEY(key)); 1075 INSIST(key->func->isprivate != NULL); 1076 return (key->func->isprivate(key)); 1077} 1078 1079isc_result_t 1080dst_key_buildfilename(const dst_key_t *key, int type, 1081 const char *directory, isc_buffer_t *out) { 1082 1083 REQUIRE(VALID_KEY(key)); 1084 REQUIRE(type == DST_TYPE_PRIVATE || type == DST_TYPE_PUBLIC || 1085 type == 0); 1086 1087 return (buildfilename(key->key_name, key->key_id, key->key_alg, 1088 type, directory, out)); 1089} 1090 1091isc_result_t 1092dst_key_sigsize(const dst_key_t *key, unsigned int *n) { 1093 REQUIRE(dst_initialized == ISC_TRUE); 1094 REQUIRE(VALID_KEY(key)); 1095 REQUIRE(n != NULL); 1096 1097 /* XXXVIX this switch statement is too sparse to gen a jump table. */ 1098 switch (key->key_alg) { 1099 case DST_ALG_RSAMD5: 1100 case DST_ALG_RSASHA1: 1101 case DST_ALG_NSEC3RSASHA1: 1102 case DST_ALG_RSASHA256: 1103 case DST_ALG_RSASHA512: 1104 *n = (key->key_size + 7) / 8; 1105 break; 1106 case DST_ALG_DSA: 1107 case DST_ALG_NSEC3DSA: 1108 *n = DNS_SIG_DSASIGSIZE; 1109 break; 1110 case DST_ALG_ECCGOST: 1111 *n = DNS_SIG_GOSTSIGSIZE; 1112 break; 1113 case DST_ALG_HMACMD5: 1114 *n = 16; 1115 break; 1116 case DST_ALG_HMACSHA1: 1117 *n = ISC_SHA1_DIGESTLENGTH; 1118 break; 1119 case DST_ALG_HMACSHA224: 1120 *n = ISC_SHA224_DIGESTLENGTH; 1121 break; 1122 case DST_ALG_HMACSHA256: 1123 *n = ISC_SHA256_DIGESTLENGTH; 1124 break; 1125 case DST_ALG_HMACSHA384: 1126 *n = ISC_SHA384_DIGESTLENGTH; 1127 break; 1128 case DST_ALG_HMACSHA512: 1129 *n = ISC_SHA512_DIGESTLENGTH; 1130 break; 1131 case DST_ALG_GSSAPI: 1132 *n = 128; /*%< XXX */ 1133 break; 1134 case DST_ALG_DH: 1135 default: 1136 return (DST_R_UNSUPPORTEDALG); 1137 } 1138 return (ISC_R_SUCCESS); 1139} 1140 1141isc_result_t 1142dst_key_secretsize(const dst_key_t *key, unsigned int *n) { 1143 REQUIRE(dst_initialized == ISC_TRUE); 1144 REQUIRE(VALID_KEY(key)); 1145 REQUIRE(n != NULL); 1146 1147 if (key->key_alg == DST_ALG_DH) 1148 *n = (key->key_size + 7) / 8; 1149 else 1150 return (DST_R_UNSUPPORTEDALG); 1151 return (ISC_R_SUCCESS); 1152} 1153 1154/*% 1155 * Set the flags on a key, then recompute the key ID 1156 */ 1157isc_result_t 1158dst_key_setflags(dst_key_t *key, isc_uint32_t flags) { 1159 REQUIRE(VALID_KEY(key)); 1160 key->key_flags = flags; 1161 return (computeid(key)); 1162} 1163 1164void 1165dst_key_format(const dst_key_t *key, char *cp, unsigned int size) { 1166 char namestr[DNS_NAME_FORMATSIZE]; 1167 char algstr[DNS_NAME_FORMATSIZE]; 1168 1169 dns_name_format(dst_key_name(key), namestr, sizeof(namestr)); 1170 dns_secalg_format((dns_secalg_t) dst_key_alg(key), algstr, 1171 sizeof(algstr)); 1172 snprintf(cp, size, "%s/%s/%d", namestr, algstr, dst_key_id(key)); 1173} 1174 1175isc_result_t 1176dst_key_dump(dst_key_t *key, isc_mem_t *mctx, char **buffer, int *length) { 1177 1178 REQUIRE(buffer != NULL && *buffer == NULL); 1179 REQUIRE(length != NULL && *length == 0); 1180 REQUIRE(VALID_KEY(key)); 1181 1182 if (key->func->isprivate == NULL) 1183 return (ISC_R_NOTIMPLEMENTED); 1184 return (key->func->dump(key, mctx, buffer, length)); 1185} 1186 1187isc_result_t 1188dst_key_restore(dns_name_t *name, unsigned int alg, unsigned int flags, 1189 unsigned int protocol, dns_rdataclass_t rdclass, 1190 isc_mem_t *mctx, const char *keystr, dst_key_t **keyp) 1191{ 1192 isc_result_t result; 1193 dst_key_t *key; 1194 1195 REQUIRE(dst_initialized == ISC_TRUE); 1196 REQUIRE(keyp != NULL && *keyp == NULL); 1197 1198 if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) 1199 return (DST_R_UNSUPPORTEDALG); 1200 1201 if (dst_t_func[alg]->restore == NULL) 1202 return (ISC_R_NOTIMPLEMENTED); 1203 1204 key = get_key_struct(name, alg, flags, protocol, 0, rdclass, mctx); 1205 if (key == NULL) 1206 return (ISC_R_NOMEMORY); 1207 1208 result = (dst_t_func[alg]->restore)(key, keystr); 1209 if (result == ISC_R_SUCCESS) 1210 *keyp = key; 1211 else 1212 dst_key_free(&key); 1213 1214 return (result); 1215} 1216 1217/*** 1218 *** Static methods 1219 ***/ 1220 1221/*% 1222 * Allocates a key structure and fills in some of the fields. 1223 */ 1224static dst_key_t * 1225get_key_struct(dns_name_t *name, unsigned int alg, 1226 unsigned int flags, unsigned int protocol, 1227 unsigned int bits, dns_rdataclass_t rdclass, 1228 isc_mem_t *mctx) 1229{ 1230 dst_key_t *key; 1231 isc_result_t result; 1232 int i; 1233 1234 key = (dst_key_t *) isc_mem_get(mctx, sizeof(dst_key_t)); 1235 if (key == NULL) 1236 return (NULL); 1237 1238 memset(key, 0, sizeof(dst_key_t)); 1239 key->magic = KEY_MAGIC; 1240 1241 result = isc_refcount_init(&key->refs, 1); 1242 if (result != ISC_R_SUCCESS) { 1243 isc_mem_put(mctx, key, sizeof(dst_key_t)); 1244 return (NULL); 1245 } 1246 1247 key->key_name = isc_mem_get(mctx, sizeof(dns_name_t)); 1248 if (key->key_name == NULL) { 1249 isc_refcount_destroy(&key->refs); 1250 isc_mem_put(mctx, key, sizeof(dst_key_t)); 1251 return (NULL); 1252 } 1253 dns_name_init(key->key_name, NULL); 1254 result = dns_name_dup(name, mctx, key->key_name); 1255 if (result != ISC_R_SUCCESS) { 1256 isc_refcount_destroy(&key->refs); 1257 isc_mem_put(mctx, key->key_name, sizeof(dns_name_t)); 1258 isc_mem_put(mctx, key, sizeof(dst_key_t)); 1259 return (NULL); 1260 } 1261 key->key_alg = alg; 1262 key->key_flags = flags; 1263 key->key_proto = protocol; 1264 key->mctx = mctx; 1265 key->keydata.generic = NULL; 1266 key->key_size = bits; 1267 key->key_class = rdclass; 1268 key->func = dst_t_func[alg]; 1269 key->fmt_major = 0; 1270 key->fmt_minor = 0; 1271 for (i = 0; i < (DST_MAX_TIMES + 1); i++) { 1272 key->times[i] = 0; 1273 key->timeset[i] = ISC_FALSE; 1274 } 1275 return (key); 1276} 1277 1278/*% 1279 * Reads a public key from disk 1280 */ 1281isc_result_t 1282dst_key_read_public(const char *filename, int type, 1283 isc_mem_t *mctx, dst_key_t **keyp) 1284{ 1285 u_char rdatabuf[DST_KEY_MAXSIZE]; 1286 isc_buffer_t b; 1287 dns_fixedname_t name; 1288 isc_lex_t *lex = NULL; 1289 isc_token_t token; 1290 isc_result_t ret; 1291 dns_rdata_t rdata = DNS_RDATA_INIT; 1292 unsigned int opt = ISC_LEXOPT_DNSMULTILINE; 1293 dns_rdataclass_t rdclass = dns_rdataclass_in; 1294 isc_lexspecials_t specials; 1295 isc_uint32_t ttl; 1296 isc_result_t result; 1297 dns_rdatatype_t keytype; 1298 1299 /* 1300 * Open the file and read its formatted contents 1301 * File format: 1302 * domain.name [ttl] [class] [KEY|DNSKEY] <flags> <protocol> <algorithm> <key> 1303 */ 1304 1305 /* 1500 should be large enough for any key */ 1306 ret = isc_lex_create(mctx, 1500, &lex); 1307 if (ret != ISC_R_SUCCESS) 1308 goto cleanup; 1309 1310 memset(specials, 0, sizeof(specials)); 1311 specials['('] = 1; 1312 specials[')'] = 1; 1313 specials['"'] = 1; 1314 isc_lex_setspecials(lex, specials); 1315 isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE); 1316 1317 ret = isc_lex_openfile(lex, filename); 1318 if (ret != ISC_R_SUCCESS) 1319 goto cleanup; 1320 1321#define NEXTTOKEN(lex, opt, token) { \ 1322 ret = isc_lex_gettoken(lex, opt, token); \ 1323 if (ret != ISC_R_SUCCESS) \ 1324 goto cleanup; \ 1325 } 1326 1327#define BADTOKEN() { \ 1328 ret = ISC_R_UNEXPECTEDTOKEN; \ 1329 goto cleanup; \ 1330 } 1331 1332 /* Read the domain name */ 1333 NEXTTOKEN(lex, opt, &token); 1334 if (token.type != isc_tokentype_string) 1335 BADTOKEN(); 1336 1337 /* 1338 * We don't support "@" in .key files. 1339 */ 1340 if (!strcmp(DST_AS_STR(token), "@")) 1341 BADTOKEN(); 1342 1343 dns_fixedname_init(&name); 1344 isc_buffer_init(&b, DST_AS_STR(token), strlen(DST_AS_STR(token))); 1345 isc_buffer_add(&b, strlen(DST_AS_STR(token))); 1346 ret = dns_name_fromtext(dns_fixedname_name(&name), &b, dns_rootname, 1347 0, NULL); 1348 if (ret != ISC_R_SUCCESS) 1349 goto cleanup; 1350 1351 /* Read the next word: either TTL, class, or 'KEY' */ 1352 NEXTTOKEN(lex, opt, &token); 1353 1354 if (token.type != isc_tokentype_string) 1355 BADTOKEN(); 1356 1357 /* If it's a TTL, read the next one */ 1358 result = dns_ttl_fromtext(&token.value.as_textregion, &ttl); 1359 if (result == ISC_R_SUCCESS) 1360 NEXTTOKEN(lex, opt, &token); 1361 1362 if (token.type != isc_tokentype_string) 1363 BADTOKEN(); 1364 1365 ret = dns_rdataclass_fromtext(&rdclass, &token.value.as_textregion); 1366 if (ret == ISC_R_SUCCESS) 1367 NEXTTOKEN(lex, opt, &token); 1368 1369 if (token.type != isc_tokentype_string) 1370 BADTOKEN(); 1371 1372 if (strcasecmp(DST_AS_STR(token), "DNSKEY") == 0) 1373 keytype = dns_rdatatype_dnskey; 1374 else if (strcasecmp(DST_AS_STR(token), "KEY") == 0) 1375 keytype = dns_rdatatype_key; /*%< SIG(0), TKEY */ 1376 else 1377 BADTOKEN(); 1378 1379 if (((type & DST_TYPE_KEY) != 0 && keytype != dns_rdatatype_key) || 1380 ((type & DST_TYPE_KEY) == 0 && keytype != dns_rdatatype_dnskey)) { 1381 ret = DST_R_BADKEYTYPE; 1382 goto cleanup; 1383 } 1384 1385 isc_buffer_init(&b, rdatabuf, sizeof(rdatabuf)); 1386 ret = dns_rdata_fromtext(&rdata, rdclass, keytype, lex, NULL, 1387 ISC_FALSE, mctx, &b, NULL); 1388 if (ret != ISC_R_SUCCESS) 1389 goto cleanup; 1390 1391 ret = dst_key_fromdns(dns_fixedname_name(&name), rdclass, &b, mctx, 1392 keyp); 1393 if (ret != ISC_R_SUCCESS) 1394 goto cleanup; 1395 1396 cleanup: 1397 if (lex != NULL) 1398 isc_lex_destroy(&lex); 1399 return (ret); 1400} 1401 1402static isc_boolean_t 1403issymmetric(const dst_key_t *key) { 1404 REQUIRE(dst_initialized == ISC_TRUE); 1405 REQUIRE(VALID_KEY(key)); 1406 1407 /* XXXVIX this switch statement is too sparse to gen a jump table. */ 1408 switch (key->key_alg) { 1409 case DST_ALG_RSAMD5: 1410 case DST_ALG_RSASHA1: 1411 case DST_ALG_NSEC3RSASHA1: 1412 case DST_ALG_RSASHA256: 1413 case DST_ALG_RSASHA512: 1414 case DST_ALG_DSA: 1415 case DST_ALG_NSEC3DSA: 1416 case DST_ALG_DH: 1417 case DST_ALG_ECCGOST: 1418 return (ISC_FALSE); 1419 case DST_ALG_HMACMD5: 1420 case DST_ALG_GSSAPI: 1421 return (ISC_TRUE); 1422 default: 1423 return (ISC_FALSE); 1424 } 1425} 1426 1427/*% 1428 * Write key timing metadata to a file pointer, preceded by 'tag' 1429 */ 1430static void 1431printtime(const dst_key_t *key, int type, const char *tag, FILE *stream) { 1432 isc_result_t result; 1433#ifdef ISC_PLATFORM_USETHREADS 1434 char output[26]; /* Minimum buffer as per ctime_r() specification. */ 1435#else 1436 const char *output; 1437#endif 1438 isc_stdtime_t when; 1439 time_t t; 1440 char utc[sizeof("YYYYMMDDHHSSMM")]; 1441 isc_buffer_t b; 1442 isc_region_t r; 1443 1444 result = dst_key_gettime(key, type, &when); 1445 if (result == ISC_R_NOTFOUND) 1446 return; 1447 1448 /* time_t and isc_stdtime_t might be different sizes */ 1449 t = when; 1450#ifdef ISC_PLATFORM_USETHREADS 1451#ifdef WIN32 1452 if (ctime_s(output, sizeof(output), &t) != 0) 1453 goto error; 1454#else 1455 if (ctime_r(&t, output) == NULL) 1456 goto error; 1457#endif 1458#else 1459 output = ctime(&t); 1460#endif 1461 1462 isc_buffer_init(&b, utc, sizeof(utc)); 1463 result = dns_time32_totext(when, &b); 1464 if (result != ISC_R_SUCCESS) 1465 goto error; 1466 1467 isc_buffer_usedregion(&b, &r); 1468 fprintf(stream, "%s: %.*s (%.*s)\n", tag, (int)r.length, r.base, 1469 (int)strlen(output) - 1, output); 1470 return; 1471 1472 error: 1473 fprintf(stream, "%s: (set, unable to display)\n", tag); 1474} 1475 1476/*% 1477 * Writes a public key to disk in DNS format. 1478 */ 1479static isc_result_t 1480write_public_key(const dst_key_t *key, int type, const char *directory) { 1481 FILE *fp; 1482 isc_buffer_t keyb, textb, fileb, classb; 1483 isc_region_t r; 1484 char filename[ISC_DIR_NAMEMAX]; 1485 unsigned char key_array[DST_KEY_MAXSIZE]; 1486 char text_array[DST_KEY_MAXTEXTSIZE]; 1487 char class_array[10]; 1488 isc_result_t ret; 1489 dns_rdata_t rdata = DNS_RDATA_INIT; 1490 isc_fsaccess_t access; 1491 1492 REQUIRE(VALID_KEY(key)); 1493 1494 isc_buffer_init(&keyb, key_array, sizeof(key_array)); 1495 isc_buffer_init(&textb, text_array, sizeof(text_array)); 1496 isc_buffer_init(&classb, class_array, sizeof(class_array)); 1497 1498 ret = dst_key_todns(key, &keyb); 1499 if (ret != ISC_R_SUCCESS) 1500 return (ret); 1501 1502 isc_buffer_usedregion(&keyb, &r); 1503 dns_rdata_fromregion(&rdata, key->key_class, dns_rdatatype_dnskey, &r); 1504 1505 ret = dns_rdata_totext(&rdata, (dns_name_t *) NULL, &textb); 1506 if (ret != ISC_R_SUCCESS) 1507 return (DST_R_INVALIDPUBLICKEY); 1508 1509 ret = dns_rdataclass_totext(key->key_class, &classb); 1510 if (ret != ISC_R_SUCCESS) 1511 return (DST_R_INVALIDPUBLICKEY); 1512 1513 /* 1514 * Make the filename. 1515 */ 1516 isc_buffer_init(&fileb, filename, sizeof(filename)); 1517 ret = dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory, &fileb); 1518 if (ret != ISC_R_SUCCESS) 1519 return (ret); 1520 1521 /* 1522 * Create public key file. 1523 */ 1524 if ((fp = fopen(filename, "w")) == NULL) 1525 return (DST_R_WRITEERROR); 1526 1527 if (issymmetric(key)) { 1528 access = 0; 1529 isc_fsaccess_add(ISC_FSACCESS_OWNER, 1530 ISC_FSACCESS_READ | ISC_FSACCESS_WRITE, 1531 &access); 1532 (void)isc_fsaccess_set(filename, access); 1533 } 1534 1535 /* Write key information in comments */ 1536 if ((type & DST_TYPE_KEY) == 0) { 1537 fprintf(fp, "; This is a %s%s-signing key, keyid %d, for ", 1538 (key->key_flags & DNS_KEYFLAG_REVOKE) != 0 ? 1539 "revoked " : 1540 "", 1541 (key->key_flags & DNS_KEYFLAG_KSK) != 0 ? 1542 "key" : 1543 "zone", 1544 key->key_id); 1545 ret = dns_name_print(key->key_name, fp); 1546 if (ret != ISC_R_SUCCESS) { 1547 fclose(fp); 1548 return (ret); 1549 } 1550 fputc('\n', fp); 1551 1552 printtime(key, DST_TIME_CREATED, "; Created", fp); 1553 printtime(key, DST_TIME_PUBLISH, "; Publish", fp); 1554 printtime(key, DST_TIME_ACTIVATE, "; Activate", fp); 1555 printtime(key, DST_TIME_REVOKE, "; Revoke", fp); 1556 printtime(key, DST_TIME_INACTIVE, "; Inactive", fp); 1557 printtime(key, DST_TIME_DELETE, "; Delete", fp); 1558 } 1559 1560 /* Now print the actual key */ 1561 ret = dns_name_print(key->key_name, fp); 1562 1563 fprintf(fp, " "); 1564 1565 isc_buffer_usedregion(&classb, &r); 1566 if ((unsigned) fwrite(r.base, 1, r.length, fp) != r.length) 1567 ret = DST_R_WRITEERROR; 1568 1569 if ((type & DST_TYPE_KEY) != 0) 1570 fprintf(fp, " KEY "); 1571 else 1572 fprintf(fp, " DNSKEY "); 1573 1574 isc_buffer_usedregion(&textb, &r); 1575 if ((unsigned) fwrite(r.base, 1, r.length, fp) != r.length) 1576 ret = DST_R_WRITEERROR; 1577 1578 fputc('\n', fp); 1579 fflush(fp); 1580 if (ferror(fp)) 1581 ret = DST_R_WRITEERROR; 1582 fclose(fp); 1583 1584 return (ret); 1585} 1586 1587static isc_result_t 1588buildfilename(dns_name_t *name, dns_keytag_t id, 1589 unsigned int alg, unsigned int type, 1590 const char *directory, isc_buffer_t *out) 1591{ 1592 const char *suffix = ""; 1593 unsigned int len; 1594 isc_result_t result; 1595 1596 REQUIRE(out != NULL); 1597 if ((type & DST_TYPE_PRIVATE) != 0) 1598 suffix = ".private"; 1599 else if (type == DST_TYPE_PUBLIC) 1600 suffix = ".key"; 1601 if (directory != NULL) { 1602 if (isc_buffer_availablelength(out) < strlen(directory)) 1603 return (ISC_R_NOSPACE); 1604 isc_buffer_putstr(out, directory); 1605 if (strlen(directory) > 0U && 1606 directory[strlen(directory) - 1] != '/') 1607 isc_buffer_putstr(out, "/"); 1608 } 1609 if (isc_buffer_availablelength(out) < 1) 1610 return (ISC_R_NOSPACE); 1611 isc_buffer_putstr(out, "K"); 1612 result = dns_name_tofilenametext(name, ISC_FALSE, out); 1613 if (result != ISC_R_SUCCESS) 1614 return (result); 1615 len = 1 + 3 + 1 + 5 + strlen(suffix) + 1; 1616 if (isc_buffer_availablelength(out) < len) 1617 return (ISC_R_NOSPACE); 1618 sprintf((char *) isc_buffer_used(out), "+%03d+%05d%s", alg, id, 1619 suffix); 1620 isc_buffer_add(out, len); 1621 1622 return (ISC_R_SUCCESS); 1623} 1624 1625static isc_result_t 1626computeid(dst_key_t *key) { 1627 isc_buffer_t dnsbuf; 1628 unsigned char dns_array[DST_KEY_MAXSIZE]; 1629 isc_region_t r; 1630 isc_result_t ret; 1631 1632 isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array)); 1633 ret = dst_key_todns(key, &dnsbuf); 1634 if (ret != ISC_R_SUCCESS) 1635 return (ret); 1636 1637 isc_buffer_usedregion(&dnsbuf, &r); 1638 key->key_id = dst_region_computeid(&r, key->key_alg); 1639 key->key_rid = dst_region_computerid(&r, key->key_alg); 1640 return (ISC_R_SUCCESS); 1641} 1642 1643static isc_result_t 1644frombuffer(dns_name_t *name, unsigned int alg, unsigned int flags, 1645 unsigned int protocol, dns_rdataclass_t rdclass, 1646 isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) 1647{ 1648 dst_key_t *key; 1649 isc_result_t ret; 1650 1651 REQUIRE(dns_name_isabsolute(name)); 1652 REQUIRE(source != NULL); 1653 REQUIRE(mctx != NULL); 1654 REQUIRE(keyp != NULL && *keyp == NULL); 1655 1656 key = get_key_struct(name, alg, flags, protocol, 0, rdclass, mctx); 1657 if (key == NULL) 1658 return (ISC_R_NOMEMORY); 1659 1660 if (isc_buffer_remaininglength(source) > 0) { 1661 ret = algorithm_status(alg); 1662 if (ret != ISC_R_SUCCESS) { 1663 dst_key_free(&key); 1664 return (ret); 1665 } 1666 if (key->func->fromdns == NULL) { 1667 dst_key_free(&key); 1668 return (DST_R_UNSUPPORTEDALG); 1669 } 1670 1671 ret = key->func->fromdns(key, source); 1672 if (ret != ISC_R_SUCCESS) { 1673 dst_key_free(&key); 1674 return (ret); 1675 } 1676 } 1677 1678 *keyp = key; 1679 return (ISC_R_SUCCESS); 1680} 1681 1682static isc_result_t 1683algorithm_status(unsigned int alg) { 1684 REQUIRE(dst_initialized == ISC_TRUE); 1685 1686 if (dst_algorithm_supported(alg)) 1687 return (ISC_R_SUCCESS); 1688#ifndef OPENSSL 1689 if (alg == DST_ALG_RSAMD5 || alg == DST_ALG_RSASHA1 || 1690 alg == DST_ALG_DSA || alg == DST_ALG_DH || 1691 alg == DST_ALG_HMACMD5 || alg == DST_ALG_NSEC3DSA || 1692 alg == DST_ALG_NSEC3RSASHA1 || 1693 alg == DST_ALG_RSASHA256 || alg == DST_ALG_RSASHA512 || 1694 alg == DST_ALG_ECCGOST) 1695 return (DST_R_NOCRYPTO); 1696#endif 1697 return (DST_R_UNSUPPORTEDALG); 1698} 1699 1700static isc_result_t 1701addsuffix(char *filename, int len, const char *odirname, 1702 const char *ofilename, const char *suffix) 1703{ 1704 int olen = strlen(ofilename); 1705 int n; 1706 1707 if (olen > 1 && ofilename[olen - 1] == '.') 1708 olen -= 1; 1709 else if (olen > 8 && strcmp(ofilename + olen - 8, ".private") == 0) 1710 olen -= 8; 1711 else if (olen > 4 && strcmp(ofilename + olen - 4, ".key") == 0) 1712 olen -= 4; 1713 1714 if (odirname == NULL) 1715 n = snprintf(filename, len, "%.*s%s", olen, ofilename, suffix); 1716 else 1717 n = snprintf(filename, len, "%s/%.*s%s", 1718 odirname, olen, ofilename, suffix); 1719 if (n < 0) 1720 return (ISC_R_FAILURE); 1721 if (n >= len) 1722 return (ISC_R_NOSPACE); 1723 return (ISC_R_SUCCESS); 1724} 1725 1726isc_result_t 1727dst__entropy_getdata(void *buf, unsigned int len, isc_boolean_t pseudo) { 1728#ifdef BIND9 1729 unsigned int flags = dst_entropy_flags; 1730 1731 if (len == 0) 1732 return (ISC_R_SUCCESS); 1733 if (pseudo) 1734 flags &= ~ISC_ENTROPY_GOODONLY; 1735 else 1736 flags |= ISC_ENTROPY_BLOCKING; 1737 return (isc_entropy_getdata(dst_entropy_pool, buf, len, NULL, flags)); 1738#else 1739 UNUSED(buf); 1740 UNUSED(len); 1741 UNUSED(pseudo); 1742 1743 return (ISC_R_NOTIMPLEMENTED); 1744#endif 1745} 1746 1747unsigned int 1748dst__entropy_status(void) { 1749#ifdef BIND9 1750#ifdef GSSAPI 1751 unsigned int flags = dst_entropy_flags; 1752 isc_result_t ret; 1753 unsigned char buf[32]; 1754 static isc_boolean_t first = ISC_TRUE; 1755 1756 if (first) { 1757 /* Someone believes RAND_status() initializes the PRNG */ 1758 flags &= ~ISC_ENTROPY_GOODONLY; 1759 ret = isc_entropy_getdata(dst_entropy_pool, buf, 1760 sizeof(buf), NULL, flags); 1761 INSIST(ret == ISC_R_SUCCESS); 1762 isc_entropy_putdata(dst_entropy_pool, buf, 1763 sizeof(buf), 2 * sizeof(buf)); 1764 first = ISC_FALSE; 1765 } 1766#endif 1767 return (isc_entropy_status(dst_entropy_pool)); 1768#else 1769 return (0); 1770#endif 1771} 1772 1773isc_buffer_t * 1774dst_key_tkeytoken(const dst_key_t *key) { 1775 REQUIRE(VALID_KEY(key)); 1776 return (key->key_tkeytoken); 1777}