contrib/unbound/validator/val_nsec.c

   1 /*
   2  * validator/val_nsec.c - validator NSEC denial of existence 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 NSEC checking, the different NSEC proofs
  41  * for denial of existence, and proofs for presence of types.
  42  */
  43 #include "config.h"
  44 #include "validator/val_nsec.h"
  45 #include "validator/val_utils.h"
  46 #include "util/data/msgreply.h"
  47 #include "util/data/dname.h"
  48 #include "util/net_help.h"
  49 #include "util/module.h"
  50 #include "services/cache/rrset.h"
  51
  52 /** get ttl of rrset */
  53 static uint32_t
  54 rrset_get_ttl(struct ub_packed_rrset_key* k)
  55 {
  56         struct packed_rrset_data* d = (struct packed_rrset_data*)k->entry.data;
  57         return d->ttl;
  58 }
  59
  60 int
  61 nsecbitmap_has_type_rdata(uint8_t* bitmap, size_t len, uint16_t type)
  62 {
  63         /* Check type present in NSEC typemap with bitmap arg */
  64         /* bitmasks for determining type-lowerbits presence */
  65         uint8_t masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
  66         uint8_t type_window = type>>8;
  67         uint8_t type_low = type&0xff;
  68         uint8_t win, winlen;
  69         /* read each of the type bitmap windows and see if the searched
  70          * type is amongst it */
  71         while(len > 0) {
  72                 if(len < 3) /* bad window, at least window# winlen bitmap */
  73                         return 0;
  74                 win = *bitmap++;
  75                 winlen = *bitmap++;
  76                 len -= 2;
  77                 if(len < winlen || winlen < 1 || winlen > 32)
  78                         return 0;       /* bad window length */
  79                 if(win == type_window) {
  80                         /* search window bitmap for the correct byte */
  81                         /* mybyte is 0 if we need the first byte */
  82                         size_t mybyte = type_low>>3;
  83                         if(winlen <= mybyte)
  84                                 return 0; /* window too short */
  85                         return (int)(bitmap[mybyte] & masks[type_low&0x7]);
  86                 } else {
  87                         /* not the window we are looking for */
  88                         bitmap += winlen;
  89                         len -= winlen;
  90                 }
  91         }
  92         /* end of bitmap reached, no type found */
  93         return 0;
  94 }
  95
  96 int
  97 nsec_has_type(struct ub_packed_rrset_key* nsec, uint16_t type)
  98 {
  99         struct packed_rrset_data* d = (struct packed_rrset_data*)nsec->
 100                 entry.data;
 101         size_t len;
 102         if(!d || d->count == 0 || d->rr_len[0] < 2+1)
 103                 return 0;
 104         len = dname_valid(d->rr_data[0]+2, d->rr_len[0]-2);
 105         if(!len)
 106                 return 0;
 107         return nsecbitmap_has_type_rdata(d->rr_data[0]+2+len,
 108                 d->rr_len[0]-2-len, type);
 109 }
 110
 111 /**
 112  * Get next owner name from nsec record
 113  * @param nsec: the nsec RRset.
 114  *      If there are multiple RRs, then this will only return one of them.
 115  * @param nm: the next name is returned.
 116  * @param ln: length of nm is returned.
 117  * @return false on a bad NSEC RR (too short, malformed dname).
 118  */
 119 static int
 120 nsec_get_next(struct ub_packed_rrset_key* nsec, uint8_t** nm, size_t* ln)
 121 {
 122         struct packed_rrset_data* d = (struct packed_rrset_data*)nsec->
 123                 entry.data;
 124         if(!d || d->count == 0 || d->rr_len[0] < 2+1) {
 125                 *nm = 0;
 126                 *ln = 0;
 127                 return 0;
 128         }
 129         *nm = d->rr_data[0]+2;
 130         *ln = dname_valid(*nm, d->rr_len[0]-2);
 131         if(!*ln) {
 132                 *nm = 0;
 133                 *ln = 0;
 134                 return 0;
 135         }
 136         return 1;
 137 }
 138
 139 /**
 140  * For an NSEC that matches the DS queried for, check absence of DS type.
 141  *
 142  * @param nsec: NSEC for proof, must be trusted.
 143  * @param qinfo: what is queried for.
 144  * @return if secure the nsec proves that no DS is present, or
 145  *      insecure if it proves it is not a delegation point.
 146  *      or bogus if something was wrong.
 147  */
 148 static enum sec_status
 149 val_nsec_proves_no_ds(struct ub_packed_rrset_key* nsec,
 150         struct query_info* qinfo)
 151 {
 152         log_assert(qinfo->qtype == LDNS_RR_TYPE_DS);
 153         log_assert(ntohs(nsec->rk.type) == LDNS_RR_TYPE_NSEC);
 154
 155         if(nsec_has_type(nsec, LDNS_RR_TYPE_SOA) && qinfo->qname_len != 1) {
 156                 /* SOA present means that this is the NSEC from the child,
 157                  * not the parent (so it is the wrong one). */
 158                 return sec_status_bogus;
 159         }
 160         if(nsec_has_type(nsec, LDNS_RR_TYPE_DS)) {
 161                 /* DS present means that there should have been a positive
 162                  * response to the DS query, so there is something wrong. */
 163                 return sec_status_bogus;
 164         }
 165
 166         if(!nsec_has_type(nsec, LDNS_RR_TYPE_NS)) {
 167                 /* If there is no NS at this point at all, then this
 168                  * doesn't prove anything one way or the other. */
 169                 return sec_status_insecure;
 170         }
 171         /* Otherwise, this proves no DS. */
 172         return sec_status_secure;
 173 }
 174
 175 /** check security status from cache or verify rrset, returns true if secure */
 176 static int
 177 nsec_verify_rrset(struct module_env* env, struct val_env* ve,
 178         struct ub_packed_rrset_key* nsec, struct key_entry_key* kkey,
 179         char** reason)
 180 {
 181         struct packed_rrset_data* d = (struct packed_rrset_data*)
 182                 nsec->entry.data;
 183         if(d->security == sec_status_secure)
 184                 return 1;
 185         rrset_check_sec_status(env->rrset_cache, nsec, *env->now);
 186         if(d->security == sec_status_secure)
 187                 return 1;
 188         d->security = val_verify_rrset_entry(env, ve, nsec, kkey, reason);
 189         if(d->security == sec_status_secure) {
 190                 rrset_update_sec_status(env->rrset_cache, nsec, *env->now);
 191                 return 1;
 192         }
 193         return 0;
 194 }
 195
 196 enum sec_status
 197 val_nsec_prove_nodata_dsreply(struct module_env* env, struct val_env* ve,
 198         struct query_info* qinfo, struct reply_info* rep,
 199         struct key_entry_key* kkey, time_t* proof_ttl, char** reason)
 200 {
 201         struct ub_packed_rrset_key* nsec = reply_find_rrset_section_ns(
 202                 rep, qinfo->qname, qinfo->qname_len, LDNS_RR_TYPE_NSEC,
 203                 qinfo->qclass);
 204         enum sec_status sec;
 205         size_t i;
 206         uint8_t* wc = NULL, *ce = NULL;
 207         int valid_nsec = 0;
 208         struct ub_packed_rrset_key* wc_nsec = NULL;
 209
 210         /* If we have a NSEC at the same name, it must prove one
 211          * of two things
 212          * --
 213          * 1) this is a delegation point and there is no DS
 214          * 2) this is not a delegation point */
 215         if(nsec) {
 216                 if(!nsec_verify_rrset(env, ve, nsec, kkey, reason)) {
 217                         verbose(VERB_ALGO, "NSEC RRset for the "
 218                                 "referral did not verify.");
 219                         return sec_status_bogus;
 220                 }
 221                 sec = val_nsec_proves_no_ds(nsec, qinfo);
 222                 if(sec == sec_status_bogus) {
 223                         /* something was wrong. */
 224                         *reason = "NSEC does not prove absence of DS";
 225                         return sec;
 226                 } else if(sec == sec_status_insecure) {
 227                         /* this wasn't a delegation point. */
 228                         return sec;
 229                 } else if(sec == sec_status_secure) {
 230                         /* this proved no DS. */
 231                         *proof_ttl = ub_packed_rrset_ttl(nsec);
 232                         return sec;
 233                 }
 234                 /* if unchecked, fall through to next proof */
 235         }
 236
 237         /* Otherwise, there is no NSEC at qname. This could be an ENT.
 238          * (ENT=empty non terminal). If not, this is broken. */
 239
 240         /* verify NSEC rrsets in auth section */
 241         for(i=rep->an_numrrsets; i < rep->an_numrrsets+rep->ns_numrrsets;
 242                 i++) {
 243                 if(rep->rrsets[i]->rk.type != htons(LDNS_RR_TYPE_NSEC))
 244                         continue;
 245                 if(!nsec_verify_rrset(env, ve, rep->rrsets[i], kkey, reason)) {
 246                         verbose(VERB_ALGO, "NSEC for empty non-terminal "
 247                                 "did not verify.");
 248                         return sec_status_bogus;
 249                 }
 250                 if(nsec_proves_nodata(rep->rrsets[i], qinfo, &wc)) {
 251                         verbose(VERB_ALGO, "NSEC for empty non-terminal "
 252                                 "proved no DS.");
 253                         *proof_ttl = rrset_get_ttl(rep->rrsets[i]);
 254                         if(wc && dname_is_wild(rep->rrsets[i]->rk.dname))
 255                                 wc_nsec = rep->rrsets[i];
 256                         valid_nsec = 1;
 257                 }
 258                 if(val_nsec_proves_name_error(rep->rrsets[i], qinfo->qname)) {
 259                         ce = nsec_closest_encloser(qinfo->qname,
 260                                 rep->rrsets[i]);
 261                 }
 262         }
 263         if(wc && !ce)
 264                 valid_nsec = 0;
 265         else if(wc && ce) {
 266                 /* ce and wc must match */
 267                 if(query_dname_compare(wc, ce) != 0)
 268                         valid_nsec = 0;
 269                 else if(!wc_nsec)
 270                         valid_nsec = 0;
 271         }
 272         if(valid_nsec) {
 273                 if(wc) {
 274                         /* check if this is a delegation */
 275                         *reason = "NSEC for wildcard does not prove absence of DS";
 276                         return val_nsec_proves_no_ds(wc_nsec, qinfo);
 277                 }
 278                 /* valid nsec proves empty nonterminal */
 279                 return sec_status_insecure;
 280         }
 281
 282         /* NSEC proof did not conclusively point to DS or no DS */
 283         return sec_status_unchecked;
 284 }
 285
 286 int nsec_proves_nodata(struct ub_packed_rrset_key* nsec,
 287         struct query_info* qinfo, uint8_t** wc)
 288 {
 289         log_assert(wc);
 290         if(query_dname_compare(nsec->rk.dname, qinfo->qname) != 0) {
 291                 uint8_t* nm;
 292                 size_t ln;
 293
 294                 /* empty-non-terminal checking.
 295                  * Done before wildcard, because this is an exact match,
 296                  * and would prevent a wildcard from matching. */
 297
 298                 /* If the nsec is proving that qname is an ENT, the nsec owner
 299                  * will be less than qname, and the next name will be a child
 300                  * domain of the qname. */
 301                 if(!nsec_get_next(nsec, &nm, &ln))
 302                         return 0; /* bad nsec */
 303                 if(dname_strict_subdomain_c(nm, qinfo->qname) &&
 304                         dname_canonical_compare(nsec->rk.dname,
 305                                 qinfo->qname) < 0) {
 306                         return 1; /* proves ENT */
 307                 }
 308
 309                 /* wildcard checking. */
 310
 311                 /* If this is a wildcard NSEC, make sure that a) it was
 312                  * possible to have generated qname from the wildcard and
 313                  * b) the type map does not contain qtype. Note that this
 314                  * does NOT prove that this wildcard was the applicable
 315                  * wildcard. */
 316                 if(dname_is_wild(nsec->rk.dname)) {
 317                         /* the purported closest encloser. */
 318                         uint8_t* ce = nsec->rk.dname;
 319                         size_t ce_len = nsec->rk.dname_len;
 320                         dname_remove_label(&ce, &ce_len);
 321
 322                         /* The qname must be a strict subdomain of the
 323                          * closest encloser, for the wildcard to apply
 324                          */
 325                         if(dname_strict_subdomain_c(qinfo->qname, ce)) {
 326                                 /* here we have a matching NSEC for the qname,
 327                                  * perform matching NSEC checks */
 328                                 if(nsec_has_type(nsec, LDNS_RR_TYPE_CNAME)) {
 329                                    /* should have gotten the wildcard CNAME */
 330                                         return 0;
 331                                 }
 332                                 if(nsec_has_type(nsec, LDNS_RR_TYPE_NS) &&
 333                                    !nsec_has_type(nsec, LDNS_RR_TYPE_SOA)) {
 334                                    /* wrong parentside (wildcard) NSEC used */
 335                                         return 0;
 336                                 }
 337                                 if(nsec_has_type(nsec, qinfo->qtype)) {
 338                                         return 0;
 339                                 }
 340                                 *wc = ce;
 341                                 return 1;
 342                         }
 343                 } else {
 344                         /* See if the next owner name covers a wildcard
 345                          * empty non-terminal. */
 346                         while (dname_strict_subdomain_c(nm, nsec->rk.dname)) {
 347                                 /* wildcard does not apply if qname below
 348                                  * the name that exists under the '*' */
 349                                 if (dname_subdomain_c(qinfo->qname, nm))
 350                                         break;
 351                                 /* but if it is a wildcard and qname is below
 352                                  * it, then the wildcard applies. The wildcard
 353                                  * is an empty nonterminal. nodata proven. */
 354                                 if (dname_is_wild(nm)) {
 355                                         size_t ce_len = ln;
 356                                         uint8_t* ce = nm;
 357                                         dname_remove_label(&ce, &ce_len);
 358                                         if(dname_strict_subdomain_c(qinfo->qname, ce)) {
 359                                                 *wc = ce;
 360                                                 return 1;
 361                                         }
 362                                 }
 363                                 dname_remove_label(&nm, &ln);
 364                         }
 365                 }
 366
 367                 /* Otherwise, this NSEC does not prove ENT and is not a
 368                  * wildcard, so it does not prove NODATA. */
 369                 return 0;
 370         }
 371
 372         /* If the qtype exists, then we should have gotten it. */
 373         if(nsec_has_type(nsec, qinfo->qtype)) {
 374                 return 0;
 375         }
 376
 377         /* if the name is a CNAME node, then we should have gotten the CNAME*/
 378         if(nsec_has_type(nsec, LDNS_RR_TYPE_CNAME)) {
 379                 return 0;
 380         }
 381
 382         /* If an NS set exists at this name, and NOT a SOA (so this is a
 383          * zone cut, not a zone apex), then we should have gotten a
 384          * referral (or we just got the wrong NSEC).
 385          * The reverse of this check is used when qtype is DS, since that
 386          * must use the NSEC from above the zone cut. */
 387         if(qinfo->qtype != LDNS_RR_TYPE_DS &&
 388                 nsec_has_type(nsec, LDNS_RR_TYPE_NS) &&
 389                 !nsec_has_type(nsec, LDNS_RR_TYPE_SOA)) {
 390                 return 0;
 391         } else if(qinfo->qtype == LDNS_RR_TYPE_DS &&
 392                 nsec_has_type(nsec, LDNS_RR_TYPE_SOA) &&
 393                 !dname_is_root(qinfo->qname)) {
 394                 return 0;
 395         }
 396
 397         return 1;
 398 }
 399
 400 int
 401 val_nsec_proves_name_error(struct ub_packed_rrset_key* nsec, uint8_t* qname)
 402 {
 403         uint8_t* owner = nsec->rk.dname;
 404         uint8_t* next;
 405         size_t nlen;
 406         if(!nsec_get_next(nsec, &next, &nlen))
 407                 return 0;
 408
 409         /* If NSEC owner == qname, then this NSEC proves that qname exists. */
 410         if(query_dname_compare(qname, owner) == 0) {
 411                 return 0;
 412         }
 413
 414         /* If NSEC is a parent of qname, we need to check the type map
 415          * If the parent name has a DNAME or is a delegation point, then
 416          * this NSEC is being misused. */
 417         if(dname_subdomain_c(qname, owner) &&
 418                 (nsec_has_type(nsec, LDNS_RR_TYPE_DNAME) ||
 419                 (nsec_has_type(nsec, LDNS_RR_TYPE_NS)
 420                         && !nsec_has_type(nsec, LDNS_RR_TYPE_SOA))
 421                 )) {
 422                 return 0;
 423         }
 424
 425         if(query_dname_compare(owner, next) == 0) {
 426                 /* this nsec is the only nsec */
 427                 /* zone.name NSEC zone.name, disproves everything else */
 428                 /* but only for subdomains of that zone */
 429                 if(dname_strict_subdomain_c(qname, next))
 430                         return 1;
 431         }
 432         else if(dname_canonical_compare(owner, next) > 0) {
 433                 /* this is the last nsec, ....(bigger) NSEC zonename(smaller) */
 434                 /* the names after the last (owner) name do not exist
 435                  * there are no names before the zone name in the zone
 436                  * but the qname must be a subdomain of the zone name(next). */
 437                 if(dname_canonical_compare(owner, qname) < 0 &&
 438                         dname_strict_subdomain_c(qname, next))
 439                         return 1;
 440         } else {
 441                 /* regular NSEC, (smaller) NSEC (larger) */
 442                 if(dname_canonical_compare(owner, qname) < 0 &&
 443                    dname_canonical_compare(qname, next) < 0) {
 444                         return 1;
 445                 }
 446         }
 447         return 0;
 448 }
 449
 450 int val_nsec_proves_insecuredelegation(struct ub_packed_rrset_key* nsec,
 451         struct query_info* qinfo)
 452 {
 453         if(nsec_has_type(nsec, LDNS_RR_TYPE_NS) &&
 454                 !nsec_has_type(nsec, LDNS_RR_TYPE_DS) &&
 455                 !nsec_has_type(nsec, LDNS_RR_TYPE_SOA)) {
 456                 /* see if nsec signals an insecure delegation */
 457                 if(qinfo->qtype == LDNS_RR_TYPE_DS) {
 458                         /* if type is DS and qname is equal to nsec, then it
 459                          * is an exact match nsec, result not insecure */
 460                         if(dname_strict_subdomain_c(qinfo->qname,
 461                                 nsec->rk.dname))
 462                                 return 1;
 463                 } else {
 464                         if(dname_subdomain_c(qinfo->qname, nsec->rk.dname))
 465                                 return 1;
 466                 }
 467         }
 468         return 0;
 469 }
 470
 471 uint8_t*
 472 nsec_closest_encloser(uint8_t* qname, struct ub_packed_rrset_key* nsec)
 473 {
 474         uint8_t* next;
 475         size_t nlen;
 476         uint8_t* common1, *common2;
 477         if(!nsec_get_next(nsec, &next, &nlen))
 478                 return NULL;
 479         /* longest common with owner or next name */
 480         common1 = dname_get_shared_topdomain(nsec->rk.dname, qname);
 481         common2 = dname_get_shared_topdomain(next, qname);
 482         if(dname_count_labels(common1) > dname_count_labels(common2))
 483                 return common1;
 484         return common2;
 485 }
 486
 487 int val_nsec_proves_positive_wildcard(struct ub_packed_rrset_key* nsec,
 488         struct query_info* qinf, uint8_t* wc)
 489 {
 490         uint8_t* ce;
 491         /*  1) prove that qname doesn't exist and
 492          *  2) that the correct wildcard was used
 493          *  nsec has been verified already. */
 494         if(!val_nsec_proves_name_error(nsec, qinf->qname))
 495                 return 0;
 496         /* check wildcard name */
 497         ce = nsec_closest_encloser(qinf->qname, nsec);
 498         if(!ce)
 499                 return 0;
 500         if(query_dname_compare(wc, ce) != 0) {
 501                 return 0;
 502         }
 503         return 1;
 504 }
 505
 506 int
 507 val_nsec_proves_no_wc(struct ub_packed_rrset_key* nsec, uint8_t* qname,
 508         size_t qnamelen)
 509 {
 510         /* Determine if a NSEC record proves the non-existence of a
 511          * wildcard that could have produced qname. */
 512         int labs;
 513         int i;
 514         uint8_t* ce = nsec_closest_encloser(qname, nsec);
 515         uint8_t* strip;
 516         size_t striplen;
 517         uint8_t buf[LDNS_MAX_DOMAINLEN+3];
 518         if(!ce)
 519                 return 0;
 520         /* we can subtract the closest encloser count - since that is the
 521          * largest shared topdomain with owner and next NSEC name,
 522          * because the NSEC is no proof for names shorter than the owner
 523          * and next names. */
 524         labs = dname_count_labels(qname) - dname_count_labels(ce);
 525
 526         for(i=labs; i>0; i--) {
 527                 /* i is number of labels to strip off qname, prepend * wild */
 528                 strip = qname;
 529                 striplen = qnamelen;
 530                 dname_remove_labels(&strip, &striplen, i);
 531                 if(striplen > LDNS_MAX_DOMAINLEN-2)
 532                         continue; /* too long to prepend wildcard */
 533                 buf[0] = 1;
 534                 buf[1] = (uint8_t)'*';
 535                 memmove(buf+2, strip, striplen);
 536                 if(val_nsec_proves_name_error(nsec, buf)) {
 537                         return 1;
 538                 }
 539         }
 540         return 0;
 541 }
 542
 543 /**
 544  * Find shared topdomain that exists
 545  */
 546 static void
 547 dlv_topdomain(struct ub_packed_rrset_key* nsec, uint8_t* qname,
 548         uint8_t** nm, size_t* nm_len)
 549 {
 550         /* make sure reply is part of nm */
 551         /* take shared topdomain with left of NSEC. */
 552
 553         /* because, if empty nonterminal, then right is subdomain of qname.
 554          * and any shared topdomain would be empty nonterminals.
 555          *
 556          * If nxdomain, then the right is bigger, and could have an
 557          * interesting shared topdomain, but if it does have one, it is
 558          * an empty nonterminal. An empty nonterminal shared with the left
 559          * one. */
 560         int n;
 561         uint8_t* common = dname_get_shared_topdomain(qname, nsec->rk.dname);
 562         n = dname_count_labels(*nm) - dname_count_labels(common);
 563         dname_remove_labels(nm, nm_len, n);
 564 }
 565
 566 int val_nsec_check_dlv(struct query_info* qinfo,
 567         struct reply_info* rep, uint8_t** nm, size_t* nm_len)
 568 {
 569         uint8_t* next;
 570         size_t i, nlen;
 571         int c;
 572         /* we should now have a NOERROR/NODATA or NXDOMAIN message */
 573         if(rep->an_numrrsets != 0) {
 574                 return 0;
 575         }
 576         /* is this NOERROR ? */
 577         if(FLAGS_GET_RCODE(rep->flags) == LDNS_RCODE_NOERROR) {
 578                 /* it can be a plain NSEC match - go up one more level. */
 579                 /* or its an empty nonterminal - go up to nonempty level */
 580                 for(i=0; i<rep->ns_numrrsets; i++) {
 581                         if(htons(rep->rrsets[i]->rk.type)!=LDNS_RR_TYPE_NSEC ||
 582                                 !nsec_get_next(rep->rrsets[i], &next, &nlen))
 583                                 continue;
 584                         c = dname_canonical_compare(
 585                                 rep->rrsets[i]->rk.dname, qinfo->qname);
 586                         if(c == 0) {
 587                                 /* plain match */
 588                                 if(nsec_has_type(rep->rrsets[i],
 589                                         LDNS_RR_TYPE_DLV))
 590                                         return 0;
 591                                 dname_remove_label(nm, nm_len);
 592                                 return 1;
 593                         } else if(c < 0 &&
 594                                 dname_strict_subdomain_c(next, qinfo->qname)) {
 595                                 /* ENT */
 596                                 dlv_topdomain(rep->rrsets[i], qinfo->qname,
 597                                         nm, nm_len);
 598                                 return 1;
 599                         }
 600                 }
 601                 return 0;
 602         }
 603
 604         /* is this NXDOMAIN ? */
 605         if(FLAGS_GET_RCODE(rep->flags) == LDNS_RCODE_NXDOMAIN) {
 606                 /* find the qname denial NSEC record. It can tell us
 607                  * a closest encloser name; or that we not need bother */
 608                 for(i=0; i<rep->ns_numrrsets; i++) {
 609                         if(htons(rep->rrsets[i]->rk.type) != LDNS_RR_TYPE_NSEC)
 610                                 continue;
 611                         if(val_nsec_proves_name_error(rep->rrsets[i],
 612                                 qinfo->qname)) {
 613                                 log_nametypeclass(VERB_ALGO, "topdomain on",
 614                                         rep->rrsets[i]->rk.dname,
 615                                         ntohs(rep->rrsets[i]->rk.type), 0);
 616                                 dlv_topdomain(rep->rrsets[i], qinfo->qname,
 617                                         nm, nm_len);
 618                                 return 1;
 619                         }
 620                 }
 621                 return 0;
 622         }
 623         return 0;
 624 }