contrib/bind-9.3/lib/dns/openssldsa_link.c

   1 /*
   2  * Portions Copyright (C) 2004  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 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.4.1 2004/12/09 04:07:18 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 == 0)
 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         DSA *dsa;
 175         unsigned char rand_array[ISC_SHA1_DIGESTLENGTH];
 176         isc_result_t result;
 177
 178         UNUSED(unused);
 179
 180         result = dst__entropy_getdata(rand_array, sizeof(rand_array),
 181                                       ISC_FALSE);
 182         if (result != ISC_R_SUCCESS)
 183                 return (result);
 184
 185         dsa = DSA_generate_parameters(key->key_size, rand_array,
 186                                       ISC_SHA1_DIGESTLENGTH, NULL, NULL,
 187                                       NULL, NULL);
 188
 189         if (dsa == NULL)
 190                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 191
 192         if (DSA_generate_key(dsa) == 0) {
 193                 DSA_free(dsa);
 194                 return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
 195         }
 196         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 197
 198         key->opaque = dsa;
 199
 200         return (ISC_R_SUCCESS);
 201 }
 202
 203 static isc_boolean_t
 204 openssldsa_isprivate(const dst_key_t *key) {
 205         DSA *dsa = (DSA *) key->opaque;
 206         return (ISC_TF(dsa != NULL && dsa->priv_key != NULL));
 207 }
 208
 209 static void
 210 openssldsa_destroy(dst_key_t *key) {
 211         DSA *dsa = key->opaque;
 212         DSA_free(dsa);
 213         key->opaque = NULL;
 214 }
 215
 216
 217 static isc_result_t
 218 openssldsa_todns(const dst_key_t *key, isc_buffer_t *data) {
 219         DSA *dsa;
 220         isc_region_t r;
 221         int dnslen;
 222         unsigned int t, p_bytes;
 223
 224         REQUIRE(key->opaque != NULL);
 225
 226         dsa = (DSA *) key->opaque;
 227
 228         isc_buffer_availableregion(data, &r);
 229
 230         t = (BN_num_bytes(dsa->p) - 64) / 8;
 231         if (t > 8)
 232                 return (DST_R_INVALIDPUBLICKEY);
 233         p_bytes = 64 + 8 * t;
 234
 235         dnslen = 1 + (key->key_size * 3)/8 + ISC_SHA1_DIGESTLENGTH;
 236         if (r.length < (unsigned int) dnslen)
 237                 return (ISC_R_NOSPACE);
 238
 239         *r.base++ = t;
 240         BN_bn2bin_fixed(dsa->q, r.base, ISC_SHA1_DIGESTLENGTH);
 241         r.base += ISC_SHA1_DIGESTLENGTH;
 242         BN_bn2bin_fixed(dsa->p, r.base, key->key_size/8);
 243         r.base += p_bytes;
 244         BN_bn2bin_fixed(dsa->g, r.base, key->key_size/8);
 245         r.base += p_bytes;
 246         BN_bn2bin_fixed(dsa->pub_key, r.base, key->key_size/8);
 247         r.base += p_bytes;
 248
 249         isc_buffer_add(data, dnslen);
 250
 251         return (ISC_R_SUCCESS);
 252 }
 253
 254 static isc_result_t
 255 openssldsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
 256         DSA *dsa;
 257         isc_region_t r;
 258         unsigned int t, p_bytes;
 259         isc_mem_t *mctx = key->mctx;
 260
 261         UNUSED(mctx);
 262
 263         isc_buffer_remainingregion(data, &r);
 264         if (r.length == 0)
 265                 return (ISC_R_SUCCESS);
 266
 267         dsa = DSA_new();
 268         if (dsa == NULL)
 269                 return (ISC_R_NOMEMORY);
 270         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 271
 272         t = (unsigned int) *r.base++;
 273         if (t > 8) {
 274                 DSA_free(dsa);
 275                 return (DST_R_INVALIDPUBLICKEY);
 276         }
 277         p_bytes = 64 + 8 * t;
 278
 279         if (r.length < 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes) {
 280                 DSA_free(dsa);
 281                 return (DST_R_INVALIDPUBLICKEY);
 282         }
 283
 284         dsa->q = BN_bin2bn(r.base, ISC_SHA1_DIGESTLENGTH, NULL);
 285         r.base += ISC_SHA1_DIGESTLENGTH;
 286
 287         dsa->p = BN_bin2bn(r.base, p_bytes, NULL);
 288         r.base += p_bytes;
 289
 290         dsa->g = BN_bin2bn(r.base, p_bytes, NULL);
 291         r.base += p_bytes;
 292
 293         dsa->pub_key = BN_bin2bn(r.base, p_bytes, NULL);
 294         r.base += p_bytes;
 295
 296         key->key_size = p_bytes * 8;
 297
 298         isc_buffer_forward(data, 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes);
 299
 300         key->opaque = (void *) dsa;
 301
 302         return (ISC_R_SUCCESS);
 303 }
 304
 305
 306 static isc_result_t
 307 openssldsa_tofile(const dst_key_t *key, const char *directory) {
 308         int cnt = 0;
 309         DSA *dsa;
 310         dst_private_t priv;
 311         unsigned char bufs[5][128];
 312
 313         if (key->opaque == NULL)
 314                 return (DST_R_NULLKEY);
 315
 316         dsa = (DSA *) key->opaque;
 317
 318         priv.elements[cnt].tag = TAG_DSA_PRIME;
 319         priv.elements[cnt].length = BN_num_bytes(dsa->p);
 320         BN_bn2bin(dsa->p, bufs[cnt]);
 321         priv.elements[cnt].data = bufs[cnt];
 322         cnt++;
 323
 324         priv.elements[cnt].tag = TAG_DSA_SUBPRIME;
 325         priv.elements[cnt].length = BN_num_bytes(dsa->q);
 326         BN_bn2bin(dsa->q, bufs[cnt]);
 327         priv.elements[cnt].data = bufs[cnt];
 328         cnt++;
 329
 330         priv.elements[cnt].tag = TAG_DSA_BASE;
 331         priv.elements[cnt].length = BN_num_bytes(dsa->g);
 332         BN_bn2bin(dsa->g, bufs[cnt]);
 333         priv.elements[cnt].data = bufs[cnt];
 334         cnt++;
 335
 336         priv.elements[cnt].tag = TAG_DSA_PRIVATE;
 337         priv.elements[cnt].length = BN_num_bytes(dsa->priv_key);
 338         BN_bn2bin(dsa->priv_key, bufs[cnt]);
 339         priv.elements[cnt].data = bufs[cnt];
 340         cnt++;
 341
 342         priv.elements[cnt].tag = TAG_DSA_PUBLIC;
 343         priv.elements[cnt].length = BN_num_bytes(dsa->pub_key);
 344         BN_bn2bin(dsa->pub_key, bufs[cnt]);
 345         priv.elements[cnt].data = bufs[cnt];
 346         cnt++;
 347
 348         priv.nelements = cnt;
 349         return (dst__privstruct_writefile(key, &priv, directory));
 350 }
 351
 352 static isc_result_t
 353 openssldsa_parse(dst_key_t *key, isc_lex_t *lexer) {
 354         dst_private_t priv;
 355         isc_result_t ret;
 356         int i;
 357         DSA *dsa = NULL;
 358         isc_mem_t *mctx = key->mctx;
 359 #define DST_RET(a) {ret = a; goto err;}
 360
 361         /* read private key file */
 362         ret = dst__privstruct_parse(key, DST_ALG_DSA, lexer, mctx, &priv);
 363         if (ret != ISC_R_SUCCESS)
 364                 return (ret);
 365
 366         dsa = DSA_new();
 367         if (dsa == NULL)
 368                 DST_RET(ISC_R_NOMEMORY);
 369         dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
 370         key->opaque = dsa;
 371
 372         for (i=0; i < priv.nelements; i++) {
 373                 BIGNUM *bn;
 374                 bn = BN_bin2bn(priv.elements[i].data,
 375                                priv.elements[i].length, NULL);
 376                 if (bn == NULL)
 377                         DST_RET(ISC_R_NOMEMORY);
 378
 379                 switch (priv.elements[i].tag) {
 380                         case TAG_DSA_PRIME:
 381                                 dsa->p = bn;
 382                                 break;
 383                         case TAG_DSA_SUBPRIME:
 384                                 dsa->q = bn;
 385                                 break;
 386                         case TAG_DSA_BASE:
 387                                 dsa->g = bn;
 388                                 break;
 389                         case TAG_DSA_PRIVATE:
 390                                 dsa->priv_key = bn;
 391                                 break;
 392                         case TAG_DSA_PUBLIC:
 393                                 dsa->pub_key = bn;
 394                                 break;
 395                 }
 396         }
 397         dst__privstruct_free(&priv, mctx);
 398
 399         key->key_size = BN_num_bits(dsa->p);
 400
 401         return (ISC_R_SUCCESS);
 402
 403  err:
 404         openssldsa_destroy(key);
 405         dst__privstruct_free(&priv, mctx);
 406         memset(&priv, 0, sizeof(priv));
 407         return (ret);
 408 }
 409
 410 static dst_func_t openssldsa_functions = {
 411         openssldsa_createctx,
 412         openssldsa_destroyctx,
 413         openssldsa_adddata,
 414         openssldsa_sign,
 415         openssldsa_verify,
 416         NULL, /* computesecret */
 417         openssldsa_compare,
 418         NULL, /* paramcompare */
 419         openssldsa_generate,
 420         openssldsa_isprivate,
 421         openssldsa_destroy,
 422         openssldsa_todns,
 423         openssldsa_fromdns,
 424         openssldsa_tofile,
 425         openssldsa_parse,
 426         NULL, /* cleanup */
 427 };
 428
 429 isc_result_t
 430 dst__openssldsa_init(dst_func_t **funcp) {
 431         REQUIRE(funcp != NULL);
 432         if (*funcp == NULL)
 433                 *funcp = &openssldsa_functions;
 434         return (ISC_R_SUCCESS);
 435 }
 436
 437 #else /* OPENSSL */
 438
 439 #include <isc/util.h>
 440
 441 EMPTY_TRANSLATION_UNIT
 442
 443 #endif /* OPENSSL */