contrib/bind-9.3/lib/dns/dnssec.c

   1 /*
   2  * Copyright (C) 2004, 2006  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and 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.9 2006/01/04 23:50:20 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         if (labels - sig.labels > 0) {
 409                 dns_name_split(name, sig.labels + 1, NULL,
 410                                dns_fixedname_name(&fnewname));
 411                 RUNTIME_CHECK(dns_name_downcase(dns_fixedname_name(&fnewname),
 412                                                 dns_fixedname_name(&fnewname),
 413                                                 NULL)
 414                               == ISC_R_SUCCESS);
 415         }
 416         else
 417                 dns_name_downcase(name, dns_fixedname_name(&fnewname), NULL);
 418
 419         dns_name_toregion(dns_fixedname_name(&fnewname), &r);
 420
 421         /*
 422          * Create an envelope for each rdata: <name|type|class|ttl>.
 423          */
 424         isc_buffer_init(&envbuf, data, sizeof(data));
 425         if (labels - sig.labels > 0) {
 426                 isc_buffer_putuint8(&envbuf, 1);
 427                 isc_buffer_putuint8(&envbuf, '*');
 428                 memcpy(data + 2, r.base, r.length);
 429         }
 430         else
 431                 memcpy(data, r.base, r.length);
 432         isc_buffer_add(&envbuf, r.length);
 433         isc_buffer_putuint16(&envbuf, set->type);
 434         isc_buffer_putuint16(&envbuf, set->rdclass);
 435         isc_buffer_putuint32(&envbuf, sig.originalttl);
 436
 437         ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
 438         if (ret != ISC_R_SUCCESS)
 439                 goto cleanup_context;
 440
 441         isc_buffer_usedregion(&envbuf, &r);
 442
 443         for (i = 0; i < nrdatas; i++) {
 444                 isc_uint16_t len;
 445                 isc_buffer_t lenbuf;
 446                 isc_region_t lenr;
 447
 448                 /*
 449                  * Skip duplicates.
 450                  */
 451                 if (i > 0 && dns_rdata_compare(&rdatas[i], &rdatas[i-1]) == 0)
 452                     continue;
 453
 454                 /*
 455                  * Digest the envelope.
 456                  */
 457                 ret = dst_context_adddata(ctx, &r);
 458                 if (ret != ISC_R_SUCCESS)
 459                         goto cleanup_array;
 460
 461                 /*
 462                  * Digest the rdata length.
 463                  */
 464                 isc_buffer_init(&lenbuf, &len, sizeof(len));
 465                 INSIST(rdatas[i].length < 65536);
 466                 isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
 467                 isc_buffer_usedregion(&lenbuf, &lenr);
 468
 469                 /*
 470                  * Digest the rdata.
 471                  */
 472                 ret = dst_context_adddata(ctx, &lenr);
 473                 if (ret != ISC_R_SUCCESS)
 474                         goto cleanup_array;
 475                 ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
 476                 if (ret != ISC_R_SUCCESS)
 477                         goto cleanup_array;
 478         }
 479
 480         r.base = sig.signature;
 481         r.length = sig.siglen;
 482         ret = dst_context_verify(ctx, &r);
 483         if (ret == DST_R_VERIFYFAILURE)
 484                 ret = DNS_R_SIGINVALID;
 485
 486 cleanup_array:
 487         isc_mem_put(mctx, rdatas, nrdatas * sizeof(dns_rdata_t));
 488 cleanup_context:
 489         dst_context_destroy(&ctx);
 490 cleanup_struct:
 491         dns_rdata_freestruct(&sig);
 492
 493         if (ret == ISC_R_SUCCESS && labels - sig.labels > 0) {
 494                 if (wild != NULL)
 495                         RUNTIME_CHECK(dns_name_concatenate(dns_wildcardname,
 496                                                  dns_fixedname_name(&fnewname),
 497                                                  wild, NULL) == ISC_R_SUCCESS);
 498                 ret = DNS_R_FROMWILDCARD;
 499         }
 500         return (ret);
 501 }
 502
 503 isc_result_t
 504 dns_dnssec_verify(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 505                   isc_boolean_t ignoretime, isc_mem_t *mctx,
 506                   dns_rdata_t *sigrdata)
 507 {
 508         isc_result_t result;
 509
 510         result = dns_dnssec_verify2(name, set, key, ignoretime, mctx,
 511                                     sigrdata, NULL);
 512         if (result == DNS_R_FROMWILDCARD)
 513                 result = ISC_R_SUCCESS;
 514         return (result);
 515 }
 516
 517 #define is_zone_key(key) ((dst_key_flags(key) & DNS_KEYFLAG_OWNERMASK) \
 518                           == DNS_KEYOWNER_ZONE)
 519
 520 isc_result_t
 521 dns_dnssec_findzonekeys2(dns_db_t *db, dns_dbversion_t *ver,
 522                         dns_dbnode_t *node, dns_name_t *name,
 523                         const char *directory, isc_mem_t *mctx,
 524                         unsigned int maxkeys, dst_key_t **keys,
 525                         unsigned int *nkeys)
 526 {
 527         dns_rdataset_t rdataset;
 528         dns_rdata_t rdata = DNS_RDATA_INIT;
 529         isc_result_t result;
 530         dst_key_t *pubkey = NULL;
 531         unsigned int count = 0;
 532
 533         *nkeys = 0;
 534         dns_rdataset_init(&rdataset);
 535         RETERR(dns_db_findrdataset(db, node, ver, dns_rdatatype_dnskey, 0, 0,
 536                                    &rdataset, NULL));
 537         RETERR(dns_rdataset_first(&rdataset));
 538         while (result == ISC_R_SUCCESS && count < maxkeys) {
 539                 pubkey = NULL;
 540                 dns_rdataset_current(&rdataset, &rdata);
 541                 RETERR(dns_dnssec_keyfromrdata(name, &rdata, mctx, &pubkey));
 542                 if (!is_zone_key(pubkey))
 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                         goto next;
 553                 if (result != ISC_R_SUCCESS)
 554                         goto failure;
 555                 if ((dst_key_flags(keys[count]) & DNS_KEYTYPE_NOAUTH) != 0) {
 556                         dst_key_free(&keys[count]);
 557                         goto next;
 558                 }
 559                 count++;
 560  next:
 561                 dst_key_free(&pubkey);
 562                 dns_rdata_reset(&rdata);
 563                 result = dns_rdataset_next(&rdataset);
 564         }
 565         if (result != ISC_R_NOMORE)
 566                 goto failure;
 567         if (count == 0)
 568                 result = ISC_R_NOTFOUND;
 569         else
 570                 result = ISC_R_SUCCESS;
 571
 572  failure:
 573         if (dns_rdataset_isassociated(&rdataset))
 574                 dns_rdataset_disassociate(&rdataset);
 575         if (pubkey != NULL)
 576                 dst_key_free(&pubkey);
 577         *nkeys = count;
 578         return (result);
 579 }
 580
 581 isc_result_t
 582 dns_dnssec_findzonekeys(dns_db_t *db, dns_dbversion_t *ver,
 583                         dns_dbnode_t *node, dns_name_t *name, isc_mem_t *mctx,
 584                         unsigned int maxkeys, dst_key_t **keys,
 585                         unsigned int *nkeys)
 586 {
 587         return (dns_dnssec_findzonekeys2(db, ver, node, name, NULL, mctx,
 588                                          maxkeys, keys, nkeys));
 589 }
 590
 591 isc_result_t
 592 dns_dnssec_signmessage(dns_message_t *msg, dst_key_t *key) {
 593         dns_rdata_sig_t sig;    /* SIG(0) */
 594         unsigned char data[512];
 595         unsigned char header[DNS_MESSAGE_HEADERLEN];
 596         isc_buffer_t headerbuf, databuf, sigbuf;
 597         unsigned int sigsize;
 598         isc_buffer_t *dynbuf = NULL;
 599         dns_rdata_t *rdata;
 600         dns_rdatalist_t *datalist;
 601         dns_rdataset_t *dataset;
 602         isc_region_t r;
 603         isc_stdtime_t now;
 604         dst_context_t *ctx = NULL;
 605         isc_mem_t *mctx;
 606         isc_result_t result;
 607         isc_boolean_t signeedsfree = ISC_TRUE;
 608
 609         REQUIRE(msg != NULL);
 610         REQUIRE(key != NULL);
 611
 612         if (is_response(msg))
 613                 REQUIRE(msg->query.base != NULL);
 614
 615         mctx = msg->mctx;
 616
 617         memset(&sig, 0, sizeof(sig));
 618
 619         sig.mctx = mctx;
 620         sig.common.rdclass = dns_rdataclass_any;
 621         sig.common.rdtype = dns_rdatatype_sig;  /* SIG(0) */
 622         ISC_LINK_INIT(&sig.common, link);
 623
 624         sig.covered = 0;
 625         sig.algorithm = dst_key_alg(key);
 626         sig.labels = 0; /* the root name */
 627         sig.originalttl = 0;
 628
 629         isc_stdtime_get(&now);
 630         sig.timesigned = now - DNS_TSIG_FUDGE;
 631         sig.timeexpire = now + DNS_TSIG_FUDGE;
 632
 633         sig.keyid = dst_key_id(key);
 634
 635         dns_name_init(&sig.signer, NULL);
 636         dns_name_clone(dst_key_name(key), &sig.signer);
 637
 638         sig.siglen = 0;
 639         sig.signature = NULL;
 640
 641         isc_buffer_init(&databuf, data, sizeof(data));
 642
 643         RETERR(dst_context_create(key, mctx, &ctx));
 644
 645         /*
 646          * Digest the fields of the SIG - we can cheat and use
 647          * dns_rdata_fromstruct.  Since siglen is 0, the digested data
 648          * is identical to dns format.
 649          */
 650         RETERR(dns_rdata_fromstruct(NULL, dns_rdataclass_any,
 651                                     dns_rdatatype_sig /* SIG(0) */,
 652                                     &sig, &databuf));
 653         isc_buffer_usedregion(&databuf, &r);
 654         RETERR(dst_context_adddata(ctx, &r));
 655
 656         /*
 657          * If this is a response, digest the query.
 658          */
 659         if (is_response(msg))
 660                 RETERR(dst_context_adddata(ctx, &msg->query));
 661
 662         /*
 663          * Digest the header.
 664          */
 665         isc_buffer_init(&headerbuf, header, sizeof(header));
 666         dns_message_renderheader(msg, &headerbuf);
 667         isc_buffer_usedregion(&headerbuf, &r);
 668         RETERR(dst_context_adddata(ctx, &r));
 669
 670         /*
 671          * Digest the remainder of the message.
 672          */
 673         isc_buffer_usedregion(msg->buffer, &r);
 674         isc_region_consume(&r, DNS_MESSAGE_HEADERLEN);
 675         RETERR(dst_context_adddata(ctx, &r));
 676
 677         RETERR(dst_key_sigsize(key, &sigsize));
 678         sig.siglen = sigsize;
 679         sig.signature = (unsigned char *) isc_mem_get(mctx, sig.siglen);
 680         if (sig.signature == NULL) {
 681                 result = ISC_R_NOMEMORY;
 682                 goto failure;
 683         }
 684
 685         isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
 686         RETERR(dst_context_sign(ctx, &sigbuf));
 687         dst_context_destroy(&ctx);
 688
 689         rdata = NULL;
 690         RETERR(dns_message_gettemprdata(msg, &rdata));
 691         RETERR(isc_buffer_allocate(msg->mctx, &dynbuf, 1024));
 692         RETERR(dns_rdata_fromstruct(rdata, dns_rdataclass_any,
 693                                     dns_rdatatype_sig /* SIG(0) */,
 694                                     &sig, dynbuf));
 695
 696         isc_mem_put(mctx, sig.signature, sig.siglen);
 697         signeedsfree = ISC_FALSE;
 698
 699         dns_message_takebuffer(msg, &dynbuf);
 700
 701         datalist = NULL;
 702         RETERR(dns_message_gettemprdatalist(msg, &datalist));
 703         datalist->rdclass = dns_rdataclass_any;
 704         datalist->type = dns_rdatatype_sig;     /* SIG(0) */
 705         datalist->covers = 0;
 706         datalist->ttl = 0;
 707         ISC_LIST_INIT(datalist->rdata);
 708         ISC_LIST_APPEND(datalist->rdata, rdata, link);
 709         dataset = NULL;
 710         RETERR(dns_message_gettemprdataset(msg, &dataset));
 711         dns_rdataset_init(dataset);
 712         RUNTIME_CHECK(dns_rdatalist_tordataset(datalist, dataset) == ISC_R_SUCCESS);
 713         msg->sig0 = dataset;
 714
 715         return (ISC_R_SUCCESS);
 716
 717 failure:
 718         if (dynbuf != NULL)
 719                 isc_buffer_free(&dynbuf);
 720         if (signeedsfree)
 721                 isc_mem_put(mctx, sig.signature, sig.siglen);
 722         if (ctx != NULL)
 723                 dst_context_destroy(&ctx);
 724
 725         return (result);
 726 }
 727
 728 isc_result_t
 729 dns_dnssec_verifymessage(isc_buffer_t *source, dns_message_t *msg,
 730                          dst_key_t *key)
 731 {
 732         dns_rdata_sig_t sig;    /* SIG(0) */
 733         unsigned char header[DNS_MESSAGE_HEADERLEN];
 734         dns_rdata_t rdata = DNS_RDATA_INIT;
 735         isc_region_t r, source_r, sig_r, header_r;
 736         isc_stdtime_t now;
 737         dst_context_t *ctx = NULL;
 738         isc_mem_t *mctx;
 739         isc_result_t result;
 740         isc_uint16_t addcount;
 741         isc_boolean_t signeedsfree = ISC_FALSE;
 742
 743         REQUIRE(source != NULL);
 744         REQUIRE(msg != NULL);
 745         REQUIRE(key != NULL);
 746
 747         mctx = msg->mctx;
 748
 749         msg->verify_attempted = 1;
 750
 751         if (is_response(msg)) {
 752                 if (msg->query.base == NULL)
 753                         return (DNS_R_UNEXPECTEDTSIG);
 754         }
 755
 756         isc_buffer_usedregion(source, &source_r);
 757
 758         RETERR(dns_rdataset_first(msg->sig0));
 759         dns_rdataset_current(msg->sig0, &rdata);
 760
 761         RETERR(dns_rdata_tostruct(&rdata, &sig, NULL));
 762         signeedsfree = ISC_TRUE;
 763
 764         if (sig.labels != 0) {
 765                 result = DNS_R_SIGINVALID;
 766                 goto failure;
 767         }
 768
 769         if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
 770                 result = DNS_R_SIGINVALID;
 771                 msg->sig0status = dns_tsigerror_badtime;
 772                 goto failure;
 773         }
 774
 775         isc_stdtime_get(&now);
 776         if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
 777                 result = DNS_R_SIGFUTURE;
 778                 msg->sig0status = dns_tsigerror_badtime;
 779                 goto failure;
 780         }
 781         else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
 782                 result = DNS_R_SIGEXPIRED;
 783                 msg->sig0status = dns_tsigerror_badtime;
 784                 goto failure;
 785         }
 786
 787         if (!dns_name_equal(dst_key_name(key), &sig.signer)) {
 788                 result = DNS_R_SIGINVALID;
 789                 msg->sig0status = dns_tsigerror_badkey;
 790                 goto failure;
 791         }
 792
 793         RETERR(dst_context_create(key, mctx, &ctx));
 794
 795         /*
 796          * Digest the SIG(0) record, except for the signature.
 797          */
 798         dns_rdata_toregion(&rdata, &r);
 799         r.length -= sig.siglen;
 800         RETERR(dst_context_adddata(ctx, &r));
 801
 802         /*
 803          * If this is a response, digest the query.
 804          */
 805         if (is_response(msg))
 806                 RETERR(dst_context_adddata(ctx, &msg->query));
 807
 808         /*
 809          * Extract the header.
 810          */
 811         memcpy(header, source_r.base, DNS_MESSAGE_HEADERLEN);
 812
 813         /*
 814          * Decrement the additional field counter.
 815          */
 816         memcpy(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
 817         addcount = htons((isc_uint16_t)(ntohs(addcount) - 1));
 818         memcpy(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
 819
 820         /*
 821          * Digest the modified header.
 822          */
 823         header_r.base = (unsigned char *) header;
 824         header_r.length = DNS_MESSAGE_HEADERLEN;
 825         RETERR(dst_context_adddata(ctx, &header_r));
 826
 827         /*
 828          * Digest all non-SIG(0) records.
 829          */
 830         r.base = source_r.base + DNS_MESSAGE_HEADERLEN;
 831         r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN;
 832         RETERR(dst_context_adddata(ctx, &r));
 833
 834         sig_r.base = sig.signature;
 835         sig_r.length = sig.siglen;
 836         result = dst_context_verify(ctx, &sig_r);
 837         if (result != ISC_R_SUCCESS) {
 838                 msg->sig0status = dns_tsigerror_badsig;
 839                 goto failure;
 840         }
 841
 842         msg->verified_sig = 1;
 843
 844         dst_context_destroy(&ctx);
 845         dns_rdata_freestruct(&sig);
 846
 847         return (ISC_R_SUCCESS);
 848
 849 failure:
 850         if (signeedsfree)
 851                 dns_rdata_freestruct(&sig);
 852         if (ctx != NULL)
 853                 dst_context_destroy(&ctx);
 854
 855         return (result);
 856 }