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 "dh_locl.h"
  65 #include <openssl/bn.h>
  66 #include <openssl/dsa.h>
  67 #include <openssl/objects.h>
  68 #include "internal/evp_int.h"
  69
  70 /* DH pkey context structure */
  71
  72 typedef struct {
  73     /* Parameter gen parameters */
  74     int prime_len;
  75     int generator;
  76     int use_dsa;
  77     int subprime_len;
  78     /* message digest used for parameter generation */
  79     const EVP_MD *md;
  80     int rfc5114_param;
  81     /* Keygen callback info */
  82     int gentmp[2];
  83     /* KDF (if any) to use for DH */
  84     char kdf_type;
  85     /* OID to use for KDF */
  86     ASN1_OBJECT *kdf_oid;
  87     /* Message digest to use for key derivation */
  88     const EVP_MD *kdf_md;
  89     /* User key material */
  90     unsigned char *kdf_ukm;
  91     size_t kdf_ukmlen;
  92     /* KDF output length */
  93     size_t kdf_outlen;
  94 } DH_PKEY_CTX;
  95
  96 static int pkey_dh_init(EVP_PKEY_CTX *ctx)
  97 {
  98     DH_PKEY_CTX *dctx;
  99
 100     dctx = OPENSSL_zalloc(sizeof(*dctx));
 101     if (dctx == NULL)
 102         return 0;
 103     dctx->prime_len = 1024;
 104     dctx->subprime_len = -1;
 105     dctx->generator = 2;
 106     dctx->kdf_type = EVP_PKEY_DH_KDF_NONE;
 107
 108     ctx->data = dctx;
 109     ctx->keygen_info = dctx->gentmp;
 110     ctx->keygen_info_count = 2;
 111
 112     return 1;
 113 }
 114
 115 static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
 116 {
 117     DH_PKEY_CTX *dctx = ctx->data;
 118     if (dctx != NULL) {
 119         OPENSSL_free(dctx->kdf_ukm);
 120         ASN1_OBJECT_free(dctx->kdf_oid);
 121         OPENSSL_free(dctx);
 122     }
 123 }
 124
 125
 126 static int pkey_dh_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
 127 {
 128     DH_PKEY_CTX *dctx, *sctx;
 129     if (!pkey_dh_init(dst))
 130         return 0;
 131     sctx = src->data;
 132     dctx = dst->data;
 133     dctx->prime_len = sctx->prime_len;
 134     dctx->subprime_len = sctx->subprime_len;
 135     dctx->generator = sctx->generator;
 136     dctx->use_dsa = sctx->use_dsa;
 137     dctx->md = sctx->md;
 138     dctx->rfc5114_param = sctx->rfc5114_param;
 139
 140     dctx->kdf_type = sctx->kdf_type;
 141     dctx->kdf_oid = OBJ_dup(sctx->kdf_oid);
 142     if (dctx->kdf_oid == NULL)
 143         return 0;
 144     dctx->kdf_md = sctx->kdf_md;
 145     if (sctx->kdf_ukm != NULL) {
 146         dctx->kdf_ukm = OPENSSL_memdup(sctx->kdf_ukm, sctx->kdf_ukmlen);
 147         if (dctx->kdf_ukm == NULL)
 148           return 0;
 149         dctx->kdf_ukmlen = sctx->kdf_ukmlen;
 150     }
 151     dctx->kdf_outlen = sctx->kdf_outlen;
 152     return 1;
 153 }
 154
 155 static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 156 {
 157     DH_PKEY_CTX *dctx = ctx->data;
 158     switch (type) {
 159     case EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN:
 160         if (p1 < 256)
 161             return -2;
 162         dctx->prime_len = p1;
 163         return 1;
 164
 165     case EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN:
 166         if (dctx->use_dsa == 0)
 167             return -2;
 168         dctx->subprime_len = p1;
 169         return 1;
 170
 171     case EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR:
 172         if (dctx->use_dsa)
 173             return -2;
 174         dctx->generator = p1;
 175         return 1;
 176
 177     case EVP_PKEY_CTRL_DH_PARAMGEN_TYPE:
 178 #ifdef OPENSSL_NO_DSA
 179         if (p1 != 0)
 180             return -2;
 181 #else
 182         if (p1 < 0 || p1 > 2)
 183             return -2;
 184 #endif
 185         dctx->use_dsa = p1;
 186         return 1;
 187
 188     case EVP_PKEY_CTRL_DH_RFC5114:
 189         if (p1 < 1 || p1 > 3)
 190             return -2;
 191         dctx->rfc5114_param = p1;
 192         return 1;
 193
 194     case EVP_PKEY_CTRL_PEER_KEY:
 195         /* Default behaviour is OK */
 196         return 1;
 197
 198     case EVP_PKEY_CTRL_DH_KDF_TYPE:
 199         if (p1 == -2)
 200             return dctx->kdf_type;
 201 #ifdef OPENSSL_NO_CMS
 202         if (p1 != EVP_PKEY_DH_KDF_NONE)
 203 #else
 204         if (p1 != EVP_PKEY_DH_KDF_NONE && p1 != EVP_PKEY_DH_KDF_X9_42)
 205 #endif
 206             return -2;
 207         dctx->kdf_type = p1;
 208         return 1;
 209
 210     case EVP_PKEY_CTRL_DH_KDF_MD:
 211         dctx->kdf_md = p2;
 212         return 1;
 213
 214     case EVP_PKEY_CTRL_GET_DH_KDF_MD:
 215         *(const EVP_MD **)p2 = dctx->kdf_md;
 216         return 1;
 217
 218     case EVP_PKEY_CTRL_DH_KDF_OUTLEN:
 219         if (p1 <= 0)
 220             return -2;
 221         dctx->kdf_outlen = (size_t)p1;
 222         return 1;
 223
 224     case EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN:
 225         *(int *)p2 = dctx->kdf_outlen;
 226         return 1;
 227
 228     case EVP_PKEY_CTRL_DH_KDF_UKM:
 229         OPENSSL_free(dctx->kdf_ukm);
 230         dctx->kdf_ukm = p2;
 231         if (p2)
 232             dctx->kdf_ukmlen = p1;
 233         else
 234             dctx->kdf_ukmlen = 0;
 235         return 1;
 236
 237     case EVP_PKEY_CTRL_GET_DH_KDF_UKM:
 238         *(unsigned char **)p2 = dctx->kdf_ukm;
 239         return dctx->kdf_ukmlen;
 240
 241     case EVP_PKEY_CTRL_DH_KDF_OID:
 242         ASN1_OBJECT_free(dctx->kdf_oid);
 243         dctx->kdf_oid = p2;
 244         return 1;
 245
 246     case EVP_PKEY_CTRL_GET_DH_KDF_OID:
 247         *(ASN1_OBJECT **)p2 = dctx->kdf_oid;
 248         return 1;
 249
 250     default:
 251         return -2;
 252
 253     }
 254 }
 255
 256 static int pkey_dh_ctrl_str(EVP_PKEY_CTX *ctx,
 257                             const char *type, const char *value)
 258 {
 259     if (strcmp(type, "dh_paramgen_prime_len") == 0) {
 260         int len;
 261         len = atoi(value);
 262         return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len);
 263     }
 264     if (strcmp(type, "dh_rfc5114") == 0) {
 265         DH_PKEY_CTX *dctx = ctx->data;
 266         int len;
 267         len = atoi(value);
 268         if (len < 0 || len > 3)
 269             return -2;
 270         dctx->rfc5114_param = len;
 271         return 1;
 272     }
 273     if (strcmp(type, "dh_paramgen_generator") == 0) {
 274         int len;
 275         len = atoi(value);
 276         return EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, len);
 277     }
 278     if (strcmp(type, "dh_paramgen_subprime_len") == 0) {
 279         int len;
 280         len = atoi(value);
 281         return EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len);
 282     }
 283     if (strcmp(type, "dh_paramgen_type") == 0) {
 284         int typ;
 285         typ = atoi(value);
 286         return EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ);
 287     }
 288     return -2;
 289 }
 290
 291 #ifndef OPENSSL_NO_DSA
 292
 293 extern int dsa_builtin_paramgen(DSA *ret, size_t bits, size_t qbits,
 294                                 const EVP_MD *evpmd,
 295                                 const unsigned char *seed_in, size_t seed_len,
 296                                 unsigned char *seed_out, int *counter_ret,
 297                                 unsigned long *h_ret, BN_GENCB *cb);
 298
 299 extern int dsa_builtin_paramgen2(DSA *ret, size_t L, size_t N,
 300                                  const EVP_MD *evpmd,
 301                                  const unsigned char *seed_in,
 302                                  size_t seed_len, int idx,
 303                                  unsigned char *seed_out, int *counter_ret,
 304                                  unsigned long *h_ret, BN_GENCB *cb);
 305
 306 static DSA *dsa_dh_generate(DH_PKEY_CTX *dctx, BN_GENCB *pcb)
 307 {
 308     DSA *ret;
 309     int rv = 0;
 310     int prime_len = dctx->prime_len;
 311     int subprime_len = dctx->subprime_len;
 312     const EVP_MD *md = dctx->md;
 313     if (dctx->use_dsa > 2)
 314         return NULL;
 315     ret = DSA_new();
 316     if (ret == NULL)
 317         return NULL;
 318     if (subprime_len == -1) {
 319         if (prime_len >= 2048)
 320             subprime_len = 256;
 321         else
 322             subprime_len = 160;
 323     }
 324     if (md == NULL) {
 325         if (prime_len >= 2048)
 326             md = EVP_sha256();
 327         else
 328             md = EVP_sha1();
 329     }
 330     if (dctx->use_dsa == 1)
 331         rv = dsa_builtin_paramgen(ret, prime_len, subprime_len, md,
 332                                   NULL, 0, NULL, NULL, NULL, pcb);
 333     else if (dctx->use_dsa == 2)
 334         rv = dsa_builtin_paramgen2(ret, prime_len, subprime_len, md,
 335                                    NULL, 0, -1, NULL, NULL, NULL, pcb);
 336     if (rv <= 0) {
 337         DSA_free(ret);
 338         return NULL;
 339     }
 340     return ret;
 341 }
 342
 343 #endif
 344
 345 static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 346 {
 347     DH *dh = NULL;
 348     DH_PKEY_CTX *dctx = ctx->data;
 349     BN_GENCB *pcb;
 350     int ret;
 351     if (dctx->rfc5114_param) {
 352         switch (dctx->rfc5114_param) {
 353         case 1:
 354             dh = DH_get_1024_160();
 355             break;
 356
 357         case 2:
 358             dh = DH_get_2048_224();
 359             break;
 360
 361         case 3:
 362             dh = DH_get_2048_256();
 363             break;
 364
 365         default:
 366             return -2;
 367         }
 368         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 369         return 1;
 370     }
 371
 372     if (ctx->pkey_gencb) {
 373         pcb = BN_GENCB_new();
 374         if (pcb == NULL)
 375             return 0;
 376         evp_pkey_set_cb_translate(pcb, ctx);
 377     } else
 378         pcb = NULL;
 379 #ifndef OPENSSL_NO_DSA
 380     if (dctx->use_dsa) {
 381         DSA *dsa_dh;
 382         dsa_dh = dsa_dh_generate(dctx, pcb);
 383         BN_GENCB_free(pcb);
 384         if (dsa_dh == NULL)
 385             return 0;
 386         dh = DSA_dup_DH(dsa_dh);
 387         DSA_free(dsa_dh);
 388         if (!dh)
 389             return 0;
 390         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 391         return 1;
 392     }
 393 #endif
 394     dh = DH_new();
 395     if (dh == NULL) {
 396         BN_GENCB_free(pcb);
 397         return 0;
 398     }
 399     ret = DH_generate_parameters_ex(dh,
 400                                     dctx->prime_len, dctx->generator, pcb);
 401     BN_GENCB_free(pcb);
 402     if (ret)
 403         EVP_PKEY_assign_DH(pkey, dh);
 404     else
 405         DH_free(dh);
 406     return ret;
 407 }
 408
 409 static int pkey_dh_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 410 {
 411     DH *dh = NULL;
 412     if (ctx->pkey == NULL) {
 413         DHerr(DH_F_PKEY_DH_KEYGEN, DH_R_NO_PARAMETERS_SET);
 414         return 0;
 415     }
 416     dh = DH_new();
 417     if (dh == NULL)
 418         return 0;
 419     EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, dh);
 420     /* Note: if error return, pkey is freed by parent routine */
 421     if (!EVP_PKEY_copy_parameters(pkey, ctx->pkey))
 422         return 0;
 423     return DH_generate_key(pkey->pkey.dh);
 424 }
 425
 426 static int pkey_dh_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 427                           size_t *keylen)
 428 {
 429     int ret;
 430     DH *dh;
 431     DH_PKEY_CTX *dctx = ctx->data;
 432     BIGNUM *dhpub;
 433     if (!ctx->pkey || !ctx->peerkey) {
 434         DHerr(DH_F_PKEY_DH_DERIVE, DH_R_KEYS_NOT_SET);
 435         return 0;
 436     }
 437     dh = ctx->pkey->pkey.dh;
 438     dhpub = ctx->peerkey->pkey.dh->pub_key;
 439     if (dctx->kdf_type == EVP_PKEY_DH_KDF_NONE) {
 440         if (key == NULL) {
 441             *keylen = DH_size(dh);
 442             return 1;
 443         }
 444         ret = DH_compute_key(key, dhpub, dh);
 445         if (ret < 0)
 446             return ret;
 447         *keylen = ret;
 448         return 1;
 449     }
 450 #ifndef OPENSSL_NO_CMS
 451     else if (dctx->kdf_type == EVP_PKEY_DH_KDF_X9_42) {
 452
 453         unsigned char *Z = NULL;
 454         size_t Zlen = 0;
 455         if (!dctx->kdf_outlen || !dctx->kdf_oid)
 456             return 0;
 457         if (key == NULL) {
 458             *keylen = dctx->kdf_outlen;
 459             return 1;
 460         }
 461         if (*keylen != dctx->kdf_outlen)
 462             return 0;
 463         ret = 0;
 464         Zlen = DH_size(dh);
 465         Z = OPENSSL_malloc(Zlen);
 466         if (Z == NULL) {
 467             goto err;
 468         }
 469         if (DH_compute_key_padded(Z, dhpub, dh) <= 0)
 470             goto err;
 471         if (!DH_KDF_X9_42(key, *keylen, Z, Zlen, dctx->kdf_oid,
 472                           dctx->kdf_ukm, dctx->kdf_ukmlen, dctx->kdf_md))
 473             goto err;
 474         *keylen = dctx->kdf_outlen;
 475         ret = 1;
 476  err:
 477         OPENSSL_clear_free(Z, Zlen);
 478         return ret;
 479     }
 480 #endif
 481     return 0;
 482 }
 483
 484 const EVP_PKEY_METHOD dh_pkey_meth = {
 485     EVP_PKEY_DH,
 486     0,
 487     pkey_dh_init,
 488     pkey_dh_copy,
 489     pkey_dh_cleanup,
 490
 491     0,
 492     pkey_dh_paramgen,
 493
 494     0,
 495     pkey_dh_keygen,
 496
 497     0,
 498     0,
 499
 500     0,
 501     0,
 502
 503     0, 0,
 504
 505     0, 0, 0, 0,
 506
 507     0, 0,
 508
 509     0, 0,
 510
 511     0,
 512     pkey_dh_derive,
 513
 514     pkey_dh_ctrl,
 515     pkey_dh_ctrl_str
 516 };
 517
 518 const EVP_PKEY_METHOD dhx_pkey_meth = {
 519     EVP_PKEY_DHX,
 520     0,
 521     pkey_dh_init,
 522     pkey_dh_copy,
 523     pkey_dh_cleanup,
 524
 525     0,
 526     pkey_dh_paramgen,
 527
 528     0,
 529     pkey_dh_keygen,
 530
 531     0,
 532     0,
 533
 534     0,
 535     0,
 536
 537     0, 0,
 538
 539     0, 0, 0, 0,
 540
 541     0, 0,
 542
 543     0, 0,
 544
 545     0,
 546     pkey_dh_derive,
 547
 548     pkey_dh_ctrl,
 549     pkey_dh_ctrl_str
 550 };