[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;
    int setparamfncnt = 0, getparamfncnt = 0;
    int setgenparamfncnt = 0, getgenparamfncnt = 0;
    int importfncnt = 0, exportfncnt = 0;

    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_NEW:
            if (keymgmt->new == NULL)
                keymgmt->new = OSSL_get_OP_keymgmt_new(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GEN_INIT:
            if (keymgmt->gen_init == NULL)
                keymgmt->gen_init = OSSL_get_OP_keymgmt_gen_init(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE:
            if (keymgmt->gen_set_template == NULL)
                keymgmt->gen_set_template =
                    OSSL_get_OP_keymgmt_gen_set_template(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS:
            if (keymgmt->gen_set_params == NULL) {
                setgenparamfncnt++;
                keymgmt->gen_set_params =
                    OSSL_get_OP_keymgmt_gen_set_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS:
            if (keymgmt->gen_settable_params == NULL) {
                setgenparamfncnt++;
                keymgmt->gen_settable_params =
                    OSSL_get_OP_keymgmt_gen_settable_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_GEN_GET_PARAMS:
            if (keymgmt->gen_get_params == NULL) {
                getgenparamfncnt++;
                keymgmt->gen_get_params =
                    OSSL_get_OP_keymgmt_gen_get_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_GEN_GETTABLE_PARAMS:
            if (keymgmt->gen_gettable_params == NULL) {
                getgenparamfncnt++;
                keymgmt->gen_gettable_params =
                    OSSL_get_OP_keymgmt_gen_gettable_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_GEN:
            if (keymgmt->gen == NULL)
                keymgmt->gen = OSSL_get_OP_keymgmt_gen(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GEN_CLEANUP:
            if (keymgmt->gen_cleanup == NULL)
                keymgmt->gen_cleanup = OSSL_get_OP_keymgmt_gen_cleanup(fns);
            break;
        case OSSL_FUNC_KEYMGMT_FREE:
            if (keymgmt->free == NULL)
                keymgmt->free = OSSL_get_OP_keymgmt_free(fns);
            break;
        case OSSL_FUNC_KEYMGMT_GET_PARAMS:
            if (keymgmt->get_params == NULL) {
                getparamfncnt++;
                keymgmt->get_params = OSSL_get_OP_keymgmt_get_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS:
            if (keymgmt->gettable_params == NULL) {
                getparamfncnt++;
                keymgmt->gettable_params =
                    OSSL_get_OP_keymgmt_gettable_params(fns);
            }
            break;
         case OSSL_FUNC_KEYMGMT_SET_PARAMS:
            if (keymgmt->set_params == NULL) {
                setparamfncnt++;
                keymgmt->set_params = OSSL_get_OP_keymgmt_set_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS:
            if (keymgmt->settable_params == NULL) {
                setparamfncnt++;
                keymgmt->settable_params =
                    OSSL_get_OP_keymgmt_settable_params(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
            if (keymgmt->query_operation_name == NULL)
                keymgmt->query_operation_name =
                    OSSL_get_OP_keymgmt_query_operation_name(fns);
            break;
        case OSSL_FUNC_KEYMGMT_HAS:
            if (keymgmt->has == NULL)
                keymgmt->has = OSSL_get_OP_keymgmt_has(fns);
            break;
        case OSSL_FUNC_KEYMGMT_VALIDATE:
            if (keymgmt->validate == NULL)
                keymgmt->validate = OSSL_get_OP_keymgmt_validate(fns);
            break;
        case OSSL_FUNC_KEYMGMT_MATCH:
            if (keymgmt->match == NULL)
                keymgmt->match = OSSL_get_OP_keymgmt_match(fns);
            break;
        case OSSL_FUNC_KEYMGMT_IMPORT:
            if (keymgmt->import == NULL) {
                importfncnt++;
                keymgmt->import = OSSL_get_OP_keymgmt_import(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_IMPORT_TYPES:
            if (keymgmt->import_types == NULL) {
                importfncnt++;
                keymgmt->import_types = OSSL_get_OP_keymgmt_import_types(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_EXPORT:
            if (keymgmt->export == NULL) {
                exportfncnt++;
                keymgmt->export = OSSL_get_OP_keymgmt_export(fns);
            }
            break;
        case OSSL_FUNC_KEYMGMT_EXPORT_TYPES:
            if (keymgmt->export_types == NULL) {
                exportfncnt++;
                keymgmt->export_types = OSSL_get_OP_keymgmt_export_types(fns);
            }
            break;
        }
    }
    /*
     * Try to check that the method is sensible.
     * At least one constructor and the destructor are MANDATORY
     * The functions 'has' is MANDATORY
     * 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->free == NULL
        || (keymgmt->new == NULL && keymgmt->gen == NULL)
        || keymgmt->has == NULL
        || (getparamfncnt != 0 && getparamfncnt != 2)
        || (setparamfncnt != 0 && setparamfncnt != 2)
        || (setgenparamfncnt != 0 && setgenparamfncnt != 2)
        || (getgenparamfncnt != 0 && getgenparamfncnt != 2)
        || (importfncnt != 0 && importfncnt != 2)
        || (exportfncnt != 0 && exportfncnt != 2)
        || (keymgmt->gen != NULL
            && (keymgmt->gen_init == NULL
                || keymgmt->gen_cleanup == 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_newdata(const EVP_KEYMGMT *keymgmt)
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    /*
     * TODO(3.0) 'new' is currently mandatory on its own, but when new
     * constructors appear, it won't be quite as mandatory, so we have
     * a check for future cases.
     */
    if (keymgmt->new == NULL)
        return NULL;
    return keymgmt->new(provctx);
}

void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keydata)
{
    /* This is mandatory, no need to check for its presence */
    keymgmt->free(keydata);
}

void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection)
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    if (keymgmt->gen_init == NULL)
        return NULL;
    return keymgmt->gen_init(provctx, selection);
}

int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx,
                                 void *template)
{
    /*
     * It's arguable if we actually should return success in this case, as
     * it allows the caller to set a template key, which is then ignored.
     * However, this is how the legacy methods (EVP_PKEY_METHOD) operate,
     * so we do this in the interest of backward compatibility.
     * TODO(3.0) Investigate if we should change this behaviour.
     */
    if (keymgmt->gen_set_template == NULL)
        return 1;
    return keymgmt->gen_set_template(genctx, template);
}

int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx,
                               const OSSL_PARAM params[])
{
    if (keymgmt->gen_set_params == NULL)
        return 0;
    return keymgmt->gen_set_params(genctx, params);
}

const OSSL_PARAM *evp_keymgmt_gen_settable_params(const EVP_KEYMGMT *keymgmt)
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    if (keymgmt->gen_settable_params == NULL)
        return NULL;
    return keymgmt->gen_settable_params(provctx);
}

int evp_keymgmt_gen_get_params(const EVP_KEYMGMT *keymgmt, void *genctx,
                               OSSL_PARAM params[])
{
    if (keymgmt->gen_get_params == NULL)
        return 0;
    return keymgmt->gen_get_params(genctx, params);
}

const OSSL_PARAM *evp_keymgmt_gen_gettable_params(const EVP_KEYMGMT *keymgmt)
{
    void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));

    if (keymgmt->gen_gettable_params == NULL)
        return NULL;
    return keymgmt->gen_gettable_params(provctx);
}

void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx,
                      OSSL_CALLBACK *cb, void *cbarg)
{
    if (keymgmt->gen == NULL)
        return NULL;
    return keymgmt->gen(genctx, cb, cbarg);
}

void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx)
{
    if (keymgmt->gen != NULL)
        keymgmt->gen_cleanup(genctx);
}

int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, void *keydata,
                           OSSL_PARAM params[])
{
    if (keymgmt->get_params == NULL)
        return 1;
    return keymgmt->get_params(keydata, params);
}

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

int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, void *keydata,
                           const OSSL_PARAM params[])
{
    if (keymgmt->set_params == NULL)
        return 1;
    return keymgmt->set_params(keydata, params);
}

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

int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keydata, int selection)
{
    /* This is mandatory, no need to check for its presence */
    return keymgmt->has(keydata, selection);
}

int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
                         int selection)
{
    /* We assume valid if the implementation doesn't have a function */
    if (keymgmt->validate == NULL)
        return 1;
    return keymgmt->validate(keydata, selection);
}

