Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / ldns / dnssec_verify.h
1 /** dnssec_verify */
2
3 #ifndef LDNS_DNSSEC_VERIFY_H
4 #define LDNS_DNSSEC_VERIFY_H
5
6 #define LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS 10
7
8 #include <ldns/dnssec.h>
9
10 /**
11  * Chain structure that contains all DNSSEC data needed to
12  * verify an rrset
13  */
14 typedef struct ldns_dnssec_data_chain_struct ldns_dnssec_data_chain;
15 struct ldns_dnssec_data_chain_struct
16 {
17         ldns_rr_list *rrset;
18         ldns_rr_list *signatures;
19         ldns_rr_type parent_type;
20         ldns_dnssec_data_chain *parent;
21         ldns_pkt_rcode packet_rcode;
22         ldns_rr_type packet_qtype;
23         bool packet_nodata;
24 };
25
26 /**
27  * Creates a new dnssec_chain structure
28  * \return ldns_dnssec_data_chain *
29  */
30 ldns_dnssec_data_chain *ldns_dnssec_data_chain_new();
31
32 /**
33  * Frees a dnssec_data_chain structure
34  *
35  * \param[in] *chain The chain to free
36  */
37 void ldns_dnssec_data_chain_free(ldns_dnssec_data_chain *chain);
38
39 /**
40  * Frees a dnssec_data_chain structure, and all data
41  * contained therein
42  *
43  * \param[in] *chain The dnssec_data_chain to free
44  */
45 void ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain);
46
47 /**
48  * Prints the dnssec_data_chain to the given file stream
49  * 
50  * \param[in] *out The file stream to print to
51  * \param[in] *chain The dnssec_data_chain to print
52  */
53 void ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain);
54
55 /**
56  * Build an ldns_dnssec_data_chain, which contains all
57  * DNSSEC data that is needed to derive the trust tree later
58  *
59  * The data_set will be cloned
60  *
61  * \param[in] *res resolver structure for further needed queries
62  * \param[in] qflags resolution flags
63  * \param[in] *data_set The original rrset where the chain ends
64  * \param[in] *pkt optional, can contain the original packet
65  * (and hence the sigs and maybe the key)
66  * \param[in] *orig_rr The original Resource Record
67  *
68  * \return the DNSSEC data chain
69  */
70 ldns_dnssec_data_chain *ldns_dnssec_build_data_chain(ldns_resolver *res,
71                                                                                    const uint16_t qflags,
72                                                                                    const ldns_rr_list *data_set,
73                                                                                    const ldns_pkt *pkt,
74                                                                                    ldns_rr *orig_rr);
75
76 /**
77  * Tree structure that contains the relation of DNSSEC data,
78  * and their cryptographic status.
79  *
80  * This tree is derived from a data_chain, and can be used
81  * to look whether there is a connection between an RRSET
82  * and a trusted key. The tree only contains pointers to the
83  * data_chain, and therefore one should *never* free() the
84  * data_chain when there is still a trust tree derived from
85  * that chain.
86  *
87  * Example tree:
88  *     key   key    key
89  *       \    |    /
90  *        \   |   /
91  *         \  |  /
92  *            ds
93  *            |
94  *           key
95  *            |
96  *           key
97  *            |
98  *            rr
99  *
100  * For each signature there is a parent; if the parent
101  * pointer is null, it couldn't be found and there was no
102  * denial; otherwise is a tree which contains either a
103  * DNSKEY, a DS, or a NSEC rr
104  */
105 typedef struct ldns_dnssec_trust_tree_struct ldns_dnssec_trust_tree;
106 struct ldns_dnssec_trust_tree_struct
107 {
108         ldns_rr *rr;
109         /* the complete rrset this rr was in */
110         ldns_rr_list *rrset;
111         ldns_dnssec_trust_tree *parents[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS];
112         ldns_status parent_status[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS];
113         /** for debugging, add signatures too (you might want
114             those if they contain errors) */
115         ldns_rr *parent_signature[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS];
116         size_t parent_count;
117 };
118
119 /**
120  * Creates a new (empty) dnssec_trust_tree structure
121  *
122  * \return ldns_dnssec_trust_tree *
123  */
124 ldns_dnssec_trust_tree *ldns_dnssec_trust_tree_new();
125
126 /**
127  * Frees the dnssec_trust_tree recursively
128  *
129  * There is no deep free; all data in the trust tree
130  * consists of pointers to a data_chain
131  *
132  * \param[in] tree The tree to free
133  */
134 void ldns_dnssec_trust_tree_free(ldns_dnssec_trust_tree *tree);
135
136 /**
137  * returns the depth of the trust tree
138  *
139  * \param[in] tree tree to calculate the depth of
140  * \return The depth of the tree
141  */
142 size_t ldns_dnssec_trust_tree_depth(ldns_dnssec_trust_tree *tree);
143
144 /**
145  * Prints the dnssec_trust_tree structure to the given file
146  * stream.
147  *
148  * If a link status is not LDNS_STATUS_OK; the status and
149  * relevant signatures are printed too
150  *
151  * \param[in] *out The file stream to print to
152  * \param[in] tree The trust tree to print
153  * \param[in] tabs Prepend each line with tabs*2 spaces
154  * \param[in] extended If true, add little explanation lines to the output
155  */
156 void ldns_dnssec_trust_tree_print(FILE *out,
157                                                     ldns_dnssec_trust_tree *tree,
158                                                     size_t tabs,
159                                                     bool extended);
160
161 /**
162  * Adds a trust tree as a parent for the given trust tree
163  *
164  * \param[in] *tree The tree to add the parent to
165  * \param[in] *parent The parent tree to add
166  * \param[in] *parent_signature The RRSIG relevant to this parent/child
167  *                              connection
168  * \param[in] parent_status The DNSSEC status for this parent, child and RRSIG
169  * \return LDNS_STATUS_OK if the addition succeeds, error otherwise
170  */
171 ldns_status ldns_dnssec_trust_tree_add_parent(ldns_dnssec_trust_tree *tree,
172                                                                          const ldns_dnssec_trust_tree *parent,
173                                                                          const ldns_rr *parent_signature,
174                                                                          const ldns_status parent_status);
175
176 /**
177  * Generates a dnssec_trust_ttree for the given rr from the
178  * given data_chain
179  *
180  * This does not clone the actual data; Don't free the
181  * data_chain before you are done with this tree
182  *
183  * \param[in] *data_chain The chain to derive the trust tree from
184  * \param[in] *rr The RR this tree will be about
185  * \return ldns_dnssec_trust_tree *
186  */
187 ldns_dnssec_trust_tree *ldns_dnssec_derive_trust_tree(
188                             ldns_dnssec_data_chain *data_chain,
189                                            ldns_rr *rr);
190
191 /**
192  * Sub function for derive_trust_tree that is used for a
193  * 'normal' rrset
194  *
195  * \param[in] new_tree The trust tree that we are building
196  * \param[in] data_chain The data chain containing the data for the trust tree
197  * \param[in] cur_sig_rr The currently relevant signature
198  */
199 void ldns_dnssec_derive_trust_tree_normal_rrset(
200          ldns_dnssec_trust_tree *new_tree,
201             ldns_dnssec_data_chain *data_chain,
202             ldns_rr *cur_sig_rr);
203
204 /**
205  * Sub function for derive_trust_tree that is used for DNSKEY rrsets
206  *
207  * \param[in] new_tree The trust tree that we are building
208  * \param[in] data_chain The data chain containing the data for the trust tree
209  * \param[in] cur_rr The currently relevant DNSKEY RR
210  * \param[in] cur_sig_rr The currently relevant signature
211  */
212 void ldns_dnssec_derive_trust_tree_dnskey_rrset(
213          ldns_dnssec_trust_tree *new_tree,
214             ldns_dnssec_data_chain *data_chain,
215             ldns_rr *cur_rr,
216             ldns_rr *cur_sig_rr);
217
218 /**
219  * Sub function for derive_trust_tree that is used for DS rrsets
220  *
221  * \param[in] new_tree The trust tree that we are building
222  * \param[in] data_chain The data chain containing the data for the trust tree
223  * \param[in] cur_rr The currently relevant DS RR
224  */
225 void ldns_dnssec_derive_trust_tree_ds_rrset(
226          ldns_dnssec_trust_tree *new_tree,
227             ldns_dnssec_data_chain *data_chain,
228             ldns_rr *cur_rr);
229
230 /**
231  * Sub function for derive_trust_tree that is used when there are no
232  * signatures
233  *
234  * \param[in] new_tree The trust tree that we are building
235  * \param[in] data_chain The data chain containing the data for the trust tree
236  */
237 void ldns_dnssec_derive_trust_tree_no_sig(
238          ldns_dnssec_trust_tree *new_tree,
239             ldns_dnssec_data_chain *data_chain);
240
241 /**
242  * Returns OK if there is a trusted path in the tree to one of 
243  * the DNSKEY or DS RRs in the given list
244  *
245  * \param *tree The trust tree so search
246  * \param *keys A ldns_rr_list of DNSKEY and DS rrs to look for
247  * \return LDNS_STATUS_OK if there is a trusted path to one of
248  *                        the keys, or the *first* error encountered
249  *                        if there were no paths
250  */
251 ldns_status ldns_dnssec_trust_tree_contains_keys(
252                          ldns_dnssec_trust_tree *tree,
253                          ldns_rr_list *keys);
254
255 /**
256  * Verifies a list of signatures for one rrset.
257  *
258  * \param[in] rrset the rrset to verify
259  * \param[in] rrsig a list of signatures to check
260  * \param[in] keys a list of keys to check with
261  * \param[out] good_keys  if this is a (initialized) list, the keys
262  *                        from keys that validate one of the signatures
263  *                        are added to it
264  * \return status LDNS_STATUS_OK if there is at least one correct key
265  */
266 ldns_status ldns_verify(ldns_rr_list *rrset,
267                                     ldns_rr_list *rrsig,
268                                     const ldns_rr_list *keys,
269                                     ldns_rr_list *good_keys);   
270
271 /**
272  * Verifies a list of signatures for one rrset, but disregard the time.
273  * Inception and Expiration are not checked.
274  *
275  * \param[in] rrset the rrset to verify
276  * \param[in] rrsig a list of signatures to check
277  * \param[in] keys a list of keys to check with
278  * \param[out] good_keys  if this is a (initialized) list, the keys
279  *                        from keys that validate one of the signatures
280  *                        are added to it
281  * \return status LDNS_STATUS_OK if there is at least one correct key
282  */
283 ldns_status ldns_verify_notime(ldns_rr_list *rrset,
284                                     ldns_rr_list *rrsig,
285                                     const ldns_rr_list *keys,
286                                     ldns_rr_list *good_keys);   
287
288 /**
289  * Tries to build an authentication chain from the given 
290  * keys down to the queried domain.
291  *
292  * If we find a valid trust path, return the valid keys for the domain.
293  * 
294  * \param[in] res the current resolver
295  * \param[in] domain the domain we want valid keys for
296  * \param[in] keys the current set of trusted keys
297  * \param[out] status pointer to the status variable where the result
298  *                    code will be stored
299  * \return the set of trusted keys for the domain, or NULL if no 
300  *         trust path could be built.
301  */
302 ldns_rr_list *ldns_fetch_valid_domain_keys(const ldns_resolver * res,
303                                                                    const ldns_rdf * domain,
304                                                                    const ldns_rr_list * keys,
305                                                                    ldns_status *status);
306
307 /**
308  * Validates the DNSKEY RRset for the given domain using the provided 
309  * trusted keys.
310  *
311  * \param[in] res the current resolver
312  * \param[in] domain the domain we want valid keys for
313  * \param[in] keys the current set of trusted keys
314  * \return the set of trusted keys for the domain, or NULL if the RRSET
315  *         could not be validated
316  */
317 ldns_rr_list *ldns_validate_domain_dnskey (const ldns_resolver *res,
318                                                                    const ldns_rdf *domain,
319                                                                    const ldns_rr_list *keys);
320
321 /**
322  * Validates the DS RRset for the given domain using the provided trusted keys.
323  *
324  * \param[in] res the current resolver
325  * \param[in] domain the domain we want valid keys for
326  * \param[in] keys the current set of trusted keys
327  * \return the set of trusted keys for the domain, or NULL if the RRSET could not be validated
328  */
329 ldns_rr_list *ldns_validate_domain_ds(const ldns_resolver *res,
330                                                            const ldns_rdf *
331                                                            domain,
332                                                            const ldns_rr_list * keys);
333
334 /**
335  * Verifies a list of signatures for one RRset using a valid trust path.
336  *
337  * \param[in] res the current resolver
338  * \param[in] rrset the rrset to verify
339  * \param[in] rrsigs a list of signatures to check
340  * \param[out] validating_keys  if this is a (initialized) list, the 
341  *                              keys from keys that validate one of
342  *                              the signatures are added to it
343  * \return status LDNS_STATUS_OK if there is at least one correct key
344  */
345 ldns_status ldns_verify_trusted(ldns_resolver *res,
346                                                   ldns_rr_list *rrset,
347                                                   ldns_rr_list *rrsigs,
348                                                   ldns_rr_list *validating_keys);
349
350 /**
351  * denial is not just a river in egypt
352  *
353  * \param[in] rr The (query) RR to check the denial of existence for
354  * \param[in] nsecs The list of NSEC RRs that are supposed to deny the
355  *                  existence of the RR
356  * \param[in] rrsigs The RRSIG RR covering the NSEC RRs
357  * \return LDNS_STATUS_OK if the NSEC RRs deny the existence, error code
358  *                        containing the reason they do not otherwise
359  */
360 ldns_status ldns_dnssec_verify_denial(ldns_rr *rr,
361                                                            ldns_rr_list *nsecs,
362                                                            ldns_rr_list *rrsigs);
363
364 /**
365  * Denial of existence using NSEC3 records
366  * Since NSEC3 is a bit more complicated than normal denial, some
367  * context arguments are needed
368  *
369  * \param[in] rr The (query) RR to check the denial of existence for
370  * \param[in] nsecs The list of NSEC3 RRs that are supposed to deny the
371  *                  existence of the RR
372  * \param[in] rrsigs The RRSIG rr covering the NSEC RRs
373  * \param[in] packet_rcode The RCODE value of the packet that provided the
374  *                         NSEC3 RRs
375  * \param[in] packet_qtype The original query RR type
376  * \param[in] packet_nodata True if the providing packet had an empty ANSWER
377  *                          section
378  * \return LDNS_STATUS_OK if the NSEC3 RRs deny the existence, error code
379  *                        containing the reason they do not otherwise
380  */
381 ldns_status ldns_dnssec_verify_denial_nsec3(ldns_rr *rr,
382                                                                     ldns_rr_list *nsecs,
383                                                                     ldns_rr_list *rrsigs,
384                                                                     ldns_pkt_rcode packet_rcode,
385                                                                     ldns_rr_type packet_qtype,
386                                                                     bool packet_nodata);
387
388 /**
389  * Verifies the already processed data in the buffers
390  * This function should probably not be used directly.
391  *
392  * \param[in] rawsig_buf Buffer containing signature data to use
393  * \param[in] verify_buf Buffer containing data to verify
394  * \param[in] key_buf Buffer containing key data to use
395  * \param[in] algo Signing algorithm
396  * \return status LDNS_STATUS_OK if the data verifies. Error if not.
397  */
398 ldns_status ldns_verify_rrsig_buffers(ldns_buffer *rawsig_buf,
399                                                            ldns_buffer *verify_buf,
400                                                            ldns_buffer *key_buf,
401                                                            uint8_t algo);
402
403 /**
404  * Like ldns_verify_rrsig_buffers, but uses raw data.
405  *
406  * \param[in] sig signature data to use
407  * \param[in] siglen length of signature data to use
408  * \param[in] verify_buf Buffer containing data to verify
409  * \param[in] key key data to use
410  * \param[in] keylen length of key data to use
411  * \param[in] algo Signing algorithm
412  * \return status LDNS_STATUS_OK if the data verifies. Error if not.
413  */
414 ldns_status ldns_verify_rrsig_buffers_raw(unsigned char* sig,
415                                                                   size_t siglen, 
416                                                                   ldns_buffer *verify_buf,
417                                                                   unsigned char* key,
418                                                                   size_t keylen, 
419                                                                   uint8_t algo);
420
421 /**
422  * Verifies an rrsig. All keys in the keyset are tried.
423  * \param[in] rrset the rrset to check
424  * \param[in] rrsig the signature of the rrset
425  * \param[in] keys the keys to try
426  * \param[out] good_keys  if this is a (initialized) list, the keys 
427  *                        from keys that validate one of the signatures
428  *                        are added to it
429  * \return a list of keys which validate the rrsig + rrset. Returns
430  * status LDNS_STATUS_OK if at least one key matched. Else an error.
431  */
432 ldns_status ldns_verify_rrsig_keylist(ldns_rr_list *rrset,
433                                                            ldns_rr *rrsig,
434                                                            const ldns_rr_list *keys,
435                                                            ldns_rr_list *good_keys);
436
437 /**
438  * Verifies an rrsig. All keys in the keyset are tried. Time is not checked.
439  * \param[in] rrset the rrset to check
440  * \param[in] rrsig the signature of the rrset
441  * \param[in] keys the keys to try
442  * \param[out] good_keys  if this is a (initialized) list, the keys 
443  *                        from keys that validate one of the signatures
444  *                        are added to it
445  * \return a list of keys which validate the rrsig + rrset. Returns
446  * status LDNS_STATUS_OK if at least one key matched. Else an error.
447  */
448 ldns_status ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset,
449                                                            ldns_rr *rrsig,
450                                                            const ldns_rr_list *keys,
451                                                            ldns_rr_list *good_keys);
452
453 /**
454  * verify an rrsig with 1 key
455  * \param[in] rrset the rrset
456  * \param[in] rrsig the rrsig to verify
457  * \param[in] key the key to use
458  * \return status message wether verification succeeded.
459  */
460 ldns_status ldns_verify_rrsig(ldns_rr_list *rrset,
461                                                 ldns_rr *rrsig,
462                                                 ldns_rr *key);
463
464 /**
465  * verifies a buffer with signature data for a buffer with rrset data 
466  * with an EVP_PKEY
467  *
468  * \param[in] sig the signature data
469  * \param[in] rrset the rrset data, sorted and processed for verification
470  * \param[in] key the EVP key structure
471  * \param[in] digest_type The digest type of the signature
472  */
473 #ifdef HAVE_SSL
474 ldns_status ldns_verify_rrsig_evp(ldns_buffer *sig,
475                                                     ldns_buffer *rrset,
476                                                     EVP_PKEY *key,
477                                                     const EVP_MD *digest_type);
478 #endif
479
480 /**
481  * Like ldns_verify_rrsig_evp, but uses raw signature data.
482  * \param[in] sig the signature data, wireformat uncompressed
483  * \param[in] siglen length of the signature data
484  * \param[in] rrset the rrset data, sorted and processed for verification
485  * \param[in] key the EVP key structure
486  * \param[in] digest_type The digest type of the signature
487  */
488 #ifdef HAVE_SSL
489 ldns_status ldns_verify_rrsig_evp_raw(unsigned char *sig,
490                                                            size_t siglen,
491                                                            ldns_buffer *rrset,
492                                                            EVP_PKEY *key,
493                                                            const EVP_MD *digest_type);
494 #endif
495
496 /**
497  * verifies a buffer with signature data (DSA) for a buffer with rrset data 
498  * with a buffer with key data.
499  *
500  * \param[in] sig the signature data
501  * \param[in] rrset the rrset data, sorted and processed for verification
502  * \param[in] key the key data
503  */
504 ldns_status ldns_verify_rrsig_dsa(ldns_buffer *sig,
505                                                     ldns_buffer *rrset,
506                                                     ldns_buffer *key);
507
508 /**
509  * verifies a buffer with signature data (RSASHA1) for a buffer with rrset data 
510  * with a buffer with key data.
511  *
512  * \param[in] sig the signature data
513  * \param[in] rrset the rrset data, sorted and processed for verification
514  * \param[in] key the key data
515  */
516 ldns_status ldns_verify_rrsig_rsasha1(ldns_buffer *sig,
517                                                            ldns_buffer *rrset,
518                                                            ldns_buffer *key);
519
520 /**
521  * verifies a buffer with signature data (RSAMD5) for a buffer with rrset data 
522  * with a buffer with key data.
523  *
524  * \param[in] sig the signature data
525  * \param[in] rrset the rrset data, sorted and processed for verification
526  * \param[in] key the key data
527  */
528 ldns_status ldns_verify_rrsig_rsamd5(ldns_buffer *sig,
529                                                           ldns_buffer *rrset,
530                                                           ldns_buffer *key);
531
532 /**
533  * Like ldns_verify_rrsig_dsa, but uses raw signature and key data.
534  * \param[in] sig raw uncompressed wireformat signature data
535  * \param[in] siglen length of signature data
536  * \param[in] rrset ldns buffer with prepared rrset data.
537  * \param[in] key raw uncompressed wireformat key data
538  * \param[in] keylen length of key data
539  */
540 ldns_status ldns_verify_rrsig_dsa_raw(unsigned char* sig,
541                                                            size_t siglen,
542                                                            ldns_buffer* rrset,
543                                                            unsigned char* key,
544                                                            size_t keylen);
545
546 /**
547  * Like ldns_verify_rrsig_rsasha1, but uses raw signature and key data.
548  * \param[in] sig raw uncompressed wireformat signature data
549  * \param[in] siglen length of signature data
550  * \param[in] rrset ldns buffer with prepared rrset data.
551  * \param[in] key raw uncompressed wireformat key data
552  * \param[in] keylen length of key data
553  */
554 ldns_status ldns_verify_rrsig_rsasha1_raw(unsigned char* sig,
555                                                                   size_t siglen,
556                                                                   ldns_buffer* rrset,
557                                                                   unsigned char* key,
558                                                                   size_t keylen);
559
560 /**
561  * Like ldns_verify_rrsig_rsasha256, but uses raw signature and key data.
562  * \param[in] sig raw uncompressed wireformat signature data
563  * \param[in] siglen length of signature data
564  * \param[in] rrset ldns buffer with prepared rrset data.
565  * \param[in] key raw uncompressed wireformat key data
566  * \param[in] keylen length of key data
567  */
568
569 ldns_status ldns_verify_rrsig_rsasha256_raw(unsigned char* sig,
570                                                                     size_t siglen,
571                                                                     ldns_buffer* rrset,
572                                                                     unsigned char* key,
573                                                                     size_t keylen);
574
575 /**
576  * Like ldns_verify_rrsig_rsasha512, but uses raw signature and key data.
577  * \param[in] sig raw uncompressed wireformat signature data
578  * \param[in] siglen length of signature data
579  * \param[in] rrset ldns buffer with prepared rrset data.
580  * \param[in] key raw uncompressed wireformat key data
581  * \param[in] keylen length of key data
582  */
583 ldns_status ldns_verify_rrsig_rsasha512_raw(unsigned char* sig,
584                                                                     size_t siglen,
585                                                                     ldns_buffer* rrset,
586                                                                     unsigned char* key,
587                                                                     size_t keylen);
588
589 /**
590  * Like ldns_verify_rrsig_rsamd5, but uses raw signature and key data.
591  * \param[in] sig raw uncompressed wireformat signature data
592  * \param[in] siglen length of signature data
593  * \param[in] rrset ldns buffer with prepared rrset data.
594  * \param[in] key raw uncompressed wireformat key data
595  * \param[in] keylen length of key data
596  */
597 ldns_status ldns_verify_rrsig_rsamd5_raw(unsigned char* sig,
598                                                                  size_t siglen,
599                                                                  ldns_buffer* rrset,
600                                                                  unsigned char* key,
601                                                                  size_t keylen);
602
603 #endif
604