crypto/dh/dh_pmeth.c

   1 /*
   2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
   3  * 2006.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stdio.h>
  60 #include "internal/cryptlib.h"
  61 #include <openssl/asn1t.h>
  62 #include <openssl/x509.h>
  63 #include <openssl/evp.h>
  64 #include <openssl/dh.h>
  65 #include <openssl/bn.h>
  66 #ifndef OPENSSL_NO_DSA
  67 # include <openssl/dsa.h>
  68 #endif
  69 #include <openssl/objects.h>
  70 #include "internal/evp_int.h"
  71
  72 /* DH pkey context structure */
  73
  74 typedef struct {
  75     /* Parameter gen parameters */
  76     int prime_len;
  77     int generator;
  78     int use_dsa;
  79     int subprime_len;
  80     /* message digest used for parameter generation */
  81     const EVP_MD *md;
  82     int rfc5114_param;
  83     /* Keygen callback info */
  84     int gentmp[2];
  85     /* KDF (if any) to use for DH */
  86     char kdf_type;
  87     /* OID to use for KDF */
  88     ASN1_OBJECT *kdf_oid;
  89     /* Message digest to use for key derivation */
  90     const EVP_MD *kdf_md;
  91     /* User key material */
  92     unsigned char *kdf_ukm;
  93     size_t kdf_ukmlen;
  94     /* KDF output length */
  95     size_t kdf_outlen;
  96 } DH_PKEY_CTX;
  97
  98 static int pkey_dh_init(EVP_PKEY_CTX *ctx)
  99 {
 100     DH_PKEY_CTX *dctx;
 101
 102     dctx = OPENSSL_zalloc(sizeof(*dctx));
 103     if (!dctx)
 104         return 0;
 105     dctx->prime_len = 1024;
 106     dctx->subprime_len = -1;
 107     dctx->generator = 2;
 108     dctx->kdf_type = EVP_PKEY_DH_KDF_NONE;
 109
 110     ctx->data = dctx;
 111     ctx->keygen_info = dctx->gentmp;
 112     ctx->keygen_info_count = 2;
 113
 114     return 1;
 115 }
 116
 117 static int pkey_dh_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
 118 {
 119     DH_PKEY_CTX *dctx, *sctx;
 120     if (!pkey_dh_init(dst))
 121         return 0;
 122     sctx = src->data;
 123     dctx = dst->data;
 124     dctx->prime_len = sctx->prime_len;
 125     dctx->subprime_len = sctx->subprime_len;
 126     dctx->generator = sctx->generator;
 127     dctx->use_dsa = sctx->use_dsa;
 128     dctx->md = sctx->md;
 129     dctx->rfc5114_param = sctx->rfc5114_param;
 130
 131     dctx->kdf_type = sctx->kdf_type;
 132     dctx->kdf_oid = OBJ_dup(sctx->kdf_oid);
 133     if (!dctx->kdf_oid)
 134         return 0;
 135     dctx->kdf_md = sctx->kdf_md;
 136     if (dctx->kdf_ukm) {
 137         dctx->kdf_ukm = BUF_memdup(sctx->kdf_ukm, sctx->kdf_ukmlen);
 138         dctx->kdf_ukmlen = sctx->kdf_ukmlen;
 139     }
 140     dctx->kdf_outlen = sctx->kdf_outlen;
 141     return 1;
 142 }
 143
 144 static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
 145 {
 146     DH_PKEY_CTX *dctx = ctx->data;
 147     if (dctx) {
 148         OPENSSL_free(dctx->kdf_ukm);
 149         ASN1_OBJECT_free(dctx->kdf_oid);
 150         OPENSSL_free(dctx);
 151     }
 152 }
 153
 154 static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 155 {
 156     DH_PKEY_CTX *dctx = ctx->data;
 157     switch (type) {
 158     case EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN:
 159         if (p1 < 256)
 160             return -2;
 161         dctx->prime_len = p1;
 162         return 1;
 163
 164     case EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN:
 165         if (dctx->use_dsa == 0)
 166             return -2;
 167         dctx->subprime_len = p1;
 168         return 1;
 169
 170     case EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR:
 171         if (dctx->use_dsa)
 172             return -2;
 173         dctx->generator = p1;
 174         return 1;
 175
 176     case EVP_PKEY_CTRL_DH_PARAMGEN_TYPE:
 177 #ifdef OPENSSL_NO_DSA
 178         if (p1 != 0)
 179             return -2;
 180 #else
 181         if (p1 < 0 || p1 > 2)
 182             return -2;
 183 #endif
 184         dctx->use_dsa = p1;
 185         return 1;
 186
 187     case EVP_PKEY_CTRL_DH_RFC5114:
 188         if (p1 < 1 || p1 > 3)
 189             return -2;
 190         dctx->rfc5114_param = p1;
 191         return 1;
 192
 193     case EVP_PKEY_CTRL_PEER_KEY:
 194         /* Default behaviour is OK */
 195         return 1;
 196
 197     case EVP_PKEY_CTRL_DH_KDF_TYPE:
 198         if (p1 == -2)
 199             return dctx->kdf_type;
 200 #ifdef OPENSSL_NO_CMS
 201         if (p1 != EVP_PKEY_DH_KDF_NONE)
 202 #else
 203         if (p1 != EVP_PKEY_DH_KDF_NONE && p1 != EVP_PKEY_DH_KDF_X9_42)
 204 #endif
 205             return -2;
 206         dctx->kdf_type = p1;
 207         return 1;
 208
 209     case EVP_PKEY_CTRL_DH_KDF_MD:
 210         dctx->kdf_md = p2;
 211         return 1;
 212
 213     case EVP_PKEY_CTRL_GET_DH_KDF_MD:
 214         *(const EVP_MD **)p2 = dctx->kdf_md;
 215         return 1;
 216
 217     case EVP_PKEY_CTRL_DH_KDF_OUTLEN:
 218         if (p1 <= 0)
 219             return -2;
 220         dctx->kdf_outlen = (size_t)p1;
 221         return 1;
 222
 223     case EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN:
 224         *(int *)p2 = dctx->kdf_outlen;
 225         return 1;
 226
 227     case EVP_PKEY_CTRL_DH_KDF_UKM:
 228         OPENSSL_free(dctx->kdf_ukm);
 229         dctx->kdf_ukm = p2;
 230         if (p2)
 231             dctx->kdf_ukmlen = p1;
 232         else
 233             dctx->kdf_ukmlen = 0;
 234         return 1;
 235
 236     case EVP_PKEY_CTRL_GET_DH_KDF_UKM:
 237         *(unsigned char **)p2 = dctx->kdf_ukm;
 238         return dctx->kdf_ukmlen;
 239
 240     case EVP_PKEY_CTRL_DH_KDF_OID:
 241         ASN1_OBJECT_free(dctx->kdf_oid);
 242         dctx->kdf_oid = p2;
 243         return 1;
 244
 245     case EVP_PKEY_CTRL_GET_DH_KDF_OID:
 246         *(ASN1_OBJECT **)p2 = dctx->kdf_oid;
 247         return 1;
 248
 249     default:
 250         return -2;
 251
 252     }
 253 }
 254
 255 static int pkey_dh_ctrl_str(EVP_PKEY_CTX *ctx,
 256                             const char *type, const char *value)
 257 {
 258     if (strcmp(type, "dh_paramgen_prime_len") == 0) {
 259         int len;
 260         len = atoi(value);
 261         return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len);
 262     }
 263     if (strcmp(type, "dh_rfc5114") == 0) {
 264         DH_PKEY_CTX *dctx = ctx->data;
 265         int len;
 266         len = atoi(value);
 267         if (len < 0 || len > 3)
 268             return -2;
 269         dctx->rfc5114_param = len;
 270         return 1;
 271     }
 272     if (strcmp(type, "dh_paramgen_generator") == 0) {
 273         int len;
 274         len = atoi(value);
 275         return EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, len);
 276     }
 277     if (strcmp(type, "dh_paramgen_subprime_len") == 0) {
 278         int len;
 279         len = atoi(value);
 280         return EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len);
 281     }
 282     if (strcmp(type, "dh_paramgen_type") == 0) {
 283         int typ;
 284         typ = atoi(value);
 285         return EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ);
 286     }
 287     return -2;
 288 }
 289
 290 #ifndef OPENSSL_NO_DSA
 291
 292 extern int dsa_builtin_paramgen(DSA *ret, size_t bits, size_t qbits,
 293                                 const EVP_MD *evpmd,
 294                                 const unsigned char *seed_in, size_t seed_len,
 295                                 unsigned char *seed_out, int *counter_ret,
 296                                 unsigned long *h_ret, BN_GENCB *cb);
 297
 298 extern int dsa_builtin_paramgen2(DSA *ret, size_t L, size_t N,
 299                                  const EVP_MD *evpmd,
 300                                  const unsigned char *seed_in,
 301                                  size_t seed_len, int idx,
 302                                  unsigned char *seed_out, int *counter_ret,
 303                                  unsigned long *h_ret, BN_GENCB *cb);
 304
 305 static DSA *dsa_dh_generate(DH_PKEY_CTX *dctx, BN_GENCB *pcb)
 306 {
 307     DSA *ret;
 308     int rv = 0;
 309     int prime_len = dctx->prime_len;
 310     int subprime_len = dctx->subprime_len;
 311     const EVP_MD *md = dctx->md;
 312     if (dctx->use_dsa > 2)
 313         return NULL;
 314     ret = DSA_new();
 315     if (!ret)
 316         return NULL;
 317     if (subprime_len == -1) {
 318         if (prime_len >= 2048)
 319             subprime_len = 256;
 320         else
 321             subprime_len = 160;
 322     }
 323     if (md == NULL) {
 324         if (prime_len >= 2048)
 325             md = EVP_sha256();
 326         else
 327             md = EVP_sha1();
 328     }
 329     if (dctx->use_dsa == 1)
 330         rv = dsa_builtin_paramgen(ret, prime_len, subprime_len, md,
 331                                   NULL, 0, NULL, NULL, NULL, pcb);
 332     else if (dctx->use_dsa == 2)
 333         rv = dsa_builtin_paramgen2(ret, prime_len, subprime_len, md,
 334                                    NULL, 0, -1, NULL, NULL, NULL, pcb);
 335     if (rv <= 0) {
 336         DSA_free(ret);
 337         return NULL;
 338     }
 339     return ret;
 340 }
 341
 342 #endif
 343
 344 static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 345 {
 346     DH *dh = NULL;
 347     DH_PKEY_CTX *dctx = ctx->data;
 348     BN_GENCB *pcb;
 349     int ret;
 350     if (dctx->rfc5114_param) {
 351         switch (dctx->rfc5114_param) {
 352         case 1:
 353             dh = DH_get_1024_160();
 354             break;
 355
 356         case 2:
 357             dh = DH_get_2048_224();
 358             break;
 359
 360         case 3:
 361             dh = DH_get_2048_256();
 362             break;
 363
 364         default:
 365             return -2;
 366         }
 367         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 368         return 1;
 369     }
 370
 371     if (ctx->pkey_gencb) {
 372         pcb = BN_GENCB_new();
 373         evp_pkey_set_cb_translate(pcb, ctx);
 374     } else
 375         pcb = NULL;
 376 #ifndef OPENSSL_NO_DSA
 377     if (dctx->use_dsa) {
 378         DSA *dsa_dh;
 379         dsa_dh = dsa_dh_generate(dctx, pcb);
 380         BN_GENCB_free(pcb);
 381         if (!dsa_dh)
 382             return 0;
 383         dh = DSA_dup_DH(dsa_dh);
 384         DSA_free(dsa_dh);
 385         if (!dh)
 386             return 0;
 387         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 388         return 1;
 389     }
 390 #endif
 391     dh = DH_new();
 392     if (!dh) {
 393         BN_GENCB_free(pcb);
 394         return 0;
 395     }
 396     ret = DH_generate_parameters_ex(dh,
 397                                     dctx->prime_len, dctx->generator, pcb);
 398     BN_GENCB_free(pcb);
 399     if (ret)
 400         EVP_PKEY_assign_DH(pkey, dh);
 401     else
 402         DH_free(dh);
 403     return ret;
 404 }
 405
 406 static int pkey_dh_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 407 {
 408     DH *dh = NULL;
 409     if (ctx->pkey == NULL) {
 410         DHerr(DH_F_PKEY_DH_KEYGEN, DH_R_NO_PARAMETERS_SET);
 411         return 0;
 412     }
 413     dh = DH_new();
 414     if (!dh)
 415         return 0;
 416     EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, dh);
 417     /* Note: if error return, pkey is freed by parent routine */
 418     if (!EVP_PKEY_copy_parameters(pkey, ctx->pkey))
 419         return 0;
 420     return DH_generate_key(pkey->pkey.dh);
 421 }
 422
 423 static int pkey_dh_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 424                           size_t *keylen)
 425 {
 426     int ret;
 427     DH *dh;
 428     DH_PKEY_CTX *dctx = ctx->data;
 429     BIGNUM *dhpub;
 430     if (!ctx->pkey || !ctx->peerkey) {
 431         DHerr(DH_F_PKEY_DH_DERIVE, DH_R_KEYS_NOT_SET);
 432         return 0;
 433     }
 434     dh = ctx->pkey->pkey.dh;
 435     dhpub = ctx->peerkey->pkey.dh->pub_key;
 436     if (dctx->kdf_type == EVP_PKEY_DH_KDF_NONE) {
 437         if (key == NULL) {
 438             *keylen = DH_size(dh);
 439             return 1;
 440         }
 441         ret = DH_compute_key(key, dhpub, dh);
 442         if (ret < 0)
 443             return ret;
 444         *keylen = ret;
 445         return 1;
 446     }
 447 #ifndef OPENSSL_NO_CMS
 448     else if (dctx->kdf_type == EVP_PKEY_DH_KDF_X9_42) {
 449
 450         unsigned char *Z = NULL;
 451         size_t Zlen = 0;
 452         if (!dctx->kdf_outlen || !dctx->kdf_oid)
 453             return 0;
 454         if (key == NULL) {
 455             *keylen = dctx->kdf_outlen;
 456             return 1;
 457         }
 458         if (*keylen != dctx->kdf_outlen)
 459             return 0;
 460         ret = 0;
 461         Zlen = DH_size(dh);
 462         Z = OPENSSL_malloc(Zlen);
 463         if (!Z) {
 464             goto err;
 465         }
 466         if (DH_compute_key_padded(Z, dhpub, dh) <= 0)
 467             goto err;
 468         if (!DH_KDF_X9_42(key, *keylen, Z, Zlen, dctx->kdf_oid,
 469                           dctx->kdf_ukm, dctx->kdf_ukmlen, dctx->kdf_md))
 470             goto err;
 471         *keylen = dctx->kdf_outlen;
 472         ret = 1;
 473  err:
 474         OPENSSL_clear_free(Z, Zlen);
 475         return ret;
 476     }
 477 #endif
 478     return 0;
 479 }
 480
 481 const EVP_PKEY_METHOD dh_pkey_meth = {
 482     EVP_PKEY_DH,
 483     0,
 484     pkey_dh_init,
 485     pkey_dh_copy,
 486     pkey_dh_cleanup,
 487
 488     0,
 489     pkey_dh_paramgen,
 490
 491     0,
 492     pkey_dh_keygen,
 493
 494     0,
 495     0,
 496
 497     0,
 498     0,
 499
 500     0, 0,
 501
 502     0, 0, 0, 0,
 503
 504     0, 0,
 505
 506     0, 0,
 507
 508     0,
 509     pkey_dh_derive,
 510
 511     pkey_dh_ctrl,
 512     pkey_dh_ctrl_str
 513 };
 514
 515 const EVP_PKEY_METHOD dhx_pkey_meth = {
 516     EVP_PKEY_DHX,
 517     0,
 518     pkey_dh_init,
 519     pkey_dh_copy,
 520     pkey_dh_cleanup,
 521
 522     0,
 523     pkey_dh_paramgen,
 524
 525     0,
 526     pkey_dh_keygen,
 527
 528     0,
 529     0,
 530
 531     0,
 532     0,
 533
 534     0, 0,
 535
 536     0, 0, 0, 0,
 537
 538     0, 0,
 539
 540     0, 0,
 541
 542     0,
 543     pkey_dh_derive,
 544
 545     pkey_dh_ctrl,
 546     pkey_dh_ctrl_str
 547 };