crypto/evp/dh_ctrl.c

   1 /*
   2  * Copyright 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 #include <stdio.h>
  11 #include <string.h>
  12 #include <openssl/core_names.h>
  13 #include <openssl/params.h>
  14 #include <openssl/err.h>
  15 #include <openssl/dh.h>
  16 #include "crypto/dh.h"
  17 #include "crypto/evp.h"
  18
  19 static int dh_paramgen_check(EVP_PKEY_CTX *ctx)
  20 {
  21     if (ctx == NULL || !EVP_PKEY_CTX_IS_GEN_OP(ctx)) {
  22         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
  23         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
  24         return -2;
  25     }
  26     /* If key type not DH return error */
  27     if (ctx->pmeth != NULL
  28         && ctx->pmeth->pkey_id != EVP_PKEY_DH
  29         && ctx->pmeth->pkey_id != EVP_PKEY_DHX)
  30         return -1;
  31     return 1;
  32 }
  33
  34 static int dh_param_derive_check(EVP_PKEY_CTX *ctx)
  35 {
  36     if (ctx == NULL || !EVP_PKEY_CTX_IS_DERIVE_OP(ctx)) {
  37         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
  38         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
  39         return -2;
  40     }
  41     /* If key type not DH return error */
  42     if (ctx->pmeth != NULL
  43         && ctx->pmeth->pkey_id != EVP_PKEY_DH
  44         && ctx->pmeth->pkey_id != EVP_PKEY_DHX)
  45         return -1;
  46     return 1;
  47 }
  48
  49 int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex)
  50 {
  51     int ret;
  52     OSSL_PARAM params[2], *p = params;
  53
  54     if ((ret = dh_paramgen_check(ctx)) <= 0)
  55         return ret;
  56
  57     *p++ = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX, &gindex);
  58     *p = OSSL_PARAM_construct_end();
  59
  60     return EVP_PKEY_CTX_set_params(ctx, params);
  61 }
  62
  63 int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
  64                                       const unsigned char *seed,
  65                                       size_t seedlen)
  66 {
  67     int ret;
  68     OSSL_PARAM params[2], *p = params;
  69
  70     if ((ret = dh_paramgen_check(ctx)) <= 0)
  71         return ret;
  72
  73     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
  74                                              (void *)seed, seedlen);
  75     *p = OSSL_PARAM_construct_end();
  76
  77     return EVP_PKEY_CTX_set_params(ctx, params);
  78 }
  79
  80 int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int typ)
  81 {
  82     int ret;
  83     OSSL_PARAM params[2], *p = params;
  84     const char *name;
  85
  86     if ((ret = dh_paramgen_check(ctx)) <= 0)
  87         return ret;
  88
  89     /* TODO(3.0): Remove this eventually when no more legacy */
  90     if (ctx->op.keymgmt.genctx == NULL)
  91         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
  92                                  EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, typ, NULL);
  93
  94     name = dh_gen_type_id2name(typ);
  95     if (name == NULL)
  96         return 0;
  97     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
  98                                             (char *) name, 0);
  99     *p = OSSL_PARAM_construct_end();
 100
 101     return EVP_PKEY_CTX_set_params(ctx, params);
 102 }
 103
 104 int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int pbits)
 105 {
 106     int ret;
 107     OSSL_PARAM params[2], *p = params;
 108     size_t bits = pbits;
 109
 110     if ((ret = dh_paramgen_check(ctx)) <= 0)
 111         return ret;
 112
 113     /* TODO(3.0): Remove this eventually when no more legacy */
 114     if (ctx->op.keymgmt.genctx == NULL)
 115         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
 116                                  EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, pbits,
 117                                  NULL);
 118     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_FFC_PBITS, &bits);
 119     *p = OSSL_PARAM_construct_end();
 120     return EVP_PKEY_CTX_set_params(ctx, params);
 121 }
 122
 123 int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int qbits)
 124 {
 125     int ret;
 126     OSSL_PARAM params[2], *p = params;
 127     size_t bits2 = qbits;
 128
 129     if ((ret = dh_paramgen_check(ctx)) <= 0)
 130         return ret;
 131
 132     /* TODO(3.0): Remove this eventually when no more legacy */
 133     if (ctx->op.keymgmt.genctx == NULL)
 134         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
 135                                  EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, qbits,
 136                                  NULL);
 137     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_FFC_QBITS, &bits2);
 138     *p = OSSL_PARAM_construct_end();
 139
 140     return EVP_PKEY_CTX_set_params(ctx, params);
 141 }
 142
 143 int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen)
 144 {
 145     int ret;
 146     OSSL_PARAM params[2], *p = params;
 147
 148     if ((ret = dh_paramgen_check(ctx)) <= 0)
 149         return ret;
 150
 151     /* TODO(3.0): Remove this eventually when no more legacy */
 152     if (ctx->op.keymgmt.genctx == NULL)
 153         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
 154                                  EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL);
 155     *p++ = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_DH_GENERATOR, &gen);
 156     *p = OSSL_PARAM_construct_end();
 157
 158     return EVP_PKEY_CTX_set_params(ctx, params);
 159 }
 160
 161 int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int gen)
 162 {
 163     int ret;
 164     OSSL_PARAM params[2], *p = params;
 165     const char *name;
 166
 167     if ((ret = dh_paramgen_check(ctx)) <= 0)
 168         return ret;
 169
 170     /* TODO(3.0): Remove this eventually when no more legacy */
 171     if (ctx->op.keymgmt.genctx == NULL)
 172         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN,
 173                                  EVP_PKEY_CTRL_DH_RFC5114, gen, NULL);
 174     name = ossl_ffc_named_group_get_name(ossl_ffc_uid_to_dh_named_group(gen));
 175     if (name == NULL)
 176         return 0;
 177
 178     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
 179                                             (void *)name, 0);
 180     *p = OSSL_PARAM_construct_end();
 181     return EVP_PKEY_CTX_set_params(ctx, params);
 182 }
 183
 184 int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int gen)
 185 {
 186     return EVP_PKEY_CTX_set_dh_rfc5114(ctx, gen);
 187 }
 188
 189 int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid)
 190 {
 191     int ret;
 192     OSSL_PARAM params[2], *p = params;
 193     const char *name;
 194
 195     if ((ret = dh_paramgen_check(ctx)) <= 0)
 196         return ret;
 197
 198     /* TODO(3.0): Remove this eventually when no more legacy */
 199     if (ctx->op.keymgmt.genctx == NULL)
 200         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH,
 201                                  EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
 202                                  EVP_PKEY_CTRL_DH_NID, nid, NULL);
 203     name = ossl_ffc_named_group_get_name(ossl_ffc_uid_to_dh_named_group(nid));
 204     if (name == NULL)
 205         return 0;
 206
 207     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
 208                                             (void *)name, 0);
 209     *p = OSSL_PARAM_construct_end();
 210     return EVP_PKEY_CTX_set_params(ctx, params);
 211 }
 212
 213 int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad)
 214 {
 215     OSSL_PARAM dh_pad_params[2];
 216     unsigned int upad = pad;
 217
 218     /* We use EVP_PKEY_CTX_ctrl return values */
 219     if (ctx == NULL || !EVP_PKEY_CTX_IS_DERIVE_OP(ctx)) {
 220         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 221         return -2;
 222     }
 223
 224     /* TODO(3.0): Remove this eventually when no more legacy */
 225     if (ctx->op.kex.exchprovctx == NULL)
 226         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_DERIVE,
 227                                  EVP_PKEY_CTRL_DH_PAD, pad, NULL);
 228
 229     dh_pad_params[0] = OSSL_PARAM_construct_uint(OSSL_EXCHANGE_PARAM_PAD, &upad);
 230     dh_pad_params[1] = OSSL_PARAM_construct_end();
 231
 232     return EVP_PKEY_CTX_set_params(ctx, dh_pad_params);
 233 }
 234
 235 int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf)
 236 {
 237     int ret;
 238     const char *kdf_type;
 239     OSSL_PARAM params[2], *p = params;
 240
 241     ret = dh_param_derive_check(ctx);
 242     if (ret != 1)
 243         return ret;
 244
 245     /* TODO(3.0): Remove this eventually when no more legacy */
 246     if (ctx->op.kex.exchprovctx == NULL)
 247         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 248                                  EVP_PKEY_CTRL_DH_KDF_TYPE, kdf, NULL);
 249     switch (kdf) {
 250         case EVP_PKEY_DH_KDF_NONE:
 251             kdf_type = "";
 252             break;
 253         case EVP_PKEY_DH_KDF_X9_42:
 254             kdf_type = OSSL_KDF_NAME_X942KDF_ASN1;
 255             break;
 256         default:
 257             return -2;
 258     }
 259     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
 260                                             /*
 261                                              * Cast away the const. This is read
 262                                              * only so should be safe
 263                                              */
 264                                             (char *)kdf_type, 0);
 265     *p = OSSL_PARAM_construct_end();
 266
 267     ret = evp_pkey_ctx_set_params_strict(ctx, params);
 268     if (ret == -2) {
 269         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 270         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 271         return -2;
 272     }
 273
 274     return ret;
 275 }
 276
 277 int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx)
 278 {
 279     int ret;
 280     char kdf_type[80]; /* 80 should be big enough */
 281     OSSL_PARAM params[2], *p = params;
 282
 283     ret = dh_param_derive_check(ctx);
 284     if (ret != 1)
 285         return ret;
 286
 287     /* TODO(3.0): Remove this eventually when no more legacy */
 288     if (ctx->op.kex.exchprovctx == NULL)
 289         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 290                                  EVP_PKEY_CTRL_DH_KDF_TYPE, -2, NULL);
 291     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
 292                                             kdf_type, sizeof(kdf_type));
 293     *p = OSSL_PARAM_construct_end();
 294
 295     ret = evp_pkey_ctx_get_params_strict(ctx, params);
 296     if (ret == -2) {
 297         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 298         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 299         return -2;
 300     } else if (ret != 1) {
 301         return -1;
 302     }
 303
 304     if (kdf_type[0] == '\0')
 305         return EVP_PKEY_DH_KDF_NONE;
 306     else if (strcmp(kdf_type, OSSL_KDF_NAME_X942KDF_ASN1) == 0)
 307         return EVP_PKEY_DH_KDF_X9_42;
 308
 309     return -1;
 310 }
 311
 312 int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid)
 313 {
 314     int ret;
 315     OSSL_PARAM params[2], *p = params;
 316     const char *oid_name;
 317
 318     ret = dh_param_derive_check(ctx);
 319     if (ret != 1)
 320         return ret;
 321
 322     /* TODO(3.0): Remove this eventually when no more legacy */
 323     if (ctx->op.kex.exchprovctx == NULL)
 324         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 325                                  EVP_PKEY_CTRL_DH_KDF_OID, 0, (void *)(oid));
 326     oid_name = OBJ_nid2sn(OBJ_obj2nid(oid));
 327
 328     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
 329                                             (char *)oid_name, 0);
 330     *p = OSSL_PARAM_construct_end();
 331     ret = evp_pkey_ctx_set_params_strict(ctx, params);
 332     if (ret == -2) {
 333         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 334         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 335         return -2;
 336     }
 337
 338     return ret;
 339 }
 340
 341 int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid)
 342 {
 343     int ret, nid;
 344     OSSL_PARAM params[2], *p = params;
 345     char oid_name[80]; /* 80 should be big enough */
 346
 347     ret = dh_param_derive_check(ctx);
 348     if (ret != 1)
 349         return ret;
 350
 351     /* TODO(3.0): Remove this eventually when no more legacy */
 352     if (ctx->op.kex.exchprovctx == NULL)
 353         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 354                                  EVP_PKEY_CTRL_GET_DH_KDF_OID, 0, (void *)(oid));
 355     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
 356                                             oid_name, sizeof(oid_name));
 357     *p = OSSL_PARAM_construct_end();
 358
 359     ret = evp_pkey_ctx_get_params_strict(ctx, params);
 360     if (ret == -2) {
 361         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 362         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 363         return -2;
 364     } else if (ret != 1) {
 365         return -1;
 366     }
 367     nid = OBJ_sn2nid(oid_name);
 368     if (nid == NID_undef)
 369         nid = OBJ_ln2nid(oid_name);
 370     *oid = (nid == NID_undef ? NULL : OBJ_nid2obj(nid));
 371     return *oid != NULL;
 372 }
 373
 374 int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
 375 {
 376     int ret;
 377     OSSL_PARAM params[2], *p = params;
 378     const char *md_name = NULL;
 379
 380     ret = dh_param_derive_check(ctx);
 381     if (ret != 1)
 382         return ret;
 383
 384     /* TODO(3.0): Remove this eventually when no more legacy */
 385     if (ctx->op.kex.exchprovctx == NULL)
 386         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 387                                  EVP_PKEY_CTRL_DH_KDF_MD, 0, (void *)(md));
 388     md_name = (md == NULL) ? "" : EVP_MD_name(md);
 389
 390     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
 391                                             /*
 392                                              * Cast away the const. This is read
 393                                              * only so should be safe
 394                                              */
 395                                             (char *)md_name, 0);
 396     *p = OSSL_PARAM_construct_end();
 397
 398     ret = evp_pkey_ctx_set_params_strict(ctx, params);
 399     if (ret == -2) {
 400         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 401         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 402         return -2;
 403     }
 404     return ret;
 405 }
 406
 407 int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **pmd)
 408 {
 409     int ret;
 410     char name[80] = "";  /* 80 should be big enough */
 411     OSSL_PARAM params[2], *p = params;
 412
 413     ret = dh_param_derive_check(ctx);
 414     if (ret != 1)
 415         return ret;
 416
 417     /* TODO(3.0): Remove this eventually when no more legacy */
 418     if (ctx->op.kex.exchprovctx == NULL)
 419         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 420                                  EVP_PKEY_CTRL_GET_DH_KDF_MD, 0, (void *)(pmd));
 421     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
 422                                             name, sizeof(name));
 423     *p = OSSL_PARAM_construct_end();
 424
 425     ret = evp_pkey_ctx_get_params_strict(ctx, params);
 426     if (ret == -2) {
 427         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 428         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 429         return -2;
 430     } else if (ret != 1) {
 431         return -1;
 432     }
 433
 434     /* May be NULL meaning "unknown" */
 435     *pmd = EVP_get_digestbyname(name);
 436
 437     return 1;
 438 }
 439
 440 int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int inlen)
 441 {
 442     int ret;
 443     size_t len = inlen;
 444     OSSL_PARAM params[2], *p = params;
 445
 446     ret = dh_param_derive_check(ctx);
 447     if (ret != 1)
 448         return ret;
 449
 450     /* TODO(3.0): Remove this eventually when no more legacy */
 451     if (ctx->op.kex.exchprovctx == NULL)
 452         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 453                                  EVP_PKEY_CTRL_DH_KDF_OUTLEN, inlen, NULL);
 454     if (inlen <= 0) {
 455         /*
 456          * This would ideally be -1 or 0, but we have to retain compatibility
 457          * with legacy behaviour of EVP_PKEY_CTX_ctrl() which returned -2 if
 458          * in <= 0
 459          */
 460         return -2;
 461     }
 462
 463     *p++ = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
 464                                        &len);
 465     *p = OSSL_PARAM_construct_end();
 466
 467     ret = evp_pkey_ctx_set_params_strict(ctx, params);
 468     if (ret == -2) {
 469         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 470         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 471         return -2;
 472     }
 473     return ret;
 474 }
 475
 476 int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *plen)
 477 {
 478     int ret;
 479     size_t len = UINT_MAX;
 480     OSSL_PARAM params[2], *p = params;
 481
 482     ret = dh_param_derive_check(ctx);
 483     if (ret != 1)
 484         return ret;
 485
 486     /* TODO(3.0): Remove this eventually when no more legacy */
 487     if (ctx->op.kex.exchprovctx == NULL)
 488         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 489                                  EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, 0,
 490                                  (void *)(plen));
 491     *p++ = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
 492                                        &len);
 493     *p = OSSL_PARAM_construct_end();
 494
 495     ret = evp_pkey_ctx_get_params_strict(ctx, params);
 496     if (ret == -2) {
 497         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 498         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 499         return -2;
 500     } else if (ret != 1) {
 501         return -1;
 502     }
 503
 504     if (len > INT_MAX)
 505         return -1;
 506
 507     *plen = (int)len;
 508
 509     return 1;
 510 }
 511
 512 int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len)
 513 {
 514     int ret;
 515     OSSL_PARAM params[2], *p = params;
 516
 517     if (len < 0)
 518         return -1;
 519
 520     ret = dh_param_derive_check(ctx);
 521     if (ret != 1)
 522         return ret;
 523
 524     /* TODO(3.0): Remove this eventually when no more legacy */
 525     if (ctx->op.kex.exchprovctx == NULL)
 526         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 527                                  EVP_PKEY_CTRL_DH_KDF_UKM, len, (void *)(ukm));
 528
 529     *p++ = OSSL_PARAM_construct_octet_string(OSSL_EXCHANGE_PARAM_KDF_UKM,
 530                                             /*
 531                                              * Cast away the const. This is read
 532                                              * only so should be safe
 533                                              */
 534                                             (void *)ukm,
 535                                             (size_t)len);
 536     *p = OSSL_PARAM_construct_end();
 537
 538     ret = evp_pkey_ctx_set_params_strict(ctx, params);
 539     if (ret == -2) {
 540         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 541         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 542         return -2;
 543     }
 544     if (ret == 1)
 545         OPENSSL_free(ukm);
 546     return ret;
 547 }
 548
 549 int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **pukm)
 550 {
 551     int ret;
 552     size_t ukmlen;
 553     OSSL_PARAM params[2], *p = params;
 554
 555     ret = dh_param_derive_check(ctx);
 556     if (ret != 1)
 557         return ret;
 558
 559     /* TODO(3.0): Remove this eventually when no more legacy */
 560     if (ctx->op.kex.exchprovctx == NULL)
 561         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
 562                                  EVP_PKEY_CTRL_GET_DH_KDF_UKM, 0, (void *)(pukm));
 563
 564     *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_EXCHANGE_PARAM_KDF_UKM,
 565                                           (void **)pukm, 0);
 566     *p = OSSL_PARAM_construct_end();
 567
 568     ret = evp_pkey_ctx_get_params_strict(ctx, params);
 569     if (ret == -2) {
 570         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 571         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 572         return -2;
 573     } else if (ret != 1) {
 574         return -1;
 575     }
 576
 577     ukmlen = params[0].return_size;
 578     if (ukmlen > INT_MAX)
 579         return -1;
 580
 581     return (int)ukmlen;
 582 }