int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
                      const void *keydata1, const void *keydata2,
                      int selection)
{
    /* We assume no match if the implementation doesn't have a function */
    if (keymgmt->match == NULL)
        return 0;
    return keymgmt->match(keydata1, keydata2, selection);
}

int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
                       int selection, const OSSL_PARAM params[])
{
    if (keymgmt->import == NULL)
        return 0;
    return keymgmt->import(keydata, selection, params);
}

const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
                                           int selection)
{
    if (keymgmt->import_types == NULL)
        return NULL;
    return keymgmt->import_types(selection);
}

int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
                       int selection, OSSL_CALLBACK *param_cb, void *cbarg)
{
    if (keymgmt->export == NULL)
        return 0;
    return keymgmt->export(keydata, selection, param_cb, cbarg);
}

const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
                                           int selection)
{
    if (keymgmt->export_types == NULL)
        return NULL;
    return keymgmt->export_types(selection);
}

int evp_keymgmt_copy(const EVP_KEYMGMT *keymgmt,
                     void *keydata_to, const void *keydata_from,
                     int selection)
{
    /* We assume no copy if the implementation doesn't have a function */
    if (keymgmt->copy == NULL)
        return 0;
    return keymgmt->copy(keydata_to, keydata_from, selection);
}
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	{
a94a3e0d RL	40	EVP_KEYMGMT *keymgmt = NULL;
2b9add69 RL	41	int setparamfncnt = 0, getparamfncnt = 0;
2b9add69 RL	42	int setgenparamfncnt = 0, getgenparamfncnt = 0;
1a5632e0	43	int importfncnt = 0, exportfncnt = 0;
a94a3e0d	44
f7c16d48	45	if ((keymgmt = keymgmt_new()) == NULL) {
6b9e3724	46	EVP_KEYMGMT_free(keymgmt);
a94a3e0d	47	return NULL;
6b9e3724	48	}
f7c16d48	49	keymgmt->name_id = name_id;
a94a3e0d RL	50
	51	for (; fns->function_id != 0; fns++) {
	52	switch (fns->function_id) {
b305452f RL	53	case OSSL_FUNC_KEYMGMT_NEW:
	54	if (keymgmt->new == NULL)
	55	keymgmt->new = OSSL_get_OP_keymgmt_new(fns);
a94a3e0d	56	break;
1a5632e0 RL	57	case OSSL_FUNC_KEYMGMT_GEN_INIT:
	58	if (keymgmt->gen_init == NULL)
	59	keymgmt->gen_init = OSSL_get_OP_keymgmt_gen_init(fns);
	60	break;
	61	case OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE:
	62	if (keymgmt->gen_set_template == NULL)
	63	keymgmt->gen_set_template =
	64	OSSL_get_OP_keymgmt_gen_set_template(fns);
	65	break;
	66	case OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS:
	67	if (keymgmt->gen_set_params == NULL) {
	68	setgenparamfncnt++;
	69	keymgmt->gen_set_params =
	70	OSSL_get_OP_keymgmt_gen_set_params(fns);
	71	}
	72	break;
	73	case OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS:
	74	if (keymgmt->gen_settable_params == NULL) {
	75	setgenparamfncnt++;
	76	keymgmt->gen_settable_params =
	77	OSSL_get_OP_keymgmt_gen_settable_params(fns);
	78	}
	79	break;
2b9add69 RL	80	case OSSL_FUNC_KEYMGMT_GEN_GET_PARAMS:
	81	if (keymgmt->gen_get_params == NULL) {
	82	getgenparamfncnt++;
	83	keymgmt->gen_get_params =
	84	OSSL_get_OP_keymgmt_gen_get_params(fns);
	85	}
	86	break;
	87	case OSSL_FUNC_KEYMGMT_GEN_GETTABLE_PARAMS:
	88	if (keymgmt->gen_gettable_params == NULL) {
	89	getgenparamfncnt++;
	90	keymgmt->gen_gettable_params =
	91	OSSL_get_OP_keymgmt_gen_gettable_params(fns);
	92	}
	93	break;
1a5632e0 RL	94	case OSSL_FUNC_KEYMGMT_GEN:
	95	if (keymgmt->gen == NULL)
	96	keymgmt->gen = OSSL_get_OP_keymgmt_gen(fns);
	97	break;
	98	case OSSL_FUNC_KEYMGMT_GEN_CLEANUP:
	99	if (keymgmt->gen_cleanup == NULL)
	100	keymgmt->gen_cleanup = OSSL_get_OP_keymgmt_gen_cleanup(fns);
	101	break;
b305452f RL	102	case OSSL_FUNC_KEYMGMT_FREE:
	103	if (keymgmt->free == NULL)
	104	keymgmt->free = OSSL_get_OP_keymgmt_free(fns);
a94a3e0d	105	break;
b305452f	106	case OSSL_FUNC_KEYMGMT_GET_PARAMS:
273a67e3	107	if (keymgmt->get_params == NULL) {
4fe54d67	108	getparamfncnt++;
b305452f	109	keymgmt->get_params = OSSL_get_OP_keymgmt_get_params(fns);
273a67e3	110	}
a94a3e0d	111	break;
b305452f	112	case OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS:
273a67e3	113	if (keymgmt->gettable_params == NULL) {
4fe54d67	114	getparamfncnt++;
b305452f RL	115	keymgmt->gettable_params =
b305452f RL	116	OSSL_get_OP_keymgmt_gettable_params(fns);
273a67e3	117	}
a94a3e0d	118	break;
4fe54d67 NT	119	case OSSL_FUNC_KEYMGMT_SET_PARAMS:
	120	if (keymgmt->set_params == NULL) {
	121	setparamfncnt++;
	122	keymgmt->set_params = OSSL_get_OP_keymgmt_set_params(fns);
	123	}
	124	break;
	125	case OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS:
	126	if (keymgmt->settable_params == NULL) {
	127	setparamfncnt++;
	128	keymgmt->settable_params =
	129	OSSL_get_OP_keymgmt_settable_params(fns);
	130	}
	131	break;
b305452f RL	132	case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
	133	if (keymgmt->query_operation_name == NULL)
	134	keymgmt->query_operation_name =
	135	OSSL_get_OP_keymgmt_query_operation_name(fns);
6508e858	136	break;
b305452f RL	137	case OSSL_FUNC_KEYMGMT_HAS:
	138	if (keymgmt->has == NULL)
	139	keymgmt->has = OSSL_get_OP_keymgmt_has(fns);
6508e858	140	break;
b305452f RL	141	case OSSL_FUNC_KEYMGMT_VALIDATE:
	142	if (keymgmt->validate == NULL)
	143	keymgmt->validate = OSSL_get_OP_keymgmt_validate(fns);
e62a45b6	144	break;
bee5d6cd RL	145	case OSSL_FUNC_KEYMGMT_MATCH:
	146	if (keymgmt->match == NULL)
	147	keymgmt->match = OSSL_get_OP_keymgmt_match(fns);
	148	break;
b305452f	149	case OSSL_FUNC_KEYMGMT_IMPORT:
273a67e3 RL	150	if (keymgmt->import == NULL) {
273a67e3 RL	151	importfncnt++;
b305452f	152	keymgmt->import = OSSL_get_OP_keymgmt_import(fns);
273a67e3	153	}
12603de6	154	break;
b305452f	155	case OSSL_FUNC_KEYMGMT_IMPORT_TYPES:
273a67e3 RL	156	if (keymgmt->import_types == NULL) {
273a67e3 RL	157	importfncnt++;
b305452f	158	keymgmt->import_types = OSSL_get_OP_keymgmt_import_types(fns);
273a67e3	159	}
12603de6	160	break;
b305452f	161	case OSSL_FUNC_KEYMGMT_EXPORT:
273a67e3 RL	162	if (keymgmt->export == NULL) {
273a67e3 RL	163	exportfncnt++;
b305452f	164	keymgmt->export = OSSL_get_OP_keymgmt_export(fns);
273a67e3	165	}
12603de6	166	break;
b305452f	167	case OSSL_FUNC_KEYMGMT_EXPORT_TYPES:
273a67e3 RL	168	if (keymgmt->export_types == NULL) {
273a67e3 RL	169	exportfncnt++;
b305452f	170	keymgmt->export_types = OSSL_get_OP_keymgmt_export_types(fns);
273a67e3	171	}
12603de6	172	break;
a94a3e0d RL	173	}
	174	}
	175	/*
	176	* Try to check that the method is sensible.
b305452f RL	177	* At least one constructor and the destructor are MANDATORY
b305452f RL	178	* The functions 'has' is MANDATORY
a94a3e0d RL	179	* It makes no sense being able to free stuff if you can't create it.
	180	* It makes no sense providing OSSL_PARAM descriptors for import and
	181	* export if you can't import or export.
	182	*/
b305452f	183	if (keymgmt->free == NULL
1a5632e0	184	\|\| (keymgmt->new == NULL && keymgmt->gen == NULL)
b305452f	185	\|\| keymgmt->has == NULL
4fe54d67 NT	186	\|\| (getparamfncnt != 0 && getparamfncnt != 2)
4fe54d67 NT	187	\|\| (setparamfncnt != 0 && setparamfncnt != 2)
1a5632e0	188	\|\| (setgenparamfncnt != 0 && setgenparamfncnt != 2)
2b9add69	189	\|\| (getgenparamfncnt != 0 && getgenparamfncnt != 2)
273a67e3	190	\|\| (importfncnt != 0 && importfncnt != 2)
1a5632e0 RL	191	\|\| (exportfncnt != 0 && exportfncnt != 2)
	192	\|\| (keymgmt->gen != NULL
	193	&& (keymgmt->gen_init == NULL
	194	\|\| keymgmt->gen_cleanup == NULL))) {
a94a3e0d RL	195	EVP_KEYMGMT_free(keymgmt);
	196	EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
	197	return NULL;
	198	}
	199	keymgmt->prov = prov;
	200	if (prov != NULL)
	201	ossl_provider_up_ref(prov);
	202
	203	return keymgmt;
	204	}
	205
