1 /* 2 * dnssec.c 3 * 4 * contains the cryptographic function needed for DNSSEC in ldns 5 * The crypto library used is openssl 6 * 7 * (c) NLnet Labs, 2004-2008 8 * 9 * See the file LICENSE for the license 10 */ 11 12 #include <ldns/config.h> 13 14 #include <ldns/ldns.h> 15 #include <ldns/dnssec.h> 16 17 #include <strings.h> 18 #include <time.h> 19 20 #ifdef HAVE_SSL 21 #include <openssl/ssl.h> 22 #include <openssl/evp.h> 23 #include <openssl/rand.h> 24 #include <openssl/err.h> 25 #include <openssl/md5.h> 26 #include <openssl/bn.h> 27 #include <openssl/rsa.h> 28 #ifdef USE_DSA 29 #include <openssl/dsa.h> 30 #endif 31 #endif 32 33 ldns_rr * 34 ldns_dnssec_get_rrsig_for_name_and_type(const ldns_rdf *name, 35 const ldns_rr_type type, 36 const ldns_rr_list *rrs) 37 { 38 size_t i; 39 ldns_rr *candidate; 40 41 if (!name || !rrs) { 42 return NULL; 43 } 44 45 for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { 46 candidate = ldns_rr_list_rr(rrs, i); 47 if (ldns_rr_get_type(candidate) == LDNS_RR_TYPE_RRSIG) { 48 if (ldns_dname_compare(ldns_rr_owner(candidate), 49 name) == 0 && 50 ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(candidate)) 51 == type 52 ) { 53 return candidate; 54 } 55 } 56 } 57 58 return NULL; 59 } 60 61 ldns_rr * 62 ldns_dnssec_get_dnskey_for_rrsig(const ldns_rr *rrsig, 63 const ldns_rr_list *rrs) 64 { 65 size_t i; 66 ldns_rr *candidate; 67 68 if (!rrsig || !rrs) { 69 return NULL; 70 } 71 72 for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { 73 candidate = ldns_rr_list_rr(rrs, i); 74 if (ldns_rr_get_type(candidate) == LDNS_RR_TYPE_DNSKEY) { 75 if (ldns_dname_compare(ldns_rr_owner(candidate), 76 ldns_rr_rrsig_signame(rrsig)) == 0 && 77 ldns_rdf2native_int16(ldns_rr_rrsig_keytag(rrsig)) == 78 ldns_calc_keytag(candidate) 79 ) { 80 return candidate; 81 } 82 } 83 } 84 85 return NULL; 86 } 87 88 ldns_rdf * 89 ldns_nsec_get_bitmap(const ldns_rr *nsec) { 90 if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC) { 91 return ldns_rr_rdf(nsec, 1); 92 } else if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC3) { 93 return ldns_rr_rdf(nsec, 5); 94 } else { 95 return NULL; 96 } 97 } 98 99 /*return the owner name of the closest encloser for name from the list of rrs */ 100 /* this is NOT the hash, but the original name! */ 101 ldns_rdf * 102 ldns_dnssec_nsec3_closest_encloser(const ldns_rdf *qname, 103 ATTR_UNUSED(ldns_rr_type qtype), 104 const ldns_rr_list *nsec3s) 105 { 106 /* remember parameters, they must match */ 107 uint8_t algorithm; 108 uint32_t iterations; 109 uint8_t salt_length; 110 uint8_t *salt; 111 112 ldns_rdf *sname, *hashed_sname, *tmp; 113 bool flag; 114 115 bool exact_match_found; 116 bool in_range_found; 117 118 ldns_status status; 119 ldns_rdf *zone_name; 120 121 size_t nsec_i; 122 ldns_rr *nsec; 123 ldns_rdf *result = NULL; 124 125 if (!qname || !nsec3s || ldns_rr_list_rr_count(nsec3s) < 1) { 126 return NULL; 127 } 128 129 nsec = ldns_rr_list_rr(nsec3s, 0); 130 algorithm = ldns_nsec3_algorithm(nsec); 131 salt_length = ldns_nsec3_salt_length(nsec); 132 salt = ldns_nsec3_salt_data(nsec); 133 iterations = ldns_nsec3_iterations(nsec); 134 135 sname = ldns_rdf_clone(qname); 136 137 flag = false; 138 139 zone_name = ldns_dname_left_chop(ldns_rr_owner(nsec)); 140 141 /* algorithm from nsec3-07 8.3 */ 142 while (ldns_dname_label_count(sname) > 0) { 143 exact_match_found = false; 144 in_range_found = false; 145 146 hashed_sname = ldns_nsec3_hash_name(sname, 147 algorithm, 148 iterations, 149 salt_length, 150 salt); 151 152 status = ldns_dname_cat(hashed_sname, zone_name); 153 if(status != LDNS_STATUS_OK) { 154 LDNS_FREE(salt); 155 ldns_rdf_deep_free(zone_name); 156 ldns_rdf_deep_free(sname); 157 ldns_rdf_deep_free(hashed_sname); 158 return NULL; 159 } 160 161 for (nsec_i = 0; nsec_i < ldns_rr_list_rr_count(nsec3s); nsec_i++) { 162 nsec = ldns_rr_list_rr(nsec3s, nsec_i); 163 164 /* check values of iterations etc! */ 165 166 /* exact match? */ 167 if (ldns_dname_compare(ldns_rr_owner(nsec), hashed_sname) == 0) { 168 exact_match_found = true; 169 } else if (ldns_nsec_covers_name(nsec, hashed_sname)) { 170 in_range_found = true; 171 } 172 173 } 174 if (!exact_match_found && in_range_found) { 175 flag = true; 176 } else if (exact_match_found && flag) { 177 result = ldns_rdf_clone(sname); 178 /* RFC 5155: 8.3. 2.** "The proof is complete" */ 179 ldns_rdf_deep_free(hashed_sname); 180 goto done; 181 } else if (exact_match_found && !flag) { 182 /* error! */ 183 ldns_rdf_deep_free(hashed_sname); 184 goto done; 185 } else { 186 flag = false; 187 } 188 189 ldns_rdf_deep_free(hashed_sname); 190 tmp = sname; 191 sname = ldns_dname_left_chop(sname); 192 ldns_rdf_deep_free(tmp); 193 } 194 195 done: 196 LDNS_FREE(salt); 197 ldns_rdf_deep_free(zone_name); 198 ldns_rdf_deep_free(sname); 199 200 return result; 201 } 202 203 bool 204 ldns_dnssec_pkt_has_rrsigs(const ldns_pkt *pkt) 205 { 206 size_t i; 207 for (i = 0; i < ldns_pkt_ancount(pkt); i++) { 208 if (ldns_rr_get_type(ldns_rr_list_rr(ldns_pkt_answer(pkt), i)) == 209 LDNS_RR_TYPE_RRSIG) { 210 return true; 211 } 212 } 213 for (i = 0; i < ldns_pkt_nscount(pkt); i++) { 214 if (ldns_rr_get_type(ldns_rr_list_rr(ldns_pkt_authority(pkt), i)) == 215 LDNS_RR_TYPE_RRSIG) { 216 return true; 217 } 218 } 219 return false; 220 } 221 222 ldns_rr_list * 223 ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt, 224 const ldns_rdf *name, 225 ldns_rr_type type) 226 { 227 uint16_t t_netorder; 228 ldns_rr_list *sigs; 229 ldns_rr_list *sigs_covered; 230 ldns_rdf *rdf_t; 231 232 sigs = ldns_pkt_rr_list_by_name_and_type(pkt, 233 name, 234 LDNS_RR_TYPE_RRSIG, 235 LDNS_SECTION_ANY_NOQUESTION 236 ); 237 238 t_netorder = htons(type); /* rdf are in network order! */ 239 rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, LDNS_RDF_SIZE_WORD, &t_netorder); 240 sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); 241 242 ldns_rdf_free(rdf_t); 243 ldns_rr_list_deep_free(sigs); 244 245 return sigs_covered; 246 247 } 248 249 ldns_rr_list * 250 ldns_dnssec_pkt_get_rrsigs_for_type(const ldns_pkt *pkt, ldns_rr_type type) 251 { 252 uint16_t t_netorder; 253 ldns_rr_list *sigs; 254 ldns_rr_list *sigs_covered; 255 ldns_rdf *rdf_t; 256 257 sigs = ldns_pkt_rr_list_by_type(pkt, 258 LDNS_RR_TYPE_RRSIG, 259 LDNS_SECTION_ANY_NOQUESTION 260 ); 261 262 t_netorder = htons(type); /* rdf are in network order! */ 263 rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, 264 2, 265 &t_netorder); 266 sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); 267 268 ldns_rdf_free(rdf_t); 269 ldns_rr_list_deep_free(sigs); 270 271 return sigs_covered; 272 273 } 274 275 /* used only on the public key RR */ 276 uint16_t 277 ldns_calc_keytag(const ldns_rr *key) 278 { 279 uint16_t ac16; 280 ldns_buffer *keybuf; 281 size_t keysize; 282 283 if (!key) { 284 return 0; 285 } 286 287 if (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY && 288 ldns_rr_get_type(key) != LDNS_RR_TYPE_KEY 289 ) { 290 return 0; 291 } 292 293 /* rdata to buf - only put the rdata in a buffer */ 294 keybuf = ldns_buffer_new(LDNS_MIN_BUFLEN); /* grows */ 295 if (!keybuf) { 296 return 0; 297 } 298 (void)ldns_rr_rdata2buffer_wire(keybuf, key); 299 /* the current pos in the buffer is the keysize */ 300 keysize= ldns_buffer_position(keybuf); 301 302 ac16 = ldns_calc_keytag_raw(ldns_buffer_begin(keybuf), keysize); 303 ldns_buffer_free(keybuf); 304 return ac16; 305 } 306 307 uint16_t ldns_calc_keytag_raw(const uint8_t* key, size_t keysize) 308 { 309 unsigned int i; 310 uint32_t ac32; 311 uint16_t ac16; 312 313 if(keysize < 4) { 314 return 0; 315 } 316 /* look at the algorithm field, copied from 2535bis */ 317 if (key[3] == LDNS_RSAMD5) { 318 ac16 = 0; 319 if (keysize > 4) { 320 memmove(&ac16, key + keysize - 3, 2); 321 } 322 ac16 = ntohs(ac16); 323 return (uint16_t) ac16; 324 } else { 325 ac32 = 0; 326 for (i = 0; (size_t)i < keysize; ++i) { 327 ac32 += (i & 1) ? key[i] : key[i] << 8; 328 } 329 ac32 += (ac32 >> 16) & 0xFFFF; 330 return (uint16_t) (ac32 & 0xFFFF); 331 } 332 } 333 334 #ifdef HAVE_SSL 335 DSA * 336 ldns_key_buf2dsa(const ldns_buffer *key) 337 { 338 return ldns_key_buf2dsa_raw((const unsigned char*)ldns_buffer_begin(key), 339 ldns_buffer_position(key)); 340 } 341 342 DSA * 343 ldns_key_buf2dsa_raw(const unsigned char* key, size_t len) 344 { 345 uint8_t T; 346 uint16_t length; 347 uint16_t offset; 348 DSA *dsa; 349 BIGNUM *Q; BIGNUM *P; 350 BIGNUM *G; BIGNUM *Y; 351 352 if(len == 0) 353 return NULL; 354 T = (uint8_t)key[0]; 355 length = (64 + T * 8); 356 offset = 1; 357 358 if (T > 8) { 359 return NULL; 360 } 361 if(len < (size_t)1 + SHA_DIGEST_LENGTH + 3*length) 362 return NULL; 363 364 Q = BN_bin2bn(key+offset, SHA_DIGEST_LENGTH, NULL); 365 offset += SHA_DIGEST_LENGTH; 366 367 P = BN_bin2bn(key+offset, (int)length, NULL); 368 offset += length; 369 370 G = BN_bin2bn(key+offset, (int)length, NULL); 371 offset += length; 372 373 Y = BN_bin2bn(key+offset, (int)length, NULL); 374 375 /* create the key and set its properties */ 376 if(!Q || !P || !G || !Y || !(dsa = DSA_new())) { 377 BN_free(Q); 378 BN_free(P); 379 BN_free(G); 380 BN_free(Y); 381 return NULL; 382 } 383 #if OPENSSL_VERSION_NUMBER < 0x10100000 || defined(HAVE_LIBRESSL) 384 #ifndef S_SPLINT_S 385 dsa->p = P; 386 dsa->q = Q; 387 dsa->g = G; 388 dsa->pub_key = Y; 389 #endif /* splint */ 390 #else /* OPENSSL_VERSION_NUMBER */ 391 if (!DSA_set0_pqg(dsa, P, Q, G)) { 392 /* QPG not yet attached, need to free */ 393 BN_free(Q); 394 BN_free(P); 395 BN_free(G); 396 397 DSA_free(dsa); 398 BN_free(Y); 399 return NULL; 400 } 401 if (!DSA_set0_key(dsa, Y, NULL)) { 402 /* QPG attached, cleaned up by DSA_fre() */ 403 DSA_free(dsa); 404 BN_free(Y); 405 return NULL; 406 } 407 #endif /* OPENSSL_VERSION_NUMBER */ 408 return dsa; 409 } 410 411 RSA * 412 ldns_key_buf2rsa(const ldns_buffer *key) 413 { 414 return ldns_key_buf2rsa_raw((const unsigned char*)ldns_buffer_begin(key), 415 ldns_buffer_position(key)); 416 } 417 418 RSA * 419 ldns_key_buf2rsa_raw(const unsigned char* key, size_t len) 420 { 421 uint16_t offset; 422 uint16_t exp; 423 uint16_t int16; 424 RSA *rsa; 425 BIGNUM *modulus; 426 BIGNUM *exponent; 427 428 if (len == 0) 429 return NULL; 430 if (key[0] == 0) { 431 if(len < 3) 432 return NULL; 433 /* need some smart comment here XXX*/ 434 /* the exponent is too large so it's places 435 * futher...???? */ 436 memmove(&int16, key+1, 2); 437 exp = ntohs(int16); 438 offset = 3; 439 } else { 440 exp = key[0]; 441 offset = 1; 442 } 443 444 /* key length at least one */ 445 if(len < (size_t)offset + exp + 1) 446 return NULL; 447 448 /* Exponent */ 449 exponent = BN_new(); 450 if(!exponent) return NULL; 451 (void) BN_bin2bn(key+offset, (int)exp, exponent); 452 offset += exp; 453 454 /* Modulus */ 455 modulus = BN_new(); 456 if(!modulus) { 457 BN_free(exponent); 458 return NULL; 459 } 460 /* length of the buffer must match the key length! */ 461 (void) BN_bin2bn(key+offset, (int)(len - offset), modulus); 462 463 rsa = RSA_new(); 464 if(!rsa) { 465 BN_free(exponent); 466 BN_free(modulus); 467 return NULL; 468 } 469 #if OPENSSL_VERSION_NUMBER < 0x10100000 || defined(HAVE_LIBRESSL) 470 #ifndef S_SPLINT_S 471 rsa->n = modulus; 472 rsa->e = exponent; 473 #endif /* splint */ 474 #else /* OPENSSL_VERSION_NUMBER */ 475 if (!RSA_set0_key(rsa, modulus, exponent, NULL)) { 476 BN_free(exponent); 477 BN_free(modulus); 478 RSA_free(rsa); 479 return NULL; 480 } 481 #endif /* OPENSSL_VERSION_NUMBER */ 482 483 return rsa; 484 } 485 486 int 487 ldns_digest_evp(const unsigned char* data, unsigned int len, unsigned char* dest, 488 const EVP_MD* md) 489 { 490 EVP_MD_CTX* ctx; 491 ctx = EVP_MD_CTX_create(); 492 if(!ctx) 493 return false; 494 if(!EVP_DigestInit_ex(ctx, md, NULL) || 495 !EVP_DigestUpdate(ctx, data, len) || 496 !EVP_DigestFinal_ex(ctx, dest, NULL)) { 497 EVP_MD_CTX_destroy(ctx); 498 return false; 499 } 500 EVP_MD_CTX_destroy(ctx); 501 return true; 502 } 503 #endif /* HAVE_SSL */ 504 505 ldns_rr * 506 ldns_key_rr2ds(const ldns_rr *key, ldns_hash h) 507 { 508 ldns_rdf *tmp; 509 ldns_rr *ds; 510 uint16_t keytag; 511 uint8_t sha1hash; 512 uint8_t *digest; 513 ldns_buffer *data_buf; 514 #ifdef USE_GOST 515 const EVP_MD* md = NULL; 516 #endif 517 518 if (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY) { 519 return NULL; 520 } 521 522 ds = ldns_rr_new(); 523 if (!ds) { 524 return NULL; 525 } 526 ldns_rr_set_type(ds, LDNS_RR_TYPE_DS); 527 ldns_rr_set_owner(ds, ldns_rdf_clone( 528 ldns_rr_owner(key))); 529 ldns_rr_set_ttl(ds, ldns_rr_ttl(key)); 530 ldns_rr_set_class(ds, ldns_rr_get_class(key)); 531 532 switch(h) { 533 default: 534 case LDNS_SHA1: 535 digest = LDNS_XMALLOC(uint8_t, LDNS_SHA1_DIGEST_LENGTH); 536 if (!digest) { 537 ldns_rr_free(ds); 538 return NULL; 539 } 540 break; 541 case LDNS_SHA256: 542 digest = LDNS_XMALLOC(uint8_t, LDNS_SHA256_DIGEST_LENGTH); 543 if (!digest) { 544 ldns_rr_free(ds); 545 return NULL; 546 } 547 break; 548 case LDNS_HASH_GOST: 549 #ifdef USE_GOST 550 (void)ldns_key_EVP_load_gost_id(); 551 md = EVP_get_digestbyname("md_gost94"); 552 if(!md) { 553 ldns_rr_free(ds); 554 return NULL; 555 } 556 digest = LDNS_XMALLOC(uint8_t, EVP_MD_size(md)); 557 if (!digest) { 558 ldns_rr_free(ds); 559 return NULL; 560 } 561 break; 562 #else 563 /* not implemented */ 564 ldns_rr_free(ds); 565 return NULL; 566 #endif 567 case LDNS_SHA384: 568 #ifdef USE_ECDSA 569 digest = LDNS_XMALLOC(uint8_t, SHA384_DIGEST_LENGTH); 570 if (!digest) { 571 ldns_rr_free(ds); 572 return NULL; 573 } 574 break; 575 #else 576 /* not implemented */ 577 ldns_rr_free(ds); 578 return NULL; 579 #endif 580 } 581 582 data_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); 583 if (!data_buf) { 584 LDNS_FREE(digest); 585 ldns_rr_free(ds); 586 return NULL; 587 } 588 589 /* keytag */ 590 keytag = htons(ldns_calc_keytag((ldns_rr*)key)); 591 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT16, 592 sizeof(uint16_t), 593 &keytag); 594 ldns_rr_push_rdf(ds, tmp); 595 596 /* copy the algorithm field */ 597 if ((tmp = ldns_rr_rdf(key, 2)) == NULL) { 598 LDNS_FREE(digest); 599 ldns_buffer_free(data_buf); 600 ldns_rr_free(ds); 601 return NULL; 602 } else { 603 ldns_rr_push_rdf(ds, ldns_rdf_clone( tmp )); 604 } 605 606 /* digest hash type */ 607 sha1hash = (uint8_t)h; 608 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, 609 sizeof(uint8_t), 610 &sha1hash); 611 ldns_rr_push_rdf(ds, tmp); 612 613 /* digest */ 614 /* owner name */ 615 tmp = ldns_rdf_clone(ldns_rr_owner(key)); 616 ldns_dname2canonical(tmp); 617 if (ldns_rdf2buffer_wire(data_buf, tmp) != LDNS_STATUS_OK) { 618 LDNS_FREE(digest); 619 ldns_buffer_free(data_buf); 620 ldns_rr_free(ds); 621 ldns_rdf_deep_free(tmp); 622 return NULL; 623 } 624 ldns_rdf_deep_free(tmp); 625 626 /* all the rdata's */ 627 if (ldns_rr_rdata2buffer_wire(data_buf, 628 (ldns_rr*)key) != LDNS_STATUS_OK) { 629 LDNS_FREE(digest); 630 ldns_buffer_free(data_buf); 631 ldns_rr_free(ds); 632 return NULL; 633 } 634 switch(h) { 635 case LDNS_SHA1: 636 (void) ldns_sha1((unsigned char *) ldns_buffer_begin(data_buf), 637 (unsigned int) ldns_buffer_position(data_buf), 638 (unsigned char *) digest); 639 640 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, 641 LDNS_SHA1_DIGEST_LENGTH, 642 digest); 643 ldns_rr_push_rdf(ds, tmp); 644 645 break; 646 case LDNS_SHA256: 647 (void) ldns_sha256((unsigned char *) ldns_buffer_begin(data_buf), 648 (unsigned int) ldns_buffer_position(data_buf), 649 (unsigned char *) digest); 650 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, 651 LDNS_SHA256_DIGEST_LENGTH, 652 digest); 653 ldns_rr_push_rdf(ds, tmp); 654 break; 655 case LDNS_HASH_GOST: 656 #ifdef USE_GOST 657 if(!ldns_digest_evp((unsigned char *) ldns_buffer_begin(data_buf), 658 (unsigned int) ldns_buffer_position(data_buf), 659 (unsigned char *) digest, md)) { 660 LDNS_FREE(digest); 661 ldns_buffer_free(data_buf); 662 ldns_rr_free(ds); 663 return NULL; 664 } 665 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, 666 (size_t)EVP_MD_size(md), 667 digest); 668 ldns_rr_push_rdf(ds, tmp); 669 #endif 670 break; 671 case LDNS_SHA384: 672 #ifdef USE_ECDSA 673 (void) SHA384((unsigned char *) ldns_buffer_begin(data_buf), 674 (unsigned int) ldns_buffer_position(data_buf), 675 (unsigned char *) digest); 676 tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, 677 SHA384_DIGEST_LENGTH, 678 digest); 679 ldns_rr_push_rdf(ds, tmp); 680 #endif 681 break; 682 } 683 684 LDNS_FREE(digest); 685 ldns_buffer_free(data_buf); 686 return ds; 687 } 688 689 /* From RFC3845: 690 * 691 * 2.1.2. The List of Type Bit Map(s) Field 692 * 693 * The RR type space is split into 256 window blocks, each representing 694 * the low-order 8 bits of the 16-bit RR type space. Each block that 695 * has at least one active RR type is encoded using a single octet 696 * window number (from 0 to 255), a single octet bitmap length (from 1 697 * to 32) indicating the number of octets used for the window block's 698 * bitmap, and up to 32 octets (256 bits) of bitmap. 699 * 700 * Window blocks are present in the NSEC RR RDATA in increasing 701 * numerical order. 702 * 703 * "|" denotes concatenation 704 * 705 * Type Bit Map(s) Field = ( Window Block # | Bitmap Length | Bitmap ) + 706 * 707 * <cut> 708 * 709 * Blocks with no types present MUST NOT be included. Trailing zero 710 * octets in the bitmap MUST be omitted. The length of each block's 711 * bitmap is determined by the type code with the largest numerical 712 * value within that block, among the set of RR types present at the 713 * NSEC RR's owner name. Trailing zero octets not specified MUST be 714 * interpreted as zero octets. 715 */ 716 ldns_rdf * 717 ldns_dnssec_create_nsec_bitmap(ldns_rr_type rr_type_list[], 718 size_t size, 719 ldns_rr_type nsec_type) 720 { 721 uint8_t window; /* most significant octet of type */ 722 uint8_t subtype; /* least significant octet of type */ 723 int windows[256]; /* Max subtype per window */ 724 uint8_t windowpresent[256]; /* bool if window appears in bitmap */ 725 ldns_rr_type* d; /* used to traverse rr_type_list*/ 726 size_t i; /* used to traverse windows array */ 727 728 size_t sz; /* size needed for type bitmap rdf */ 729 uint8_t* data = NULL; /* rdf data */ 730 uint8_t* dptr; /* used to itraverse rdf data */ 731 ldns_rdf* rdf; /* bitmap rdf to return */ 732 733 if (nsec_type != LDNS_RR_TYPE_NSEC && 734 nsec_type != LDNS_RR_TYPE_NSEC3) { 735 return NULL; 736 } 737 memset(windows, 0, sizeof(int)*256); 738 memset(windowpresent, 0, 256); 739 740 /* Which other windows need to be in the bitmap rdf? 741 */ 742 for (d = rr_type_list; d < rr_type_list + size; d++) { 743 window = *d >> 8; 744 subtype = *d & 0xff; 745 windowpresent[window] = 1; 746 if (windows[window] < (int)subtype) { 747 windows[window] = (int)subtype; 748 } 749 } 750 751 /* How much space do we need in the rdf for those windows? 752 */ 753 sz = 0; 754 for (i = 0; i < 256; i++) { 755 if (windowpresent[i]) { 756 sz += windows[i] / 8 + 3; 757 } 758 } 759 if (sz > 0) { 760 /* Format rdf data according RFC3845 Section 2.1.2 (see above) 761 */ 762 dptr = data = LDNS_CALLOC(uint8_t, sz); 763 if (!data) { 764 return NULL; 765 } 766 for (i = 0; i < 256; i++) { 767 if (windowpresent[i]) { 768 *dptr++ = (uint8_t)i; 769 *dptr++ = (uint8_t)(windows[i] / 8 + 1); 770 771 /* Now let windows[i] index the bitmap 772 * within data 773 */ 774 windows[i] = (int)(dptr - data); 775 776 dptr += dptr[-1]; 777 } 778 } 779 } 780 781 /* Set the bits? 782 */ 783 for (d = rr_type_list; d < rr_type_list + size; d++) { 784 subtype = *d & 0xff; 785 data[windows[*d >> 8] + subtype/8] |= (0x80 >> (subtype % 8)); 786 } 787 788 /* Allocate and return rdf structure for the data 789 */ 790 rdf = ldns_rdf_new(LDNS_RDF_TYPE_BITMAP, sz, data); 791 if (!rdf) { 792 LDNS_FREE(data); 793 return NULL; 794 } 795 return rdf; 796 } 797 798 int 799 ldns_dnssec_rrsets_contains_type(const ldns_dnssec_rrsets *rrsets, 800 ldns_rr_type type) 801 { 802 const ldns_dnssec_rrsets *cur_rrset = rrsets; 803 while (cur_rrset) { 804 if (cur_rrset->type == type) { 805 return 1; 806 } 807 cur_rrset = cur_rrset->next; 808 } 809 return 0; 810 } 811 812 ldns_rr * 813 ldns_dnssec_create_nsec(const ldns_dnssec_name *from, 814 const ldns_dnssec_name *to, 815 ldns_rr_type nsec_type) 816 { 817 ldns_rr *nsec_rr; 818 ldns_rr_type types[65536]; 819 size_t type_count = 0; 820 ldns_dnssec_rrsets *cur_rrsets; 821 int on_delegation_point; 822 823 if (!from || !to || (nsec_type != LDNS_RR_TYPE_NSEC)) { 824 return NULL; 825 } 826 827 nsec_rr = ldns_rr_new(); 828 ldns_rr_set_type(nsec_rr, nsec_type); 829 ldns_rr_set_owner(nsec_rr, ldns_rdf_clone(ldns_dnssec_name_name(from))); 830 ldns_rr_push_rdf(nsec_rr, ldns_rdf_clone(ldns_dnssec_name_name(to))); 831 832 on_delegation_point = ldns_dnssec_rrsets_contains_type( 833 from->rrsets, LDNS_RR_TYPE_NS) 834 && !ldns_dnssec_rrsets_contains_type( 835 from->rrsets, LDNS_RR_TYPE_SOA); 836 837 cur_rrsets = from->rrsets; 838 while (cur_rrsets) { 839 /* Do not include non-authoritative rrsets on the delegation point 840 * in the type bitmap */ 841 if ((on_delegation_point && ( 842 cur_rrsets->type == LDNS_RR_TYPE_NS 843 || cur_rrsets->type == LDNS_RR_TYPE_DS)) 844 || (!on_delegation_point && 845 cur_rrsets->type != LDNS_RR_TYPE_RRSIG 846 && cur_rrsets->type != LDNS_RR_TYPE_NSEC)) { 847 848 types[type_count] = cur_rrsets->type; 849 type_count++; 850 } 851 cur_rrsets = cur_rrsets->next; 852 853 } 854 types[type_count] = LDNS_RR_TYPE_RRSIG; 855 type_count++; 856 types[type_count] = LDNS_RR_TYPE_NSEC; 857 type_count++; 858 859 ldns_rr_push_rdf(nsec_rr, ldns_dnssec_create_nsec_bitmap(types, 860 type_count, 861 nsec_type)); 862 863 return nsec_rr; 864 } 865 866 ldns_rr * 867 ldns_dnssec_create_nsec3(const ldns_dnssec_name *from, 868 const ldns_dnssec_name *to, 869 const ldns_rdf *zone_name, 870 uint8_t algorithm, 871 uint8_t flags, 872 uint16_t iterations, 873 uint8_t salt_length, 874 const uint8_t *salt) 875 { 876 ldns_rr *nsec_rr; 877 ldns_rr_type types[65536]; 878 size_t type_count = 0; 879 ldns_dnssec_rrsets *cur_rrsets; 880 ldns_status status; 881 int on_delegation_point; 882 883 if (!from) { 884 return NULL; 885 } 886 887 nsec_rr = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3); 888 ldns_rr_set_owner(nsec_rr, 889 ldns_nsec3_hash_name(ldns_dnssec_name_name(from), 890 algorithm, 891 iterations, 892 salt_length, 893 salt)); 894 status = ldns_dname_cat(ldns_rr_owner(nsec_rr), zone_name); 895 if(status != LDNS_STATUS_OK) { 896 ldns_rr_free(nsec_rr); 897 return NULL; 898 } 899 ldns_nsec3_add_param_rdfs(nsec_rr, 900 algorithm, 901 flags, 902 iterations, 903 salt_length, 904 salt); 905 906 on_delegation_point = ldns_dnssec_rrsets_contains_type( 907 from->rrsets, LDNS_RR_TYPE_NS) 908 && !ldns_dnssec_rrsets_contains_type( 909 from->rrsets, LDNS_RR_TYPE_SOA); 910 cur_rrsets = from->rrsets; 911 while (cur_rrsets) { 912 /* Do not include non-authoritative rrsets on the delegation point 913 * in the type bitmap. Potentionally not skipping insecure 914 * delegation should have been done earlier, in function 915 * ldns_dnssec_zone_create_nsec3s, or even earlier in: 916 * ldns_dnssec_zone_sign_nsec3_flg . 917 */ 918 if ((on_delegation_point && ( 919 cur_rrsets->type == LDNS_RR_TYPE_NS 920 || cur_rrsets->type == LDNS_RR_TYPE_DS)) 921 || (!on_delegation_point && 922 cur_rrsets->type != LDNS_RR_TYPE_RRSIG)) { 923 924 types[type_count] = cur_rrsets->type; 925 type_count++; 926 } 927 cur_rrsets = cur_rrsets->next; 928 } 929 /* always add rrsig type if this is not an unsigned 930 * delegation 931 */ 932 if (type_count > 0 && 933 !(type_count == 1 && types[0] == LDNS_RR_TYPE_NS)) { 934 types[type_count] = LDNS_RR_TYPE_RRSIG; 935 type_count++; 936 } 937 938 /* leave next rdata empty if they weren't precomputed yet */ 939 if (to && to->hashed_name) { 940 (void) ldns_rr_set_rdf(nsec_rr, 941 ldns_rdf_clone(to->hashed_name), 942 4); 943 } else { 944 (void) ldns_rr_set_rdf(nsec_rr, NULL, 4); 945 } 946 947 ldns_rr_push_rdf(nsec_rr, 948 ldns_dnssec_create_nsec_bitmap(types, 949 type_count, 950 LDNS_RR_TYPE_NSEC3)); 951 952 return nsec_rr; 953 } 954 955 ldns_rr * 956 ldns_create_nsec(ldns_rdf *cur_owner, ldns_rdf *next_owner, ldns_rr_list *rrs) 957 { 958 /* we do not do any check here - garbage in, garbage out */ 959 960 /* the the start and end names - get the type from the 961 * before rrlist */ 962 963 /* inefficient, just give it a name, a next name, and a list of rrs */ 964 /* we make 1 big uberbitmap first, then windows */ 965 /* todo: make something more efficient :) */ 966 uint16_t i; 967 ldns_rr *i_rr; 968 uint16_t i_type; 969 970 ldns_rr *nsec = NULL; 971 ldns_rr_type i_type_list[65536]; 972 size_t type_count = 0; 973 974 nsec = ldns_rr_new(); 975 ldns_rr_set_type(nsec, LDNS_RR_TYPE_NSEC); 976 ldns_rr_set_owner(nsec, ldns_rdf_clone(cur_owner)); 977 ldns_rr_push_rdf(nsec, ldns_rdf_clone(next_owner)); 978 979 for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { 980 i_rr = ldns_rr_list_rr(rrs, i); 981 if (ldns_rdf_compare(cur_owner, 982 ldns_rr_owner(i_rr)) == 0) { 983 i_type = ldns_rr_get_type(i_rr); 984 if (i_type != LDNS_RR_TYPE_RRSIG && i_type != LDNS_RR_TYPE_NSEC) { 985 if (type_count == 0 || i_type_list[type_count-1] != i_type) { 986 i_type_list[type_count] = i_type; 987 type_count++; 988 } 989 } 990 } 991 } 992 993 i_type_list[type_count] = LDNS_RR_TYPE_RRSIG; 994 type_count++; 995 i_type_list[type_count] = LDNS_RR_TYPE_NSEC; 996 type_count++; 997 998 ldns_rr_push_rdf(nsec, 999 ldns_dnssec_create_nsec_bitmap(i_type_list, 1000 type_count, LDNS_RR_TYPE_NSEC)); 1001 1002 return nsec; 1003 } 1004 1005 ldns_rdf * 1006 ldns_nsec3_hash_name(const ldns_rdf *name, 1007 uint8_t algorithm, 1008 uint16_t iterations, 1009 uint8_t salt_length, 1010 const uint8_t *salt) 1011 { 1012 size_t hashed_owner_str_len; 1013 ldns_rdf *cann; 1014 ldns_rdf *hashed_owner; 1015 unsigned char *hashed_owner_str; 1016 char *hashed_owner_b32; 1017 size_t hashed_owner_b32_len; 1018 uint32_t cur_it; 1019 /* define to contain the largest possible hash, which is 1020 * sha1 at the moment */ 1021 unsigned char hash[LDNS_SHA1_DIGEST_LENGTH]; 1022 ldns_status status; 1023 1024 /* TODO: mnemonic list for hash algs SHA-1, default to 1 now (sha1) */ 1025 if (algorithm != LDNS_SHA1) { 1026 return NULL; 1027 } 1028 1029 /* prepare the owner name according to the draft section bla */ 1030 cann = ldns_rdf_clone(name); 1031 if(!cann) { 1032 #ifdef STDERR_MSGS 1033 fprintf(stderr, "Memory error\n"); 1034 #endif 1035 return NULL; 1036 } 1037 ldns_dname2canonical(cann); 1038 1039 hashed_owner_str_len = salt_length + ldns_rdf_size(cann); 1040 hashed_owner_str = LDNS_XMALLOC(unsigned char, hashed_owner_str_len); 1041 if(!hashed_owner_str) { 1042 ldns_rdf_deep_free(cann); 1043 return NULL; 1044 } 1045 memcpy(hashed_owner_str, ldns_rdf_data(cann), ldns_rdf_size(cann)); 1046 memcpy(hashed_owner_str + ldns_rdf_size(cann), salt, salt_length); 1047 ldns_rdf_deep_free(cann); 1048 1049 for (cur_it = iterations + 1; cur_it > 0; cur_it--) { 1050 (void) ldns_sha1((unsigned char *) hashed_owner_str, 1051 (unsigned int) hashed_owner_str_len, hash); 1052 1053 LDNS_FREE(hashed_owner_str); 1054 hashed_owner_str_len = salt_length + LDNS_SHA1_DIGEST_LENGTH; 1055 hashed_owner_str = LDNS_XMALLOC(unsigned char, hashed_owner_str_len); 1056 if (!hashed_owner_str) { 1057 return NULL; 1058 } 1059 memcpy(hashed_owner_str, hash, LDNS_SHA1_DIGEST_LENGTH); 1060 memcpy(hashed_owner_str + LDNS_SHA1_DIGEST_LENGTH, salt, salt_length); 1061 hashed_owner_str_len = LDNS_SHA1_DIGEST_LENGTH + salt_length; 1062 } 1063 1064 LDNS_FREE(hashed_owner_str); 1065 hashed_owner_str = hash; 1066 hashed_owner_str_len = LDNS_SHA1_DIGEST_LENGTH; 1067 1068 hashed_owner_b32 = LDNS_XMALLOC(char, 1069 ldns_b32_ntop_calculate_size(hashed_owner_str_len) + 1); 1070 if(!hashed_owner_b32) { 1071 return NULL; 1072 } 1073 hashed_owner_b32_len = (size_t) ldns_b32_ntop_extended_hex( 1074 (uint8_t *) hashed_owner_str, 1075 hashed_owner_str_len, 1076 hashed_owner_b32, 1077 ldns_b32_ntop_calculate_size(hashed_owner_str_len)+1); 1078 if (hashed_owner_b32_len < 1) { 1079 #ifdef STDERR_MSGS 1080 fprintf(stderr, "Error in base32 extended hex encoding "); 1081 fprintf(stderr, "of hashed owner name (name: "); 1082 ldns_rdf_print(stderr, name); 1083 fprintf(stderr, ", return code: %u)\n", 1084 (unsigned int) hashed_owner_b32_len); 1085 #endif 1086 LDNS_FREE(hashed_owner_b32); 1087 return NULL; 1088 } 1089 hashed_owner_b32[hashed_owner_b32_len] = '\0'; 1090 1091 status = ldns_str2rdf_dname(&hashed_owner, hashed_owner_b32); 1092 if (status != LDNS_STATUS_OK) { 1093 #ifdef STDERR_MSGS 1094 fprintf(stderr, "Error creating rdf from %s\n", hashed_owner_b32); 1095 #endif 1096 LDNS_FREE(hashed_owner_b32); 1097 return NULL; 1098 } 1099 1100 LDNS_FREE(hashed_owner_b32); 1101 return hashed_owner; 1102 } 1103 1104 void 1105 ldns_nsec3_add_param_rdfs(ldns_rr *rr, 1106 uint8_t algorithm, 1107 uint8_t flags, 1108 uint16_t iterations, 1109 uint8_t salt_length, 1110 const uint8_t *salt) 1111 { 1112 ldns_rdf *salt_rdf = NULL; 1113 uint8_t *salt_data = NULL; 1114 ldns_rdf *old; 1115 1116 old = ldns_rr_set_rdf(rr, 1117 ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, 1118 1, (void*)&algorithm), 1119 0); 1120 if (old) ldns_rdf_deep_free(old); 1121 1122 old = ldns_rr_set_rdf(rr, 1123 ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, 1124 1, (void*)&flags), 1125 1); 1126 if (old) ldns_rdf_deep_free(old); 1127 1128 old = ldns_rr_set_rdf(rr, 1129 ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, 1130 iterations), 1131 2); 1132 if (old) ldns_rdf_deep_free(old); 1133 1134 salt_data = LDNS_XMALLOC(uint8_t, salt_length + 1); 1135 if(!salt_data) { 1136 /* no way to return error */ 1137 return; 1138 } 1139 salt_data[0] = salt_length; 1140 memcpy(salt_data + 1, salt, salt_length); 1141 salt_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1142 salt_length + 1, 1143 salt_data); 1144 if(!salt_rdf) { 1145 LDNS_FREE(salt_data); 1146 /* no way to return error */ 1147 return; 1148 } 1149 1150 old = ldns_rr_set_rdf(rr, salt_rdf, 3); 1151 if (old) ldns_rdf_deep_free(old); 1152 LDNS_FREE(salt_data); 1153 } 1154 1155 static int 1156 rr_list_delegation_only(const ldns_rdf *origin, const ldns_rr_list *rr_list) 1157 { 1158 size_t i; 1159 ldns_rr *cur_rr; 1160 if (!origin || !rr_list) return 0; 1161 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { 1162 cur_rr = ldns_rr_list_rr(rr_list, i); 1163 if (ldns_dname_compare(ldns_rr_owner(cur_rr), origin) == 0) { 1164 return 0; 1165 } 1166 if (ldns_rr_get_type(cur_rr) != LDNS_RR_TYPE_NS) { 1167 return 0; 1168 } 1169 } 1170 return 1; 1171 } 1172 1173 /* this will NOT return the NSEC3 completed, you will have to run the 1174 finalize function on the rrlist later! */ 1175 ldns_rr * 1176 ldns_create_nsec3(const ldns_rdf *cur_owner, 1177 const ldns_rdf *cur_zone, 1178 const ldns_rr_list *rrs, 1179 uint8_t algorithm, 1180 uint8_t flags, 1181 uint16_t iterations, 1182 uint8_t salt_length, 1183 const uint8_t *salt, 1184 bool emptynonterminal) 1185 { 1186 size_t i; 1187 ldns_rr *i_rr; 1188 uint16_t i_type; 1189 1190 ldns_rr *nsec = NULL; 1191 ldns_rdf *hashed_owner = NULL; 1192 1193 ldns_status status; 1194 1195 ldns_rr_type i_type_list[1024]; 1196 size_t type_count = 0; 1197 1198 hashed_owner = ldns_nsec3_hash_name(cur_owner, 1199 algorithm, 1200 iterations, 1201 salt_length, 1202 salt); 1203 status = ldns_dname_cat(hashed_owner, cur_zone); 1204 if(status != LDNS_STATUS_OK) { 1205 ldns_rdf_deep_free(hashed_owner); 1206 return NULL; 1207 } 1208 nsec = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3); 1209 if(!nsec) { 1210 ldns_rdf_deep_free(hashed_owner); 1211 return NULL; 1212 } 1213 ldns_rr_set_type(nsec, LDNS_RR_TYPE_NSEC3); 1214 ldns_rr_set_owner(nsec, hashed_owner); 1215 1216 ldns_nsec3_add_param_rdfs(nsec, 1217 algorithm, 1218 flags, 1219 iterations, 1220 salt_length, 1221 salt); 1222 (void) ldns_rr_set_rdf(nsec, NULL, 4); 1223 1224 1225 for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { 1226 i_rr = ldns_rr_list_rr(rrs, i); 1227 if (ldns_rdf_compare(cur_owner, 1228 ldns_rr_owner(i_rr)) == 0) { 1229 i_type = ldns_rr_get_type(i_rr); 1230 if (type_count == 0 || i_type_list[type_count-1] != i_type) { 1231 i_type_list[type_count] = i_type; 1232 type_count++; 1233 } 1234 } 1235 } 1236 1237 /* add RRSIG anyway, but only if this is not an ENT or 1238 * an unsigned delegation */ 1239 if (!emptynonterminal && !rr_list_delegation_only(cur_zone, rrs)) { 1240 i_type_list[type_count] = LDNS_RR_TYPE_RRSIG; 1241 type_count++; 1242 } 1243 1244 /* and SOA if owner == zone */ 1245 if (ldns_dname_compare(cur_zone, cur_owner) == 0) { 1246 i_type_list[type_count] = LDNS_RR_TYPE_SOA; 1247 type_count++; 1248 } 1249 1250 ldns_rr_push_rdf(nsec, 1251 ldns_dnssec_create_nsec_bitmap(i_type_list, 1252 type_count, LDNS_RR_TYPE_NSEC3)); 1253 1254 return nsec; 1255 } 1256 1257 uint8_t 1258 ldns_nsec3_algorithm(const ldns_rr *nsec3_rr) 1259 { 1260 if (nsec3_rr && 1261 (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || 1262 ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) 1263 && (ldns_rr_rdf(nsec3_rr, 0) != NULL) 1264 && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 0)) > 0) { 1265 return ldns_rdf2native_int8(ldns_rr_rdf(nsec3_rr, 0)); 1266 } 1267 return 0; 1268 } 1269 1270 uint8_t 1271 ldns_nsec3_flags(const ldns_rr *nsec3_rr) 1272 { 1273 if (nsec3_rr && 1274 (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || 1275 ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) 1276 && (ldns_rr_rdf(nsec3_rr, 1) != NULL) 1277 && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 1)) > 0) { 1278 return ldns_rdf2native_int8(ldns_rr_rdf(nsec3_rr, 1)); 1279 } 1280 return 0; 1281 } 1282 1283 bool 1284 ldns_nsec3_optout(const ldns_rr *nsec3_rr) 1285 { 1286 return (ldns_nsec3_flags(nsec3_rr) & LDNS_NSEC3_VARS_OPTOUT_MASK); 1287 } 1288 1289 uint16_t 1290 ldns_nsec3_iterations(const ldns_rr *nsec3_rr) 1291 { 1292 if (nsec3_rr && 1293 (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || 1294 ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) 1295 && (ldns_rr_rdf(nsec3_rr, 2) != NULL) 1296 && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 2)) > 0) { 1297 return ldns_rdf2native_int16(ldns_rr_rdf(nsec3_rr, 2)); 1298 } 1299 return 0; 1300 1301 } 1302 1303 ldns_rdf * 1304 ldns_nsec3_salt(const ldns_rr *nsec3_rr) 1305 { 1306 if (nsec3_rr && 1307 (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || 1308 ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) 1309 ) { 1310 return ldns_rr_rdf(nsec3_rr, 3); 1311 } 1312 return NULL; 1313 } 1314 1315 uint8_t 1316 ldns_nsec3_salt_length(const ldns_rr *nsec3_rr) 1317 { 1318 ldns_rdf *salt_rdf = ldns_nsec3_salt(nsec3_rr); 1319 if (salt_rdf && ldns_rdf_size(salt_rdf) > 0) { 1320 return (uint8_t) ldns_rdf_data(salt_rdf)[0]; 1321 } 1322 return 0; 1323 } 1324 1325 /* allocs data, free with LDNS_FREE() */ 1326 uint8_t * 1327 ldns_nsec3_salt_data(const ldns_rr *nsec3_rr) 1328 { 1329 uint8_t salt_length; 1330 uint8_t *salt; 1331 1332 ldns_rdf *salt_rdf = ldns_nsec3_salt(nsec3_rr); 1333 if (salt_rdf && ldns_rdf_size(salt_rdf) > 0) { 1334 salt_length = ldns_rdf_data(salt_rdf)[0]; 1335 salt = LDNS_XMALLOC(uint8_t, salt_length); 1336 if(!salt) return NULL; 1337 memcpy(salt, &ldns_rdf_data(salt_rdf)[1], salt_length); 1338 return salt; 1339 } 1340 return NULL; 1341 } 1342 1343 ldns_rdf * 1344 ldns_nsec3_next_owner(const ldns_rr *nsec3_rr) 1345 { 1346 if (!nsec3_rr || ldns_rr_get_type(nsec3_rr) != LDNS_RR_TYPE_NSEC3) { 1347 return NULL; 1348 } else { 1349 return ldns_rr_rdf(nsec3_rr, 4); 1350 } 1351 } 1352 1353 ldns_rdf * 1354 ldns_nsec3_bitmap(const ldns_rr *nsec3_rr) 1355 { 1356 if (!nsec3_rr || ldns_rr_get_type(nsec3_rr) != LDNS_RR_TYPE_NSEC3) { 1357 return NULL; 1358 } else { 1359 return ldns_rr_rdf(nsec3_rr, 5); 1360 } 1361 } 1362 1363 ldns_rdf * 1364 ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, const ldns_rdf *name) 1365 { 1366 uint8_t algorithm; 1367 uint16_t iterations; 1368 uint8_t salt_length; 1369 uint8_t *salt = 0; 1370 1371 ldns_rdf *hashed_owner; 1372 1373 algorithm = ldns_nsec3_algorithm(nsec); 1374 salt_length = ldns_nsec3_salt_length(nsec); 1375 salt = ldns_nsec3_salt_data(nsec); 1376 iterations = ldns_nsec3_iterations(nsec); 1377 1378 hashed_owner = ldns_nsec3_hash_name(name, 1379 algorithm, 1380 iterations, 1381 salt_length, 1382 salt); 1383 1384 LDNS_FREE(salt); 1385 return hashed_owner; 1386 } 1387 1388 bool 1389 ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type) 1390 { 1391 uint8_t* dptr; 1392 uint8_t* dend; 1393 1394 /* From RFC3845 Section 2.1.2: 1395 * 1396 * "The RR type space is split into 256 window blocks, each re- 1397 * presenting the low-order 8 bits of the 16-bit RR type space." 1398 */ 1399 uint8_t window = type >> 8; 1400 uint8_t subtype = type & 0xff; 1401 1402 if (! bitmap) { 1403 return false; 1404 } 1405 assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); 1406 1407 dptr = ldns_rdf_data(bitmap); 1408 dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); 1409 1410 /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + 1411 * dptr[0] dptr[1] dptr[2:] 1412 */ 1413 while (dptr < dend && dptr[0] <= window) { 1414 1415 if (dptr[0] == window && subtype / 8 < dptr[1] && 1416 dptr + dptr[1] + 2 <= dend) { 1417 1418 return dptr[2 + subtype / 8] & (0x80 >> (subtype % 8)); 1419 } 1420 dptr += dptr[1] + 2; /* next window */ 1421 } 1422 return false; 1423 } 1424 1425 ldns_status 1426 ldns_nsec_bitmap_set_type(ldns_rdf* bitmap, ldns_rr_type type) 1427 { 1428 uint8_t* dptr; 1429 uint8_t* dend; 1430 1431 /* From RFC3845 Section 2.1.2: 1432 * 1433 * "The RR type space is split into 256 window blocks, each re- 1434 * presenting the low-order 8 bits of the 16-bit RR type space." 1435 */ 1436 uint8_t window = type >> 8; 1437 uint8_t subtype = type & 0xff; 1438 1439 if (! bitmap) { 1440 return false; 1441 } 1442 assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); 1443 1444 dptr = ldns_rdf_data(bitmap); 1445 dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); 1446 1447 /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + 1448 * dptr[0] dptr[1] dptr[2:] 1449 */ 1450 while (dptr < dend && dptr[0] <= window) { 1451 1452 if (dptr[0] == window && subtype / 8 < dptr[1] && 1453 dptr + dptr[1] + 2 <= dend) { 1454 1455 dptr[2 + subtype / 8] |= (0x80 >> (subtype % 8)); 1456 return LDNS_STATUS_OK; 1457 } 1458 dptr += dptr[1] + 2; /* next window */ 1459 } 1460 return LDNS_STATUS_TYPE_NOT_IN_BITMAP; 1461 } 1462 1463 ldns_status 1464 ldns_nsec_bitmap_clear_type(ldns_rdf* bitmap, ldns_rr_type type) 1465 { 1466 uint8_t* dptr; 1467 uint8_t* dend; 1468 1469 /* From RFC3845 Section 2.1.2: 1470 * 1471 * "The RR type space is split into 256 window blocks, each re- 1472 * presenting the low-order 8 bits of the 16-bit RR type space." 1473 */ 1474 uint8_t window = type >> 8; 1475 uint8_t subtype = type & 0xff; 1476 1477 if (! bitmap) { 1478 return false; 1479 } 1480 1481 assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); 1482 1483 dptr = ldns_rdf_data(bitmap); 1484 dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); 1485 1486 /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + 1487 * dptr[0] dptr[1] dptr[2:] 1488 */ 1489 while (dptr < dend && dptr[0] <= window) { 1490 1491 if (dptr[0] == window && subtype / 8 < dptr[1] && 1492 dptr + dptr[1] + 2 <= dend) { 1493 1494 dptr[2 + subtype / 8] &= ~(0x80 >> (subtype % 8)); 1495 return LDNS_STATUS_OK; 1496 } 1497 dptr += dptr[1] + 2; /* next window */ 1498 } 1499 return LDNS_STATUS_TYPE_NOT_IN_BITMAP; 1500 } 1501 1502 1503 bool 1504 ldns_nsec_covers_name(const ldns_rr *nsec, const ldns_rdf *name) 1505 { 1506 ldns_rdf *nsec_owner = ldns_rr_owner(nsec); 1507 ldns_rdf *hash_next; 1508 char *next_hash_str; 1509 ldns_rdf *nsec_next = NULL; 1510 ldns_status status; 1511 ldns_rdf *chopped_dname; 1512 bool result; 1513 1514 if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC) { 1515 if (ldns_rr_rdf(nsec, 0) != NULL) { 1516 nsec_next = ldns_rdf_clone(ldns_rr_rdf(nsec, 0)); 1517 } else { 1518 return false; 1519 } 1520 } else if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC3) { 1521 hash_next = ldns_nsec3_next_owner(nsec); 1522 next_hash_str = ldns_rdf2str(hash_next); 1523 nsec_next = ldns_dname_new_frm_str(next_hash_str); 1524 LDNS_FREE(next_hash_str); 1525 chopped_dname = ldns_dname_left_chop(nsec_owner); 1526 status = ldns_dname_cat(nsec_next, chopped_dname); 1527 ldns_rdf_deep_free(chopped_dname); 1528 if (status != LDNS_STATUS_OK) { 1529 printf("error catting: %s\n", ldns_get_errorstr_by_id(status)); 1530 } 1531 } else { 1532 ldns_rdf_deep_free(nsec_next); 1533 return false; 1534 } 1535 1536 /* in the case of the last nsec */ 1537 if(ldns_dname_compare(nsec_owner, nsec_next) > 0) { 1538 result = (ldns_dname_compare(nsec_owner, name) <= 0 || 1539 ldns_dname_compare(name, nsec_next) < 0); 1540 } else if(ldns_dname_compare(nsec_owner, nsec_next) < 0) { 1541 result = (ldns_dname_compare(nsec_owner, name) <= 0 && 1542 ldns_dname_compare(name, nsec_next) < 0); 1543 } else { 1544 result = true; 1545 } 1546 1547 ldns_rdf_deep_free(nsec_next); 1548 return result; 1549 } 1550 1551 #ifdef HAVE_SSL 1552 /* sig may be null - if so look in the packet */ 1553 1554 ldns_status 1555 ldns_pkt_verify_time(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o, 1556 const ldns_rr_list *k, const ldns_rr_list *s, 1557 time_t check_time, ldns_rr_list *good_keys) 1558 { 1559 ldns_rr_list *rrset; 1560 ldns_rr_list *sigs; 1561 ldns_rr_list *sigs_covered; 1562 ldns_rdf *rdf_t; 1563 ldns_rr_type t_netorder; 1564 ldns_status status; 1565 1566 if (!k) { 1567 return LDNS_STATUS_ERR; 1568 /* return LDNS_STATUS_CRYPTO_NO_DNSKEY; */ 1569 } 1570 1571 if (t == LDNS_RR_TYPE_RRSIG) { 1572 /* we don't have RRSIG(RRSIG) (yet? ;-) ) */ 1573 return LDNS_STATUS_ERR; 1574 } 1575 1576 if (s) { 1577 /* if s is not NULL, the sigs are given to use */ 1578 sigs = (ldns_rr_list *)s; 1579 } else { 1580 /* otherwise get them from the packet */ 1581 sigs = ldns_pkt_rr_list_by_name_and_type(p, o, 1582 LDNS_RR_TYPE_RRSIG, 1583 LDNS_SECTION_ANY_NOQUESTION); 1584 if (!sigs) { 1585 /* no sigs */ 1586 return LDNS_STATUS_ERR; 1587 /* return LDNS_STATUS_CRYPTO_NO_RRSIG; */ 1588 } 1589 } 1590 1591 /* rrsig are subtyped, so now we need to find the correct 1592 * sigs for the type t 1593 */ 1594 t_netorder = htons(t); /* rdf are in network order! */ 1595 /* a type identifier is a 16-bit number, so the size is 2 bytes */ 1596 rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, 2, &t_netorder); 1597 1598 sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); 1599 ldns_rdf_free(rdf_t); 1600 if (! sigs_covered) { 1601 if (! s) { 1602 ldns_rr_list_deep_free(sigs); 1603 } 1604 return LDNS_STATUS_ERR; 1605 } 1606 ldns_rr_list_deep_free(sigs_covered); 1607 1608 rrset = ldns_pkt_rr_list_by_name_and_type(p, o, t, 1609 LDNS_SECTION_ANY_NOQUESTION); 1610 if (!rrset) { 1611 if (! s) { 1612 ldns_rr_list_deep_free(sigs); 1613 } 1614 return LDNS_STATUS_ERR; 1615 } 1616 status = ldns_verify_time(rrset, sigs, k, check_time, good_keys); 1617 ldns_rr_list_deep_free(rrset); 1618 return status; 1619 } 1620 1621 ldns_status 1622 ldns_pkt_verify(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o, 1623 const ldns_rr_list *k, const ldns_rr_list *s, ldns_rr_list *good_keys) 1624 { 1625 return ldns_pkt_verify_time(p, t, o, k, s, ldns_time(NULL), good_keys); 1626 } 1627 #endif /* HAVE_SSL */ 1628 1629 ldns_status 1630 ldns_dnssec_chain_nsec3_list(ldns_rr_list *nsec3_rrs) 1631 { 1632 size_t i; 1633 char *next_nsec_owner_str; 1634 ldns_rdf *next_nsec_owner_label; 1635 ldns_rdf *next_nsec_rdf; 1636 ldns_status status = LDNS_STATUS_OK; 1637 1638 for (i = 0; i < ldns_rr_list_rr_count(nsec3_rrs); i++) { 1639 if (i == ldns_rr_list_rr_count(nsec3_rrs) - 1) { 1640 next_nsec_owner_label = 1641 ldns_dname_label(ldns_rr_owner(ldns_rr_list_rr(nsec3_rrs, 1642 0)), 0); 1643 next_nsec_owner_str = ldns_rdf2str(next_nsec_owner_label); 1644 if (next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] 1645 == '.') { 1646 next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] 1647 = '\0'; 1648 } 1649 status = ldns_str2rdf_b32_ext(&next_nsec_rdf, 1650 next_nsec_owner_str); 1651 if (!ldns_rr_set_rdf(ldns_rr_list_rr(nsec3_rrs, i), 1652 next_nsec_rdf, 4)) { 1653 /* todo: error */ 1654 } 1655 1656 ldns_rdf_deep_free(next_nsec_owner_label); 1657 LDNS_FREE(next_nsec_owner_str); 1658 } else { 1659 next_nsec_owner_label = 1660 ldns_dname_label(ldns_rr_owner(ldns_rr_list_rr(nsec3_rrs, 1661 i + 1)), 1662 0); 1663 next_nsec_owner_str = ldns_rdf2str(next_nsec_owner_label); 1664 if (next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] 1665 == '.') { 1666 next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] 1667 = '\0'; 1668 } 1669 status = ldns_str2rdf_b32_ext(&next_nsec_rdf, 1670 next_nsec_owner_str); 1671 ldns_rdf_deep_free(next_nsec_owner_label); 1672 LDNS_FREE(next_nsec_owner_str); 1673 if (!ldns_rr_set_rdf(ldns_rr_list_rr(nsec3_rrs, i), 1674 next_nsec_rdf, 4)) { 1675 /* todo: error */ 1676 } 1677 } 1678 } 1679 return status; 1680 } 1681 1682 int 1683 qsort_rr_compare_nsec3(const void *a, const void *b) 1684 { 1685 const ldns_rr *rr1 = * (const ldns_rr **) a; 1686 const ldns_rr *rr2 = * (const ldns_rr **) b; 1687 if (rr1 == NULL && rr2 == NULL) { 1688 return 0; 1689 } 1690 if (rr1 == NULL) { 1691 return -1; 1692 } 1693 if (rr2 == NULL) { 1694 return 1; 1695 } 1696 return ldns_rdf_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)); 1697 } 1698 1699 void 1700 ldns_rr_list_sort_nsec3(ldns_rr_list *unsorted) 1701 { 1702 qsort(unsorted->_rrs, 1703 ldns_rr_list_rr_count(unsorted), 1704 sizeof(ldns_rr *), 1705 qsort_rr_compare_nsec3); 1706 } 1707 1708 int 1709 ldns_dnssec_default_add_to_signatures( ATTR_UNUSED(ldns_rr *sig) 1710 , ATTR_UNUSED(void *n) 1711 ) 1712 { 1713 return LDNS_SIGNATURE_LEAVE_ADD_NEW; 1714 } 1715 1716 int 1717 ldns_dnssec_default_leave_signatures( ATTR_UNUSED(ldns_rr *sig) 1718 , ATTR_UNUSED(void *n) 1719 ) 1720 { 1721 return LDNS_SIGNATURE_LEAVE_NO_ADD; 1722 } 1723 1724 int 1725 ldns_dnssec_default_delete_signatures( ATTR_UNUSED(ldns_rr *sig) 1726 , ATTR_UNUSED(void *n) 1727 ) 1728 { 1729 return LDNS_SIGNATURE_REMOVE_NO_ADD; 1730 } 1731 1732 int 1733 ldns_dnssec_default_replace_signatures( ATTR_UNUSED(ldns_rr *sig) 1734 , ATTR_UNUSED(void *n) 1735 ) 1736 { 1737 return LDNS_SIGNATURE_REMOVE_ADD_NEW; 1738 } 1739 1740 #ifdef HAVE_SSL 1741 ldns_rdf * 1742 ldns_convert_dsa_rrsig_asn12rdf(const ldns_buffer *sig, 1743 const long sig_len) 1744 { 1745 #ifdef USE_DSA 1746 ldns_rdf *sigdata_rdf; 1747 DSA_SIG *dsasig; 1748 const BIGNUM *R, *S; 1749 unsigned char *dsasig_data = (unsigned char*)ldns_buffer_begin(sig); 1750 size_t byte_offset; 1751 1752 dsasig = d2i_DSA_SIG(NULL, 1753 (const unsigned char **)&dsasig_data, 1754 sig_len); 1755 if (!dsasig) { 1756 DSA_SIG_free(dsasig); 1757 return NULL; 1758 } 1759 1760 dsasig_data = LDNS_XMALLOC(unsigned char, 41); 1761 if(!dsasig_data) { 1762 DSA_SIG_free(dsasig); 1763 return NULL; 1764 } 1765 dsasig_data[0] = 0; 1766 # ifdef HAVE_DSA_SIG_GET0 1767 DSA_SIG_get0(dsasig, &R, &S); 1768 # else 1769 R = dsasig->r; 1770 S = dsasig->s; 1771 # endif 1772 byte_offset = (size_t) (20 - BN_num_bytes(R)); 1773 if (byte_offset > 20) { 1774 DSA_SIG_free(dsasig); 1775 LDNS_FREE(dsasig_data); 1776 return NULL; 1777 } 1778 memset(&dsasig_data[1], 0, byte_offset); 1779 BN_bn2bin(R, &dsasig_data[1 + byte_offset]); 1780 byte_offset = (size_t) (20 - BN_num_bytes(S)); 1781 if (byte_offset > 20) { 1782 DSA_SIG_free(dsasig); 1783 LDNS_FREE(dsasig_data); 1784 return NULL; 1785 } 1786 memset(&dsasig_data[21], 0, byte_offset); 1787 BN_bn2bin(S, &dsasig_data[21 + byte_offset]); 1788 1789 sigdata_rdf = ldns_rdf_new(LDNS_RDF_TYPE_B64, 41, dsasig_data); 1790 if(!sigdata_rdf) { 1791 LDNS_FREE(dsasig_data); 1792 } 1793 DSA_SIG_free(dsasig); 1794 1795 return sigdata_rdf; 1796 #else 1797 (void)sig; (void)sig_len; 1798 return NULL; 1799 #endif 1800 } 1801 1802 ldns_status 1803 ldns_convert_dsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, 1804 const ldns_rdf *sig_rdf) 1805 { 1806 #ifdef USE_DSA 1807 /* the EVP api wants the DER encoding of the signature... */ 1808 BIGNUM *R, *S; 1809 DSA_SIG *dsasig; 1810 unsigned char *raw_sig = NULL; 1811 int raw_sig_len; 1812 1813 if(ldns_rdf_size(sig_rdf) < 1 + 2*SHA_DIGEST_LENGTH) 1814 return LDNS_STATUS_SYNTAX_RDATA_ERR; 1815 /* extract the R and S field from the sig buffer */ 1816 R = BN_new(); 1817 if(!R) return LDNS_STATUS_MEM_ERR; 1818 (void) BN_bin2bn((unsigned char *) ldns_rdf_data(sig_rdf) + 1, 1819 SHA_DIGEST_LENGTH, R); 1820 S = BN_new(); 1821 if(!S) { 1822 BN_free(R); 1823 return LDNS_STATUS_MEM_ERR; 1824 } 1825 (void) BN_bin2bn((unsigned char *) ldns_rdf_data(sig_rdf) + 21, 1826 SHA_DIGEST_LENGTH, S); 1827 1828 dsasig = DSA_SIG_new(); 1829 if (!dsasig) { 1830 BN_free(R); 1831 BN_free(S); 1832 return LDNS_STATUS_MEM_ERR; 1833 } 1834 # ifdef HAVE_DSA_SIG_SET0 1835 if (! DSA_SIG_set0(dsasig, R, S)) 1836 return LDNS_STATUS_SSL_ERR; 1837 # else 1838 dsasig->r = R; 1839 dsasig->s = S; 1840 # endif 1841 1842 raw_sig_len = i2d_DSA_SIG(dsasig, &raw_sig); 1843 if (raw_sig_len < 0) { 1844 DSA_SIG_free(dsasig); 1845 free(raw_sig); 1846 return LDNS_STATUS_SSL_ERR; 1847 } 1848 if (ldns_buffer_reserve(target_buffer, (size_t) raw_sig_len)) { 1849 ldns_buffer_write(target_buffer, raw_sig, (size_t)raw_sig_len); 1850 } 1851 1852 DSA_SIG_free(dsasig); 1853 free(raw_sig); 1854 1855 return ldns_buffer_status(target_buffer); 1856 #else 1857 (void)target_buffer; (void)sig_rdf; 1858 return LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL; 1859 #endif 1860 } 1861 1862 #ifdef USE_ECDSA 1863 #ifndef S_SPLINT_S 1864 ldns_rdf * 1865 ldns_convert_ecdsa_rrsig_asn1len2rdf(const ldns_buffer *sig, 1866 const long sig_len, int num_bytes) 1867 { 1868 ECDSA_SIG* ecdsa_sig; 1869 const BIGNUM *r, *s; 1870 unsigned char *data = (unsigned char*)ldns_buffer_begin(sig); 1871 ldns_rdf* rdf; 1872 ecdsa_sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&data, sig_len); 1873 if(!ecdsa_sig) return NULL; 1874 1875 #ifdef HAVE_ECDSA_SIG_GET0 1876 ECDSA_SIG_get0(ecdsa_sig, &r, &s); 1877 #else 1878 r = ecdsa_sig->r; 1879 s = ecdsa_sig->s; 1880 #endif 1881 /* "r | s". */ 1882 if(BN_num_bytes(r) > num_bytes || 1883 BN_num_bytes(s) > num_bytes) { 1884 ECDSA_SIG_free(ecdsa_sig); 1885 return NULL; /* numbers too big for passed curve size */ 1886 } 1887 data = LDNS_XMALLOC(unsigned char, num_bytes*2); 1888 if(!data) { 1889 ECDSA_SIG_free(ecdsa_sig); 1890 return NULL; 1891 } 1892 /* write the bignums (in big-endian) a little offset if the BN code 1893 * wants to write a shorter number of bytes, with zeroes prefixed */ 1894 memset(data, 0, num_bytes*2); 1895 BN_bn2bin(r, data+num_bytes-BN_num_bytes(r)); 1896 BN_bn2bin(s, data+num_bytes*2-BN_num_bytes(s)); 1897 rdf = ldns_rdf_new(LDNS_RDF_TYPE_B64, (size_t)(num_bytes*2), data); 1898 ECDSA_SIG_free(ecdsa_sig); 1899 return rdf; 1900 } 1901 1902 ldns_status 1903 ldns_convert_ecdsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, 1904 const ldns_rdf *sig_rdf) 1905 { 1906 /* convert from two BIGNUMs in the rdata buffer, to ASN notation. 1907 * ASN preable: 30440220 <R 32bytefor256> 0220 <S 32bytefor256> 1908 * the '20' is the length of that field (=bnsize). 1909 * the '44' is the total remaining length. 1910 * if negative, start with leading zero. 1911 * if starts with 00s, remove them from the number. 1912 */ 1913 uint8_t pre[] = {0x30, 0x44, 0x02, 0x20}; 1914 int pre_len = 4; 1915 uint8_t mid[] = {0x02, 0x20}; 1916 int mid_len = 2; 1917 int raw_sig_len, r_high, s_high, r_rem=0, s_rem=0; 1918 long bnsize = (long)ldns_rdf_size(sig_rdf) / 2; 1919 uint8_t* d = ldns_rdf_data(sig_rdf); 1920 /* if too short, or not even length, do not bother */ 1921 if(bnsize < 16 || (size_t)bnsize*2 != ldns_rdf_size(sig_rdf)) 1922 return LDNS_STATUS_ERR; 1923 /* strip leading zeroes from r (but not last one) */ 1924 while(r_rem < bnsize-1 && d[r_rem] == 0) 1925 r_rem++; 1926 /* strip leading zeroes from s (but not last one) */ 1927 while(s_rem < bnsize-1 && d[bnsize+s_rem] == 0) 1928 s_rem++; 1929 1930 r_high = ((d[0+r_rem]&0x80)?1:0); 1931 s_high = ((d[bnsize+s_rem]&0x80)?1:0); 1932 raw_sig_len = pre_len + r_high + bnsize - r_rem + mid_len + 1933 s_high + bnsize - s_rem; 1934 if(ldns_buffer_reserve(target_buffer, (size_t) raw_sig_len)) { 1935 ldns_buffer_write_u8(target_buffer, pre[0]); 1936 ldns_buffer_write_u8(target_buffer, raw_sig_len-2); 1937 ldns_buffer_write_u8(target_buffer, pre[2]); 1938 ldns_buffer_write_u8(target_buffer, bnsize + r_high - r_rem); 1939 if(r_high) 1940 ldns_buffer_write_u8(target_buffer, 0); 1941 ldns_buffer_write(target_buffer, d+r_rem, bnsize-r_rem); 1942 ldns_buffer_write(target_buffer, mid, mid_len-1); 1943 ldns_buffer_write_u8(target_buffer, bnsize + s_high - s_rem); 1944 if(s_high) 1945 ldns_buffer_write_u8(target_buffer, 0); 1946 ldns_buffer_write(target_buffer, d+bnsize+s_rem, bnsize-s_rem); 1947 } 1948 return ldns_buffer_status(target_buffer); 1949 } 1950 1951 #endif /* S_SPLINT_S */ 1952 #endif /* USE_ECDSA */ 1953 #endif /* HAVE_SSL */ 1954