2 * Copyright (C) 2004-2012 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
28 #include <isc/buffer.h>
31 #include <isc/serial.h>
32 #include <isc/string.h>
37 #include <dns/dnssec.h>
38 #include <dns/fixedname.h>
39 #include <dns/keyvalues.h>
41 #include <dns/message.h>
42 #include <dns/rdata.h>
43 #include <dns/rdatalist.h>
44 #include <dns/rdataset.h>
45 #include <dns/rdatastruct.h>
46 #include <dns/result.h>
47 #include <dns/stats.h>
48 #include <dns/tsig.h> /* for DNS_TSIG_FUDGE */
50 #include <dst/result.h>
52 LIBDNS_EXTERNAL_DATA isc_stats_t *dns_dnssec_stats;
54 #define is_response(msg) (msg->flags & DNS_MESSAGEFLAG_QR)
56 #define RETERR(x) do { \
58 if (result != ISC_R_SUCCESS) \
67 digest_callback(void *arg, isc_region_t *data);
70 rdata_compare_wrapper(const void *rdata1, const void *rdata2);
73 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
74 dns_rdata_t **rdata, int *nrdata);
77 digest_callback(void *arg, isc_region_t *data) {
78 dst_context_t *ctx = arg;
80 return (dst_context_adddata(ctx, data));
84 inc_stat(isc_statscounter_t counter) {
85 if (dns_dnssec_stats != NULL)
86 isc_stats_increment(dns_dnssec_stats, counter);
93 rdata_compare_wrapper(const void *rdata1, const void *rdata2) {
94 return (dns_rdata_compare((const dns_rdata_t *)rdata1,
95 (const dns_rdata_t *)rdata2));
99 * Sort the rdataset into an array.
102 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
103 dns_rdata_t **rdata, int *nrdata)
108 dns_rdataset_t rdataset;
110 n = dns_rdataset_count(set);
112 data = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
114 return (ISC_R_NOMEMORY);
116 dns_rdataset_init(&rdataset);
117 dns_rdataset_clone(set, &rdataset);
118 ret = dns_rdataset_first(&rdataset);
119 if (ret != ISC_R_SUCCESS) {
120 dns_rdataset_disassociate(&rdataset);
121 isc_mem_put(mctx, data, n * sizeof(dns_rdata_t));
126 * Put them in the array.
129 dns_rdata_init(&data[i]);
130 dns_rdataset_current(&rdataset, &data[i++]);
131 } while (dns_rdataset_next(&rdataset) == ISC_R_SUCCESS);
136 qsort(data, n, sizeof(dns_rdata_t), rdata_compare_wrapper);
139 dns_rdataset_disassociate(&rdataset);
140 return (ISC_R_SUCCESS);
144 dns_dnssec_keyfromrdata(dns_name_t *name, dns_rdata_t *rdata, isc_mem_t *mctx,
150 INSIST(name != NULL);
151 INSIST(rdata != NULL);
152 INSIST(mctx != NULL);
154 INSIST(*key == NULL);
155 REQUIRE(rdata->type == dns_rdatatype_key ||
156 rdata->type == dns_rdatatype_dnskey);
158 dns_rdata_toregion(rdata, &r);
159 isc_buffer_init(&b, r.base, r.length);
160 isc_buffer_add(&b, r.length);
161 return (dst_key_fromdns(name, rdata->rdclass, &b, mctx, key));
165 digest_sig(dst_context_t *ctx, isc_boolean_t downcase, dns_rdata_t *sigrdata,
166 dns_rdata_rrsig_t *rrsig)
170 dns_fixedname_t fname;
172 dns_rdata_toregion(sigrdata, &r);
173 INSIST(r.length >= 19);
176 ret = dst_context_adddata(ctx, &r);
177 if (ret != ISC_R_SUCCESS)
180 dns_fixedname_init(&fname);
182 RUNTIME_CHECK(dns_name_downcase(&rrsig->signer,
183 dns_fixedname_name(&fname),
184 NULL) == ISC_R_SUCCESS);
185 dns_name_toregion(dns_fixedname_name(&fname), &r);
187 dns_name_toregion(&rrsig->signer, &r);
189 return (dst_context_adddata(ctx, &r));
193 dns_dnssec_sign(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
194 isc_stdtime_t *inception, isc_stdtime_t *expire,
195 isc_mem_t *mctx, isc_buffer_t *buffer, dns_rdata_t *sigrdata)
197 dns_rdata_rrsig_t sig;
198 dns_rdata_t tmpsigrdata;
201 isc_buffer_t sigbuf, envbuf;
203 dst_context_t *ctx = NULL;
205 isc_buffer_t *databuf = NULL;
208 unsigned int sigsize;
209 dns_fixedname_t fnewname;
210 dns_fixedname_t fsigner;
212 REQUIRE(name != NULL);
213 REQUIRE(dns_name_countlabels(name) <= 255);
214 REQUIRE(set != NULL);
215 REQUIRE(key != NULL);
216 REQUIRE(inception != NULL);
217 REQUIRE(expire != NULL);
218 REQUIRE(mctx != NULL);
219 REQUIRE(sigrdata != NULL);
221 if (*inception >= *expire)
222 return (DNS_R_INVALIDTIME);
225 * Is the key allowed to sign data?
227 flags = dst_key_flags(key);
228 if (flags & DNS_KEYTYPE_NOAUTH)
229 return (DNS_R_KEYUNAUTHORIZED);
230 if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE)
231 return (DNS_R_KEYUNAUTHORIZED);
234 sig.common.rdclass = set->rdclass;
235 sig.common.rdtype = dns_rdatatype_rrsig;
236 ISC_LINK_INIT(&sig.common, link);
241 dns_name_init(&sig.signer, NULL);
242 dns_fixedname_init(&fsigner);
243 RUNTIME_CHECK(dns_name_downcase(dst_key_name(key),
244 dns_fixedname_name(&fsigner), NULL) == ISC_R_SUCCESS);
245 dns_name_clone(dns_fixedname_name(&fsigner), &sig.signer);
247 sig.covered = set->type;
248 sig.algorithm = dst_key_alg(key);
249 sig.labels = dns_name_countlabels(name) - 1;
250 if (dns_name_iswildcard(name))
252 sig.originalttl = set->ttl;
253 sig.timesigned = *inception;
254 sig.timeexpire = *expire;
255 sig.keyid = dst_key_id(key);
256 ret = dst_key_sigsize(key, &sigsize);
257 if (ret != ISC_R_SUCCESS)
259 sig.siglen = sigsize;
261 * The actual contents of sig.signature are not important yet, since
262 * they're not used in digest_sig().
264 sig.signature = isc_mem_get(mctx, sig.siglen);
265 if (sig.signature == NULL)
266 return (ISC_R_NOMEMORY);
268 ret = isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
269 if (ret != ISC_R_SUCCESS)
270 goto cleanup_signature;
272 dns_rdata_init(&tmpsigrdata);
273 ret = dns_rdata_fromstruct(&tmpsigrdata, sig.common.rdclass,
274 sig.common.rdtype, &sig, databuf);
275 if (ret != ISC_R_SUCCESS)
276 goto cleanup_databuf;
278 ret = dst_context_create2(key, mctx, DNS_LOGCATEGORY_DNSSEC, &ctx);
279 if (ret != ISC_R_SUCCESS)
280 goto cleanup_databuf;
283 * Digest the SIG rdata.
285 ret = digest_sig(ctx, ISC_FALSE, &tmpsigrdata, &sig);
286 if (ret != ISC_R_SUCCESS)
287 goto cleanup_context;
289 dns_fixedname_init(&fnewname);
290 RUNTIME_CHECK(dns_name_downcase(name, dns_fixedname_name(&fnewname),
291 NULL) == ISC_R_SUCCESS);
292 dns_name_toregion(dns_fixedname_name(&fnewname), &r);
295 * Create an envelope for each rdata: <name|type|class|ttl>.
297 isc_buffer_init(&envbuf, data, sizeof(data));
298 memcpy(data, r.base, r.length);
299 isc_buffer_add(&envbuf, r.length);
300 isc_buffer_putuint16(&envbuf, set->type);
301 isc_buffer_putuint16(&envbuf, set->rdclass);
302 isc_buffer_putuint32(&envbuf, set->ttl);
304 ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
305 if (ret != ISC_R_SUCCESS)
306 goto cleanup_context;
307 isc_buffer_usedregion(&envbuf, &r);
309 for (i = 0; i < nrdatas; i++) {
317 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
321 * Digest the envelope.
323 ret = dst_context_adddata(ctx, &r);
324 if (ret != ISC_R_SUCCESS)
328 * Digest the length of the rdata.
330 isc_buffer_init(&lenbuf, &len, sizeof(len));
331 INSIST(rdatas[i].length < 65536);
332 isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
333 isc_buffer_usedregion(&lenbuf, &lenr);
334 ret = dst_context_adddata(ctx, &lenr);
335 if (ret != ISC_R_SUCCESS)
341 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
342 if (ret != ISC_R_SUCCESS)
346 isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
347 ret = dst_context_sign(ctx, &sigbuf);
348 if (ret != ISC_R_SUCCESS)
350 isc_buffer_usedregion(&sigbuf, &r);
351 if (r.length != sig.siglen) {
356 ret = dns_rdata_fromstruct(sigrdata, sig.common.rdclass,
357 sig.common.rdtype, &sig, buffer);
360 isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
362 dst_context_destroy(&ctx);
364 isc_buffer_free(&databuf);
366 isc_mem_put(mctx, sig.signature, sig.siglen);
372 dns_dnssec_verify2(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
373 isc_boolean_t ignoretime, isc_mem_t *mctx,
374 dns_rdata_t *sigrdata, dns_name_t *wild)
376 return (dns_dnssec_verify3(name, set, key, ignoretime, 0, mctx,
381 dns_dnssec_verify3(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
382 isc_boolean_t ignoretime, unsigned int maxbits,
383 isc_mem_t *mctx, dns_rdata_t *sigrdata, dns_name_t *wild)
385 dns_rdata_rrsig_t sig;
386 dns_fixedname_t fnewname;
393 unsigned char data[300];
394 dst_context_t *ctx = NULL;
397 isc_boolean_t downcase = ISC_FALSE;
399 REQUIRE(name != NULL);
400 REQUIRE(set != NULL);
401 REQUIRE(key != NULL);
402 REQUIRE(mctx != NULL);
403 REQUIRE(sigrdata != NULL && sigrdata->type == dns_rdatatype_rrsig);
405 ret = dns_rdata_tostruct(sigrdata, &sig, NULL);
406 if (ret != ISC_R_SUCCESS)
409 if (set->type != sig.covered)
410 return (DNS_R_SIGINVALID);
412 if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
413 inc_stat(dns_dnssecstats_fail);
414 return (DNS_R_SIGINVALID);
418 isc_stdtime_get(&now);
421 * Is SIG temporally valid?
423 if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
424 inc_stat(dns_dnssecstats_fail);
425 return (DNS_R_SIGFUTURE);
426 } else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
427 inc_stat(dns_dnssecstats_fail);
428 return (DNS_R_SIGEXPIRED);
433 * NS, SOA and DNSSKEY records are signed by their owner.
434 * DS records are signed by the parent.
437 case dns_rdatatype_ns:
438 case dns_rdatatype_soa:
439 case dns_rdatatype_dnskey:
440 if (!dns_name_equal(name, &sig.signer)) {
441 inc_stat(dns_dnssecstats_fail);
442 return (DNS_R_SIGINVALID);
445 case dns_rdatatype_ds:
446 if (dns_name_equal(name, &sig.signer)) {
447 inc_stat(dns_dnssecstats_fail);
448 return (DNS_R_SIGINVALID);
452 if (!dns_name_issubdomain(name, &sig.signer)) {
453 inc_stat(dns_dnssecstats_fail);
454 return (DNS_R_SIGINVALID);
460 * Is the key allowed to sign data?
462 flags = dst_key_flags(key);
463 if (flags & DNS_KEYTYPE_NOAUTH) {
464 inc_stat(dns_dnssecstats_fail);
465 return (DNS_R_KEYUNAUTHORIZED);
467 if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE) {
468 inc_stat(dns_dnssecstats_fail);
469 return (DNS_R_KEYUNAUTHORIZED);
473 ret = dst_context_create2(key, mctx, DNS_LOGCATEGORY_DNSSEC, &ctx);
474 if (ret != ISC_R_SUCCESS)
478 * Digest the SIG rdata (not including the signature).
480 ret = digest_sig(ctx, downcase, sigrdata, &sig);
481 if (ret != ISC_R_SUCCESS)
482 goto cleanup_context;
485 * If the name is an expanded wildcard, use the wildcard name.
487 dns_fixedname_init(&fnewname);
488 labels = dns_name_countlabels(name) - 1;
489 RUNTIME_CHECK(dns_name_downcase(name, dns_fixedname_name(&fnewname),
490 NULL) == ISC_R_SUCCESS);
491 if (labels - sig.labels > 0)
492 dns_name_split(dns_fixedname_name(&fnewname), sig.labels + 1,
493 NULL, dns_fixedname_name(&fnewname));
495 dns_name_toregion(dns_fixedname_name(&fnewname), &r);
498 * Create an envelope for each rdata: <name|type|class|ttl>.
500 isc_buffer_init(&envbuf, data, sizeof(data));
501 if (labels - sig.labels > 0) {
502 isc_buffer_putuint8(&envbuf, 1);
503 isc_buffer_putuint8(&envbuf, '*');
504 memcpy(data + 2, r.base, r.length);
507 memcpy(data, r.base, r.length);
508 isc_buffer_add(&envbuf, r.length);
509 isc_buffer_putuint16(&envbuf, set->type);
510 isc_buffer_putuint16(&envbuf, set->rdclass);
511 isc_buffer_putuint32(&envbuf, sig.originalttl);
513 ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
514 if (ret != ISC_R_SUCCESS)
515 goto cleanup_context;
517 isc_buffer_usedregion(&envbuf, &r);
519 for (i = 0; i < nrdatas; i++) {
527 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
531 * Digest the envelope.
533 ret = dst_context_adddata(ctx, &r);
534 if (ret != ISC_R_SUCCESS)
538 * Digest the rdata length.
540 isc_buffer_init(&lenbuf, &len, sizeof(len));
541 INSIST(rdatas[i].length < 65536);
542 isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
543 isc_buffer_usedregion(&lenbuf, &lenr);
548 ret = dst_context_adddata(ctx, &lenr);
549 if (ret != ISC_R_SUCCESS)
551 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
552 if (ret != ISC_R_SUCCESS)
556 r.base = sig.signature;
557 r.length = sig.siglen;
558 ret = dst_context_verify2(ctx, maxbits, &r);
559 if (ret == ISC_R_SUCCESS && downcase) {
560 char namebuf[DNS_NAME_FORMATSIZE];
561 dns_name_format(&sig.signer, namebuf, sizeof(namebuf));
562 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
563 DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
564 "successfully validated after lower casing "
565 "signer '%s'", namebuf);
566 inc_stat(dns_dnssecstats_downcase);
567 } else if (ret == ISC_R_SUCCESS)
568 inc_stat(dns_dnssecstats_asis);
571 isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
573 dst_context_destroy(&ctx);
574 if (ret == DST_R_VERIFYFAILURE && !downcase) {
579 dns_rdata_freestruct(&sig);
581 if (ret == DST_R_VERIFYFAILURE)
582 ret = DNS_R_SIGINVALID;
584 if (ret != ISC_R_SUCCESS)
585 inc_stat(dns_dnssecstats_fail);
587 if (ret == ISC_R_SUCCESS && labels - sig.labels > 0) {
589 RUNTIME_CHECK(dns_name_concatenate(dns_wildcardname,
590 dns_fixedname_name(&fnewname),
591 wild, NULL) == ISC_R_SUCCESS);
592 inc_stat(dns_dnssecstats_wildcard);
593 ret = DNS_R_FROMWILDCARD;
599 dns_dnssec_verify(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
600 isc_boolean_t ignoretime, isc_mem_t *mctx,
601 dns_rdata_t *sigrdata)
605 result = dns_dnssec_verify2(name, set, key, ignoretime, mctx,
607 if (result == DNS_R_FROMWILDCARD)
608 result = ISC_R_SUCCESS;
613 key_active(dst_key_t *key, isc_stdtime_t now) {
615 isc_stdtime_t publish, active, revoke, inactive, delete;
616 isc_boolean_t pubset = ISC_FALSE, actset = ISC_FALSE;
617 isc_boolean_t revset = ISC_FALSE, inactset = ISC_FALSE;
618 isc_boolean_t delset = ISC_FALSE;
621 /* Is this an old-style key? */
622 result = dst_key_getprivateformat(key, &major, &minor);
623 RUNTIME_CHECK(result == ISC_R_SUCCESS);
626 * Smart signing started with key format 1.3; prior to that, all
627 * keys are assumed active
629 if (major == 1 && minor <= 2)
632 result = dst_key_gettime(key, DST_TIME_PUBLISH, &publish);
633 if (result == ISC_R_SUCCESS)
636 result = dst_key_gettime(key, DST_TIME_ACTIVATE, &active);
637 if (result == ISC_R_SUCCESS)
640 result = dst_key_gettime(key, DST_TIME_REVOKE, &revoke);
641 if (result == ISC_R_SUCCESS)
644 result = dst_key_gettime(key, DST_TIME_INACTIVE, &inactive);
645 if (result == ISC_R_SUCCESS)
648 result = dst_key_gettime(key, DST_TIME_DELETE, &delete);
649 if (result == ISC_R_SUCCESS)
652 if ((inactset && inactive <= now) || (delset && delete <= now))
655 if (revset && revoke <= now && pubset && publish <= now)
658 if (actset && active <= now)
664 #define is_zone_key(key) ((dst_key_flags(key) & DNS_KEYFLAG_OWNERMASK) \
665 == DNS_KEYOWNER_ZONE)
668 dns_dnssec_findzonekeys2(dns_db_t *db, dns_dbversion_t *ver,
669 dns_dbnode_t *node, dns_name_t *name,
670 const char *directory, isc_mem_t *mctx,
671 unsigned int maxkeys, dst_key_t **keys,
674 dns_rdataset_t rdataset;
675 dns_rdata_t rdata = DNS_RDATA_INIT;
677 dst_key_t *pubkey = NULL;
678 unsigned int count = 0;
681 REQUIRE(nkeys != NULL);
682 REQUIRE(keys != NULL);
684 isc_stdtime_get(&now);
687 dns_rdataset_init(&rdataset);
688 RETERR(dns_db_findrdataset(db, node, ver, dns_rdatatype_dnskey, 0, 0,
690 RETERR(dns_rdataset_first(&rdataset));
691 while (result == ISC_R_SUCCESS && count < maxkeys) {
693 dns_rdataset_current(&rdataset, &rdata);
694 RETERR(dns_dnssec_keyfromrdata(name, &rdata, mctx, &pubkey));
695 dst_key_setttl(pubkey, rdataset.ttl);
697 if (!is_zone_key(pubkey) ||
698 (dst_key_flags(pubkey) & DNS_KEYTYPE_NOAUTH) != 0)
700 /* Corrupted .key file? */
701 if (!dns_name_equal(name, dst_key_name(pubkey)))
704 result = dst_key_fromfile(dst_key_name(pubkey),
707 DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
712 * If the key was revoked and the private file
713 * doesn't exist, maybe it was revoked internally
714 * by named. Try loading the unrevoked version.
716 if (result == ISC_R_FILENOTFOUND) {
718 flags = dst_key_flags(pubkey);
719 if ((flags & DNS_KEYFLAG_REVOKE) != 0) {
720 dst_key_setflags(pubkey,
721 flags & ~DNS_KEYFLAG_REVOKE);
722 result = dst_key_fromfile(dst_key_name(pubkey),
729 if (result == ISC_R_SUCCESS &&
730 dst_key_pubcompare(pubkey, keys[count],
732 dst_key_setflags(keys[count], flags);
734 dst_key_setflags(pubkey, flags);
738 if (result != ISC_R_SUCCESS) {
739 char keybuf[DNS_NAME_FORMATSIZE];
740 char algbuf[DNS_SECALG_FORMATSIZE];
741 dns_name_format(dst_key_name(pubkey), keybuf,
743 dns_secalg_format(dst_key_alg(pubkey), algbuf,
745 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
746 DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
747 "dns_dnssec_findzonekeys2: error "
748 "reading private key file %s/%s/%d: %s",
749 keybuf, algbuf, dst_key_id(pubkey),
750 isc_result_totext(result));
753 if (result == ISC_R_FILENOTFOUND || result == ISC_R_NOPERM) {
754 keys[count] = pubkey;
760 if (result != ISC_R_SUCCESS)
764 * If a key is marked inactive, skip it
766 if (!key_active(keys[count], now)) {
767 dst_key_free(&keys[count]);
768 keys[count] = pubkey;
775 * Whatever the key's default TTL may have
776 * been, the rdataset TTL takes priority.
778 dst_key_setttl(keys[count], rdataset.ttl);
780 if ((dst_key_flags(keys[count]) & DNS_KEYTYPE_NOAUTH) != 0) {
781 /* We should never get here. */
782 dst_key_free(&keys[count]);
788 dst_key_free(&pubkey);
789 dns_rdata_reset(&rdata);
790 result = dns_rdataset_next(&rdataset);
792 if (result != ISC_R_NOMORE)
795 result = ISC_R_NOTFOUND;
797 result = ISC_R_SUCCESS;
800 if (dns_rdataset_isassociated(&rdataset))
801 dns_rdataset_disassociate(&rdataset);
803 dst_key_free(&pubkey);
804 if (result != ISC_R_SUCCESS)
806 dst_key_free(&keys[--count]);
812 dns_dnssec_findzonekeys(dns_db_t *db, dns_dbversion_t *ver,
813 dns_dbnode_t *node, dns_name_t *name, isc_mem_t *mctx,
814 unsigned int maxkeys, dst_key_t **keys,
817 return (dns_dnssec_findzonekeys2(db, ver, node, name, NULL, mctx,
818 maxkeys, keys, nkeys));
822 dns_dnssec_signmessage(dns_message_t *msg, dst_key_t *key) {
823 dns_rdata_sig_t sig; /* SIG(0) */
824 unsigned char data[512];
825 unsigned char header[DNS_MESSAGE_HEADERLEN];
826 isc_buffer_t headerbuf, databuf, sigbuf;
827 unsigned int sigsize;
828 isc_buffer_t *dynbuf = NULL;
830 dns_rdatalist_t *datalist;
831 dns_rdataset_t *dataset;
834 dst_context_t *ctx = NULL;
837 isc_boolean_t signeedsfree = ISC_TRUE;
839 REQUIRE(msg != NULL);
840 REQUIRE(key != NULL);
842 if (is_response(msg))
843 REQUIRE(msg->query.base != NULL);
847 memset(&sig, 0, sizeof(sig));
850 sig.common.rdclass = dns_rdataclass_any;
851 sig.common.rdtype = dns_rdatatype_sig; /* SIG(0) */
852 ISC_LINK_INIT(&sig.common, link);
855 sig.algorithm = dst_key_alg(key);
856 sig.labels = 0; /* the root name */
859 isc_stdtime_get(&now);
860 sig.timesigned = now - DNS_TSIG_FUDGE;
861 sig.timeexpire = now + DNS_TSIG_FUDGE;
863 sig.keyid = dst_key_id(key);
865 dns_name_init(&sig.signer, NULL);
866 dns_name_clone(dst_key_name(key), &sig.signer);
869 sig.signature = NULL;
871 isc_buffer_init(&databuf, data, sizeof(data));
873 RETERR(dst_context_create2(key, mctx, DNS_LOGCATEGORY_DNSSEC, &ctx));
876 * Digest the fields of the SIG - we can cheat and use
877 * dns_rdata_fromstruct. Since siglen is 0, the digested data
878 * is identical to dns format.
880 RETERR(dns_rdata_fromstruct(NULL, dns_rdataclass_any,
881 dns_rdatatype_sig /* SIG(0) */,
883 isc_buffer_usedregion(&databuf, &r);
884 RETERR(dst_context_adddata(ctx, &r));
887 * If this is a response, digest the query.
889 if (is_response(msg))
890 RETERR(dst_context_adddata(ctx, &msg->query));
895 isc_buffer_init(&headerbuf, header, sizeof(header));
896 dns_message_renderheader(msg, &headerbuf);
897 isc_buffer_usedregion(&headerbuf, &r);
898 RETERR(dst_context_adddata(ctx, &r));
901 * Digest the remainder of the message.
903 isc_buffer_usedregion(msg->buffer, &r);
904 isc_region_consume(&r, DNS_MESSAGE_HEADERLEN);
905 RETERR(dst_context_adddata(ctx, &r));
907 RETERR(dst_key_sigsize(key, &sigsize));
908 sig.siglen = sigsize;
909 sig.signature = (unsigned char *) isc_mem_get(mctx, sig.siglen);
910 if (sig.signature == NULL) {
911 result = ISC_R_NOMEMORY;
915 isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
916 RETERR(dst_context_sign(ctx, &sigbuf));
917 dst_context_destroy(&ctx);
920 RETERR(dns_message_gettemprdata(msg, &rdata));
921 RETERR(isc_buffer_allocate(msg->mctx, &dynbuf, 1024));
922 RETERR(dns_rdata_fromstruct(rdata, dns_rdataclass_any,
923 dns_rdatatype_sig /* SIG(0) */,
926 isc_mem_put(mctx, sig.signature, sig.siglen);
927 signeedsfree = ISC_FALSE;
929 dns_message_takebuffer(msg, &dynbuf);
932 RETERR(dns_message_gettemprdatalist(msg, &datalist));
933 datalist->rdclass = dns_rdataclass_any;
934 datalist->type = dns_rdatatype_sig; /* SIG(0) */
935 datalist->covers = 0;
937 ISC_LIST_INIT(datalist->rdata);
938 ISC_LIST_APPEND(datalist->rdata, rdata, link);
940 RETERR(dns_message_gettemprdataset(msg, &dataset));
941 dns_rdataset_init(dataset);
942 RUNTIME_CHECK(dns_rdatalist_tordataset(datalist, dataset) == ISC_R_SUCCESS);
945 return (ISC_R_SUCCESS);
949 isc_buffer_free(&dynbuf);
951 isc_mem_put(mctx, sig.signature, sig.siglen);
953 dst_context_destroy(&ctx);
959 dns_dnssec_verifymessage(isc_buffer_t *source, dns_message_t *msg,
962 dns_rdata_sig_t sig; /* SIG(0) */
963 unsigned char header[DNS_MESSAGE_HEADERLEN];
964 dns_rdata_t rdata = DNS_RDATA_INIT;
965 isc_region_t r, source_r, sig_r, header_r;
967 dst_context_t *ctx = NULL;
970 isc_uint16_t addcount;
971 isc_boolean_t signeedsfree = ISC_FALSE;
973 REQUIRE(source != NULL);
974 REQUIRE(msg != NULL);
975 REQUIRE(key != NULL);
979 msg->verify_attempted = 1;
981 if (is_response(msg)) {
982 if (msg->query.base == NULL)
983 return (DNS_R_UNEXPECTEDTSIG);
986 isc_buffer_usedregion(source, &source_r);
988 RETERR(dns_rdataset_first(msg->sig0));
989 dns_rdataset_current(msg->sig0, &rdata);
991 RETERR(dns_rdata_tostruct(&rdata, &sig, NULL));
992 signeedsfree = ISC_TRUE;
994 if (sig.labels != 0) {
995 result = DNS_R_SIGINVALID;
999 if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
1000 result = DNS_R_SIGINVALID;
1001 msg->sig0status = dns_tsigerror_badtime;
1005 isc_stdtime_get(&now);
1006 if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
1007 result = DNS_R_SIGFUTURE;
1008 msg->sig0status = dns_tsigerror_badtime;
1011 else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
1012 result = DNS_R_SIGEXPIRED;
1013 msg->sig0status = dns_tsigerror_badtime;
1017 if (!dns_name_equal(dst_key_name(key), &sig.signer)) {
1018 result = DNS_R_SIGINVALID;
1019 msg->sig0status = dns_tsigerror_badkey;
1023 RETERR(dst_context_create2(key, mctx, DNS_LOGCATEGORY_DNSSEC, &ctx));
1026 * Digest the SIG(0) record, except for the signature.
1028 dns_rdata_toregion(&rdata, &r);
1029 r.length -= sig.siglen;
1030 RETERR(dst_context_adddata(ctx, &r));
1033 * If this is a response, digest the query.
1035 if (is_response(msg))
1036 RETERR(dst_context_adddata(ctx, &msg->query));
1039 * Extract the header.
1041 memcpy(header, source_r.base, DNS_MESSAGE_HEADERLEN);
1044 * Decrement the additional field counter.
1046 memcpy(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
1047 addcount = htons((isc_uint16_t)(ntohs(addcount) - 1));
1048 memcpy(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
1051 * Digest the modified header.
1053 header_r.base = (unsigned char *) header;
1054 header_r.length = DNS_MESSAGE_HEADERLEN;
1055 RETERR(dst_context_adddata(ctx, &header_r));
1058 * Digest all non-SIG(0) records.
1060 r.base = source_r.base + DNS_MESSAGE_HEADERLEN;
1061 r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN;
1062 RETERR(dst_context_adddata(ctx, &r));
1064 sig_r.base = sig.signature;
1065 sig_r.length = sig.siglen;
1066 result = dst_context_verify(ctx, &sig_r);
1067 if (result != ISC_R_SUCCESS) {
1068 msg->sig0status = dns_tsigerror_badsig;
1072 msg->verified_sig = 1;
1074 dst_context_destroy(&ctx);
1075 dns_rdata_freestruct(&sig);
1077 return (ISC_R_SUCCESS);
1081 dns_rdata_freestruct(&sig);
1083 dst_context_destroy(&ctx);
1089 * Does this key ('rdata') self sign the rrset ('rdataset')?
1092 dns_dnssec_selfsigns(dns_rdata_t *rdata, dns_name_t *name,
1093 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
1094 isc_boolean_t ignoretime, isc_mem_t *mctx)
1096 INSIST(rdataset->type == dns_rdatatype_key ||
1097 rdataset->type == dns_rdatatype_dnskey);
1098 if (rdataset->type == dns_rdatatype_key) {
1099 INSIST(sigrdataset->type == dns_rdatatype_sig);
1100 INSIST(sigrdataset->covers == dns_rdatatype_key);
1102 INSIST(sigrdataset->type == dns_rdatatype_rrsig);
1103 INSIST(sigrdataset->covers == dns_rdatatype_dnskey);
1106 return (dns_dnssec_signs(rdata, name, rdataset, sigrdataset,
1112 dns_dnssec_signs(dns_rdata_t *rdata, dns_name_t *name,
1113 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
1114 isc_boolean_t ignoretime, isc_mem_t *mctx)
1116 dst_key_t *dstkey = NULL;
1117 dns_keytag_t keytag;
1118 dns_rdata_dnskey_t key;
1119 dns_rdata_rrsig_t sig;
1120 dns_rdata_t sigrdata = DNS_RDATA_INIT;
1121 isc_result_t result;
1123 INSIST(sigrdataset->type == dns_rdatatype_rrsig);
1124 if (sigrdataset->covers != rdataset->type)
1127 result = dns_dnssec_keyfromrdata(name, rdata, mctx, &dstkey);
1128 if (result != ISC_R_SUCCESS)
1130 result = dns_rdata_tostruct(rdata, &key, NULL);
1131 RUNTIME_CHECK(result == ISC_R_SUCCESS);
1133 keytag = dst_key_id(dstkey);
1134 for (result = dns_rdataset_first(sigrdataset);
1135 result == ISC_R_SUCCESS;
1136 result = dns_rdataset_next(sigrdataset))
1138 dns_rdata_reset(&sigrdata);
1139 dns_rdataset_current(sigrdataset, &sigrdata);
1140 result = dns_rdata_tostruct(&sigrdata, &sig, NULL);
1141 RUNTIME_CHECK(result == ISC_R_SUCCESS);
1143 if (sig.algorithm == key.algorithm &&
1144 sig.keyid == keytag) {
1145 result = dns_dnssec_verify2(name, rdataset, dstkey,
1148 if (result == ISC_R_SUCCESS) {
1149 dst_key_free(&dstkey);
1154 dst_key_free(&dstkey);
1159 dns_dnsseckey_create(isc_mem_t *mctx, dst_key_t **dstkey,
1160 dns_dnsseckey_t **dkp)
1162 isc_result_t result;
1163 dns_dnsseckey_t *dk;
1166 REQUIRE(dkp != NULL && *dkp == NULL);
1167 dk = isc_mem_get(mctx, sizeof(dns_dnsseckey_t));
1169 return (ISC_R_NOMEMORY);
1173 dk->force_publish = ISC_FALSE;
1174 dk->force_sign = ISC_FALSE;
1175 dk->hint_publish = ISC_FALSE;
1176 dk->hint_sign = ISC_FALSE;
1177 dk->hint_remove = ISC_FALSE;
1178 dk->first_sign = ISC_FALSE;
1179 dk->is_active = ISC_FALSE;
1181 dk->source = dns_keysource_unknown;
1185 dk->ksk = ISC_TF((dst_key_flags(dk->key) & DNS_KEYFLAG_KSK) != 0);
1187 /* Is this an old-style key? */
1188 result = dst_key_getprivateformat(dk->key, &major, &minor);
1189 INSIST(result == ISC_R_SUCCESS);
1191 /* Smart signing started with key format 1.3 */
1192 dk->legacy = ISC_TF(major == 1 && minor <= 2);
1194 ISC_LINK_INIT(dk, link);
1196 return (ISC_R_SUCCESS);
1200 dns_dnsseckey_destroy(isc_mem_t *mctx, dns_dnsseckey_t **dkp) {
1201 dns_dnsseckey_t *dk;
1203 REQUIRE(dkp != NULL && *dkp != NULL);
1205 if (dk->key != NULL)
1206 dst_key_free(&dk->key);
1207 isc_mem_put(mctx, dk, sizeof(dns_dnsseckey_t));
1212 get_hints(dns_dnsseckey_t *key, isc_stdtime_t now) {
1213 isc_result_t result;
1214 isc_stdtime_t publish, active, revoke, inactive, delete;
1215 isc_boolean_t pubset = ISC_FALSE, actset = ISC_FALSE;
1216 isc_boolean_t revset = ISC_FALSE, inactset = ISC_FALSE;
1217 isc_boolean_t delset = ISC_FALSE;
1219 REQUIRE(key != NULL && key->key != NULL);
1221 result = dst_key_gettime(key->key, DST_TIME_PUBLISH, &publish);
1222 if (result == ISC_R_SUCCESS)
1225 result = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
1226 if (result == ISC_R_SUCCESS)
1229 result = dst_key_gettime(key->key, DST_TIME_REVOKE, &revoke);
1230 if (result == ISC_R_SUCCESS)
1233 result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &inactive);
1234 if (result == ISC_R_SUCCESS)
1235 inactset = ISC_TRUE;
1237 result = dst_key_gettime(key->key, DST_TIME_DELETE, &delete);
1238 if (result == ISC_R_SUCCESS)
1241 /* Metadata says publish (but possibly not activate) */
1242 if (pubset && publish <= now)
1243 key->hint_publish = ISC_TRUE;
1245 /* Metadata says activate (so we must also publish) */
1246 if (actset && active <= now) {
1247 key->hint_sign = ISC_TRUE;
1248 key->hint_publish = ISC_TRUE;
1252 * Activation date is set (maybe in the future), but
1253 * publication date isn't. Most likely the user wants to
1254 * publish now and activate later.
1256 if (actset && !pubset)
1257 key->hint_publish = ISC_TRUE;
1260 * If activation date is in the future, make note of how far off
1262 if (key->hint_publish && actset && active > now) {
1263 key->prepublish = active - now;
1267 * Key has been marked inactive: we can continue publishing,
1270 if (key->hint_publish && inactset && inactive <= now) {
1271 key->hint_sign = ISC_FALSE;
1275 * Metadata says revoke. If the key is published,
1276 * we *have to* sign with it per RFC5011--even if it was
1277 * not active before.
1279 * If it hasn't already been done, we should also revoke it now.
1281 if (key->hint_publish && (revset && revoke <= now)) {
1283 key->hint_sign = ISC_TRUE;
1284 flags = dst_key_flags(key->key);
1285 if ((flags & DNS_KEYFLAG_REVOKE) == 0) {
1286 flags |= DNS_KEYFLAG_REVOKE;
1287 dst_key_setflags(key->key, flags);
1292 * Metadata says delete, so don't publish this key or sign with it.
1294 if (delset && delete <= now) {
1295 key->hint_publish = ISC_FALSE;
1296 key->hint_sign = ISC_FALSE;
1297 key->hint_remove = ISC_TRUE;
1302 * Get a list of DNSSEC keys from the key repository
1305 dns_dnssec_findmatchingkeys(dns_name_t *origin, const char *directory,
1306 isc_mem_t *mctx, dns_dnsseckeylist_t *keylist)
1308 isc_result_t result = ISC_R_SUCCESS;
1309 isc_boolean_t dir_open = ISC_FALSE;
1310 dns_dnsseckeylist_t list;
1312 dns_dnsseckey_t *key = NULL;
1313 dst_key_t *dstkey = NULL;
1314 char namebuf[DNS_NAME_FORMATSIZE], *p;
1319 REQUIRE(keylist != NULL);
1320 ISC_LIST_INIT(list);
1323 isc_buffer_init(&b, namebuf, sizeof(namebuf) - 1);
1324 RETERR(dns_name_tofilenametext(origin, ISC_FALSE, &b));
1325 len = isc_buffer_usedlength(&b);
1326 namebuf[len] = '\0';
1328 if (directory == NULL)
1330 RETERR(isc_dir_open(&dir, directory));
1331 dir_open = ISC_TRUE;
1333 isc_stdtime_get(&now);
1335 while (isc_dir_read(&dir) == ISC_R_SUCCESS) {
1336 if (dir.entry.name[0] == 'K' &&
1337 dir.entry.length > len + 1 &&
1338 dir.entry.name[len + 1] == '+' &&
1339 strncasecmp(dir.entry.name + 1, namebuf, len) == 0) {
1340 p = strrchr(dir.entry.name, '.');
1341 if (p != NULL && strcmp(p, ".private") != 0)
1345 result = dst_key_fromnamedfile(dir.entry.name,
1351 if (result != ISC_R_SUCCESS) {
1352 isc_log_write(dns_lctx,
1353 DNS_LOGCATEGORY_GENERAL,
1354 DNS_LOGMODULE_DNSSEC,
1356 "dns_dnssec_findmatchingkeys: "
1357 "error reading key file %s: %s",
1359 isc_result_totext(result));
1363 RETERR(dns_dnsseckey_create(mctx, &dstkey, &key));
1364 key->source = dns_keysource_repository;
1365 get_hints(key, now);
1368 dns_dnsseckey_destroy(mctx, &key);
1370 ISC_LIST_APPEND(list, key, link);
1376 if (!ISC_LIST_EMPTY(list))
1377 ISC_LIST_APPENDLIST(*keylist, list, link);
1379 result = ISC_R_NOTFOUND;
1383 isc_dir_close(&dir);
1384 INSIST(key == NULL);
1385 while ((key = ISC_LIST_HEAD(list)) != NULL) {
1386 ISC_LIST_UNLINK(list, key, link);
1387 INSIST(key->key != NULL);
1388 dst_key_free(&key->key);
1389 dns_dnsseckey_destroy(mctx, &key);
1392 dst_key_free(&dstkey);
1397 * Add 'newkey' to 'keylist' if it's not already there.
1399 * If 'savekeys' is ISC_TRUE, then we need to preserve all
1400 * the keys in the keyset, regardless of whether they have
1401 * metadata indicating they should be deactivated or removed.
1404 addkey(dns_dnsseckeylist_t *keylist, dst_key_t **newkey,
1405 isc_boolean_t savekeys, isc_mem_t *mctx)
1407 dns_dnsseckey_t *key;
1408 isc_result_t result;
1410 /* Skip duplicates */
1411 for (key = ISC_LIST_HEAD(*keylist);
1413 key = ISC_LIST_NEXT(key, link)) {
1414 if (dst_key_id(key->key) == dst_key_id(*newkey) &&
1415 dst_key_alg(key->key) == dst_key_alg(*newkey) &&
1416 dns_name_equal(dst_key_name(key->key),
1417 dst_key_name(*newkey)))
1423 * Found a match. If the old key was only public and the
1424 * new key is private, replace the old one; otherwise
1425 * leave it. But either way, mark the key as having
1426 * been found in the zone.
1428 if (dst_key_isprivate(key->key)) {
1429 dst_key_free(newkey);
1430 } else if (dst_key_isprivate(*newkey)) {
1431 dst_key_free(&key->key);
1435 key->source = dns_keysource_zoneapex;
1436 return (ISC_R_SUCCESS);
1439 result = dns_dnsseckey_create(mctx, newkey, &key);
1440 if (result != ISC_R_SUCCESS)
1442 if (key->legacy || savekeys) {
1443 key->force_publish = ISC_TRUE;
1444 key->force_sign = dst_key_isprivate(key->key);
1446 key->source = dns_keysource_zoneapex;
1447 ISC_LIST_APPEND(*keylist, key, link);
1449 return (ISC_R_SUCCESS);
1454 * Mark all keys which signed the DNSKEY/SOA RRsets as "active",
1455 * for future reference.
1458 mark_active_keys(dns_dnsseckeylist_t *keylist, dns_rdataset_t *rrsigs) {
1459 isc_result_t result = ISC_R_SUCCESS;
1460 dns_rdata_t rdata = DNS_RDATA_INIT;
1461 dns_rdataset_t sigs;
1462 dns_dnsseckey_t *key;
1464 REQUIRE(rrsigs != NULL && dns_rdataset_isassociated(rrsigs));
1466 dns_rdataset_init(&sigs);
1467 dns_rdataset_clone(rrsigs, &sigs);
1468 for (key = ISC_LIST_HEAD(*keylist);
1470 key = ISC_LIST_NEXT(key, link)) {
1471 isc_uint16_t keyid, sigid;
1472 dns_secalg_t keyalg, sigalg;
1473 keyid = dst_key_id(key->key);
1474 keyalg = dst_key_alg(key->key);
1476 for (result = dns_rdataset_first(&sigs);
1477 result == ISC_R_SUCCESS;
1478 result = dns_rdataset_next(&sigs)) {
1479 dns_rdata_rrsig_t sig;
1481 dns_rdata_reset(&rdata);
1482 dns_rdataset_current(&sigs, &rdata);
1483 result = dns_rdata_tostruct(&rdata, &sig, NULL);
1484 RUNTIME_CHECK(result == ISC_R_SUCCESS);
1485 sigalg = sig.algorithm;
1487 if (keyid == sigid && keyalg == sigalg) {
1488 key->is_active = ISC_TRUE;
1494 if (result == ISC_R_NOMORE)
1495 result = ISC_R_SUCCESS;
1497 if (dns_rdataset_isassociated(&sigs))
1498 dns_rdataset_disassociate(&sigs);
1503 * Add the contents of a DNSKEY rdataset 'keyset' to 'keylist'.
1506 dns_dnssec_keylistfromrdataset(dns_name_t *origin,
1507 const char *directory, isc_mem_t *mctx,
1508 dns_rdataset_t *keyset, dns_rdataset_t *keysigs,
1509 dns_rdataset_t *soasigs, isc_boolean_t savekeys,
1510 isc_boolean_t public,
1511 dns_dnsseckeylist_t *keylist)
1513 dns_rdataset_t keys;
1514 dns_rdata_t rdata = DNS_RDATA_INIT;
1515 dst_key_t *pubkey = NULL, *privkey = NULL;
1516 isc_result_t result;
1518 REQUIRE(keyset != NULL && dns_rdataset_isassociated(keyset));
1520 dns_rdataset_init(&keys);
1522 dns_rdataset_clone(keyset, &keys);
1523 for (result = dns_rdataset_first(&keys);
1524 result == ISC_R_SUCCESS;
1525 result = dns_rdataset_next(&keys)) {
1526 dns_rdata_reset(&rdata);
1527 dns_rdataset_current(&keys, &rdata);
1528 RETERR(dns_dnssec_keyfromrdata(origin, &rdata, mctx, &pubkey));
1529 dst_key_setttl(pubkey, keys.ttl);
1531 if (!is_zone_key(pubkey) ||
1532 (dst_key_flags(pubkey) & DNS_KEYTYPE_NOAUTH) != 0)
1535 /* Corrupted .key file? */
1536 if (!dns_name_equal(origin, dst_key_name(pubkey)))
1540 RETERR(addkey(keylist, &pubkey, savekeys, mctx));
1544 result = dst_key_fromfile(dst_key_name(pubkey),
1546 dst_key_alg(pubkey),
1547 DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
1548 directory, mctx, &privkey);
1551 * If the key was revoked and the private file
1552 * doesn't exist, maybe it was revoked internally
1553 * by named. Try loading the unrevoked version.
1555 if (result == ISC_R_FILENOTFOUND) {
1557 flags = dst_key_flags(pubkey);
1558 if ((flags & DNS_KEYFLAG_REVOKE) != 0) {
1559 dst_key_setflags(pubkey,
1560 flags & ~DNS_KEYFLAG_REVOKE);
1561 result = dst_key_fromfile(dst_key_name(pubkey),
1563 dst_key_alg(pubkey),
1568 if (result == ISC_R_SUCCESS &&
1569 dst_key_pubcompare(pubkey, privkey,
1571 dst_key_setflags(privkey, flags);
1573 dst_key_setflags(pubkey, flags);
1577 if (result != ISC_R_SUCCESS) {
1578 char keybuf[DNS_NAME_FORMATSIZE];
1579 char algbuf[DNS_SECALG_FORMATSIZE];
1580 dns_name_format(dst_key_name(pubkey), keybuf,
1582 dns_secalg_format(dst_key_alg(pubkey), algbuf,
1584 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
1585 DNS_LOGMODULE_DNSSEC, ISC_LOG_WARNING,
1586 "dns_dnssec_keylistfromrdataset: error "
1587 "reading private key file %s/%s/%d: %s",
1588 keybuf, algbuf, dst_key_id(pubkey),
1589 isc_result_totext(result));
1592 if (result == ISC_R_FILENOTFOUND || result == ISC_R_NOPERM) {
1593 RETERR(addkey(keylist, &pubkey, savekeys, mctx));
1598 /* This should never happen. */
1599 if ((dst_key_flags(privkey) & DNS_KEYTYPE_NOAUTH) != 0)
1603 * Whatever the key's default TTL may have
1604 * been, the rdataset TTL takes priority.
1606 dst_key_setttl(privkey, dst_key_getttl(pubkey));
1608 RETERR(addkey(keylist, &privkey, savekeys, mctx));
1611 dst_key_free(&pubkey);
1612 if (privkey != NULL)
1613 dst_key_free(&privkey);
1616 if (result != ISC_R_NOMORE)
1619 if (keysigs != NULL && dns_rdataset_isassociated(keysigs))
1620 RETERR(mark_active_keys(keylist, keysigs));
1622 if (soasigs != NULL && dns_rdataset_isassociated(soasigs))
1623 RETERR(mark_active_keys(keylist, soasigs));
1625 result = ISC_R_SUCCESS;
1628 if (dns_rdataset_isassociated(&keys))
1629 dns_rdataset_disassociate(&keys);
1631 dst_key_free(&pubkey);
1632 if (privkey != NULL)
1633 dst_key_free(&privkey);
1638 make_dnskey(dst_key_t *key, unsigned char *buf, int bufsize,
1639 dns_rdata_t *target)
1641 isc_result_t result;
1645 isc_buffer_init(&b, buf, bufsize);
1646 result = dst_key_todns(key, &b);
1647 if (result != ISC_R_SUCCESS)
1650 dns_rdata_reset(target);
1651 isc_buffer_usedregion(&b, &r);
1652 dns_rdata_fromregion(target, dst_key_class(key),
1653 dns_rdatatype_dnskey, &r);
1654 return (ISC_R_SUCCESS);
1658 publish_key(dns_diff_t *diff, dns_dnsseckey_t *key, dns_name_t *origin,
1659 dns_ttl_t ttl, isc_mem_t *mctx, isc_boolean_t allzsk,
1660 void (*report)(const char *, ...))
1662 isc_result_t result;
1663 dns_difftuple_t *tuple = NULL;
1664 unsigned char buf[DST_KEY_MAXSIZE];
1665 dns_rdata_t dnskey = DNS_RDATA_INIT;
1668 dns_rdata_reset(&dnskey);
1669 RETERR(make_dnskey(key->key, buf, sizeof(buf), &dnskey));
1671 dns_secalg_format(dst_key_alg(key->key), alg, sizeof(alg));
1672 report("Fetching %s %d/%s from key %s.",
1673 key->ksk ? (allzsk ? "KSK/ZSK" : "KSK") : "ZSK",
1674 dst_key_id(key->key), alg,
1675 key->source == dns_keysource_user ? "file" : "repository");
1677 if (key->prepublish && ttl > key->prepublish) {
1678 char keystr[DST_KEY_FORMATSIZE];
1681 dst_key_format(key->key, keystr, sizeof(keystr));
1682 report("Key %s: Delaying activation to match the DNSKEY TTL.\n",
1685 isc_stdtime_get(&now);
1686 dst_key_settime(key->key, DST_TIME_ACTIVATE, now + ttl);
1690 RETERR(dns_difftuple_create(mctx, DNS_DIFFOP_ADD, origin, ttl,
1692 dns_diff_appendminimal(diff, &tuple);
1693 result = ISC_R_SUCCESS;
1700 remove_key(dns_diff_t *diff, dns_dnsseckey_t *key, dns_name_t *origin,
1701 dns_ttl_t ttl, isc_mem_t *mctx, const char *reason,
1702 void (*report)(const char *, ...))
1704 isc_result_t result;
1705 dns_difftuple_t *tuple = NULL;
1706 unsigned char buf[DST_KEY_MAXSIZE];
1707 dns_rdata_t dnskey = DNS_RDATA_INIT;
1710 dns_secalg_format(dst_key_alg(key->key), alg, sizeof(alg));
1711 report("Removing %s key %d/%s from DNSKEY RRset.",
1712 reason, dst_key_id(key->key), alg);
1714 RETERR(make_dnskey(key->key, buf, sizeof(buf), &dnskey));
1715 RETERR(dns_difftuple_create(mctx, DNS_DIFFOP_DEL, origin, ttl, &dnskey,
1717 dns_diff_appendminimal(diff, &tuple);
1718 result = ISC_R_SUCCESS;
1725 * Update 'keys' with information from 'newkeys'.
1727 * If 'removed' is not NULL, any keys that are being removed from
1728 * the zone will be added to the list for post-removal processing.
1731 dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
1732 dns_dnsseckeylist_t *removed, dns_name_t *origin,
1733 dns_ttl_t hint_ttl, dns_diff_t *diff,
1734 isc_boolean_t allzsk, isc_mem_t *mctx,
1735 void (*report)(const char *, ...))
1737 isc_result_t result;
1738 dns_dnsseckey_t *key, *key1, *key2, *next;
1739 isc_boolean_t found_ttl = ISC_FALSE;
1740 dns_ttl_t ttl = hint_ttl;
1743 * First, look through the existing key list to find keys
1744 * supplied from the command line which are not in the zone.
1745 * Update the zone to include them.
1747 * Also, if there are keys published in the zone already,
1748 * use their TTL for all subsequent published keys.
1750 for (key = ISC_LIST_HEAD(*keys);
1752 key = ISC_LIST_NEXT(key, link)) {
1753 if (key->source == dns_keysource_user &&
1754 (key->hint_publish || key->force_publish)) {
1755 RETERR(publish_key(diff, key, origin, ttl,
1756 mctx, allzsk, report));
1758 if (key->source == dns_keysource_zoneapex) {
1759 ttl = dst_key_getttl(key->key);
1760 found_ttl = ISC_TRUE;
1765 * If there were no existing keys, use the smallest nonzero
1766 * TTL of the keys found in the repository.
1768 if (!found_ttl && !ISC_LIST_EMPTY(*newkeys)) {
1769 dns_ttl_t shortest = 0;
1771 for (key = ISC_LIST_HEAD(*newkeys);
1773 key = ISC_LIST_NEXT(key, link)) {
1774 dns_ttl_t thisttl = dst_key_getttl(key->key);
1776 (shortest == 0 || thisttl < shortest))
1785 * Second, scan the list of newly found keys looking for matches
1786 * with known keys, and update accordingly.
1788 for (key1 = ISC_LIST_HEAD(*newkeys); key1 != NULL; key1 = next) {
1789 isc_boolean_t key_revoked = ISC_FALSE;
1791 next = ISC_LIST_NEXT(key1, link);
1793 for (key2 = ISC_LIST_HEAD(*keys);
1795 key2 = ISC_LIST_NEXT(key2, link)) {
1796 if (dst_key_pubcompare(key1->key, key2->key,
1799 r1 = dst_key_flags(key1->key) &
1801 r2 = dst_key_flags(key2->key) &
1803 key_revoked = ISC_TF(r1 != r2);
1808 /* No match found in keys; add the new key. */
1810 ISC_LIST_UNLINK(*newkeys, key1, link);
1811 ISC_LIST_APPEND(*keys, key1, link);
1813 if (key1->source != dns_keysource_zoneapex &&
1814 (key1->hint_publish || key1->force_publish)) {
1815 RETERR(publish_key(diff, key1, origin, ttl,
1816 mctx, allzsk, report));
1817 if (key1->hint_sign || key1->force_sign)
1818 key1->first_sign = ISC_TRUE;
1824 /* Match found: remove or update it as needed */
1825 if (key1->hint_remove) {
1826 RETERR(remove_key(diff, key2, origin, ttl, mctx,
1827 "expired", report));
1828 ISC_LIST_UNLINK(*keys, key2, link);
1829 if (removed != NULL)
1830 ISC_LIST_APPEND(*removed, key2, link);
1832 dns_dnsseckey_destroy(mctx, &key2);
1833 } else if (key_revoked &&
1834 (dst_key_flags(key1->key) & DNS_KEYFLAG_REVOKE) != 0) {
1837 * A previously valid key has been revoked.
1838 * We need to remove the old version and pull
1841 RETERR(remove_key(diff, key2, origin, ttl, mctx,
1842 "revoked", report));
1843 ISC_LIST_UNLINK(*keys, key2, link);
1844 if (removed != NULL)
1845 ISC_LIST_APPEND(*removed, key2, link);
1847 dns_dnsseckey_destroy(mctx, &key2);
1849 RETERR(publish_key(diff, key1, origin, ttl,
1850 mctx, allzsk, report));
1851 ISC_LIST_UNLINK(*newkeys, key1, link);
1852 ISC_LIST_APPEND(*keys, key1, link);
1855 * XXX: The revoke flag is only defined for trust
1856 * anchors. Setting the flag on a non-KSK is legal,
1857 * but not defined in any RFC. It seems reasonable
1858 * to treat it the same as a KSK: keep it in the
1859 * zone, sign the DNSKEY set with it, but not
1860 * sign other records with it.
1862 key1->ksk = ISC_TRUE;
1865 if (!key2->is_active &&
1866 (key1->hint_sign || key1->force_sign))
1867 key2->first_sign = ISC_TRUE;
1868 key2->hint_sign = key1->hint_sign;
1869 key2->hint_publish = key1->hint_publish;
1873 /* Free any leftover keys in newkeys */
1874 while (!ISC_LIST_EMPTY(*newkeys)) {
1875 key1 = ISC_LIST_HEAD(*newkeys);
1876 ISC_LIST_UNLINK(*newkeys, key1, link);
1877 dns_dnsseckey_destroy(mctx, &key1);
1880 result = ISC_R_SUCCESS;