contrib/bind9/lib/dns/openssldh_link.c

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