contrib/ldns/dnssec_verify.c

   1 #include <ldns/config.h>
   2
   3 #include <ldns/ldns.h>
   4
   5 #include <strings.h>
   6 #include <time.h>
   7
   8 #ifdef HAVE_SSL
   9 /* this entire file is rather useless when you don't have
  10  * crypto...
  11  */
  12 #include <openssl/ssl.h>
  13 #include <openssl/evp.h>
  14 #include <openssl/rand.h>
  15 #include <openssl/err.h>
  16 #include <openssl/md5.h>
  17
  18 ldns_dnssec_data_chain *
  19 ldns_dnssec_data_chain_new()
  20 {
  21         ldns_dnssec_data_chain *nc = LDNS_XMALLOC(ldns_dnssec_data_chain, 1);
  22         nc->rrset = NULL;
  23         nc->parent_type = 0;
  24         nc->parent = NULL;
  25         nc->signatures = NULL;
  26         nc->packet_rcode = 0;
  27         nc->packet_qtype = 0;
  28         nc->packet_nodata = false;
  29         return nc;
  30 }
  31
  32 void
  33 ldns_dnssec_data_chain_free(ldns_dnssec_data_chain *chain)
  34 {
  35         LDNS_FREE(chain);
  36 }
  37
  38 void
  39 ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain)
  40 {
  41         ldns_rr_list_deep_free(chain->rrset);
  42         ldns_rr_list_deep_free(chain->signatures);
  43         if (chain->parent) {
  44                 ldns_dnssec_data_chain_deep_free(chain->parent);
  45         }
  46         LDNS_FREE(chain);
  47 }
  48
  49 void
  50 ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain)
  51 {
  52         ldns_lookup_table *rcode;
  53         const ldns_rr_descriptor *rr_descriptor;
  54         if (chain) {
  55                 ldns_dnssec_data_chain_print(out, chain->parent);
  56                 if (ldns_rr_list_rr_count(chain->rrset) > 0) {
  57                         rcode = ldns_lookup_by_id(ldns_rcodes,
  58                                                                  (int) chain->packet_rcode);
  59                         if (rcode) {
  60                                 fprintf(out, ";; rcode: %s\n", rcode->name);
  61                         }
  62
  63                         rr_descriptor = ldns_rr_descript(chain->packet_qtype);
  64                         if (rr_descriptor && rr_descriptor->_name) {
  65                                 fprintf(out, ";; qtype: %s\n", rr_descriptor->_name);
  66                         } else if (chain->packet_qtype != 0) {
  67                                 fprintf(out, "TYPE%u",
  68                                            chain->packet_qtype);
  69                         }
  70                         if (chain->packet_nodata) {
  71                                 fprintf(out, ";; NODATA response\n");
  72                         }
  73                         fprintf(out, "rrset:\n");
  74                         ldns_rr_list_print(out, chain->rrset);
  75                         fprintf(out, "sigs:\n");
  76                         ldns_rr_list_print(out, chain->signatures);
  77                         fprintf(out, "---\n");
  78                 } else {
  79                         fprintf(out, "<no data>\n");
  80                 }
  81         }
  82 }
  83
  84 static void
  85 ldns_dnssec_build_data_chain_dnskey(ldns_resolver *res,
  86                                             uint16_t qflags,
  87                                             const ldns_pkt *pkt,
  88                                             ldns_rr_list *signatures,
  89                                                 ldns_dnssec_data_chain *new_chain,
  90                                                 ldns_rdf *key_name,
  91                                                 ldns_rr_class c) {
  92         ldns_rr_list *keys;
  93         ldns_pkt *my_pkt;
  94         if (signatures && ldns_rr_list_rr_count(signatures) > 0) {
  95                 new_chain->signatures = ldns_rr_list_clone(signatures);
  96                 new_chain->parent_type = 0;
  97
  98                 keys = ldns_pkt_rr_list_by_name_and_type(
  99                                   pkt,
 100                                  key_name,
 101                                  LDNS_RR_TYPE_DNSKEY,
 102                                  LDNS_SECTION_ANY_NOQUESTION
 103                           );
 104                 if (!keys) {
 105                         my_pkt = ldns_resolver_query(res,
 106                                                                         key_name,
 107                                                                         LDNS_RR_TYPE_DNSKEY,
 108                                                                         c,
 109                                                                         qflags);
 110                         keys = ldns_pkt_rr_list_by_name_and_type(
 111                                           my_pkt,
 112                                          key_name,
 113                                          LDNS_RR_TYPE_DNSKEY,
 114                                          LDNS_SECTION_ANY_NOQUESTION
 115                                   );
 116                         new_chain->parent = ldns_dnssec_build_data_chain(res,
 117                                                                                                         qflags,
 118                                                                                                         keys,
 119                                                                                                         my_pkt,
 120                                                                                                         NULL);
 121                         new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY;
 122                         ldns_pkt_free(my_pkt);
 123                 } else {
 124                         new_chain->parent = ldns_dnssec_build_data_chain(res,
 125                                                                                                         qflags,
 126                                                                                                         keys,
 127                                                                                                         pkt,
 128                                                                                                         NULL);
 129                         new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY;
 130                 }
 131                 ldns_rr_list_deep_free(keys);
 132         }
 133 }
 134
 135 static void
 136 ldns_dnssec_build_data_chain_other(ldns_resolver *res,
 137                                             uint16_t qflags,
 138                                                 ldns_dnssec_data_chain *new_chain,
 139                                                 ldns_rdf *key_name,
 140                                                 ldns_rr_class c,
 141                                                 ldns_rr_list *dss)
 142 {
 143         /* 'self-signed', parent is a DS */
 144
 145         /* okay, either we have other keys signing the current one,
 146          * or the current
 147          * one should have a DS record in the parent zone.
 148          * How do we find this out? Try both?
 149          *
 150          * request DNSKEYS for current zone,
 151          * add all signatures to current level
 152          */
 153         ldns_pkt *my_pkt;
 154         ldns_rr_list *signatures2;
 155
 156         new_chain->parent_type = 1;
 157
 158         my_pkt = ldns_resolver_query(res,
 159                                                         key_name,
 160                                                         LDNS_RR_TYPE_DS,
 161                                                         c,
 162                                                         qflags);
 163         dss = ldns_pkt_rr_list_by_name_and_type(my_pkt,
 164                                                                         key_name,
 165                                                                         LDNS_RR_TYPE_DS,
 166                                                                         LDNS_SECTION_ANY_NOQUESTION
 167                                                                         );
 168         if (dss) {
 169                 new_chain->parent = ldns_dnssec_build_data_chain(res,
 170                                                                                                 qflags,
 171                                                                                                 dss,
 172                                                                                                 my_pkt,
 173                                                                                                 NULL);
 174                 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS;
 175                 ldns_rr_list_deep_free(dss);
 176         }
 177         ldns_pkt_free(my_pkt);
 178
 179         my_pkt = ldns_resolver_query(res,
 180                                                         key_name,
 181                                                         LDNS_RR_TYPE_DNSKEY,
 182                                                         c,
 183                                                         qflags);
 184         signatures2 = ldns_pkt_rr_list_by_name_and_type(my_pkt,
 185                                                                                    key_name,
 186                                                                                    LDNS_RR_TYPE_RRSIG,
 187                                                                                    LDNS_SECTION_ANSWER);
 188         if (signatures2) {
 189                 if (new_chain->signatures) {
 190                         printf("There were already sigs!\n");
 191                         ldns_rr_list_deep_free(new_chain->signatures);
 192                         printf("replacing the old sigs\n");
 193                 }
 194                 new_chain->signatures = signatures2;
 195         }
 196         ldns_pkt_free(my_pkt);
 197 }
 198
 199 ldns_dnssec_data_chain *
 200 ldns_dnssec_build_data_chain_nokeyname(ldns_resolver *res,
 201                                        uint16_t qflags,
 202                                        ldns_rr *orig_rr,
 203                                        const ldns_rr_list *rrset,
 204                                        ldns_dnssec_data_chain *new_chain)
 205 {
 206         ldns_rdf *possible_parent_name;
 207         ldns_pkt *my_pkt;
 208         /* apparently we were not able to find a signing key, so
 209            we assume the chain ends here
 210         */
 211         /* try parents for auth denial of DS */
 212         if (orig_rr) {
 213                 possible_parent_name = ldns_rr_owner(orig_rr);
 214         } else if (rrset && ldns_rr_list_rr_count(rrset) > 0) {
 215                 possible_parent_name = ldns_rr_owner(ldns_rr_list_rr(rrset, 0));
 216         } else {
 217                 /* no information to go on, give up */
 218                 return new_chain;
 219         }
 220
 221         my_pkt = ldns_resolver_query(res,
 222                       possible_parent_name,
 223                       LDNS_RR_TYPE_DS,
 224                       LDNS_RR_CLASS_IN,
 225                       qflags);
 226
 227         if (ldns_pkt_ancount(my_pkt) > 0) {
 228                 /* add error, no sigs but DS in parent */
 229                 /*ldns_pkt_print(stdout, my_pkt);*/
 230                 ldns_pkt_free(my_pkt);
 231         } else {
 232                 /* are there signatures? */
 233                 new_chain->parent =  ldns_dnssec_build_data_chain(res,
 234                                           qflags,
 235                                           NULL,
 236                                           my_pkt,
 237                                           NULL);
 238
 239                 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS;
 240
 241         }
 242         return new_chain;
 243 }
 244
 245
 246 ldns_dnssec_data_chain *
 247 ldns_dnssec_build_data_chain(ldns_resolver *res,
 248                                             uint16_t qflags,
 249                                             const ldns_rr_list *rrset,
 250                                             const ldns_pkt *pkt,
 251                                             ldns_rr *orig_rr)
 252 {
 253         ldns_rr_list *signatures = NULL;
 254         ldns_rr_list *dss = NULL;
 255
 256         ldns_rr_list *my_rrset;
 257
 258         ldns_pkt *my_pkt;
 259
 260         ldns_rdf *name = NULL, *key_name = NULL;
 261         ldns_rr_type type = 0;
 262         ldns_rr_class c = 0;
 263
 264         bool other_rrset = false;
 265
 266         ldns_dnssec_data_chain *new_chain = ldns_dnssec_data_chain_new();
 267
 268         if (!ldns_dnssec_pkt_has_rrsigs(pkt)) {
 269                 /* hmm. no dnssec data in the packet. go up to try and deny
 270                  * DS? */
 271                 return new_chain;
 272         }
 273
 274         if (orig_rr) {
 275                 new_chain->rrset = ldns_rr_list_new();
 276                 ldns_rr_list_push_rr(new_chain->rrset, orig_rr);
 277                 new_chain->parent = ldns_dnssec_build_data_chain(res,
 278                                                                                             qflags,
 279                                                                                             rrset,
 280                                                                                             pkt,
 281                                                                                             NULL);
 282                 new_chain->packet_rcode = ldns_pkt_get_rcode(pkt);
 283                 new_chain->packet_qtype = ldns_rr_get_type(orig_rr);
 284                 if (ldns_pkt_ancount(pkt) == 0) {
 285                         new_chain->packet_nodata = true;
 286                 }
 287                 return new_chain;
 288         }
 289
 290         if (!rrset || ldns_rr_list_rr_count(rrset) < 1) {
 291                 /* hmm, no data, do we have denial? only works if pkt was given,
 292                    otherwise caller has to do the check himself */
 293                 new_chain->packet_nodata = true;
 294                 if (pkt) {
 295                         my_rrset = ldns_pkt_rr_list_by_type(pkt,
 296                                                                                  LDNS_RR_TYPE_NSEC,
 297                                                                                  LDNS_SECTION_ANY_NOQUESTION
 298                                                                                  );
 299                         if (my_rrset) {
 300                                 if (ldns_rr_list_rr_count(my_rrset) > 0) {
 301                                         type = LDNS_RR_TYPE_NSEC;
 302                                         other_rrset = true;
 303                                 } else {
 304                                         ldns_rr_list_deep_free(my_rrset);
 305                                         my_rrset = NULL;
 306                                 }
 307                         } else {
 308                                 /* nothing, try nsec3 */
 309                                 my_rrset = ldns_pkt_rr_list_by_type(pkt,
 310                                                      LDNS_RR_TYPE_NSEC3,
 311                                                         LDNS_SECTION_ANY_NOQUESTION);
 312                                 if (my_rrset) {
 313                                         if (ldns_rr_list_rr_count(my_rrset) > 0) {
 314                                                 type = LDNS_RR_TYPE_NSEC3;
 315                                                 other_rrset = true;
 316                                         } else {
 317                                                 ldns_rr_list_deep_free(my_rrset);
 318                                                 my_rrset = NULL;
 319                                         }
 320                                 } else {
 321                                         /* nothing, stop */
 322                                         /* try parent zone? for denied insecure? */
 323                                         return new_chain;
 324                                 }
 325                         }
 326                 } else {
 327                         return new_chain;
 328                 }
 329         } else {
 330                 my_rrset = (ldns_rr_list *) rrset;
 331         }
 332
 333         if (my_rrset && ldns_rr_list_rr_count(my_rrset) > 0) {
 334                 new_chain->rrset = ldns_rr_list_clone(my_rrset);
 335                 name = ldns_rr_owner(ldns_rr_list_rr(my_rrset, 0));
 336                 type = ldns_rr_get_type(ldns_rr_list_rr(my_rrset, 0));
 337                 c = ldns_rr_get_class(ldns_rr_list_rr(my_rrset, 0));
 338         }
 339
 340         if (other_rrset) {
 341                 ldns_rr_list_deep_free(my_rrset);
 342         }
 343
 344         /* normally there will only be 1 signature 'set'
 345            but there can be more than 1 denial (wildcards)
 346            so check for NSEC
 347         */
 348         if (type == LDNS_RR_TYPE_NSEC || type == LDNS_RR_TYPE_NSEC3) {
 349                 /* just throw in all signatures, the tree builder must sort
 350                    this out */
 351                 if (pkt) {
 352                         signatures = ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type);
 353                 } else {
 354                         my_pkt = ldns_resolver_query(res, name, type, c, qflags);
 355                         signatures = ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type);
 356                         ldns_pkt_free(my_pkt);
 357                 }
 358         } else {
 359                 if (pkt) {
 360                         signatures =
 361                                 ldns_dnssec_pkt_get_rrsigs_for_name_and_type(pkt,
 362                                                                                                         name,
 363                                                                                                         type);
 364                 }
 365                 if (!signatures) {
 366                         my_pkt = ldns_resolver_query(res, name, type, c, qflags);
 367                         signatures =
 368                                 ldns_dnssec_pkt_get_rrsigs_for_name_and_type(my_pkt,
 369                                                                                                         name,
 370                                                                                                         type);
 371                         ldns_pkt_free(my_pkt);
 372                 }
 373         }
 374
 375         if (signatures && ldns_rr_list_rr_count(signatures) > 0) {
 376                 key_name = ldns_rr_rdf(ldns_rr_list_rr(signatures, 0), 7);
 377         }
 378
 379         if (!key_name) {
 380                 return ldns_dnssec_build_data_chain_nokeyname(res,
 381                                                               qflags,
 382                                                               orig_rr,
 383                                                               rrset,
 384                                                               new_chain);
 385         }
 386
 387         if (type != LDNS_RR_TYPE_DNSKEY) {
 388                 ldns_dnssec_build_data_chain_dnskey(res,
 389                                                     qflags,
 390                                                     pkt,
 391                                                     signatures,
 392                                                     new_chain,
 393                                                     key_name,
 394                                                     c
 395                                                     );
 396         } else {
 397                 ldns_dnssec_build_data_chain_other(res,
 398                                                    qflags,
 399                                                    new_chain,
 400                                                    key_name,
 401                                                    c,
 402                                                    dss
 403
 404                                                     );
 405         }
 406         if (signatures) {
 407                 ldns_rr_list_deep_free(signatures);
 408         }
 409
 410         return new_chain;
 411 }
 412
 413 ldns_dnssec_trust_tree *
 414 ldns_dnssec_trust_tree_new()
 415 {
 416         ldns_dnssec_trust_tree *new_tree = LDNS_XMALLOC(ldns_dnssec_trust_tree,
 417                                                                                    1);
 418         new_tree->rr = NULL;
 419         new_tree->rrset = NULL;
 420         new_tree->parent_count = 0;
 421
 422         return new_tree;
 423 }
 424
 425 void
 426 ldns_dnssec_trust_tree_free(ldns_dnssec_trust_tree *tree)
 427 {
 428         size_t i;
 429         if (tree) {
 430                 for (i = 0; i < tree->parent_count; i++) {
 431                         ldns_dnssec_trust_tree_free(tree->parents[i]);
 432                 }
 433         }
 434         LDNS_FREE(tree);
 435 }
 436
 437 size_t
 438 ldns_dnssec_trust_tree_depth(ldns_dnssec_trust_tree *tree)
 439 {
 440         size_t result = 0;
 441         size_t parent = 0;
 442         size_t i;
 443
 444         for (i = 0; i < tree->parent_count; i++) {
 445                 parent = ldns_dnssec_trust_tree_depth(tree->parents[i]);
 446                 if (parent > result) {
 447                         result = parent;
 448                 }
 449         }
 450         return 1 + result;
 451 }
 452
 453 /* TODO ldns_ */
 454 static void
 455 print_tabs(FILE *out, size_t nr, uint8_t *map, size_t treedepth)
 456 {
 457         size_t i;
 458         for (i = 0; i < nr; i++) {
 459                 if (i == nr - 1) {
 460                         fprintf(out, "|---");
 461                 } else if (map && i < treedepth && map[i] == 1) {
 462                         fprintf(out, "|   ");
 463                 } else {
 464                         fprintf(out, "    ");
 465                 }
 466         }
 467 }
 468
 469 void
 470 ldns_dnssec_trust_tree_print_sm(FILE *out,
 471                                                   ldns_dnssec_trust_tree *tree,
 472                                                   size_t tabs,
 473                                                   bool extended,
 474                                                   uint8_t *sibmap,
 475                                                   size_t treedepth)
 476 {
 477         size_t i;
 478         const ldns_rr_descriptor *descriptor;
 479         bool mapset = false;
 480
 481         if (!sibmap) {
 482                 treedepth = ldns_dnssec_trust_tree_depth(tree);
 483                 sibmap = malloc(treedepth);
 484                 memset(sibmap, 0, treedepth);
 485                 mapset = true;
 486         }
 487
 488         if (tree) {
 489                 if (tree->rr) {
 490                         print_tabs(out, tabs, sibmap, treedepth);
 491                         ldns_rdf_print(out, ldns_rr_owner(tree->rr));
 492                         descriptor = ldns_rr_descript(ldns_rr_get_type(tree->rr));
 493
 494                         if (descriptor->_name) {
 495                                 fprintf(out, " (%s", descriptor->_name);
 496                         } else {
 497                                 fprintf(out, " (TYPE%d",
 498                                            ldns_rr_get_type(tree->rr));
 499                         }
 500                         if (tabs > 0) {
 501                                 if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_DNSKEY) {
 502                                         fprintf(out, " keytag: %u",
 503                                                 (unsigned int) ldns_calc_keytag(tree->rr));
 504                                         fprintf(out, " alg: ");
 505                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 2));
 506                                         fprintf(out, " flags: ");
 507                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0));
 508                                 } else if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_DS) {
 509                                         fprintf(out, " keytag: ");
 510                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0));
 511                                         fprintf(out, " digest type: ");
 512                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 2));
 513                                 }
 514                                 if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NSEC) {
 515                                         fprintf(out, " ");
 516                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0));
 517                                         fprintf(out, " ");
 518                                         ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 1));
 519                                 }
 520                         }
 521
 522                         fprintf(out, ")\n");
 523                         for (i = 0; i < tree->parent_count; i++) {
 524                                 if (tree->parent_count > 1 && i < tree->parent_count - 1) {
 525                                         sibmap[tabs] = 1;
 526                                 } else {
 527                                         sibmap[tabs] = 0;
 528                                 }
 529                                 /* only print errors */
 530                                 if (ldns_rr_get_type(tree->parents[i]->rr) ==
 531                                     LDNS_RR_TYPE_NSEC ||
 532                                     ldns_rr_get_type(tree->parents[i]->rr) ==
 533                                     LDNS_RR_TYPE_NSEC3) {
 534                                         if (tree->parent_status[i] == LDNS_STATUS_OK) {
 535                                                 print_tabs(out, tabs + 1, sibmap, treedepth);
 536                                                 if (tabs == 0 &&
 537                                                     ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NS &&
 538                                                         ldns_rr_rd_count(tree->rr) > 0) {
 539                                                         fprintf(out, "Existence of DS is denied by:\n");
 540                                                 } else {
 541                                                         fprintf(out, "Existence is denied by:\n");
 542                                                 }
 543                                         } else {
 544                                                 /* NS records aren't signed */
 545                                                 if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NS) {
 546                                                         fprintf(out, "Existence of DS is denied by:\n");
 547                                                 } else {
 548                                                         print_tabs(out, tabs + 1, sibmap, treedepth);
 549                                                         fprintf(out,
 550                                                                    "Error in denial of existence: %s\n",
 551                                                                    ldns_get_errorstr_by_id(
 552                                                                            tree->parent_status[i]));
 553                                                 }
 554                                         }
 555                                 } else
 556                                         if (tree->parent_status[i] != LDNS_STATUS_OK) {
 557                                                 print_tabs(out, tabs + 1, sibmap, treedepth);
 558                                                 fprintf(out,
 559                                                            "%s:\n",
 560                                                            ldns_get_errorstr_by_id(
 561                                                                tree->parent_status[i]));
 562                                                 if (tree->parent_status[i]
 563                                                     == LDNS_STATUS_SSL_ERR) {
 564                                                         printf("; SSL Error: ");
 565                                                         ERR_load_crypto_strings();
 566                                                         ERR_print_errors_fp(stdout);
 567                                                         printf("\n");
 568                                                 }
 569                                                 ldns_rr_print(out, tree->parent_signature[i]);
 570                                                 printf("For RRset:\n");
 571                                                 ldns_rr_list_print(out, tree->rrset);
 572                                                 printf("With key:\n");
 573                                                 ldns_rr_print(out, tree->parents[i]->rr);
 574                                         }
 575                                 ldns_dnssec_trust_tree_print_sm(out,
 576                                                                                   tree->parents[i],
 577                                                                                   tabs+1,
 578                                                                                   extended,
 579                                                                                   sibmap,
 580                                                                                   treedepth);
 581                         }
 582                 } else {
 583                         print_tabs(out, tabs, sibmap, treedepth);
 584                         fprintf(out, "<no data>\n");
 585                 }
 586         } else {
 587                 fprintf(out, "<null pointer>\n");
 588         }
 589
 590         if (mapset) {
 591                 free(sibmap);
 592         }
 593 }
 594
 595 void
 596 ldns_dnssec_trust_tree_print(FILE *out,
 597                                             ldns_dnssec_trust_tree *tree,
 598                                             size_t tabs,
 599                                             bool extended)
 600 {
 601         ldns_dnssec_trust_tree_print_sm(out, tree, tabs, extended, NULL, 0);
 602 }
 603
 604 ldns_status
 605 ldns_dnssec_trust_tree_add_parent(ldns_dnssec_trust_tree *tree,
 606                                   const ldns_dnssec_trust_tree *parent,
 607                                   const ldns_rr *signature,
 608                                   const ldns_status parent_status)
 609 {
 610         if (tree
 611             && parent
 612             && tree->parent_count < LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS) {
 613                 /*
 614                   printf("Add parent for: ");
 615                   ldns_rr_print(stdout, tree->rr);
 616                   printf("parent: ");
 617                   ldns_rr_print(stdout, parent->rr);
 618                 */
 619                 tree->parents[tree->parent_count] =
 620                         (ldns_dnssec_trust_tree *) parent;
 621                 tree->parent_status[tree->parent_count] = parent_status;
 622                 tree->parent_signature[tree->parent_count] = (ldns_rr *) signature;
 623                 tree->parent_count++;
 624                 return LDNS_STATUS_OK;
 625         } else {
 626                 return LDNS_STATUS_ERR;
 627         }
 628 }
 629
 630 /* if rr is null, take the first from the rrset */
 631 ldns_dnssec_trust_tree *
 632 ldns_dnssec_derive_trust_tree(ldns_dnssec_data_chain *data_chain, ldns_rr *rr)
 633 {
 634         ldns_rr_list *cur_rrset;
 635         ldns_rr_list *cur_sigs;
 636         ldns_rr *cur_rr = NULL;
 637         ldns_rr *cur_sig_rr;
 638         size_t i, j;
 639
 640         ldns_dnssec_trust_tree *new_tree = ldns_dnssec_trust_tree_new();
 641
 642         if (data_chain && data_chain->rrset) {
 643                 cur_rrset = data_chain->rrset;
 644
 645                 cur_sigs = data_chain->signatures;
 646
 647                 if (rr) {
 648                         cur_rr = rr;
 649                 }
 650
 651                 if (!cur_rr && ldns_rr_list_rr_count(cur_rrset) > 0) {
 652                         cur_rr = ldns_rr_list_rr(cur_rrset, 0);
 653                 }
 654
 655                 if (cur_rr) {
 656                         new_tree->rr = cur_rr;
 657                         new_tree->rrset = cur_rrset;
 658                         /* there are three possibilities:
 659                            1 - 'normal' rrset, signed by a key
 660                            2 - dnskey signed by other dnskey
 661                            3 - dnskey proven by higher level DS
 662                            (data denied by nsec is a special case that can
 663                            occur in multiple places)
 664
 665                         */
 666                         if (cur_sigs) {
 667                                 for (i = 0; i < ldns_rr_list_rr_count(cur_sigs); i++) {
 668                                         /* find the appropriate key in the parent list */
 669                                         cur_sig_rr = ldns_rr_list_rr(cur_sigs, i);
 670
 671                                         if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_NSEC) {
 672                                                 if (ldns_dname_compare(ldns_rr_owner(cur_sig_rr),
 673                                                                                    ldns_rr_owner(cur_rr)))
 674                                                         {
 675                                                                 /* find first that does match */
 676
 677                                                                 for (j = 0;
 678                                                                      j < ldns_rr_list_rr_count(cur_rrset) &&
 679                                                                                 ldns_dname_compare(ldns_rr_owner(cur_sig_rr),ldns_rr_owner(cur_rr)) != 0;
 680                                                                      j++) {
 681                                                                         cur_rr = ldns_rr_list_rr(cur_rrset, j);
 682
 683                                                                 }
 684                                                                 if (ldns_dname_compare(ldns_rr_owner(cur_sig_rr),
 685                                                                                                    ldns_rr_owner(cur_rr)))
 686                                                                         {
 687                                                                                 break;
 688                                                                         }
 689                                                         }
 690
 691                                         }
 692                                         /* option 1 */
 693                                         if (data_chain->parent) {
 694                                                 ldns_dnssec_derive_trust_tree_normal_rrset(
 695                                                     new_tree,
 696                                                     data_chain,
 697                                                     cur_sig_rr);
 698                                         }
 699
 700                                         /* option 2 */
 701                                         ldns_dnssec_derive_trust_tree_dnskey_rrset(
 702                                             new_tree,
 703                                             data_chain,
 704                                             cur_rr,
 705                                             cur_sig_rr);
 706                                 }
 707
 708                                 ldns_dnssec_derive_trust_tree_ds_rrset(new_tree,
 709                                                                                             data_chain,
 710                                                                                             cur_rr);
 711                         } else {
 712                                 /* no signatures? maybe it's nsec data */
 713
 714                                 /* just add every rr from parent as new parent */
 715                                 ldns_dnssec_derive_trust_tree_no_sig(new_tree, data_chain);
 716                         }
 717                 }
 718         }
 719
 720         return new_tree;
 721 }
 722
 723 void
 724 ldns_dnssec_derive_trust_tree_normal_rrset(ldns_dnssec_trust_tree *new_tree,
 725                                            ldns_dnssec_data_chain *data_chain,
 726                                            ldns_rr *cur_sig_rr)
 727 {
 728         size_t i, j;
 729         ldns_rr_list *cur_rrset = ldns_rr_list_clone(data_chain->rrset);
 730         ldns_dnssec_trust_tree *cur_parent_tree;
 731         ldns_rr *cur_parent_rr;
 732         uint16_t cur_keytag;
 733         ldns_rr_list *tmp_rrset = NULL;
 734         ldns_status cur_status;
 735
 736         cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr));
 737
 738         for (j = 0; j < ldns_rr_list_rr_count(data_chain->parent->rrset); j++) {
 739                 cur_parent_rr = ldns_rr_list_rr(data_chain->parent->rrset, j);
 740                 if (ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DNSKEY) {
 741                         if (ldns_calc_keytag(cur_parent_rr) == cur_keytag) {
 742
 743                                 /* TODO: check wildcard nsec too */
 744                                 if (cur_rrset && ldns_rr_list_rr_count(cur_rrset) > 0) {
 745                                         tmp_rrset = cur_rrset;
 746                                         if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0))
 747                                             == LDNS_RR_TYPE_NSEC ||
 748                                             ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0))
 749                                             == LDNS_RR_TYPE_NSEC3) {
 750                                                 /* might contain different names!
 751                                                    sort and split */
 752                                                 ldns_rr_list_sort(cur_rrset);
 753                                                 if (tmp_rrset && tmp_rrset != cur_rrset) {
 754                                                         ldns_rr_list_deep_free(tmp_rrset);
 755                                                         tmp_rrset = NULL;
 756                                                 }
 757                                                 tmp_rrset = ldns_rr_list_pop_rrset(cur_rrset);
 758
 759                                                 /* with nsecs, this might be the wrong one */
 760                                                 while (tmp_rrset &&
 761                                                        ldns_rr_list_rr_count(cur_rrset) > 0 &&
 762                                                        ldns_dname_compare(
 763                                                                 ldns_rr_owner(ldns_rr_list_rr(
 764                                                                                         tmp_rrset, 0)),
 765                                                                 ldns_rr_owner(cur_sig_rr)) != 0) {
 766                                                         ldns_rr_list_deep_free(tmp_rrset);
 767                                                         tmp_rrset =
 768                                                                 ldns_rr_list_pop_rrset(cur_rrset);
 769                                                 }
 770                                         }
 771                                         cur_status = ldns_verify_rrsig(tmp_rrset,
 772                                                                                          cur_sig_rr,
 773                                                                                          cur_parent_rr);
 774                                         /* avoid dupes */
 775                                         for (i = 0; i < new_tree->parent_count; i++) {
 776                                                 if (cur_parent_rr == new_tree->parents[i]->rr) {
 777                                                         goto done;
 778                                                 }
 779                                         }
 780
 781                                         cur_parent_tree =
 782                                                 ldns_dnssec_derive_trust_tree(data_chain->parent,
 783                                                                               cur_parent_rr);
 784                                         (void)ldns_dnssec_trust_tree_add_parent(new_tree,
 785                                                    cur_parent_tree,
 786                                                    cur_sig_rr,
 787                                                    cur_status);
 788                                 }
 789                         }
 790                 }
 791         }
 792  done:
 793         if (tmp_rrset && tmp_rrset != cur_rrset) {
 794                 ldns_rr_list_deep_free(tmp_rrset);
 795         }
 796         ldns_rr_list_deep_free(cur_rrset);
 797 }
 798
 799 void
 800 ldns_dnssec_derive_trust_tree_dnskey_rrset(ldns_dnssec_trust_tree *new_tree,
 801                                            ldns_dnssec_data_chain *data_chain,
 802                                            ldns_rr *cur_rr,
 803                                            ldns_rr *cur_sig_rr)
 804 {
 805         size_t j;
 806         ldns_rr_list *cur_rrset = data_chain->rrset;
 807         ldns_dnssec_trust_tree *cur_parent_tree;
 808         ldns_rr *cur_parent_rr;
 809         uint16_t cur_keytag;
 810         ldns_status cur_status;
 811
 812         cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr));
 813
 814         for (j = 0; j < ldns_rr_list_rr_count(cur_rrset); j++) {
 815                 cur_parent_rr = ldns_rr_list_rr(cur_rrset, j);
 816                 if (cur_parent_rr != cur_rr &&
 817                     ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DNSKEY) {
 818                         if (ldns_calc_keytag(cur_parent_rr) == cur_keytag
 819                             ) {
 820                                 cur_parent_tree = ldns_dnssec_trust_tree_new();
 821                                 cur_parent_tree->rr = cur_parent_rr;
 822                                 cur_parent_tree->rrset = cur_rrset;
 823                                 cur_status = ldns_verify_rrsig(cur_rrset,
 824                                                                cur_sig_rr,
 825                                                                cur_parent_rr);
 826                                 (void) ldns_dnssec_trust_tree_add_parent(new_tree,
 827                                             cur_parent_tree, cur_sig_rr, cur_status);
 828                         }
 829                 }
 830         }
 831 }
 832
 833 void
 834 ldns_dnssec_derive_trust_tree_ds_rrset(ldns_dnssec_trust_tree *new_tree,
 835                                        ldns_dnssec_data_chain *data_chain,
 836                                        ldns_rr *cur_rr)
 837 {
 838         size_t j, h;
 839         ldns_rr_list *cur_rrset = data_chain->rrset;
 840         ldns_dnssec_trust_tree *cur_parent_tree;
 841         ldns_rr *cur_parent_rr;
 842
 843         /* try the parent to see whether there are DSs there */
 844         if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_DNSKEY &&
 845             data_chain->parent &&
 846             data_chain->parent->rrset
 847             ) {
 848                 for (j = 0;
 849                         j < ldns_rr_list_rr_count(data_chain->parent->rrset);
 850                         j++) {
 851                         cur_parent_rr = ldns_rr_list_rr(data_chain->parent->rrset, j);
 852                         if (ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DS) {
 853                                 for (h = 0; h < ldns_rr_list_rr_count(cur_rrset); h++) {
 854                                         cur_rr = ldns_rr_list_rr(cur_rrset, h);
 855                                         if (ldns_rr_compare_ds(cur_rr, cur_parent_rr)) {
 856                                                 cur_parent_tree =
 857                                                         ldns_dnssec_derive_trust_tree(
 858                                                             data_chain->parent, cur_parent_rr);
 859                                                 (void) ldns_dnssec_trust_tree_add_parent(
 860                                                             new_tree,
 861                                                             cur_parent_tree,
 862                                                             NULL,
 863                                                             LDNS_STATUS_OK);
 864                                         } else {
 865                                                 /*ldns_rr_print(stdout, cur_parent_rr);*/
 866                                         }
 867                                 }
 868                         }
 869                 }
 870         }
 871 }
 872
 873 void
 874 ldns_dnssec_derive_trust_tree_no_sig(ldns_dnssec_trust_tree *new_tree,
 875                                      ldns_dnssec_data_chain *data_chain)
 876 {
 877         size_t i;
 878         ldns_rr_list *cur_rrset;
 879         ldns_rr *cur_parent_rr;
 880         ldns_dnssec_trust_tree *cur_parent_tree;
 881         ldns_status result;
 882
 883         if (data_chain->parent && data_chain->parent->rrset) {
 884                 cur_rrset = data_chain->parent->rrset;
 885                 /* nsec? */
 886                 if (cur_rrset && ldns_rr_list_rr_count(cur_rrset) > 0) {
 887                         if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) ==
 888                             LDNS_RR_TYPE_NSEC3) {
 889                                 result = ldns_dnssec_verify_denial_nsec3(
 890                                                 new_tree->rr,
 891                                                    cur_rrset,
 892                                                    data_chain->parent->signatures,
 893                                                    data_chain->packet_rcode,
 894                                                    data_chain->packet_qtype,
 895                                                    data_chain->packet_nodata);
 896                         } else if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) ==
 897                                          LDNS_RR_TYPE_NSEC3) {
 898                                 result = ldns_dnssec_verify_denial(
 899                                                 new_tree->rr,
 900                                                    cur_rrset,
 901                                                    data_chain->parent->signatures);
 902                         } else {
 903                                 /* unsigned zone, unsigned parent */
 904                                 result = LDNS_STATUS_OK;
 905                         }
 906                 } else {
 907                         result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
 908                 }
 909                 for (i = 0; i < ldns_rr_list_rr_count(cur_rrset); i++) {
 910                         cur_parent_rr = ldns_rr_list_rr(cur_rrset, i);
 911                         cur_parent_tree =
 912                                 ldns_dnssec_derive_trust_tree(data_chain->parent,
 913                                                                                 cur_parent_rr);
 914                         (void) ldns_dnssec_trust_tree_add_parent(new_tree,
 915                                     cur_parent_tree, NULL, result);
 916                 }
 917         }
 918 }
 919
 920 /*
 921  * returns OK if there is a path from tree to key with only OK
 922  * the (first) error in between otherwise
 923  * or NOT_FOUND if the key wasn't present at all
 924  */
 925 ldns_status
 926 ldns_dnssec_trust_tree_contains_keys(ldns_dnssec_trust_tree *tree,
 927                                                           ldns_rr_list *trusted_keys)
 928 {
 929         size_t i;
 930         ldns_status result = LDNS_STATUS_CRYPTO_NO_DNSKEY;
 931         bool equal;
 932         ldns_status parent_result;
 933
 934         if (tree && trusted_keys && ldns_rr_list_rr_count(trusted_keys) > 0)
 935                 { if (tree->rr) {
 936                                 for (i = 0; i < ldns_rr_list_rr_count(trusted_keys); i++) {
 937                                         equal = ldns_rr_compare_ds(
 938                                                           tree->rr,
 939                                                           ldns_rr_list_rr(trusted_keys, i));
 940                                         if (equal) {
 941                                                 result = LDNS_STATUS_OK;
 942                                                 return result;
 943                                         }
 944                                 }
 945                         }
 946                         for (i = 0; i < tree->parent_count; i++) {
 947                                 parent_result =
 948                                         ldns_dnssec_trust_tree_contains_keys(tree->parents[i],
 949                                                                                                   trusted_keys);
 950                                 if (parent_result != LDNS_STATUS_CRYPTO_NO_DNSKEY) {
 951                                         if (tree->parent_status[i] != LDNS_STATUS_OK) {
 952                                                 result = tree->parent_status[i];
 953                                         } else {
 954                                                 if (ldns_rr_get_type(tree->rr)
 955                                                     == LDNS_RR_TYPE_NSEC &&
 956                                                     parent_result == LDNS_STATUS_OK
 957                                                     ) {
 958                                                         result =
 959                                                                 LDNS_STATUS_DNSSEC_EXISTENCE_DENIED;
 960                                                 } else {
 961                                                         result = parent_result;
 962                                                 }
 963                                         }
 964                                 }
 965                         }
 966                 } else {
 967                 result = LDNS_STATUS_ERR;
 968         }
 969
 970         return result;
 971 }
 972
 973 ldns_status
 974 ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys,
 975                   ldns_rr_list *good_keys)
 976 {
 977         uint16_t i;
 978         ldns_status verify_result = LDNS_STATUS_ERR;
 979
 980         if (!rrset || !rrsig || !keys) {
 981                 return LDNS_STATUS_ERR;
 982         }
 983
 984         if (ldns_rr_list_rr_count(rrset) < 1) {
 985                 return LDNS_STATUS_ERR;
 986         }
 987
 988         if (ldns_rr_list_rr_count(rrsig) < 1) {
 989                 return LDNS_STATUS_CRYPTO_NO_RRSIG;
 990         }
 991
 992         if (ldns_rr_list_rr_count(keys) < 1) {
 993                 verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY;
 994         } else {
 995                 for (i = 0; i < ldns_rr_list_rr_count(rrsig); i++) {
 996                         ldns_status s = ldns_verify_rrsig_keylist(rrset,
 997                                 ldns_rr_list_rr(rrsig, i), keys, good_keys);
 998                         /* try a little to get more descriptive error */
 999                         if(s == LDNS_STATUS_OK) {
1000                                 verify_result = LDNS_STATUS_OK;
1001                         } else if(verify_result == LDNS_STATUS_ERR)
1002                                 verify_result = s;
1003                         else if(s !=  LDNS_STATUS_ERR && verify_result ==
1004                                 LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY)
1005                                 verify_result = s;
1006                 }
1007         }
1008         return verify_result;
1009 }
1010
1011 ldns_status
1012 ldns_verify_notime(ldns_rr_list *rrset, ldns_rr_list *rrsig,
1013         const ldns_rr_list *keys, ldns_rr_list *good_keys)
1014 {
1015         uint16_t i;
1016         ldns_status verify_result = LDNS_STATUS_ERR;
1017
1018         if (!rrset || !rrsig || !keys) {
1019                 return LDNS_STATUS_ERR;
1020         }
1021
1022         if (ldns_rr_list_rr_count(rrset) < 1) {
1023                 return LDNS_STATUS_ERR;
1024         }
1025
1026         if (ldns_rr_list_rr_count(rrsig) < 1) {
1027                 return LDNS_STATUS_CRYPTO_NO_RRSIG;
1028         }
1029
1030         if (ldns_rr_list_rr_count(keys) < 1) {
1031                 verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY;
1032         } else {
1033                 for (i = 0; i < ldns_rr_list_rr_count(rrsig); i++) {
1034                         ldns_status s = ldns_verify_rrsig_keylist_notime(rrset,
1035                                 ldns_rr_list_rr(rrsig, i), keys, good_keys);
1036
1037                         /* try a little to get more descriptive error */
1038                         if (s == LDNS_STATUS_OK) {
1039                                 verify_result = LDNS_STATUS_OK;
1040                         } else if (verify_result == LDNS_STATUS_ERR) {
1041                                 verify_result = s;
1042                         } else if (s !=  LDNS_STATUS_ERR && verify_result ==
1043                                 LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) {
1044                                 verify_result = s;
1045                         }
1046                 }
1047         }
1048         return verify_result;
1049 }
1050
1051 ldns_rr_list *
1052 ldns_fetch_valid_domain_keys(const ldns_resolver *res,
1053                              const ldns_rdf *domain,
1054                              const ldns_rr_list *keys,
1055                              ldns_status *status)
1056 {
1057         ldns_rr_list * trusted_keys = NULL;
1058         ldns_rr_list * ds_keys = NULL;
1059
1060         if (res && domain && keys) {
1061
1062                 if ((trusted_keys = ldns_validate_domain_dnskey(res,
1063                                          domain,
1064                                          keys))) {
1065                         *status = LDNS_STATUS_OK;
1066                 } else {
1067                         /* No trusted keys in this domain, we'll have to find some in the parent domain */
1068                         *status = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY;
1069
1070                         if (ldns_rdf_size(domain) > 1) {
1071                                 /* Fail if we are at the root */
1072                                 ldns_rr_list * parent_keys;
1073                                 ldns_rdf * parent_domain = ldns_dname_left_chop(domain);
1074
1075                                 if ((parent_keys =
1076                                         ldns_fetch_valid_domain_keys(res,
1077                                              parent_domain,
1078                                              keys,
1079                                              status))) {
1080                                         /* Check DS records */
1081                                         if ((ds_keys =
1082                                                 ldns_validate_domain_ds(res,
1083                                                      domain,
1084                                                      parent_keys))) {
1085                                                 trusted_keys =
1086                                                         ldns_fetch_valid_domain_keys(res,
1087                                                              domain,
1088                                                              ds_keys,
1089                                                              status);
1090                                                 ldns_rr_list_deep_free(ds_keys);
1091                                         } else {
1092                                                 /* No valid DS at the parent -- fail */
1093                                                 *status = LDNS_STATUS_CRYPTO_NO_TRUSTED_DS ;
1094                                         }
1095                                         ldns_rr_list_deep_free(parent_keys);
1096                                 }
1097                                 ldns_rdf_deep_free(parent_domain);
1098                         }
1099                 }
1100         }
1101         return trusted_keys;
1102 }
1103
1104 ldns_rr_list *
1105 ldns_validate_domain_dnskey(const ldns_resolver * res,
1106                                            const ldns_rdf * domain,
1107                                            const ldns_rr_list * keys)
1108 {
1109         ldns_pkt * keypkt;
1110         ldns_rr * cur_key;
1111         uint16_t key_i; uint16_t key_j; uint16_t key_k;
1112         uint16_t sig_i; ldns_rr * cur_sig;
1113
1114         ldns_rr_list * domain_keys = NULL;
1115         ldns_rr_list * domain_sigs = NULL;
1116         ldns_rr_list * trusted_keys = NULL;
1117
1118         /* Fetch keys for the domain */
1119         if ((keypkt = ldns_resolver_query(res,
1120                                                             domain,
1121                                                             LDNS_RR_TYPE_DNSKEY,
1122                                                             LDNS_RR_CLASS_IN,
1123                                                             LDNS_RD))) {
1124
1125                 domain_keys = ldns_pkt_rr_list_by_type(keypkt,
1126                                                                             LDNS_RR_TYPE_DNSKEY,
1127                                                                             LDNS_SECTION_ANSWER);
1128                 domain_sigs = ldns_pkt_rr_list_by_type(keypkt,
1129                                                                             LDNS_RR_TYPE_RRSIG,
1130                                                                             LDNS_SECTION_ANSWER);
1131
1132                 /* Try to validate the record using our keys */
1133                 for (key_i=0; key_i< ldns_rr_list_rr_count(domain_keys); key_i++) {
1134
1135                         cur_key = ldns_rr_list_rr(domain_keys, key_i);
1136                         for (key_j=0; key_j<ldns_rr_list_rr_count(keys); key_j++) {
1137                                 if (ldns_rr_compare_ds(ldns_rr_list_rr(keys, key_j),
1138                                                                    cur_key)) {
1139
1140                                         /* Current key is trusted -- validate */
1141                                         trusted_keys = ldns_rr_list_new();
1142
1143                                         for (sig_i=0;
1144                                                 sig_i<ldns_rr_list_rr_count(domain_sigs);
1145                                                 sig_i++) {
1146                                                 cur_sig = ldns_rr_list_rr(domain_sigs, sig_i);
1147                                                 /* Avoid non-matching sigs */
1148                                                 if (ldns_rdf2native_int16(
1149                                                            ldns_rr_rrsig_keytag(cur_sig))
1150                                                     == ldns_calc_keytag(cur_key)) {
1151                                                         if (ldns_verify_rrsig(domain_keys,
1152                                                                                            cur_sig,
1153                                                                                            cur_key)
1154                                                             == LDNS_STATUS_OK) {
1155
1156                                                                 /* Push the whole rrset
1157                                                                    -- we can't do much more */
1158                                                                 for (key_k=0;
1159                                                                         key_k<ldns_rr_list_rr_count(
1160                                                                                         domain_keys);
1161                                                                         key_k++) {
1162                                                                         ldns_rr_list_push_rr(
1163                                                                             trusted_keys,
1164                                                                             ldns_rr_clone(
1165                                                                                    ldns_rr_list_rr(
1166                                                                                           domain_keys,
1167                                                                                           key_k)));
1168                                                                 }
1169
1170                                                                 ldns_rr_list_deep_free(domain_keys);
1171                                                                 ldns_rr_list_deep_free(domain_sigs);
1172                                                                 ldns_pkt_free(keypkt);
1173                                                                 return trusted_keys;
1174                                                         }
1175                                                 }
1176                                         }
1177
1178                                         /* Only push our trusted key */
1179                                         ldns_rr_list_push_rr(trusted_keys,
1180                                                                          ldns_rr_clone(cur_key));
1181                                 }
1182                         }
1183                 }
1184
1185                 ldns_rr_list_deep_free(domain_keys);
1186                 ldns_rr_list_deep_free(domain_sigs);
1187                 ldns_pkt_free(keypkt);
1188
1189         } else {
1190                 /* LDNS_STATUS_CRYPTO_NO_DNSKEY */
1191         }
1192
1193         return trusted_keys;
1194 }
1195
1196 ldns_rr_list *
1197 ldns_validate_domain_ds(const ldns_resolver *res,
1198                                     const ldns_rdf * domain,
1199                                     const ldns_rr_list * keys)
1200 {
1201         ldns_pkt * dspkt;
1202         uint16_t key_i;
1203         ldns_rr_list * rrset = NULL;
1204         ldns_rr_list * sigs = NULL;
1205         ldns_rr_list * trusted_keys = NULL;
1206
1207         /* Fetch DS for the domain */
1208         if ((dspkt = ldns_resolver_query(res,
1209                                                            domain,
1210                                                            LDNS_RR_TYPE_DS,
1211                                                            LDNS_RR_CLASS_IN,
1212                                                            LDNS_RD))) {
1213
1214                 rrset = ldns_pkt_rr_list_by_type(dspkt,
1215                                                                    LDNS_RR_TYPE_DS,
1216                                                                    LDNS_SECTION_ANSWER);
1217                 sigs = ldns_pkt_rr_list_by_type(dspkt,
1218                                                                   LDNS_RR_TYPE_RRSIG,
1219                                                                   LDNS_SECTION_ANSWER);
1220
1221                 /* Validate sigs */
1222                 if (ldns_verify(rrset, sigs, keys, NULL) == LDNS_STATUS_OK) {
1223                         trusted_keys = ldns_rr_list_new();
1224                         for (key_i=0; key_i<ldns_rr_list_rr_count(rrset); key_i++) {
1225                                 ldns_rr_list_push_rr(trusted_keys,
1226                                                                  ldns_rr_clone(ldns_rr_list_rr(rrset,
1227                                                                                                                  key_i)
1228                                                                                         )
1229                                                                  );
1230                         }
1231                 }
1232
1233                 ldns_rr_list_deep_free(rrset);
1234                 ldns_rr_list_deep_free(sigs);
1235                 ldns_pkt_free(dspkt);
1236
1237         } else {
1238                 /* LDNS_STATUS_CRYPTO_NO_DS */
1239         }
1240
1241         return trusted_keys;
1242 }
1243
1244 ldns_status
1245 ldns_verify_trusted(ldns_resolver *res,
1246                                 ldns_rr_list *rrset,
1247                                 ldns_rr_list * rrsigs,
1248                                 ldns_rr_list * validating_keys)
1249 {
1250         uint16_t sig_i; uint16_t key_i;
1251         ldns_rr * cur_sig; ldns_rr * cur_key;
1252         ldns_rr_list * trusted_keys = NULL;
1253         ldns_status result = LDNS_STATUS_ERR;
1254
1255         if (!res || !rrset || !rrsigs) {
1256                 return LDNS_STATUS_ERR;
1257         }
1258
1259         if (ldns_rr_list_rr_count(rrset) < 1) {
1260                 return LDNS_STATUS_ERR;
1261         }
1262
1263         if (ldns_rr_list_rr_count(rrsigs) < 1) {
1264                 return LDNS_STATUS_CRYPTO_NO_RRSIG;
1265         }
1266
1267         /* Look at each sig */
1268         for (sig_i=0; sig_i < ldns_rr_list_rr_count(rrsigs); sig_i++) {
1269
1270                 cur_sig = ldns_rr_list_rr(rrsigs, sig_i);
1271                 /* Get a valid signer key and validate the sig */
1272                 if ((trusted_keys = ldns_fetch_valid_domain_keys(
1273                                                     res,
1274                                                     ldns_rr_rrsig_signame(cur_sig),
1275                                                     ldns_resolver_dnssec_anchors(res),
1276                                                     &result))) {
1277
1278                         for (key_i = 0;
1279                                 key_i < ldns_rr_list_rr_count(trusted_keys);
1280                                 key_i++) {
1281                                 cur_key = ldns_rr_list_rr(trusted_keys, key_i);
1282
1283                                 if ((result = ldns_verify_rrsig(rrset,
1284                                                                                   cur_sig,
1285                                                                                   cur_key))
1286                                     == LDNS_STATUS_OK) {
1287                                         if (validating_keys) {
1288                                                 ldns_rr_list_push_rr(validating_keys,
1289                                                                                  ldns_rr_clone(cur_key));
1290                                         }
1291                                         ldns_rr_list_deep_free(trusted_keys);
1292                                         return LDNS_STATUS_OK;
1293                                 } else {
1294                                         ldns_rr_list_print(stdout, rrset);
1295                                         ldns_rr_print(stdout, cur_sig);
1296                                         ldns_rr_print(stdout, cur_key);
1297
1298                                 }
1299                         }
1300                 }
1301         }
1302
1303         ldns_rr_list_deep_free(trusted_keys);
1304         return result;
1305 }
1306
1307 ldns_status
1308 ldns_dnssec_verify_denial(ldns_rr *rr,
1309                           ldns_rr_list *nsecs,
1310                           ldns_rr_list *rrsigs)
1311 {
1312         ldns_rdf *rr_name;
1313         ldns_rdf *wildcard_name;
1314         ldns_rdf *chopped_dname;
1315         ldns_rr *cur_nsec;
1316         size_t i;
1317         ldns_status result;
1318         /* needed for wildcard check on exact match */
1319         ldns_rr *rrsig;
1320         bool name_covered = false;
1321         bool type_covered = false;
1322         bool wildcard_covered = false;
1323         bool wildcard_type_covered = false;
1324
1325         wildcard_name = ldns_dname_new_frm_str("*");
1326         rr_name = ldns_rr_owner(rr);
1327         chopped_dname = ldns_dname_left_chop(rr_name);
1328         result = ldns_dname_cat(wildcard_name, chopped_dname);
1329         if (result != LDNS_STATUS_OK) {
1330                 return result;
1331         }
1332
1333         ldns_rdf_deep_free(chopped_dname);
1334
1335         for  (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) {
1336                 cur_nsec = ldns_rr_list_rr(nsecs, i);
1337                 if (ldns_dname_compare(rr_name, ldns_rr_owner(cur_nsec)) == 0) {
1338                         /* see section 5.4 of RFC4035, if the label count of the NSEC's
1339                            RRSIG is equal, then it is proven that wildcard expansion
1340                            could not have been used to match the request */
1341                         rrsig = ldns_dnssec_get_rrsig_for_name_and_type(
1342                                           ldns_rr_owner(cur_nsec),
1343                                           ldns_rr_get_type(cur_nsec),
1344                                           rrsigs);
1345                         if (rrsig && ldns_rdf2native_int8(ldns_rr_rrsig_labels(rrsig))
1346                             == ldns_dname_label_count(rr_name)) {
1347                                 wildcard_covered = true;
1348                         }
1349
1350                         if (ldns_nsec_bitmap_covers_type(ldns_nsec_get_bitmap(cur_nsec),
1351                                                                            ldns_rr_get_type(rr))) {
1352                                 type_covered = true;
1353                         }
1354                 }
1355                 if (ldns_nsec_covers_name(cur_nsec, rr_name)) {
1356                         name_covered = true;
1357                 }
1358
1359                 if (ldns_dname_compare(wildcard_name,
1360                                                    ldns_rr_owner(cur_nsec)) == 0) {
1361                         if (ldns_nsec_bitmap_covers_type(ldns_nsec_get_bitmap(cur_nsec),
1362                                                                            ldns_rr_get_type(rr))) {
1363                                 wildcard_type_covered = true;
1364                         }
1365                 }
1366
1367                 if (ldns_nsec_covers_name(cur_nsec, wildcard_name)) {
1368                         wildcard_covered = true;
1369                 }
1370
1371         }
1372
1373         ldns_rdf_deep_free(wildcard_name);
1374
1375         if (type_covered || !name_covered) {
1376                 return LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1377         }
1378
1379         if (wildcard_type_covered || !wildcard_covered) {
1380                 return LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED;
1381         }
1382
1383         return LDNS_STATUS_OK;
1384 }
1385
1386 #ifdef HAVE_SSL
1387 ldns_status
1388 ldns_dnssec_verify_denial_nsec3(ldns_rr *rr,
1389                                                   ldns_rr_list *nsecs,
1390                                                   ldns_rr_list *rrsigs,
1391                                                   ldns_pkt_rcode packet_rcode,
1392                                                   ldns_rr_type packet_qtype,
1393                                                   bool packet_nodata)
1394 {
1395         ldns_rdf *closest_encloser;
1396         ldns_rdf *wildcard;
1397         ldns_rdf *hashed_wildcard_name;
1398         bool wildcard_covered = false;
1399         ldns_rdf *zone_name;
1400         ldns_rdf *hashed_name;
1401         size_t i;
1402         ldns_status result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1403
1404         rrsigs = rrsigs;
1405
1406         zone_name = ldns_dname_left_chop(ldns_rr_owner(ldns_rr_list_rr(nsecs,0)));
1407
1408         /* section 8.4 */
1409         if (packet_rcode == LDNS_RCODE_NXDOMAIN) {
1410                 closest_encloser = ldns_dnssec_nsec3_closest_encloser(
1411                                                    ldns_rr_owner(rr),
1412                                                    ldns_rr_get_type(rr),
1413                                                    nsecs);
1414                 if(!closest_encloser) {
1415                         result = LDNS_STATUS_NSEC3_ERR;
1416                         goto done;
1417                 }
1418
1419                 wildcard = ldns_dname_new_frm_str("*");
1420                 (void) ldns_dname_cat(wildcard, closest_encloser);
1421
1422                 for (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) {
1423                         hashed_wildcard_name =
1424                                 ldns_nsec3_hash_name_frm_nsec3(ldns_rr_list_rr(nsecs, 0),
1425                                                                                  wildcard
1426                                                                                  );
1427                         (void) ldns_dname_cat(hashed_wildcard_name, zone_name);
1428
1429                         if (ldns_nsec_covers_name(ldns_rr_list_rr(nsecs, i),
1430                                                                  hashed_wildcard_name)) {
1431                                 wildcard_covered = true;
1432                         }
1433                         ldns_rdf_deep_free(hashed_wildcard_name);
1434                 }
1435
1436                 ldns_rdf_deep_free(closest_encloser);
1437                 ldns_rdf_deep_free(wildcard);
1438
1439                 if (!wildcard_covered) {
1440                         result = LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED;
1441                 } else if (closest_encloser && wildcard_covered) {
1442                         result = LDNS_STATUS_OK;
1443                 } else {
1444                         result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1445                 }
1446         } else if (packet_nodata && packet_qtype != LDNS_RR_TYPE_DS) {
1447                 /* section 8.5 */
1448                 hashed_name = ldns_nsec3_hash_name_frm_nsec3(
1449                                    ldns_rr_list_rr(nsecs, 0),
1450                                    ldns_rr_owner(rr));
1451                 (void) ldns_dname_cat(hashed_name, zone_name);
1452                 for (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) {
1453                         if (ldns_dname_compare(hashed_name,
1454                                  ldns_rr_owner(ldns_rr_list_rr(nsecs, i)))
1455                             == 0) {
1456                                 if (!ldns_nsec_bitmap_covers_type(
1457                                             ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
1458                                             packet_qtype)
1459                                     &&
1460                                     !ldns_nsec_bitmap_covers_type(
1461                                             ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
1462                                             LDNS_RR_TYPE_CNAME)) {
1463                                         result = LDNS_STATUS_OK;
1464                                         goto done;
1465                                 }
1466                         }
1467                 }
1468                 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1469         } else if (packet_nodata && packet_qtype == LDNS_RR_TYPE_DS) {
1470                 /* section 8.6 */
1471                 /* note: up to XXX this is the same as for 8.5 */
1472                 hashed_name = ldns_nsec3_hash_name_frm_nsec3(ldns_rr_list_rr(nsecs,
1473                                                                                                                  0),
1474                                                                                         ldns_rr_owner(rr)
1475                                                                                         );
1476                 (void) ldns_dname_cat(hashed_name, zone_name);
1477                 for (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) {
1478                         if (ldns_dname_compare(hashed_name,
1479                                                            ldns_rr_owner(ldns_rr_list_rr(nsecs,
1480                                                                                                            i)))
1481                             == 0) {
1482                                 if (!ldns_nsec_bitmap_covers_type(
1483                                             ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
1484                                             LDNS_RR_TYPE_DS)
1485                                     &&
1486                                     !ldns_nsec_bitmap_covers_type(
1487                                             ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
1488                                             LDNS_RR_TYPE_CNAME)) {
1489                                         result = LDNS_STATUS_OK;
1490                                         goto done;
1491                                 }
1492                         }
1493                 }
1494
1495                 /* XXX see note above */
1496                 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1497         }
1498
1499  done:
1500         ldns_rdf_deep_free(zone_name);
1501         return result;
1502 }
1503 #endif /* HAVE_SSL */
1504
1505 #ifdef USE_GOST
1506 EVP_PKEY*
1507 ldns_gost2pkey_raw(unsigned char* key, size_t keylen)
1508 {
1509         /* prefix header for X509 encoding */
1510         uint8_t asn[37] = { 0x30, 0x63, 0x30, 0x1c, 0x06, 0x06, 0x2a, 0x85,
1511                 0x03, 0x02, 0x02, 0x13, 0x30, 0x12, 0x06, 0x07, 0x2a, 0x85,
1512                 0x03, 0x02, 0x02, 0x23, 0x01, 0x06, 0x07, 0x2a, 0x85, 0x03,
1513                 0x02, 0x02, 0x1e, 0x01, 0x03, 0x43, 0x00, 0x04, 0x40};
1514         unsigned char encoded[37+64];
1515         const unsigned char* pp;
1516         if(keylen != 64) {
1517                 /* key wrong size */
1518                 return NULL;
1519         }
1520
1521         /* create evp_key */
1522         memmove(encoded, asn, 37);
1523         memmove(encoded+37, key, 64);
1524         pp = (unsigned char*)&encoded[0];
1525
1526         return d2i_PUBKEY(NULL, &pp, sizeof(encoded));
1527 }
1528
1529 static ldns_status
1530 ldns_verify_rrsig_gost_raw(unsigned char* sig, size_t siglen,
1531         ldns_buffer* rrset, unsigned char* key, size_t keylen)
1532 {
1533         EVP_PKEY *evp_key;
1534         ldns_status result;
1535
1536         (void) ldns_key_EVP_load_gost_id();
1537         evp_key = ldns_gost2pkey_raw(key, keylen);
1538         if(!evp_key) {
1539                 /* could not convert key */
1540                 return LDNS_STATUS_CRYPTO_BOGUS;
1541         }
1542
1543         /* verify signature */
1544         result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset,
1545                 evp_key, EVP_get_digestbyname("md_gost94"));
1546         EVP_PKEY_free(evp_key);
1547
1548         return result;
1549 }
1550 #endif
1551
1552 #ifdef USE_ECDSA
1553 EVP_PKEY*
1554 ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
1555 {
1556         unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */
1557         const unsigned char* pp = buf;
1558         EVP_PKEY *evp_key;
1559         EC_KEY *ec;
1560         /* check length, which uncompressed must be 2 bignums */
1561         if(algo == LDNS_ECDSAP256SHA256) {
1562                 if(keylen != 2*256/8) return NULL;
1563                 ec = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1564         } else if(algo == LDNS_ECDSAP384SHA384) {
1565                 if(keylen != 2*384/8) return NULL;
1566                 ec = EC_KEY_new_by_curve_name(NID_secp384r1);
1567         } else    ec = NULL;
1568         if(!ec) return NULL;
1569         if(keylen+1 > sizeof(buf))
1570                 return NULL; /* sanity check */
1571         /* prepend the 0x02 (from docs) (or actually 0x04 from implementation
1572          * of openssl) for uncompressed data */
1573         buf[0] = POINT_CONVERSION_UNCOMPRESSED;
1574         memmove(buf+1, key, keylen);
1575         if(!o2i_ECPublicKey(&ec, &pp, keylen+1)) {
1576                 EC_KEY_free(ec);
1577                 return NULL;
1578         }
1579         evp_key = EVP_PKEY_new();
1580         if(!evp_key) {
1581                 EC_KEY_free(ec);
1582                 return NULL;
1583         }
1584         EVP_PKEY_assign_EC_KEY(evp_key, ec);
1585         return evp_key;
1586 }
1587
1588 static ldns_status
1589 ldns_verify_rrsig_ecdsa_raw(unsigned char* sig, size_t siglen,
1590         ldns_buffer* rrset, unsigned char* key, size_t keylen, uint8_t algo)
1591 {
1592         EVP_PKEY *evp_key;
1593         ldns_status result;
1594         const EVP_MD *d;
1595
1596         evp_key = ldns_ecdsa2pkey_raw(key, keylen, algo);
1597         if(!evp_key) {
1598                 /* could not convert key */
1599                 return LDNS_STATUS_CRYPTO_BOGUS;
1600         }
1601         if(algo == LDNS_ECDSAP256SHA256)
1602                 d = EVP_sha256();
1603         else    d = EVP_sha384(); /* LDNS_ECDSAP384SHA384 */
1604         result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, d);
1605         EVP_PKEY_free(evp_key);
1606         return result;
1607 }
1608 #endif
1609
1610 ldns_status
1611 ldns_verify_rrsig_buffers(ldns_buffer *rawsig_buf, ldns_buffer *verify_buf,
1612                                          ldns_buffer *key_buf, uint8_t algo)
1613 {
1614         return ldns_verify_rrsig_buffers_raw(
1615                          (unsigned char*)ldns_buffer_begin(rawsig_buf),
1616                          ldns_buffer_position(rawsig_buf),
1617                          verify_buf,
1618                          (unsigned char*)ldns_buffer_begin(key_buf),
1619                          ldns_buffer_position(key_buf), algo);
1620 }
1621
1622 ldns_status
1623 ldns_verify_rrsig_buffers_raw(unsigned char* sig, size_t siglen,
1624                                                 ldns_buffer *verify_buf, unsigned char* key, size_t keylen,
1625                                                 uint8_t algo)
1626 {
1627         /* check for right key */
1628         switch(algo) {
1629         case LDNS_DSA:
1630         case LDNS_DSA_NSEC3:
1631                 return ldns_verify_rrsig_dsa_raw(sig,
1632                                                                    siglen,
1633                                                                    verify_buf,
1634                                                                    key,
1635                                                                    keylen);
1636                 break;
1637         case LDNS_RSASHA1:
1638         case LDNS_RSASHA1_NSEC3:
1639                 return ldns_verify_rrsig_rsasha1_raw(sig,
1640                                                                           siglen,
1641                                                                           verify_buf,
1642                                                                           key,
1643                                                                           keylen);
1644                 break;
1645 #ifdef USE_SHA2
1646         case LDNS_RSASHA256:
1647                 return ldns_verify_rrsig_rsasha256_raw(sig,
1648                                                                             siglen,
1649                                                                             verify_buf,
1650                                                                             key,
1651                                                                             keylen);
1652                 break;
1653         case LDNS_RSASHA512:
1654                 return ldns_verify_rrsig_rsasha512_raw(sig,
1655                                                                             siglen,
1656                                                                             verify_buf,
1657                                                                             key,
1658                                                                             keylen);
1659                 break;
1660 #endif
1661 #ifdef USE_GOST
1662         case LDNS_ECC_GOST:
1663                 return ldns_verify_rrsig_gost_raw(sig, siglen, verify_buf,
1664                         key, keylen);
1665                 break;
1666 #endif
1667 #ifdef USE_ECDSA
1668         case LDNS_ECDSAP256SHA256:
1669         case LDNS_ECDSAP384SHA384:
1670                 return ldns_verify_rrsig_ecdsa_raw(sig, siglen, verify_buf,
1671                         key, keylen, algo);
1672                 break;
1673 #endif
1674         case LDNS_RSAMD5:
1675                 return ldns_verify_rrsig_rsamd5_raw(sig,
1676                                                                          siglen,
1677                                                                          verify_buf,
1678                                                                          key,
1679                                                                          keylen);
1680                 break;
1681         default:
1682                 /* do you know this alg?! */
1683                 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
1684         }
1685 }
1686
1687
1688 /**
1689  * Reset the ttl in the rrset with the orig_ttl from the sig
1690  * and update owner name if it was wildcard
1691  * Also canonicalizes the rrset.
1692  * @param rrset: rrset to modify
1693  * @param sig: signature to take TTL and wildcard values from
1694  */
1695 static void
1696 ldns_rrset_use_signature_ttl(ldns_rr_list* rrset_clone, ldns_rr* rrsig)
1697 {
1698         uint32_t orig_ttl;
1699         uint16_t i;
1700         uint8_t label_count;
1701         ldns_rdf *wildcard_name;
1702         ldns_rdf *wildcard_chopped;
1703         ldns_rdf *wildcard_chopped_tmp;
1704
1705         orig_ttl = ldns_rdf2native_int32( ldns_rr_rdf(rrsig, 3));
1706         label_count = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 2));
1707
1708         for(i = 0; i < ldns_rr_list_rr_count(rrset_clone); i++) {
1709                 if (label_count <
1710                     ldns_dname_label_count(
1711                            ldns_rr_owner(ldns_rr_list_rr(rrset_clone, i)))) {
1712                         (void) ldns_str2rdf_dname(&wildcard_name, "*");
1713                         wildcard_chopped = ldns_rdf_clone(ldns_rr_owner(
1714                                 ldns_rr_list_rr(rrset_clone, i)));
1715                         while (label_count < ldns_dname_label_count(wildcard_chopped)) {
1716                                 wildcard_chopped_tmp = ldns_dname_left_chop(
1717                                         wildcard_chopped);
1718                                 ldns_rdf_deep_free(wildcard_chopped);
1719                                 wildcard_chopped = wildcard_chopped_tmp;
1720                         }
1721                         (void) ldns_dname_cat(wildcard_name, wildcard_chopped);
1722                         ldns_rdf_deep_free(wildcard_chopped);
1723                         ldns_rdf_deep_free(ldns_rr_owner(ldns_rr_list_rr(
1724                                 rrset_clone, i)));
1725                         ldns_rr_set_owner(ldns_rr_list_rr(rrset_clone, i),
1726                                 wildcard_name);
1727                 }
1728                 ldns_rr_set_ttl(ldns_rr_list_rr(rrset_clone, i), orig_ttl);
1729                 /* convert to lowercase */
1730                 ldns_rr2canonical(ldns_rr_list_rr(rrset_clone, i));
1731         }
1732 }
1733
1734 /**
1735  * Make raw signature buffer out of rrsig
1736  * @param rawsig_buf: raw signature buffer for result
1737  * @param rrsig: signature to convert
1738  * @return OK or more specific error.
1739  */
1740 static ldns_status
1741 ldns_rrsig2rawsig_buffer(ldns_buffer* rawsig_buf, ldns_rr* rrsig)
1742 {
1743         uint8_t sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1));
1744         /* check for known and implemented algo's now (otherwise
1745          * the function could return a wrong error
1746          */
1747         /* create a buffer with signature rdata */
1748         /* for some algorithms we need other data than for others... */
1749         /* (the DSA API wants DER encoding for instance) */
1750
1751         switch(sig_algo) {
1752         case LDNS_RSAMD5:
1753         case LDNS_RSASHA1:
1754         case LDNS_RSASHA1_NSEC3:
1755 #ifdef USE_SHA2
1756         case LDNS_RSASHA256:
1757         case LDNS_RSASHA512:
1758 #endif
1759 #ifdef USE_GOST
1760         case LDNS_ECC_GOST:
1761 #endif
1762                 if (ldns_rdf2buffer_wire(rawsig_buf,
1763                     ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1764                         return LDNS_STATUS_MEM_ERR;
1765                 }
1766                 break;
1767         case LDNS_DSA:
1768         case LDNS_DSA_NSEC3:
1769                 /* EVP takes rfc2459 format, which is a tad longer than dns format */
1770                 if (ldns_convert_dsa_rrsig_rdf2asn1(rawsig_buf,
1771                         ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1772                         /*
1773                           if (ldns_rdf2buffer_wire(rawsig_buf,
1774                           ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1775                         */
1776                         return LDNS_STATUS_MEM_ERR;
1777                 }
1778                 break;
1779 #ifdef USE_ECDSA
1780         case LDNS_ECDSAP256SHA256:
1781         case LDNS_ECDSAP384SHA384:
1782                 /* EVP produces an ASN prefix on the signature, which is
1783                  * not used in the DNS */
1784                 if (ldns_convert_ecdsa_rrsig_rdf2asn1(rawsig_buf,
1785                         ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1786                         return LDNS_STATUS_MEM_ERR;
1787                 }
1788                 break;
1789 #endif
1790         case LDNS_DH:
1791         case LDNS_ECC:
1792         case LDNS_INDIRECT:
1793                 return LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL;
1794         default:
1795                 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
1796         }
1797         return LDNS_STATUS_OK;
1798 }
1799
1800 /**
1801  * Check RRSIG timestamps against the given 'now' time.
1802  * @param rrsig: signature to check.
1803  * @param now: the current time in seconds epoch.
1804  * @return status code LDNS_STATUS_OK if all is fine.
1805  */
1806 static ldns_status
1807 ldns_rrsig_check_timestamps(ldns_rr* rrsig, int32_t now)
1808 {
1809         int32_t inception, expiration;
1810
1811         /* check the signature time stamps */
1812         inception = (int32_t)ldns_rdf2native_time_t(
1813                 ldns_rr_rrsig_inception(rrsig));
1814         expiration = (int32_t)ldns_rdf2native_time_t(
1815                 ldns_rr_rrsig_expiration(rrsig));
1816
1817         if (expiration - inception < 0) {
1818                 /* bad sig, expiration before inception?? Tsssg */
1819                 return LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION;
1820         }
1821         if (now - inception < 0) {
1822                 /* bad sig, inception date has not yet come to pass */
1823                 return LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED;
1824         }
1825         if (expiration - now < 0) {
1826                 /* bad sig, expiration date has passed */
1827                 return LDNS_STATUS_CRYPTO_SIG_EXPIRED;
1828         }
1829         return LDNS_STATUS_OK;
1830 }
1831
1832 /**
1833  * Prepare for verification.
1834  * @param rawsig_buf: raw signature buffer made ready.
1835  * @param verify_buf: data for verification buffer made ready.
1836  * @param rrset_clone: made ready.
1837  * @param rrsig: signature to prepare for.
1838  * @return LDNS_STATUS_OK is all went well. Otherwise specific error.
1839  */
1840 static ldns_status
1841 ldns_prepare_for_verify(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
1842         ldns_rr_list* rrset_clone, ldns_rr* rrsig)
1843 {
1844         ldns_status result;
1845
1846         /* canonicalize the sig */
1847         ldns_dname2canonical(ldns_rr_owner(rrsig));
1848
1849         /* check if the typecovered is equal to the type checked */
1850         if (ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(rrsig)) !=
1851             ldns_rr_get_type(ldns_rr_list_rr(rrset_clone, 0)))
1852                 return LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR;
1853
1854         /* create a buffer with b64 signature rdata */
1855         result = ldns_rrsig2rawsig_buffer(rawsig_buf, rrsig);
1856         if(result != LDNS_STATUS_OK)
1857                 return result;
1858
1859         /* use TTL from signature. Use wildcard names for wildcards */
1860         /* also canonicalizes rrset_clone */
1861         ldns_rrset_use_signature_ttl(rrset_clone, rrsig);
1862
1863         /* sort the rrset in canonical order  */
1864         ldns_rr_list_sort(rrset_clone);
1865
1866         /* put the signature rr (without the b64) to the verify_buf */
1867         if (ldns_rrsig2buffer_wire(verify_buf, rrsig) != LDNS_STATUS_OK)
1868                 return LDNS_STATUS_MEM_ERR;
1869
1870         /* add the rrset in verify_buf */
1871         if(ldns_rr_list2buffer_wire(verify_buf, rrset_clone)
1872                 != LDNS_STATUS_OK)
1873                 return LDNS_STATUS_MEM_ERR;
1874
1875         return LDNS_STATUS_OK;
1876 }
1877
1878 /**
1879  * Check if a key matches a signature.
1880  * Checks keytag, sigalgo and signature.
1881  * @param rawsig_buf: raw signature buffer for verify
1882  * @param verify_buf: raw data buffer for verify
1883  * @param rrsig: the rrsig
1884  * @param key: key to attempt.
1885  * @return LDNS_STATUS_OK if OK, else some specific error.
1886  */
1887 static ldns_status
1888 ldns_verify_test_sig_key(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
1889         ldns_rr* rrsig, ldns_rr* key)
1890 {
1891         uint8_t sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1));
1892
1893         /* before anything, check if the keytags match */
1894         if (ldns_calc_keytag(key)
1895             ==
1896             ldns_rdf2native_int16(ldns_rr_rrsig_keytag(rrsig))
1897             ) {
1898                 ldns_buffer* key_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1899                 ldns_status result = LDNS_STATUS_ERR;
1900
1901                 /* put the key-data in a buffer, that's the third rdf, with
1902                  * the base64 encoded key data */
1903                 if (ldns_rdf2buffer_wire(key_buf, ldns_rr_rdf(key, 3))
1904                         != LDNS_STATUS_OK) {
1905                         ldns_buffer_free(key_buf);
1906                         /* returning is bad might screw up
1907                            good keys later in the list
1908                            what to do? */
1909                         return LDNS_STATUS_ERR;
1910                 }
1911
1912                 if (sig_algo == ldns_rdf2native_int8(ldns_rr_rdf(key, 2))) {
1913                         result = ldns_verify_rrsig_buffers(rawsig_buf,
1914                                 verify_buf, key_buf, sig_algo);
1915                 } else {
1916                         /* No keys with the corresponding algorithm are found */
1917                         result = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY;
1918                 }
1919
1920                 ldns_buffer_free(key_buf);
1921                 return result;
1922         }
1923         else {
1924                 /* No keys with the corresponding keytag are found */
1925                 return LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY;
1926         }
1927 }
1928
1929 /*
1930  * to verify:
1931  * - create the wire fmt of the b64 key rdata
1932  * - create the wire fmt of the sorted rrset
1933  * - create the wire fmt of the b64 sig rdata
1934  * - create the wire fmt of the sig without the b64 rdata
1935  * - cat the sig data (without b64 rdata) to the rrset
1936  * - verify the rrset+sig, with the b64 data and the b64 key data
1937  */
1938 ldns_status
1939 ldns_verify_rrsig_keylist(ldns_rr_list *rrset,
1940                                          ldns_rr *rrsig,
1941                                          const ldns_rr_list *keys,
1942                                          ldns_rr_list *good_keys)
1943 {
1944         ldns_status result;
1945         ldns_rr_list *valid = ldns_rr_list_new();
1946         if (!valid)
1947                 return LDNS_STATUS_MEM_ERR;
1948
1949         result = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, valid);
1950         if(result != LDNS_STATUS_OK) {
1951                 ldns_rr_list_free(valid);
1952                 return result;
1953         }
1954
1955         /* check timestamps last; its OK except time */
1956         result = ldns_rrsig_check_timestamps(rrsig, (int32_t)time(NULL));
1957         if(result != LDNS_STATUS_OK) {
1958                 ldns_rr_list_free(valid);
1959                 return result;
1960         }
1961
1962         ldns_rr_list_cat(good_keys, valid);
1963         ldns_rr_list_free(valid);
1964         return LDNS_STATUS_OK;
1965 }
1966
1967 ldns_status
1968 ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset,
1969                                          ldns_rr *rrsig,
1970                                          const ldns_rr_list *keys,
1971                                          ldns_rr_list *good_keys)
1972 {
1973         ldns_buffer *rawsig_buf;
1974         ldns_buffer *verify_buf;
1975         uint16_t i;
1976         ldns_status result, status;
1977         ldns_rr_list *rrset_clone;
1978         ldns_rr_list *validkeys;
1979
1980         if (!rrset) {
1981                 return LDNS_STATUS_ERR;
1982         }
1983
1984         validkeys = ldns_rr_list_new();
1985         if (!validkeys) {
1986                 return LDNS_STATUS_MEM_ERR;
1987         }
1988
1989         /* clone the rrset so that we can fiddle with it */
1990         rrset_clone = ldns_rr_list_clone(rrset);
1991
1992         /* create the buffers which will certainly hold the raw data */
1993         rawsig_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1994         verify_buf  = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1995
1996         result = ldns_prepare_for_verify(rawsig_buf, verify_buf,
1997                 rrset_clone, rrsig);
1998         if(result != LDNS_STATUS_OK) {
1999                 ldns_buffer_free(verify_buf);
2000                 ldns_buffer_free(rawsig_buf);
2001                 ldns_rr_list_deep_free(rrset_clone);
2002                 ldns_rr_list_free(validkeys);
2003                 return result;
2004         }
2005
2006         result = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY;
2007         for(i = 0; i < ldns_rr_list_rr_count(keys); i++) {
2008                 status = ldns_verify_test_sig_key(rawsig_buf, verify_buf,
2009                         rrsig, ldns_rr_list_rr(keys, i));
2010                 if (status == LDNS_STATUS_OK) {
2011                         /* one of the keys has matched, don't break
2012                          * here, instead put the 'winning' key in
2013                          * the validkey list and return the list
2014                          * later */
2015                         if (!ldns_rr_list_push_rr(validkeys,
2016                                 ldns_rr_list_rr(keys,i))) {
2017                                 /* couldn't push the key?? */
2018                                 ldns_buffer_free(rawsig_buf);
2019                                 ldns_buffer_free(verify_buf);
2020                                 ldns_rr_list_deep_free(rrset_clone);
2021                                 ldns_rr_list_free(validkeys);
2022                                 return LDNS_STATUS_MEM_ERR;
2023                         }
2024
2025                         result = status;
2026                 }
2027
2028                 if (result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) {
2029                         result = status;
2030                 }
2031         }
2032
2033         /* no longer needed */
2034         ldns_rr_list_deep_free(rrset_clone);
2035         ldns_buffer_free(rawsig_buf);
2036         ldns_buffer_free(verify_buf);
2037
2038         if (ldns_rr_list_rr_count(validkeys) == 0) {
2039                 /* no keys were added, return last error */
2040                 ldns_rr_list_free(validkeys);
2041                 return result;
2042         }
2043
2044         /* do not check timestamps */
2045
2046         ldns_rr_list_cat(good_keys, validkeys);
2047         ldns_rr_list_free(validkeys);
2048         return LDNS_STATUS_OK;
2049 }
2050
2051 ldns_status
2052 ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key)
2053 {
2054         ldns_buffer *rawsig_buf;
2055         ldns_buffer *verify_buf;
2056         ldns_status result;
2057         ldns_rr_list *rrset_clone;
2058
2059         if (!rrset) {
2060                 return LDNS_STATUS_NO_DATA;
2061         }
2062         /* clone the rrset so that we can fiddle with it */
2063         rrset_clone = ldns_rr_list_clone(rrset);
2064         /* create the buffers which will certainly hold the raw data */
2065         rawsig_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2066         verify_buf  = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2067
2068         result = ldns_prepare_for_verify(rawsig_buf, verify_buf,
2069                 rrset_clone, rrsig);
2070         if(result != LDNS_STATUS_OK) {
2071                 ldns_rr_list_deep_free(rrset_clone);
2072                 ldns_buffer_free(rawsig_buf);
2073                 ldns_buffer_free(verify_buf);
2074                 return result;
2075         }
2076         result = ldns_verify_test_sig_key(rawsig_buf, verify_buf,
2077                 rrsig, key);
2078         /* no longer needed */
2079         ldns_rr_list_deep_free(rrset_clone);
2080         ldns_buffer_free(rawsig_buf);
2081         ldns_buffer_free(verify_buf);
2082
2083         /* check timestamp last, apart from time its OK */
2084         if(result == LDNS_STATUS_OK)
2085                 result = ldns_rrsig_check_timestamps(rrsig,
2086                         (int32_t)time(NULL));
2087
2088         return result;
2089 }
2090
2091 ldns_status
2092 ldns_verify_rrsig_evp(ldns_buffer *sig,
2093                                   ldns_buffer *rrset,
2094                                   EVP_PKEY *key,
2095                                   const EVP_MD *digest_type)
2096 {
2097         return ldns_verify_rrsig_evp_raw(
2098                          (unsigned char*)ldns_buffer_begin(sig),
2099                          ldns_buffer_position(sig),
2100                          rrset,
2101                          key,
2102                          digest_type);
2103 }
2104
2105 ldns_status
2106 ldns_verify_rrsig_evp_raw(unsigned char *sig, size_t siglen,
2107                                          ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type)
2108 {
2109         EVP_MD_CTX ctx;
2110         int res;
2111
2112         EVP_MD_CTX_init(&ctx);
2113
2114         EVP_VerifyInit(&ctx, digest_type);
2115         EVP_VerifyUpdate(&ctx,
2116                                   ldns_buffer_begin(rrset),
2117                                   ldns_buffer_position(rrset));
2118         res = EVP_VerifyFinal(&ctx, sig, (unsigned int) siglen, key);
2119
2120         EVP_MD_CTX_cleanup(&ctx);
2121
2122         if (res == 1) {
2123                 return LDNS_STATUS_OK;
2124         } else if (res == 0) {
2125                 return LDNS_STATUS_CRYPTO_BOGUS;
2126         }
2127         /* TODO how to communicate internal SSL error?
2128            let caller use ssl's get_error() */
2129         return LDNS_STATUS_SSL_ERR;
2130 }
2131
2132 ldns_status
2133 ldns_verify_rrsig_dsa(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2134 {
2135         return ldns_verify_rrsig_dsa_raw(
2136                          (unsigned char*) ldns_buffer_begin(sig),
2137                          ldns_buffer_position(sig),
2138                          rrset,
2139                          (unsigned char*) ldns_buffer_begin(key),
2140                          ldns_buffer_position(key));
2141 }
2142
2143 ldns_status
2144 ldns_verify_rrsig_rsasha1(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2145 {
2146         return ldns_verify_rrsig_rsasha1_raw(
2147                          (unsigned char*)ldns_buffer_begin(sig),
2148                          ldns_buffer_position(sig),
2149                          rrset,
2150                          (unsigned char*) ldns_buffer_begin(key),
2151                          ldns_buffer_position(key));
2152 }
2153
2154 ldns_status
2155 ldns_verify_rrsig_rsamd5(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2156 {
2157         return ldns_verify_rrsig_rsamd5_raw(
2158                          (unsigned char*)ldns_buffer_begin(sig),
2159                          ldns_buffer_position(sig),
2160                          rrset,
2161                          (unsigned char*) ldns_buffer_begin(key),
2162                          ldns_buffer_position(key));
2163 }
2164
2165 ldns_status
2166 ldns_verify_rrsig_dsa_raw(unsigned char* sig, size_t siglen,
2167                                          ldns_buffer* rrset, unsigned char* key, size_t keylen)
2168 {
2169         EVP_PKEY *evp_key;
2170         ldns_status result;
2171
2172         evp_key = EVP_PKEY_new();
2173         EVP_PKEY_assign_DSA(evp_key, ldns_key_buf2dsa_raw(key, keylen));
2174         result = ldns_verify_rrsig_evp_raw(sig,
2175                                                                 siglen,
2176                                                                 rrset,
2177                                                                 evp_key,
2178                                                                 EVP_dss1());
2179         EVP_PKEY_free(evp_key);
2180         return result;
2181
2182 }
2183
2184 ldns_status
2185 ldns_verify_rrsig_rsasha1_raw(unsigned char* sig, size_t siglen,
2186                                                 ldns_buffer* rrset, unsigned char* key, size_t keylen)
2187 {
2188         EVP_PKEY *evp_key;
2189         ldns_status result;
2190
2191         evp_key = EVP_PKEY_new();
2192         EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen));
2193         result = ldns_verify_rrsig_evp_raw(sig,
2194                                                                 siglen,
2195                                                                 rrset,
2196                                                                 evp_key,
2197                                                                 EVP_sha1());
2198         EVP_PKEY_free(evp_key);
2199
2200         return result;
2201 }
2202
2203 ldns_status
2204 ldns_verify_rrsig_rsasha256_raw(unsigned char* sig,
2205                                                   size_t siglen,
2206                                                   ldns_buffer* rrset,
2207                                                   unsigned char* key,
2208                                                   size_t keylen)
2209 {
2210 #ifdef USE_SHA2
2211         EVP_PKEY *evp_key;
2212         ldns_status result;
2213
2214         evp_key = EVP_PKEY_new();
2215         EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen));
2216         result = ldns_verify_rrsig_evp_raw(sig,
2217                                                                 siglen,
2218                                                                 rrset,
2219                                                                 evp_key,
2220                                                                 EVP_sha256());
2221         EVP_PKEY_free(evp_key);
2222
2223         return result;
2224 #else
2225         /* touch these to prevent compiler warnings */
2226         (void) sig;
2227         (void) siglen;
2228         (void) rrset;
2229         (void) key;
2230         (void) keylen;
2231         return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
2232 #endif
2233 }
2234
2235 ldns_status
2236 ldns_verify_rrsig_rsasha512_raw(unsigned char* sig,
2237                                                   size_t siglen,
2238                                                   ldns_buffer* rrset,
2239                                                   unsigned char* key,
2240                                                   size_t keylen)
2241 {
2242 #ifdef USE_SHA2
2243         EVP_PKEY *evp_key;
2244         ldns_status result;
2245
2246         evp_key = EVP_PKEY_new();
2247         EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen));
2248         result = ldns_verify_rrsig_evp_raw(sig,
2249                                                                 siglen,
2250                                                                 rrset,
2251                                                                 evp_key,
2252                                                                 EVP_sha512());
2253         EVP_PKEY_free(evp_key);
2254
2255         return result;
2256 #else
2257         /* touch these to prevent compiler warnings */
2258         (void) sig;
2259         (void) siglen;
2260         (void) rrset;
2261         (void) key;
2262         (void) keylen;
2263         return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
2264 #endif
2265 }
2266
2267
2268 ldns_status
2269 ldns_verify_rrsig_rsamd5_raw(unsigned char* sig,
2270                                             size_t siglen,
2271                                             ldns_buffer* rrset,
2272                                             unsigned char* key,
2273                                             size_t keylen)
2274 {
2275         EVP_PKEY *evp_key;
2276         ldns_status result;
2277
2278         evp_key = EVP_PKEY_new();
2279         EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen));
2280         result = ldns_verify_rrsig_evp_raw(sig,
2281                                                                 siglen,
2282                                                                 rrset,
2283                                                                 evp_key,
2284                                                                 EVP_md5());
2285         EVP_PKEY_free(evp_key);
2286
2287         return result;
2288 }
2289
2290 #endif