external/bsd/bind/dist/lib/dns/rdata/generic/ds_43.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2004, 2005, 2007, 2009  Internet Systems Consortium, Inc. ("ISC")
   5  * Copyright (C) 2002  Internet Software Consortium.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /* Id: ds_43.c,v 1.14 2009/12/04 22:06:37 tbox Exp */
  21
  22 /* draft-ietf-dnsext-delegation-signer-05.txt */
  23
  24 #ifndef RDATA_GENERIC_DS_43_C
  25 #define RDATA_GENERIC_DS_43_C
  26
  27 #define RRTYPE_DS_ATTRIBUTES \
  28         (DNS_RDATATYPEATTR_DNSSEC|DNS_RDATATYPEATTR_ATPARENT)
  29
  30 #include <isc/sha1.h>
  31 #include <isc/sha2.h>
  32
  33 #include <dns/ds.h>
  34
  35 static inline isc_result_t
  36 fromtext_ds(ARGS_FROMTEXT) {
  37         isc_token_t token;
  38         unsigned char c;
  39         int length;
  40
  41         REQUIRE(type == 43);
  42
  43         UNUSED(type);
  44         UNUSED(rdclass);
  45         UNUSED(origin);
  46         UNUSED(options);
  47         UNUSED(callbacks);
  48
  49         /*
  50          * Key tag.
  51          */
  52         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
  53                                       ISC_FALSE));
  54         if (token.value.as_ulong > 0xffffU)
  55                 RETTOK(ISC_R_RANGE);
  56         RETERR(uint16_tobuffer(token.value.as_ulong, target));
  57
  58         /*
  59          * Algorithm.
  60          */
  61         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  62                                       ISC_FALSE));
  63         RETTOK(dns_secalg_fromtext(&c, &token.value.as_textregion));
  64         RETERR(mem_tobuffer(target, &c, 1));
  65
  66         /*
  67          * Digest type.
  68          */
  69         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
  70                                       ISC_FALSE));
  71         if (token.value.as_ulong > 0xffU)
  72                 RETTOK(ISC_R_RANGE);
  73         RETERR(uint8_tobuffer(token.value.as_ulong, target));
  74         c = (unsigned char) token.value.as_ulong;
  75
  76         /*
  77          * Digest.
  78          */
  79         if (c == DNS_DSDIGEST_SHA1)
  80                 length = ISC_SHA1_DIGESTLENGTH;
  81         else if (c == DNS_DSDIGEST_SHA256)
  82                 length = ISC_SHA256_DIGESTLENGTH;
  83         else
  84                 length = -1;
  85         return (isc_hex_tobuffer(lexer, target, length));
  86 }
  87
  88 static inline isc_result_t
  89 totext_ds(ARGS_TOTEXT) {
  90         isc_region_t sr;
  91         char buf[sizeof("64000 ")];
  92         unsigned int n;
  93
  94         REQUIRE(rdata->type == 43);
  95         REQUIRE(rdata->length != 0);
  96
  97         UNUSED(tctx);
  98
  99         dns_rdata_toregion(rdata, &sr);
 100
 101         /*
 102          * Key tag.
 103          */
 104         n = uint16_fromregion(&sr);
 105         isc_region_consume(&sr, 2);
 106         sprintf(buf, "%u ", n);
 107         RETERR(str_totext(buf, target));
 108
 109         /*
 110          * Algorithm.
 111          */
 112         n = uint8_fromregion(&sr);
 113         isc_region_consume(&sr, 1);
 114         sprintf(buf, "%u ", n);
 115         RETERR(str_totext(buf, target));
 116
 117         /*
 118          * Digest type.
 119          */
 120         n = uint8_fromregion(&sr);
 121         isc_region_consume(&sr, 1);
 122         sprintf(buf, "%u", n);
 123         RETERR(str_totext(buf, target));
 124
 125         /*
 126          * Digest.
 127          */
 128         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 129                 RETERR(str_totext(" (", target));
 130         RETERR(str_totext(tctx->linebreak, target));
 131         RETERR(isc_hex_totext(&sr, tctx->width - 2, tctx->linebreak, target));
 132         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 133                 RETERR(str_totext(" )", target));
 134         return (ISC_R_SUCCESS);
 135 }
 136
 137 static inline isc_result_t
 138 fromwire_ds(ARGS_FROMWIRE) {
 139         isc_region_t sr;
 140
 141         REQUIRE(type == 43);
 142
 143         UNUSED(type);
 144         UNUSED(rdclass);
 145         UNUSED(dctx);
 146         UNUSED(options);
 147
 148         isc_buffer_activeregion(source, &sr);
 149
 150         /*
 151          * Check digest lengths if we know them.
 152          */
 153         if (sr.length < 4 ||
 154             (sr.base[3] == DNS_DSDIGEST_SHA1 &&
 155              sr.length < 4 + ISC_SHA1_DIGESTLENGTH) ||
 156             (sr.base[3] == DNS_DSDIGEST_SHA256 &&
 157              sr.length < 4 + ISC_SHA256_DIGESTLENGTH))
 158                 return (ISC_R_UNEXPECTEDEND);
 159
 160         /*
 161          * Only copy digest lengths if we know them.
 162          * If there is extra data dns_rdata_fromwire() will
 163          * detect that.
 164          */
 165         if (sr.base[3] == DNS_DSDIGEST_SHA1)
 166                 sr.length = 4 + ISC_SHA1_DIGESTLENGTH;
 167         else if (sr.base[3] == DNS_DSDIGEST_SHA256)
 168                 sr.length = 4 + ISC_SHA256_DIGESTLENGTH;
 169
 170         isc_buffer_forward(source, sr.length);
 171         return (mem_tobuffer(target, sr.base, sr.length));
 172 }
 173
 174 static inline isc_result_t
 175 towire_ds(ARGS_TOWIRE) {
 176         isc_region_t sr;
 177
 178         REQUIRE(rdata->type == 43);
 179         REQUIRE(rdata->length != 0);
 180
 181         UNUSED(cctx);
 182
 183         dns_rdata_toregion(rdata, &sr);
 184         return (mem_tobuffer(target, sr.base, sr.length));
 185 }
 186
 187 static inline int
 188 compare_ds(ARGS_COMPARE) {
 189         isc_region_t r1;
 190         isc_region_t r2;
 191
 192         REQUIRE(rdata1->type == rdata2->type);
 193         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 194         REQUIRE(rdata1->type == 43);
 195         REQUIRE(rdata1->length != 0);
 196         REQUIRE(rdata2->length != 0);
 197
 198         dns_rdata_toregion(rdata1, &r1);
 199         dns_rdata_toregion(rdata2, &r2);
 200         return (isc_region_compare(&r1, &r2));
 201 }
 202
 203 static inline isc_result_t
 204 fromstruct_ds(ARGS_FROMSTRUCT) {
 205         dns_rdata_ds_t *ds = source;
 206
 207         REQUIRE(type == 43);
 208         REQUIRE(source != NULL);
 209         REQUIRE(ds->common.rdtype == type);
 210         REQUIRE(ds->common.rdclass == rdclass);
 211         switch (ds->digest_type) {
 212         case DNS_DSDIGEST_SHA1:
 213                 REQUIRE(ds->length == ISC_SHA1_DIGESTLENGTH);
 214                 break;
 215         case DNS_DSDIGEST_SHA256:
 216                 REQUIRE(ds->length == ISC_SHA256_DIGESTLENGTH);
 217                 break;
 218         }
 219
 220         UNUSED(type);
 221         UNUSED(rdclass);
 222
 223         RETERR(uint16_tobuffer(ds->key_tag, target));
 224         RETERR(uint8_tobuffer(ds->algorithm, target));
 225         RETERR(uint8_tobuffer(ds->digest_type, target));
 226
 227         return (mem_tobuffer(target, ds->digest, ds->length));
 228 }
 229
 230 static inline isc_result_t
 231 tostruct_ds(ARGS_TOSTRUCT) {
 232         dns_rdata_ds_t *ds = target;
 233         isc_region_t region;
 234
 235         REQUIRE(rdata->type == 43);
 236         REQUIRE(target != NULL);
 237         REQUIRE(rdata->length != 0);
 238
 239         ds->common.rdclass = rdata->rdclass;
 240         ds->common.rdtype = rdata->type;
 241         ISC_LINK_INIT(&ds->common, link);
 242
 243         dns_rdata_toregion(rdata, &region);
 244
 245         ds->key_tag = uint16_fromregion(&region);
 246         isc_region_consume(&region, 2);
 247         ds->algorithm = uint8_fromregion(&region);
 248         isc_region_consume(&region, 1);
 249         ds->digest_type = uint8_fromregion(&region);
 250         isc_region_consume(&region, 1);
 251         ds->length = region.length;
 252
 253         ds->digest = mem_maybedup(mctx, region.base, region.length);
 254         if (ds->digest == NULL)
 255                 return (ISC_R_NOMEMORY);
 256
 257         ds->mctx = mctx;
 258         return (ISC_R_SUCCESS);
 259 }
 260
 261 static inline void
 262 freestruct_ds(ARGS_FREESTRUCT) {
 263         dns_rdata_ds_t *ds = source;
 264
 265         REQUIRE(ds != NULL);
 266         REQUIRE(ds->common.rdtype == 43);
 267
 268         if (ds->mctx == NULL)
 269                 return;
 270
 271         if (ds->digest != NULL)
 272                 isc_mem_free(ds->mctx, ds->digest);
 273         ds->mctx = NULL;
 274 }
 275
 276 static inline isc_result_t
 277 additionaldata_ds(ARGS_ADDLDATA) {
 278         REQUIRE(rdata->type == 43);
 279
 280         UNUSED(rdata);
 281         UNUSED(add);
 282         UNUSED(arg);
 283
 284         return (ISC_R_SUCCESS);
 285 }
 286
 287 static inline isc_result_t
 288 digest_ds(ARGS_DIGEST) {
 289         isc_region_t r;
 290
 291         REQUIRE(rdata->type == 43);
 292
 293         dns_rdata_toregion(rdata, &r);
 294
 295         return ((digest)(arg, &r));
 296 }
 297
 298 static inline isc_boolean_t
 299 checkowner_ds(ARGS_CHECKOWNER) {
 300
 301         REQUIRE(type == 43);
 302
 303         UNUSED(name);
 304         UNUSED(type);
 305         UNUSED(rdclass);
 306         UNUSED(wildcard);
 307
 308         return (ISC_TRUE);
 309 }
 310
 311 static inline isc_boolean_t
 312 checknames_ds(ARGS_CHECKNAMES) {
 313
 314         REQUIRE(rdata->type == 43);
 315
 316         UNUSED(rdata);
 317         UNUSED(owner);
 318         UNUSED(bad);
 319
 320         return (ISC_TRUE);
 321 }
 322
 323 static inline int
 324 casecompare_ds(ARGS_COMPARE) {
 325         return (compare_ds(rdata1, rdata2));
 326 }
 327
 328 #endif  /* RDATA_GENERIC_DS_43_C */