contrib/bind9/lib/dns/openssldsa_link.c

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