external/bsd/bind/dist/lib/dns/openssldsa_link.c

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