crypto/dh/dh_pmeth.c

   1 /*
   2  * Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * DH & DSA low level APIs are deprecated for public use, but still ok for
  12  * internal use.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include <stdio.h>
  17 #include "internal/cryptlib.h"
  18 #include <openssl/asn1t.h>
  19 #include <openssl/x509.h>
  20 #include <openssl/evp.h>
  21 #include "dh_local.h"
  22 #include <openssl/bn.h>
  23 #include <openssl/dsa.h>
  24 #include <openssl/objects.h>
  25 #include "crypto/evp.h"
  26
  27 /* DH pkey context structure */
  28
  29 typedef struct {
  30     /* Parameter gen parameters */
  31     int prime_len;
  32     int generator;
  33     int paramgen_type;
  34     int subprime_len;
  35     int pad;
  36     /* message digest used for parameter generation */
  37     const EVP_MD *md;
  38     int rfc5114_param;
  39     int param_nid;
  40     /* Keygen callback info */
  41     int gentmp[2];
  42     /* KDF (if any) to use for DH */
  43     char kdf_type;
  44     /* OID to use for KDF */
  45     ASN1_OBJECT *kdf_oid;
  46     /* Message digest to use for key derivation */
  47     const EVP_MD *kdf_md;
  48     /* User key material */
  49     unsigned char *kdf_ukm;
  50     size_t kdf_ukmlen;
  51     /* KDF output length */
  52     size_t kdf_outlen;
  53 } DH_PKEY_CTX;
  54
  55 static int pkey_dh_init(EVP_PKEY_CTX *ctx)
  56 {
  57     DH_PKEY_CTX *dctx;
  58
  59     if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL) {
  60         DHerr(DH_F_PKEY_DH_INIT, ERR_R_MALLOC_FAILURE);
  61         return 0;
  62     }
  63     dctx->prime_len = 2048;
  64     dctx->subprime_len = -1;
  65     dctx->generator = 2;
  66     dctx->kdf_type = EVP_PKEY_DH_KDF_NONE;
  67
  68     ctx->data = dctx;
  69     ctx->keygen_info = dctx->gentmp;
  70     ctx->keygen_info_count = 2;
  71
  72     return 1;
  73 }
  74
  75 static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
  76 {
  77     DH_PKEY_CTX *dctx = ctx->data;
  78
  79     if (dctx != NULL) {
  80         OPENSSL_free(dctx->kdf_ukm);
  81         ASN1_OBJECT_free(dctx->kdf_oid);
  82         OPENSSL_free(dctx);
  83     }
  84 }
  85
  86
  87 static int pkey_dh_copy(EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src)
  88 {
  89     DH_PKEY_CTX *dctx, *sctx;
  90
  91     if (!pkey_dh_init(dst))
  92         return 0;
  93     sctx = src->data;
  94     dctx = dst->data;
  95     dctx->prime_len = sctx->prime_len;
  96     dctx->subprime_len = sctx->subprime_len;
  97     dctx->generator = sctx->generator;
  98     dctx->paramgen_type = sctx->paramgen_type;
  99     dctx->pad = sctx->pad;
 100     dctx->md = sctx->md;
 101     dctx->rfc5114_param = sctx->rfc5114_param;
 102     dctx->param_nid = sctx->param_nid;
 103
 104     dctx->kdf_type = sctx->kdf_type;
 105     dctx->kdf_oid = OBJ_dup(sctx->kdf_oid);
 106     if (dctx->kdf_oid == NULL)
 107         return 0;
 108     dctx->kdf_md = sctx->kdf_md;
 109     if (sctx->kdf_ukm != NULL) {
 110         dctx->kdf_ukm = OPENSSL_memdup(sctx->kdf_ukm, sctx->kdf_ukmlen);
 111         if (dctx->kdf_ukm == NULL)
 112           return 0;
 113         dctx->kdf_ukmlen = sctx->kdf_ukmlen;
 114     }
 115     dctx->kdf_outlen = sctx->kdf_outlen;
 116     return 1;
 117 }
 118
 119 static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 120 {
 121     DH_PKEY_CTX *dctx = ctx->data;
 122     switch (type) {
 123     case EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN:
 124         if (p1 < 256)
 125             return -2;
 126         dctx->prime_len = p1;
 127         return 1;
 128
 129     case EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN:
 130         if (dctx->paramgen_type == DH_PARAMGEN_TYPE_GENERATOR)
 131             return -2;
 132         dctx->subprime_len = p1;
 133         return 1;
 134
 135     case EVP_PKEY_CTRL_DH_PAD:
 136         dctx->pad = p1;
 137         return 1;
 138
 139     case EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR:
 140         if (dctx->paramgen_type != DH_PARAMGEN_TYPE_GENERATOR)
 141             return -2;
 142         dctx->generator = p1;
 143         return 1;
 144
 145     case EVP_PKEY_CTRL_DH_PARAMGEN_TYPE:
 146 #ifdef OPENSSL_NO_DSA
 147         if (p1 != DH_PARAMGEN_TYPE_GENERATOR)
 148             return -2;
 149 #else
 150         if (p1 < 0 || p1 > 2)
 151             return -2;
 152 #endif
 153         dctx->paramgen_type = p1;
 154         return 1;
 155
 156     case EVP_PKEY_CTRL_DH_RFC5114:
 157         if (p1 < 1 || p1 > 3 || dctx->param_nid != NID_undef)
 158             return -2;
 159         dctx->rfc5114_param = p1;
 160         return 1;
 161
 162     case EVP_PKEY_CTRL_DH_NID:
 163         if (p1 <= 0 || dctx->rfc5114_param != 0)
 164             return -2;
 165         dctx->param_nid = p1;
 166         return 1;
 167
 168     case EVP_PKEY_CTRL_PEER_KEY:
 169         /* Default behaviour is OK */
 170         return 1;
 171
 172     case EVP_PKEY_CTRL_DH_KDF_TYPE:
 173         if (p1 == -2)
 174             return dctx->kdf_type;
 175         if (p1 != EVP_PKEY_DH_KDF_NONE && p1 != EVP_PKEY_DH_KDF_X9_42)
 176             return -2;
 177         dctx->kdf_type = p1;
 178         return 1;
 179
 180     case EVP_PKEY_CTRL_DH_KDF_MD:
 181         dctx->kdf_md = p2;
 182         return 1;
 183
 184     case EVP_PKEY_CTRL_GET_DH_KDF_MD:
 185         *(const EVP_MD **)p2 = dctx->kdf_md;
 186         return 1;
 187
 188     case EVP_PKEY_CTRL_DH_KDF_OUTLEN:
 189         if (p1 <= 0)
 190             return -2;
 191         dctx->kdf_outlen = (size_t)p1;
 192         return 1;
 193
 194     case EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN:
 195         *(int *)p2 = dctx->kdf_outlen;
 196         return 1;
 197
 198     case EVP_PKEY_CTRL_DH_KDF_UKM:
 199         OPENSSL_free(dctx->kdf_ukm);
 200         dctx->kdf_ukm = p2;
 201         if (p2)
 202             dctx->kdf_ukmlen = p1;
 203         else
 204             dctx->kdf_ukmlen = 0;
 205         return 1;
 206
 207     case EVP_PKEY_CTRL_GET_DH_KDF_UKM:
 208         *(unsigned char **)p2 = dctx->kdf_ukm;
 209         return dctx->kdf_ukmlen;
 210
 211     case EVP_PKEY_CTRL_DH_KDF_OID:
 212         ASN1_OBJECT_free(dctx->kdf_oid);
 213         dctx->kdf_oid = p2;
 214         return 1;
 215
 216     case EVP_PKEY_CTRL_GET_DH_KDF_OID:
 217         *(ASN1_OBJECT **)p2 = dctx->kdf_oid;
 218         return 1;
 219
 220     default:
 221         return -2;
 222
 223     }
 224 }
 225
 226 static int pkey_dh_ctrl_str(EVP_PKEY_CTX *ctx,
 227                             const char *type, const char *value)
 228 {
 229     if (strcmp(type, "dh_paramgen_prime_len") == 0) {
 230         int len;
 231         len = atoi(value);
 232         return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len);
 233     }
 234     if (strcmp(type, "dh_rfc5114") == 0) {
 235         DH_PKEY_CTX *dctx = ctx->data;
 236         int len;
 237         len = atoi(value);
 238         if (len < 0 || len > 3)
 239             return -2;
 240         dctx->rfc5114_param = len;
 241         return 1;
 242     }
 243     if (strcmp(type, "dh_param") == 0) {
 244         DH_PKEY_CTX *dctx = ctx->data;
 245         int nid = OBJ_sn2nid(value);
 246
 247         if (nid == NID_undef) {
 248             DHerr(DH_F_PKEY_DH_CTRL_STR, DH_R_INVALID_PARAMETER_NAME);
 249             return -2;
 250         }
 251         dctx->param_nid = nid;
 252         return 1;
 253     }
 254     if (strcmp(type, "dh_paramgen_generator") == 0) {
 255         int len;
 256         len = atoi(value);
 257         return EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, len);
 258     }
 259     if (strcmp(type, "dh_paramgen_subprime_len") == 0) {
 260         int len;
 261         len = atoi(value);
 262         return EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len);
 263     }
 264     if (strcmp(type, "dh_paramgen_type") == 0) {
 265         int typ;
 266         typ = atoi(value);
 267         return EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ);
 268     }
 269     if (strcmp(type, "dh_pad") == 0) {
 270         int pad;
 271         pad = atoi(value);
 272         return EVP_PKEY_CTX_set_dh_pad(ctx, pad);
 273     }
 274     return -2;
 275 }
 276
 277 static DH *ffc_params_generate(OPENSSL_CTX *libctx, DH_PKEY_CTX *dctx,
 278                                BN_GENCB *pcb)
 279 {
 280     DH *ret;
 281     int rv = 0;
 282     int res;
 283     int prime_len = dctx->prime_len;
 284     int subprime_len = dctx->subprime_len;
 285
 286     if (dctx->paramgen_type > DH_PARAMGEN_TYPE_FIPS_186_4)
 287         return NULL;
 288     ret = DH_new();
 289     if (ret == NULL)
 290         return NULL;
 291
 292     if (subprime_len == -1) {
 293         if (prime_len >= 2048)
 294             subprime_len = 256;
 295         else
 296             subprime_len = 160;
 297     }
 298
 299     if (dctx->md != NULL)
 300         ffc_set_digest(&ret->params, EVP_MD_name(dctx->md), NULL);
 301
 302 # ifndef FIPS_MODULE
 303     if (dctx->paramgen_type == DH_PARAMGEN_TYPE_FIPS_186_2)
 304         rv = ffc_params_FIPS186_2_generate(libctx, &ret->params,
 305                                            FFC_PARAM_TYPE_DH,
 306                                            prime_len, subprime_len, &res, pcb);
 307     else
 308 # endif
 309     /* For FIPS we always use the DH_PARAMGEN_TYPE_FIPS_186_4 generator */
 310     if (dctx->paramgen_type >= DH_PARAMGEN_TYPE_FIPS_186_2)
 311         rv = ffc_params_FIPS186_4_generate(libctx, &ret->params,
 312                                            FFC_PARAM_TYPE_DH,
 313                                            prime_len, subprime_len, &res, pcb);
 314     if (rv <= 0) {
 315         DH_free(ret);
 316         return NULL;
 317     }
 318     return ret;
 319 }
 320
 321 static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx,
 322                             EVP_PKEY *pkey)
 323 {
 324     DH *dh = NULL;
 325     DH_PKEY_CTX *dctx = ctx->data;
 326     BN_GENCB *pcb = NULL;
 327     int ret;
 328
 329     /*
 330      * Look for a safe prime group for key establishment. Which uses
 331      * either RFC_3526 (modp_XXXX) or RFC_7919 (ffdheXXXX).
 332      */
 333     if (dctx->param_nid != NID_undef) {
 334         if ((dh = DH_new_by_nid(dctx->param_nid)) == NULL)
 335             return 0;
 336         EVP_PKEY_assign(pkey, EVP_PKEY_DH, dh);
 337         return 1;
 338     }
 339
 340 #ifndef FIPS_MODULE
 341     if (dctx->rfc5114_param) {
 342         switch (dctx->rfc5114_param) {
 343         case 1:
 344             dh = DH_get_1024_160();
 345             break;
 346
 347         case 2:
 348             dh = DH_get_2048_224();
 349             break;
 350
 351         case 3:
 352             dh = DH_get_2048_256();
 353             break;
 354
 355         default:
 356             return -2;
 357         }
 358         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 359         return 1;
 360     }
 361 #endif /* FIPS_MODULE */
 362
 363     if (ctx->pkey_gencb != NULL) {
 364         pcb = BN_GENCB_new();
 365         if (pcb == NULL)
 366             return 0;
 367         evp_pkey_set_cb_translate(pcb, ctx);
 368     }
 369 # ifdef FIPS_MODULE
 370     dctx->paramgen_type = DH_PARAMGEN_TYPE_FIPS_186_4;
 371 # endif /* FIPS_MODULE */
 372     if (dctx->paramgen_type >= DH_PARAMGEN_TYPE_FIPS_186_2) {
 373         dh = ffc_params_generate(NULL, dctx, pcb);
 374         BN_GENCB_free(pcb);
 375         if (dh == NULL)
 376             return 0;
 377         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
 378         return 1;
 379     }
 380     dh = DH_new();
 381     if (dh == NULL) {
 382         BN_GENCB_free(pcb);
 383         return 0;
 384     }
 385     ret = DH_generate_parameters_ex(dh,
 386                                     dctx->prime_len, dctx->generator, pcb);
 387     BN_GENCB_free(pcb);
 388     if (ret)
 389         EVP_PKEY_assign_DH(pkey, dh);
 390     else
 391         DH_free(dh);
 392     return ret;
 393 }
 394
 395 static int pkey_dh_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 396 {
 397     DH_PKEY_CTX *dctx = ctx->data;
 398     DH *dh = NULL;
 399
 400     if (ctx->pkey == NULL && dctx->param_nid == NID_undef) {
 401         DHerr(DH_F_PKEY_DH_KEYGEN, DH_R_NO_PARAMETERS_SET);
 402         return 0;
 403     }
 404     if (dctx->param_nid != NID_undef)
 405         dh = DH_new_by_nid(dctx->param_nid);
 406     else
 407         dh = DH_new();
 408     if (dh == NULL)
 409         return 0;
 410     EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, dh);
 411     /* Note: if error return, pkey is freed by parent routine */
 412     if (ctx->pkey != NULL && !EVP_PKEY_copy_parameters(pkey, ctx->pkey))
 413         return 0;
 414     return DH_generate_key(pkey->pkey.dh);
 415 }
 416
 417 static int pkey_dh_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 418                           size_t *keylen)
 419 {
 420     int ret;
 421     DH *dh;
 422     DH_PKEY_CTX *dctx = ctx->data;
 423     BIGNUM *dhpub;
 424     if (!ctx->pkey || !ctx->peerkey) {
 425         DHerr(DH_F_PKEY_DH_DERIVE, DH_R_KEYS_NOT_SET);
 426         return 0;
 427     }
 428     dh = ctx->pkey->pkey.dh;
 429     dhpub = ctx->peerkey->pkey.dh->pub_key;
 430     if (dctx->kdf_type == EVP_PKEY_DH_KDF_NONE) {
 431         if (key == NULL) {
 432             *keylen = DH_size(dh);
 433             return 1;
 434         }
 435         if (dctx->pad)
 436             ret = DH_compute_key_padded(key, dhpub, dh);
 437         else
 438             ret = DH_compute_key(key, dhpub, dh);
 439         if (ret < 0)
 440             return ret;
 441         *keylen = ret;
 442         return 1;
 443     }
 444     else if (dctx->kdf_type == EVP_PKEY_DH_KDF_X9_42) {
 445
 446         unsigned char *Z = NULL;
 447         size_t Zlen = 0;
 448         if (!dctx->kdf_outlen || !dctx->kdf_oid)
 449             return 0;
 450         if (key == NULL) {
 451             *keylen = dctx->kdf_outlen;
 452             return 1;
 453         }
 454         if (*keylen != dctx->kdf_outlen)
 455             return 0;
 456         ret = 0;
 457         Zlen = DH_size(dh);
 458         Z = OPENSSL_malloc(Zlen);
 459         if (Z == NULL) {
 460             goto err;
 461         }
 462         if (DH_compute_key_padded(Z, dhpub, dh) <= 0)
 463             goto err;
 464         if (!DH_KDF_X9_42(key, *keylen, Z, Zlen, dctx->kdf_oid,
 465                           dctx->kdf_ukm, dctx->kdf_ukmlen, dctx->kdf_md))
 466             goto err;
 467         *keylen = dctx->kdf_outlen;
 468         ret = 1;
 469  err:
 470         OPENSSL_clear_free(Z, Zlen);
 471         return ret;
 472     }
 473     return 0;
 474 }
 475
 476 static const EVP_PKEY_METHOD dh_pkey_meth = {
 477     EVP_PKEY_DH,
 478     0,
 479     pkey_dh_init,
 480     pkey_dh_copy,
 481     pkey_dh_cleanup,
 482
 483     0,
 484     pkey_dh_paramgen,
 485
 486     0,
 487     pkey_dh_keygen,
 488
 489     0,
 490     0,
 491
 492     0,
 493     0,
 494
 495     0, 0,
 496
 497     0, 0, 0, 0,
 498
 499     0, 0,
 500
 501     0, 0,
 502
 503     0,
 504     pkey_dh_derive,
 505
 506     pkey_dh_ctrl,
 507     pkey_dh_ctrl_str
 508 };
 509
 510 const EVP_PKEY_METHOD *dh_pkey_method(void)
 511 {
 512     return &dh_pkey_meth;
 513 }
 514
 515 static 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 };
 548
 549 const EVP_PKEY_METHOD *dhx_pkey_method(void)
 550 {
 551     return &dhx_pkey_meth;
 552 }