contrib/bind9/lib/dns/openssldsa_link.c

   1 /*
   2  * Portions Copyright (C) 2004-2007  Internet Systems Consortium, Inc. ("ISC")
   3  * Portions Copyright (C) 1999-2002  Internet Software Consortium.
   4  * Portions Copyright (C) 1995-2000 by Network Associates, Inc.
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
  11  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
  13  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  16  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /* $Id: openssldsa_link.c,v 1.1.6.9.28.1 2008/12/24 00:21:22 marka Exp $ */
  20
  21 #ifdef OPENSSL
  22
  23 #include <config.h>
  24
  25 #include <string.h>
  26
  27 #include <isc/entropy.h>
  28 #include <isc/mem.h>
  29 #include <isc/sha1.h>
  30 #include <isc/util.h>
  31
  32 #include <dst/result.h>
  33
  34 #include "dst_internal.h"
  35 #include "dst_openssl.h"
  36 #include "dst_parse.h"
  37
  38 #include <openssl/dsa.h>
  39
  40 static isc_result_t openssldsa_todns(const dst_key_t *key, isc_buffer_t *data);
  41
  42 static isc_result_t
  43 openssldsa_createctx(dst_key_t *key, dst_context_t *dctx) {
  44         isc_sha1_t *sha1ctx;
  45
  46         UNUSED(key);
  47
  48         sha1ctx = isc_mem_get(dctx->mctx, sizeof(isc_sha1_t));
  49         isc_sha1_init(sha1ctx);
  50         dctx->opaque = sha1ctx;
  51         return (ISC_R_SUCCESS);
  52 }
  53
  54 static void
  55 openssldsa_destroyctx(dst_context_t *dctx) {
  56         isc_sha1_t *sha1ctx = dctx->opaque;
  57
  58         if (sha1ctx != NULL) {
  59                 isc_sha1_invalidate(sha1ctx);
  60                 isc_mem_put(dctx->mctx, sha1ctx, sizeof(isc_sha1_t));
  61                 dctx->opaque = NULL;
  62         }
  63 }
  64
  65 static isc_result_t
  66 openssldsa_adddata(dst_context_t *dctx, const isc_region_t *data) {
  67         isc_sha1_t *sha1ctx = dctx->opaque;
  68
  69         isc_sha1_update(sha1ctx, data->base, data->length);
  70         return (ISC_R_SUCCESS);
  71 }
  72
  73 static int
  74 BN_bn2bin_fixed(BIGNUM *bn, unsigned char *buf, int size) {
  75         int bytes = size - BN_num_bytes(bn);
  76         while (bytes-- > 0)
  77                 *buf++ = 0;
  78         BN_bn2bin(bn, buf);
  79         return (size);
  80 }
  81
  82 static isc_result_t
  83 openssldsa_sign(dst_context_t *dctx, isc_buffer_t *sig) {
  84         isc_sha1_t *sha1ctx = dctx->opaque;
  85         dst_key_t *key = dctx->key;
  86         DSA *dsa = key->opaque;
  87         DSA_SIG *dsasig;
  88         isc_region_t r;
  89         unsigned char digest[ISC_SHA1_DIGESTLENGTH];
  90
  91         isc_buffer_availableregion(sig, &r);
  92         if (r.length < ISC_SHA1_DIGESTLENGTH * 2 + 1)
  93                 return (ISC_R_NOSPACE);
  94
  95         isc_sha1_final(sha1ctx, digest);
  96
  97         dsasig = DSA_do_sign(digest, ISC_SHA1_DIGESTLENGTH, dsa);
  98         if (dsasig == NULL)
  99                 return (dst__openssl_toresult(DST_R_SIGNFAILURE));
 100
 101         *r.base++ = (key->key_size - 512)/64;
 102         BN_bn2bin_fixed(dsasig->r, r.base, ISC_SHA1_DIGESTLENGTH);
 103         r.base += ISC_SHA1_DIGESTLENGTH;
 104         BN_bn2bin_fixed(dsasig->s, r.base, ISC_SHA1_DIGESTLENGTH);
 105         r.base += ISC_SHA1_DIGESTLENGTH;
 106         DSA_SIG_free(dsasig);
 107         isc_buffer_add(sig, ISC_SHA1_DIGESTLENGTH * 2 + 1);
 108
 109         return (ISC_R_SUCCESS);
 110 }
 111
 112 static isc_result_t
 113 openssldsa_verify(dst_context_t *dctx, const isc_region_t *sig) {
 114         isc_sha1_t *sha1ctx = dctx->opaque;
 115         dst_key_t *key = dctx->key;
 116         DSA *dsa = key->opaque;
 117         DSA_SIG *dsasig;
 118         int status = 0;
 119         unsigned char digest[ISC_SHA1_DIGESTLENGTH];
 120         unsigned char *cp = sig->base;
 121
 122         isc_sha1_final(sha1ctx, digest);
 123
 124         if (sig->length < 2 * ISC_SHA1_DIGESTLENGTH + 1)
 125                 return (DST_R_VERIFYFAILURE);
 126
 127         cp++;   /*%< Skip T */
 128         dsasig = DSA_SIG_new();
 129         dsasig->r = BN_bin2bn(cp, ISC_SHA1_DIGESTLENGTH, NULL);
 130         cp += ISC_SHA1_DIGESTLENGTH;
 131         dsasig->s = BN_bin2bn(cp, ISC_SHA1_DIGESTLENGTH, NULL);
 132         cp += ISC_SHA1_DIGESTLENGTH;
 133
 134         status = DSA_do_verify(digest, ISC_SHA1_DIGESTLENGTH, dsasig, dsa);
 135         DSA_SIG_free(dsasig);
 136         if (status != 1)
 137                 return (dst__openssl_toresult(DST_R_VERIFYFAILURE));
 138
 139         return (ISC_R_SUCCESS);
 140 }
 141
 142 static isc_boolean_t
 143 openssldsa_compare(const dst_key_t *key1, const dst_key_t *key2) {
 144         int status;
 145         DSA *dsa1, *dsa2;
 146
 147         dsa1 = (DSA *) key1->opaque;
 148         dsa2 = (DSA *) key2->opaque;
 149
 150         if (dsa1 == NULL && dsa2 == NULL)
 151                 return (ISC_TRUE);
 152         else if (dsa1 == NULL || dsa2 == NULL)
 153                 return (ISC_FALSE);
 154
 155         status = BN_cmp(dsa1->p, dsa2->p) ||
 156                  BN_cmp(dsa1->q, dsa2->q) ||
 157                  BN_cmp(dsa1->g, dsa2->g) ||
 158                  BN_cmp(dsa1->pub_key, dsa2->pub_key);
 159
 160         if (status != 0)
 161                 return (ISC_FALSE);
 162
 163         if (dsa1->priv_key != NULL || dsa2->priv_key != NULL) {
 164                 if (dsa1->priv_key == NULL || dsa2->priv_key == NULL)
 165                         return (ISC_FALSE);
 166                 if (BN_cmp(dsa1->priv_key, dsa2->priv_key))
 167                         return (ISC_FALSE);
 168         }
 169         return (ISC_TRUE);
 170 }
 171
 172 static isc_result_t
 173 openssldsa_generate(dst_key_t *key, int unused) {
 174 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 175         BN_GENCB cb;
 176 #endif
 177         DSA *dsa;
 178         unsigned char rand_array[ISC_SHA1_DIGESTLENGTH];
 179         isc_result_t result;
 180
 181         UNUSED(unused);
 182
 183         result = dst__entropy_getdata(rand_array, sizeof(rand_array),
 184                                       ISC_FALSE);
 185         if (result != ISC_R_SUCCESS)
 186                 return (result);
 187
 188 #if OPENSSL_VERSION_NUMBER > 0x00908000L
 189         dsa = DSA_new();
 190         if (dsa == NULL)
 191                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 192
 193         BN_GENCB_set_old(&cb, NULL, NULL);
 194
 195         if (!DSA_generate_parameters_ex(dsa, key->key_size, rand_array,
 196                                         ISC_SHA1_DIGESTLENGTH,  NULL, NULL,
 197                                         &cb))
 198         {
 199                 DSA_free(dsa);
 200                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 201         }
 202 #else
 203         dsa = DSA_generate_parameters(key->key_size, rand_array,
 204                                       ISC_SHA1_DIGESTLENGTH, NULL, NULL,
 205                                       NULL, NULL);
 206         if (dsa == NULL)
 207                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 208 #endif
 209
 210         if (DSA_generate_key(dsa) == 0) {
 211                 DSA_free(dsa);
 212                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 213         }
 214         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 215
 216         key->opaque = dsa;
 217
 218         return (ISC_R_SUCCESS);
 219 }
 220
 221 static isc_boolean_t
 222 openssldsa_isprivate(const dst_key_t *key) {
 223         DSA *dsa = (DSA *) key->opaque;
 224         return (ISC_TF(dsa != NULL && dsa->priv_key != NULL));
 225 }
 226
 227 static void
 228 openssldsa_destroy(dst_key_t *key) {
 229         DSA *dsa = key->opaque;
 230         DSA_free(dsa);
 231         key->opaque = NULL;
 232 }
 233
 234
 235 static isc_result_t
 236 openssldsa_todns(const dst_key_t *key, isc_buffer_t *data) {
 237         DSA *dsa;
 238         isc_region_t r;
 239         int dnslen;
 240         unsigned int t, p_bytes;
 241
 242         REQUIRE(key->opaque != NULL);
 243
 244         dsa = (DSA *) key->opaque;
 245
 246         isc_buffer_availableregion(data, &r);
 247
 248         t = (BN_num_bytes(dsa->p) - 64) / 8;
 249         if (t > 8)
 250                 return (DST_R_INVALIDPUBLICKEY);
 251         p_bytes = 64 + 8 * t;
 252
 253         dnslen = 1 + (key->key_size * 3)/8 + ISC_SHA1_DIGESTLENGTH;
 254         if (r.length < (unsigned int) dnslen)
 255                 return (ISC_R_NOSPACE);
 256
 257         *r.base++ = t;
 258         BN_bn2bin_fixed(dsa->q, r.base, ISC_SHA1_DIGESTLENGTH);
 259         r.base += ISC_SHA1_DIGESTLENGTH;
 260         BN_bn2bin_fixed(dsa->p, r.base, key->key_size/8);
 261         r.base += p_bytes;
 262         BN_bn2bin_fixed(dsa->g, r.base, key->key_size/8);
 263         r.base += p_bytes;
 264         BN_bn2bin_fixed(dsa->pub_key, r.base, key->key_size/8);
 265         r.base += p_bytes;
 266
 267         isc_buffer_add(data, dnslen);
 268
 269         return (ISC_R_SUCCESS);
 270 }
 271
 272 static isc_result_t
 273 openssldsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
 274         DSA *dsa;
 275         isc_region_t r;
 276         unsigned int t, p_bytes;
 277         isc_mem_t *mctx = key->mctx;
 278
 279         UNUSED(mctx);
 280
 281         isc_buffer_remainingregion(data, &r);
 282         if (r.length == 0)
 283                 return (ISC_R_SUCCESS);
 284
 285         dsa = DSA_new();
 286         if (dsa == NULL)
 287                 return (ISC_R_NOMEMORY);
 288         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 289
 290         t = (unsigned int) *r.base++;
 291         if (t > 8) {
 292                 DSA_free(dsa);
 293                 return (DST_R_INVALIDPUBLICKEY);
 294         }
 295         p_bytes = 64 + 8 * t;
 296
 297         if (r.length < 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes) {
 298                 DSA_free(dsa);
 299                 return (DST_R_INVALIDPUBLICKEY);
 300         }
 301
 302         dsa->q = BN_bin2bn(r.base, ISC_SHA1_DIGESTLENGTH, NULL);
 303         r.base += ISC_SHA1_DIGESTLENGTH;
 304
 305         dsa->p = BN_bin2bn(r.base, p_bytes, NULL);
 306         r.base += p_bytes;
 307
 308         dsa->g = BN_bin2bn(r.base, p_bytes, NULL);
 309         r.base += p_bytes;
 310
 311         dsa->pub_key = BN_bin2bn(r.base, p_bytes, NULL);
 312         r.base += p_bytes;
 313
 314         key->key_size = p_bytes * 8;
 315
 316         isc_buffer_forward(data, 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes);
 317
 318         key->opaque = (void *) dsa;
 319
 320         return (ISC_R_SUCCESS);
 321 }
 322
 323
 324 static isc_result_t
 325 openssldsa_tofile(const dst_key_t *key, const char *directory) {
 326         int cnt = 0;
 327         DSA *dsa;
 328         dst_private_t priv;
 329         unsigned char bufs[5][128];
 330
 331         if (key->opaque == NULL)
 332                 return (DST_R_NULLKEY);
 333
 334         dsa = (DSA *) key->opaque;
 335
 336         priv.elements[cnt].tag = TAG_DSA_PRIME;
 337         priv.elements[cnt].length = BN_num_bytes(dsa->p);
 338         BN_bn2bin(dsa->p, bufs[cnt]);
 339         priv.elements[cnt].data = bufs[cnt];
 340         cnt++;
 341
 342         priv.elements[cnt].tag = TAG_DSA_SUBPRIME;
 343         priv.elements[cnt].length = BN_num_bytes(dsa->q);
 344         BN_bn2bin(dsa->q, bufs[cnt]);
 345         priv.elements[cnt].data = bufs[cnt];
 346         cnt++;
 347
 348         priv.elements[cnt].tag = TAG_DSA_BASE;
 349         priv.elements[cnt].length = BN_num_bytes(dsa->g);
 350         BN_bn2bin(dsa->g, bufs[cnt]);
 351         priv.elements[cnt].data = bufs[cnt];
 352         cnt++;
 353
 354         priv.elements[cnt].tag = TAG_DSA_PRIVATE;
 355         priv.elements[cnt].length = BN_num_bytes(dsa->priv_key);
 356         BN_bn2bin(dsa->priv_key, bufs[cnt]);
 357         priv.elements[cnt].data = bufs[cnt];
 358         cnt++;
 359
 360         priv.elements[cnt].tag = TAG_DSA_PUBLIC;
 361         priv.elements[cnt].length = BN_num_bytes(dsa->pub_key);
 362         BN_bn2bin(dsa->pub_key, bufs[cnt]);
 363         priv.elements[cnt].data = bufs[cnt];
 364         cnt++;
 365
 366         priv.nelements = cnt;
 367         return (dst__privstruct_writefile(key, &priv, directory));
 368 }
 369
 370 static isc_result_t
 371 openssldsa_parse(dst_key_t *key, isc_lex_t *lexer) {
 372         dst_private_t priv;
 373         isc_result_t ret;
 374         int i;
 375         DSA *dsa = NULL;
 376         isc_mem_t *mctx = key->mctx;
 377 #define DST_RET(a) {ret = a; goto err;}
 378
 379         /* read private key file */
 380         ret = dst__privstruct_parse(key, DST_ALG_DSA, lexer, mctx, &priv);
 381         if (ret != ISC_R_SUCCESS)
 382                 return (ret);
 383
 384         dsa = DSA_new();
 385         if (dsa == NULL)
 386                 DST_RET(ISC_R_NOMEMORY);
 387         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 388         key->opaque = dsa;
 389
 390         for (i=0; i < priv.nelements; i++) {
 391                 BIGNUM *bn;
 392                 bn = BN_bin2bn(priv.elements[i].data,
 393                                priv.elements[i].length, NULL);
 394                 if (bn == NULL)
 395                         DST_RET(ISC_R_NOMEMORY);
 396
 397                 switch (priv.elements[i].tag) {
 398                         case TAG_DSA_PRIME:
 399                                 dsa->p = bn;
 400                                 break;
 401                         case TAG_DSA_SUBPRIME:
 402                                 dsa->q = bn;
 403                                 break;
 404                         case TAG_DSA_BASE:
 405                                 dsa->g = bn;
 406                                 break;
 407                         case TAG_DSA_PRIVATE:
 408                                 dsa->priv_key = bn;
 409                                 break;
 410                         case TAG_DSA_PUBLIC:
 411                                 dsa->pub_key = bn;
 412                                 break;
 413                 }
 414         }
 415         dst__privstruct_free(&priv, mctx);
 416
 417         key->key_size = BN_num_bits(dsa->p);
 418
 419         return (ISC_R_SUCCESS);
 420
 421  err:
 422         openssldsa_destroy(key);
 423         dst__privstruct_free(&priv, mctx);
 424         memset(&priv, 0, sizeof(priv));
 425         return (ret);
 426 }
 427
 428 static dst_func_t openssldsa_functions = {
 429         openssldsa_createctx,
 430         openssldsa_destroyctx,
 431         openssldsa_adddata,
 432         openssldsa_sign,
 433         openssldsa_verify,
 434         NULL, /*%< computesecret */
 435         openssldsa_compare,
 436         NULL, /*%< paramcompare */
 437         openssldsa_generate,
 438         openssldsa_isprivate,
 439         openssldsa_destroy,
 440         openssldsa_todns,
 441         openssldsa_fromdns,
 442         openssldsa_tofile,
 443         openssldsa_parse,
 444         NULL, /*%< cleanup */
 445 };
 446
 447 isc_result_t
 448 dst__openssldsa_init(dst_func_t **funcp) {
 449         REQUIRE(funcp != NULL);
 450         if (*funcp == NULL)
 451                 *funcp = &openssldsa_functions;
 452         return (ISC_R_SUCCESS);
 453 }
 454
 455 #else /* OPENSSL */
 456
 457 #include <isc/util.h>
 458
 459 EMPTY_TRANSLATION_UNIT
 460
 461 #endif /* OPENSSL */
 462 /*! \file */