1 /* 2 * validator/val_sigcrypt.c - validator signature crypto functions. 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 /** 37 * \file 38 * 39 * This file contains helper functions for the validator module. 40 * The functions help with signature verification and checking, the 41 * bridging between RR wireformat data and crypto calls. 42 */ 43 #include "config.h" 44 #include "validator/val_sigcrypt.h" 45 #include "validator/val_secalgo.h" 46 #include "validator/validator.h" 47 #include "util/data/msgreply.h" 48 #include "util/data/msgparse.h" 49 #include "util/data/dname.h" 50 #include "util/rbtree.h" 51 #include "util/rfc_1982.h" 52 #include "util/module.h" 53 #include "util/net_help.h" 54 #include "util/regional.h" 55 #include "util/config_file.h" 56 #include "sldns/keyraw.h" 57 #include "sldns/sbuffer.h" 58 #include "sldns/parseutil.h" 59 #include "sldns/wire2str.h" 60 #include "services/mesh.h" 61 62 #include <ctype.h> 63 #if !defined(HAVE_SSL) && !defined(HAVE_NSS) && !defined(HAVE_NETTLE) 64 #error "Need crypto library to do digital signature cryptography" 65 #endif 66 67 #ifdef HAVE_OPENSSL_ERR_H 68 #include <openssl/err.h> 69 #endif 70 71 #ifdef HAVE_OPENSSL_RAND_H 72 #include <openssl/rand.h> 73 #endif 74 75 #ifdef HAVE_OPENSSL_CONF_H 76 #include <openssl/conf.h> 77 #endif 78 79 #ifdef HAVE_OPENSSL_ENGINE_H 80 #include <openssl/engine.h> 81 #endif 82 83 /** Maximum number of RRSIG validations for an RRset. */ 84 #define MAX_VALIDATE_RRSIGS 8 85 /** Maximum number of NSEC validations for a message. */ 86 #define MAX_VALIDATE_NSECS 8 87 88 /** return number of rrs in an rrset */ 89 static size_t 90 rrset_get_count(struct ub_packed_rrset_key* rrset) 91 { 92 struct packed_rrset_data* d = (struct packed_rrset_data*) 93 rrset->entry.data; 94 if(!d) return 0; 95 return d->count; 96 } 97 98 /** 99 * Get RR signature count 100 */ 101 static size_t 102 rrset_get_sigcount(struct ub_packed_rrset_key* k) 103 { 104 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 105 return d->rrsig_count; 106 } 107 108 /** 109 * Get signature keytag value 110 * @param k: rrset (with signatures) 111 * @param sig_idx: signature index. 112 * @return keytag or 0 if malformed rrsig. 113 */ 114 static uint16_t 115 rrset_get_sig_keytag(struct ub_packed_rrset_key* k, size_t sig_idx) 116 { 117 uint16_t t; 118 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 119 log_assert(sig_idx < d->rrsig_count); 120 if(d->rr_len[d->count + sig_idx] < 2+18) 121 return 0; 122 memmove(&t, d->rr_data[d->count + sig_idx]+2+16, 2); 123 return ntohs(t); 124 } 125 126 /** 127 * Get signature signing algorithm value 128 * @param k: rrset (with signatures) 129 * @param sig_idx: signature index. 130 * @return algo or 0 if malformed rrsig. 131 */ 132 static int 133 rrset_get_sig_algo(struct ub_packed_rrset_key* k, size_t sig_idx) 134 { 135 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 136 log_assert(sig_idx < d->rrsig_count); 137 if(d->rr_len[d->count + sig_idx] < 2+3) 138 return 0; 139 return (int)d->rr_data[d->count + sig_idx][2+2]; 140 } 141 142 /** get rdata pointer and size */ 143 static void 144 rrset_get_rdata(struct ub_packed_rrset_key* k, size_t idx, uint8_t** rdata, 145 size_t* len) 146 { 147 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 148 log_assert(d && idx < (d->count + d->rrsig_count)); 149 *rdata = d->rr_data[idx]; 150 *len = d->rr_len[idx]; 151 } 152 153 uint16_t 154 dnskey_get_flags(struct ub_packed_rrset_key* k, size_t idx) 155 { 156 uint8_t* rdata; 157 size_t len; 158 uint16_t f; 159 rrset_get_rdata(k, idx, &rdata, &len); 160 if(len < 2+2) 161 return 0; 162 memmove(&f, rdata+2, 2); 163 f = ntohs(f); 164 return f; 165 } 166 167 /** 168 * Get DNSKEY protocol value from rdata 169 * @param k: DNSKEY rrset. 170 * @param idx: which key. 171 * @return protocol octet value 172 */ 173 static int 174 dnskey_get_protocol(struct ub_packed_rrset_key* k, size_t idx) 175 { 176 uint8_t* rdata; 177 size_t len; 178 rrset_get_rdata(k, idx, &rdata, &len); 179 if(len < 2+4) 180 return 0; 181 return (int)rdata[2+2]; 182 } 183 184 int 185 dnskey_get_algo(struct ub_packed_rrset_key* k, size_t idx) 186 { 187 uint8_t* rdata; 188 size_t len; 189 rrset_get_rdata(k, idx, &rdata, &len); 190 if(len < 2+4) 191 return 0; 192 return (int)rdata[2+3]; 193 } 194 195 /** get public key rdata field from a dnskey RR and do some checks */ 196 static void 197 dnskey_get_pubkey(struct ub_packed_rrset_key* k, size_t idx, 198 unsigned char** pk, unsigned int* pklen) 199 { 200 uint8_t* rdata; 201 size_t len; 202 rrset_get_rdata(k, idx, &rdata, &len); 203 if(len < 2+5) { 204 *pk = NULL; 205 *pklen = 0; 206 return; 207 } 208 *pk = (unsigned char*)rdata+2+4; 209 *pklen = (unsigned)len-2-4; 210 } 211 212 int 213 ds_get_key_algo(struct ub_packed_rrset_key* k, size_t idx) 214 { 215 uint8_t* rdata; 216 size_t len; 217 rrset_get_rdata(k, idx, &rdata, &len); 218 if(len < 2+3) 219 return 0; 220 return (int)rdata[2+2]; 221 } 222 223 int 224 ds_get_digest_algo(struct ub_packed_rrset_key* k, size_t idx) 225 { 226 uint8_t* rdata; 227 size_t len; 228 rrset_get_rdata(k, idx, &rdata, &len); 229 if(len < 2+4) 230 return 0; 231 return (int)rdata[2+3]; 232 } 233 234 uint16_t 235 ds_get_keytag(struct ub_packed_rrset_key* ds_rrset, size_t ds_idx) 236 { 237 uint16_t t; 238 uint8_t* rdata; 239 size_t len; 240 rrset_get_rdata(ds_rrset, ds_idx, &rdata, &len); 241 if(len < 2+2) 242 return 0; 243 memmove(&t, rdata+2, 2); 244 return ntohs(t); 245 } 246 247 /** 248 * Return pointer to the digest in a DS RR. 249 * @param k: DS rrset. 250 * @param idx: which DS. 251 * @param digest: digest data is returned. 252 * on error, this is NULL. 253 * @param len: length of digest is returned. 254 * on error, the length is 0. 255 */ 256 static void 257 ds_get_sigdata(struct ub_packed_rrset_key* k, size_t idx, uint8_t** digest, 258 size_t* len) 259 { 260 uint8_t* rdata; 261 size_t rdlen; 262 rrset_get_rdata(k, idx, &rdata, &rdlen); 263 if(rdlen < 2+5) { 264 *digest = NULL; 265 *len = 0; 266 return; 267 } 268 *digest = rdata + 2 + 4; 269 *len = rdlen - 2 - 4; 270 } 271 272 /** 273 * Return size of DS digest according to its hash algorithm. 274 * @param k: DS rrset. 275 * @param idx: which DS. 276 * @return size in bytes of digest, or 0 if not supported. 277 */ 278 static size_t 279 ds_digest_size_algo(struct ub_packed_rrset_key* k, size_t idx) 280 { 281 return ds_digest_size_supported(ds_get_digest_algo(k, idx)); 282 } 283 284 /** 285 * Create a DS digest for a DNSKEY entry. 286 * 287 * @param env: module environment. Uses scratch space. 288 * @param dnskey_rrset: DNSKEY rrset. 289 * @param dnskey_idx: index of RR in rrset. 290 * @param ds_rrset: DS rrset 291 * @param ds_idx: index of RR in DS rrset. 292 * @param digest: digest is returned in here (must be correctly sized). 293 * @return false on error. 294 */ 295 static int 296 ds_create_dnskey_digest(struct module_env* env, 297 struct ub_packed_rrset_key* dnskey_rrset, size_t dnskey_idx, 298 struct ub_packed_rrset_key* ds_rrset, size_t ds_idx, 299 uint8_t* digest) 300 { 301 sldns_buffer* b = env->scratch_buffer; 302 uint8_t* dnskey_rdata; 303 size_t dnskey_len; 304 rrset_get_rdata(dnskey_rrset, dnskey_idx, &dnskey_rdata, &dnskey_len); 305 306 /* create digest source material in buffer 307 * digest = digest_algorithm( DNSKEY owner name | DNSKEY RDATA); 308 * DNSKEY RDATA = Flags | Protocol | Algorithm | Public Key. */ 309 sldns_buffer_clear(b); 310 if(!sldns_buffer_available(b, dnskey_rrset->rk.dname_len + dnskey_len-2)) 311 return 0; /* buffer too small */ 312 sldns_buffer_write(b, dnskey_rrset->rk.dname, 313 dnskey_rrset->rk.dname_len); 314 query_dname_tolower(sldns_buffer_begin(b)); 315 sldns_buffer_write(b, dnskey_rdata+2, dnskey_len-2); /* skip rdatalen*/ 316 sldns_buffer_flip(b); 317 318 return secalgo_ds_digest(ds_get_digest_algo(ds_rrset, ds_idx), 319 (unsigned char*)sldns_buffer_begin(b), sldns_buffer_limit(b), 320 (unsigned char*)digest); 321 } 322 323 int ds_digest_match_dnskey(struct module_env* env, 324 struct ub_packed_rrset_key* dnskey_rrset, size_t dnskey_idx, 325 struct ub_packed_rrset_key* ds_rrset, size_t ds_idx) 326 { 327 uint8_t* ds; /* DS digest */ 328 size_t dslen; 329 uint8_t* digest; /* generated digest */ 330 size_t digestlen = ds_digest_size_algo(ds_rrset, ds_idx); 331 332 if(digestlen == 0) { 333 verbose(VERB_QUERY, "DS fail: not supported, or DS RR " 334 "format error"); 335 return 0; /* not supported, or DS RR format error */ 336 } 337 #ifndef USE_SHA1 338 if(fake_sha1 && ds_get_digest_algo(ds_rrset, ds_idx)==LDNS_SHA1) 339 return 1; 340 #endif 341 342 /* check digest length in DS with length from hash function */ 343 ds_get_sigdata(ds_rrset, ds_idx, &ds, &dslen); 344 if(!ds || dslen != digestlen) { 345 verbose(VERB_QUERY, "DS fail: DS RR algo and digest do not " 346 "match each other"); 347 return 0; /* DS algorithm and digest do not match */ 348 } 349 350 digest = regional_alloc(env->scratch, digestlen); 351 if(!digest) { 352 verbose(VERB_QUERY, "DS fail: out of memory"); 353 return 0; /* mem error */ 354 } 355 if(!ds_create_dnskey_digest(env, dnskey_rrset, dnskey_idx, ds_rrset, 356 ds_idx, digest)) { 357 verbose(VERB_QUERY, "DS fail: could not calc key digest"); 358 return 0; /* digest algo failed */ 359 } 360 if(memcmp(digest, ds, dslen) != 0) { 361 verbose(VERB_QUERY, "DS fail: digest is different"); 362 return 0; /* digest different */ 363 } 364 return 1; 365 } 366 367 int 368 ds_digest_algo_is_supported(struct ub_packed_rrset_key* ds_rrset, 369 size_t ds_idx) 370 { 371 return (ds_digest_size_algo(ds_rrset, ds_idx) != 0); 372 } 373 374 int 375 ds_key_algo_is_supported(struct ub_packed_rrset_key* ds_rrset, 376 size_t ds_idx) 377 { 378 return dnskey_algo_id_is_supported(ds_get_key_algo(ds_rrset, ds_idx)); 379 } 380 381 uint16_t 382 dnskey_calc_keytag(struct ub_packed_rrset_key* dnskey_rrset, size_t dnskey_idx) 383 { 384 uint8_t* data; 385 size_t len; 386 rrset_get_rdata(dnskey_rrset, dnskey_idx, &data, &len); 387 /* do not pass rdatalen to ldns */ 388 return sldns_calc_keytag_raw(data+2, len-2); 389 } 390 391 int dnskey_algo_is_supported(struct ub_packed_rrset_key* dnskey_rrset, 392 size_t dnskey_idx) 393 { 394 return dnskey_algo_id_is_supported(dnskey_get_algo(dnskey_rrset, 395 dnskey_idx)); 396 } 397 398 int dnskey_size_is_supported(struct ub_packed_rrset_key* dnskey_rrset, 399 size_t dnskey_idx) 400 { 401 #ifdef DEPRECATE_RSA_1024 402 uint8_t* rdata; 403 size_t len; 404 int alg = dnskey_get_algo(dnskey_rrset, dnskey_idx); 405 size_t keysize; 406 407 rrset_get_rdata(dnskey_rrset, dnskey_idx, &rdata, &len); 408 if(len < 2+4) 409 return 0; 410 keysize = sldns_rr_dnskey_key_size_raw(rdata+2+4, len-2-4, alg); 411 412 switch((sldns_algorithm)alg) { 413 case LDNS_RSAMD5: 414 case LDNS_RSASHA1: 415 case LDNS_RSASHA1_NSEC3: 416 case LDNS_RSASHA256: 417 case LDNS_RSASHA512: 418 /* reject RSA keys of 1024 bits and shorter */ 419 if(keysize <= 1024) 420 return 0; 421 break; 422 default: 423 break; 424 } 425 #else 426 (void)dnskey_rrset; (void)dnskey_idx; 427 #endif /* DEPRECATE_RSA_1024 */ 428 return 1; 429 } 430 431 int dnskeyset_size_is_supported(struct ub_packed_rrset_key* dnskey_rrset) 432 { 433 size_t i, num = rrset_get_count(dnskey_rrset); 434 for(i=0; i<num; i++) { 435 if(!dnskey_size_is_supported(dnskey_rrset, i)) 436 return 0; 437 } 438 return 1; 439 } 440 441 void algo_needs_init_dnskey_add(struct algo_needs* n, 442 struct ub_packed_rrset_key* dnskey, uint8_t* sigalg) 443 { 444 uint8_t algo; 445 size_t i, total = n->num; 446 size_t num = rrset_get_count(dnskey); 447 448 for(i=0; i<num; i++) { 449 algo = (uint8_t)dnskey_get_algo(dnskey, i); 450 if(!dnskey_algo_id_is_supported((int)algo)) 451 continue; 452 if(n->needs[algo] == 0) { 453 n->needs[algo] = 1; 454 sigalg[total] = algo; 455 total++; 456 } 457 } 458 sigalg[total] = 0; 459 n->num = total; 460 } 461 462 void algo_needs_init_list(struct algo_needs* n, uint8_t* sigalg) 463 { 464 uint8_t algo; 465 size_t total = 0; 466 467 memset(n->needs, 0, sizeof(uint8_t)*ALGO_NEEDS_MAX); 468 while( (algo=*sigalg++) != 0) { 469 log_assert(dnskey_algo_id_is_supported((int)algo)); 470 log_assert(n->needs[algo] == 0); 471 n->needs[algo] = 1; 472 total++; 473 } 474 n->num = total; 475 } 476 477 void algo_needs_init_ds(struct algo_needs* n, struct ub_packed_rrset_key* ds, 478 int fav_ds_algo, uint8_t* sigalg) 479 { 480 uint8_t algo; 481 size_t i, total = 0; 482 size_t num = rrset_get_count(ds); 483 484 memset(n->needs, 0, sizeof(uint8_t)*ALGO_NEEDS_MAX); 485 for(i=0; i<num; i++) { 486 if(ds_get_digest_algo(ds, i) != fav_ds_algo) 487 continue; 488 algo = (uint8_t)ds_get_key_algo(ds, i); 489 if(!dnskey_algo_id_is_supported((int)algo)) 490 continue; 491 log_assert(algo != 0); /* we do not support 0 and is EOS */ 492 if(n->needs[algo] == 0) { 493 n->needs[algo] = 1; 494 sigalg[total] = algo; 495 total++; 496 } 497 } 498 sigalg[total] = 0; 499 n->num = total; 500 } 501 502 int algo_needs_set_secure(struct algo_needs* n, uint8_t algo) 503 { 504 if(n->needs[algo]) { 505 n->needs[algo] = 0; 506 n->num --; 507 if(n->num == 0) /* done! */ 508 return 1; 509 } 510 return 0; 511 } 512 513 void algo_needs_set_bogus(struct algo_needs* n, uint8_t algo) 514 { 515 if(n->needs[algo]) n->needs[algo] = 2; /* need it, but bogus */ 516 } 517 518 size_t algo_needs_num_missing(struct algo_needs* n) 519 { 520 return n->num; 521 } 522 523 int algo_needs_missing(struct algo_needs* n) 524 { 525 int i, miss = -1; 526 /* check if a needed algo was bogus - report that; 527 * check the first missing algo - report that; 528 * or return 0 */ 529 for(i=0; i<ALGO_NEEDS_MAX; i++) { 530 if(n->needs[i] == 2) 531 return 0; 532 if(n->needs[i] == 1 && miss == -1) 533 miss = i; 534 } 535 if(miss != -1) return miss; 536 return 0; 537 } 538 539 /** 540 * verify rrset, with dnskey rrset, for a specific rrsig in rrset 541 * @param env: module environment, scratch space is used. 542 * @param ve: validator environment, date settings. 543 * @param now: current time for validation (can be overridden). 544 * @param rrset: to be validated. 545 * @param dnskey: DNSKEY rrset, keyset to try. 546 * @param sig_idx: which signature to try to validate. 547 * @param sortree: reused sorted order. Stored in region. Pass NULL at start, 548 * and for a new rrset. 549 * @param reason: if bogus, a string returned, fixed or alloced in scratch. 550 * @param reason_bogus: EDE (RFC8914) code paired with the reason of failure. 551 * @param section: section of packet where this rrset comes from. 552 * @param qstate: qstate with region. 553 * @param vq: validator qstate with attempt counts. 554 * @param numverified: incremented when the number of RRSIG validations 555 * increases. 556 * @param num_tagmatches: incremented for tag matches. 557 * @return secure if any key signs *this* signature. bogus if no key signs it, 558 * unchecked on error, or indeterminate if all keys are not supported by 559 * the crypto library (openssl3+ only). 560 */ 561 static enum sec_status 562 dnskeyset_verify_rrset_sig(struct module_env* env, struct val_env* ve, 563 time_t now, struct ub_packed_rrset_key* rrset, 564 struct ub_packed_rrset_key* dnskey, size_t sig_idx, 565 struct rbtree_type** sortree, 566 char** reason, sldns_ede_code *reason_bogus, 567 sldns_pkt_section section, struct module_qstate* qstate, 568 struct val_qstate* vq, int* numverified, size_t* num_tagmatches) 569 { 570 /* find matching keys and check them */ 571 enum sec_status sec = sec_status_bogus; 572 uint16_t tag = rrset_get_sig_keytag(rrset, sig_idx); 573 int algo = rrset_get_sig_algo(rrset, sig_idx); 574 size_t i, num = rrset_get_count(dnskey); 575 size_t numchecked = 0; 576 size_t numindeterminate = 0; 577 int buf_canon = 0; 578 verbose(VERB_ALGO, "verify sig %d %d", (int)tag, algo); 579 if(!dnskey_algo_id_is_supported(algo)) { 580 if(reason_bogus) 581 *reason_bogus = LDNS_EDE_UNSUPPORTED_DNSKEY_ALG; 582 verbose(VERB_QUERY, "verify sig: unknown algorithm"); 583 return sec_status_insecure; 584 } 585 586 for(i=0; i<num; i++) { 587 if((*num_tagmatches)++ > MAX_TAG_MATCHES) { 588 *reason = "too many tag matches"; 589 if(reason_bogus) 590 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 591 verbose(VERB_ALGO, "verify sig: too many tag matches, " 592 "MAX_TAG_MATCHES (%d); bogus", MAX_TAG_MATCHES); 593 return sec_status_bogus; 594 } 595 /* see if key matches keytag and algo */ 596 if(algo != dnskey_get_algo(dnskey, i) || 597 tag != dnskey_calc_keytag(dnskey, i)) 598 continue; 599 numchecked ++; 600 (*numverified)++; 601 602 if(vq && vq->num_validation_attempts++ > env->cfg->val_validation_attempts) { 603 *reason = "too many validation attempts"; 604 if(reason_bogus) 605 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 606 verbose(VERB_ALGO, "verify sig: too many validation attempts, " 607 "val-validation-attempts (%d); bogus", env->cfg->val_validation_attempts); 608 return sec_status_bogus; 609 } 610 if(vq && (ntohs(rrset->rk.type) == LDNS_RR_TYPE_NSEC || 611 ntohs(rrset->rk.type) == LDNS_RR_TYPE_NSEC3) && 612 vq->num_nsec_attempts++ > MAX_VALIDATE_NSECS) { 613 *reason = "too many NSEC or NSEC3 validation attempts"; 614 if(reason_bogus) 615 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 616 verbose(VERB_ALGO, "verify sig: too many NSEC or NSEC3 validation attempts, " 617 "(%d); bogus", MAX_VALIDATE_NSECS); 618 vq->num_nsec_attempts_exceeded = 1; 619 return sec_status_bogus; 620 } 621 622 /* see if key verifies */ 623 sec = dnskey_verify_rrset_sig(env->scratch, 624 env->scratch_buffer, ve, now, rrset, dnskey, i, 625 sig_idx, sortree, &buf_canon, reason, reason_bogus, 626 section, qstate); 627 if(sec == sec_status_secure) 628 return sec; 629 else if(sec == sec_status_indeterminate) 630 numindeterminate ++; 631 if(*numverified > MAX_VALIDATE_RRSIGS) { 632 *reason = "too many RRSIG validations"; 633 if(reason_bogus) 634 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 635 verbose(VERB_ALGO, "verify sig: too many RRSIG validations"); 636 return sec_status_bogus; 637 } 638 } 639 if(numchecked == 0) { 640 *reason = "signatures from unknown keys"; 641 if(reason_bogus) 642 *reason_bogus = LDNS_EDE_DNSKEY_MISSING; 643 verbose(VERB_QUERY, "verify: could not find appropriate key"); 644 return sec_status_bogus; 645 } 646 if(numindeterminate == numchecked) { 647 *reason = "unsupported algorithm by crypto library"; 648 if(reason_bogus) 649 *reason_bogus = LDNS_EDE_UNSUPPORTED_DNSKEY_ALG; 650 verbose(VERB_ALGO, "verify sig: unsupported algorithm by " 651 "crypto library"); 652 return sec_status_indeterminate; 653 } 654 return sec_status_bogus; 655 } 656 657 enum sec_status 658 dnskeyset_verify_rrset(struct module_env* env, struct val_env* ve, 659 struct ub_packed_rrset_key* rrset, struct ub_packed_rrset_key* dnskey, 660 uint8_t* sigalg, char** reason, sldns_ede_code *reason_bogus, 661 sldns_pkt_section section, struct module_qstate* qstate, 662 struct val_qstate* vq, int* verified, char* reasonbuf, 663 size_t reasonlen) 664 { 665 enum sec_status sec; 666 size_t i, num, num_tagmatches = 0; 667 rbtree_type* sortree = NULL; 668 /* make sure that for all DNSKEY algorithms there are valid sigs */ 669 struct algo_needs needs; 670 int alg; 671 *verified = 0; 672 673 num = rrset_get_sigcount(rrset); 674 if(num == 0) { 675 verbose(VERB_QUERY, "rrset failed to verify due to a lack of " 676 "signatures"); 677 *reason = "no signatures"; 678 if(reason_bogus) 679 *reason_bogus = LDNS_EDE_RRSIGS_MISSING; 680 return sec_status_bogus; 681 } 682 683 if(sigalg) { 684 algo_needs_init_list(&needs, sigalg); 685 if(algo_needs_num_missing(&needs) == 0) { 686 verbose(VERB_QUERY, "zone has no known algorithms"); 687 *reason = "zone has no known algorithms"; 688 if(reason_bogus) 689 *reason_bogus = LDNS_EDE_UNSUPPORTED_DNSKEY_ALG; 690 return sec_status_insecure; 691 } 692 } 693 for(i=0; i<num; i++) { 694 if(num_tagmatches > MAX_TAG_MATCHES) { 695 *reason = "too many tag matches"; 696 if(reason_bogus) 697 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 698 verbose(VERB_ALGO, "rrset failed to verify: too many tag matches, " 699 "MAX_TAG_MATCHES (%d)", MAX_TAG_MATCHES); 700 if(reason_bogus) 701 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 702 return sec_status_bogus; 703 } 704 sec = dnskeyset_verify_rrset_sig(env, ve, *env->now, rrset, 705 dnskey, i, &sortree, reason, reason_bogus, 706 section, qstate, vq, verified, &num_tagmatches); 707 /* see which algorithm has been fixed up */ 708 if(sec == sec_status_secure) { 709 if(!sigalg) 710 return sec; /* done! */ 711 else if(algo_needs_set_secure(&needs, 712 (uint8_t)rrset_get_sig_algo(rrset, i))) 713 return sec; /* done! */ 714 } else if(sigalg && sec == sec_status_bogus) { 715 algo_needs_set_bogus(&needs, 716 (uint8_t)rrset_get_sig_algo(rrset, i)); 717 } 718 if(*verified > MAX_VALIDATE_RRSIGS) { 719 verbose(VERB_QUERY, "rrset failed to verify, too many RRSIG validations"); 720 *reason = "too many RRSIG validations"; 721 if(reason_bogus) 722 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 723 return sec_status_bogus; 724 } 725 } 726 if(sigalg && (alg=algo_needs_missing(&needs)) != 0) { 727 verbose(VERB_ALGO, "rrset failed to verify: " 728 "no valid signatures for %d algorithms", 729 (int)algo_needs_num_missing(&needs)); 730 algo_needs_reason(alg, reason, "no signatures", reasonbuf, 731 reasonlen); 732 } else { 733 verbose(VERB_ALGO, "rrset failed to verify: " 734 "no valid signatures"); 735 } 736 return sec_status_bogus; 737 } 738 739 void algo_needs_reason(int alg, char** reason, char* s, char* reasonbuf, 740 size_t reasonlen) 741 { 742 sldns_lookup_table *t = sldns_lookup_by_id(sldns_algorithms, alg); 743 if(t&&t->name) 744 snprintf(reasonbuf, reasonlen, "%s with algorithm %s", s, 745 t->name); 746 else snprintf(reasonbuf, reasonlen, "%s with algorithm ALG%u", s, 747 (unsigned)alg); 748 *reason = reasonbuf; 749 } 750 751 enum sec_status 752 dnskey_verify_rrset(struct module_env* env, struct val_env* ve, 753 struct ub_packed_rrset_key* rrset, struct ub_packed_rrset_key* dnskey, 754 size_t dnskey_idx, char** reason, sldns_ede_code *reason_bogus, 755 sldns_pkt_section section, struct module_qstate* qstate, 756 struct val_qstate* vq, size_t* num_tagmatches) 757 { 758 enum sec_status sec; 759 size_t i, num, numchecked = 0, numindeterminate = 0; 760 rbtree_type* sortree = NULL; 761 int buf_canon = 0; 762 uint16_t tag = dnskey_calc_keytag(dnskey, dnskey_idx); 763 int algo = dnskey_get_algo(dnskey, dnskey_idx); 764 int numverified = 0; 765 766 num = rrset_get_sigcount(rrset); 767 if(num == 0) { 768 verbose(VERB_QUERY, "rrset failed to verify due to a lack of " 769 "signatures"); 770 *reason = "no signatures"; 771 if(reason_bogus) 772 *reason_bogus = LDNS_EDE_RRSIGS_MISSING; 773 return sec_status_bogus; 774 } 775 for(i=0; i<num; i++) { 776 /* see if sig matches keytag and algo */ 777 if((*num_tagmatches)++ > MAX_TAG_MATCHES) { 778 *reason = "too many tag matches"; 779 if(reason_bogus) 780 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 781 verbose(VERB_ALGO, "rrset failed to verify: too many tag matches, " 782 "MAX_TAG_MATCHES (%d); bogus", MAX_TAG_MATCHES); 783 return sec_status_bogus; 784 } 785 if(algo != rrset_get_sig_algo(rrset, i) || 786 tag != rrset_get_sig_keytag(rrset, i)) 787 continue; 788 if(vq && vq->num_validation_attempts++ > env->cfg->val_validation_attempts) { 789 *reason = "too many validation attempts"; 790 if(reason_bogus) 791 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 792 verbose(VERB_ALGO, "rrset failed to verify: too many validation attempts, " 793 "val-validation-attempts (%d); bogus", env->cfg->val_validation_attempts); 794 return sec_status_bogus; 795 } 796 797 buf_canon = 0; 798 sec = dnskey_verify_rrset_sig(env->scratch, 799 env->scratch_buffer, ve, *env->now, rrset, 800 dnskey, dnskey_idx, i, &sortree, &buf_canon, reason, 801 reason_bogus, section, qstate); 802 if(sec == sec_status_secure) 803 return sec; 804 numchecked ++; 805 numverified ++; 806 if(sec == sec_status_indeterminate) 807 numindeterminate ++; 808 if(numverified > MAX_VALIDATE_RRSIGS) { 809 verbose(VERB_QUERY, "rrset failed to verify, too many RRSIG validations"); 810 *reason = "too many RRSIG validations"; 811 if(reason_bogus) 812 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 813 return sec_status_bogus; 814 } 815 } 816 if(!numchecked) { 817 *reason = "signature for expected key and algorithm missing"; 818 if(reason_bogus) 819 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 820 } else if(numchecked == numindeterminate) { 821 verbose(VERB_ALGO, "rrset failed to verify due to algorithm " 822 "refusal by cryptolib"); 823 if(reason_bogus) 824 *reason_bogus = LDNS_EDE_UNSUPPORTED_DNSKEY_ALG; 825 *reason = "algorithm refused by cryptolib"; 826 return sec_status_indeterminate; 827 } 828 verbose(VERB_ALGO, "rrset failed to verify: all signatures are bogus"); 829 return sec_status_bogus; 830 } 831 832 /** 833 * RR entries in a canonical sorted tree of RRs 834 */ 835 struct canon_rr { 836 /** rbtree node, key is this structure */ 837 rbnode_type node; 838 /** rrset the RR is in */ 839 struct ub_packed_rrset_key* rrset; 840 /** which RR in the rrset */ 841 size_t rr_idx; 842 }; 843 844 /** 845 * Compare two RR for canonical order, in a field-style sweep. 846 * @param d: rrset data 847 * @param desc: ldns wireformat descriptor. 848 * @param i: first RR to compare 849 * @param j: first RR to compare 850 * @return comparison code. 851 */ 852 static int 853 canonical_compare_byfield(struct packed_rrset_data* d, 854 const sldns_rr_descriptor* desc, size_t i, size_t j) 855 { 856 /* sweep across rdata, keep track of some state: 857 * which rr field, and bytes left in field. 858 * current position in rdata, length left. 859 * are we in a dname, length left in a label. 860 */ 861 int wfi = -1; /* current wireformat rdata field (rdf) */ 862 int wfj = -1; 863 uint8_t* di = d->rr_data[i]+2; /* ptr to current rdata byte */ 864 uint8_t* dj = d->rr_data[j]+2; 865 size_t ilen = d->rr_len[i]-2; /* length left in rdata */ 866 size_t jlen = d->rr_len[j]-2; 867 int dname_i = 0; /* true if these bytes are part of a name */ 868 int dname_j = 0; 869 size_t lablen_i = 0; /* 0 for label length byte,for first byte of rdf*/ 870 size_t lablen_j = 0; /* otherwise remaining length of rdf or label */ 871 int dname_num_i = (int)desc->_dname_count; /* decreased at root label */ 872 int dname_num_j = (int)desc->_dname_count; 873 874 /* loop while there are rdata bytes available for both rrs, 875 * and still some lowercasing needs to be done; either the dnames 876 * have not been reached yet, or they are currently being processed */ 877 while(ilen > 0 && jlen > 0 && (dname_num_i > 0 || dname_num_j > 0)) { 878 /* compare these two bytes */ 879 /* lowercase if in a dname and not a label length byte */ 880 if( ((dname_i && lablen_i)?(uint8_t)tolower((int)*di):*di) 881 != ((dname_j && lablen_j)?(uint8_t)tolower((int)*dj):*dj) 882 ) { 883 if(((dname_i && lablen_i)?(uint8_t)tolower((int)*di):*di) 884 < ((dname_j && lablen_j)?(uint8_t)tolower((int)*dj):*dj)) 885 return -1; 886 return 1; 887 } 888 ilen--; 889 jlen--; 890 /* bytes are equal */ 891 892 /* advance field i */ 893 /* lablen 0 means that this byte is the first byte of the 894 * next rdata field; inspect this rdata field and setup 895 * to process the rest of this rdata field. 896 * The reason to first read the byte, then setup the rdf, 897 * is that we are then sure the byte is available and short 898 * rdata is handled gracefully (even if it is a formerr). */ 899 if(lablen_i == 0) { 900 if(dname_i) { 901 /* scan this dname label */ 902 /* capture length to lowercase */ 903 lablen_i = (size_t)*di; 904 if(lablen_i == 0) { 905 /* end root label */ 906 dname_i = 0; 907 dname_num_i--; 908 /* if dname num is 0, then the 909 * remainder is binary only */ 910 if(dname_num_i == 0) 911 lablen_i = ilen; 912 } 913 } else { 914 /* scan this rdata field */ 915 wfi++; 916 if(desc->_wireformat[wfi] 917 == LDNS_RDF_TYPE_DNAME) { 918 dname_i = 1; 919 lablen_i = (size_t)*di; 920 if(lablen_i == 0) { 921 dname_i = 0; 922 dname_num_i--; 923 if(dname_num_i == 0) 924 lablen_i = ilen; 925 } 926 } else if(desc->_wireformat[wfi] 927 == LDNS_RDF_TYPE_STR) 928 lablen_i = (size_t)*di; 929 else lablen_i = get_rdf_size( 930 desc->_wireformat[wfi]) - 1; 931 } 932 } else lablen_i--; 933 934 /* advance field j; same as for i */ 935 if(lablen_j == 0) { 936 if(dname_j) { 937 lablen_j = (size_t)*dj; 938 if(lablen_j == 0) { 939 dname_j = 0; 940 dname_num_j--; 941 if(dname_num_j == 0) 942 lablen_j = jlen; 943 } 944 } else { 945 wfj++; 946 if(desc->_wireformat[wfj] 947 == LDNS_RDF_TYPE_DNAME) { 948 dname_j = 1; 949 lablen_j = (size_t)*dj; 950 if(lablen_j == 0) { 951 dname_j = 0; 952 dname_num_j--; 953 if(dname_num_j == 0) 954 lablen_j = jlen; 955 } 956 } else if(desc->_wireformat[wfj] 957 == LDNS_RDF_TYPE_STR) 958 lablen_j = (size_t)*dj; 959 else lablen_j = get_rdf_size( 960 desc->_wireformat[wfj]) - 1; 961 } 962 } else lablen_j--; 963 di++; 964 dj++; 965 } 966 /* end of the loop; because we advanced byte by byte; now we have 967 * that the rdata has ended, or that there is a binary remainder */ 968 /* shortest first */ 969 if(ilen == 0 && jlen == 0) 970 return 0; 971 if(ilen == 0) 972 return -1; 973 if(jlen == 0) 974 return 1; 975 /* binary remainder, capture comparison in wfi variable */ 976 if((wfi = memcmp(di, dj, (ilen<jlen)?ilen:jlen)) != 0) 977 return wfi; 978 if(ilen < jlen) 979 return -1; 980 if(jlen < ilen) 981 return 1; 982 return 0; 983 } 984 985 /** 986 * Compare two RRs in the same RRset and determine their relative 987 * canonical order. 988 * @param rrset: the rrset in which to perform compares. 989 * @param i: first RR to compare 990 * @param j: first RR to compare 991 * @return 0 if RR i== RR j, -1 if <, +1 if >. 992 */ 993 static int 994 canonical_compare(struct ub_packed_rrset_key* rrset, size_t i, size_t j) 995 { 996 struct packed_rrset_data* d = (struct packed_rrset_data*) 997 rrset->entry.data; 998 const sldns_rr_descriptor* desc; 999 uint16_t type = ntohs(rrset->rk.type); 1000 size_t minlen; 1001 int c; 1002 1003 if(i==j) 1004 return 0; 1005 1006 switch(type) { 1007 /* These RR types have only a name as RDATA. 1008 * This name has to be canonicalized.*/ 1009 case LDNS_RR_TYPE_NS: 1010 case LDNS_RR_TYPE_MD: 1011 case LDNS_RR_TYPE_MF: 1012 case LDNS_RR_TYPE_CNAME: 1013 case LDNS_RR_TYPE_MB: 1014 case LDNS_RR_TYPE_MG: 1015 case LDNS_RR_TYPE_MR: 1016 case LDNS_RR_TYPE_PTR: 1017 case LDNS_RR_TYPE_DNAME: 1018 /* the wireread function has already checked these 1019 * dname's for correctness, and this double checks */ 1020 if(!dname_valid(d->rr_data[i]+2, d->rr_len[i]-2) || 1021 !dname_valid(d->rr_data[j]+2, d->rr_len[j]-2)) 1022 return 0; 1023 return query_dname_compare(d->rr_data[i]+2, 1024 d->rr_data[j]+2); 1025 1026 /* These RR types have STR and fixed size rdata fields 1027 * before one or more name fields that need canonicalizing, 1028 * and after that a byte-for byte remainder can be compared. 1029 */ 1030 /* type starts with the name; remainder is binary compared */ 1031 case LDNS_RR_TYPE_NXT: 1032 /* use rdata field formats */ 1033 case LDNS_RR_TYPE_MINFO: 1034 case LDNS_RR_TYPE_RP: 1035 case LDNS_RR_TYPE_SOA: 1036 case LDNS_RR_TYPE_RT: 1037 case LDNS_RR_TYPE_AFSDB: 1038 case LDNS_RR_TYPE_KX: 1039 case LDNS_RR_TYPE_MX: 1040 case LDNS_RR_TYPE_SIG: 1041 /* RRSIG signer name has to be downcased */ 1042 case LDNS_RR_TYPE_RRSIG: 1043 case LDNS_RR_TYPE_PX: 1044 case LDNS_RR_TYPE_NAPTR: 1045 case LDNS_RR_TYPE_SRV: 1046 desc = sldns_rr_descript(type); 1047 log_assert(desc); 1048 /* this holds for the types that need canonicalizing */ 1049 log_assert(desc->_minimum == desc->_maximum); 1050 return canonical_compare_byfield(d, desc, i, j); 1051 1052 case LDNS_RR_TYPE_HINFO: /* no longer downcased */ 1053 case LDNS_RR_TYPE_NSEC: 1054 default: 1055 /* For unknown RR types, or types not listed above, 1056 * no canonicalization is needed, do binary compare */ 1057 /* byte for byte compare, equal means shortest first*/ 1058 minlen = d->rr_len[i]-2; 1059 if(minlen > d->rr_len[j]-2) 1060 minlen = d->rr_len[j]-2; 1061 c = memcmp(d->rr_data[i]+2, d->rr_data[j]+2, minlen); 1062 if(c!=0) 1063 return c; 1064 /* rdata equal, shortest is first */ 1065 if(d->rr_len[i] < d->rr_len[j]) 1066 return -1; 1067 if(d->rr_len[i] > d->rr_len[j]) 1068 return 1; 1069 /* rdata equal, length equal */ 1070 break; 1071 } 1072 return 0; 1073 } 1074 1075 int 1076 canonical_tree_compare(const void* k1, const void* k2) 1077 { 1078 struct canon_rr* r1 = (struct canon_rr*)k1; 1079 struct canon_rr* r2 = (struct canon_rr*)k2; 1080 log_assert(r1->rrset == r2->rrset); 1081 return canonical_compare(r1->rrset, r1->rr_idx, r2->rr_idx); 1082 } 1083 1084 /** 1085 * Sort RRs for rrset in canonical order. 1086 * Does not actually canonicalize the RR rdatas. 1087 * Does not touch rrsigs. 1088 * @param rrset: to sort. 1089 * @param d: rrset data. 1090 * @param sortree: tree to sort into. 1091 * @param rrs: rr storage. 1092 */ 1093 static void 1094 canonical_sort(struct ub_packed_rrset_key* rrset, struct packed_rrset_data* d, 1095 rbtree_type* sortree, struct canon_rr* rrs) 1096 { 1097 size_t i; 1098 /* insert into rbtree to sort and detect duplicates */ 1099 for(i=0; i<d->count; i++) { 1100 rrs[i].node.key = &rrs[i]; 1101 rrs[i].rrset = rrset; 1102 rrs[i].rr_idx = i; 1103 if(!rbtree_insert(sortree, &rrs[i].node)) { 1104 /* this was a duplicate */ 1105 } 1106 } 1107 } 1108 1109 /** 1110 * Insert canonical owner name into buffer. 1111 * @param buf: buffer to insert into at current position. 1112 * @param k: rrset with its owner name. 1113 * @param sig: signature with signer name and label count. 1114 * must be length checked, at least 18 bytes long. 1115 * @param can_owner: position in buffer returned for future use. 1116 * @param can_owner_len: length of canonical owner name. 1117 */ 1118 static void 1119 insert_can_owner(sldns_buffer* buf, struct ub_packed_rrset_key* k, 1120 uint8_t* sig, uint8_t** can_owner, size_t* can_owner_len) 1121 { 1122 int rrsig_labels = (int)sig[3]; 1123 int fqdn_labels = dname_signame_label_count(k->rk.dname); 1124 *can_owner = sldns_buffer_current(buf); 1125 if(rrsig_labels == fqdn_labels) { 1126 /* no change */ 1127 sldns_buffer_write(buf, k->rk.dname, k->rk.dname_len); 1128 query_dname_tolower(*can_owner); 1129 *can_owner_len = k->rk.dname_len; 1130 return; 1131 } 1132 log_assert(rrsig_labels < fqdn_labels); 1133 /* *. | fqdn(rightmost rrsig_labels) */ 1134 if(rrsig_labels < fqdn_labels) { 1135 int i; 1136 uint8_t* nm = k->rk.dname; 1137 size_t len = k->rk.dname_len; 1138 /* so skip fqdn_labels-rrsig_labels */ 1139 for(i=0; i<fqdn_labels-rrsig_labels; i++) { 1140 dname_remove_label(&nm, &len); 1141 } 1142 *can_owner_len = len+2; 1143 sldns_buffer_write(buf, (uint8_t*)"\001*", 2); 1144 sldns_buffer_write(buf, nm, len); 1145 query_dname_tolower(*can_owner); 1146 } 1147 } 1148 1149 /** lowercase a wire dname but never step past end */ 1150 static void 1151 canon_dname_tolower(uint8_t* d, uint8_t* end) 1152 { 1153 uint8_t lab; 1154 while(d < end && (lab = *d) != 0) { 1155 if((size_t)lab+1 > (size_t)(end-d)) return; /* malformed */ 1156 for(d++; lab; lab--, d++) 1157 *d = (uint8_t)tolower((unsigned char)*d); 1158 } 1159 } 1160 1161 /** 1162 * Canonicalize Rdata in buffer. 1163 * @param buf: buffer at position just after the rdata. 1164 * @param rrset: rrset with type. 1165 * @param len: length of the rdata (including rdatalen uint16). 1166 */ 1167 static void 1168 canonicalize_rdata(sldns_buffer* buf, struct ub_packed_rrset_key* rrset, 1169 size_t len) 1170 { 1171 uint8_t* datstart = sldns_buffer_current(buf)-len+2; 1172 uint8_t* datend = sldns_buffer_current(buf); 1173 size_t firstlen; 1174 switch(ntohs(rrset->rk.type)) { 1175 case LDNS_RR_TYPE_NXT: 1176 case LDNS_RR_TYPE_NS: 1177 case LDNS_RR_TYPE_MD: 1178 case LDNS_RR_TYPE_MF: 1179 case LDNS_RR_TYPE_CNAME: 1180 case LDNS_RR_TYPE_MB: 1181 case LDNS_RR_TYPE_MG: 1182 case LDNS_RR_TYPE_MR: 1183 case LDNS_RR_TYPE_PTR: 1184 case LDNS_RR_TYPE_DNAME: 1185 /* type only has a single argument, the name */ 1186 canon_dname_tolower(datstart, datend); 1187 return; 1188 case LDNS_RR_TYPE_MINFO: 1189 case LDNS_RR_TYPE_RP: 1190 case LDNS_RR_TYPE_SOA: 1191 /* two names after another */ 1192 canon_dname_tolower(datstart, datend); 1193 firstlen = dname_valid(datstart, len-2); 1194 if(firstlen && firstlen < len-2) 1195 canon_dname_tolower(datstart + firstlen, datend); 1196 return; 1197 case LDNS_RR_TYPE_RT: 1198 case LDNS_RR_TYPE_AFSDB: 1199 case LDNS_RR_TYPE_KX: 1200 case LDNS_RR_TYPE_MX: 1201 /* skip fixed part */ 1202 if(len < 2+2+1) /* rdlen, skiplen, 1byteroot */ 1203 return; 1204 datstart += 2; 1205 canon_dname_tolower(datstart, datend); 1206 return; 1207 case LDNS_RR_TYPE_SIG: 1208 /* downcase the RRSIG, compat with BIND (kept it from SIG) */ 1209 case LDNS_RR_TYPE_RRSIG: 1210 /* skip fixed part */ 1211 if(len < 2+18+1) 1212 return; 1213 datstart += 18; 1214 canon_dname_tolower(datstart, datend); 1215 return; 1216 case LDNS_RR_TYPE_PX: 1217 /* skip, then two names after another */ 1218 if(len < 2+2+1) 1219 return; 1220 datstart += 2; 1221 canon_dname_tolower(datstart, datend); 1222 firstlen = dname_valid(datstart, len-2-2); 1223 if(firstlen && firstlen < len-2-2) 1224 canon_dname_tolower(datstart + firstlen, datend); 1225 return; 1226 case LDNS_RR_TYPE_NAPTR: 1227 if(len < 2+4) 1228 return; 1229 len -= 2+4; 1230 datstart += 4; 1231 if(len < (size_t)datstart[0]+1) /* skip text field */ 1232 return; 1233 len -= (size_t)datstart[0]+1; 1234 datstart += (size_t)datstart[0]+1; 1235 if(len < (size_t)datstart[0]+1) /* skip text field */ 1236 return; 1237 len -= (size_t)datstart[0]+1; 1238 datstart += (size_t)datstart[0]+1; 1239 if(len < (size_t)datstart[0]+1) /* skip text field */ 1240 return; 1241 len -= (size_t)datstart[0]+1; 1242 datstart += (size_t)datstart[0]+1; 1243 if(len < 1) /* check name is at least 1 byte*/ 1244 return; 1245 canon_dname_tolower(datstart, datend); 1246 return; 1247 case LDNS_RR_TYPE_SRV: 1248 /* skip fixed part */ 1249 if(len < 2+6+1) 1250 return; 1251 datstart += 6; 1252 canon_dname_tolower(datstart, datend); 1253 return; 1254 1255 /* do not canonicalize NSEC rdata name, compat with 1256 * from bind 9.4 signer, where it does not do so */ 1257 case LDNS_RR_TYPE_NSEC: /* type starts with the name */ 1258 case LDNS_RR_TYPE_HINFO: /* not downcased */ 1259 /* A6 not supported */ 1260 default: 1261 /* nothing to do for unknown types */ 1262 return; 1263 } 1264 } 1265 1266 int rrset_canonical_equal(struct regional* region, 1267 struct ub_packed_rrset_key* k1, struct ub_packed_rrset_key* k2) 1268 { 1269 struct rbtree_type sortree1, sortree2; 1270 struct canon_rr *rrs1, *rrs2, *p1, *p2; 1271 struct packed_rrset_data* d1=(struct packed_rrset_data*)k1->entry.data; 1272 struct packed_rrset_data* d2=(struct packed_rrset_data*)k2->entry.data; 1273 struct ub_packed_rrset_key fk; 1274 struct packed_rrset_data fd; 1275 size_t flen[2]; 1276 uint8_t* fdata[2]; 1277 1278 /* basic compare */ 1279 if(k1->rk.dname_len != k2->rk.dname_len || 1280 k1->rk.flags != k2->rk.flags || 1281 k1->rk.type != k2->rk.type || 1282 k1->rk.rrset_class != k2->rk.rrset_class || 1283 query_dname_compare(k1->rk.dname, k2->rk.dname) != 0) 1284 return 0; 1285 if(d1->ttl != d2->ttl || 1286 d1->count != d2->count || 1287 d1->rrsig_count != d2->rrsig_count || 1288 d1->trust != d2->trust || 1289 d1->security != d2->security) 1290 return 0; 1291 1292 /* init */ 1293 memset(&fk, 0, sizeof(fk)); 1294 memset(&fd, 0, sizeof(fd)); 1295 fk.entry.data = &fd; 1296 fd.count = 2; 1297 fd.rr_len = flen; 1298 fd.rr_data = fdata; 1299 rbtree_init(&sortree1, &canonical_tree_compare); 1300 rbtree_init(&sortree2, &canonical_tree_compare); 1301 if(d1->count > RR_COUNT_MAX || d2->count > RR_COUNT_MAX) 1302 return 1; /* protection against integer overflow */ 1303 rrs1 = regional_alloc(region, sizeof(struct canon_rr)*d1->count); 1304 rrs2 = regional_alloc(region, sizeof(struct canon_rr)*d2->count); 1305 if(!rrs1 || !rrs2) return 1; /* alloc failure */ 1306 1307 /* sort */ 1308 canonical_sort(k1, d1, &sortree1, rrs1); 1309 canonical_sort(k2, d2, &sortree2, rrs2); 1310 1311 /* compare canonical-sorted RRs for canonical-equality */ 1312 if(sortree1.count != sortree2.count) 1313 return 0; 1314 p1 = (struct canon_rr*)rbtree_first(&sortree1); 1315 p2 = (struct canon_rr*)rbtree_first(&sortree2); 1316 while(p1 != (struct canon_rr*)RBTREE_NULL && 1317 p2 != (struct canon_rr*)RBTREE_NULL) { 1318 flen[0] = d1->rr_len[p1->rr_idx]; 1319 flen[1] = d2->rr_len[p2->rr_idx]; 1320 fdata[0] = d1->rr_data[p1->rr_idx]; 1321 fdata[1] = d2->rr_data[p2->rr_idx]; 1322 1323 if(canonical_compare(&fk, 0, 1) != 0) 1324 return 0; 1325 p1 = (struct canon_rr*)rbtree_next(&p1->node); 1326 p2 = (struct canon_rr*)rbtree_next(&p2->node); 1327 } 1328 return 1; 1329 } 1330 1331 /** 1332 * Create canonical form of rrset in the scratch buffer. 1333 * @param region: temporary region. 1334 * @param buf: the buffer to use. 1335 * @param k: the rrset to insert. 1336 * @param sig: RRSIG rdata to include. 1337 * @param siglen: RRSIG rdata len excluding signature field, but inclusive 1338 * signer name length. 1339 * @param sortree: if NULL is passed a new sorted rrset tree is built. 1340 * Otherwise it is reused. 1341 * @param section: section of packet where this rrset comes from. 1342 * @param qstate: qstate with region. 1343 * @return false on alloc error. 1344 */ 1345 static int 1346 rrset_canonical(struct regional* region, sldns_buffer* buf, 1347 struct ub_packed_rrset_key* k, uint8_t* sig, size_t siglen, 1348 struct rbtree_type** sortree, sldns_pkt_section section, 1349 struct module_qstate* qstate) 1350 { 1351 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 1352 uint8_t* can_owner = NULL; 1353 size_t can_owner_len = 0; 1354 struct canon_rr* walk; 1355 struct canon_rr* rrs; 1356 1357 if(!*sortree) { 1358 *sortree = (struct rbtree_type*)regional_alloc(region, 1359 sizeof(rbtree_type)); 1360 if(!*sortree) 1361 return 0; 1362 if(d->count > RR_COUNT_MAX) 1363 return 0; /* integer overflow protection */ 1364 rrs = regional_alloc(region, sizeof(struct canon_rr)*d->count); 1365 if(!rrs) { 1366 *sortree = NULL; 1367 return 0; 1368 } 1369 rbtree_init(*sortree, &canonical_tree_compare); 1370 canonical_sort(k, d, *sortree, rrs); 1371 } 1372 1373 sldns_buffer_clear(buf); 1374 if(sldns_buffer_remaining(buf) < siglen || siglen < 18+1) { 1375 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1376 "rrset too big"); 1377 return 0; 1378 } 1379 sldns_buffer_write(buf, sig, siglen); 1380 /* canonicalize signer name */ 1381 canon_dname_tolower(sldns_buffer_begin(buf)+18, 1382 sldns_buffer_current(buf)); 1383 1384 if(sldns_buffer_remaining(buf) < k->rk.dname_len+2) { 1385 /* Check if the first can_owner name can fit in the buffer. 1386 * The length is k->rk.dname_len or k->rk.dname_len+2 1387 * if it has '*.' in prefixed. Checks the upper bound, 1388 * also realistically the rest of the rrtype, rrclass, origttl, 1389 * rdata and so on has to be inserted, so that extra space has 1390 * to be there. */ 1391 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1392 "rrset too big"); 1393 return 0; 1394 } 1395 RBTREE_FOR(walk, struct canon_rr*, (*sortree)) { 1396 /* see if there is enough space left in the buffer */ 1397 if(sldns_buffer_remaining(buf) < can_owner_len + 2 + 2 + 4 1398 + d->rr_len[walk->rr_idx]) { 1399 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1400 "rrset too big"); 1401 return 0; 1402 } 1403 /* determine canonical owner name */ 1404 if(can_owner) 1405 sldns_buffer_write(buf, can_owner, can_owner_len); 1406 else insert_can_owner(buf, k, sig, &can_owner, 1407 &can_owner_len); 1408 /* Check again, if the rdata can fit in the buffer */ 1409 if(sldns_buffer_remaining(buf) < 2 + 2 + 4 1410 + d->rr_len[walk->rr_idx]) { 1411 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1412 "rrset too big"); 1413 return 0; 1414 } 1415 sldns_buffer_write(buf, &k->rk.type, 2); 1416 sldns_buffer_write(buf, &k->rk.rrset_class, 2); 1417 sldns_buffer_write(buf, sig+4, 4); 1418 sldns_buffer_write(buf, d->rr_data[walk->rr_idx], 1419 d->rr_len[walk->rr_idx]); 1420 canonicalize_rdata(buf, k, d->rr_len[walk->rr_idx]); 1421 } 1422 sldns_buffer_flip(buf); 1423 1424 /* Replace RR owner with canonical owner for NSEC records in authority 1425 * section, to prevent that a wildcard synthesized NSEC can be used in 1426 * the non-existence proves. */ 1427 if(ntohs(k->rk.type) == LDNS_RR_TYPE_NSEC && 1428 section == LDNS_SECTION_AUTHORITY && qstate) { 1429 uint8_t* new_dname = regional_alloc_init(qstate->region, can_owner, 1430 can_owner_len); 1431 if(!new_dname) 1432 return 0; 1433 k->rk.dname = new_dname; 1434 k->rk.dname_len = can_owner_len; 1435 } 1436 1437 1438 return 1; 1439 } 1440 1441 int 1442 rrset_canonicalize_to_buffer(struct regional* region, sldns_buffer* buf, 1443 struct ub_packed_rrset_key* k) 1444 { 1445 struct rbtree_type* sortree = NULL; 1446 struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data; 1447 uint8_t* can_owner = NULL; 1448 size_t can_owner_len = 0; 1449 struct canon_rr* walk; 1450 struct canon_rr* rrs; 1451 1452 sortree = (struct rbtree_type*)regional_alloc(region, 1453 sizeof(rbtree_type)); 1454 if(!sortree) 1455 return 0; 1456 if(d->count > RR_COUNT_MAX) 1457 return 0; /* integer overflow protection */ 1458 rrs = regional_alloc(region, sizeof(struct canon_rr)*d->count); 1459 if(!rrs) { 1460 return 0; 1461 } 1462 rbtree_init(sortree, &canonical_tree_compare); 1463 canonical_sort(k, d, sortree, rrs); 1464 1465 sldns_buffer_clear(buf); 1466 if(sldns_buffer_remaining(buf) < k->rk.dname_len) { 1467 /* Check if the first can_owner name can fit in the buffer. */ 1468 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1469 "rrset too big"); 1470 return 0; 1471 } 1472 RBTREE_FOR(walk, struct canon_rr*, sortree) { 1473 /* see if there is enough space left in the buffer */ 1474 if(sldns_buffer_remaining(buf) < can_owner_len + 2 + 2 + 4 1475 + d->rr_len[walk->rr_idx]) { 1476 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1477 "rrset too big"); 1478 return 0; 1479 } 1480 /* determine canonical owner name */ 1481 if(can_owner) 1482 sldns_buffer_write(buf, can_owner, can_owner_len); 1483 else { 1484 can_owner = sldns_buffer_current(buf); 1485 sldns_buffer_write(buf, k->rk.dname, k->rk.dname_len); 1486 query_dname_tolower(can_owner); 1487 can_owner_len = k->rk.dname_len; 1488 } 1489 /* Check again, if the rdata can fit in the buffer */ 1490 if(sldns_buffer_remaining(buf) < 2 + 2 + 4 1491 + d->rr_len[walk->rr_idx]) { 1492 verbose(VERB_ALGO, "verify: failed to canonicalize, " 1493 "rrset too big"); 1494 return 0; 1495 } 1496 sldns_buffer_write(buf, &k->rk.type, 2); 1497 sldns_buffer_write(buf, &k->rk.rrset_class, 2); 1498 sldns_buffer_write_u32(buf, d->rr_ttl[walk->rr_idx]); 1499 sldns_buffer_write(buf, d->rr_data[walk->rr_idx], 1500 d->rr_len[walk->rr_idx]); 1501 canonicalize_rdata(buf, k, d->rr_len[walk->rr_idx]); 1502 } 1503 sldns_buffer_flip(buf); 1504 return 1; 1505 } 1506 1507 /** pretty print rrsig error with dates */ 1508 static void 1509 sigdate_error(const char* str, int32_t expi, int32_t incep, int32_t now) 1510 { 1511 struct tm tm; 1512 char expi_buf[16]; 1513 char incep_buf[16]; 1514 char now_buf[16]; 1515 time_t te, ti, tn; 1516 1517 if(verbosity < VERB_QUERY) 1518 return; 1519 te = (time_t)expi; 1520 ti = (time_t)incep; 1521 tn = (time_t)now; 1522 memset(&tm, 0, sizeof(tm)); 1523 if(gmtime_r(&te, &tm) && strftime(expi_buf, 15, "%Y%m%d%H%M%S", &tm) 1524 &&gmtime_r(&ti, &tm) && strftime(incep_buf, 15, "%Y%m%d%H%M%S", &tm) 1525 &&gmtime_r(&tn, &tm) && strftime(now_buf, 15, "%Y%m%d%H%M%S", &tm)) { 1526 log_info("%s expi=%s incep=%s now=%s", str, expi_buf, 1527 incep_buf, now_buf); 1528 } else 1529 log_info("%s expi=%u incep=%u now=%u", str, (unsigned)expi, 1530 (unsigned)incep, (unsigned)now); 1531 } 1532 1533 /** check rrsig dates */ 1534 static int 1535 check_dates(struct val_env* ve, uint32_t unow, uint8_t* expi_p, 1536 uint8_t* incep_p, char** reason, sldns_ede_code *reason_bogus) 1537 { 1538 /* read out the dates */ 1539 uint32_t expi, incep, now; 1540 memmove(&expi, expi_p, sizeof(expi)); 1541 memmove(&incep, incep_p, sizeof(incep)); 1542 expi = ntohl(expi); 1543 incep = ntohl(incep); 1544 1545 /* get current date */ 1546 if(ve->date_override) { 1547 if(ve->date_override == -1) { 1548 verbose(VERB_ALGO, "date override: ignore date"); 1549 return 1; 1550 } 1551 now = ve->date_override; 1552 verbose(VERB_ALGO, "date override option %d", (int)now); 1553 } else now = unow; 1554 1555 /* check them */ 1556 if(compare_1982(incep, expi) > 0) { 1557 sigdate_error("verify: inception after expiration, " 1558 "signature bad", expi, incep, now); 1559 *reason = "signature inception after expiration"; 1560 if(reason_bogus){ 1561 /* from RFC8914 on Signature Not Yet Valid: The resolver 1562 * attempted to perform DNSSEC validation, but no 1563 * signatures are presently valid and at least some are 1564 * not yet valid. */ 1565 *reason_bogus = LDNS_EDE_SIGNATURE_NOT_YET_VALID; 1566 } 1567 1568 return 0; 1569 } 1570 if(compare_1982(incep, now) > 0) { 1571 /* within skew ? (calc here to avoid calculation normally) */ 1572 uint32_t skew = subtract_1982(incep, expi)/10; 1573 if(skew < (uint32_t)ve->skew_min) skew = ve->skew_min; 1574 if(skew > (uint32_t)ve->skew_max) skew = ve->skew_max; 1575 if(subtract_1982(now, incep) > skew) { 1576 sigdate_error("verify: signature bad, current time is" 1577 " before inception date", expi, incep, now); 1578 *reason = "signature before inception date"; 1579 if(reason_bogus) 1580 *reason_bogus = LDNS_EDE_SIGNATURE_NOT_YET_VALID; 1581 return 0; 1582 } 1583 sigdate_error("verify warning suspicious signature inception " 1584 " or bad local clock", expi, incep, now); 1585 } 1586 if(compare_1982(now, expi) > 0) { 1587 uint32_t skew = subtract_1982(incep, expi)/10; 1588 if(skew < (uint32_t)ve->skew_min) skew = ve->skew_min; 1589 if(skew > (uint32_t)ve->skew_max) skew = ve->skew_max; 1590 if(subtract_1982(expi, now) > skew) { 1591 sigdate_error("verify: signature expired", expi, 1592 incep, now); 1593 *reason = "signature expired"; 1594 if(reason_bogus) 1595 *reason_bogus = LDNS_EDE_SIGNATURE_EXPIRED; 1596 return 0; 1597 } 1598 sigdate_error("verify warning suspicious signature expiration " 1599 " or bad local clock", expi, incep, now); 1600 } 1601 return 1; 1602 } 1603 1604 /** adjust rrset TTL for verified rrset, compare to original TTL and expi */ 1605 static void 1606 adjust_ttl(struct val_env* ve, uint32_t unow, 1607 struct ub_packed_rrset_key* rrset, uint8_t* orig_p, 1608 uint8_t* expi_p, uint8_t* incep_p) 1609 { 1610 struct packed_rrset_data* d = 1611 (struct packed_rrset_data*)rrset->entry.data; 1612 /* read out the dates */ 1613 int32_t origttl, expittl, expi, incep, now; 1614 memmove(&origttl, orig_p, sizeof(origttl)); 1615 memmove(&expi, expi_p, sizeof(expi)); 1616 memmove(&incep, incep_p, sizeof(incep)); 1617 expi = ntohl(expi); 1618 incep = ntohl(incep); 1619 origttl = ntohl(origttl); 1620 1621 /* get current date */ 1622 if(ve->date_override) { 1623 now = ve->date_override; 1624 } else now = (int32_t)unow; 1625 expittl = (int32_t)((uint32_t)expi - (uint32_t)now); 1626 1627 /* so now: 1628 * d->ttl: rrset ttl read from message or cache. May be reduced 1629 * origttl: original TTL from signature, authoritative TTL max. 1630 * MIN_TTL: minimum TTL from config. 1631 * expittl: TTL until the signature expires. 1632 * 1633 * Use the smallest of these, but don't let origttl set the TTL 1634 * below the minimum. 1635 */ 1636 if(MIN_TTL > (time_t)origttl && d->ttl > MIN_TTL) { 1637 verbose(VERB_QUERY, "rrset TTL larger than original and minimum" 1638 " TTL, adjusting TTL downwards to minimum ttl"); 1639 d->ttl = MIN_TTL; 1640 } 1641 else if(MIN_TTL <= origttl && d->ttl > (time_t)origttl) { 1642 verbose(VERB_QUERY, "rrset TTL larger than original TTL, " 1643 "adjusting TTL downwards to original ttl"); 1644 d->ttl = origttl; 1645 } 1646 1647 if(expittl > 0 && d->ttl > (time_t)expittl) { 1648 verbose(VERB_ALGO, "rrset TTL larger than sig expiration ttl," 1649 " adjusting TTL downwards"); 1650 d->ttl = expittl; 1651 } 1652 } 1653 1654 enum sec_status 1655 dnskey_verify_rrset_sig(struct regional* region, sldns_buffer* buf, 1656 struct val_env* ve, time_t now, 1657 struct ub_packed_rrset_key* rrset, struct ub_packed_rrset_key* dnskey, 1658 size_t dnskey_idx, size_t sig_idx, 1659 struct rbtree_type** sortree, int* buf_canon, 1660 char** reason, sldns_ede_code *reason_bogus, 1661 sldns_pkt_section section, struct module_qstate* qstate) 1662 { 1663 enum sec_status sec; 1664 uint8_t* sig; /* RRSIG rdata */ 1665 size_t siglen; 1666 size_t rrnum = rrset_get_count(rrset); 1667 uint8_t* signer; /* rrsig signer name */ 1668 size_t signer_len; 1669 unsigned char* sigblock; /* signature rdata field */ 1670 unsigned int sigblock_len; 1671 uint16_t ktag; /* DNSKEY key tag */ 1672 unsigned char* key; /* public key rdata field */ 1673 unsigned int keylen; 1674 rrset_get_rdata(rrset, rrnum + sig_idx, &sig, &siglen); 1675 /* min length of rdatalen, fixed rrsig, root signer, 1 byte sig */ 1676 if(siglen < 2+20) { 1677 verbose(VERB_QUERY, "verify: signature too short"); 1678 *reason = "signature too short"; 1679 if(reason_bogus) 1680 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1681 return sec_status_bogus; 1682 } 1683 1684 if(!(dnskey_get_flags(dnskey, dnskey_idx) & DNSKEY_BIT_ZSK)) { 1685 verbose(VERB_QUERY, "verify: dnskey without ZSK flag"); 1686 *reason = "dnskey without ZSK flag"; 1687 if(reason_bogus) 1688 *reason_bogus = LDNS_EDE_NO_ZONE_KEY_BIT_SET; 1689 return sec_status_bogus; 1690 } 1691 if((dnskey_get_flags(dnskey, dnskey_idx) & LDNS_KEY_REVOKE_KEY) && 1692 /* The REVOKE key is allowed to check sigs on itself. */ 1693 !(ntohs(rrset->rk.type) == LDNS_RR_TYPE_DNSKEY && 1694 query_dname_compare(rrset->rk.dname, dnskey->rk.dname)==0) 1695 ) { 1696 verbose(VERB_QUERY, "verify: dnskey has REVOKE bit set, " 1697 "not usable for data validation per RFC 5011 s2.1"); 1698 *reason = "dnskey revoked"; 1699 if(reason_bogus) 1700 *reason_bogus = LDNS_EDE_DNSKEY_MISSING; 1701 return sec_status_bogus; 1702 } 1703 1704 if(dnskey_get_protocol(dnskey, dnskey_idx) != LDNS_DNSSEC_KEYPROTO) { 1705 /* RFC 4034 says DNSKEY PROTOCOL MUST be 3 */ 1706 verbose(VERB_QUERY, "verify: dnskey has wrong key protocol"); 1707 *reason = "dnskey has wrong protocolnumber"; 1708 if(reason_bogus) 1709 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1710 return sec_status_bogus; 1711 } 1712 1713 /* verify as many fields in rrsig as possible */ 1714 signer = sig+2+18; 1715 signer_len = dname_valid(signer, siglen-2-18); 1716 if(!signer_len) { 1717 verbose(VERB_QUERY, "verify: malformed signer name"); 1718 *reason = "signer name malformed"; 1719 if(reason_bogus) 1720 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1721 return sec_status_bogus; /* signer name invalid */ 1722 } 1723 if(!dname_subdomain_c(rrset->rk.dname, signer)) { 1724 verbose(VERB_QUERY, "verify: signer name is off-tree"); 1725 *reason = "signer name off-tree"; 1726 if(reason_bogus) 1727 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1728 return sec_status_bogus; /* signer name offtree */ 1729 } 1730 /* NSEC3, the owner name must be the <base32hash>.signername */ 1731 if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_NSEC3 && 1732 rrset->rk.dname_len > 0) { 1733 uint8_t* dnameless = rrset->rk.dname; 1734 size_t dnamelesslen = rrset->rk.dname_len; 1735 dname_remove_label(&dnameless, &dnamelesslen); 1736 if(query_dname_compare(dnameless, signer) != 0) { 1737 verbose(VERB_QUERY, "verify: NSEC3 owner name is not b32.signer name"); 1738 *reason = "NSEC3 owner name is not b32.signer name"; 1739 if(reason_bogus) 1740 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1741 return sec_status_bogus; /* NSEC3 owner not b32.signer */ 1742 } 1743 } 1744 /* NSEC, a next owner that is not under the signer is not allowed.*/ 1745 if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_NSEC && 1746 !nsec_nextowner_subdomain(rrset, signer)) { 1747 verbose(VERB_QUERY, "verify: NSEC next owner overreaches signer name"); 1748 *reason = "NSEC next owner overreaches signer name"; 1749 if(reason_bogus) 1750 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1751 return sec_status_bogus; /* nextowner overreaching */ 1752 } 1753 1754 sigblock = (unsigned char*)signer+signer_len; 1755 if(siglen < 2+18+signer_len+1) { 1756 verbose(VERB_QUERY, "verify: too short, no signature data"); 1757 *reason = "signature too short, no signature data"; 1758 if(reason_bogus) 1759 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1760 return sec_status_bogus; /* sig rdf is < 1 byte */ 1761 } 1762 sigblock_len = (unsigned int)(siglen - 2 - 18 - signer_len); 1763 1764 /* verify key dname == sig signer name */ 1765 if(query_dname_compare(signer, dnskey->rk.dname) != 0) { 1766 verbose(VERB_QUERY, "verify: wrong key for rrsig"); 1767 log_nametypeclass(VERB_QUERY, "RRSIG signername is", 1768 signer, 0, 0); 1769 log_nametypeclass(VERB_QUERY, "the key name is", 1770 dnskey->rk.dname, 0, 0); 1771 *reason = "signer name mismatches key name"; 1772 if(reason_bogus) 1773 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1774 return sec_status_bogus; 1775 } 1776 1777 /* verify covered type */ 1778 /* memcmp works because type is in network format for rrset */ 1779 if(memcmp(sig+2, &rrset->rk.type, 2) != 0) { 1780 verbose(VERB_QUERY, "verify: wrong type covered"); 1781 *reason = "signature covers wrong type"; 1782 if(reason_bogus) 1783 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1784 return sec_status_bogus; 1785 } 1786 /* verify keytag and sig algo (possibly again) */ 1787 if((int)sig[2+2] != dnskey_get_algo(dnskey, dnskey_idx)) { 1788 verbose(VERB_QUERY, "verify: wrong algorithm"); 1789 *reason = "signature has wrong algorithm"; 1790 if(reason_bogus) 1791 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1792 return sec_status_bogus; 1793 } 1794 ktag = htons(dnskey_calc_keytag(dnskey, dnskey_idx)); 1795 if(memcmp(sig+2+16, &ktag, 2) != 0) { 1796 verbose(VERB_QUERY, "verify: wrong keytag"); 1797 *reason = "signature has wrong keytag"; 1798 if(reason_bogus) 1799 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1800 return sec_status_bogus; 1801 } 1802 1803 /* verify labels is in a valid range */ 1804 if((int)sig[2+3] > dname_signame_label_count(rrset->rk.dname)) { 1805 verbose(VERB_QUERY, "verify: labelcount out of range"); 1806 *reason = "signature labelcount out of range"; 1807 if(reason_bogus) 1808 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1809 return sec_status_bogus; 1810 } 1811 if((int)sig[2+3] < dname_signame_label_count(signer)) { 1812 verbose(VERB_QUERY, "verify: RRSIG label count too low for signer"); 1813 *reason = "signature labelcount lower than signature signer"; 1814 if(reason_bogus) 1815 *reason_bogus = LDNS_EDE_DNSSEC_BOGUS; 1816 return sec_status_bogus; 1817 } 1818 1819 /* original ttl, always ok */ 1820 1821 if(!*buf_canon) { 1822 /* create rrset canonical format in buffer, ready for 1823 * signature */ 1824 if(!rrset_canonical(region, buf, rrset, sig+2, 1825 18 + signer_len, sortree, section, qstate)) { 1826 log_err("verify: failed due to alloc error"); 1827 return sec_status_unchecked; 1828 } 1829 *buf_canon = 1; 1830 } 1831 1832 /* check that dnskey is available */ 1833 dnskey_get_pubkey(dnskey, dnskey_idx, &key, &keylen); 1834 if(!key) { 1835 verbose(VERB_QUERY, "verify: short DNSKEY RR"); 1836 return sec_status_unchecked; 1837 } 1838 1839 /* verify */ 1840 sec = verify_canonrrset(buf, (int)sig[2+2], 1841 sigblock, sigblock_len, key, keylen, reason); 1842 1843 /* count validation operation */ 1844 if(qstate && qstate->env && qstate->env->mesh) 1845 qstate->env->mesh->val_ops++; 1846 1847 if(sec == sec_status_secure) { 1848 /* check if TTL is too high - reduce if so */ 1849 adjust_ttl(ve, now, rrset, sig+2+4, sig+2+8, sig+2+12); 1850 1851 /* verify inception, expiration dates 1852 * Do this last so that if you ignore expired-sigs the 1853 * rest is sure to be OK. */ 1854 if(!check_dates(ve, now, sig+2+8, sig+2+12, 1855 reason, reason_bogus)) { 1856 return sec_status_bogus; 1857 } 1858 } 1859 1860 return sec; 1861 } 1862
Indexes created Sat Oct 03 00:25:10 UTC 2026