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