contrib/bind9/lib/dns/dnssec.c

   1 /*
   2  * Copyright (C) 2004-2007  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2003  Internet Software Consortium.
   4  *
   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.
   8  *
   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.
  16  */
  17
  18 /*
  19  * $Id: dnssec.c,v 1.81.18.10 2007/09/14 04:35:42 marka Exp $
  20  */
  21
  22 /*! \file */
  23
  24 #include <config.h>
  25
  26 #include <stdlib.h>
  27
  28 #include <isc/buffer.h>
  29 #include <isc/mem.h>
  30 #include <isc/serial.h>
  31 #include <isc/string.h>
  32 #include <isc/util.h>
  33
  34 #include <dns/db.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 */
  45
  46 #include <dst/result.h>
  47
  48 #define is_response(msg) (msg->flags & DNS_MESSAGEFLAG_QR)
  49
  50 #define RETERR(x) do { \
  51         result = (x); \
  52         if (result != ISC_R_SUCCESS) \
  53                 goto failure; \
  54         } while (0)
  55
  56
  57 #define TYPE_SIGN 0
  58 #define TYPE_VERIFY 1
  59
  60 static isc_result_t
  61 digest_callback(void *arg, isc_region_t *data);
  62
  63 static int
  64 rdata_compare_wrapper(const void *rdata1, const void *rdata2);
  65
  66 static isc_result_t
  67 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
  68                         dns_rdata_t **rdata, int *nrdata);
  69
  70 static isc_result_t
  71 digest_callback(void *arg, isc_region_t *data) {
  72         dst_context_t *ctx = arg;
  73
  74         return (dst_context_adddata(ctx, data));
  75 }
  76
  77 /*
  78  * Make qsort happy.
  79  */
  80 static int
  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));
  84 }
  85
  86 /*
  87  * Sort the rdataset into an array.
  88  */
  89 static isc_result_t
  90 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
  91                         dns_rdata_t **rdata, int *nrdata)
  92 {
  93         isc_result_t ret;
  94         int i = 0, n;
  95         dns_rdata_t *data;
  96
  97         n = dns_rdataset_count(set);
  98
  99         data = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
 100         if (data == NULL)
 101                 return (ISC_R_NOMEMORY);
 102
 103         ret = dns_rdataset_first(set);
 104         if (ret != ISC_R_SUCCESS) {
 105                 isc_mem_put(mctx, data, n * sizeof(dns_rdata_t));
 106                 return (ret);
 107         }
 108
 109         /*
 110          * Put them in the array.
 111          */
 112         do {
 113                 dns_rdata_init(&data[i]);
 114                 dns_rdataset_current(set, &data[i++]);
 115         } while (dns_rdataset_next(set) == ISC_R_SUCCESS);
 116
 117         /*
 118          * Sort the array.
 119          */
 120         qsort(data, n, sizeof(dns_rdata_t), rdata_compare_wrapper);
 121         *rdata = data;
 122         *nrdata = n;
 123         return (ISC_R_SUCCESS);
 124 }
 125
 126 isc_result_t
 127 dns_dnssec_keyfromrdata(dns_name_t *name, dns_rdata_t *rdata, isc_mem_t *mctx,
 128                         dst_key_t **key)
 129 {
 130         isc_buffer_t b;
 131         isc_region_t r;
 132
 133         INSIST(name != NULL);
 134         INSIST(rdata != NULL);
 135         INSIST(mctx != NULL);
 136         INSIST(key != NULL);
 137         INSIST(*key == NULL);
 138         REQUIRE(rdata->type == dns_rdatatype_key ||
 139                 rdata->type == dns_rdatatype_dnskey);
 140
 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));
 145 }
 146
 147 static isc_result_t
 148 digest_sig(dst_context_t *ctx, dns_rdata_t *sigrdata, dns_rdata_rrsig_t *sig) {
 149         isc_region_t r;
 150         isc_result_t ret;
 151         dns_fixedname_t fname;
 152
 153         dns_rdata_toregion(sigrdata, &r);
 154         INSIST(r.length >= 19);
 155
 156         r.length = 18;
 157         ret = dst_context_adddata(ctx, &r);
 158         if (ret != ISC_R_SUCCESS)
 159                 return (ret);
 160         dns_fixedname_init(&fname);
 161         RUNTIME_CHECK(dns_name_downcase(&sig->signer,
 162                                         dns_fixedname_name(&fname), NULL)
 163                       == ISC_R_SUCCESS);
 164         dns_name_toregion(dns_fixedname_name(&fname), &r);
 165         return (dst_context_adddata(ctx, &r));
 166 }
 167
 168 isc_result_t
 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)
 172 {
 173         dns_rdata_rrsig_t sig;
 174         dns_rdata_t tmpsigrdata;
 175         dns_rdata_t *rdatas;
 176         int nrdatas, i;
 177         isc_buffer_t sigbuf, envbuf;
 178         isc_region_t r;
 179         dst_context_t *ctx = NULL;
 180         isc_result_t ret;
 181         isc_buffer_t *databuf = NULL;
 182         char data[256 + 8];
 183         isc_uint32_t flags;
 184         unsigned int sigsize;
 185         dns_fixedname_t fnewname;
 186
 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);
 195
 196         if (*inception >= *expire)
 197                 return (DNS_R_INVALIDTIME);
 198
 199         /*
 200          * Is the key allowed to sign data?
 201          */
 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);
 207
 208         sig.mctx = mctx;
 209         sig.common.rdclass = set->rdclass;
 210         sig.common.rdtype = dns_rdatatype_rrsig;
 211         ISC_LINK_INIT(&sig.common, link);
 212
 213         dns_name_init(&sig.signer, NULL);
 214         dns_name_clone(dst_key_name(key), &sig.signer);
 215
 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))
 220                 sig.labels--;
 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)
 227                 return (ret);
 228         sig.siglen = sigsize;
 229         /*
 230          * The actual contents of sig.signature are not important yet, since
 231          * they're not used in digest_sig().
 232          */
 233         sig.signature = isc_mem_get(mctx, sig.siglen);
 234         if (sig.signature == NULL)
 235                 return (ISC_R_NOMEMORY);
 236
 237         ret = isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
 238         if (ret != ISC_R_SUCCESS)
 239                 goto cleanup_signature;
 240
 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;
 246
 247         ret = dst_context_create(key, mctx, &ctx);
 248         if (ret != ISC_R_SUCCESS)
 249                 goto cleanup_databuf;
 250
 251         /*
 252          * Digest the SIG rdata.
 253          */
 254         ret = digest_sig(ctx, &tmpsigrdata, &sig);
 255         if (ret != ISC_R_SUCCESS)
 256                 goto cleanup_context;
 257
 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);
 262
 263         /*
 264          * Create an envelope for each rdata: <name|type|class|ttl>.
 265          */
 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);
 272
 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);
 277
 278         for (i = 0; i < nrdatas; i++) {
 279                 isc_uint16_t len;
 280                 isc_buffer_t lenbuf;
 281                 isc_region_t lenr;
 282
 283                 /*
 284                  * Skip duplicates.
 285                  */
 286                 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
 287                     continue;
 288
 289                 /*
 290                  * Digest the envelope.
 291                  */
 292                 ret = dst_context_adddata(ctx, &r);
 293                 if (ret != ISC_R_SUCCESS)
 294                         goto cleanup_array;
 295
 296                 /*
 297                  * Digest the length of the rdata.
 298                  */
 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)
 305                         goto cleanup_array;
 306
 307                 /*
 308                  * Digest the rdata.
 309                  */
 310                 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
 311                 if (ret != ISC_R_SUCCESS)
 312                         goto cleanup_array;
 313         }
 314
 315         isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
 316         ret = dst_context_sign(ctx, &sigbuf);
 317         if (ret != ISC_R_SUCCESS)
 318                 goto cleanup_array;
 319         isc_buffer_usedregion(&sigbuf, &r);
 320         if (r.length != sig.siglen) {
 321                 ret = ISC_R_NOSPACE;
 322                 goto cleanup_array;
 323         }
 324         memcpy(sig.signature, r.base, sig.siglen);
 325
 326         ret = dns_rdata_fromstruct(sigrdata, sig.common.rdclass,
 327                                   sig.common.rdtype, &sig, buffer);
 328
 329 cleanup_array:
 330         isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
 331 cleanup_context:
 332         dst_context_destroy(&ctx);
 333 cleanup_databuf:
 334         isc_buffer_free(&databuf);
 335 cleanup_signature:
 336         isc_mem_put(mctx, sig.signature, sig.siglen);
 337
 338         return (ret);
 339 }
 340
 341 isc_result_t
 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)
 345 {
 346         dns_rdata_rrsig_t sig;
 347         dns_fixedname_t fnewname;
 348         isc_region_t r;
 349         isc_buffer_t envbuf;
 350         dns_rdata_t *rdatas;
 351         int nrdatas, i;
 352         isc_stdtime_t now;
 353         isc_result_t ret;
 354         unsigned char data[300];
 355         dst_context_t *ctx = NULL;
 356         int labels = 0;
 357         isc_uint32_t flags;
 358
 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);
 364
 365         ret = dns_rdata_tostruct(sigrdata, &sig, NULL);
 366         if (ret != ISC_R_SUCCESS)
 367                 return (ret);
 368
 369         if (isc_serial_lt(sig.timeexpire, sig.timesigned))
 370                 return (DNS_R_SIGINVALID);
 371
 372         if (!ignoretime) {
 373                 isc_stdtime_get(&now);
 374
 375                 /*
 376                  * Is SIG temporally valid?
 377                  */
 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);
 382         }
 383
 384         /*
 385          * Is the key allowed to sign data?
 386          */
 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);
 392
 393         ret = dst_context_create(key, mctx, &ctx);
 394         if (ret != ISC_R_SUCCESS)
 395                 goto cleanup_struct;
 396
 397         /*
 398          * Digest the SIG rdata (not including the signature).
 399          */
 400         ret = digest_sig(ctx, sigrdata, &sig);
 401         if (ret != ISC_R_SUCCESS)
 402                 goto cleanup_context;
 403
 404         /*
 405          * If the name is an expanded wildcard, use the wildcard name.
 406          */
 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));
 414
 415         dns_name_toregion(dns_fixedname_name(&fnewname), &r);
 416
 417         /*
 418          * Create an envelope for each rdata: <name|type|class|ttl>.
 419          */
 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);
 425         }
 426         else
 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);
 432
 433         ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
 434         if (ret != ISC_R_SUCCESS)
 435                 goto cleanup_context;
 436
 437         isc_buffer_usedregion(&envbuf, &r);
 438
 439         for (i = 0; i < nrdatas; i++) {
 440                 isc_uint16_t len;
 441                 isc_buffer_t lenbuf;
 442                 isc_region_t lenr;
 443
 444                 /*
 445                  * Skip duplicates.
 446                  */
 447                 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
 448                     continue;
 449
 450                 /*
 451                  * Digest the envelope.
 452                  */
 453                 ret = dst_context_adddata(ctx, &r);
 454                 if (ret != ISC_R_SUCCESS)
 455                         goto cleanup_array;
 456
 457                 /*
 458                  * Digest the rdata length.
 459                  */
 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);
 464
 465                 /*
 466                  * Digest the rdata.
 467                  */
 468                 ret = dst_context_adddata(ctx, &lenr);
 469                 if (ret != ISC_R_SUCCESS)
 470                         goto cleanup_array;
 471                 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
 472                 if (ret != ISC_R_SUCCESS)
 473                         goto cleanup_array;
 474         }
 475
 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;
 481
 482 cleanup_array:
 483         isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
 484 cleanup_context:
 485         dst_context_destroy(&ctx);
 486 cleanup_struct:
 487         dns_rdata_freestruct(&sig);
 488
 489         if (ret == ISC_R_SUCCESS && labels - sig.labels > 0) {
 490                 if (wild != NULL)
 491                         RUNTIME_CHECK(dns_name_concatenate(dns_wildcardname,
 492                                                  dns_fixedname_name(&fnewname),
 493                                                  wild, NULL) == ISC_R_SUCCESS);
 494                 ret = DNS_R_FROMWILDCARD;
 495         }
 496         return (ret);
 497 }
 498
 499 isc_result_t
 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)
 503 {
 504         isc_result_t result;
 505
 506         result = dns_dnssec_verify2(name, set, key, ignoretime, mctx,
 507                                     sigrdata, NULL);
 508         if (result == DNS_R_FROMWILDCARD)
 509                 result = ISC_R_SUCCESS;
 510         return (result);
 511 }
 512
 513 #define is_zone_key(key) ((dst_key_flags(key) & DNS_KEYFLAG_OWNERMASK) \
 514                           == DNS_KEYOWNER_ZONE)
 515
 516 isc_result_t
 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,
 521                          unsigned int *nkeys)
 522 {
 523         dns_rdataset_t rdataset;
 524         dns_rdata_t rdata = DNS_RDATA_INIT;
 525         isc_result_t result;
 526         dst_key_t *pubkey = NULL;
 527         unsigned int count = 0;
 528
 529         REQUIRE(nkeys != NULL);
 530         REQUIRE(keys != NULL);
 531
 532         *nkeys = 0;
 533         dns_rdataset_init(&rdataset);
 534         RETERR(dns_db_findrdataset(db, node, ver, dns_rdatatype_dnskey, 0, 0,
 535                                    &rdataset, NULL));
 536         RETERR(dns_rdataset_first(&rdataset));
 537         while (result == ISC_R_SUCCESS && count < maxkeys) {
 538                 pubkey = NULL;
 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)
 543                         goto next;
 544                 keys[count] = NULL;
 545                 result = dst_key_fromfile(dst_key_name(pubkey),
 546                                           dst_key_id(pubkey),
 547                                           dst_key_alg(pubkey),
 548                                           DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
 549                                           directory,
 550                                           mctx, &keys[count]);
 551                 if (result == ISC_R_FILENOTFOUND) {
 552                         keys[count] = pubkey;
 553                         pubkey = NULL;
 554                         count++;
 555                         goto next;
 556                 }
 557                 if (result != ISC_R_SUCCESS)
 558                         goto failure;
 559                 if ((dst_key_flags(keys[count]) & DNS_KEYTYPE_NOAUTH) != 0) {
 560                         /* We should never get here. */
 561                         dst_key_free(&keys[count]);
 562                         goto next;
 563                 }
 564                 count++;
 565  next:
 566                 if (pubkey != NULL)
 567                         dst_key_free(&pubkey);
 568                 dns_rdata_reset(&rdata);
 569                 result = dns_rdataset_next(&rdataset);
 570         }
 571         if (result != ISC_R_NOMORE)
 572                 goto failure;
 573         if (count == 0)
 574                 result = ISC_R_NOTFOUND;
 575         else
 576                 result = ISC_R_SUCCESS;
 577
 578  failure:
 579         if (dns_rdataset_isassociated(&rdataset))
 580                 dns_rdataset_disassociate(&rdataset);
 581         if (pubkey != NULL)
 582                 dst_key_free(&pubkey);
 583         if (result != ISC_R_SUCCESS)
 584                 while (count > 0)
 585                         dst_key_free(&keys[--count]);
 586         *nkeys = count;
 587         return (result);
 588 }
 589
 590 isc_result_t
 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,
 594                         unsigned int *nkeys)
 595 {
 596         return (dns_dnssec_findzonekeys2(db, ver, node, name, NULL, mctx,
 597                                          maxkeys, keys, nkeys));
 598 }
 599
 600 isc_result_t
 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;
 608         dns_rdata_t *rdata;
 609         dns_rdatalist_t *datalist;
 610         dns_rdataset_t *dataset;
 611         isc_region_t r;
 612         isc_stdtime_t now;
 613         dst_context_t *ctx = NULL;
 614         isc_mem_t *mctx;
 615         isc_result_t result;
 616         isc_boolean_t signeedsfree = ISC_TRUE;
 617
 618         REQUIRE(msg != NULL);
 619         REQUIRE(key != NULL);
 620
 621         if (is_response(msg))
 622                 REQUIRE(msg->query.base != NULL);
 623
 624         mctx = msg->mctx;
 625
 626         memset(&sig, 0, sizeof(sig));
 627
 628         sig.mctx = mctx;
 629         sig.common.rdclass = dns_rdataclass_any;
 630         sig.common.rdtype = dns_rdatatype_sig;  /* SIG(0) */
 631         ISC_LINK_INIT(&sig.common, link);
 632
 633         sig.covered = 0;
 634         sig.algorithm = dst_key_alg(key);
 635         sig.labels = 0; /* the root name */
 636         sig.originalttl = 0;
 637
 638         isc_stdtime_get(&now);
 639         sig.timesigned = now - DNS_TSIG_FUDGE;
 640         sig.timeexpire = now + DNS_TSIG_FUDGE;
 641
 642         sig.keyid = dst_key_id(key);
 643
 644         dns_name_init(&sig.signer, NULL);
 645         dns_name_clone(dst_key_name(key), &sig.signer);
 646
 647         sig.siglen = 0;
 648         sig.signature = NULL;
 649
 650         isc_buffer_init(&databuf, data, sizeof(data));
 651
 652         RETERR(dst_context_create(key, mctx, &ctx));
 653
 654         /*
 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.
 658          */
 659         RETERR(dns_rdata_fromstruct(NULL, dns_rdataclass_any,
 660                                     dns_rdatatype_sig /* SIG(0) */,
 661                                     &sig, &databuf));
 662         isc_buffer_usedregion(&databuf, &r);
 663         RETERR(dst_context_adddata(ctx, &r));
 664
 665         /*
 666          * If this is a response, digest the query.
 667          */
 668         if (is_response(msg))
 669                 RETERR(dst_context_adddata(ctx, &msg->query));
 670
 671         /*
 672          * Digest the header.
 673          */
 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));
 678
 679         /*
 680          * Digest the remainder of the message.
 681          */
 682         isc_buffer_usedregion(msg->buffer, &r);
 683         isc_region_consume(&r, DNS_MESSAGE_HEADERLEN);
 684         RETERR(dst_context_adddata(ctx, &r));
 685
 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;
 691                 goto failure;
 692         }
 693
 694         isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
 695         RETERR(dst_context_sign(ctx, &sigbuf));
 696         dst_context_destroy(&ctx);
 697
 698         rdata = NULL;
 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) */,
 703                                     &sig, dynbuf));
 704
 705         isc_mem_put(mctx, sig.signature, sig.siglen);
 706         signeedsfree = ISC_FALSE;
 707
 708         dns_message_takebuffer(msg, &dynbuf);
 709
 710         datalist = NULL;
 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;
 715         datalist->ttl = 0;
 716         ISC_LIST_INIT(datalist->rdata);
 717         ISC_LIST_APPEND(datalist->rdata, rdata, link);
 718         dataset = NULL;
 719         RETERR(dns_message_gettemprdataset(msg, &dataset));
 720         dns_rdataset_init(dataset);
 721         RUNTIME_CHECK(dns_rdatalist_tordataset(datalist, dataset) == ISC_R_SUCCESS);
 722         msg->sig0 = dataset;
 723
 724         return (ISC_R_SUCCESS);
 725
 726 failure:
 727         if (dynbuf != NULL)
 728                 isc_buffer_free(&dynbuf);
 729         if (signeedsfree)
 730                 isc_mem_put(mctx, sig.signature, sig.siglen);
 731         if (ctx != NULL)
 732                 dst_context_destroy(&ctx);
 733
 734         return (result);
 735 }
 736
 737 isc_result_t
 738 dns_dnssec_verifymessage(isc_buffer_t *source, dns_message_t *msg,
 739                          dst_key_t *key)
 740 {
 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;
 745         isc_stdtime_t now;
 746         dst_context_t *ctx = NULL;
 747         isc_mem_t *mctx;
 748         isc_result_t result;
 749         isc_uint16_t addcount;
 750         isc_boolean_t signeedsfree = ISC_FALSE;
 751
 752         REQUIRE(source != NULL);
 753         REQUIRE(msg != NULL);
 754         REQUIRE(key != NULL);
 755
 756         mctx = msg->mctx;
 757
 758         msg->verify_attempted = 1;
 759
 760         if (is_response(msg)) {
 761                 if (msg->query.base == NULL)
 762                         return (DNS_R_UNEXPECTEDTSIG);
 763         }
 764
 765         isc_buffer_usedregion(source, &source_r);
 766
 767         RETERR(dns_rdataset_first(msg->sig0));
 768         dns_rdataset_current(msg->sig0, &rdata);
 769
 770         RETERR(dns_rdata_tostruct(&rdata, &sig, NULL));
 771         signeedsfree = ISC_TRUE;
 772
 773         if (sig.labels != 0) {
 774                 result = DNS_R_SIGINVALID;
 775                 goto failure;
 776         }
 777
 778         if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
 779                 result = DNS_R_SIGINVALID;
 780                 msg->sig0status = dns_tsigerror_badtime;
 781                 goto failure;
 782         }
 783
 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;
 788                 goto failure;
 789         }
 790         else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
 791                 result = DNS_R_SIGEXPIRED;
 792                 msg->sig0status = dns_tsigerror_badtime;
 793                 goto failure;
 794         }
 795
 796         if (!dns_name_equal(dst_key_name(key), &sig.signer)) {
 797                 result = DNS_R_SIGINVALID;
 798                 msg->sig0status = dns_tsigerror_badkey;
 799                 goto failure;
 800         }
 801
 802         RETERR(dst_context_create(key, mctx, &ctx));
 803
 804         /*
 805          * Digest the SIG(0) record, except for the signature.
 806          */
 807         dns_rdata_toregion(&rdata, &r);
 808         r.length -= sig.siglen;
 809         RETERR(dst_context_adddata(ctx, &r));
 810
 811         /*
 812          * If this is a response, digest the query.
 813          */
 814         if (is_response(msg))
 815                 RETERR(dst_context_adddata(ctx, &msg->query));
 816
 817         /*
 818          * Extract the header.
 819          */
 820         memcpy(header, source_r.base, DNS_MESSAGE_HEADERLEN);
 821
 822         /*
 823          * Decrement the additional field counter.
 824          */
 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);
 828
 829         /*
 830          * Digest the modified header.
 831          */
 832         header_r.base = (unsigned char *) header;
 833         header_r.length = DNS_MESSAGE_HEADERLEN;
 834         RETERR(dst_context_adddata(ctx, &header_r));
 835
 836         /*
 837          * Digest all non-SIG(0) records.
 838          */
 839         r.base = source_r.base + DNS_MESSAGE_HEADERLEN;
 840         r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN;
 841         RETERR(dst_context_adddata(ctx, &r));
 842
 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;
 848                 goto failure;
 849         }
 850
 851         msg->verified_sig = 1;
 852
 853         dst_context_destroy(&ctx);
 854         dns_rdata_freestruct(&sig);
 855
 856         return (ISC_R_SUCCESS);
 857
 858 failure:
 859         if (signeedsfree)
 860                 dns_rdata_freestruct(&sig);
 861         if (ctx != NULL)
 862                 dst_context_destroy(&ctx);
 863
 864         return (result);
 865 }