contrib/bind9/lib/dns/dnssec.c

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