2 * Copyright (C) 2004-2007 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.
19 * $Id: dnssec.c,v 1.81.18.10 2007/09/14 04:35:42 marka Exp $
28 #include <isc/buffer.h>
30 #include <isc/serial.h>
31 #include <isc/string.h>
35 #include <dns/dnssec.h>
36 #include <dns/fixedname.h>
37 #include <dns/keyvalues.h>
38 #include <dns/message.h>
39 #include <dns/rdata.h>
40 #include <dns/rdatalist.h>
41 #include <dns/rdataset.h>
42 #include <dns/rdatastruct.h>
43 #include <dns/result.h>
44 #include <dns/tsig.h> /* for DNS_TSIG_FUDGE */
46 #include <dst/result.h>
48 #define is_response(msg) (msg->flags & DNS_MESSAGEFLAG_QR)
50 #define RETERR(x) do { \
52 if (result != ISC_R_SUCCESS) \
61 digest_callback(void *arg, isc_region_t *data);
64 rdata_compare_wrapper(const void *rdata1, const void *rdata2);
67 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
68 dns_rdata_t **rdata, int *nrdata);
71 digest_callback(void *arg, isc_region_t *data) {
72 dst_context_t *ctx = arg;
74 return (dst_context_adddata(ctx, data));
81 rdata_compare_wrapper(const void *rdata1, const void *rdata2) {
82 return (dns_rdata_compare((const dns_rdata_t *)rdata1,
83 (const dns_rdata_t *)rdata2));
87 * Sort the rdataset into an array.
90 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
91 dns_rdata_t **rdata, int *nrdata)
97 n = dns_rdataset_count(set);
99 data = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
101 return (ISC_R_NOMEMORY);
103 ret = dns_rdataset_first(set);
104 if (ret != ISC_R_SUCCESS) {
105 isc_mem_put(mctx, data, n * sizeof(dns_rdata_t));
110 * Put them in the array.
113 dns_rdata_init(&data[i]);
114 dns_rdataset_current(set, &data[i++]);
115 } while (dns_rdataset_next(set) == ISC_R_SUCCESS);
120 qsort(data, n, sizeof(dns_rdata_t), rdata_compare_wrapper);
123 return (ISC_R_SUCCESS);
127 dns_dnssec_keyfromrdata(dns_name_t *name, dns_rdata_t *rdata, isc_mem_t *mctx,
133 INSIST(name != NULL);
134 INSIST(rdata != NULL);
135 INSIST(mctx != NULL);
137 INSIST(*key == NULL);
138 REQUIRE(rdata->type == dns_rdatatype_key ||
139 rdata->type == dns_rdatatype_dnskey);
141 dns_rdata_toregion(rdata, &r);
142 isc_buffer_init(&b, r.base, r.length);
143 isc_buffer_add(&b, r.length);
144 return (dst_key_fromdns(name, rdata->rdclass, &b, mctx, key));
148 digest_sig(dst_context_t *ctx, dns_rdata_t *sigrdata, dns_rdata_rrsig_t *sig) {
151 dns_fixedname_t fname;
153 dns_rdata_toregion(sigrdata, &r);
154 INSIST(r.length >= 19);
157 ret = dst_context_adddata(ctx, &r);
158 if (ret != ISC_R_SUCCESS)
160 dns_fixedname_init(&fname);
161 RUNTIME_CHECK(dns_name_downcase(&sig->signer,
162 dns_fixedname_name(&fname), NULL)
164 dns_name_toregion(dns_fixedname_name(&fname), &r);
165 return (dst_context_adddata(ctx, &r));
169 dns_dnssec_sign(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
170 isc_stdtime_t *inception, isc_stdtime_t *expire,
171 isc_mem_t *mctx, isc_buffer_t *buffer, dns_rdata_t *sigrdata)
173 dns_rdata_rrsig_t sig;
174 dns_rdata_t tmpsigrdata;
177 isc_buffer_t sigbuf, envbuf;
179 dst_context_t *ctx = NULL;
181 isc_buffer_t *databuf = NULL;
184 unsigned int sigsize;
185 dns_fixedname_t fnewname;
187 REQUIRE(name != NULL);
188 REQUIRE(dns_name_countlabels(name) <= 255);
189 REQUIRE(set != NULL);
190 REQUIRE(key != NULL);
191 REQUIRE(inception != NULL);
192 REQUIRE(expire != NULL);
193 REQUIRE(mctx != NULL);
194 REQUIRE(sigrdata != NULL);
196 if (*inception >= *expire)
197 return (DNS_R_INVALIDTIME);
200 * Is the key allowed to sign data?
202 flags = dst_key_flags(key);
203 if (flags & DNS_KEYTYPE_NOAUTH)
204 return (DNS_R_KEYUNAUTHORIZED);
205 if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE)
206 return (DNS_R_KEYUNAUTHORIZED);
209 sig.common.rdclass = set->rdclass;
210 sig.common.rdtype = dns_rdatatype_rrsig;
211 ISC_LINK_INIT(&sig.common, link);
213 dns_name_init(&sig.signer, NULL);
214 dns_name_clone(dst_key_name(key), &sig.signer);
216 sig.covered = set->type;
217 sig.algorithm = dst_key_alg(key);
218 sig.labels = dns_name_countlabels(name) - 1;
219 if (dns_name_iswildcard(name))
221 sig.originalttl = set->ttl;
222 sig.timesigned = *inception;
223 sig.timeexpire = *expire;
224 sig.keyid = dst_key_id(key);
225 ret = dst_key_sigsize(key, &sigsize);
226 if (ret != ISC_R_SUCCESS)
228 sig.siglen = sigsize;
230 * The actual contents of sig.signature are not important yet, since
231 * they're not used in digest_sig().
233 sig.signature = isc_mem_get(mctx, sig.siglen);
234 if (sig.signature == NULL)
235 return (ISC_R_NOMEMORY);
237 ret = isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
238 if (ret != ISC_R_SUCCESS)
239 goto cleanup_signature;
241 dns_rdata_init(&tmpsigrdata);
242 ret = dns_rdata_fromstruct(&tmpsigrdata, sig.common.rdclass,
243 sig.common.rdtype, &sig, databuf);
244 if (ret != ISC_R_SUCCESS)
245 goto cleanup_databuf;
247 ret = dst_context_create(key, mctx, &ctx);
248 if (ret != ISC_R_SUCCESS)
249 goto cleanup_databuf;
252 * Digest the SIG rdata.
254 ret = digest_sig(ctx, &tmpsigrdata, &sig);
255 if (ret != ISC_R_SUCCESS)
256 goto cleanup_context;
258 dns_fixedname_init(&fnewname);
259 RUNTIME_CHECK(dns_name_downcase(name, dns_fixedname_name(&fnewname),
260 NULL) == ISC_R_SUCCESS);
261 dns_name_toregion(dns_fixedname_name(&fnewname), &r);
264 * Create an envelope for each rdata: <name|type|class|ttl>.
266 isc_buffer_init(&envbuf, data, sizeof(data));
267 memcpy(data, r.base, r.length);
268 isc_buffer_add(&envbuf, r.length);
269 isc_buffer_putuint16(&envbuf, set->type);
270 isc_buffer_putuint16(&envbuf, set->rdclass);
271 isc_buffer_putuint32(&envbuf, set->ttl);
273 ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
274 if (ret != ISC_R_SUCCESS)
275 goto cleanup_context;
276 isc_buffer_usedregion(&envbuf, &r);
278 for (i = 0; i < nrdatas; i++) {
286 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
290 * Digest the envelope.
292 ret = dst_context_adddata(ctx, &r);
293 if (ret != ISC_R_SUCCESS)
297 * Digest the length of the rdata.
299 isc_buffer_init(&lenbuf, &len, sizeof(len));
300 INSIST(rdatas[i].length < 65536);
301 isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
302 isc_buffer_usedregion(&lenbuf, &lenr);
303 ret = dst_context_adddata(ctx, &lenr);
304 if (ret != ISC_R_SUCCESS)
310 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
311 if (ret != ISC_R_SUCCESS)
315 isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
316 ret = dst_context_sign(ctx, &sigbuf);
317 if (ret != ISC_R_SUCCESS)
319 isc_buffer_usedregion(&sigbuf, &r);
320 if (r.length != sig.siglen) {
324 memcpy(sig.signature, r.base, sig.siglen);
326 ret = dns_rdata_fromstruct(sigrdata, sig.common.rdclass,
327 sig.common.rdtype, &sig, buffer);
330 isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
332 dst_context_destroy(&ctx);
334 isc_buffer_free(&databuf);
336 isc_mem_put(mctx, sig.signature, sig.siglen);
342 dns_dnssec_verify2(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
343 isc_boolean_t ignoretime, isc_mem_t *mctx,
344 dns_rdata_t *sigrdata, dns_name_t *wild)
346 dns_rdata_rrsig_t sig;
347 dns_fixedname_t fnewname;
354 unsigned char data[300];
355 dst_context_t *ctx = NULL;
359 REQUIRE(name != NULL);
360 REQUIRE(set != NULL);
361 REQUIRE(key != NULL);
362 REQUIRE(mctx != NULL);
363 REQUIRE(sigrdata != NULL && sigrdata->type == dns_rdatatype_rrsig);
365 ret = dns_rdata_tostruct(sigrdata, &sig, NULL);
366 if (ret != ISC_R_SUCCESS)
369 if (isc_serial_lt(sig.timeexpire, sig.timesigned))
370 return (DNS_R_SIGINVALID);
373 isc_stdtime_get(&now);
376 * Is SIG temporally valid?
378 if (isc_serial_lt((isc_uint32_t)now, sig.timesigned))
379 return (DNS_R_SIGFUTURE);
380 else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now))
381 return (DNS_R_SIGEXPIRED);
385 * Is the key allowed to sign data?
387 flags = dst_key_flags(key);
388 if (flags & DNS_KEYTYPE_NOAUTH)
389 return (DNS_R_KEYUNAUTHORIZED);
390 if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE)
391 return (DNS_R_KEYUNAUTHORIZED);
393 ret = dst_context_create(key, mctx, &ctx);
394 if (ret != ISC_R_SUCCESS)
398 * Digest the SIG rdata (not including the signature).
400 ret = digest_sig(ctx, sigrdata, &sig);
401 if (ret != ISC_R_SUCCESS)
402 goto cleanup_context;
405 * If the name is an expanded wildcard, use the wildcard name.
407 dns_fixedname_init(&fnewname);
408 labels = dns_name_countlabels(name) - 1;
409 RUNTIME_CHECK(dns_name_downcase(name, dns_fixedname_name(&fnewname),
410 NULL) == ISC_R_SUCCESS);
411 if (labels - sig.labels > 0)
412 dns_name_split(dns_fixedname_name(&fnewname), sig.labels + 1,
413 NULL, dns_fixedname_name(&fnewname));
415 dns_name_toregion(dns_fixedname_name(&fnewname), &r);
418 * Create an envelope for each rdata: <name|type|class|ttl>.
420 isc_buffer_init(&envbuf, data, sizeof(data));
421 if (labels - sig.labels > 0) {
422 isc_buffer_putuint8(&envbuf, 1);
423 isc_buffer_putuint8(&envbuf, '*');
424 memcpy(data + 2, r.base, r.length);
427 memcpy(data, r.base, r.length);
428 isc_buffer_add(&envbuf, r.length);
429 isc_buffer_putuint16(&envbuf, set->type);
430 isc_buffer_putuint16(&envbuf, set->rdclass);
431 isc_buffer_putuint32(&envbuf, sig.originalttl);
433 ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
434 if (ret != ISC_R_SUCCESS)
435 goto cleanup_context;
437 isc_buffer_usedregion(&envbuf, &r);
439 for (i = 0; i < nrdatas; i++) {
447 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
451 * Digest the envelope.
453 ret = dst_context_adddata(ctx, &r);
454 if (ret != ISC_R_SUCCESS)
458 * Digest the rdata length.
460 isc_buffer_init(&lenbuf, &len, sizeof(len));
461 INSIST(rdatas[i].length < 65536);
462 isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
463 isc_buffer_usedregion(&lenbuf, &lenr);
468 ret = dst_context_adddata(ctx, &lenr);
469 if (ret != ISC_R_SUCCESS)
471 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
472 if (ret != ISC_R_SUCCESS)
476 r.base = sig.signature;
477 r.length = sig.siglen;
478 ret = dst_context_verify(ctx, &r);
479 if (ret == DST_R_VERIFYFAILURE)
480 ret = DNS_R_SIGINVALID;
483 isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
485 dst_context_destroy(&ctx);
487 dns_rdata_freestruct(&sig);
489 if (ret == ISC_R_SUCCESS && labels - sig.labels > 0) {
491 RUNTIME_CHECK(dns_name_concatenate(dns_wildcardname,
492 dns_fixedname_name(&fnewname),
493 wild, NULL) == ISC_R_SUCCESS);
494 ret = DNS_R_FROMWILDCARD;
500 dns_dnssec_verify(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
501 isc_boolean_t ignoretime, isc_mem_t *mctx,
502 dns_rdata_t *sigrdata)
506 result = dns_dnssec_verify2(name, set, key, ignoretime, mctx,
508 if (result == DNS_R_FROMWILDCARD)
509 result = ISC_R_SUCCESS;
513 #define is_zone_key(key) ((dst_key_flags(key) & DNS_KEYFLAG_OWNERMASK) \
514 == DNS_KEYOWNER_ZONE)
517 dns_dnssec_findzonekeys2(dns_db_t *db, dns_dbversion_t *ver,
518 dns_dbnode_t *node, dns_name_t *name,
519 const char *directory, isc_mem_t *mctx,
520 unsigned int maxkeys, dst_key_t **keys,
523 dns_rdataset_t rdataset;
524 dns_rdata_t rdata = DNS_RDATA_INIT;
526 dst_key_t *pubkey = NULL;
527 unsigned int count = 0;
529 REQUIRE(nkeys != NULL);
530 REQUIRE(keys != NULL);
533 dns_rdataset_init(&rdataset);
534 RETERR(dns_db_findrdataset(db, node, ver, dns_rdatatype_dnskey, 0, 0,
536 RETERR(dns_rdataset_first(&rdataset));
537 while (result == ISC_R_SUCCESS && count < maxkeys) {
539 dns_rdataset_current(&rdataset, &rdata);
540 RETERR(dns_dnssec_keyfromrdata(name, &rdata, mctx, &pubkey));
541 if (!is_zone_key(pubkey) ||
542 (dst_key_flags(pubkey) & DNS_KEYTYPE_NOAUTH) != 0)
545 result = dst_key_fromfile(dst_key_name(pubkey),
548 DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
551 if (result == ISC_R_FILENOTFOUND) {
552 keys[count] = pubkey;
557 if (result != ISC_R_SUCCESS)
559 if ((dst_key_flags(keys[count]) & DNS_KEYTYPE_NOAUTH) != 0) {
560 /* We should never get here. */
561 dst_key_free(&keys[count]);
567 dst_key_free(&pubkey);
568 dns_rdata_reset(&rdata);
569 result = dns_rdataset_next(&rdataset);
571 if (result != ISC_R_NOMORE)
574 result = ISC_R_NOTFOUND;
576 result = ISC_R_SUCCESS;
579 if (dns_rdataset_isassociated(&rdataset))
580 dns_rdataset_disassociate(&rdataset);
582 dst_key_free(&pubkey);
583 if (result != ISC_R_SUCCESS)
585 dst_key_free(&keys[--count]);
591 dns_dnssec_findzonekeys(dns_db_t *db, dns_dbversion_t *ver,
592 dns_dbnode_t *node, dns_name_t *name, isc_mem_t *mctx,
593 unsigned int maxkeys, dst_key_t **keys,
596 return (dns_dnssec_findzonekeys2(db, ver, node, name, NULL, mctx,
597 maxkeys, keys, nkeys));
601 dns_dnssec_signmessage(dns_message_t *msg, dst_key_t *key) {
602 dns_rdata_sig_t sig; /* SIG(0) */
603 unsigned char data[512];
604 unsigned char header[DNS_MESSAGE_HEADERLEN];
605 isc_buffer_t headerbuf, databuf, sigbuf;
606 unsigned int sigsize;
607 isc_buffer_t *dynbuf = NULL;
609 dns_rdatalist_t *datalist;
610 dns_rdataset_t *dataset;
613 dst_context_t *ctx = NULL;
616 isc_boolean_t signeedsfree = ISC_TRUE;
618 REQUIRE(msg != NULL);
619 REQUIRE(key != NULL);
621 if (is_response(msg))
622 REQUIRE(msg->query.base != NULL);
626 memset(&sig, 0, sizeof(sig));
629 sig.common.rdclass = dns_rdataclass_any;
630 sig.common.rdtype = dns_rdatatype_sig; /* SIG(0) */
631 ISC_LINK_INIT(&sig.common, link);
634 sig.algorithm = dst_key_alg(key);
635 sig.labels = 0; /* the root name */
638 isc_stdtime_get(&now);
639 sig.timesigned = now - DNS_TSIG_FUDGE;
640 sig.timeexpire = now + DNS_TSIG_FUDGE;
642 sig.keyid = dst_key_id(key);
644 dns_name_init(&sig.signer, NULL);
645 dns_name_clone(dst_key_name(key), &sig.signer);
648 sig.signature = NULL;
650 isc_buffer_init(&databuf, data, sizeof(data));
652 RETERR(dst_context_create(key, mctx, &ctx));
655 * Digest the fields of the SIG - we can cheat and use
656 * dns_rdata_fromstruct. Since siglen is 0, the digested data
657 * is identical to dns format.
659 RETERR(dns_rdata_fromstruct(NULL, dns_rdataclass_any,
660 dns_rdatatype_sig /* SIG(0) */,
662 isc_buffer_usedregion(&databuf, &r);
663 RETERR(dst_context_adddata(ctx, &r));
666 * If this is a response, digest the query.
668 if (is_response(msg))
669 RETERR(dst_context_adddata(ctx, &msg->query));
674 isc_buffer_init(&headerbuf, header, sizeof(header));
675 dns_message_renderheader(msg, &headerbuf);
676 isc_buffer_usedregion(&headerbuf, &r);
677 RETERR(dst_context_adddata(ctx, &r));
680 * Digest the remainder of the message.
682 isc_buffer_usedregion(msg->buffer, &r);
683 isc_region_consume(&r, DNS_MESSAGE_HEADERLEN);
684 RETERR(dst_context_adddata(ctx, &r));
686 RETERR(dst_key_sigsize(key, &sigsize));
687 sig.siglen = sigsize;
688 sig.signature = (unsigned char *) isc_mem_get(mctx, sig.siglen);
689 if (sig.signature == NULL) {
690 result = ISC_R_NOMEMORY;
694 isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
695 RETERR(dst_context_sign(ctx, &sigbuf));
696 dst_context_destroy(&ctx);
699 RETERR(dns_message_gettemprdata(msg, &rdata));
700 RETERR(isc_buffer_allocate(msg->mctx, &dynbuf, 1024));
701 RETERR(dns_rdata_fromstruct(rdata, dns_rdataclass_any,
702 dns_rdatatype_sig /* SIG(0) */,
705 isc_mem_put(mctx, sig.signature, sig.siglen);
706 signeedsfree = ISC_FALSE;
708 dns_message_takebuffer(msg, &dynbuf);
711 RETERR(dns_message_gettemprdatalist(msg, &datalist));
712 datalist->rdclass = dns_rdataclass_any;
713 datalist->type = dns_rdatatype_sig; /* SIG(0) */
714 datalist->covers = 0;
716 ISC_LIST_INIT(datalist->rdata);
717 ISC_LIST_APPEND(datalist->rdata, rdata, link);
719 RETERR(dns_message_gettemprdataset(msg, &dataset));
720 dns_rdataset_init(dataset);
721 RUNTIME_CHECK(dns_rdatalist_tordataset(datalist, dataset) == ISC_R_SUCCESS);
724 return (ISC_R_SUCCESS);
728 isc_buffer_free(&dynbuf);
730 isc_mem_put(mctx, sig.signature, sig.siglen);
732 dst_context_destroy(&ctx);
738 dns_dnssec_verifymessage(isc_buffer_t *source, dns_message_t *msg,
741 dns_rdata_sig_t sig; /* SIG(0) */
742 unsigned char header[DNS_MESSAGE_HEADERLEN];
743 dns_rdata_t rdata = DNS_RDATA_INIT;
744 isc_region_t r, source_r, sig_r, header_r;
746 dst_context_t *ctx = NULL;
749 isc_uint16_t addcount;
750 isc_boolean_t signeedsfree = ISC_FALSE;
752 REQUIRE(source != NULL);
753 REQUIRE(msg != NULL);
754 REQUIRE(key != NULL);
758 msg->verify_attempted = 1;
760 if (is_response(msg)) {
761 if (msg->query.base == NULL)
762 return (DNS_R_UNEXPECTEDTSIG);
765 isc_buffer_usedregion(source, &source_r);
767 RETERR(dns_rdataset_first(msg->sig0));
768 dns_rdataset_current(msg->sig0, &rdata);
770 RETERR(dns_rdata_tostruct(&rdata, &sig, NULL));
771 signeedsfree = ISC_TRUE;
773 if (sig.labels != 0) {
774 result = DNS_R_SIGINVALID;
778 if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
779 result = DNS_R_SIGINVALID;
780 msg->sig0status = dns_tsigerror_badtime;
784 isc_stdtime_get(&now);
785 if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
786 result = DNS_R_SIGFUTURE;
787 msg->sig0status = dns_tsigerror_badtime;
790 else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
791 result = DNS_R_SIGEXPIRED;
792 msg->sig0status = dns_tsigerror_badtime;
796 if (!dns_name_equal(dst_key_name(key), &sig.signer)) {
797 result = DNS_R_SIGINVALID;
798 msg->sig0status = dns_tsigerror_badkey;
802 RETERR(dst_context_create(key, mctx, &ctx));
805 * Digest the SIG(0) record, except for the signature.
807 dns_rdata_toregion(&rdata, &r);
808 r.length -= sig.siglen;
809 RETERR(dst_context_adddata(ctx, &r));
812 * If this is a response, digest the query.
814 if (is_response(msg))
815 RETERR(dst_context_adddata(ctx, &msg->query));
818 * Extract the header.
820 memcpy(header, source_r.base, DNS_MESSAGE_HEADERLEN);
823 * Decrement the additional field counter.
825 memcpy(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
826 addcount = htons((isc_uint16_t)(ntohs(addcount) - 1));
827 memcpy(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
830 * Digest the modified header.
832 header_r.base = (unsigned char *) header;
833 header_r.length = DNS_MESSAGE_HEADERLEN;
834 RETERR(dst_context_adddata(ctx, &header_r));
837 * Digest all non-SIG(0) records.
839 r.base = source_r.base + DNS_MESSAGE_HEADERLEN;
840 r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN;
841 RETERR(dst_context_adddata(ctx, &r));
843 sig_r.base = sig.signature;
844 sig_r.length = sig.siglen;
845 result = dst_context_verify(ctx, &sig_r);
846 if (result != ISC_R_SUCCESS) {
847 msg->sig0status = dns_tsigerror_badsig;
851 msg->verified_sig = 1;
853 dst_context_destroy(&ctx);
854 dns_rdata_freestruct(&sig);
856 return (ISC_R_SUCCESS);
860 dns_rdata_freestruct(&sig);
862 dst_context_destroy(&ctx);