[thirdparty/openssl.git] / crypto / evp / keymgmt_meth.c

/*
 * Copyright 2019 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 <openssl/crypto.h>
#include <openssl/core_numbers.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include "internal/provider.h"
#include "internal/refcount.h"
#include "crypto/evp.h"
#include "evp_local.h"


static void *keymgmt_new(void)
{
    EVP_KEYMGMT *keymgmt = NULL;

    if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL
        || (keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
        EVP_KEYMGMT_free(keymgmt);
        EVPerr(0, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    keymgmt->refcnt = 1;

    return keymgmt;
}

static void *keymgmt_from_dispatch(int name_id,
                                   const OSSL_DISPATCH *fns,
                                   OSSL_PROVIDER *prov)
{
    EVP_KEYMGMT *keymgmt = NULL;

    if ((keymgmt = keymgmt_new()) == NULL) {
        EVP_KEYMGMT_free(keymgmt);
        return NULL;
    }
    keymgmt->name_id = name_id;

    for (; fns->function_id != 0; fns++) {
        switch (fns->function_id) {
        case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAMS:
            if (keymgmt->importdomparams != NULL)
                break;
            keymgmt->importdomparams =
                OSSL_get_OP_keymgmt_importdomparams(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GENDOMPARAMS:
            if (keymgmt->gendomparams != NULL)
                break;
            keymgmt->gendomparams = OSSL_get_OP_keymgmt_gendomparams(fns);
            break;
        case OSSL_FUNC_KEYMGMT_FREEDOMPARAMS:
            if (keymgmt->freedomparams != NULL)
                break;
            keymgmt->freedomparams = OSSL_get_OP_keymgmt_freedomparams(fns);
            break;
        case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAMS:
            if (keymgmt->exportdomparams != NULL)
                break;
            keymgmt->exportdomparams =
                OSSL_get_OP_keymgmt_exportdomparams(fns);
            break;
        case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAM_TYPES:
            if (keymgmt->importdomparam_types != NULL)
                break;
            keymgmt->importdomparam_types =
                OSSL_get_OP_keymgmt_importdomparam_types(fns);
            break;
        case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAM_TYPES:
            if (keymgmt->exportdomparam_types != NULL)
                break;
            keymgmt->exportdomparam_types =
                OSSL_get_OP_keymgmt_exportdomparam_types(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GET_DOMPARAM_PARAMS:
            if (keymgmt->get_domparam_params == NULL)
                keymgmt->get_domparam_params =
                    OSSL_get_OP_keymgmt_get_domparam_params(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GETTABLE_DOMPARAM_PARAMS:
            if (keymgmt->gettable_domparam_params == NULL)
                keymgmt->gettable_domparam_params =
                    OSSL_get_OP_keymgmt_gettable_domparam_params(fns);
            break;
        case OSSL_FUNC_KEYMGMT_IMPORTKEY:
            if (keymgmt->importkey != NULL)
                break;
            keymgmt->importkey = OSSL_get_OP_keymgmt_importkey(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GENKEY:
            if (keymgmt->genkey != NULL)
                break;
            keymgmt->genkey = OSSL_get_OP_keymgmt_genkey(fns);
            break;
        case OSSL_FUNC_KEYMGMT_LOADKEY:
            if (keymgmt->loadkey != NULL)
                break;
            keymgmt->loadkey = OSSL_get_OP_keymgmt_loadkey(fns);
            break;
        case OSSL_FUNC_KEYMGMT_FREEKEY:
            if (keymgmt->freekey != NULL)
                break;
            keymgmt->freekey = OSSL_get_OP_keymgmt_freekey(fns);
            break;
        case OSSL_FUNC_KEYMGMT_EXPORTKEY:
            if (keymgmt->exportkey != NULL)
                break;
            keymgmt->exportkey = OSSL_get_OP_keymgmt_exportkey(fns);
            break;
        case OSSL_FUNC_KEYMGMT_IMPORTKEY_TYPES:
            if (keymgmt->importkey_types != NULL)
                break;
            keymgmt->importkey_types =
                OSSL_get_OP_keymgmt_importkey_types(fns);
            break;
        case OSSL_FUNC_KEYMGMT_EXPORTKEY_TYPES:
            if (keymgmt->exportkey_types != NULL)
                break;
            keymgmt->exportkey_types =
                OSSL_get_OP_keymgmt_exportkey_types(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GET_KEY_PARAMS:
            if (keymgmt->get_key_params == NULL)
                keymgmt->get_key_params =
                    OSSL_get_OP_keymgmt_get_key_params(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GETTABLE_KEY_PARAMS:
            if (keymgmt->gettable_key_params == NULL)
                keymgmt->gettable_key_params =
                    OSSL_get_OP_keymgmt_gettable_key_params(fns);
            break;
        case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
            if (keymgmt->query_operation_name != NULL)
                break;
            keymgmt->query_operation_name =
                OSSL_get_OP_keymgmt_query_operation_name(fns);
            break;
        case OSSL_FUNC_KEYMGMT_VALIDATE_DOMPARAMS:
            if (keymgmt->validatedomparams != NULL)
                break;
            keymgmt->validatedomparams =
                OSSL_get_OP_keymgmt_validate_domparams(fns);
            break;
        case OSSL_FUNC_KEYMGMT_VALIDATE_PUBLIC:
            if (keymgmt->validatepublic != NULL)
                break;
            keymgmt->validatepublic =
                OSSL_get_OP_keymgmt_validate_public(fns);
            break;
        case OSSL_FUNC_KEYMGMT_VALIDATE_PRIVATE:
            if (keymgmt->validateprivate != NULL)
                break;
            keymgmt->validateprivate =
                OSSL_get_OP_keymgmt_validate_private(fns);
            break;
        case OSSL_FUNC_KEYMGMT_VALIDATE_PAIRWISE:
            if (keymgmt->validatepairwise != NULL)
                break;
            keymgmt->validatepairwise =
                OSSL_get_OP_keymgmt_validate_pairwise(fns);
            break;
        }
    }
    /*
     * Try to check that the method is sensible.
     * It makes no sense being able to free stuff if you can't create it.
     * It makes no sense providing OSSL_PARAM descriptors for import and
     * export if you can't import or export.
     */
    if ((keymgmt->freedomparams != NULL
         && (keymgmt->importdomparams == NULL
             && keymgmt->gendomparams == NULL))
        || (keymgmt->freekey != NULL
            && (keymgmt->importkey == NULL
                && keymgmt->genkey == NULL
                && keymgmt->loadkey == NULL))
        || (keymgmt->importdomparam_types != NULL
            && keymgmt->importdomparams == NULL)
        || (keymgmt->exportdomparam_types != NULL
            && keymgmt->exportdomparams == NULL)
        || (keymgmt->gettable_domparam_params != NULL
            && keymgmt->get_domparam_params == NULL)
        || (keymgmt->importkey_types != NULL
            && keymgmt->importkey == NULL)
        || (keymgmt->exportkey_types != NULL
            && keymgmt->exportkey == NULL)
        || (keymgmt->gettable_key_params != NULL
            && keymgmt->get_key_params == NULL)) {
        EVP_KEYMGMT_free(keymgmt);
        EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
        return NULL;
    }
    keymgmt->prov = prov;
    if (prov != NULL)
        ossl_provider_up_ref(prov);

    return keymgmt;
}

