contrib/bind9/lib/dns/dst_parse.c

   1 /*
   2  * Portions Copyright (C) 2004-2012  Internet Systems Consortium, Inc. ("ISC")
   3  * Portions Copyright (C) 1999-2002  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 AND NETWORK ASSOCIATES DISCLAIMS
  10  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
  12  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  15  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  * Portions Copyright (C) 1995-2000 by Network Associates, Inc.
  18  *
  19  * Permission to use, copy, modify, and/or distribute this software for any
  20  * purpose with or without fee is hereby granted, provided that the above
  21  * copyright notice and this permission notice appear in all copies.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
  24  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  25  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
  26  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  27  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  28  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  29  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  30  */
  31
  32 /*%
  33  * Principal Author: Brian Wellington
  34  * $Id$
  35  */
  36
  37 #include <config.h>
  38
  39 #include <isc/base64.h>
  40 #include <isc/dir.h>
  41 #include <isc/fsaccess.h>
  42 #include <isc/lex.h>
  43 #include <isc/mem.h>
  44 #include <isc/string.h>
  45 #include <isc/util.h>
  46
  47 #include "dst_internal.h"
  48 #include "dst_parse.h"
  49 #include "dst/result.h"
  50
  51 #define DST_AS_STR(t) ((t).value.as_textregion.base)
  52
  53 #define PRIVATE_KEY_STR "Private-key-format:"
  54 #define ALGORITHM_STR "Algorithm:"
  55
  56 struct parse_map {
  57         const int value;
  58         const char *tag;
  59 };
  60
  61 static struct parse_map map[] = {
  62         {TAG_RSA_MODULUS, "Modulus:"},
  63         {TAG_RSA_PUBLICEXPONENT, "PublicExponent:"},
  64         {TAG_RSA_PRIVATEEXPONENT, "PrivateExponent:"},
  65         {TAG_RSA_PRIME1, "Prime1:"},
  66         {TAG_RSA_PRIME2, "Prime2:"},
  67         {TAG_RSA_EXPONENT1, "Exponent1:"},
  68         {TAG_RSA_EXPONENT2, "Exponent2:"},
  69         {TAG_RSA_COEFFICIENT, "Coefficient:"},
  70         {TAG_RSA_ENGINE, "Engine:" },
  71         {TAG_RSA_LABEL, "Label:" },
  72         {TAG_RSA_PIN, "PIN:" },
  73
  74         {TAG_DH_PRIME, "Prime(p):"},
  75         {TAG_DH_GENERATOR, "Generator(g):"},
  76         {TAG_DH_PRIVATE, "Private_value(x):"},
  77         {TAG_DH_PUBLIC, "Public_value(y):"},
  78
  79         {TAG_DSA_PRIME, "Prime(p):"},
  80         {TAG_DSA_SUBPRIME, "Subprime(q):"},
  81         {TAG_DSA_BASE, "Base(g):"},
  82         {TAG_DSA_PRIVATE, "Private_value(x):"},
  83         {TAG_DSA_PUBLIC, "Public_value(y):"},
  84
  85         {TAG_HMACMD5_KEY, "Key:"},
  86         {TAG_HMACMD5_BITS, "Bits:"},
  87
  88         {TAG_HMACSHA1_KEY, "Key:"},
  89         {TAG_HMACSHA1_BITS, "Bits:"},
  90
  91         {TAG_HMACSHA224_KEY, "Key:"},
  92         {TAG_HMACSHA224_BITS, "Bits:"},
  93
  94         {TAG_HMACSHA256_KEY, "Key:"},
  95         {TAG_HMACSHA256_BITS, "Bits:"},
  96
  97         {TAG_HMACSHA384_KEY, "Key:"},
  98         {TAG_HMACSHA384_BITS, "Bits:"},
  99
 100         {TAG_HMACSHA512_KEY, "Key:"},
 101         {TAG_HMACSHA512_BITS, "Bits:"},
 102
 103         {0, NULL}
 104 };
 105
 106 static int
 107 find_value(const char *s, const unsigned int alg) {
 108         int i;
 109
 110         for (i = 0; ; i++) {
 111                 if (map[i].tag == NULL)
 112                         return (-1);
 113                 else if (strcasecmp(s, map[i].tag) == 0 &&
 114                          TAG_ALG(map[i].value) == alg)
 115                         return (map[i].value);
 116         }
 117 }
 118
 119 static const char *
 120 find_tag(const int value) {
 121         int i;
 122
 123         for (i = 0; ; i++) {
 124                 if (map[i].tag == NULL)
 125                         return (NULL);
 126                 else if (value == map[i].value)
 127                         return (map[i].tag);
 128         }
 129 }
 130
 131 static int
 132 check_rsa(const dst_private_t *priv) {
 133         int i, j;
 134         isc_boolean_t have[RSA_NTAGS];
 135         isc_boolean_t ok;
 136         unsigned int mask;
 137
 138         for (i = 0; i < RSA_NTAGS; i++)
 139                 have[i] = ISC_FALSE;
 140         for (j = 0; j < priv->nelements; j++) {
 141                 for (i = 0; i < RSA_NTAGS; i++)
 142                         if (priv->elements[j].tag == TAG(DST_ALG_RSAMD5, i))
 143                                 break;
 144                 if (i == RSA_NTAGS)
 145                         return (-1);
 146                 have[i] = ISC_TRUE;
 147         }
 148
 149         mask = ~0;
 150         mask <<= sizeof(mask) * 8 - TAG_SHIFT;
 151         mask >>= sizeof(mask) * 8 - TAG_SHIFT;
 152
 153         if (have[TAG_RSA_ENGINE & mask])
 154                 ok = have[TAG_RSA_MODULUS & mask] &&
 155                      have[TAG_RSA_PUBLICEXPONENT & mask] &&
 156                      have[TAG_RSA_LABEL & mask];
 157         else
 158                 ok = have[TAG_RSA_MODULUS & mask] &&
 159                      have[TAG_RSA_PUBLICEXPONENT & mask] &&
 160                      have[TAG_RSA_PRIVATEEXPONENT & mask] &&
 161                      have[TAG_RSA_PRIME1 & mask] &&
 162                      have[TAG_RSA_PRIME2 & mask] &&
 163                      have[TAG_RSA_EXPONENT1 & mask] &&
 164                      have[TAG_RSA_EXPONENT2 & mask] &&
 165                      have[TAG_RSA_COEFFICIENT & mask];
 166         return (ok ? 0 : -1 );
 167 }
 168
 169 static int
 170 check_dh(const dst_private_t *priv) {
 171         int i, j;
 172         if (priv->nelements != DH_NTAGS)
 173                 return (-1);
 174         for (i = 0; i < DH_NTAGS; i++) {
 175                 for (j = 0; j < priv->nelements; j++)
 176                         if (priv->elements[j].tag == TAG(DST_ALG_DH, i))
 177                                 break;
 178                 if (j == priv->nelements)
 179                         return (-1);
 180         }
 181         return (0);
 182 }
 183
 184 static int
 185 check_dsa(const dst_private_t *priv) {
 186         int i, j;
 187         if (priv->nelements != DSA_NTAGS)
 188                 return (-1);
 189         for (i = 0; i < DSA_NTAGS; i++) {
 190                 for (j = 0; j < priv->nelements; j++)
 191                         if (priv->elements[j].tag == TAG(DST_ALG_DSA, i))
 192                                 break;
 193                 if (j == priv->nelements)
 194                         return (-1);
 195         }
 196         return (0);
 197 }
 198
 199 static int
 200 check_hmac_md5(const dst_private_t *priv, isc_boolean_t old) {
 201         int i, j;
 202
 203         if (priv->nelements != HMACMD5_NTAGS) {
 204                 /*
 205                  * If this is a good old format and we are accepting
 206                  * the old format return success.
 207                  */
 208                 if (old && priv->nelements == OLD_HMACMD5_NTAGS &&
 209                     priv->elements[0].tag == TAG_HMACMD5_KEY)
 210                         return (0);
 211                 return (-1);
 212         }
 213         /*
 214          * We must be new format at this point.
 215          */
 216         for (i = 0; i < HMACMD5_NTAGS; i++) {
 217                 for (j = 0; j < priv->nelements; j++)
 218                         if (priv->elements[j].tag == TAG(DST_ALG_HMACMD5, i))
 219                                 break;
 220                 if (j == priv->nelements)
 221                         return (-1);
 222         }
 223         return (0);
 224 }
 225
 226 static int
 227 check_hmac_sha(const dst_private_t *priv, unsigned int ntags,
 228                unsigned int alg)
 229 {
 230         unsigned int i, j;
 231         if (priv->nelements != ntags)
 232                 return (-1);
 233         for (i = 0; i < ntags; i++) {
 234                 for (j = 0; j < priv->nelements; j++)
 235                         if (priv->elements[j].tag == TAG(alg, i))
 236                                 break;
 237                 if (j == priv->nelements)
 238                         return (-1);
 239         }
 240         return (0);
 241 }
 242
 243 static int
 244 check_data(const dst_private_t *priv, const unsigned int alg,
 245            isc_boolean_t old)
 246 {
 247         /* XXXVIX this switch statement is too sparse to gen a jump table. */
 248         switch (alg) {
 249         case DST_ALG_RSAMD5:
 250         case DST_ALG_RSASHA1:
 251         case DST_ALG_NSEC3RSASHA1:
 252         case DST_ALG_RSASHA256:
 253         case DST_ALG_RSASHA512:
 254                 return (check_rsa(priv));
 255         case DST_ALG_DH:
 256                 return (check_dh(priv));
 257         case DST_ALG_DSA:
 258         case DST_ALG_NSEC3DSA:
 259                 return (check_dsa(priv));
 260         case DST_ALG_HMACMD5:
 261                 return (check_hmac_md5(priv, old));
 262         case DST_ALG_HMACSHA1:
 263                 return (check_hmac_sha(priv, HMACSHA1_NTAGS, alg));
 264         case DST_ALG_HMACSHA224:
 265                 return (check_hmac_sha(priv, HMACSHA224_NTAGS, alg));
 266         case DST_ALG_HMACSHA256:
 267                 return (check_hmac_sha(priv, HMACSHA256_NTAGS, alg));
 268         case DST_ALG_HMACSHA384:
 269                 return (check_hmac_sha(priv, HMACSHA384_NTAGS, alg));
 270         case DST_ALG_HMACSHA512:
 271                 return (check_hmac_sha(priv, HMACSHA512_NTAGS, alg));
 272         default:
 273                 return (DST_R_UNSUPPORTEDALG);
 274         }
 275 }
 276
 277 void
 278 dst__privstruct_free(dst_private_t *priv, isc_mem_t *mctx) {
 279         int i;
 280
 281         if (priv == NULL)
 282                 return;
 283         for (i = 0; i < priv->nelements; i++) {
 284                 if (priv->elements[i].data == NULL)
 285                         continue;
 286                 memset(priv->elements[i].data, 0, MAXFIELDSIZE);
 287                 isc_mem_put(mctx, priv->elements[i].data, MAXFIELDSIZE);
 288         }
 289         priv->nelements = 0;
 290 }
 291
 292 int
 293 dst__privstruct_parse(dst_key_t *key, unsigned int alg, isc_lex_t *lex,
 294                       isc_mem_t *mctx, dst_private_t *priv)
 295 {
 296         int n = 0, major, minor, check;
 297         isc_buffer_t b;
 298         isc_token_t token;
 299         unsigned char *data = NULL;
 300         unsigned int opt = ISC_LEXOPT_EOL;
 301         isc_result_t ret;
 302
 303         REQUIRE(priv != NULL);
 304
 305         priv->nelements = 0;
 306         memset(priv->elements, 0, sizeof(priv->elements));
 307
 308 #define NEXTTOKEN(lex, opt, token)                              \
 309         do {                                                    \
 310                 ret = isc_lex_gettoken(lex, opt, token);        \
 311                 if (ret != ISC_R_SUCCESS)                       \
 312                         goto fail;                              \
 313         } while (0)
 314
 315 #define READLINE(lex, opt, token)                               \
 316         do {                                                    \
 317                 ret = isc_lex_gettoken(lex, opt, token);        \
 318                 if (ret == ISC_R_EOF)                           \
 319                         break;                                  \
 320                 else if (ret != ISC_R_SUCCESS)                  \
 321                         goto fail;                              \
 322         } while ((*token).type != isc_tokentype_eol)
 323
 324         /*
 325          * Read the description line.
 326          */
 327         NEXTTOKEN(lex, opt, &token);
 328         if (token.type != isc_tokentype_string ||
 329             strcmp(DST_AS_STR(token), PRIVATE_KEY_STR) != 0)
 330         {
 331                 ret = DST_R_INVALIDPRIVATEKEY;
 332                 goto fail;
 333         }
 334
 335         NEXTTOKEN(lex, opt, &token);
 336         if (token.type != isc_tokentype_string ||
 337             (DST_AS_STR(token))[0] != 'v')
 338         {
 339                 ret = DST_R_INVALIDPRIVATEKEY;
 340                 goto fail;
 341         }
 342         if (sscanf(DST_AS_STR(token), "v%d.%d", &major, &minor) != 2)
 343         {
 344                 ret = DST_R_INVALIDPRIVATEKEY;
 345                 goto fail;
 346         }
 347
 348         if (major > MAJOR_VERSION ||
 349             (major == MAJOR_VERSION && minor > MINOR_VERSION))
 350         {
 351                 ret = DST_R_INVALIDPRIVATEKEY;
 352                 goto fail;
 353         }
 354
 355         READLINE(lex, opt, &token);
 356
 357         /*
 358          * Read the algorithm line.
 359          */
 360         NEXTTOKEN(lex, opt, &token);
 361         if (token.type != isc_tokentype_string ||
 362             strcmp(DST_AS_STR(token), ALGORITHM_STR) != 0)
 363         {
 364                 ret = DST_R_INVALIDPRIVATEKEY;
 365                 goto fail;
 366         }
 367
 368         NEXTTOKEN(lex, opt | ISC_LEXOPT_NUMBER, &token);
 369         if (token.type != isc_tokentype_number ||
 370             token.value.as_ulong != (unsigned long) dst_key_alg(key))
 371         {
 372                 ret = DST_R_INVALIDPRIVATEKEY;
 373                 goto fail;
 374         }
 375
 376         READLINE(lex, opt, &token);
 377
 378         /*
 379          * Read the key data.
 380          */
 381         for (n = 0; n < MAXFIELDS; n++) {
 382                 int tag;
 383                 isc_region_t r;
 384
 385                 do {
 386                         ret = isc_lex_gettoken(lex, opt, &token);
 387                         if (ret == ISC_R_EOF)
 388                                 goto done;
 389                         if (ret != ISC_R_SUCCESS)
 390                                 goto fail;
 391                 } while (token.type == isc_tokentype_eol);
 392
 393                 if (token.type != isc_tokentype_string) {
 394                         ret = DST_R_INVALIDPRIVATEKEY;
 395                         goto fail;
 396                 }
 397
 398                 tag = find_value(DST_AS_STR(token), alg);
 399                 if (tag < 0 || TAG_ALG(tag) != alg) {
 400                         ret = DST_R_INVALIDPRIVATEKEY;
 401                         goto fail;
 402                 }
 403                 priv->elements[n].tag = tag;
 404
 405                 data = (unsigned char *) isc_mem_get(mctx, MAXFIELDSIZE);
 406                 if (data == NULL)
 407                         goto fail;
 408
 409                 isc_buffer_init(&b, data, MAXFIELDSIZE);
 410                 ret = isc_base64_tobuffer(lex, &b, -1);
 411                 if (ret != ISC_R_SUCCESS)
 412                         goto fail;
 413                 isc_buffer_usedregion(&b, &r);
 414                 priv->elements[n].length = r.length;
 415                 priv->elements[n].data = r.base;
 416
 417                 READLINE(lex, opt, &token);
 418                 data = NULL;
 419         }
 420  done:
 421         priv->nelements = n;
 422
 423         check = check_data(priv, alg, ISC_TRUE);
 424         if (check < 0) {
 425                 ret = DST_R_INVALIDPRIVATEKEY;
 426                 goto fail;
 427         } else if (check != ISC_R_SUCCESS) {
 428                 ret = check;
 429                 goto fail;
 430         }
 431
 432         return (ISC_R_SUCCESS);
 433
 434 fail:
 435         priv->nelements = n;
 436         dst__privstruct_free(priv, mctx);
 437         if (data != NULL)
 438                 isc_mem_put(mctx, data, MAXFIELDSIZE);
 439
 440         return (ret);
 441 }
 442
 443 int
 444 dst__privstruct_writefile(const dst_key_t *key, const dst_private_t *priv,
 445                           const char *directory)
 446 {
 447         FILE *fp;
 448         int ret, i;
 449         isc_result_t result;
 450         char filename[ISC_DIR_NAMEMAX];
 451         char buffer[MAXFIELDSIZE * 2];
 452         isc_buffer_t b;
 453         isc_fsaccess_t access;
 454
 455         REQUIRE(priv != NULL);
 456
 457         ret = check_data(priv, dst_key_alg(key), ISC_FALSE);
 458         if (ret < 0)
 459                 return (DST_R_INVALIDPRIVATEKEY);
 460         else if (ret != ISC_R_SUCCESS)
 461                 return (ret);
 462
 463         isc_buffer_init(&b, filename, sizeof(filename));
 464         result = dst_key_buildfilename(key, DST_TYPE_PRIVATE, directory, &b);
 465         if (result != ISC_R_SUCCESS)
 466                 return (result);
 467
 468         if ((fp = fopen(filename, "w")) == NULL)
 469                 return (DST_R_WRITEERROR);
 470
 471         access = 0;
 472         isc_fsaccess_add(ISC_FSACCESS_OWNER,
 473                          ISC_FSACCESS_READ | ISC_FSACCESS_WRITE,
 474                          &access);
 475         (void)isc_fsaccess_set(filename, access);
 476
 477         /* XXXDCL return value should be checked for full filesystem */
 478         fprintf(fp, "%s v%d.%d\n", PRIVATE_KEY_STR, MAJOR_VERSION,
 479                 MINOR_VERSION);
 480
 481         fprintf(fp, "%s %d ", ALGORITHM_STR, dst_key_alg(key));
 482         /* XXXVIX this switch statement is too sparse to gen a jump table. */
 483         switch (dst_key_alg(key)) {
 484         case DST_ALG_RSAMD5:
 485                 fprintf(fp, "(RSA)\n");
 486                 break;
 487         case DST_ALG_DH:
 488                 fprintf(fp, "(DH)\n");
 489                 break;
 490         case DST_ALG_DSA:
 491                 fprintf(fp, "(DSA)\n");
 492                 break;
 493         case DST_ALG_RSASHA1:
 494                 fprintf(fp, "(RSASHA1)\n");
 495                 break;
 496         case DST_ALG_NSEC3DSA:
 497                 fprintf(fp, "(NSEC3DSA)\n");
 498                 break;
 499         case DST_ALG_NSEC3RSASHA1:
 500                 fprintf(fp, "(NSEC3RSASHA1)\n");
 501                 break;
 502         case DST_ALG_RSASHA256:
 503                 fprintf(fp, "(RSASHA256)\n");
 504                 break;
 505         case DST_ALG_RSASHA512:
 506                 fprintf(fp, "(RSASHA512)\n");
 507                 break;
 508         case DST_ALG_HMACMD5:
 509                 fprintf(fp, "(HMAC_MD5)\n");
 510                 break;
 511         case DST_ALG_HMACSHA1:
 512                 fprintf(fp, "(HMAC_SHA1)\n");
 513                 break;
 514         case DST_ALG_HMACSHA224:
 515                 fprintf(fp, "(HMAC_SHA224)\n");
 516                 break;
 517         case DST_ALG_HMACSHA256:
 518                 fprintf(fp, "(HMAC_SHA256)\n");
 519                 break;
 520         case DST_ALG_HMACSHA384:
 521                 fprintf(fp, "(HMAC_SHA384)\n");
 522                 break;
 523         case DST_ALG_HMACSHA512:
 524                 fprintf(fp, "(HMAC_SHA512)\n");
 525                 break;
 526         default:
 527                 fprintf(fp, "(?)\n");
 528                 break;
 529         }
 530
 531         for (i = 0; i < priv->nelements; i++) {
 532                 isc_buffer_t b;
 533                 isc_region_t r;
 534                 const char *s;
 535
 536                 s = find_tag(priv->elements[i].tag);
 537
 538                 r.base = priv->elements[i].data;
 539                 r.length = priv->elements[i].length;
 540                 isc_buffer_init(&b, buffer, sizeof(buffer));
 541                 result = isc_base64_totext(&r, sizeof(buffer), "", &b);
 542                 if (result != ISC_R_SUCCESS) {
 543                         fclose(fp);
 544                         return (DST_R_INVALIDPRIVATEKEY);
 545                 }
 546                 isc_buffer_usedregion(&b, &r);
 547
 548                fprintf(fp, "%s %.*s\n", s, (int)r.length, r.base);
 549         }
 550
 551         fflush(fp);
 552         result = ferror(fp) ? DST_R_WRITEERROR : ISC_R_SUCCESS;
 553         fclose(fp);
 554         return (result);
 555 }
 556
 557 /*! \file */