f7c16d48 RL	206	EVP_KEYMGMT evp_keymgmt_fetch_by_number(OPENSSL_CTX ctx, int name_id,
	207	const char *properties)
	208	{
	209	return evp_generic_fetch_by_number(ctx,
	210	OSSL_OP_KEYMGMT, name_id, properties,
0ddf74bf	211	keymgmt_from_dispatch,
f7c16d48 RL	212	(int ()(void ))EVP_KEYMGMT_up_ref,
	213	(void ()(void ))EVP_KEYMGMT_free);
	214	}
	215
a94a3e0d RL	216	EVP_KEYMGMT EVP_KEYMGMT_fetch(OPENSSL_CTX ctx, const char *algorithm,
	217	const char *properties)
	218	{
f7c16d48	219	return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
0ddf74bf	220	keymgmt_from_dispatch,
f7c16d48 RL	221	(int ()(void ))EVP_KEYMGMT_up_ref,
f7c16d48 RL	222	(void ()(void ))EVP_KEYMGMT_free);
a94a3e0d RL	223	}
	224
	225	int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
	226	{
	227	int ref = 0;
	228
	229	CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
	230	return 1;
	231	}
	232
	233	void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
	234	{
	235	int ref = 0;
	236
	237	if (keymgmt == NULL)
	238	return;
	239
	240	CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
	241	if (ref > 0)
	242	return;
	243	ossl_provider_free(keymgmt->prov);
	244	CRYPTO_THREAD_lock_free(keymgmt->lock);
	245	OPENSSL_free(keymgmt);
	246	}
	247
	248	const OSSL_PROVIDER EVP_KEYMGMT_provider(const EVP_KEYMGMT keymgmt)
	249	{
	250	return keymgmt->prov;
	251	}
	252