EVP_KEYMGMT *evp_keymgmt_fetch_by_number(OPENSSL_CTX *ctx, int name_id,
                                         const char *properties)
{
    return evp_generic_fetch_by_number(ctx,
                                       OSSL_OP_KEYMGMT, name_id, properties,
                                       keymgmt_from_dispatch,
                                       (int (*)(void *))EVP_KEYMGMT_up_ref,
                                       (void (*)(void *))EVP_KEYMGMT_free);
}

EVP_KEYMGMT *EVP_KEYMGMT_fetch(OPENSSL_CTX *ctx, const char *algorithm,
                               const char *properties)
{
    return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
                             keymgmt_from_dispatch,
                             (int (*)(void *))EVP_KEYMGMT_up_ref,
                             (void (*)(void *))EVP_KEYMGMT_free);
}

int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
{
    int ref = 0;

    CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
    return 1;
}

void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
{
    int ref = 0;

    if (keymgmt == NULL)
        return;

    CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
    if (ref > 0)
        return;
    ossl_provider_free(keymgmt->prov);
    CRYPTO_THREAD_lock_free(keymgmt->lock);
    OPENSSL_free(keymgmt);
}

const OSSL_PROVIDER *EVP_KEYMGMT_provider(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->prov;
}

int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->name_id;
}

