crypto/dh/dh_pmeth.c

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