crypto/evp/pmeth_gn.c - third_party/openssl - Git at Google

 /*
  * Copyright 2006-2022 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
  * in the file LICENSE in the source distribution or at
  * https://www.openssl.org/source/license.html
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <openssl/core.h>
 #include <openssl/core_names.h>
 #include "internal/cryptlib.h"
 #include "internal/core.h"
 #include <openssl/objects.h>
 #include <openssl/evp.h>
 #include "crypto/bn.h"
 #ifndef FIPS_MODULE
 # include "crypto/asn1.h"
 #endif
 #include "crypto/evp.h"
 #include "evp_local.h"

 static int gen_init(EVP_PKEY_CTX *ctx, int operation)
 {
     int ret = 0;

     if (ctx == NULL)
         goto not_supported;

     evp_pkey_ctx_free_old_ops(ctx);
     ctx->operation = operation;

     if (ctx->keymgmt == NULL || ctx->keymgmt->gen_init == NULL)
         goto legacy;

     switch (operation) {
     case EVP_PKEY_OP_PARAMGEN:
         ctx->op.keymgmt.genctx =
             evp_keymgmt_gen_init(ctx->keymgmt,
                                  OSSL_KEYMGMT_SELECT_ALL_PARAMETERS, NULL);
         break;
     case EVP_PKEY_OP_KEYGEN:
         ctx->op.keymgmt.genctx =
             evp_keymgmt_gen_init(ctx->keymgmt, OSSL_KEYMGMT_SELECT_KEYPAIR,
                                  NULL);
         break;
     }

     if (ctx->op.keymgmt.genctx == NULL)
         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
     else
         ret = 1;
     goto end;

  legacy:
 #ifdef FIPS_MODULE
     goto not_supported;
 #else
     if (ctx->pmeth == NULL
         || (operation == EVP_PKEY_OP_PARAMGEN
             && ctx->pmeth->paramgen == NULL)
         || (operation == EVP_PKEY_OP_KEYGEN
             && ctx->pmeth->keygen == NULL))
         goto not_supported;

     ret = 1;
     switch (operation) {
     case EVP_PKEY_OP_PARAMGEN:
         if (ctx->pmeth->paramgen_init != NULL)
             ret = ctx->pmeth->paramgen_init(ctx);
         break;
     case EVP_PKEY_OP_KEYGEN:
         if (ctx->pmeth->keygen_init != NULL)
             ret = ctx->pmeth->keygen_init(ctx);
         break;
     }
 #endif

  end:
     if (ret <= 0 && ctx != NULL) {
         evp_pkey_ctx_free_old_ops(ctx);
         ctx->operation = EVP_PKEY_OP_UNDEFINED;
     }
     return ret;

  not_supported:
     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
     ret = -2;
     goto end;
 }

 int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
 {
     return gen_init(ctx, EVP_PKEY_OP_PARAMGEN);
 }

 int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
 {
     return gen_init(ctx, EVP_PKEY_OP_KEYGEN);
 }

 static int ossl_callback_to_pkey_gencb(const OSSL_PARAM params[], void *arg)
 {
     EVP_PKEY_CTX *ctx = arg;
     const OSSL_PARAM *param = NULL;
     int p = -1, n = -1;

     if (ctx->pkey_gencb == NULL)
         return 1;                /* No callback?  That's fine */

     if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_POTENTIAL))
         == NULL
         || !OSSL_PARAM_get_int(param, &p))
         return 0;
     if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_ITERATION))
         == NULL
         || !OSSL_PARAM_get_int(param, &n))
         return 0;

     ctx->keygen_info[0] = p;
     ctx->keygen_info[1] = n;

     return ctx->pkey_gencb(ctx);
 }

 int EVP_PKEY_generate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
 {
     int ret = 0;
     EVP_PKEY *allocated_pkey = NULL;
     /* Legacy compatible keygen callback info, only used with provider impls */
     int gentmp[2];

     if (ppkey == NULL)
         return -1;

     if (ctx == NULL)
         goto not_supported;

     if ((ctx->operation & EVP_PKEY_OP_TYPE_GEN) == 0)
         goto not_initialized;

     if (*ppkey == NULL)
         *ppkey = allocated_pkey = EVP_PKEY_new();

     if (*ppkey == NULL) {
         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
         return -1;
     }

     if (ctx->op.keymgmt.genctx == NULL)
         goto legacy;

     /*
      * Asssigning gentmp to ctx->keygen_info is something our legacy
      * implementations do.  Because the provider implementations aren't
      * allowed to reach into our EVP_PKEY_CTX, we need to provide similar
      * space for backward compatibility.  It's ok that we attach a local
      * variable, as it should only be useful in the calls down from here.
      * This is cleared as soon as it isn't useful any more, i.e. directly
      * after the evp_keymgmt_util_gen() call.
      */
     ctx->keygen_info = gentmp;
     ctx->keygen_info_count = 2;

     ret = 1;
     if (ctx->pkey != NULL) {
         EVP_KEYMGMT *tmp_keymgmt = ctx->keymgmt;
         void *keydata =
             evp_pkey_export_to_provider(ctx->pkey, ctx->libctx,
                                         &tmp_keymgmt, ctx->propquery);

         if (tmp_keymgmt == NULL)
             goto not_supported;
         /*
          * It's ok if keydata is NULL here.  The backend is expected to deal
          * with that as it sees fit.
          */
         ret = evp_keymgmt_gen_set_template(ctx->keymgmt,
                                            ctx->op.keymgmt.genctx, keydata);
     }

     /*
      * the returned value from evp_keymgmt_util_gen() is cached in *ppkey,
      * so we do not need to save it, just check it.
      */
     ret = ret
         && (evp_keymgmt_util_gen(*ppkey, ctx->keymgmt, ctx->op.keymgmt.genctx,
                                  ossl_callback_to_pkey_gencb, ctx)
             != NULL);

     ctx->keygen_info = NULL;

 #ifndef FIPS_MODULE
     /* In case |*ppkey| was originally a legacy key */
     if (ret)
         evp_pkey_free_legacy(*ppkey);
 #endif

     /*
      * Because we still have legacy keys
      */
     (*ppkey)->type = ctx->legacy_keytype;

     goto end;

  legacy:
 #ifdef FIPS_MODULE
     goto not_supported;
 #else
     /*
      * If we get here then we're using legacy paramgen/keygen. In that case
      * the pkey in ctx (if there is one) had better not be provided (because the
      * legacy methods may not know how to handle it). However we can only get
      * here if ctx->op.keymgmt.genctx == NULL, but that should never be the case
      * if ctx->pkey is provided because we don't allow this when we initialise
      * the ctx.
      */
     if (ctx->pkey != NULL && !ossl_assert(!evp_pkey_is_provided(ctx->pkey)))
         goto not_accessible;

     switch (ctx->operation) {
     case EVP_PKEY_OP_PARAMGEN:
         ret = ctx->pmeth->paramgen(ctx, *ppkey);
         break;
     case EVP_PKEY_OP_KEYGEN:
         ret = ctx->pmeth->keygen(ctx, *ppkey);
         break;
     default:
         goto not_supported;
     }
 #endif

  end:
     if (ret <= 0) {
         if (allocated_pkey != NULL)
             *ppkey = NULL;
         EVP_PKEY_free(allocated_pkey);
     }
     return ret;

  not_supported:
     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
     ret = -2;
     goto end;
  not_initialized:
     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
     ret = -1;
     goto end;
 #ifndef FIPS_MODULE
  not_accessible:
     ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS);
     ret = -1;
     goto end;
 #endif
 }

 int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
 {
     if (ctx->operation != EVP_PKEY_OP_PARAMGEN) {
         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
         return -1;
     }
     return EVP_PKEY_generate(ctx, ppkey);
 }

 int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
 {
     if (ctx->operation != EVP_PKEY_OP_KEYGEN) {
         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
         return -1;
     }
     return EVP_PKEY_generate(ctx, ppkey);
 }

 void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb)
 {
     ctx->pkey_gencb = cb;
 }

 EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx)
 {
     return ctx->pkey_gencb;
 }

 /*
  * "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB style
  * callbacks.
  */

 static int trans_cb(int a, int b, BN_GENCB *gcb)
 {
     EVP_PKEY_CTX *ctx = BN_GENCB_get_arg(gcb);
     ctx->keygen_info[0] = a;
     ctx->keygen_info[1] = b;
     return ctx->pkey_gencb(ctx);
 }

 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx)
 {
     BN_GENCB_set(cb, trans_cb, ctx);
 }

 int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
 {
     if (idx == -1)
         return ctx->keygen_info_count;
     if (idx < 0 || idx > ctx->keygen_info_count)
         return 0;
     return ctx->keygen_info[idx];
 }

 #ifndef FIPS_MODULE

 EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
                                const unsigned char *key, int keylen)
 {
     EVP_PKEY_CTX *mac_ctx = NULL;
     EVP_PKEY *mac_key = NULL;
     mac_ctx = EVP_PKEY_CTX_new_id(type, e);
     if (!mac_ctx)
         return NULL;
     if (EVP_PKEY_keygen_init(mac_ctx) <= 0)
         goto merr;
     if (EVP_PKEY_CTX_set_mac_key(mac_ctx, key, keylen) <= 0)
         goto merr;
     if (EVP_PKEY_keygen(mac_ctx, &mac_key) <= 0)
         goto merr;
  merr:
     EVP_PKEY_CTX_free(mac_ctx);
     return mac_key;
 }

 #endif /* FIPS_MODULE */

 /*- All methods below can also be used in FIPS_MODULE */

 static int fromdata_init(EVP_PKEY_CTX *ctx, int operation)
 {
     if (ctx == NULL || ctx->keytype == NULL)
         goto not_supported;

     evp_pkey_ctx_free_old_ops(ctx);
     if (ctx->keymgmt == NULL)
         goto not_supported;

     ctx->operation = operation;
     return 1;

  not_supported:
     if (ctx != NULL)
         ctx->operation = EVP_PKEY_OP_UNDEFINED;
     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
     return -2;
 }

 int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx)
 {
     return fromdata_init(ctx, EVP_PKEY_OP_FROMDATA);
 }

 int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection,
                       OSSL_PARAM params[])
 {
     void *keydata = NULL;
     EVP_PKEY *allocated_pkey = NULL;

     if (ctx == NULL || (ctx->operation & EVP_PKEY_OP_FROMDATA) == 0) {
         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
         return -2;
     }

     if (ppkey == NULL)
         return -1;

     if (*ppkey == NULL)
         allocated_pkey = *ppkey = EVP_PKEY_new();

     if (*ppkey == NULL) {
         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
         return -1;
     }

     keydata = evp_keymgmt_util_fromdata(*ppkey, ctx->keymgmt, selection, params);
     if (keydata == NULL) {
         if (allocated_pkey != NULL) {
             *ppkey = NULL;
             EVP_PKEY_free(allocated_pkey);
         }
         return 0;
     }
     /* keydata is cached in *ppkey, so we need not bother with it further */
     return 1;
 }

 const OSSL_PARAM *EVP_PKEY_fromdata_settable(EVP_PKEY_CTX *ctx, int selection)
 {
     /* We call fromdata_init to get ctx->keymgmt populated */
     if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED) == 1)
         return evp_keymgmt_import_types(ctx->keymgmt, selection);
     return NULL;
 }

 static OSSL_CALLBACK ossl_pkey_todata_cb;

 static int ossl_pkey_todata_cb(const OSSL_PARAM params[], void *arg)
 {
     OSSL_PARAM **ret = arg;

     *ret = OSSL_PARAM_dup(params);
     return 1;
 }

 int EVP_PKEY_todata(const EVP_PKEY *pkey, int selection, OSSL_PARAM **params)
 {
     if (params == NULL)
         return 0;
     return EVP_PKEY_export(pkey, selection, ossl_pkey_todata_cb, params);
 }

 #ifndef FIPS_MODULE
 struct fake_import_data_st {
     OSSL_CALLBACK *export_cb;
     void *export_cbarg;
 };

 static OSSL_FUNC_keymgmt_import_fn pkey_fake_import;
 static int pkey_fake_import(void *fake_keydata, int ignored_selection,
                             const OSSL_PARAM params[])
 {
     struct fake_import_data_st *data = fake_keydata;

     return data->export_cb(params, data->export_cbarg);
 }
 #endif

 int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
                     OSSL_CALLBACK *export_cb, void *export_cbarg)
 {
     if (pkey == NULL) {
         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
         return 0;
     }
 #ifndef FIPS_MODULE
     if (evp_pkey_is_legacy(pkey)) {
         struct fake_import_data_st data;

         data.export_cb = export_cb;
         data.export_cbarg = export_cbarg;

         /*
          * We don't need to care about libctx or propq here, as we're only
          * interested in the resulting OSSL_PARAM array.
          */
         return pkey->ameth->export_to(pkey, &data, pkey_fake_import,
                                       NULL, NULL);
     }
 #endif
     return evp_keymgmt_util_export(pkey, selection, export_cb, export_cbarg);
 }
	/*
	* Copyright 2006-2022 The OpenSSL Project Authors. All Rights Reserved.
	*
	* Licensed under the Apache License 2.0 (the "License"). You may not use
	* this file except in compliance with the License. You can obtain a copy
	* in the file LICENSE in the source distribution or at
	* https://www.openssl.org/source/license.html
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <openssl/core.h>
	#include <openssl/core_names.h>
	#include "internal/cryptlib.h"
	#include "internal/core.h"
	#include <openssl/objects.h>
	#include <openssl/evp.h>
	#include "crypto/bn.h"
	#ifndef FIPS_MODULE
	# include "crypto/asn1.h"
	#endif
	#include "crypto/evp.h"
	#include "evp_local.h"

	static int gen_init(EVP_PKEY_CTX *ctx, int operation)
	{
	int ret = 0;

	if (ctx == NULL)
	goto not_supported;

	evp_pkey_ctx_free_old_ops(ctx);
	ctx->operation = operation;

	if (ctx->keymgmt == NULL \|\| ctx->keymgmt->gen_init == NULL)
	goto legacy;

	switch (operation) {
	case EVP_PKEY_OP_PARAMGEN:
	ctx->op.keymgmt.genctx =
	evp_keymgmt_gen_init(ctx->keymgmt,
	OSSL_KEYMGMT_SELECT_ALL_PARAMETERS, NULL);
	break;
	case EVP_PKEY_OP_KEYGEN:
	ctx->op.keymgmt.genctx =
	evp_keymgmt_gen_init(ctx->keymgmt, OSSL_KEYMGMT_SELECT_KEYPAIR,
	NULL);
	break;
	}

	if (ctx->op.keymgmt.genctx == NULL)
	ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
	else
	ret = 1;
	goto end;

	legacy:
	#ifdef FIPS_MODULE
	goto not_supported;
	#else
	if (ctx->pmeth == NULL
	\|\| (operation == EVP_PKEY_OP_PARAMGEN
	&& ctx->pmeth->paramgen == NULL)
	\|\| (operation == EVP_PKEY_OP_KEYGEN
	&& ctx->pmeth->keygen == NULL))
	goto not_supported;

	ret = 1;
	switch (operation) {
	case EVP_PKEY_OP_PARAMGEN:
	if (ctx->pmeth->paramgen_init != NULL)
	ret = ctx->pmeth->paramgen_init(ctx);
	break;
	case EVP_PKEY_OP_KEYGEN:
	if (ctx->pmeth->keygen_init != NULL)
	ret = ctx->pmeth->keygen_init(ctx);
	break;
	}
	#endif

	end:
	if (ret <= 0 && ctx != NULL) {
	evp_pkey_ctx_free_old_ops(ctx);
	ctx->operation = EVP_PKEY_OP_UNDEFINED;
	}
	return ret;

	not_supported:
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
	ret = -2;
	goto end;
	}

	int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
	{
	return gen_init(ctx, EVP_PKEY_OP_PARAMGEN);
	}

	int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
	{
	return gen_init(ctx, EVP_PKEY_OP_KEYGEN);
	}

	static int ossl_callback_to_pkey_gencb(const OSSL_PARAM params[], void *arg)
	{
	EVP_PKEY_CTX *ctx = arg;
	const OSSL_PARAM *param = NULL;
	int p = -1, n = -1;

	if (ctx->pkey_gencb == NULL)
	return 1; /* No callback? That's fine */

	if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_POTENTIAL))
	== NULL
	\|\| !OSSL_PARAM_get_int(param, &p))
	return 0;
	if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_ITERATION))
	== NULL
	\|\| !OSSL_PARAM_get_int(param, &n))
	return 0;

	ctx->keygen_info[0] = p;
	ctx->keygen_info[1] = n;

	return ctx->pkey_gencb(ctx);
	}

	int EVP_PKEY_generate(EVP_PKEY_CTX ctx, EVP_PKEY *ppkey)
	{
	int ret = 0;
	EVP_PKEY *allocated_pkey = NULL;
	/* Legacy compatible keygen callback info, only used with provider impls */
	int gentmp[2];

	if (ppkey == NULL)
	return -1;

	if (ctx == NULL)
	goto not_supported;

	if ((ctx->operation & EVP_PKEY_OP_TYPE_GEN) == 0)
	goto not_initialized;

	if (*ppkey == NULL)
	*ppkey = allocated_pkey = EVP_PKEY_new();

	if (*ppkey == NULL) {
	ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
	return -1;
	}

	if (ctx->op.keymgmt.genctx == NULL)
	goto legacy;

	/*
	* Asssigning gentmp to ctx->keygen_info is something our legacy
	* implementations do. Because the provider implementations aren't
	* allowed to reach into our EVP_PKEY_CTX, we need to provide similar
	* space for backward compatibility. It's ok that we attach a local
	* variable, as it should only be useful in the calls down from here.
	* This is cleared as soon as it isn't useful any more, i.e. directly
	* after the evp_keymgmt_util_gen() call.
	*/
	ctx->keygen_info = gentmp;
	ctx->keygen_info_count = 2;

	ret = 1;
	if (ctx->pkey != NULL) {
	EVP_KEYMGMT *tmp_keymgmt = ctx->keymgmt;
	void *keydata =
	evp_pkey_export_to_provider(ctx->pkey, ctx->libctx,
	&tmp_keymgmt, ctx->propquery);

	if (tmp_keymgmt == NULL)
	goto not_supported;
	/*
	* It's ok if keydata is NULL here. The backend is expected to deal
	* with that as it sees fit.
	*/
	ret = evp_keymgmt_gen_set_template(ctx->keymgmt,
	ctx->op.keymgmt.genctx, keydata);
	}

	/*
	* the returned value from evp_keymgmt_util_gen() is cached in *ppkey,
	* so we do not need to save it, just check it.
	*/
	ret = ret
	&& (evp_keymgmt_util_gen(*ppkey, ctx->keymgmt, ctx->op.keymgmt.genctx,
	ossl_callback_to_pkey_gencb, ctx)
	!= NULL);

	ctx->keygen_info = NULL;

	#ifndef FIPS_MODULE
	/* In case \|ppkey\| was originally a legacy key /
	if (ret)
	evp_pkey_free_legacy(*ppkey);
	#endif

	/*
	* Because we still have legacy keys
	*/
	(*ppkey)->type = ctx->legacy_keytype;

	goto end;

	legacy:
	#ifdef FIPS_MODULE
	goto not_supported;
	#else
	/*
	* If we get here then we're using legacy paramgen/keygen. In that case
	* the pkey in ctx (if there is one) had better not be provided (because the
	* legacy methods may not know how to handle it). However we can only get
	* here if ctx->op.keymgmt.genctx == NULL, but that should never be the case
	* if ctx->pkey is provided because we don't allow this when we initialise
	* the ctx.
	*/
	if (ctx->pkey != NULL && !ossl_assert(!evp_pkey_is_provided(ctx->pkey)))
	goto not_accessible;

	switch (ctx->operation) {
	case EVP_PKEY_OP_PARAMGEN:
	ret = ctx->pmeth->paramgen(ctx, *ppkey);
	break;
	case EVP_PKEY_OP_KEYGEN:
	ret = ctx->pmeth->keygen(ctx, *ppkey);
	break;
	default:
	goto not_supported;
	}
	#endif

	end:
	if (ret <= 0) {
	if (allocated_pkey != NULL)
	*ppkey = NULL;
	EVP_PKEY_free(allocated_pkey);
	}
	return ret;

	not_supported:
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
	ret = -2;
	goto end;
	not_initialized:
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
	ret = -1;
	goto end;
	#ifndef FIPS_MODULE
	not_accessible:
	ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS);
	ret = -1;
	goto end;
	#endif
	}

	int EVP_PKEY_paramgen(EVP_PKEY_CTX ctx, EVP_PKEY *ppkey)
	{
	if (ctx->operation != EVP_PKEY_OP_PARAMGEN) {
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
	return -1;
	}
	return EVP_PKEY_generate(ctx, ppkey);
	}

	int EVP_PKEY_keygen(EVP_PKEY_CTX ctx, EVP_PKEY *ppkey)
	{
	if (ctx->operation != EVP_PKEY_OP_KEYGEN) {
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_INITIALIZED);
	return -1;
	}
	return EVP_PKEY_generate(ctx, ppkey);
	}

	void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX ctx, EVP_PKEY_gen_cb cb)
	{
	ctx->pkey_gencb = cb;
	}

	EVP_PKEY_gen_cb EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX ctx)
	{
	return ctx->pkey_gencb;
	}

	/*
	* "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB style
	* callbacks.
	*/

	static int trans_cb(int a, int b, BN_GENCB *gcb)
	{
	EVP_PKEY_CTX *ctx = BN_GENCB_get_arg(gcb);
	ctx->keygen_info[0] = a;
	ctx->keygen_info[1] = b;
	return ctx->pkey_gencb(ctx);
	}

	void evp_pkey_set_cb_translate(BN_GENCB cb, EVP_PKEY_CTX ctx)
	{
	BN_GENCB_set(cb, trans_cb, ctx);
	}

	int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
	{
	if (idx == -1)
	return ctx->keygen_info_count;
	if (idx < 0 \|\| idx > ctx->keygen_info_count)
	return 0;
	return ctx->keygen_info[idx];
	}

	#ifndef FIPS_MODULE

	EVP_PKEY EVP_PKEY_new_mac_key(int type, ENGINE e,
	const unsigned char *key, int keylen)
	{
	EVP_PKEY_CTX *mac_ctx = NULL;
	EVP_PKEY *mac_key = NULL;
	mac_ctx = EVP_PKEY_CTX_new_id(type, e);
	if (!mac_ctx)
	return NULL;
	if (EVP_PKEY_keygen_init(mac_ctx) <= 0)
	goto merr;
	if (EVP_PKEY_CTX_set_mac_key(mac_ctx, key, keylen) <= 0)
	goto merr;
	if (EVP_PKEY_keygen(mac_ctx, &mac_key) <= 0)
	goto merr;
	merr:
	EVP_PKEY_CTX_free(mac_ctx);
	return mac_key;
	}

	#endif /* FIPS_MODULE */

	/- All methods below can also be used in FIPS_MODULE /

	static int fromdata_init(EVP_PKEY_CTX *ctx, int operation)
	{
	if (ctx == NULL \|\| ctx->keytype == NULL)
	goto not_supported;

	evp_pkey_ctx_free_old_ops(ctx);
	if (ctx->keymgmt == NULL)
	goto not_supported;

	ctx->operation = operation;
	return 1;

	not_supported:
	if (ctx != NULL)
	ctx->operation = EVP_PKEY_OP_UNDEFINED;
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
	return -2;
	}

	int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx)
	{
	return fromdata_init(ctx, EVP_PKEY_OP_FROMDATA);
	}

	int EVP_PKEY_fromdata(EVP_PKEY_CTX ctx, EVP_PKEY *ppkey, int selection,
	OSSL_PARAM params[])
	{
	void *keydata = NULL;
	EVP_PKEY *allocated_pkey = NULL;

	if (ctx == NULL \|\| (ctx->operation & EVP_PKEY_OP_FROMDATA) == 0) {
	ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
	return -2;
	}

	if (ppkey == NULL)
	return -1;

	if (*ppkey == NULL)
	allocated_pkey = *ppkey = EVP_PKEY_new();

	if (*ppkey == NULL) {
	ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
	return -1;
	}

	keydata = evp_keymgmt_util_fromdata(*ppkey, ctx->keymgmt, selection, params);
	if (keydata == NULL) {
	if (allocated_pkey != NULL) {
	*ppkey = NULL;
	EVP_PKEY_free(allocated_pkey);
	}
	return 0;
	}
	/* keydata is cached in ppkey, so we need not bother with it further /
	return 1;
	}

	const OSSL_PARAM EVP_PKEY_fromdata_settable(EVP_PKEY_CTX ctx, int selection)
	{
	/* We call fromdata_init to get ctx->keymgmt populated */
	if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED) == 1)
	return evp_keymgmt_import_types(ctx->keymgmt, selection);
	return NULL;
	}

	static OSSL_CALLBACK ossl_pkey_todata_cb;

	static int ossl_pkey_todata_cb(const OSSL_PARAM params[], void *arg)
	{
	OSSL_PARAM **ret = arg;

	*ret = OSSL_PARAM_dup(params);
	return 1;
	}

	int EVP_PKEY_todata(const EVP_PKEY pkey, int selection, OSSL_PARAM *params)
	{
	if (params == NULL)
	return 0;
	return EVP_PKEY_export(pkey, selection, ossl_pkey_todata_cb, params);
	}

	#ifndef FIPS_MODULE
	struct fake_import_data_st {
	OSSL_CALLBACK *export_cb;
	void *export_cbarg;
	};

	static OSSL_FUNC_keymgmt_import_fn pkey_fake_import;
	static int pkey_fake_import(void *fake_keydata, int ignored_selection,
	const OSSL_PARAM params[])
	{
	struct fake_import_data_st *data = fake_keydata;

	return data->export_cb(params, data->export_cbarg);
	}
	#endif

	int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
	OSSL_CALLBACK export_cb, void export_cbarg)
	{
	if (pkey == NULL) {
	ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
	return 0;
	}
	#ifndef FIPS_MODULE
	if (evp_pkey_is_legacy(pkey)) {
	struct fake_import_data_st data;

	data.export_cb = export_cb;
	data.export_cbarg = export_cbarg;

	/*
	* We don't need to care about libctx or propq here, as we're only
	* interested in the resulting OSSL_PARAM array.
	*/
	return pkey->ameth->export_to(pkey, &data, pkey_fake_import,
	NULL, NULL);
	}
	#endif
	return evp_keymgmt_util_export(pkey, selection, export_cb, export_cbarg);
	}