int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name)
{
    return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
}

void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
                                 void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
                                 void *arg)
{
    evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
                       (void (*)(void *, void *))fn, arg,
                       keymgmt_from_dispatch,
                       (void (*)(void *))EVP_KEYMGMT_free);
}

void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
                              void (*fn)(const char *name, void *data),
                              void *data)
{
    if (keymgmt->prov != NULL)
        evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
}

/*
 * Internal API that interfaces with the method function pointers
 */
void *evp_keymgmt_importdomparams(const EVP_KEYMGMT *keymgmt,
                                  const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    return keymgmt->importdomparams(provctx, params);
}

void *evp_keymgmt_gendomparams(const EVP_KEYMGMT *keymgmt,
                               const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    return keymgmt->gendomparams(provctx, params);
}

void evp_keymgmt_freedomparams(const EVP_KEYMGMT *keymgmt,
                               void *provdomparams)
{
    keymgmt->freedomparams(provdomparams);
}

int evp_keymgmt_exportdomparams(const EVP_KEYMGMT *keymgmt,
                                void *provdomparams,
                                OSSL_CALLBACK *param_cb, void *cbarg)
{
    return keymgmt->exportdomparams(provdomparams, param_cb, cbarg);
}

const OSSL_PARAM *evp_keymgmt_importdomparam_types(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->importdomparam_types();
}

/*
 * TODO(v3.0) investigate if we need this function.  'openssl provider' may
 * be a caller...
 */
const OSSL_PARAM *evp_keymgmt_exportdomparam_types(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->exportdomparam_types();
}

int evp_keymgmt_get_domparam_params(const EVP_KEYMGMT *keymgmt,
                                     void *provdomparams, OSSL_PARAM params[])
{
    if (keymgmt->get_domparam_params == NULL)
        return 1;
    return keymgmt->get_domparam_params(provdomparams, params);
}

const OSSL_PARAM *
evp_keymgmt_gettable_domparam_params(const EVP_KEYMGMT *keymgmt)
{
    if (keymgmt->gettable_domparam_params == NULL)
        return NULL;
    return keymgmt->gettable_domparam_params();
}


void *evp_keymgmt_importkey(const EVP_KEYMGMT *keymgmt,
                            const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    return keymgmt->importkey(provctx, params);
}

void *evp_keymgmt_genkey(const EVP_KEYMGMT *keymgmt, void *domparams,
                         const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    return keymgmt->genkey(provctx, domparams, params);
}

void *evp_keymgmt_loadkey(const EVP_KEYMGMT *keymgmt,
                          void *id, size_t idlen)
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    return keymgmt->loadkey(provctx, id, idlen);
}

void evp_keymgmt_freekey(const EVP_KEYMGMT *keymgmt, void *provkey)
{
    keymgmt->freekey(provkey);
}

