msgparse.c revision 361435
1/* 2 * util/data/msgparse.c - parse wireformat DNS messages. 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 * \file 37 * Routines for message parsing a packet buffer to a descriptive structure. 38 */ 39#include "config.h" 40#include "util/data/msgparse.h" 41#include "util/data/msgreply.h" 42#include "util/data/dname.h" 43#include "util/data/packed_rrset.h" 44#include "util/storage/lookup3.h" 45#include "util/regional.h" 46#include "sldns/rrdef.h" 47#include "sldns/sbuffer.h" 48#include "sldns/parseutil.h" 49#include "sldns/wire2str.h" 50 51/** smart comparison of (compressed, valid) dnames from packet */ 52static int 53smart_compare(sldns_buffer* pkt, uint8_t* dnow, 54 uint8_t* dprfirst, uint8_t* dprlast) 55{ 56 if(LABEL_IS_PTR(*dnow)) { 57 /* ptr points to a previous dname */ 58 uint8_t* p; 59 if((size_t)PTR_OFFSET(dnow[0], dnow[1]) 60 >= sldns_buffer_limit(pkt)) 61 return -1; 62 p = sldns_buffer_at(pkt, PTR_OFFSET(dnow[0], dnow[1])); 63 if( p == dprfirst || p == dprlast ) 64 return 0; 65 /* prev dname is also a ptr, both ptrs are the same. */ 66 if(LABEL_IS_PTR(*dprlast) && 67 dprlast[0] == dnow[0] && dprlast[1] == dnow[1]) 68 return 0; 69 } 70 return dname_pkt_compare(pkt, dnow, dprlast); 71} 72 73/** 74 * Allocate new rrset in region, fill with data. 75 */ 76static struct rrset_parse* 77new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen, 78 uint16_t type, uint16_t dclass, hashvalue_type hash, 79 uint32_t rrset_flags, sldns_pkt_section section, 80 struct regional* region) 81{ 82 struct rrset_parse* p = regional_alloc(region, sizeof(*p)); 83 if(!p) return NULL; 84 p->rrset_bucket_next = msg->hashtable[hash & (PARSE_TABLE_SIZE-1)]; 85 msg->hashtable[hash & (PARSE_TABLE_SIZE-1)] = p; 86 p->rrset_all_next = 0; 87 if(msg->rrset_last) 88 msg->rrset_last->rrset_all_next = p; 89 else msg->rrset_first = p; 90 msg->rrset_last = p; 91 p->hash = hash; 92 p->section = section; 93 p->dname = dname; 94 p->dname_len = dnamelen; 95 p->type = type; 96 p->rrset_class = dclass; 97 p->flags = rrset_flags; 98 p->rr_count = 0; 99 p->size = 0; 100 p->rr_first = 0; 101 p->rr_last = 0; 102 p->rrsig_count = 0; 103 p->rrsig_first = 0; 104 p->rrsig_last = 0; 105 return p; 106} 107 108/** See if next rrset is nsec at zone apex */ 109static int 110nsec_at_apex(sldns_buffer* pkt) 111{ 112 /* we are at ttl position in packet. */ 113 size_t pos = sldns_buffer_position(pkt); 114 uint16_t rdatalen; 115 if(sldns_buffer_remaining(pkt) < 7) /* ttl+len+root */ 116 return 0; /* eek! */ 117 sldns_buffer_skip(pkt, 4); /* ttl */; 118 rdatalen = sldns_buffer_read_u16(pkt); 119 if(sldns_buffer_remaining(pkt) < rdatalen) { 120 sldns_buffer_set_position(pkt, pos); 121 return 0; /* parse error happens later */ 122 } 123 /* must validate the nsec next domain name format */ 124 if(pkt_dname_len(pkt) == 0) { 125 sldns_buffer_set_position(pkt, pos); 126 return 0; /* parse error */ 127 } 128 129 /* see if SOA bit is set. */ 130 if(sldns_buffer_position(pkt) < pos+4+rdatalen) { 131 /* nsec type bitmap contains items */ 132 uint8_t win, blen, bits; 133 /* need: windownum, bitmap len, firstbyte */ 134 if(sldns_buffer_position(pkt)+3 > pos+4+rdatalen) { 135 sldns_buffer_set_position(pkt, pos); 136 return 0; /* malformed nsec */ 137 } 138 win = sldns_buffer_read_u8(pkt); 139 blen = sldns_buffer_read_u8(pkt); 140 bits = sldns_buffer_read_u8(pkt); 141 /* 0window always first window. bitlen >=1 or parse 142 error really. bit 0x2 is SOA. */ 143 if(win == 0 && blen >= 1 && (bits & 0x02)) { 144 sldns_buffer_set_position(pkt, pos); 145 return 1; 146 } 147 } 148 149 sldns_buffer_set_position(pkt, pos); 150 return 0; 151} 152 153/** Calculate rrset flags */ 154static uint32_t 155pkt_rrset_flags(sldns_buffer* pkt, uint16_t type, sldns_pkt_section sec) 156{ 157 uint32_t f = 0; 158 if(type == LDNS_RR_TYPE_NSEC && nsec_at_apex(pkt)) { 159 f |= PACKED_RRSET_NSEC_AT_APEX; 160 } else if(type == LDNS_RR_TYPE_SOA && sec == LDNS_SECTION_AUTHORITY) { 161 f |= PACKED_RRSET_SOA_NEG; 162 } 163 return f; 164} 165 166hashvalue_type 167pkt_hash_rrset(sldns_buffer* pkt, uint8_t* dname, uint16_t type, 168 uint16_t dclass, uint32_t rrset_flags) 169{ 170 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 171 /* this routine handles compressed names */ 172 hashvalue_type h = 0xab; 173 h = dname_pkt_hash(pkt, dname, h); 174 h = hashlittle(&type, sizeof(type), h); /* host order */ 175 h = hashlittle(&dclass, sizeof(dclass), h); /* netw order */ 176 h = hashlittle(&rrset_flags, sizeof(uint32_t), h); 177 return h; 178} 179 180/** create partial dname hash for rrset hash */ 181static hashvalue_type 182pkt_hash_rrset_first(sldns_buffer* pkt, uint8_t* dname) 183{ 184 /* works together with pkt_hash_rrset_rest */ 185 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 186 /* this routine handles compressed names */ 187 hashvalue_type h = 0xab; 188 h = dname_pkt_hash(pkt, dname, h); 189 return h; 190} 191 192/** create a rrset hash from a partial dname hash */ 193static hashvalue_type 194pkt_hash_rrset_rest(hashvalue_type dname_h, uint16_t type, uint16_t dclass, 195 uint32_t rrset_flags) 196{ 197 /* works together with pkt_hash_rrset_first */ 198 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 199 hashvalue_type h; 200 h = hashlittle(&type, sizeof(type), dname_h); /* host order */ 201 h = hashlittle(&dclass, sizeof(dclass), h); /* netw order */ 202 h = hashlittle(&rrset_flags, sizeof(uint32_t), h); 203 return h; 204} 205 206/** compare rrset_parse with data */ 207static int 208rrset_parse_equals(struct rrset_parse* p, sldns_buffer* pkt, hashvalue_type h, 209 uint32_t rrset_flags, uint8_t* dname, size_t dnamelen, 210 uint16_t type, uint16_t dclass) 211{ 212 if(p->hash == h && p->dname_len == dnamelen && p->type == type && 213 p->rrset_class == dclass && p->flags == rrset_flags && 214 dname_pkt_compare(pkt, dname, p->dname) == 0) 215 return 1; 216 return 0; 217} 218 219 220struct rrset_parse* 221msgparse_hashtable_lookup(struct msg_parse* msg, sldns_buffer* pkt, 222 hashvalue_type h, uint32_t rrset_flags, uint8_t* dname, 223 size_t dnamelen, uint16_t type, uint16_t dclass) 224{ 225 struct rrset_parse* p = msg->hashtable[h & (PARSE_TABLE_SIZE-1)]; 226 while(p) { 227 if(rrset_parse_equals(p, pkt, h, rrset_flags, dname, dnamelen, 228 type, dclass)) 229 return p; 230 p = p->rrset_bucket_next; 231 } 232 return NULL; 233} 234 235/** return type networkformat that rrsig in packet covers */ 236static int 237pkt_rrsig_covered(sldns_buffer* pkt, uint8_t* here, uint16_t* type) 238{ 239 size_t pos = sldns_buffer_position(pkt); 240 sldns_buffer_set_position(pkt, (size_t)(here-sldns_buffer_begin(pkt))); 241 /* ttl + len + size of small rrsig(rootlabel, no signature) */ 242 if(sldns_buffer_remaining(pkt) < 4+2+19) 243 return 0; 244 sldns_buffer_skip(pkt, 4); /* ttl */ 245 if(sldns_buffer_read_u16(pkt) < 19) /* too short */ { 246 sldns_buffer_set_position(pkt, pos); 247 return 0; 248 } 249 *type = sldns_buffer_read_u16(pkt); 250 sldns_buffer_set_position(pkt, pos); 251 return 1; 252} 253 254/** true if covered type equals prevtype */ 255static int 256pkt_rrsig_covered_equals(sldns_buffer* pkt, uint8_t* here, uint16_t type) 257{ 258 uint16_t t; 259 if(pkt_rrsig_covered(pkt, here, &t) && t == type) 260 return 1; 261 return 0; 262} 263 264void 265msgparse_bucket_remove(struct msg_parse* msg, struct rrset_parse* rrset) 266{ 267 struct rrset_parse** p; 268 p = &msg->hashtable[ rrset->hash & (PARSE_TABLE_SIZE-1) ]; 269 while(*p) { 270 if(*p == rrset) { 271 *p = rrset->rrset_bucket_next; 272 return; 273 } 274 p = &( (*p)->rrset_bucket_next ); 275 } 276} 277 278/** change section of rrset from previous to current section */ 279static void 280change_section(struct msg_parse* msg, struct rrset_parse* rrset, 281 sldns_pkt_section section) 282{ 283 struct rrset_parse *p, *prev; 284 /* remove from list */ 285 if(section == rrset->section) 286 return; 287 p = msg->rrset_first; 288 prev = 0; 289 while(p) { 290 if(p == rrset) { 291 if(prev) prev->rrset_all_next = p->rrset_all_next; 292 else msg->rrset_first = p->rrset_all_next; 293 if(msg->rrset_last == rrset) 294 msg->rrset_last = prev; 295 break; 296 } 297 prev = p; 298 p = p->rrset_all_next; 299 } 300 /* remove from count */ 301 switch(rrset->section) { 302 case LDNS_SECTION_ANSWER: msg->an_rrsets--; break; 303 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets--; break; 304 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets--; break; 305 default: log_assert(0); 306 } 307 /* insert at end of list */ 308 rrset->rrset_all_next = 0; 309 if(msg->rrset_last) 310 msg->rrset_last->rrset_all_next = rrset; 311 else msg->rrset_first = rrset; 312 msg->rrset_last = rrset; 313 /* up count of new section */ 314 switch(section) { 315 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets++; break; 316 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets++; break; 317 default: log_assert(0); 318 } 319 rrset->section = section; 320} 321 322/** see if rrset of type RRSIG contains sig over given type */ 323static int 324rrset_has_sigover(sldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type, 325 int* hasother) 326{ 327 int res = 0; 328 struct rr_parse* rr = rrset->rr_first; 329 log_assert( rrset->type == LDNS_RR_TYPE_RRSIG ); 330 while(rr) { 331 if(pkt_rrsig_covered_equals(pkt, rr->ttl_data, type)) 332 res = 1; 333 else *hasother = 1; 334 rr = rr->next; 335 } 336 return res; 337} 338 339/** move rrsigs from sigset to dataset */ 340static int 341moveover_rrsigs(sldns_buffer* pkt, struct regional* region, 342 struct rrset_parse* sigset, struct rrset_parse* dataset, int duplicate) 343{ 344 struct rr_parse* sig = sigset->rr_first; 345 struct rr_parse* prev = NULL; 346 struct rr_parse* insert; 347 struct rr_parse* nextsig; 348 while(sig) { 349 nextsig = sig->next; 350 if(pkt_rrsig_covered_equals(pkt, sig->ttl_data, 351 dataset->type)) { 352 if(duplicate) { 353 /* new */ 354 insert = (struct rr_parse*)regional_alloc( 355 region, sizeof(struct rr_parse)); 356 if(!insert) return 0; 357 insert->outside_packet = 0; 358 insert->ttl_data = sig->ttl_data; 359 insert->size = sig->size; 360 /* prev not used */ 361 } else { 362 /* remove from sigset */ 363 if(prev) prev->next = sig->next; 364 else sigset->rr_first = sig->next; 365 if(sigset->rr_last == sig) 366 sigset->rr_last = prev; 367 sigset->rr_count--; 368 sigset->size -= sig->size; 369 insert = sig; 370 /* prev not changed */ 371 } 372 /* add to dataset */ 373 dataset->rrsig_count++; 374 insert->next = 0; 375 if(dataset->rrsig_last) 376 dataset->rrsig_last->next = insert; 377 else dataset->rrsig_first = insert; 378 dataset->rrsig_last = insert; 379 dataset->size += insert->size; 380 } else { 381 prev = sig; 382 } 383 sig = nextsig; 384 } 385 return 1; 386} 387 388/** change an rrsig rrset for use as data rrset */ 389static struct rrset_parse* 390change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg, 391 sldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags, 392 int hasother, sldns_pkt_section section, struct regional* region) 393{ 394 struct rrset_parse* dataset = sigset; 395 hashvalue_type hash = pkt_hash_rrset(pkt, sigset->dname, datatype, 396 sigset->rrset_class, rrset_flags); 397 log_assert( sigset->type == LDNS_RR_TYPE_RRSIG ); 398 log_assert( datatype != LDNS_RR_TYPE_RRSIG ); 399 if(hasother) { 400 /* need to make new rrset to hold data type */ 401 dataset = new_rrset(msg, sigset->dname, sigset->dname_len, 402 datatype, sigset->rrset_class, hash, rrset_flags, 403 section, region); 404 if(!dataset) 405 return NULL; 406 switch(section) { 407 case LDNS_SECTION_ANSWER: msg->an_rrsets++; break; 408 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets++; break; 409 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets++; break; 410 default: log_assert(0); 411 } 412 if(!moveover_rrsigs(pkt, region, sigset, dataset, 413 msg->qtype == LDNS_RR_TYPE_RRSIG || 414 (msg->qtype == LDNS_RR_TYPE_ANY && 415 section != LDNS_SECTION_ANSWER) )) 416 return NULL; 417 return dataset; 418 } 419 /* changeover the type of the rrset to data set */ 420 msgparse_bucket_remove(msg, dataset); 421 /* insert into new hash bucket */ 422 dataset->rrset_bucket_next = msg->hashtable[hash&(PARSE_TABLE_SIZE-1)]; 423 msg->hashtable[hash&(PARSE_TABLE_SIZE-1)] = dataset; 424 dataset->hash = hash; 425 /* use section of data item for result */ 426 change_section(msg, dataset, section); 427 dataset->type = datatype; 428 dataset->flags = rrset_flags; 429 dataset->rrsig_count += dataset->rr_count; 430 dataset->rr_count = 0; 431 /* move sigs to end of siglist */ 432 if(dataset->rrsig_last) 433 dataset->rrsig_last->next = dataset->rr_first; 434 else dataset->rrsig_first = dataset->rr_first; 435 dataset->rrsig_last = dataset->rr_last; 436 dataset->rr_first = 0; 437 dataset->rr_last = 0; 438 return dataset; 439} 440 441/** Find rrset. If equal to previous it is fast. hash if not so. 442 * @param msg: the message with hash table. 443 * @param pkt: the packet in wireformat (needed for compression ptrs). 444 * @param dname: pointer to start of dname (compressed) in packet. 445 * @param dnamelen: uncompressed wirefmt length of dname. 446 * @param type: type of current rr. 447 * @param dclass: class of current rr. 448 * @param hash: hash value is returned if the rrset could not be found. 449 * @param rrset_flags: is returned if the rrset could not be found. 450 * @param prev_dname_first: dname of last seen RR. First seen dname. 451 * @param prev_dname_last: dname of last seen RR. Last seen dname. 452 * @param prev_dnamelen: dname len of last seen RR. 453 * @param prev_type: type of last seen RR. 454 * @param prev_dclass: class of last seen RR. 455 * @param rrset_prev: last seen RRset. 456 * @param section: the current section in the packet. 457 * @param region: used to allocate temporary parsing data. 458 * @return 0 on out of memory. 459 */ 460static int 461find_rrset(struct msg_parse* msg, sldns_buffer* pkt, uint8_t* dname, 462 size_t dnamelen, uint16_t type, uint16_t dclass, hashvalue_type* hash, 463 uint32_t* rrset_flags, 464 uint8_t** prev_dname_first, uint8_t** prev_dname_last, 465 size_t* prev_dnamelen, uint16_t* prev_type, 466 uint16_t* prev_dclass, struct rrset_parse** rrset_prev, 467 sldns_pkt_section section, struct regional* region) 468{ 469 hashvalue_type dname_h = pkt_hash_rrset_first(pkt, dname); 470 uint16_t covtype; 471 if(*rrset_prev) { 472 /* check if equal to previous item */ 473 if(type == *prev_type && dclass == *prev_dclass && 474 dnamelen == *prev_dnamelen && 475 smart_compare(pkt, dname, *prev_dname_first, 476 *prev_dname_last) == 0 && 477 type != LDNS_RR_TYPE_RRSIG) { 478 /* same as previous */ 479 *prev_dname_last = dname; 480 return 1; 481 } 482 /* check if rrsig over previous item */ 483 if(type == LDNS_RR_TYPE_RRSIG && dclass == *prev_dclass && 484 pkt_rrsig_covered_equals(pkt, sldns_buffer_current(pkt), 485 *prev_type) && 486 smart_compare(pkt, dname, *prev_dname_first, 487 *prev_dname_last) == 0) { 488 /* covers previous */ 489 *prev_dname_last = dname; 490 return 1; 491 } 492 } 493 /* find by hashing and lookup in hashtable */ 494 *rrset_flags = pkt_rrset_flags(pkt, type, section); 495 496 /* if rrsig - try to lookup matching data set first */ 497 if(type == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt, 498 sldns_buffer_current(pkt), &covtype)) { 499 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 500 *rrset_flags); 501 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, 502 *rrset_flags, dname, dnamelen, covtype, dclass); 503 if(!*rrset_prev && covtype == LDNS_RR_TYPE_NSEC) { 504 /* if NSEC try with NSEC apex bit twiddled */ 505 *rrset_flags ^= PACKED_RRSET_NSEC_AT_APEX; 506 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 507 *rrset_flags); 508 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, 509 *hash, *rrset_flags, dname, dnamelen, covtype, 510 dclass); 511 if(!*rrset_prev) /* untwiddle if not found */ 512 *rrset_flags ^= PACKED_RRSET_NSEC_AT_APEX; 513 } 514 if(!*rrset_prev && covtype == LDNS_RR_TYPE_SOA) { 515 /* if SOA try with SOA neg flag twiddled */ 516 *rrset_flags ^= PACKED_RRSET_SOA_NEG; 517 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 518 *rrset_flags); 519 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, 520 *hash, *rrset_flags, dname, dnamelen, covtype, 521 dclass); 522 if(!*rrset_prev) /* untwiddle if not found */ 523 *rrset_flags ^= PACKED_RRSET_SOA_NEG; 524 } 525 if(*rrset_prev) { 526 *prev_dname_first = (*rrset_prev)->dname; 527 *prev_dname_last = dname; 528 *prev_dnamelen = dnamelen; 529 *prev_type = covtype; 530 *prev_dclass = dclass; 531 return 1; 532 } 533 } 534 if(type != LDNS_RR_TYPE_RRSIG) { 535 int hasother = 0; 536 /* find matching rrsig */ 537 *hash = pkt_hash_rrset_rest(dname_h, LDNS_RR_TYPE_RRSIG, 538 dclass, 0); 539 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, 540 0, dname, dnamelen, LDNS_RR_TYPE_RRSIG, 541 dclass); 542 if(*rrset_prev && rrset_has_sigover(pkt, *rrset_prev, type, 543 &hasother)) { 544 /* yes! */ 545 *prev_dname_first = (*rrset_prev)->dname; 546 *prev_dname_last = dname; 547 *prev_dnamelen = dnamelen; 548 *prev_type = type; 549 *prev_dclass = dclass; 550 *rrset_prev = change_rrsig_rrset(*rrset_prev, msg, 551 pkt, type, *rrset_flags, hasother, section, 552 region); 553 if(!*rrset_prev) return 0; 554 return 1; 555 } 556 } 557 558 *hash = pkt_hash_rrset_rest(dname_h, type, dclass, *rrset_flags); 559 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, *rrset_flags, 560 dname, dnamelen, type, dclass); 561 if(*rrset_prev) 562 *prev_dname_first = (*rrset_prev)->dname; 563 else *prev_dname_first = dname; 564 *prev_dname_last = dname; 565 *prev_dnamelen = dnamelen; 566 *prev_type = type; 567 *prev_dclass = dclass; 568 return 1; 569} 570 571/** 572 * Parse query section. 573 * @param pkt: packet, position at call must be at start of query section. 574 * at end position is after query section. 575 * @param msg: store results here. 576 * @return: 0 if OK, or rcode on error. 577 */ 578static int 579parse_query_section(sldns_buffer* pkt, struct msg_parse* msg) 580{ 581 if(msg->qdcount == 0) 582 return 0; 583 if(msg->qdcount > 1) 584 return LDNS_RCODE_FORMERR; 585 log_assert(msg->qdcount == 1); 586 if(sldns_buffer_remaining(pkt) <= 0) 587 return LDNS_RCODE_FORMERR; 588 msg->qname = sldns_buffer_current(pkt); 589 if((msg->qname_len = pkt_dname_len(pkt)) == 0) 590 return LDNS_RCODE_FORMERR; 591 if(sldns_buffer_remaining(pkt) < sizeof(uint16_t)*2) 592 return LDNS_RCODE_FORMERR; 593 msg->qtype = sldns_buffer_read_u16(pkt); 594 msg->qclass = sldns_buffer_read_u16(pkt); 595 return 0; 596} 597 598size_t 599get_rdf_size(sldns_rdf_type rdf) 600{ 601 switch(rdf) { 602 case LDNS_RDF_TYPE_CLASS: 603 case LDNS_RDF_TYPE_ALG: 604 case LDNS_RDF_TYPE_INT8: 605 return 1; 606 break; 607 case LDNS_RDF_TYPE_INT16: 608 case LDNS_RDF_TYPE_TYPE: 609 case LDNS_RDF_TYPE_CERT_ALG: 610 return 2; 611 break; 612 case LDNS_RDF_TYPE_INT32: 613 case LDNS_RDF_TYPE_TIME: 614 case LDNS_RDF_TYPE_A: 615 case LDNS_RDF_TYPE_PERIOD: 616 return 4; 617 break; 618 case LDNS_RDF_TYPE_TSIGTIME: 619 return 6; 620 break; 621 case LDNS_RDF_TYPE_AAAA: 622 return 16; 623 break; 624 default: 625 log_assert(0); /* add type above */ 626 /* only types that appear before a domain * 627 * name are needed. rest is simply copied. */ 628 } 629 return 0; 630} 631 632/** calculate the size of one rr */ 633static int 634calc_size(sldns_buffer* pkt, uint16_t type, struct rr_parse* rr) 635{ 636 const sldns_rr_descriptor* desc; 637 uint16_t pkt_len; /* length of rr inside the packet */ 638 rr->size = sizeof(uint16_t); /* the rdatalen */ 639 sldns_buffer_skip(pkt, 4); /* skip ttl */ 640 pkt_len = sldns_buffer_read_u16(pkt); 641 if(sldns_buffer_remaining(pkt) < pkt_len) 642 return 0; 643 desc = sldns_rr_descript(type); 644 if(pkt_len > 0 && desc && desc->_dname_count > 0) { 645 int count = (int)desc->_dname_count; 646 int rdf = 0; 647 size_t len; 648 size_t oldpos; 649 /* skip first part. */ 650 while(pkt_len > 0 && count) { 651 switch(desc->_wireformat[rdf]) { 652 case LDNS_RDF_TYPE_DNAME: 653 /* decompress every domain name */ 654 oldpos = sldns_buffer_position(pkt); 655 if((len = pkt_dname_len(pkt)) == 0) 656 return 0; /* malformed dname */ 657 if(sldns_buffer_position(pkt)-oldpos > pkt_len) 658 return 0; /* dname exceeds rdata */ 659 pkt_len -= sldns_buffer_position(pkt)-oldpos; 660 rr->size += len; 661 count--; 662 len = 0; 663 break; 664 case LDNS_RDF_TYPE_STR: 665 if(pkt_len < 1) { 666 /* NOTREACHED, due to 'while(>0)' */ 667 return 0; /* len byte exceeds rdata */ 668 } 669 len = sldns_buffer_current(pkt)[0] + 1; 670 break; 671 default: 672 len = get_rdf_size(desc->_wireformat[rdf]); 673 } 674 if(len) { 675 if(pkt_len < len) 676 return 0; /* exceeds rdata */ 677 pkt_len -= len; 678 sldns_buffer_skip(pkt, (ssize_t)len); 679 rr->size += len; 680 } 681 rdf++; 682 } 683 } 684 /* remaining rdata */ 685 rr->size += pkt_len; 686 sldns_buffer_skip(pkt, (ssize_t)pkt_len); 687 return 1; 688} 689 690/** skip rr ttl and rdata */ 691static int 692skip_ttl_rdata(sldns_buffer* pkt) 693{ 694 uint16_t rdatalen; 695 if(sldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */ 696 return 0; 697 sldns_buffer_skip(pkt, 4); /* ttl */ 698 rdatalen = sldns_buffer_read_u16(pkt); 699 if(sldns_buffer_remaining(pkt) < rdatalen) 700 return 0; 701 sldns_buffer_skip(pkt, (ssize_t)rdatalen); 702 return 1; 703} 704 705/** see if RRSIG is a duplicate of another */ 706static int 707sig_is_double(sldns_buffer* pkt, struct rrset_parse* rrset, uint8_t* ttldata) 708{ 709 uint16_t rlen, siglen; 710 size_t pos = sldns_buffer_position(pkt); 711 struct rr_parse* sig; 712 if(sldns_buffer_remaining(pkt) < 6) 713 return 0; 714 sldns_buffer_skip(pkt, 4); /* ttl */ 715 rlen = sldns_buffer_read_u16(pkt); 716 if(sldns_buffer_remaining(pkt) < rlen) { 717 sldns_buffer_set_position(pkt, pos); 718 return 0; 719 } 720 sldns_buffer_set_position(pkt, pos); 721 722 sig = rrset->rrsig_first; 723 while(sig) { 724 /* check if rdatalen is same */ 725 memmove(&siglen, sig->ttl_data+4, sizeof(siglen)); 726 siglen = ntohs(siglen); 727 /* checks if data in packet is exactly the same, this means 728 * also dname in rdata is the same, but rrsig is not allowed 729 * to have compressed dnames anyway. If it is compressed anyway 730 * it will lead to duplicate rrs for qtype=RRSIG. (or ANY). 731 * 732 * Cannot use sig->size because size of the other one is not 733 * calculated yet. 734 */ 735 if(siglen == rlen) { 736 if(siglen>0 && memcmp(sig->ttl_data+6, ttldata+6, 737 siglen) == 0) { 738 /* same! */ 739 return 1; 740 } 741 } 742 sig = sig->next; 743 } 744 return 0; 745} 746 747/** Add rr (from packet here) to rrset, skips rr */ 748static int 749add_rr_to_rrset(struct rrset_parse* rrset, sldns_buffer* pkt, 750 struct msg_parse* msg, struct regional* region, 751 sldns_pkt_section section, uint16_t type) 752{ 753 struct rr_parse* rr; 754 /* check section of rrset. */ 755 if(rrset->section != section && type != LDNS_RR_TYPE_RRSIG && 756 rrset->type != LDNS_RR_TYPE_RRSIG) { 757 /* silently drop it - we drop the last part, since 758 * trust in rr data depends on the section it is in. 759 * the less trustworthy part is discarded. 760 * also the last part is more likely to be incomplete. 761 * RFC 2181: must put RRset only once in response. */ 762 /* 763 verbose(VERB_QUERY, "Packet contains rrset data in " 764 "multiple sections, dropped last part."); 765 log_buf(VERB_QUERY, "packet was", pkt); 766 */ 767 /* forwards */ 768 if(!skip_ttl_rdata(pkt)) 769 return LDNS_RCODE_FORMERR; 770 return 0; 771 } 772 773 if( (msg->qtype == LDNS_RR_TYPE_RRSIG || 774 msg->qtype == LDNS_RR_TYPE_ANY) 775 && sig_is_double(pkt, rrset, sldns_buffer_current(pkt))) { 776 if(!skip_ttl_rdata(pkt)) 777 return LDNS_RCODE_FORMERR; 778 return 0; 779 } 780 781 /* create rr */ 782 if(!(rr = (struct rr_parse*)regional_alloc(region, sizeof(*rr)))) 783 return LDNS_RCODE_SERVFAIL; 784 rr->outside_packet = 0; 785 rr->ttl_data = sldns_buffer_current(pkt); 786 rr->next = 0; 787 if(type == LDNS_RR_TYPE_RRSIG && rrset->type != LDNS_RR_TYPE_RRSIG) { 788 if(rrset->rrsig_last) 789 rrset->rrsig_last->next = rr; 790 else rrset->rrsig_first = rr; 791 rrset->rrsig_last = rr; 792 rrset->rrsig_count++; 793 } else { 794 if(rrset->rr_last) 795 rrset->rr_last->next = rr; 796 else rrset->rr_first = rr; 797 rrset->rr_last = rr; 798 rrset->rr_count++; 799 } 800 801 /* calc decompressed size */ 802 if(!calc_size(pkt, type, rr)) 803 return LDNS_RCODE_FORMERR; 804 rrset->size += rr->size; 805 806 return 0; 807} 808 809/** 810 * Parse packet RR section, for answer, authority and additional sections. 811 * @param pkt: packet, position at call must be at start of section. 812 * at end position is after section. 813 * @param msg: store results here. 814 * @param region: how to alloc results. 815 * @param section: section enum. 816 * @param num_rrs: how many rrs are in the section. 817 * @param num_rrsets: returns number of rrsets in the section. 818 * @return: 0 if OK, or rcode on error. 819 */ 820static int 821parse_section(sldns_buffer* pkt, struct msg_parse* msg, 822 struct regional* region, sldns_pkt_section section, 823 uint16_t num_rrs, size_t* num_rrsets) 824{ 825 uint16_t i; 826 uint8_t* dname, *prev_dname_f = NULL, *prev_dname_l = NULL; 827 size_t dnamelen, prev_dnamelen = 0; 828 uint16_t type, prev_type = 0; 829 uint16_t dclass, prev_dclass = 0; 830 uint32_t rrset_flags = 0; 831 hashvalue_type hash = 0; 832 struct rrset_parse* rrset = NULL; 833 int r; 834 835 if(num_rrs == 0) 836 return 0; 837 if(sldns_buffer_remaining(pkt) <= 0) 838 return LDNS_RCODE_FORMERR; 839 for(i=0; i<num_rrs; i++) { 840 /* parse this RR. */ 841 dname = sldns_buffer_current(pkt); 842 if((dnamelen = pkt_dname_len(pkt)) == 0) 843 return LDNS_RCODE_FORMERR; 844 if(sldns_buffer_remaining(pkt) < 10) /* type, class, ttl, len */ 845 return LDNS_RCODE_FORMERR; 846 type = sldns_buffer_read_u16(pkt); 847 sldns_buffer_read(pkt, &dclass, sizeof(dclass)); 848 849 if(0) { /* debug show what is being parsed. */ 850 if(type == LDNS_RR_TYPE_RRSIG) { 851 uint16_t t; 852 if(pkt_rrsig_covered(pkt, 853 sldns_buffer_current(pkt), &t)) 854 fprintf(stderr, "parse of %s(%d) [%s(%d)]", 855 sldns_rr_descript(type)? 856 sldns_rr_descript(type)->_name: "??", 857 (int)type, 858 sldns_rr_descript(t)? 859 sldns_rr_descript(t)->_name: "??", 860 (int)t); 861 } else 862 fprintf(stderr, "parse of %s(%d)", 863 sldns_rr_descript(type)? 864 sldns_rr_descript(type)->_name: "??", 865 (int)type); 866 fprintf(stderr, " %s(%d) ", 867 sldns_lookup_by_id(sldns_rr_classes, 868 (int)ntohs(dclass))?sldns_lookup_by_id( 869 sldns_rr_classes, (int)ntohs(dclass))->name: 870 "??", (int)ntohs(dclass)); 871 dname_print(stderr, pkt, dname); 872 fprintf(stderr, "\n"); 873 } 874 875 /* see if it is part of an existing RR set */ 876 if(!find_rrset(msg, pkt, dname, dnamelen, type, dclass, &hash, 877 &rrset_flags, &prev_dname_f, &prev_dname_l, 878 &prev_dnamelen, &prev_type, &prev_dclass, &rrset, 879 section, region)) 880 return LDNS_RCODE_SERVFAIL; 881 if(!rrset) { 882 /* it is a new RR set. hash&flags already calculated.*/ 883 (*num_rrsets)++; 884 rrset = new_rrset(msg, dname, dnamelen, type, dclass, 885 hash, rrset_flags, section, region); 886 if(!rrset) 887 return LDNS_RCODE_SERVFAIL; 888 } 889 else if(0) { 890 fprintf(stderr, "is part of existing: "); 891 dname_print(stderr, pkt, rrset->dname); 892 fprintf(stderr, " type %s(%d)\n", 893 sldns_rr_descript(rrset->type)? 894 sldns_rr_descript(rrset->type)->_name: "??", 895 (int)rrset->type); 896 } 897 /* add to rrset. */ 898 if((r=add_rr_to_rrset(rrset, pkt, msg, region, section, 899 type)) != 0) 900 return r; 901 } 902 return 0; 903} 904 905int 906parse_packet(sldns_buffer* pkt, struct msg_parse* msg, struct regional* region) 907{ 908 int ret; 909 if(sldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE) 910 return LDNS_RCODE_FORMERR; 911 /* read the header */ 912 sldns_buffer_read(pkt, &msg->id, sizeof(uint16_t)); 913 msg->flags = sldns_buffer_read_u16(pkt); 914 msg->qdcount = sldns_buffer_read_u16(pkt); 915 msg->ancount = sldns_buffer_read_u16(pkt); 916 msg->nscount = sldns_buffer_read_u16(pkt); 917 msg->arcount = sldns_buffer_read_u16(pkt); 918 if(msg->qdcount > 1) 919 return LDNS_RCODE_FORMERR; 920 if((ret = parse_query_section(pkt, msg)) != 0) 921 return ret; 922 if((ret = parse_section(pkt, msg, region, LDNS_SECTION_ANSWER, 923 msg->ancount, &msg->an_rrsets)) != 0) 924 return ret; 925 if((ret = parse_section(pkt, msg, region, LDNS_SECTION_AUTHORITY, 926 msg->nscount, &msg->ns_rrsets)) != 0) 927 return ret; 928 if(sldns_buffer_remaining(pkt) == 0 && msg->arcount == 1) { 929 /* BIND accepts leniently that an EDNS record is missing. 930 * so, we do too. */ 931 } else if((ret = parse_section(pkt, msg, region, 932 LDNS_SECTION_ADDITIONAL, msg->arcount, &msg->ar_rrsets)) != 0) 933 return ret; 934 /* if(sldns_buffer_remaining(pkt) > 0) { */ 935 /* there is spurious data at end of packet. ignore */ 936 /* } */ 937 msg->rrset_count = msg->an_rrsets + msg->ns_rrsets + msg->ar_rrsets; 938 return 0; 939} 940 941/** parse EDNS options from EDNS wireformat rdata */ 942static int 943parse_edns_options(uint8_t* rdata_ptr, size_t rdata_len, 944 struct edns_data* edns, struct regional* region) 945{ 946 /* while still more options, and have code+len to read */ 947 /* ignores partial content (i.e. rdata len 3) */ 948 while(rdata_len >= 4) { 949 uint16_t opt_code = sldns_read_uint16(rdata_ptr); 950 uint16_t opt_len = sldns_read_uint16(rdata_ptr+2); 951 rdata_ptr += 4; 952 rdata_len -= 4; 953 if(opt_len > rdata_len) 954 break; /* option code partial */ 955 if(!edns_opt_append(edns, region, opt_code, opt_len, 956 rdata_ptr)) { 957 log_err("out of memory"); 958 return 0; 959 } 960 rdata_ptr += opt_len; 961 rdata_len -= opt_len; 962 } 963 return 1; 964} 965 966int 967parse_extract_edns(struct msg_parse* msg, struct edns_data* edns, 968 struct regional* region) 969{ 970 struct rrset_parse* rrset = msg->rrset_first; 971 struct rrset_parse* prev = 0; 972 struct rrset_parse* found = 0; 973 struct rrset_parse* found_prev = 0; 974 size_t rdata_len; 975 uint8_t* rdata_ptr; 976 /* since the class encodes the UDP size, we cannot use hash table to 977 * find the EDNS OPT record. Scan the packet. */ 978 while(rrset) { 979 if(rrset->type == LDNS_RR_TYPE_OPT) { 980 /* only one OPT RR allowed. */ 981 if(found) return LDNS_RCODE_FORMERR; 982 /* found it! */ 983 found_prev = prev; 984 found = rrset; 985 } 986 prev = rrset; 987 rrset = rrset->rrset_all_next; 988 } 989 if(!found) { 990 memset(edns, 0, sizeof(*edns)); 991 edns->udp_size = 512; 992 return 0; 993 } 994 /* check the found RRset */ 995 /* most lenient check possible. ignore dname, use last opt */ 996 if(found->section != LDNS_SECTION_ADDITIONAL) 997 return LDNS_RCODE_FORMERR; 998 if(found->rr_count == 0) 999 return LDNS_RCODE_FORMERR; 1000 if(0) { /* strict checking of dname and RRcount */ 1001 if(found->dname_len != 1 || !found->dname 1002 || found->dname[0] != 0) return LDNS_RCODE_FORMERR; 1003 if(found->rr_count != 1) return LDNS_RCODE_FORMERR; 1004 } 1005 log_assert(found->rr_first && found->rr_last); 1006 1007 /* remove from packet */ 1008 if(found_prev) found_prev->rrset_all_next = found->rrset_all_next; 1009 else msg->rrset_first = found->rrset_all_next; 1010 if(found == msg->rrset_last) 1011 msg->rrset_last = found_prev; 1012 msg->arcount --; 1013 msg->ar_rrsets --; 1014 msg->rrset_count --; 1015 1016 /* take the data ! */ 1017 edns->edns_present = 1; 1018 edns->ext_rcode = found->rr_last->ttl_data[0]; 1019 edns->edns_version = found->rr_last->ttl_data[1]; 1020 edns->bits = sldns_read_uint16(&found->rr_last->ttl_data[2]); 1021 edns->udp_size = ntohs(found->rrset_class); 1022 edns->opt_list = NULL; 1023 1024 /* take the options */ 1025 rdata_len = found->rr_first->size-2; 1026 rdata_ptr = found->rr_first->ttl_data+6; 1027 if(!parse_edns_options(rdata_ptr, rdata_len, edns, region)) 1028 return 0; 1029 1030 /* ignore rrsigs */ 1031 1032 return 0; 1033} 1034 1035/** skip RR in packet */ 1036static int 1037skip_pkt_rr(sldns_buffer* pkt) 1038{ 1039 if(sldns_buffer_remaining(pkt) < 1) return 0; 1040 if(!pkt_dname_len(pkt)) 1041 return 0; 1042 if(sldns_buffer_remaining(pkt) < 4) return 0; 1043 sldns_buffer_skip(pkt, 4); /* type and class */ 1044 if(!skip_ttl_rdata(pkt)) 1045 return 0; 1046 return 1; 1047} 1048 1049/** skip RRs from packet */ 1050static int 1051skip_pkt_rrs(sldns_buffer* pkt, int num) 1052{ 1053 int i; 1054 for(i=0; i<num; i++) { 1055 if(!skip_pkt_rr(pkt)) 1056 return 0; 1057 } 1058 return 1; 1059} 1060 1061int 1062parse_edns_from_pkt(sldns_buffer* pkt, struct edns_data* edns, 1063 struct regional* region) 1064{ 1065 size_t rdata_len; 1066 uint8_t* rdata_ptr; 1067 log_assert(LDNS_QDCOUNT(sldns_buffer_begin(pkt)) == 1); 1068 memset(edns, 0, sizeof(*edns)); 1069 if(LDNS_ANCOUNT(sldns_buffer_begin(pkt)) != 0 || 1070 LDNS_NSCOUNT(sldns_buffer_begin(pkt)) != 0) { 1071 if(!skip_pkt_rrs(pkt, ((int)LDNS_ANCOUNT(sldns_buffer_begin(pkt)))+ 1072 ((int)LDNS_NSCOUNT(sldns_buffer_begin(pkt))))) 1073 return LDNS_RCODE_FORMERR; 1074 } 1075 /* check edns section is present */ 1076 if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) > 1) { 1077 return LDNS_RCODE_FORMERR; 1078 } 1079 if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) == 0) { 1080 edns->udp_size = 512; 1081 return 0; 1082 } 1083 /* domain name must be the root of length 1. */ 1084 if(pkt_dname_len(pkt) != 1) 1085 return LDNS_RCODE_FORMERR; 1086 if(sldns_buffer_remaining(pkt) < 10) /* type, class, ttl, rdatalen */ 1087 return LDNS_RCODE_FORMERR; 1088 if(sldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT) 1089 return LDNS_RCODE_FORMERR; 1090 edns->edns_present = 1; 1091 edns->udp_size = sldns_buffer_read_u16(pkt); /* class is udp size */ 1092 edns->ext_rcode = sldns_buffer_read_u8(pkt); /* ttl used for bits */ 1093 edns->edns_version = sldns_buffer_read_u8(pkt); 1094 edns->bits = sldns_buffer_read_u16(pkt); 1095 edns->opt_list = NULL; 1096 1097 /* take the options */ 1098 rdata_len = sldns_buffer_read_u16(pkt); 1099 if(sldns_buffer_remaining(pkt) < rdata_len) 1100 return LDNS_RCODE_FORMERR; 1101 rdata_ptr = sldns_buffer_current(pkt); 1102 if(!parse_edns_options(rdata_ptr, rdata_len, edns, region)) 1103 return LDNS_RCODE_SERVFAIL; 1104 1105 /* ignore rrsigs */ 1106 1107 return 0; 1108} 1109 1110void 1111log_edns_opt_list(enum verbosity_value level, const char* info_str, 1112 struct edns_option* list) 1113{ 1114 if(verbosity >= level && list) { 1115 char str[128], *s; 1116 size_t slen; 1117 verbose(level, "%s", info_str); 1118 while(list) { 1119 s = str; 1120 slen = sizeof(str); 1121 (void)sldns_wire2str_edns_option_print(&s, &slen, list->opt_code, 1122 list->opt_data, list->opt_len); 1123 verbose(level, " %s", str); 1124 list = list->next; 1125 } 1126 } 1127} 1128