506cb0f6 RL	253	int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
	254	{
	255	return keymgmt->name_id;
	256	}
	257
251e610c RL	258	int EVP_KEYMGMT_is_a(const EVP_KEYMGMT keymgmt, const char name)
251e610c RL	259	{
e4a1d023	260	return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
251e610c RL	261	}
	262
	263	void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
	264	void (fn)(EVP_KEYMGMT keymgmt, void *arg),
	265	void *arg)
	266	{
	267	evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
	268	(void ()(void , void *))fn, arg,
0ddf74bf	269	keymgmt_from_dispatch,
251e610c RL	270	(void ()(void ))EVP_KEYMGMT_free);
251e610c RL	271	}
f651c727 RL	272
	273	void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
	274	void (fn)(const char name, void *data),
	275	void *data)
	276	{
	277	if (keymgmt->prov != NULL)
	278	evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
	279	}
68552cde RL	280
	281	/*
	282	* Internal API that interfaces with the method function pointers
	283	*/
b305452f	284	void evp_keymgmt_newdata(const EVP_KEYMGMT keymgmt)
68552cde RL	285	{
	286	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	287
b305452f RL	288	/*
	289	* TODO(3.0) 'new' is currently mandatory on its own, but when new
	290	* constructors appear, it won't be quite as mandatory, so we have
	291	* a check for future cases.
	292	*/
	293	if (keymgmt->new == NULL)
	294	return NULL;
	295	return keymgmt->new(provctx);
68552cde RL	296	}
68552cde RL	297
b305452f	298	void evp_keymgmt_freedata(const EVP_KEYMGMT keymgmt, void keydata)
68552cde	299	{
b305452f RL	300	/* This is mandatory, no need to check for its presence */
b305452f RL	301	keymgmt->free(keydata);
68552cde RL	302	}
68552cde RL	303
1a5632e0 RL	304	void evp_keymgmt_gen_init(const EVP_KEYMGMT keymgmt, int selection)
	305	{
	306	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	307
	308	if (keymgmt->gen_init == NULL)
	309	return NULL;
	310	return keymgmt->gen_init(provctx, selection);
	311	}
	312
	313	int evp_keymgmt_gen_set_template(const EVP_KEYMGMT keymgmt, void genctx,
	314	void *template)
	315	{
d0ddf9b4 RL	316	/*
	317	* It's arguable if we actually should return success in this case, as
	318	* it allows the caller to set a template key, which is then ignored.
	319	* However, this is how the legacy methods (EVP_PKEY_METHOD) operate,
	320	* so we do this in the interest of backward compatibility.
	321	* TODO(3.0) Investigate if we should change this behaviour.
	322	*/
1a5632e0	323	if (keymgmt->gen_set_template == NULL)
d0ddf9b4	324	return 1;
1a5632e0 RL	325	return keymgmt->gen_set_template(genctx, template);
	326	}
	327
	328	int evp_keymgmt_gen_set_params(const EVP_KEYMGMT keymgmt, void genctx,
	329	const OSSL_PARAM params[])
	330	{
	331	if (keymgmt->gen_set_params == NULL)
	332	return 0;
	333	return keymgmt->gen_set_params(genctx, params);
	334	}
	335
	336	const OSSL_PARAM evp_keymgmt_gen_settable_params(const EVP_KEYMGMT keymgmt)
	337	{
	338	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	339
	340	if (keymgmt->gen_settable_params == NULL)
	341	return NULL;
	342	return keymgmt->gen_settable_params(provctx);
	343	}
	344