int evp_keymgmt_exportkey(const EVP_KEYMGMT *keymgmt, void *provkey,
                          OSSL_CALLBACK *param_cb, void *cbarg)
{
    return keymgmt->exportkey(provkey, param_cb, cbarg);
}

const OSSL_PARAM *evp_keymgmt_importkey_types(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->importkey_types();
}

/*
 * TODO(v3.0) investigate if we need this function.  'openssl provider' may
 * be a caller...
 */
const OSSL_PARAM *evp_keymgmt_exportkey_types(const EVP_KEYMGMT *keymgmt)
{
    return keymgmt->exportkey_types();
}

int evp_keymgmt_get_key_params(const EVP_KEYMGMT *keymgmt,
                               void *provkey, OSSL_PARAM params[])
{
    if (keymgmt->get_key_params == NULL)
        return 1;
    return keymgmt->get_key_params(provkey, params);
}

const OSSL_PARAM *evp_keymgmt_gettable_key_params(const EVP_KEYMGMT *keymgmt)
{
    if (keymgmt->gettable_key_params == NULL)
        return NULL;
    return keymgmt->gettable_key_params();
}

int evp_keymgmt_validate_domparams(const EVP_KEYMGMT *keymgmt, void *provkey)
{
    /* if domainparams are not supported - then pass */
    if (keymgmt->validatedomparams == NULL)
        return 1;
    return keymgmt->validatedomparams(provkey);
}

int evp_keymgmt_validate_public(const EVP_KEYMGMT *keymgmt, void *provkey)
{
    return keymgmt->validatepublic(provkey);
}

int evp_keymgmt_validate_private(const EVP_KEYMGMT *keymgmt, void *provkey)
{
    return keymgmt->validateprivate(provkey);
}

