contrib/bind9/lib/dns/openssldsa_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 /* $Id$ */
  33
  34 #ifdef OPENSSL
  35 #ifndef USE_EVP
  36 #define USE_EVP 1
  37 #endif
  38
  39 #include <config.h>
  40
  41 #include <string.h>
  42
  43 #include <isc/entropy.h>
  44 #include <isc/mem.h>
  45 #include <isc/sha1.h>
  46 #include <isc/util.h>
  47
  48 #include <dst/result.h>
  49
  50 #include "dst_internal.h"
  51 #include "dst_openssl.h"
  52 #include "dst_parse.h"
  53
  54 #include <openssl/dsa.h>
  55
  56 static isc_result_t openssldsa_todns(const dst_key_t *key, isc_buffer_t *data);
  57
  58 static isc_result_t
  59 openssldsa_createctx(dst_key_t *key, dst_context_t *dctx) {
  60 #if USE_EVP
  61         EVP_MD_CTX *evp_md_ctx;
  62
  63         UNUSED(key);
  64
  65         evp_md_ctx = EVP_MD_CTX_create();
  66         if (evp_md_ctx == NULL)
  67                 return (ISC_R_NOMEMORY);
  68
  69         if (!EVP_DigestInit_ex(evp_md_ctx, EVP_dss1(), NULL)) {
  70                 EVP_MD_CTX_destroy(evp_md_ctx);
  71                         return (ISC_R_FAILURE);
  72         }
  73
  74         dctx->ctxdata.evp_md_ctx = evp_md_ctx;
  75
  76         return (ISC_R_SUCCESS);
  77 #else
  78         isc_sha1_t *sha1ctx;
  79
  80         UNUSED(key);
  81
  82         sha1ctx = isc_mem_get(dctx->mctx, sizeof(isc_sha1_t));
  83         isc_sha1_init(sha1ctx);
  84         dctx->ctxdata.sha1ctx = sha1ctx;
  85         return (ISC_R_SUCCESS);
  86 #endif
  87 }
  88
  89 static void
  90 openssldsa_destroyctx(dst_context_t *dctx) {
  91 #if USE_EVP
  92         EVP_MD_CTX *evp_md_ctx = dctx->ctxdata.evp_md_ctx;
  93
  94         if (evp_md_ctx != NULL) {
  95                 EVP_MD_CTX_destroy(evp_md_ctx);
  96                 dctx->ctxdata.evp_md_ctx = NULL;
  97         }
  98 #else
  99         isc_sha1_t *sha1ctx = dctx->ctxdata.sha1ctx;
 100
 101         if (sha1ctx != NULL) {
 102                 isc_sha1_invalidate(sha1ctx);
 103                 isc_mem_put(dctx->mctx, sha1ctx, sizeof(isc_sha1_t));
 104                 dctx->ctxdata.sha1ctx = NULL;
 105         }
 106 #endif
 107 }
 108
 109 static isc_result_t
 110 openssldsa_adddata(dst_context_t *dctx, const isc_region_t *data) {
 111 #if USE_EVP
 112         EVP_MD_CTX *evp_md_ctx = dctx->ctxdata.evp_md_ctx;
 113
 114         if (!EVP_DigestUpdate(evp_md_ctx, data->base, data->length)) {
 115                 return (ISC_R_FAILURE);
 116         }
 117 #else
 118         isc_sha1_t *sha1ctx = dctx->ctxdata.sha1ctx;
 119
 120         isc_sha1_update(sha1ctx, data->base, data->length);
 121 #endif
 122         return (ISC_R_SUCCESS);
 123 }
 124
 125 static int
 126 BN_bn2bin_fixed(BIGNUM *bn, unsigned char *buf, int size) {
 127         int bytes = size - BN_num_bytes(bn);
 128         while (bytes-- > 0)
 129                 *buf++ = 0;
 130         BN_bn2bin(bn, buf);
 131         return (size);
 132 }
 133
 134 static isc_result_t
 135 openssldsa_sign(dst_context_t *dctx, isc_buffer_t *sig) {
 136         dst_key_t *key = dctx->key;
 137         DSA *dsa = key->keydata.dsa;
 138         isc_region_t r;
 139         DSA_SIG *dsasig;
 140 #if USE_EVP
 141         EVP_MD_CTX *evp_md_ctx = dctx->ctxdata.evp_md_ctx;
 142         EVP_PKEY *pkey;
 143         unsigned char *sigbuf;
 144         const unsigned char *sb;
 145         unsigned int siglen;
 146 #else
 147         isc_sha1_t *sha1ctx = dctx->ctxdata.sha1ctx;
 148         unsigned char digest[ISC_SHA1_DIGESTLENGTH];
 149 #endif
 150
 151         isc_buffer_availableregion(sig, &r);
 152         if (r.length < ISC_SHA1_DIGESTLENGTH * 2 + 1)
 153                 return (ISC_R_NOSPACE);
 154
 155 #if USE_EVP
 156         pkey = EVP_PKEY_new();
 157         if (pkey == NULL)
 158                 return (ISC_R_NOMEMORY);
 159         if (!EVP_PKEY_set1_DSA(pkey, dsa)) {
 160                 EVP_PKEY_free(pkey);
 161                 return (ISC_R_FAILURE);
 162         }
 163         sigbuf = malloc(EVP_PKEY_size(pkey));
 164         if (sigbuf == NULL) {
 165                 EVP_PKEY_free(pkey);
 166                 return (ISC_R_NOMEMORY);
 167         }
 168         if (!EVP_SignFinal(evp_md_ctx, sigbuf, &siglen, pkey)) {
 169                 EVP_PKEY_free(pkey);
 170                 free(sigbuf);
 171                 return (dst__openssl_toresult3(dctx->category,
 172                                                "EVP_SignFinal",
 173                                                ISC_R_FAILURE));
 174         }
 175         INSIST(EVP_PKEY_size(pkey) >= (int) siglen);
 176         EVP_PKEY_free(pkey);
 177         /* Convert from Dss-Sig-Value (RFC2459). */
 178         dsasig = DSA_SIG_new();
 179         if (dsasig == NULL) {
 180                 free(sigbuf);
 181                 return (ISC_R_NOMEMORY);
 182         }
 183         sb = sigbuf;
 184         if (d2i_DSA_SIG(&dsasig, &sb, (long) siglen) == NULL) {
 185                 free(sigbuf);
 186                 return (dst__openssl_toresult3(dctx->category,
 187                                                "d2i_DSA_SIG",
 188                                                ISC_R_FAILURE));
 189         }
 190         free(sigbuf);
 191 #elif 0
 192         /* Only use EVP for the Digest */
 193         if (!EVP_DigestFinal_ex(evp_md_ctx, digest, &siglen)) {
 194                 return (dst__openssl_toresult3(dctx->category,
 195                                                "EVP_DigestFinal_ex",
 196                                                ISC_R_FAILURE));
 197         }
 198         dsasig = DSA_do_sign(digest, ISC_SHA1_DIGESTLENGTH, dsa);
 199         if (dsasig == NULL)
 200                 return (dst__openssl_toresult3(dctx->category,
 201                                                "DSA_do_sign",
 202                                                DST_R_SIGNFAILURE));
 203 #else
 204         isc_sha1_final(sha1ctx, digest);
 205
 206         dsasig = DSA_do_sign(digest, ISC_SHA1_DIGESTLENGTH, dsa);
 207         if (dsasig == NULL)
 208                 return (dst__openssl_toresult3(dctx->category,
 209                                                "DSA_do_sign",
 210                                                DST_R_SIGNFAILURE));
 211 #endif
 212         *r.base++ = (key->key_size - 512)/64;
 213         BN_bn2bin_fixed(dsasig->r, r.base, ISC_SHA1_DIGESTLENGTH);
 214         r.base += ISC_SHA1_DIGESTLENGTH;
 215         BN_bn2bin_fixed(dsasig->s, r.base, ISC_SHA1_DIGESTLENGTH);
 216         r.base += ISC_SHA1_DIGESTLENGTH;
 217         DSA_SIG_free(dsasig);
 218         isc_buffer_add(sig, ISC_SHA1_DIGESTLENGTH * 2 + 1);
 219
 220         return (ISC_R_SUCCESS);
 221 }
 222
 223 static isc_result_t
 224 openssldsa_verify(dst_context_t *dctx, const isc_region_t *sig) {
 225         dst_key_t *key = dctx->key;
 226         DSA *dsa = key->keydata.dsa;
 227         int status = 0;
 228         unsigned char *cp = sig->base;
 229         DSA_SIG *dsasig;
 230 #if USE_EVP
 231         EVP_MD_CTX *evp_md_ctx = dctx->ctxdata.evp_md_ctx;
 232 #if 0
 233         EVP_PKEY *pkey;
 234         unsigned char *sigbuf;
 235 #endif
 236         unsigned int siglen;
 237 #else
 238         isc_sha1_t *sha1ctx = dctx->ctxdata.sha1ctx;
 239 #endif
 240         unsigned char digest[ISC_SHA1_DIGESTLENGTH];
 241
 242
 243 #if USE_EVP
 244 #if 1
 245         /* Only use EVP for the digest */
 246         if (!EVP_DigestFinal_ex(evp_md_ctx, digest, &siglen)) {
 247                 return (ISC_R_FAILURE);
 248         }
 249 #endif
 250 #else
 251         isc_sha1_final(sha1ctx, digest);
 252 #endif
 253
 254         if (sig->length != 2 * ISC_SHA1_DIGESTLENGTH + 1) {
 255                 return (DST_R_VERIFYFAILURE);
 256         }
 257
 258         cp++;   /*%< Skip T */
 259         dsasig = DSA_SIG_new();
 260         if (dsasig == NULL)
 261                 return (ISC_R_NOMEMORY);
 262         dsasig->r = BN_bin2bn(cp, ISC_SHA1_DIGESTLENGTH, NULL);
 263         cp += ISC_SHA1_DIGESTLENGTH;
 264         dsasig->s = BN_bin2bn(cp, ISC_SHA1_DIGESTLENGTH, NULL);
 265
 266 #if 0
 267         pkey = EVP_PKEY_new();
 268         if (pkey == NULL)
 269                 return (ISC_R_NOMEMORY);
 270         if (!EVP_PKEY_set1_DSA(pkey, dsa)) {
 271                 EVP_PKEY_free(pkey);
 272                 return (ISC_R_FAILURE);
 273         }
 274         /* Convert to Dss-Sig-Value (RFC2459). */
 275         sigbuf = malloc(EVP_PKEY_size(pkey) + 50);
 276         if (sigbuf == NULL) {
 277                 EVP_PKEY_free(pkey);
 278                 return (ISC_R_NOMEMORY);
 279         }
 280         siglen = (unsigned) i2d_DSA_SIG(dsasig, &sigbuf);
 281         INSIST(EVP_PKEY_size(pkey) >= (int) siglen);
 282         status = EVP_VerifyFinal(evp_md_ctx, sigbuf, siglen, pkey);
 283         EVP_PKEY_free(pkey);
 284         free(sigbuf);
 285 #else
 286         status = DSA_do_verify(digest, ISC_SHA1_DIGESTLENGTH, dsasig, dsa);
 287 #endif
 288         DSA_SIG_free(dsasig);
 289         switch (status) {
 290         case 1:
 291                 return (ISC_R_SUCCESS);
 292         case 0:
 293                 return (dst__openssl_toresult(DST_R_VERIFYFAILURE));
 294         default:
 295                 return (dst__openssl_toresult3(dctx->category,
 296                                                "DSA_do_verify",
 297                                                DST_R_VERIFYFAILURE));
 298         }
 299 }
 300
 301 static isc_boolean_t
 302 openssldsa_compare(const dst_key_t *key1, const dst_key_t *key2) {
 303         int status;
 304         DSA *dsa1, *dsa2;
 305
 306         dsa1 = key1->keydata.dsa;
 307         dsa2 = key2->keydata.dsa;
 308
 309         if (dsa1 == NULL && dsa2 == NULL)
 310                 return (ISC_TRUE);
 311         else if (dsa1 == NULL || dsa2 == NULL)
 312                 return (ISC_FALSE);
 313
 314         status = BN_cmp(dsa1->p, dsa2->p) ||
 315                  BN_cmp(dsa1->q, dsa2->q) ||
 316                  BN_cmp(dsa1->g, dsa2->g) ||
 317                  BN_cmp(dsa1->pub_key, dsa2->pub_key);
 318
 319         if (status != 0)
 320                 return (ISC_FALSE);
 321
 322         if (dsa1->priv_key != NULL || dsa2->priv_key != NULL) {
 323                 if (dsa1->priv_key == NULL || dsa2->priv_key == NULL)
 324                         return (ISC_FALSE);
 325                 if (BN_cmp(dsa1->priv_key, dsa2->priv_key))
 326                         return (ISC_FALSE);
 327         }
 328         return (ISC_TRUE);
 329 }
 330
 331 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 332 static int
 333 progress_cb(int p, int n, BN_GENCB *cb)
 334 {
 335         union {
 336                 void *dptr;
 337                 void (*fptr)(int);
 338         } u;
 339
 340         UNUSED(n);
 341
 342         u.dptr = cb->arg;
 343         if (u.fptr != NULL)
 344                 u.fptr(p);
 345         return (1);
 346 }
 347 #endif
 348
 349 static isc_result_t
 350 openssldsa_generate(dst_key_t *key, int unused, void (*callback)(int)) {
 351         DSA *dsa;
 352         unsigned char rand_array[ISC_SHA1_DIGESTLENGTH];
 353         isc_result_t result;
 354 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 355         BN_GENCB cb;
 356         union {
 357                 void *dptr;
 358                 void (*fptr)(int);
 359         } u;
 360
 361 #else
 362
 363         UNUSED(callback);
 364 #endif
 365         UNUSED(unused);
 366
 367         result = dst__entropy_getdata(rand_array, sizeof(rand_array),
 368                                       ISC_FALSE);
 369         if (result != ISC_R_SUCCESS)
 370                 return (result);
 371
 372 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 373         dsa = DSA_new();
 374         if (dsa == NULL)
 375                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 376
 377         if (callback == NULL) {
 378                 BN_GENCB_set_old(&cb, NULL, NULL);
 379         } else {
 380                 u.fptr = callback;
 381                 BN_GENCB_set(&cb, &progress_cb, u.dptr);
 382         }
 383
 384         if (!DSA_generate_parameters_ex(dsa, key->key_size, rand_array,
 385                                         ISC_SHA1_DIGESTLENGTH,  NULL, NULL,
 386                                         &cb))
 387         {
 388                 DSA_free(dsa);
 389                 return (dst__openssl_toresult2("DSA_generate_parameters_ex",
 390                                                DST_R_OPENSSLFAILURE));
 391         }
 392 #else
 393         dsa = DSA_generate_parameters(key->key_size, rand_array,
 394                                       ISC_SHA1_DIGESTLENGTH, NULL, NULL,
 395                                       NULL, NULL);
 396         if (dsa == NULL)
 397                 return (dst__openssl_toresult2("DSA_generate_parameters",
 398                                                DST_R_OPENSSLFAILURE));
 399 #endif
 400
 401         if (DSA_generate_key(dsa) == 0) {
 402                 DSA_free(dsa);
 403                 return (dst__openssl_toresult2("DSA_generate_key",
 404                                                DST_R_OPENSSLFAILURE));
 405         }
 406         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 407
 408         key->keydata.dsa = dsa;
 409
 410         return (ISC_R_SUCCESS);
 411 }
 412
 413 static isc_boolean_t
 414 openssldsa_isprivate(const dst_key_t *key) {
 415         DSA *dsa = key->keydata.dsa;
 416         return (ISC_TF(dsa != NULL && dsa->priv_key != NULL));
 417 }
 418
 419 static void
 420 openssldsa_destroy(dst_key_t *key) {
 421         DSA *dsa = key->keydata.dsa;
 422         DSA_free(dsa);
 423         key->keydata.dsa = NULL;
 424 }
 425
 426
 427 static isc_result_t
 428 openssldsa_todns(const dst_key_t *key, isc_buffer_t *data) {
 429         DSA *dsa;
 430         isc_region_t r;
 431         int dnslen;
 432         unsigned int t, p_bytes;
 433
 434         REQUIRE(key->keydata.dsa != NULL);
 435
 436         dsa = key->keydata.dsa;
 437
 438         isc_buffer_availableregion(data, &r);
 439
 440         t = (BN_num_bytes(dsa->p) - 64) / 8;
 441         if (t > 8)
 442                 return (DST_R_INVALIDPUBLICKEY);
 443         p_bytes = 64 + 8 * t;
 444
 445         dnslen = 1 + (key->key_size * 3)/8 + ISC_SHA1_DIGESTLENGTH;
 446         if (r.length < (unsigned int) dnslen)
 447                 return (ISC_R_NOSPACE);
 448
 449         *r.base++ = t;
 450         BN_bn2bin_fixed(dsa->q, r.base, ISC_SHA1_DIGESTLENGTH);
 451         r.base += ISC_SHA1_DIGESTLENGTH;
 452         BN_bn2bin_fixed(dsa->p, r.base, key->key_size/8);
 453         r.base += p_bytes;
 454         BN_bn2bin_fixed(dsa->g, r.base, key->key_size/8);
 455         r.base += p_bytes;
 456         BN_bn2bin_fixed(dsa->pub_key, r.base, key->key_size/8);
 457         r.base += p_bytes;
 458
 459         isc_buffer_add(data, dnslen);
 460
 461         return (ISC_R_SUCCESS);
 462 }
 463
 464 static isc_result_t
 465 openssldsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
 466         DSA *dsa;
 467         isc_region_t r;
 468         unsigned int t, p_bytes;
 469         isc_mem_t *mctx = key->mctx;
 470
 471         UNUSED(mctx);
 472
 473         isc_buffer_remainingregion(data, &r);
 474         if (r.length == 0)
 475                 return (ISC_R_SUCCESS);
 476
 477         dsa = DSA_new();
 478         if (dsa == NULL)
 479                 return (ISC_R_NOMEMORY);
 480         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 481
 482         t = (unsigned int) *r.base++;
 483         if (t > 8) {
 484                 DSA_free(dsa);
 485                 return (DST_R_INVALIDPUBLICKEY);
 486         }
 487         p_bytes = 64 + 8 * t;
 488
 489         if (r.length < 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes) {
 490                 DSA_free(dsa);
 491                 return (DST_R_INVALIDPUBLICKEY);
 492         }
 493
 494         dsa->q = BN_bin2bn(r.base, ISC_SHA1_DIGESTLENGTH, NULL);
 495         r.base += ISC_SHA1_DIGESTLENGTH;
 496
 497         dsa->p = BN_bin2bn(r.base, p_bytes, NULL);
 498         r.base += p_bytes;
 499
 500         dsa->g = BN_bin2bn(r.base, p_bytes, NULL);
 501         r.base += p_bytes;
 502
 503         dsa->pub_key = BN_bin2bn(r.base, p_bytes, NULL);
 504         r.base += p_bytes;
 505
 506         key->key_size = p_bytes * 8;
 507
 508         isc_buffer_forward(data, 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes);
 509
 510         key->keydata.dsa = dsa;
 511
 512         return (ISC_R_SUCCESS);
 513 }
 514
 515
 516 static isc_result_t
 517 openssldsa_tofile(const dst_key_t *key, const char *directory) {
 518         int cnt = 0;
 519         DSA *dsa;
 520         dst_private_t priv;
 521         unsigned char bufs[5][128];
 522
 523         if (key->keydata.dsa == NULL)
 524                 return (DST_R_NULLKEY);
 525
 526         dsa = key->keydata.dsa;
 527
 528         priv.elements[cnt].tag = TAG_DSA_PRIME;
 529         priv.elements[cnt].length = BN_num_bytes(dsa->p);
 530         BN_bn2bin(dsa->p, bufs[cnt]);
 531         priv.elements[cnt].data = bufs[cnt];
 532         cnt++;
 533
 534         priv.elements[cnt].tag = TAG_DSA_SUBPRIME;
 535         priv.elements[cnt].length = BN_num_bytes(dsa->q);
 536         BN_bn2bin(dsa->q, bufs[cnt]);
 537         priv.elements[cnt].data = bufs[cnt];
 538         cnt++;
 539
 540         priv.elements[cnt].tag = TAG_DSA_BASE;
 541         priv.elements[cnt].length = BN_num_bytes(dsa->g);
 542         BN_bn2bin(dsa->g, bufs[cnt]);
 543         priv.elements[cnt].data = bufs[cnt];
 544         cnt++;
 545
 546         priv.elements[cnt].tag = TAG_DSA_PRIVATE;
 547         priv.elements[cnt].length = BN_num_bytes(dsa->priv_key);
 548         BN_bn2bin(dsa->priv_key, bufs[cnt]);
 549         priv.elements[cnt].data = bufs[cnt];
 550         cnt++;
 551
 552         priv.elements[cnt].tag = TAG_DSA_PUBLIC;
 553         priv.elements[cnt].length = BN_num_bytes(dsa->pub_key);
 554         BN_bn2bin(dsa->pub_key, bufs[cnt]);
 555         priv.elements[cnt].data = bufs[cnt];
 556         cnt++;
 557
 558         priv.nelements = cnt;
 559         return (dst__privstruct_writefile(key, &priv, directory));
 560 }
 561
 562 static isc_result_t
 563 openssldsa_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) {
 564         dst_private_t priv;
 565         isc_result_t ret;
 566         int i;
 567         DSA *dsa = NULL;
 568         isc_mem_t *mctx = key->mctx;
 569 #define DST_RET(a) {ret = a; goto err;}
 570
 571         UNUSED(pub);
 572         /* read private key file */
 573         ret = dst__privstruct_parse(key, DST_ALG_DSA, lexer, mctx, &priv);
 574         if (ret != ISC_R_SUCCESS)
 575                 return (ret);
 576
 577         dsa = DSA_new();
 578         if (dsa == NULL)
 579                 DST_RET(ISC_R_NOMEMORY);
 580         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 581         key->keydata.dsa = dsa;
 582
 583         for (i=0; i < priv.nelements; i++) {
 584                 BIGNUM *bn;
 585                 bn = BN_bin2bn(priv.elements[i].data,
 586                                priv.elements[i].length, NULL);
 587                 if (bn == NULL)
 588                         DST_RET(ISC_R_NOMEMORY);
 589
 590                 switch (priv.elements[i].tag) {
 591                         case TAG_DSA_PRIME:
 592                                 dsa->p = bn;
 593                                 break;
 594                         case TAG_DSA_SUBPRIME:
 595                                 dsa->q = bn;
 596                                 break;
 597                         case TAG_DSA_BASE:
 598                                 dsa->g = bn;
 599                                 break;
 600                         case TAG_DSA_PRIVATE:
 601                                 dsa->priv_key = bn;
 602                                 break;
 603                         case TAG_DSA_PUBLIC:
 604                                 dsa->pub_key = bn;
 605                                 break;
 606                 }
 607         }
 608         dst__privstruct_free(&priv, mctx);
 609
 610         key->key_size = BN_num_bits(dsa->p);
 611
 612         return (ISC_R_SUCCESS);
 613
 614  err:
 615         openssldsa_destroy(key);
 616         dst__privstruct_free(&priv, mctx);
 617         memset(&priv, 0, sizeof(priv));
 618         return (ret);
 619 }
 620
 621 static dst_func_t openssldsa_functions = {
 622         openssldsa_createctx,
 623         openssldsa_destroyctx,
 624         openssldsa_adddata,
 625         openssldsa_sign,
 626         openssldsa_verify,
 627         NULL, /*%< computesecret */
 628         openssldsa_compare,
 629         NULL, /*%< paramcompare */
 630         openssldsa_generate,
 631         openssldsa_isprivate,
 632         openssldsa_destroy,
 633         openssldsa_todns,
 634         openssldsa_fromdns,
 635         openssldsa_tofile,
 636         openssldsa_parse,
 637         NULL, /*%< cleanup */
 638         NULL, /*%< fromlabel */
 639         NULL, /*%< dump */
 640         NULL, /*%< restore */
 641 };
 642
 643 isc_result_t
 644 dst__openssldsa_init(dst_func_t **funcp) {
 645         REQUIRE(funcp != NULL);
 646         if (*funcp == NULL)
 647                 *funcp = &openssldsa_functions;
 648         return (ISC_R_SUCCESS);
 649 }
 650
 651 #else /* OPENSSL */
 652
 653 #include <isc/util.h>
 654
 655 EMPTY_TRANSLATION_UNIT
 656
 657 #endif /* OPENSSL */
 658 /*! \file */