2b9add69 RL	345	int evp_keymgmt_gen_get_params(const EVP_KEYMGMT keymgmt, void genctx,
	346	OSSL_PARAM params[])
	347	{
	348	if (keymgmt->gen_get_params == NULL)
	349	return 0;
	350	return keymgmt->gen_get_params(genctx, params);
	351	}
	352
	353	const OSSL_PARAM evp_keymgmt_gen_gettable_params(const EVP_KEYMGMT keymgmt)
	354	{
	355	void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
	356
	357	if (keymgmt->gen_gettable_params == NULL)
	358	return NULL;
	359	return keymgmt->gen_gettable_params(provctx);
	360	}
	361
1a5632e0 RL	362	void evp_keymgmt_gen(const EVP_KEYMGMT keymgmt, void *genctx,
	363	OSSL_CALLBACK cb, void cbarg)
	364	{
	365	if (keymgmt->gen == NULL)
	366	return NULL;
	367	return keymgmt->gen(genctx, cb, cbarg);
	368	}
	369
	370	void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT keymgmt, void genctx)
	371	{
	372	if (keymgmt->gen != NULL)
	373	keymgmt->gen_cleanup(genctx);
	374	}
	375
b305452f RL	376	int evp_keymgmt_get_params(const EVP_KEYMGMT keymgmt, void keydata,
b305452f RL	377	OSSL_PARAM params[])
68552cde	378	{
b305452f	379	if (keymgmt->get_params == NULL)
68552cde	380	return 1;
b305452f	381	return keymgmt->get_params(keydata, params);
68552cde RL	382	}
68552cde RL	383
b305452f	384	const OSSL_PARAM evp_keymgmt_gettable_params(const EVP_KEYMGMT keymgmt)
68552cde	385	{
b305452f	386	if (keymgmt->gettable_params == NULL)
68552cde	387	return NULL;
b305452f	388	return keymgmt->gettable_params();
68552cde RL	389	}
68552cde RL	390
4fe54d67 NT	391	int evp_keymgmt_set_params(const EVP_KEYMGMT keymgmt, void keydata,
	392	const OSSL_PARAM params[])
	393	{
	394	if (keymgmt->set_params == NULL)
	395	return 1;
	396	return keymgmt->set_params(keydata, params);
	397	}
	398
	399	const OSSL_PARAM evp_keymgmt_settable_params(const EVP_KEYMGMT keymgmt)
	400	{
	401	if (keymgmt->settable_params == NULL)
	402	return NULL;
	403	return keymgmt->settable_params();
	404	}
	405