int evp_keymgmt_validate_pairwise(const EVP_KEYMGMT *keymgmt, void *provkey)
{
    return keymgmt->validatepairwise(provkey);
}
Commit	Line	Data
a94a3e0d RL	1	/*
	2	* Copyright 2019 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 <openssl/crypto.h>
	11	#include <openssl/core_numbers.h>
	12	#include <openssl/evp.h>
	13	#include <openssl/err.h>
	14	#include "internal/provider.h"
	15	#include "internal/refcount.h"
25f2138b	16	#include "crypto/evp.h"
706457b7	17	#include "evp_local.h"
a94a3e0d RL	18
	19
	20	static void *keymgmt_new(void)
	21	{
	22	EVP_KEYMGMT *keymgmt = NULL;
	23
	24	if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL
	25	\|\| (keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
	26	EVP_KEYMGMT_free(keymgmt);
6b9e3724	27	EVPerr(0, ERR_R_MALLOC_FAILURE);
a94a3e0d RL	28	return NULL;
	29	}
	30
	31	keymgmt->refcnt = 1;
	32
	33	return keymgmt;
	34	}
	35
f7c16d48 RL	36	static void *keymgmt_from_dispatch(int name_id,
f7c16d48 RL	37	const OSSL_DISPATCH *fns,
0ddf74bf	38	OSSL_PROVIDER *prov)
a94a3e0d RL	39	{
	40	EVP_KEYMGMT *keymgmt = NULL;
	41
f7c16d48	42	if ((keymgmt = keymgmt_new()) == NULL) {
6b9e3724	43	EVP_KEYMGMT_free(keymgmt);
a94a3e0d	44	return NULL;
6b9e3724	45	}
f7c16d48	46	keymgmt->name_id = name_id;
a94a3e0d RL	47
	48	for (; fns->function_id != 0; fns++) {
	49	switch (fns->function_id) {
	50	case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAMS:
	51	if (keymgmt->importdomparams != NULL)
	52	break;
	53	keymgmt->importdomparams =
	54	OSSL_get_OP_keymgmt_importdomparams(fns);
	55	break;
	56	case OSSL_FUNC_KEYMGMT_GENDOMPARAMS:
	57	if (keymgmt->gendomparams != NULL)
	58	break;
	59	keymgmt->gendomparams = OSSL_get_OP_keymgmt_gendomparams(fns);
	60	break;
	61	case OSSL_FUNC_KEYMGMT_FREEDOMPARAMS:
	62	if (keymgmt->freedomparams != NULL)
	63	break;
	64	keymgmt->freedomparams = OSSL_get_OP_keymgmt_freedomparams(fns);
	65	break;
	66	case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAMS:
	67	if (keymgmt->exportdomparams != NULL)
	68	break;
	69	keymgmt->exportdomparams =
	70	OSSL_get_OP_keymgmt_exportdomparams(fns);
	71	break;
	72	case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAM_TYPES:
	73	if (keymgmt->importdomparam_types != NULL)
	74	break;
	75	keymgmt->importdomparam_types =
	76	OSSL_get_OP_keymgmt_importdomparam_types(fns);
	77	break;
	78	case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAM_TYPES:
	79	if (keymgmt->exportdomparam_types != NULL)
	80	break;
	81	keymgmt->exportdomparam_types =
	82	OSSL_get_OP_keymgmt_exportdomparam_types(fns);
	83	break;
6508e858 RL	84	case OSSL_FUNC_KEYMGMT_GET_DOMPARAM_PARAMS:
	85	if (keymgmt->get_domparam_params == NULL)
	86	keymgmt->get_domparam_params =
	87	OSSL_get_OP_keymgmt_get_domparam_params(fns);
	88	break;
	89	case OSSL_FUNC_KEYMGMT_GETTABLE_DOMPARAM_PARAMS:
	90	if (keymgmt->gettable_domparam_params == NULL)
	91	keymgmt->gettable_domparam_params =
	92	OSSL_get_OP_keymgmt_gettable_domparam_params(fns);
	93	break;
a94a3e0d RL	94	case OSSL_FUNC_KEYMGMT_IMPORTKEY:
	95	if (keymgmt->importkey != NULL)
	96	break;
	97	keymgmt->importkey = OSSL_get_OP_keymgmt_importkey(fns);
	98	break;
	99	case OSSL_FUNC_KEYMGMT_GENKEY:
	100	if (keymgmt->genkey != NULL)
	101	break;
	102	keymgmt->genkey = OSSL_get_OP_keymgmt_genkey(fns);
	103	break;
	104	case OSSL_FUNC_KEYMGMT_LOADKEY:
	105	if (keymgmt->loadkey != NULL)
	106	break;
	107	keymgmt->loadkey = OSSL_get_OP_keymgmt_loadkey(fns);
	108	break;
	109	case OSSL_FUNC_KEYMGMT_FREEKEY:
	110	if (keymgmt->freekey != NULL)
	111	break;
	112	keymgmt->freekey = OSSL_get_OP_keymgmt_freekey(fns);
	113	break;
	114	case OSSL_FUNC_KEYMGMT_EXPORTKEY:
	115	if (keymgmt->exportkey != NULL)
	116	break;
	117	keymgmt->exportkey = OSSL_get_OP_keymgmt_exportkey(fns);
	118	break;
	119	case OSSL_FUNC_KEYMGMT_IMPORTKEY_TYPES:
	120	if (keymgmt->importkey_types != NULL)
	121	break;
	122	keymgmt->importkey_types =
	123	OSSL_get_OP_keymgmt_importkey_types(fns);
	124	break;
	125	case OSSL_FUNC_KEYMGMT_EXPORTKEY_TYPES:
	126	if (keymgmt->exportkey_types != NULL)
	127	break;
	128	keymgmt->exportkey_types =
	129	OSSL_get_OP_keymgmt_exportkey_types(fns);
	130	break;
6508e858 RL	131	case OSSL_FUNC_KEYMGMT_GET_KEY_PARAMS:
	132	if (keymgmt->get_key_params == NULL)
	133	keymgmt->get_key_params =
	134	OSSL_get_OP_keymgmt_get_key_params(fns);
	135	break;
	136	case OSSL_FUNC_KEYMGMT_GETTABLE_KEY_PARAMS:
	137	if (keymgmt->gettable_key_params == NULL)
	138	keymgmt->gettable_key_params =
	139	OSSL_get_OP_keymgmt_gettable_key_params(fns);
	140	break;
e62a45b6 RL	141	case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
	142	if (keymgmt->query_operation_name != NULL)
	143	break;
	144	keymgmt->query_operation_name =
	145	OSSL_get_OP_keymgmt_query_operation_name(fns);
	146	break;
12603de6 SL	147	case OSSL_FUNC_KEYMGMT_VALIDATE_DOMPARAMS:
	148	if (keymgmt->validatedomparams != NULL)
	149	break;
	150	keymgmt->validatedomparams =
	151	OSSL_get_OP_keymgmt_validate_domparams(fns);
	152	break;
	153	case OSSL_FUNC_KEYMGMT_VALIDATE_PUBLIC:
	154	if (keymgmt->validatepublic != NULL)
	155	break;
	156	keymgmt->validatepublic =
	157	OSSL_get_OP_keymgmt_validate_public(fns);
	158	break;
	159	case OSSL_FUNC_KEYMGMT_VALIDATE_PRIVATE:
	160	if (keymgmt->validateprivate != NULL)
	161	break;
	162	keymgmt->validateprivate =
	163	OSSL_get_OP_keymgmt_validate_private(fns);
	164	break;
	165	case OSSL_FUNC_KEYMGMT_VALIDATE_PAIRWISE:
	166	if (keymgmt->validatepairwise != NULL)
	167	break;
	168	keymgmt->validatepairwise =
	169	OSSL_get_OP_keymgmt_validate_pairwise(fns);
	170	break;
a94a3e0d RL	171	}
	172	}
	173	/*
	174	* Try to check that the method is sensible.
	175	* It makes no sense being able to free stuff if you can't create it.
	176	* It makes no sense providing OSSL_PARAM descriptors for import and
	177	* export if you can't import or export.
	178	*/
	179	if ((keymgmt->freedomparams != NULL
	180	&& (keymgmt->importdomparams == NULL
	181	&& keymgmt->gendomparams == NULL))
	182	\|\| (keymgmt->freekey != NULL
	183	&& (keymgmt->importkey == NULL
	184	&& keymgmt->genkey == NULL
	185	&& keymgmt->loadkey == NULL))
	186	\|\| (keymgmt->importdomparam_types != NULL
	187	&& keymgmt->importdomparams == NULL)
	188	\|\| (keymgmt->exportdomparam_types != NULL
	189	&& keymgmt->exportdomparams == NULL)
6508e858 RL	190	\|\| (keymgmt->gettable_domparam_params != NULL
6508e858 RL	191	&& keymgmt->get_domparam_params == NULL)
a94a3e0d RL	192	\|\| (keymgmt->importkey_types != NULL
	193	&& keymgmt->importkey == NULL)
	194	\|\| (keymgmt->exportkey_types != NULL
6508e858 RL	195	&& keymgmt->exportkey == NULL)
	196	\|\| (keymgmt->gettable_key_params != NULL
	197	&& keymgmt->get_key_params == NULL)) {
a94a3e0d RL	198	EVP_KEYMGMT_free(keymgmt);
	199	EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
	200	return NULL;
	201	}
	202	keymgmt->prov = prov;
	203	if (prov != NULL)
	204	ossl_provider_up_ref(prov);
	205
	206	return keymgmt;
	207	}
	208
