1 #include <ldns/config.h>
9 /* this entire file is rather useless when you don't have
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>
18 ldns_dnssec_data_chain *
19 ldns_dnssec_data_chain_new()
21 ldns_dnssec_data_chain *nc = LDNS_XMALLOC(ldns_dnssec_data_chain, 1);
25 nc->signatures = NULL;
28 nc->packet_nodata = false;
33 ldns_dnssec_data_chain_free(ldns_dnssec_data_chain *chain)
39 ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain)
41 ldns_rr_list_deep_free(chain->rrset);
42 ldns_rr_list_deep_free(chain->signatures);
44 ldns_dnssec_data_chain_deep_free(chain->parent);
50 ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain)
52 ldns_lookup_table *rcode;
53 const ldns_rr_descriptor *rr_descriptor;
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);
60 fprintf(out, ";; rcode: %s\n", rcode->name);
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",
70 if (chain->packet_nodata) {
71 fprintf(out, ";; NODATA response\n");
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");
79 fprintf(out, "<no data>\n");
85 ldns_dnssec_build_data_chain_dnskey(ldns_resolver *res,
88 ldns_rr_list *signatures,
89 ldns_dnssec_data_chain *new_chain,
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;
98 keys = ldns_pkt_rr_list_by_name_and_type(
102 LDNS_SECTION_ANY_NOQUESTION
105 my_pkt = ldns_resolver_query(res,
110 keys = ldns_pkt_rr_list_by_name_and_type(
114 LDNS_SECTION_ANY_NOQUESTION
116 new_chain->parent = ldns_dnssec_build_data_chain(res,
121 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY;
122 ldns_pkt_free(my_pkt);
124 new_chain->parent = ldns_dnssec_build_data_chain(res,
129 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY;
131 ldns_rr_list_deep_free(keys);
136 ldns_dnssec_build_data_chain_other(ldns_resolver *res,
138 ldns_dnssec_data_chain *new_chain,
143 /* 'self-signed', parent is a DS */
145 /* okay, either we have other keys signing the current one,
147 * one should have a DS record in the parent zone.
148 * How do we find this out? Try both?
150 * request DNSKEYS for current zone,
151 * add all signatures to current level
154 ldns_rr_list *signatures2;
156 new_chain->parent_type = 1;
158 my_pkt = ldns_resolver_query(res,
163 dss = ldns_pkt_rr_list_by_name_and_type(my_pkt,
166 LDNS_SECTION_ANY_NOQUESTION
169 new_chain->parent = ldns_dnssec_build_data_chain(res,
174 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS;
175 ldns_rr_list_deep_free(dss);
177 ldns_pkt_free(my_pkt);
179 my_pkt = ldns_resolver_query(res,
184 signatures2 = ldns_pkt_rr_list_by_name_and_type(my_pkt,
187 LDNS_SECTION_ANSWER);
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");
194 new_chain->signatures = signatures2;
196 ldns_pkt_free(my_pkt);
199 ldns_dnssec_data_chain *
200 ldns_dnssec_build_data_chain_nokeyname(ldns_resolver *res,
203 const ldns_rr_list *rrset,
204 ldns_dnssec_data_chain *new_chain)
206 ldns_rdf *possible_parent_name;
208 /* apparently we were not able to find a signing key, so
209 we assume the chain ends here
211 /* try parents for auth denial of DS */
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));
217 /* no information to go on, give up */
221 my_pkt = ldns_resolver_query(res,
222 possible_parent_name,
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);
232 /* are there signatures? */
233 new_chain->parent = ldns_dnssec_build_data_chain(res,
239 new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS;
246 ldns_dnssec_data_chain *
247 ldns_dnssec_build_data_chain(ldns_resolver *res,
249 const ldns_rr_list *rrset,
253 ldns_rr_list *signatures = NULL;
254 ldns_rr_list *dss = NULL;
256 ldns_rr_list *my_rrset;
260 ldns_rdf *name = NULL, *key_name = NULL;
261 ldns_rr_type type = 0;
264 bool other_rrset = false;
266 ldns_dnssec_data_chain *new_chain = ldns_dnssec_data_chain_new();
268 if (!ldns_dnssec_pkt_has_rrsigs(pkt)) {
269 /* hmm. no dnssec data in the packet. go up to try and deny
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,
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;
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;
295 my_rrset = ldns_pkt_rr_list_by_type(pkt,
297 LDNS_SECTION_ANY_NOQUESTION
300 if (ldns_rr_list_rr_count(my_rrset) > 0) {
301 type = LDNS_RR_TYPE_NSEC;
304 ldns_rr_list_deep_free(my_rrset);
308 /* nothing, try nsec3 */
309 my_rrset = ldns_pkt_rr_list_by_type(pkt,
311 LDNS_SECTION_ANY_NOQUESTION);
313 if (ldns_rr_list_rr_count(my_rrset) > 0) {
314 type = LDNS_RR_TYPE_NSEC3;
317 ldns_rr_list_deep_free(my_rrset);
322 /* try parent zone? for denied insecure? */
330 my_rrset = (ldns_rr_list *) rrset;
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));
341 ldns_rr_list_deep_free(my_rrset);
344 /* normally there will only be 1 signature 'set'
345 but there can be more than 1 denial (wildcards)
348 if (type == LDNS_RR_TYPE_NSEC || type == LDNS_RR_TYPE_NSEC3) {
349 /* just throw in all signatures, the tree builder must sort
352 signatures = ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type);
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);
361 ldns_dnssec_pkt_get_rrsigs_for_name_and_type(pkt,
366 my_pkt = ldns_resolver_query(res, name, type, c, qflags);
368 ldns_dnssec_pkt_get_rrsigs_for_name_and_type(my_pkt,
371 ldns_pkt_free(my_pkt);
375 if (signatures && ldns_rr_list_rr_count(signatures) > 0) {
376 key_name = ldns_rr_rdf(ldns_rr_list_rr(signatures, 0), 7);
380 return ldns_dnssec_build_data_chain_nokeyname(res,
387 if (type != LDNS_RR_TYPE_DNSKEY) {
388 ldns_dnssec_build_data_chain_dnskey(res,
397 ldns_dnssec_build_data_chain_other(res,
407 ldns_rr_list_deep_free(signatures);
413 ldns_dnssec_trust_tree *
414 ldns_dnssec_trust_tree_new()
416 ldns_dnssec_trust_tree *new_tree = LDNS_XMALLOC(ldns_dnssec_trust_tree,
419 new_tree->rrset = NULL;
420 new_tree->parent_count = 0;
426 ldns_dnssec_trust_tree_free(ldns_dnssec_trust_tree *tree)
430 for (i = 0; i < tree->parent_count; i++) {
431 ldns_dnssec_trust_tree_free(tree->parents[i]);
438 ldns_dnssec_trust_tree_depth(ldns_dnssec_trust_tree *tree)
444 for (i = 0; i < tree->parent_count; i++) {
445 parent = ldns_dnssec_trust_tree_depth(tree->parents[i]);
446 if (parent > result) {
455 print_tabs(FILE *out, size_t nr, uint8_t *map, size_t treedepth)
458 for (i = 0; i < nr; i++) {
460 fprintf(out, "|---");
461 } else if (map && i < treedepth && map[i] == 1) {
470 ldns_dnssec_trust_tree_print_sm(FILE *out,
471 ldns_dnssec_trust_tree *tree,
478 const ldns_rr_descriptor *descriptor;
482 treedepth = ldns_dnssec_trust_tree_depth(tree);
483 sibmap = malloc(treedepth);
484 memset(sibmap, 0, treedepth);
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));
494 if (descriptor->_name) {
495 fprintf(out, " (%s", descriptor->_name);
497 fprintf(out, " (TYPE%d",
498 ldns_rr_get_type(tree->rr));
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));
514 if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NSEC) {
516 ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0));
518 ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 1));
523 for (i = 0; i < tree->parent_count; i++) {
524 if (tree->parent_count > 1 && i < tree->parent_count - 1) {
529 /* only print errors */
530 if (ldns_rr_get_type(tree->parents[i]->rr) ==
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);
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");
541 fprintf(out, "Existence is denied by:\n");
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");
548 print_tabs(out, tabs + 1, sibmap, treedepth);
550 "Error in denial of existence: %s\n",
551 ldns_get_errorstr_by_id(
552 tree->parent_status[i]));
556 if (tree->parent_status[i] != LDNS_STATUS_OK) {
557 print_tabs(out, tabs + 1, sibmap, treedepth);
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);
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);
575 ldns_dnssec_trust_tree_print_sm(out,
583 print_tabs(out, tabs, sibmap, treedepth);
584 fprintf(out, "<no data>\n");
587 fprintf(out, "<null pointer>\n");
596 ldns_dnssec_trust_tree_print(FILE *out,
597 ldns_dnssec_trust_tree *tree,
601 ldns_dnssec_trust_tree_print_sm(out, tree, tabs, extended, NULL, 0);
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)
612 && tree->parent_count < LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS) {
614 printf("Add parent for: ");
615 ldns_rr_print(stdout, tree->rr);
617 ldns_rr_print(stdout, parent->rr);
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;
626 return LDNS_STATUS_ERR;
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)
634 ldns_rr_list *cur_rrset;
635 ldns_rr_list *cur_sigs;
636 ldns_rr *cur_rr = NULL;
640 ldns_dnssec_trust_tree *new_tree = ldns_dnssec_trust_tree_new();
642 if (data_chain && data_chain->rrset) {
643 cur_rrset = data_chain->rrset;
645 cur_sigs = data_chain->signatures;
651 if (!cur_rr && ldns_rr_list_rr_count(cur_rrset) > 0) {
652 cur_rr = ldns_rr_list_rr(cur_rrset, 0);
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)
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);
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)))
675 /* find first that does match */
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;
681 cur_rr = ldns_rr_list_rr(cur_rrset, j);
684 if (ldns_dname_compare(ldns_rr_owner(cur_sig_rr),
685 ldns_rr_owner(cur_rr)))
693 if (data_chain->parent) {
694 ldns_dnssec_derive_trust_tree_normal_rrset(
701 ldns_dnssec_derive_trust_tree_dnskey_rrset(
708 ldns_dnssec_derive_trust_tree_ds_rrset(new_tree,
712 /* no signatures? maybe it's nsec data */
714 /* just add every rr from parent as new parent */
715 ldns_dnssec_derive_trust_tree_no_sig(new_tree, data_chain);
724 ldns_dnssec_derive_trust_tree_normal_rrset(ldns_dnssec_trust_tree *new_tree,
725 ldns_dnssec_data_chain *data_chain,
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;
733 ldns_rr_list *tmp_rrset = NULL;
734 ldns_status cur_status;
736 cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr));
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) {
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!
752 ldns_rr_list_sort(cur_rrset);
753 if (tmp_rrset && tmp_rrset != cur_rrset) {
754 ldns_rr_list_deep_free(tmp_rrset);
757 tmp_rrset = ldns_rr_list_pop_rrset(cur_rrset);
759 /* with nsecs, this might be the wrong one */
761 ldns_rr_list_rr_count(cur_rrset) > 0 &&
763 ldns_rr_owner(ldns_rr_list_rr(
765 ldns_rr_owner(cur_sig_rr)) != 0) {
766 ldns_rr_list_deep_free(tmp_rrset);
768 ldns_rr_list_pop_rrset(cur_rrset);
771 cur_status = ldns_verify_rrsig(tmp_rrset,
775 for (i = 0; i < new_tree->parent_count; i++) {
776 if (cur_parent_rr == new_tree->parents[i]->rr) {
782 ldns_dnssec_derive_trust_tree(data_chain->parent,
784 (void)ldns_dnssec_trust_tree_add_parent(new_tree,
793 if (tmp_rrset && tmp_rrset != cur_rrset) {
794 ldns_rr_list_deep_free(tmp_rrset);
796 ldns_rr_list_deep_free(cur_rrset);
800 ldns_dnssec_derive_trust_tree_dnskey_rrset(ldns_dnssec_trust_tree *new_tree,
801 ldns_dnssec_data_chain *data_chain,
806 ldns_rr_list *cur_rrset = data_chain->rrset;
807 ldns_dnssec_trust_tree *cur_parent_tree;
808 ldns_rr *cur_parent_rr;
810 ldns_status cur_status;
812 cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr));
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
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,
826 (void) ldns_dnssec_trust_tree_add_parent(new_tree,
827 cur_parent_tree, cur_sig_rr, cur_status);
834 ldns_dnssec_derive_trust_tree_ds_rrset(ldns_dnssec_trust_tree *new_tree,
835 ldns_dnssec_data_chain *data_chain,
839 ldns_rr_list *cur_rrset = data_chain->rrset;
840 ldns_dnssec_trust_tree *cur_parent_tree;
841 ldns_rr *cur_parent_rr;
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
849 j < ldns_rr_list_rr_count(data_chain->parent->rrset);
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)) {
857 ldns_dnssec_derive_trust_tree(
858 data_chain->parent, cur_parent_rr);
859 (void) ldns_dnssec_trust_tree_add_parent(
865 /*ldns_rr_print(stdout, cur_parent_rr);*/
874 ldns_dnssec_derive_trust_tree_no_sig(ldns_dnssec_trust_tree *new_tree,
875 ldns_dnssec_data_chain *data_chain)
878 ldns_rr_list *cur_rrset;
879 ldns_rr *cur_parent_rr;
880 ldns_dnssec_trust_tree *cur_parent_tree;
883 if (data_chain->parent && data_chain->parent->rrset) {
884 cur_rrset = data_chain->parent->rrset;
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(
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(
901 data_chain->parent->signatures);
903 /* unsigned zone, unsigned parent */
904 result = LDNS_STATUS_OK;
907 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
909 for (i = 0; i < ldns_rr_list_rr_count(cur_rrset); i++) {
910 cur_parent_rr = ldns_rr_list_rr(cur_rrset, i);
912 ldns_dnssec_derive_trust_tree(data_chain->parent,
914 (void) ldns_dnssec_trust_tree_add_parent(new_tree,
915 cur_parent_tree, NULL, result);
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
926 ldns_dnssec_trust_tree_contains_keys(ldns_dnssec_trust_tree *tree,
927 ldns_rr_list *trusted_keys)
930 ldns_status result = LDNS_STATUS_CRYPTO_NO_DNSKEY;
932 ldns_status parent_result;
934 if (tree && trusted_keys && ldns_rr_list_rr_count(trusted_keys) > 0)
936 for (i = 0; i < ldns_rr_list_rr_count(trusted_keys); i++) {
937 equal = ldns_rr_compare_ds(
939 ldns_rr_list_rr(trusted_keys, i));
941 result = LDNS_STATUS_OK;
946 for (i = 0; i < tree->parent_count; i++) {
948 ldns_dnssec_trust_tree_contains_keys(tree->parents[i],
950 if (parent_result != LDNS_STATUS_CRYPTO_NO_DNSKEY) {
951 if (tree->parent_status[i] != LDNS_STATUS_OK) {
952 result = tree->parent_status[i];
954 if (ldns_rr_get_type(tree->rr)
955 == LDNS_RR_TYPE_NSEC &&
956 parent_result == LDNS_STATUS_OK
959 LDNS_STATUS_DNSSEC_EXISTENCE_DENIED;
961 result = parent_result;
967 result = LDNS_STATUS_ERR;
974 ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys,
975 ldns_rr_list *good_keys)
978 ldns_status verify_result = LDNS_STATUS_ERR;
980 if (!rrset || !rrsig || !keys) {
981 return LDNS_STATUS_ERR;
984 if (ldns_rr_list_rr_count(rrset) < 1) {
985 return LDNS_STATUS_ERR;
988 if (ldns_rr_list_rr_count(rrsig) < 1) {
989 return LDNS_STATUS_CRYPTO_NO_RRSIG;
992 if (ldns_rr_list_rr_count(keys) < 1) {
993 verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY;
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)
1003 else if(s != LDNS_STATUS_ERR && verify_result ==
1004 LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY)
1008 return verify_result;
1012 ldns_verify_notime(ldns_rr_list *rrset, ldns_rr_list *rrsig,
1013 const ldns_rr_list *keys, ldns_rr_list *good_keys)
1016 ldns_status verify_result = LDNS_STATUS_ERR;
1018 if (!rrset || !rrsig || !keys) {
1019 return LDNS_STATUS_ERR;
1022 if (ldns_rr_list_rr_count(rrset) < 1) {
1023 return LDNS_STATUS_ERR;
1026 if (ldns_rr_list_rr_count(rrsig) < 1) {
1027 return LDNS_STATUS_CRYPTO_NO_RRSIG;
1030 if (ldns_rr_list_rr_count(keys) < 1) {
1031 verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY;
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);
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) {
1042 } else if (s != LDNS_STATUS_ERR && verify_result ==
1043 LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) {
1048 return verify_result;
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)
1057 ldns_rr_list * trusted_keys = NULL;
1058 ldns_rr_list * ds_keys = NULL;
1060 if (res && domain && keys) {
1062 if ((trusted_keys = ldns_validate_domain_dnskey(res,
1065 *status = LDNS_STATUS_OK;
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;
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);
1076 ldns_fetch_valid_domain_keys(res,
1080 /* Check DS records */
1082 ldns_validate_domain_ds(res,
1086 ldns_fetch_valid_domain_keys(res,
1090 ldns_rr_list_deep_free(ds_keys);
1092 /* No valid DS at the parent -- fail */
1093 *status = LDNS_STATUS_CRYPTO_NO_TRUSTED_DS ;
1095 ldns_rr_list_deep_free(parent_keys);
1097 ldns_rdf_deep_free(parent_domain);
1101 return trusted_keys;
1105 ldns_validate_domain_dnskey(const ldns_resolver * res,
1106 const ldns_rdf * domain,
1107 const ldns_rr_list * keys)
1111 uint16_t key_i; uint16_t key_j; uint16_t key_k;
1112 uint16_t sig_i; ldns_rr * cur_sig;
1114 ldns_rr_list * domain_keys = NULL;
1115 ldns_rr_list * domain_sigs = NULL;
1116 ldns_rr_list * trusted_keys = NULL;
1118 /* Fetch keys for the domain */
1119 if ((keypkt = ldns_resolver_query(res,
1121 LDNS_RR_TYPE_DNSKEY,
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,
1130 LDNS_SECTION_ANSWER);
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++) {
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),
1140 /* Current key is trusted -- validate */
1141 trusted_keys = ldns_rr_list_new();
1144 sig_i<ldns_rr_list_rr_count(domain_sigs);
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,
1154 == LDNS_STATUS_OK) {
1156 /* Push the whole rrset
1157 -- we can't do much more */
1159 key_k<ldns_rr_list_rr_count(
1162 ldns_rr_list_push_rr(
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;
1178 /* Only push our trusted key */
1179 ldns_rr_list_push_rr(trusted_keys,
1180 ldns_rr_clone(cur_key));
1185 ldns_rr_list_deep_free(domain_keys);
1186 ldns_rr_list_deep_free(domain_sigs);
1187 ldns_pkt_free(keypkt);
1190 /* LDNS_STATUS_CRYPTO_NO_DNSKEY */
1193 return trusted_keys;
1197 ldns_validate_domain_ds(const ldns_resolver *res,
1198 const ldns_rdf * domain,
1199 const ldns_rr_list * keys)
1203 ldns_rr_list * rrset = NULL;
1204 ldns_rr_list * sigs = NULL;
1205 ldns_rr_list * trusted_keys = NULL;
1207 /* Fetch DS for the domain */
1208 if ((dspkt = ldns_resolver_query(res,
1214 rrset = ldns_pkt_rr_list_by_type(dspkt,
1216 LDNS_SECTION_ANSWER);
1217 sigs = ldns_pkt_rr_list_by_type(dspkt,
1219 LDNS_SECTION_ANSWER);
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,
1233 ldns_rr_list_deep_free(rrset);
1234 ldns_rr_list_deep_free(sigs);
1235 ldns_pkt_free(dspkt);
1238 /* LDNS_STATUS_CRYPTO_NO_DS */
1241 return trusted_keys;
1245 ldns_verify_trusted(ldns_resolver *res,
1246 ldns_rr_list *rrset,
1247 ldns_rr_list * rrsigs,
1248 ldns_rr_list * validating_keys)
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;
1255 if (!res || !rrset || !rrsigs) {
1256 return LDNS_STATUS_ERR;
1259 if (ldns_rr_list_rr_count(rrset) < 1) {
1260 return LDNS_STATUS_ERR;
1263 if (ldns_rr_list_rr_count(rrsigs) < 1) {
1264 return LDNS_STATUS_CRYPTO_NO_RRSIG;
1267 /* Look at each sig */
1268 for (sig_i=0; sig_i < ldns_rr_list_rr_count(rrsigs); sig_i++) {
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(
1274 ldns_rr_rrsig_signame(cur_sig),
1275 ldns_resolver_dnssec_anchors(res),
1279 key_i < ldns_rr_list_rr_count(trusted_keys);
1281 cur_key = ldns_rr_list_rr(trusted_keys, key_i);
1283 if ((result = ldns_verify_rrsig(rrset,
1286 == LDNS_STATUS_OK) {
1287 if (validating_keys) {
1288 ldns_rr_list_push_rr(validating_keys,
1289 ldns_rr_clone(cur_key));
1291 ldns_rr_list_deep_free(trusted_keys);
1292 return LDNS_STATUS_OK;
1294 ldns_rr_list_print(stdout, rrset);
1295 ldns_rr_print(stdout, cur_sig);
1296 ldns_rr_print(stdout, cur_key);
1303 ldns_rr_list_deep_free(trusted_keys);
1308 ldns_dnssec_verify_denial(ldns_rr *rr,
1309 ldns_rr_list *nsecs,
1310 ldns_rr_list *rrsigs)
1313 ldns_rdf *wildcard_name;
1314 ldns_rdf *chopped_dname;
1318 /* needed for wildcard check on exact match */
1320 bool name_covered = false;
1321 bool type_covered = false;
1322 bool wildcard_covered = false;
1323 bool wildcard_type_covered = false;
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) {
1333 ldns_rdf_deep_free(chopped_dname);
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),
1345 if (rrsig && ldns_rdf2native_int8(ldns_rr_rrsig_labels(rrsig))
1346 == ldns_dname_label_count(rr_name)) {
1347 wildcard_covered = true;
1350 if (ldns_nsec_bitmap_covers_type(ldns_nsec_get_bitmap(cur_nsec),
1351 ldns_rr_get_type(rr))) {
1352 type_covered = true;
1355 if (ldns_nsec_covers_name(cur_nsec, rr_name)) {
1356 name_covered = true;
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;
1367 if (ldns_nsec_covers_name(cur_nsec, wildcard_name)) {
1368 wildcard_covered = true;
1373 ldns_rdf_deep_free(wildcard_name);
1375 if (type_covered || !name_covered) {
1376 return LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1379 if (wildcard_type_covered || !wildcard_covered) {
1380 return LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED;
1383 return LDNS_STATUS_OK;
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,
1395 ldns_rdf *closest_encloser;
1397 ldns_rdf *hashed_wildcard_name;
1398 bool wildcard_covered = false;
1399 ldns_rdf *zone_name;
1400 ldns_rdf *hashed_name;
1402 ldns_status result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1406 zone_name = ldns_dname_left_chop(ldns_rr_owner(ldns_rr_list_rr(nsecs,0)));
1409 if (packet_rcode == LDNS_RCODE_NXDOMAIN) {
1410 closest_encloser = ldns_dnssec_nsec3_closest_encloser(
1412 ldns_rr_get_type(rr),
1414 if(!closest_encloser) {
1415 result = LDNS_STATUS_NSEC3_ERR;
1419 wildcard = ldns_dname_new_frm_str("*");
1420 (void) ldns_dname_cat(wildcard, closest_encloser);
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),
1427 (void) ldns_dname_cat(hashed_wildcard_name, zone_name);
1429 if (ldns_nsec_covers_name(ldns_rr_list_rr(nsecs, i),
1430 hashed_wildcard_name)) {
1431 wildcard_covered = true;
1433 ldns_rdf_deep_free(hashed_wildcard_name);
1436 ldns_rdf_deep_free(closest_encloser);
1437 ldns_rdf_deep_free(wildcard);
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;
1444 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1446 } else if (packet_nodata && packet_qtype != LDNS_RR_TYPE_DS) {
1448 hashed_name = ldns_nsec3_hash_name_frm_nsec3(
1449 ldns_rr_list_rr(nsecs, 0),
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)))
1456 if (!ldns_nsec_bitmap_covers_type(
1457 ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
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;
1468 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1469 } else if (packet_nodata && packet_qtype == LDNS_RR_TYPE_DS) {
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,
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,
1482 if (!ldns_nsec_bitmap_covers_type(
1483 ldns_nsec3_bitmap(ldns_rr_list_rr(nsecs, i)),
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;
1495 /* XXX see note above */
1496 result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED;
1500 ldns_rdf_deep_free(zone_name);
1503 #endif /* HAVE_SSL */
1507 ldns_gost2pkey_raw(unsigned char* key, size_t keylen)
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;
1517 /* key wrong size */
1521 /* create evp_key */
1522 memmove(encoded, asn, 37);
1523 memmove(encoded+37, key, 64);
1524 pp = (unsigned char*)&encoded[0];
1526 return d2i_PUBKEY(NULL, &pp, sizeof(encoded));
1530 ldns_verify_rrsig_gost_raw(unsigned char* sig, size_t siglen,
1531 ldns_buffer* rrset, unsigned char* key, size_t keylen)
1536 (void) ldns_key_EVP_load_gost_id();
1537 evp_key = ldns_gost2pkey_raw(key, keylen);
1539 /* could not convert key */
1540 return LDNS_STATUS_CRYPTO_BOGUS;
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);
1554 ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
1556 unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */
1557 const unsigned char* pp = buf;
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);
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)) {
1579 evp_key = EVP_PKEY_new();
1584 EVP_PKEY_assign_EC_KEY(evp_key, ec);
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)
1596 evp_key = ldns_ecdsa2pkey_raw(key, keylen, algo);
1598 /* could not convert key */
1599 return LDNS_STATUS_CRYPTO_BOGUS;
1601 if(algo == LDNS_ECDSAP256SHA256)
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);
1611 ldns_verify_rrsig_buffers(ldns_buffer *rawsig_buf, ldns_buffer *verify_buf,
1612 ldns_buffer *key_buf, uint8_t algo)
1614 return ldns_verify_rrsig_buffers_raw(
1615 (unsigned char*)ldns_buffer_begin(rawsig_buf),
1616 ldns_buffer_position(rawsig_buf),
1618 (unsigned char*)ldns_buffer_begin(key_buf),
1619 ldns_buffer_position(key_buf), algo);
1623 ldns_verify_rrsig_buffers_raw(unsigned char* sig, size_t siglen,
1624 ldns_buffer *verify_buf, unsigned char* key, size_t keylen,
1627 /* check for right key */
1630 case LDNS_DSA_NSEC3:
1631 return ldns_verify_rrsig_dsa_raw(sig,
1638 case LDNS_RSASHA1_NSEC3:
1639 return ldns_verify_rrsig_rsasha1_raw(sig,
1646 case LDNS_RSASHA256:
1647 return ldns_verify_rrsig_rsasha256_raw(sig,
1653 case LDNS_RSASHA512:
1654 return ldns_verify_rrsig_rsasha512_raw(sig,
1663 return ldns_verify_rrsig_gost_raw(sig, siglen, verify_buf,
1668 case LDNS_ECDSAP256SHA256:
1669 case LDNS_ECDSAP384SHA384:
1670 return ldns_verify_rrsig_ecdsa_raw(sig, siglen, verify_buf,
1675 return ldns_verify_rrsig_rsamd5_raw(sig,
1682 /* do you know this alg?! */
1683 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
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
1696 ldns_rrset_use_signature_ttl(ldns_rr_list* rrset_clone, ldns_rr* rrsig)
1700 uint8_t label_count;
1701 ldns_rdf *wildcard_name;
1702 ldns_rdf *wildcard_chopped;
1703 ldns_rdf *wildcard_chopped_tmp;
1705 orig_ttl = ldns_rdf2native_int32( ldns_rr_rdf(rrsig, 3));
1706 label_count = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 2));
1708 for(i = 0; i < ldns_rr_list_rr_count(rrset_clone); i++) {
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(
1718 ldns_rdf_deep_free(wildcard_chopped);
1719 wildcard_chopped = wildcard_chopped_tmp;
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(
1725 ldns_rr_set_owner(ldns_rr_list_rr(rrset_clone, i),
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));
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.
1741 ldns_rrsig2rawsig_buffer(ldns_buffer* rawsig_buf, ldns_rr* rrsig)
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
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) */
1754 case LDNS_RSASHA1_NSEC3:
1756 case LDNS_RSASHA256:
1757 case LDNS_RSASHA512:
1762 if (ldns_rdf2buffer_wire(rawsig_buf,
1763 ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1764 return LDNS_STATUS_MEM_ERR;
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) {
1773 if (ldns_rdf2buffer_wire(rawsig_buf,
1774 ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) {
1776 return LDNS_STATUS_MEM_ERR;
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;
1793 return LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL;
1795 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
1797 return LDNS_STATUS_OK;
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.
1807 ldns_rrsig_check_timestamps(ldns_rr* rrsig, int32_t now)
1809 int32_t inception, expiration;
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));
1817 if (expiration - inception < 0) {
1818 /* bad sig, expiration before inception?? Tsssg */
1819 return LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION;
1821 if (now - inception < 0) {
1822 /* bad sig, inception date has not yet come to pass */
1823 return LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED;
1825 if (expiration - now < 0) {
1826 /* bad sig, expiration date has passed */
1827 return LDNS_STATUS_CRYPTO_SIG_EXPIRED;
1829 return LDNS_STATUS_OK;
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.
1841 ldns_prepare_for_verify(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
1842 ldns_rr_list* rrset_clone, ldns_rr* rrsig)
1846 /* canonicalize the sig */
1847 ldns_dname2canonical(ldns_rr_owner(rrsig));
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;
1854 /* create a buffer with b64 signature rdata */
1855 result = ldns_rrsig2rawsig_buffer(rawsig_buf, rrsig);
1856 if(result != LDNS_STATUS_OK)
1859 /* use TTL from signature. Use wildcard names for wildcards */
1860 /* also canonicalizes rrset_clone */
1861 ldns_rrset_use_signature_ttl(rrset_clone, rrsig);
1863 /* sort the rrset in canonical order */
1864 ldns_rr_list_sort(rrset_clone);
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;
1870 /* add the rrset in verify_buf */
1871 if(ldns_rr_list2buffer_wire(verify_buf, rrset_clone)
1873 return LDNS_STATUS_MEM_ERR;
1875 return LDNS_STATUS_OK;
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.
1888 ldns_verify_test_sig_key(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
1889 ldns_rr* rrsig, ldns_rr* key)
1891 uint8_t sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1));
1893 /* before anything, check if the keytags match */
1894 if (ldns_calc_keytag(key)
1896 ldns_rdf2native_int16(ldns_rr_rrsig_keytag(rrsig))
1898 ldns_buffer* key_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1899 ldns_status result = LDNS_STATUS_ERR;
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
1909 return LDNS_STATUS_ERR;
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);
1916 /* No keys with the corresponding algorithm are found */
1917 result = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY;
1920 ldns_buffer_free(key_buf);
1924 /* No keys with the corresponding keytag are found */
1925 return LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY;
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
1939 ldns_verify_rrsig_keylist(ldns_rr_list *rrset,
1941 const ldns_rr_list *keys,
1942 ldns_rr_list *good_keys)
1945 ldns_rr_list *valid = ldns_rr_list_new();
1947 return LDNS_STATUS_MEM_ERR;
1949 result = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, valid);
1950 if(result != LDNS_STATUS_OK) {
1951 ldns_rr_list_free(valid);
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);
1962 ldns_rr_list_cat(good_keys, valid);
1963 ldns_rr_list_free(valid);
1964 return LDNS_STATUS_OK;
1968 ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset,
1970 const ldns_rr_list *keys,
1971 ldns_rr_list *good_keys)
1973 ldns_buffer *rawsig_buf;
1974 ldns_buffer *verify_buf;
1976 ldns_status result, status;
1977 ldns_rr_list *rrset_clone;
1978 ldns_rr_list *validkeys;
1981 return LDNS_STATUS_ERR;
1984 validkeys = ldns_rr_list_new();
1986 return LDNS_STATUS_MEM_ERR;
1989 /* clone the rrset so that we can fiddle with it */
1990 rrset_clone = ldns_rr_list_clone(rrset);
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);
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);
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
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;
2028 if (result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) {
2033 /* no longer needed */
2034 ldns_rr_list_deep_free(rrset_clone);
2035 ldns_buffer_free(rawsig_buf);
2036 ldns_buffer_free(verify_buf);
2038 if (ldns_rr_list_rr_count(validkeys) == 0) {
2039 /* no keys were added, return last error */
2040 ldns_rr_list_free(validkeys);
2044 /* do not check timestamps */
2046 ldns_rr_list_cat(good_keys, validkeys);
2047 ldns_rr_list_free(validkeys);
2048 return LDNS_STATUS_OK;
2052 ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key)
2054 ldns_buffer *rawsig_buf;
2055 ldns_buffer *verify_buf;
2057 ldns_rr_list *rrset_clone;
2060 return LDNS_STATUS_NO_DATA;
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);
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);
2076 result = ldns_verify_test_sig_key(rawsig_buf, verify_buf,
2078 /* no longer needed */
2079 ldns_rr_list_deep_free(rrset_clone);
2080 ldns_buffer_free(rawsig_buf);
2081 ldns_buffer_free(verify_buf);
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));
2092 ldns_verify_rrsig_evp(ldns_buffer *sig,
2095 const EVP_MD *digest_type)
2097 return ldns_verify_rrsig_evp_raw(
2098 (unsigned char*)ldns_buffer_begin(sig),
2099 ldns_buffer_position(sig),
2106 ldns_verify_rrsig_evp_raw(unsigned char *sig, size_t siglen,
2107 ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type)
2112 EVP_MD_CTX_init(&ctx);
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);
2120 EVP_MD_CTX_cleanup(&ctx);
2123 return LDNS_STATUS_OK;
2124 } else if (res == 0) {
2125 return LDNS_STATUS_CRYPTO_BOGUS;
2127 /* TODO how to communicate internal SSL error?
2128 let caller use ssl's get_error() */
2129 return LDNS_STATUS_SSL_ERR;
2133 ldns_verify_rrsig_dsa(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2135 return ldns_verify_rrsig_dsa_raw(
2136 (unsigned char*) ldns_buffer_begin(sig),
2137 ldns_buffer_position(sig),
2139 (unsigned char*) ldns_buffer_begin(key),
2140 ldns_buffer_position(key));
2144 ldns_verify_rrsig_rsasha1(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2146 return ldns_verify_rrsig_rsasha1_raw(
2147 (unsigned char*)ldns_buffer_begin(sig),
2148 ldns_buffer_position(sig),
2150 (unsigned char*) ldns_buffer_begin(key),
2151 ldns_buffer_position(key));
2155 ldns_verify_rrsig_rsamd5(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key)
2157 return ldns_verify_rrsig_rsamd5_raw(
2158 (unsigned char*)ldns_buffer_begin(sig),
2159 ldns_buffer_position(sig),
2161 (unsigned char*) ldns_buffer_begin(key),
2162 ldns_buffer_position(key));
2166 ldns_verify_rrsig_dsa_raw(unsigned char* sig, size_t siglen,
2167 ldns_buffer* rrset, unsigned char* key, size_t keylen)
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,
2179 EVP_PKEY_free(evp_key);
2185 ldns_verify_rrsig_rsasha1_raw(unsigned char* sig, size_t siglen,
2186 ldns_buffer* rrset, unsigned char* key, size_t keylen)
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,
2198 EVP_PKEY_free(evp_key);
2204 ldns_verify_rrsig_rsasha256_raw(unsigned char* sig,
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,
2221 EVP_PKEY_free(evp_key);
2225 /* touch these to prevent compiler warnings */
2231 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
2236 ldns_verify_rrsig_rsasha512_raw(unsigned char* sig,
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,
2253 EVP_PKEY_free(evp_key);
2257 /* touch these to prevent compiler warnings */
2263 return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
2269 ldns_verify_rrsig_rsamd5_raw(unsigned char* sig,
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,
2285 EVP_PKEY_free(evp_key);