b305452f	406	int evp_keymgmt_has(const EVP_KEYMGMT keymgmt, void keydata, int selection)
68552cde	407	{
b305452f RL	408	/* This is mandatory, no need to check for its presence */
b305452f RL	409	return keymgmt->has(keydata, selection);
68552cde RL	410	}
68552cde RL	411
b305452f RL	412	int evp_keymgmt_validate(const EVP_KEYMGMT keymgmt, void keydata,
b305452f RL	413	int selection)
68552cde	414	{
b305452f RL	415	/* We assume valid if the implementation doesn't have a function */
b305452f RL	416	if (keymgmt->validate == NULL)
68552cde	417	return 1;
b305452f	418	return keymgmt->validate(keydata, selection);
68552cde RL	419	}
68552cde RL	420
bee5d6cd RL	421	int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
	422	const void keydata1, const void keydata2,
	423	int selection)
	424	{
	425	/* We assume no match if the implementation doesn't have a function */
	426	if (keymgmt->match == NULL)
	427	return 0;
	428	return keymgmt->match(keydata1, keydata2, selection);
	429	}
	430
b305452f RL	431	int evp_keymgmt_import(const EVP_KEYMGMT keymgmt, void keydata,
b305452f RL	432	int selection, const OSSL_PARAM params[])
68552cde	433	{
b305452f RL	434	if (keymgmt->import == NULL)
	435	return 0;
	436	return keymgmt->import(keydata, selection, params);
68552cde RL	437	}
68552cde RL	438
b305452f RL	439	const OSSL_PARAM evp_keymgmt_import_types(const EVP_KEYMGMT keymgmt,
b305452f RL	440	int selection)
68552cde	441	{
b305452f RL	442	if (keymgmt->import_types == NULL)
	443	return NULL;
	444	return keymgmt->import_types(selection);
68552cde RL	445	}
68552cde RL	446
b305452f RL	447	int evp_keymgmt_export(const EVP_KEYMGMT keymgmt, void keydata,
b305452f RL	448	int selection, OSSL_CALLBACK param_cb, void cbarg)
68552cde	449	{
b305452f RL	450	if (keymgmt->export == NULL)
	451	return 0;
	452	return keymgmt->export(keydata, selection, param_cb, cbarg);
68552cde RL	453	}
68552cde RL	454
b305452f RL	455	const OSSL_PARAM evp_keymgmt_export_types(const EVP_KEYMGMT keymgmt,
b305452f RL	456	int selection)
68552cde	457	{
b305452f RL	458	if (keymgmt->export_types == NULL)
	459	return NULL;
	460	return keymgmt->export_types(selection);
68552cde	461	}
13697f1c RL	462
	463	int evp_keymgmt_copy(const EVP_KEYMGMT *keymgmt,
	464	void keydata_to, const void keydata_from,
	465	int selection)
	466	{
	467	/* We assume no copy if the implementation doesn't have a function */
	468	if (keymgmt->copy == NULL)
	469	return 0;
	470	return keymgmt->copy(keydata_to, keydata_from, selection);
	471	}