f7c16d48 RL	209	EVP_KEYMGMT evp_keymgmt_fetch_by_number(OPENSSL_CTX ctx, int name_id,
	210	const char *properties)
	211	{
	212	return evp_generic_fetch_by_number(ctx,
	213	OSSL_OP_KEYMGMT, name_id, properties,
0ddf74bf	214	keymgmt_from_dispatch,
f7c16d48 RL	215	(int ()(void ))EVP_KEYMGMT_up_ref,
	216	(void ()(void ))EVP_KEYMGMT_free);
	217	}
	218
a94a3e0d RL	219	EVP_KEYMGMT EVP_KEYMGMT_fetch(OPENSSL_CTX ctx, const char *algorithm,
	220	const char *properties)
	221	{
f7c16d48	222	return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
0ddf74bf	223	keymgmt_from_dispatch,
f7c16d48 RL	224	(int ()(void ))EVP_KEYMGMT_up_ref,
f7c16d48 RL	225	(void ()(void ))EVP_KEYMGMT_free);
a94a3e0d RL	226	}
	227
	228	int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
	229	{
	230	int ref = 0;
	231
	232	CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
	233	return 1;
	234	}
	235
	236	void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
	237	{
	238	int ref = 0;
	239
	240	if (keymgmt == NULL)
	241	return;
	242
	243	CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
	244	if (ref > 0)
	245	return;
	246	ossl_provider_free(keymgmt->prov);
	247	CRYPTO_THREAD_lock_free(keymgmt->lock);
	248	OPENSSL_free(keymgmt);
	249	}
	250
	251	const OSSL_PROVIDER EVP_KEYMGMT_provider(const EVP_KEYMGMT keymgmt)
	252	{
	253	return keymgmt->prov;
	254	}
	255
