contrib/bind9/lib/dns/openssldh_link.c

   1 /*
   2  * Portions Copyright (C) 2004-2007  Internet Systems Consortium, Inc. ("ISC")
   3  * Portions Copyright (C) 1999-2002  Internet Software Consortium.
   4  * Portions Copyright (C) 1995-2000 by Network Associates, Inc.
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
  11  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
  13  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  16  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /*
  20  * Principal Author: Brian Wellington
  21  * $Id: openssldh_link.c,v 1.1.6.10 2007/08/28 07:20:04 tbox Exp $
  22  */
  23
  24 #ifdef OPENSSL
  25
  26 #include <config.h>
  27
  28 #include <ctype.h>
  29
  30 #include <isc/mem.h>
  31 #include <isc/string.h>
  32 #include <isc/util.h>
  33
  34 #include <dst/result.h>
  35
  36 #include "dst_internal.h"
  37 #include "dst_openssl.h"
  38 #include "dst_parse.h"
  39
  40 #include <openssl/dh.h>
  41
  42 #define PRIME768 "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088" \
  43         "A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25" \
  44         "F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A63A3620FFFFFFFFFFFFFFFF"
  45
  46 #define PRIME1024 "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08" \
  47         "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF2" \
  48         "5F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406" \
  49         "B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF"
  50
  51 #define PRIME1536 "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" \
  52         "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" \
  53         "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" \
  54         "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" \
  55         "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D" \
  56         "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F" \
  57         "83655D23DCA3AD961C62F356208552BB9ED529077096966D" \
  58         "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF"
  59
  60
  61 static isc_result_t openssldh_todns(const dst_key_t *key, isc_buffer_t *data);
  62
  63 static BIGNUM bn2, bn768, bn1024, bn1536;
  64
  65 static isc_result_t
  66 openssldh_computesecret(const dst_key_t *pub, const dst_key_t *priv,
  67                         isc_buffer_t *secret)
  68 {
  69         DH *dhpub, *dhpriv;
  70         int ret;
  71         isc_region_t r;
  72         unsigned int len;
  73
  74         REQUIRE(pub->opaque != NULL);
  75         REQUIRE(priv->opaque != NULL);
  76
  77         dhpub = (DH *) pub->opaque;
  78         dhpriv = (DH *) priv->opaque;
  79
  80         len = DH_size(dhpriv);
  81         isc_buffer_availableregion(secret, &r);
  82         if (r.length < len)
  83                 return (ISC_R_NOSPACE);
  84         ret = DH_compute_key(r.base, dhpub->pub_key, dhpriv);
  85         if (ret == 0)
  86                 return (dst__openssl_toresult(DST_R_COMPUTESECRETFAILURE));
  87         isc_buffer_add(secret, len);
  88         return (ISC_R_SUCCESS);
  89 }
  90
  91 static isc_boolean_t
  92 openssldh_compare(const dst_key_t *key1, const dst_key_t *key2) {
  93         int status;
  94         DH *dh1, *dh2;
  95
  96         dh1 = (DH *) key1->opaque;
  97         dh2 = (DH *) key2->opaque;
  98
  99         if (dh1 == NULL && dh2 == NULL)
 100                 return (ISC_TRUE);
 101         else if (dh1 == NULL || dh2 == NULL)
 102                 return (ISC_FALSE);
 103
 104         status = BN_cmp(dh1->p, dh2->p) ||
 105                  BN_cmp(dh1->g, dh2->g) ||
 106                  BN_cmp(dh1->pub_key, dh2->pub_key);
 107
 108         if (status != 0)
 109                 return (ISC_FALSE);
 110
 111         if (dh1->priv_key != NULL || dh2->priv_key != NULL) {
 112                 if (dh1->priv_key == NULL || dh2->priv_key == NULL)
 113                         return (ISC_FALSE);
 114                 if (BN_cmp(dh1->priv_key, dh2->priv_key) != 0)
 115                         return (ISC_FALSE);
 116         }
 117         return (ISC_TRUE);
 118 }
 119
 120 static isc_boolean_t
 121 openssldh_paramcompare(const dst_key_t *key1, const dst_key_t *key2) {
 122         int status;
 123         DH *dh1, *dh2;
 124
 125         dh1 = (DH *) key1->opaque;
 126         dh2 = (DH *) key2->opaque;
 127
 128         if (dh1 == NULL && dh2 == NULL)
 129                 return (ISC_TRUE);
 130         else if (dh1 == NULL || dh2 == NULL)
 131                 return (ISC_FALSE);
 132
 133         status = BN_cmp(dh1->p, dh2->p) ||
 134                  BN_cmp(dh1->g, dh2->g);
 135
 136         if (status != 0)
 137                 return (ISC_FALSE);
 138         return (ISC_TRUE);
 139 }
 140
 141 static isc_result_t
 142 openssldh_generate(dst_key_t *key, int generator) {
 143 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 144         BN_GENCB cb;
 145 #endif
 146         DH *dh = NULL;
 147
 148         if (generator == 0) {
 149                 if (key->key_size == 768 ||
 150                     key->key_size == 1024 ||
 151                     key->key_size == 1536)
 152                 {
 153                         dh = DH_new();
 154                         if (dh == NULL)
 155                                 return (dst__openssl_toresult(ISC_R_NOMEMORY));
 156                         if (key->key_size == 768)
 157                                 dh->p = &bn768;
 158                         else if (key->key_size == 1024)
 159                                 dh->p = &bn1024;
 160                         else
 161                                 dh->p = &bn1536;
 162                         dh->g = &bn2;
 163                 } else
 164                         generator = 2;
 165         }
 166
 167         if (generator != 0) {
 168 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 169                 dh = DH_new();
 170                 if (dh == NULL)
 171                         return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 172
 173                 BN_GENCB_set_old(&cb, NULL, NULL);
 174
 175                 if (!DH_generate_parameters_ex(dh, key->key_size, generator,
 176                                                &cb)) {
 177                         DH_free(dh);
 178                         return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 179                 }
 180 #else
 181                 dh = DH_generate_parameters(key->key_size, generator,
 182                                             NULL, NULL);
 183 #endif
 184         }
 185
 186         if (dh == NULL)
 187                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 188
 189         if (DH_generate_key(dh) == 0) {
 190                 DH_free(dh);
 191                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 192         }
 193         dh->flags &= ~DH_FLAG_CACHE_MONT_P;
 194
 195         key->opaque = dh;
 196
 197         return (ISC_R_SUCCESS);
 198 }
 199
 200 static isc_boolean_t
 201 openssldh_isprivate(const dst_key_t *key) {
 202         DH *dh = (DH *) key->opaque;
 203         return (ISC_TF(dh != NULL && dh->priv_key != NULL));
 204 }
 205
 206 static void
 207 openssldh_destroy(dst_key_t *key) {
 208         DH *dh = key->opaque;
 209
 210         if (dh == NULL)
 211                 return;
 212
 213         if (dh->p == &bn768 || dh->p == &bn1024 || dh->p == &bn1536)
 214                 dh->p = NULL;
 215         if (dh->g == &bn2)
 216                 dh->g = NULL;
 217         DH_free(dh);
 218         key->opaque = NULL;
 219 }
 220
 221 static void
 222 uint16_toregion(isc_uint16_t val, isc_region_t *region) {
 223         *region->base++ = (val & 0xff00) >> 8;
 224         *region->base++ = (val & 0x00ff);
 225 }
 226
 227 static isc_uint16_t
 228 uint16_fromregion(isc_region_t *region) {
 229         isc_uint16_t val;
 230         unsigned char *cp = region->base;
 231
 232         val = ((unsigned int)(cp[0])) << 8;
 233         val |= ((unsigned int)(cp[1]));
 234
 235         region->base += 2;
 236         return (val);
 237 }
 238
 239 static isc_result_t
 240 openssldh_todns(const dst_key_t *key, isc_buffer_t *data) {
 241         DH *dh;
 242         isc_region_t r;
 243         isc_uint16_t dnslen, plen, glen, publen;
 244
 245         REQUIRE(key->opaque != NULL);
 246
 247         dh = (DH *) key->opaque;
 248
 249         isc_buffer_availableregion(data, &r);
 250
 251         if (dh->g == &bn2 &&
 252             (dh->p == &bn768 || dh->p == &bn1024 || dh->p == &bn1536)) {
 253                 plen = 1;
 254                 glen = 0;
 255         }
 256         else {
 257                 plen = BN_num_bytes(dh->p);
 258                 glen = BN_num_bytes(dh->g);
 259         }
 260         publen = BN_num_bytes(dh->pub_key);
 261         dnslen = plen + glen + publen + 6;
 262         if (r.length < (unsigned int) dnslen)
 263                 return (ISC_R_NOSPACE);
 264
 265         uint16_toregion(plen, &r);
 266         if (plen == 1) {
 267                 if (dh->p == &bn768)
 268                         *r.base = 1;
 269                 else if (dh->p == &bn1024)
 270                         *r.base = 2;
 271                 else
 272                         *r.base = 3;
 273         }
 274         else
 275                 BN_bn2bin(dh->p, r.base);
 276         r.base += plen;
 277
 278         uint16_toregion(glen, &r);
 279         if (glen > 0)
 280                 BN_bn2bin(dh->g, r.base);
 281         r.base += glen;
 282
 283         uint16_toregion(publen, &r);
 284         BN_bn2bin(dh->pub_key, r.base);
 285         r.base += publen;
 286
 287         isc_buffer_add(data, dnslen);
 288
 289         return (ISC_R_SUCCESS);
 290 }
 291
 292 static isc_result_t
 293 openssldh_fromdns(dst_key_t *key, isc_buffer_t *data) {
 294         DH *dh;
 295         isc_region_t r;
 296         isc_uint16_t plen, glen, publen;
 297         int special = 0;
 298
 299         isc_buffer_remainingregion(data, &r);
 300         if (r.length == 0)
 301                 return (ISC_R_SUCCESS);
 302
 303         dh = DH_new();
 304         if (dh == NULL)
 305                 return (dst__openssl_toresult(ISC_R_NOMEMORY));
 306         dh->flags &= ~DH_FLAG_CACHE_MONT_P;
 307
 308         /*
 309          * Read the prime length.  1 & 2 are table entries, > 16 means a
 310          * prime follows, otherwise an error.
 311          */
 312         if (r.length < 2) {
 313                 DH_free(dh);
 314                 return (DST_R_INVALIDPUBLICKEY);
 315         }
 316         plen = uint16_fromregion(&r);
 317         if (plen < 16 && plen != 1 && plen != 2) {
 318                 DH_free(dh);
 319                 return (DST_R_INVALIDPUBLICKEY);
 320         }
 321         if (r.length < plen) {
 322                 DH_free(dh);
 323                 return (DST_R_INVALIDPUBLICKEY);
 324         }
 325         if (plen == 1 || plen == 2) {
 326                 if (plen == 1)
 327                         special = *r.base++;
 328                 else
 329                         special = uint16_fromregion(&r);
 330                 switch (special) {
 331                         case 1:
 332                                 dh->p = &bn768;
 333                                 break;
 334                         case 2:
 335                                 dh->p = &bn1024;
 336                                 break;
 337                         case 3:
 338                                 dh->p = &bn1536;
 339                                 break;
 340                         default:
 341                                 DH_free(dh);
 342                                 return (DST_R_INVALIDPUBLICKEY);
 343                 }
 344         }
 345         else {
 346                 dh->p = BN_bin2bn(r.base, plen, NULL);
 347                 r.base += plen;
 348         }
 349
 350         /*
 351          * Read the generator length.  This should be 0 if the prime was
 352          * special, but it might not be.  If it's 0 and the prime is not
 353          * special, we have a problem.
 354          */
 355         if (r.length < 2) {
 356                 DH_free(dh);
 357                 return (DST_R_INVALIDPUBLICKEY);
 358         }
 359         glen = uint16_fromregion(&r);
 360         if (r.length < glen) {
 361                 DH_free(dh);
 362                 return (DST_R_INVALIDPUBLICKEY);
 363         }
 364         if (special != 0) {
 365                 if (glen == 0)
 366                         dh->g = &bn2;
 367                 else {
 368                         dh->g = BN_bin2bn(r.base, glen, NULL);
 369                         if (BN_cmp(dh->g, &bn2) == 0) {
 370                                 BN_free(dh->g);
 371                                 dh->g = &bn2;
 372                         }
 373                         else {
 374                                 DH_free(dh);
 375                                 return (DST_R_INVALIDPUBLICKEY);
 376                         }
 377                 }
 378         }
 379         else {
 380                 if (glen == 0) {
 381                         DH_free(dh);
 382                         return (DST_R_INVALIDPUBLICKEY);
 383                 }
 384                 dh->g = BN_bin2bn(r.base, glen, NULL);
 385         }
 386         r.base += glen;
 387
 388         if (r.length < 2) {
 389                 DH_free(dh);
 390                 return (DST_R_INVALIDPUBLICKEY);
 391         }
 392         publen = uint16_fromregion(&r);
 393         if (r.length < publen) {
 394                 DH_free(dh);
 395                 return (DST_R_INVALIDPUBLICKEY);
 396         }
 397         dh->pub_key = BN_bin2bn(r.base, publen, NULL);
 398         r.base += publen;
 399
 400         key->key_size = BN_num_bits(dh->p);
 401
 402         isc_buffer_forward(data, plen + glen + publen + 6);
 403
 404         key->opaque = (void *) dh;
 405
 406         return (ISC_R_SUCCESS);
 407 }
 408
 409 static isc_result_t
 410 openssldh_tofile(const dst_key_t *key, const char *directory) {
 411         int i;
 412         DH *dh;
 413         dst_private_t priv;
 414         unsigned char *bufs[4];
 415         isc_result_t result;
 416
 417         if (key->opaque == NULL)
 418                 return (DST_R_NULLKEY);
 419
 420         dh = (DH *) key->opaque;
 421
 422         for (i = 0; i < 4; i++) {
 423                 bufs[i] = isc_mem_get(key->mctx, BN_num_bytes(dh->p));
 424                 if (bufs[i] == NULL) {
 425                         result = ISC_R_NOMEMORY;
 426                         goto fail;
 427                 }
 428         }
 429
 430         i = 0;
 431
 432         priv.elements[i].tag = TAG_DH_PRIME;
 433         priv.elements[i].length = BN_num_bytes(dh->p);
 434         BN_bn2bin(dh->p, bufs[i]);
 435         priv.elements[i].data = bufs[i];
 436         i++;
 437
 438         priv.elements[i].tag = TAG_DH_GENERATOR;
 439         priv.elements[i].length = BN_num_bytes(dh->g);
 440         BN_bn2bin(dh->g, bufs[i]);
 441         priv.elements[i].data = bufs[i];
 442         i++;
 443
 444         priv.elements[i].tag = TAG_DH_PRIVATE;
 445         priv.elements[i].length = BN_num_bytes(dh->priv_key);
 446         BN_bn2bin(dh->priv_key, bufs[i]);
 447         priv.elements[i].data = bufs[i];
 448         i++;
 449
 450         priv.elements[i].tag = TAG_DH_PUBLIC;
 451         priv.elements[i].length = BN_num_bytes(dh->pub_key);
 452         BN_bn2bin(dh->pub_key, bufs[i]);
 453         priv.elements[i].data = bufs[i];
 454         i++;
 455
 456         priv.nelements = i;
 457         result = dst__privstruct_writefile(key, &priv, directory);
 458  fail:
 459         for (i = 0; i < 4; i++) {
 460                 if (bufs[i] == NULL)
 461                         break;
 462                 isc_mem_put(key->mctx, bufs[i], BN_num_bytes(dh->p));
 463         }
 464         return (result);
 465 }
 466
 467 static isc_result_t
 468 openssldh_parse(dst_key_t *key, isc_lex_t *lexer) {
 469         dst_private_t priv;
 470         isc_result_t ret;
 471         int i;
 472         DH *dh = NULL;
 473         isc_mem_t *mctx;
 474 #define DST_RET(a) {ret = a; goto err;}
 475
 476         mctx = key->mctx;
 477
 478         /* read private key file */
 479         ret = dst__privstruct_parse(key, DST_ALG_DH, lexer, mctx, &priv);
 480         if (ret != ISC_R_SUCCESS)
 481                 return (ret);
 482
 483         dh = DH_new();
 484         if (dh == NULL)
 485                 DST_RET(ISC_R_NOMEMORY);
 486         dh->flags &= ~DH_FLAG_CACHE_MONT_P;
 487         key->opaque = dh;
 488
 489         for (i = 0; i < priv.nelements; i++) {
 490                 BIGNUM *bn;
 491                 bn = BN_bin2bn(priv.elements[i].data,
 492                                priv.elements[i].length, NULL);
 493                 if (bn == NULL)
 494                         DST_RET(ISC_R_NOMEMORY);
 495
 496                 switch (priv.elements[i].tag) {
 497                         case TAG_DH_PRIME:
 498                                 dh->p = bn;
 499                                 break;
 500                         case TAG_DH_GENERATOR:
 501                                 dh->g = bn;
 502                                 break;
 503                         case TAG_DH_PRIVATE:
 504                                 dh->priv_key = bn;
 505                                 break;
 506                         case TAG_DH_PUBLIC:
 507                                 dh->pub_key = bn;
 508                                 break;
 509                 }
 510         }
 511         dst__privstruct_free(&priv, mctx);
 512
 513         key->key_size = BN_num_bits(dh->p);
 514
 515         if ((key->key_size == 768 ||
 516              key->key_size == 1024 ||
 517              key->key_size == 1536) &&
 518             BN_cmp(dh->g, &bn2) == 0)
 519         {
 520                 if (key->key_size == 768 && BN_cmp(dh->p, &bn768) == 0) {
 521                         BN_free(dh->p);
 522                         BN_free(dh->g);
 523                         dh->p = &bn768;
 524                         dh->g = &bn2;
 525                 } else if (key->key_size == 1024 &&
 526                            BN_cmp(dh->p, &bn1024) == 0) {
 527                         BN_free(dh->p);
 528                         BN_free(dh->g);
 529                         dh->p = &bn1024;
 530                         dh->g = &bn2;
 531                 } else if (key->key_size == 1536 &&
 532                            BN_cmp(dh->p, &bn1536) == 0) {
 533                         BN_free(dh->p);
 534                         BN_free(dh->g);
 535                         dh->p = &bn1536;
 536                         dh->g = &bn2;
 537                 }
 538         }
 539
 540         return (ISC_R_SUCCESS);
 541
 542  err:
 543         openssldh_destroy(key);
 544         dst__privstruct_free(&priv, mctx);
 545         memset(&priv, 0, sizeof(priv));
 546         return (ret);
 547 }
 548
 549 static void
 550 BN_fromhex(BIGNUM *b, const char *str) {
 551         static const char hexdigits[] = "0123456789abcdef";
 552         unsigned char data[512];
 553         unsigned int i;
 554         BIGNUM *out;
 555
 556         RUNTIME_CHECK(strlen(str) < 1024U && strlen(str) % 2 == 0U);
 557         for (i = 0; i < strlen(str); i += 2) {
 558                 char *s;
 559                 unsigned int high, low;
 560
 561                 s = strchr(hexdigits, tolower((unsigned char)str[i]));
 562                 RUNTIME_CHECK(s != NULL);
 563                 high = s - hexdigits;
 564
 565                 s = strchr(hexdigits, tolower((unsigned char)str[i + 1]));
 566                 RUNTIME_CHECK(s != NULL);
 567                 low = s - hexdigits;
 568
 569                 data[i/2] = (unsigned char)((high << 4) + low);
 570         }
 571         out = BN_bin2bn(data, strlen(str)/2, b);
 572         RUNTIME_CHECK(out != NULL);
 573 }
 574
 575 static void
 576 openssldh_cleanup(void) {
 577         BN_free(&bn2);
 578         BN_free(&bn768);
 579         BN_free(&bn1024);
 580         BN_free(&bn1536);
 581 }
 582
 583 static dst_func_t openssldh_functions = {
 584         NULL, /*%< createctx */
 585         NULL, /*%< destroyctx */
 586         NULL, /*%< adddata */
 587         NULL, /*%< openssldh_sign */
 588         NULL, /*%< openssldh_verify */
 589         openssldh_computesecret,
 590         openssldh_compare,
 591         openssldh_paramcompare,
 592         openssldh_generate,
 593         openssldh_isprivate,
 594         openssldh_destroy,
 595         openssldh_todns,
 596         openssldh_fromdns,
 597         openssldh_tofile,
 598         openssldh_parse,
 599         openssldh_cleanup,
 600 };
 601
 602 isc_result_t
 603 dst__openssldh_init(dst_func_t **funcp) {
 604         REQUIRE(funcp != NULL);
 605         if (*funcp == NULL) {
 606                 BN_init(&bn2);
 607                 BN_init(&bn768);
 608                 BN_init(&bn1024);
 609                 BN_init(&bn1536);
 610                 BN_set_word(&bn2, 2);
 611                 BN_fromhex(&bn768, PRIME768);
 612                 BN_fromhex(&bn1024, PRIME1024);
 613                 BN_fromhex(&bn1536, PRIME1536);
 614                 *funcp = &openssldh_functions;
 615         }
 616         return (ISC_R_SUCCESS);
 617 }
 618
 619 #else /* OPENSSL */
 620
 621 #include <isc/util.h>
 622
 623 EMPTY_TRANSLATION_UNIT
 624
 625 #endif /* OPENSSL */
 626 /*! \file */