506cb0f6 RL	256	int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
	257	{
	258	return keymgmt->name_id;
	259	}
	260
251e610c RL	261	int EVP_KEYMGMT_is_a(const EVP_KEYMGMT keymgmt, const char name)
251e610c RL	262	{
e4a1d023	263	return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
251e610c RL	264	}
	265
	266	void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
	267	void (fn)(EVP_KEYMGMT keymgmt, void *arg),
	268	void *arg)
	269	{
	270	evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
	271	(void ()(void , void *))fn, arg,
0ddf74bf	272	keymgmt_from_dispatch,
251e610c RL	273	(void ()(void ))EVP_KEYMGMT_free);
251e610c RL	274	}
f651c727 RL	275
	276	void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
	277	void (fn)(const char name, void *data),
	278	void *data)
	279	{
	280	if (keymgmt->prov != NULL)
	281	evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
	282	}
68552cde RL	283
	284	/*
	285	* Internal API that interfaces with the method function pointers
	286	*/
	287	void evp_keymgmt_importdomparams(const EVP_KEYMGMT keymgmt,
	288	const OSSL_PARAM params[])
	289	{
	290	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	291
	292	return keymgmt->importdomparams(provctx, params);
	293	}
	294
	295	void evp_keymgmt_gendomparams(const EVP_KEYMGMT keymgmt,
	296	const OSSL_PARAM params[])
	297	{
	298	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	299
	300	return keymgmt->gendomparams(provctx, params);
	301	}
	302
	303	void evp_keymgmt_freedomparams(const EVP_KEYMGMT *keymgmt,
	304	void *provdomparams)
	305	{
	306	keymgmt->freedomparams(provdomparams);
	307	}
	308
	309	int evp_keymgmt_exportdomparams(const EVP_KEYMGMT *keymgmt,
	310	void *provdomparams,
	311	OSSL_CALLBACK param_cb, void cbarg)
	312	{
	313	return keymgmt->exportdomparams(provdomparams, param_cb, cbarg);
	314	}
	315
	316	const OSSL_PARAM evp_keymgmt_importdomparam_types(const EVP_KEYMGMT keymgmt)
	317	{
	318	return keymgmt->importdomparam_types();
	319	}
	320
	321	/*
	322	* TODO(v3.0) investigate if we need this function. 'openssl provider' may
	323	* be a caller...
	324	*/
	325	const OSSL_PARAM evp_keymgmt_exportdomparam_types(const EVP_KEYMGMT keymgmt)
	326	{
	327	return keymgmt->exportdomparam_types();
	328	}
	329
	330	int evp_keymgmt_get_domparam_params(const EVP_KEYMGMT *keymgmt,
	331	void *provdomparams, OSSL_PARAM params[])
	332	{
	333	if (keymgmt->get_domparam_params == NULL)
	334	return 1;
	335	return keymgmt->get_domparam_params(provdomparams, params);
	336	}
	337
	338	const OSSL_PARAM *
	339	evp_keymgmt_gettable_domparam_params(const EVP_KEYMGMT *keymgmt)
	340	{
	341	if (keymgmt->gettable_domparam_params == NULL)
	342	return NULL;
	343	return keymgmt->gettable_domparam_params();
	344	}
	345
	346
347	void evp_keymgmt_importkey(const EVP_KEYMGMT keymgmt,
348	const OSSL_PARAM params[])
349	{
350	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
351
352	return keymgmt->importkey(provctx, params);
353	}
354
355	void evp_keymgmt_genkey(const EVP_KEYMGMT keymgmt, void *domparams,
356	const OSSL_PARAM params[])
357	{
358	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
359
360	return keymgmt->genkey(provctx, domparams, params);
361	}
362
363	void evp_keymgmt_loadkey(const EVP_KEYMGMT keymgmt,
364	void *id, size_t idlen)
365	{
366	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
367
368	return keymgmt->loadkey(provctx, id, idlen);
369	}
370
371	void evp_keymgmt_freekey(const EVP_KEYMGMT keymgmt, void provkey)
372	{
373	keymgmt->freekey(provkey);
374	}
375
376	int evp_keymgmt_exportkey(const EVP_KEYMGMT keymgmt, void provkey,
377	OSSL_CALLBACK param_cb, void cbarg)
378	{
379	return keymgmt->exportkey(provkey, param_cb, cbarg);
380	}
381
382	const OSSL_PARAM evp_keymgmt_importkey_types(const EVP_KEYMGMT keymgmt)
383	{
384	return keymgmt->importkey_types();
385	}
386
387	/*
388	* TODO(v3.0) investigate if we need this function. 'openssl provider' may
389	* be a caller...
390	*/
391	const OSSL_PARAM evp_keymgmt_exportkey_types(const EVP_KEYMGMT keymgmt)
392	{
393	return keymgmt->exportkey_types();
394	}
395
396	int evp_keymgmt_get_key_params(const EVP_KEYMGMT *keymgmt,
397	void *provkey, OSSL_PARAM params[])
398	{
399	if (keymgmt->get_key_params == NULL)
400	return 1;
401	return keymgmt->get_key_params(provkey, params);
402	}
403
404	const OSSL_PARAM evp_keymgmt_gettable_key_params(const EVP_KEYMGMT keymgmt)
405	{
406	if (keymgmt->gettable_key_params == NULL)
407	return NULL;
408	return keymgmt->gettable_key_params();
409	}
410
411	int evp_keymgmt_validate_domparams(const EVP_KEYMGMT keymgmt, void provkey)
412	{
413	/* if domainparams are not supported - then pass */
414	if (keymgmt->validatedomparams == NULL)
415	return 1;
416	return keymgmt->validatedomparams(provkey);
417	}
418
419	int evp_keymgmt_validate_public(const EVP_KEYMGMT keymgmt, void provkey)
420	{
421	return keymgmt->validatepublic(provkey);
422	}
423
424	int evp_keymgmt_validate_private(const EVP_KEYMGMT keymgmt, void provkey)
425	{
426	return keymgmt->validateprivate(provkey);
427	}
428
429	int evp_keymgmt_validate_pairwise(const EVP_KEYMGMT keymgmt, void provkey)
430	{
431	return keymgmt->validatepairwise(provkey);
432	}