/src/openssl41/crypto/evp/skeymgmt_meth.c

Source
/*
 * Copyright 2025-2026 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_dispatch.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include "internal/core.h"
#include "internal/provider.h"
#include "internal/refcount.h"
#include "crypto/evp.h"
#include "evp_local.h"

static void evp_skeymgmt_free(void *s);

void *evp_skeymgmt_generate(const EVP_SKEYMGMT *skeymgmt, const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));

    return (skeymgmt->generate != NULL) ? skeymgmt->generate(provctx, params) : NULL;
}

void *evp_skeymgmt_import(const EVP_SKEYMGMT *skeymgmt, int selection, const OSSL_PARAM params[])
{
    void *provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));

    /* This is mandatory, no need to check for its presence */
    return skeymgmt->import(provctx, selection, params);
}

int evp_skeymgmt_export(const EVP_SKEYMGMT *skeymgmt, void *keydata,
    int selection, OSSL_CALLBACK *param_cb, void *cbarg)
{
    /* This is mandatory, no need to check for its presence */
    return skeymgmt->export(keydata, selection, param_cb, cbarg);
}

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

static void *skeymgmt_new(void)
{
    EVP_SKEYMGMT *skeymgmt = NULL;

    if ((skeymgmt = OPENSSL_zalloc(sizeof(*skeymgmt))) == NULL)
        return NULL;
    if (!CRYPTO_NEW_REF(&skeymgmt->refcnt, 1)) {
        evp_skeymgmt_free(skeymgmt);
        return NULL;
    }
    return skeymgmt;
}

static void *skeymgmt_from_algorithm(int name_id,
    const OSSL_ALGORITHM *algodef,
    OSSL_PROVIDER *prov, int no_store)
{
    const OSSL_DISPATCH *fns = algodef->implementation;
    EVP_SKEYMGMT *skeymgmt = NULL;

    if ((skeymgmt = skeymgmt_new()) == NULL)
        return NULL;

    skeymgmt->name_id = name_id;
    skeymgmt->no_store = no_store;
    if ((skeymgmt->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
        evp_skeymgmt_free(skeymgmt);
        return NULL;
    }
    skeymgmt->description = algodef->algorithm_description;

    for (; fns->function_id != 0; fns++) {
        switch (fns->function_id) {
        case OSSL_FUNC_SKEYMGMT_FREE:
            if (skeymgmt->free == NULL)
                skeymgmt->free = OSSL_FUNC_skeymgmt_free(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_IMPORT:
            if (skeymgmt->import == NULL)
                skeymgmt->import = OSSL_FUNC_skeymgmt_import(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_EXPORT:
            if (skeymgmt->export == NULL)
                skeymgmt->export = OSSL_FUNC_skeymgmt_export(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_GENERATE:
            if (skeymgmt->generate == NULL)
                skeymgmt->generate = OSSL_FUNC_skeymgmt_generate(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_GET_KEY_ID:
            if (skeymgmt->get_key_id == NULL)
                skeymgmt->get_key_id = OSSL_FUNC_skeymgmt_get_key_id(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_GET_LOCAL_KEYID:
            if (skeymgmt->get_local_keyid == NULL)
                skeymgmt->get_local_keyid = OSSL_FUNC_skeymgmt_get_local_keyid(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_GET_ALGORITHM_ID:
            if (skeymgmt->get_algorithm_id == NULL)
                skeymgmt->get_algorithm_id = OSSL_FUNC_skeymgmt_get_algorithm_id(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_IMP_SETTABLE_PARAMS:
            if (skeymgmt->imp_params == NULL)
                skeymgmt->imp_params = OSSL_FUNC_skeymgmt_imp_settable_params(fns);
            break;
        case OSSL_FUNC_SKEYMGMT_GEN_SETTABLE_PARAMS:
            if (skeymgmt->gen_params == NULL)
                skeymgmt->gen_params = OSSL_FUNC_skeymgmt_gen_settable_params(fns);
            break;
        }
    }

    /* Check that the provider is sensible */
    if (skeymgmt->free == NULL
        || skeymgmt->import == NULL
        || skeymgmt->export == NULL) {
        evp_skeymgmt_free(skeymgmt);
        ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
        return NULL;
    }

    if (!ossl_provider_up_ref(prov)) {
        evp_skeymgmt_free(skeymgmt);
        ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
        return NULL;
    }
    skeymgmt->prov = prov;

    return skeymgmt;
}

static int evp_skeymgmt_up_ref(void *s)
{
    EVP_SKEYMGMT *skeymgmt = (EVP_SKEYMGMT *)s;
    int ref = 0;

    return CRYPTO_UP_REF(&skeymgmt->refcnt, &ref);
}

static void evp_skeymgmt_free(void *s)
{
    EVP_SKEYMGMT *skeymgmt = (EVP_SKEYMGMT *)s;
    int ref = 0;

    if (skeymgmt == NULL)
        return;

    CRYPTO_DOWN_REF(&skeymgmt->refcnt, &ref);
    if (ref > 0)
        return;
    OPENSSL_free(skeymgmt->type_name);
    ossl_provider_free(skeymgmt->prov);
    CRYPTO_FREE_REF(&skeymgmt->refcnt);
    OPENSSL_free(skeymgmt);
}

EVP_SKEYMGMT *evp_skeymgmt_fetch_from_prov(OSSL_PROVIDER *prov,
    const char *name,
    const char *properties)
{
    return evp_generic_fetch_from_prov(prov,
        OSSL_OP_SKEYMGMT,
        name, properties,
        skeymgmt_from_algorithm,
        evp_skeymgmt_up_ref,
        evp_skeymgmt_free);
}

EVP_SKEYMGMT *EVP_SKEYMGMT_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
    const char *properties)
{
    return evp_generic_fetch(ctx, OSSL_OP_SKEYMGMT, algorithm, properties,
        skeymgmt_from_algorithm,
        evp_skeymgmt_up_ref,
        evp_skeymgmt_free);
}

int EVP_SKEYMGMT_up_ref(EVP_SKEYMGMT *skeymgmt)
{
#ifdef OPENSSL_NO_CACHED_FETCH
    return evp_skeymgmt_up_ref(skeymgmt);
#else
    if (skeymgmt->no_store != 0)
        return evp_skeymgmt_up_ref(skeymgmt);
    return 1;
#endif
}

void EVP_SKEYMGMT_free(EVP_SKEYMGMT *skeymgmt)
{
#ifdef OPENSSL_NO_CACHED_FETCH
    evp_skeymgmt_free(skeymgmt);
#else
    if (skeymgmt != NULL && (skeymgmt->no_store != 0))
        evp_skeymgmt_free(skeymgmt);
#endif
}

const OSSL_PROVIDER *EVP_SKEYMGMT_get0_provider(const EVP_SKEYMGMT *skeymgmt)
{
    return (skeymgmt != NULL) ? skeymgmt->prov : NULL;
}

const char *EVP_SKEYMGMT_get0_description(const EVP_SKEYMGMT *skeymgmt)
{
    return (skeymgmt != NULL) ? skeymgmt->description : NULL;
}

const char *EVP_SKEYMGMT_get0_name(const EVP_SKEYMGMT *skeymgmt)
{
    return (skeymgmt != NULL) ? skeymgmt->type_name : NULL;
}

int EVP_SKEYMGMT_is_a(const EVP_SKEYMGMT *skeymgmt, const char *name)
{
    return skeymgmt != NULL
        && evp_is_a(skeymgmt->prov, skeymgmt->name_id, NULL, name);
}

void EVP_SKEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
    void (*fn)(EVP_SKEYMGMT *skeymgmt, void *arg),
    void *arg)
{
    struct EVP_SKEYMGMT_do_all_provided_thunk t;

    t.fn = fn;
    t.arg = arg;
    evp_generic_do_all(libctx, OSSL_OP_SKEYMGMT,
        EVP_SKEYMGMT_do_all_provided_thunk, &t,
        skeymgmt_from_algorithm,
        evp_skeymgmt_up_ref,
        evp_skeymgmt_free);
}

int EVP_SKEYMGMT_names_do_all(const EVP_SKEYMGMT *skeymgmt,
    void (*fn)(const char *name, void *data),
    void *data)
{
    if (skeymgmt == NULL)
        return 0;

    if (skeymgmt->prov != NULL)
        return evp_names_do_all(skeymgmt->prov, skeymgmt->name_id, fn, data);

    return 1;
}

const OSSL_PARAM *EVP_SKEYMGMT_get0_gen_settable_params(const EVP_SKEYMGMT *skeymgmt)
{
    void *provctx = NULL;

    if (skeymgmt == NULL)
        return 0;

    provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));

    return (skeymgmt->gen_params != NULL) ? skeymgmt->gen_params(provctx) : NULL;
}

const OSSL_PARAM *EVP_SKEYMGMT_get0_imp_settable_params(const EVP_SKEYMGMT *skeymgmt)
{
    void *provctx = NULL;

    if (skeymgmt == NULL)
        return 0;

    provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));

    return (skeymgmt->imp_params != NULL) ? skeymgmt->imp_params(provctx) : NULL;
}

Coverage Report

Created: 2026-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 2025-2026 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_dispatch.h>
12		#include <openssl/evp.h>
13		#include <openssl/err.h>
14		#include "internal/core.h"
15		#include "internal/provider.h"
16		#include "internal/refcount.h"
17		#include "crypto/evp.h"
18		#include "evp_local.h"
19
20		static void evp_skeymgmt_free(void *s);
21
22		void evp_skeymgmt_generate(const EVP_SKEYMGMT skeymgmt, const OSSL_PARAM params[])
23	0	{
24	0	void *provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));
25
26	0	return (skeymgmt->generate != NULL) ? skeymgmt->generate(provctx, params) : NULL;
27	0	}
28
29		void evp_skeymgmt_import(const EVP_SKEYMGMT skeymgmt, int selection, const OSSL_PARAM params[])
30	0	{
31	0	void *provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));
32
33		/* This is mandatory, no need to check for its presence */
34	0	return skeymgmt->import(provctx, selection, params);
35	0	}
36
37		int evp_skeymgmt_export(const EVP_SKEYMGMT skeymgmt, void keydata,
38		int selection, OSSL_CALLBACK param_cb, void cbarg)
39	0	{
40		/* This is mandatory, no need to check for its presence */
41	0	return skeymgmt->export(keydata, selection, param_cb, cbarg);
42	0	}
43
44		void evp_skeymgmt_freedata(const EVP_SKEYMGMT skeymgmt, void keydata)
45	0	{
46		/* This is mandatory, no need to check for its presence */
47	0	skeymgmt->free(keydata);
48	0	}
49
50		static void *skeymgmt_new(void)
51	0	{
52	0	EVP_SKEYMGMT *skeymgmt = NULL;
53
54	0	if ((skeymgmt = OPENSSL_zalloc(sizeof(*skeymgmt))) == NULL)
55	0	return NULL;
56	0	if (!CRYPTO_NEW_REF(&skeymgmt->refcnt, 1)) {
57	0	evp_skeymgmt_free(skeymgmt);
58	0	return NULL;
59	0	}
60	0	return skeymgmt;
61	0	}
62
63		static void *skeymgmt_from_algorithm(int name_id,
64		const OSSL_ALGORITHM *algodef,
65		OSSL_PROVIDER *prov, int no_store)
66	0	{
67	0	const OSSL_DISPATCH *fns = algodef->implementation;
68	0	EVP_SKEYMGMT *skeymgmt = NULL;
69
70	0	if ((skeymgmt = skeymgmt_new()) == NULL)
71	0	return NULL;
72
73	0	skeymgmt->name_id = name_id;
74	0	skeymgmt->no_store = no_store;
75	0	if ((skeymgmt->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
76	0	evp_skeymgmt_free(skeymgmt);
77	0	return NULL;
78	0	}
79	0	skeymgmt->description = algodef->algorithm_description;
80
81	0	for (; fns->function_id != 0; fns++) {
82	0	switch (fns->function_id) {
83	0	case OSSL_FUNC_SKEYMGMT_FREE:
84	0	if (skeymgmt->free == NULL)
85	0	skeymgmt->free = OSSL_FUNC_skeymgmt_free(fns);
86	0	break;
87	0	case OSSL_FUNC_SKEYMGMT_IMPORT:
88	0	if (skeymgmt->import == NULL)
89	0	skeymgmt->import = OSSL_FUNC_skeymgmt_import(fns);
90	0	break;
91	0	case OSSL_FUNC_SKEYMGMT_EXPORT:
92	0	if (skeymgmt->export == NULL)
93	0	skeymgmt->export = OSSL_FUNC_skeymgmt_export(fns);
94	0	break;
95	0	case OSSL_FUNC_SKEYMGMT_GENERATE:
96	0	if (skeymgmt->generate == NULL)
97	0	skeymgmt->generate = OSSL_FUNC_skeymgmt_generate(fns);
98	0	break;
99	0	case OSSL_FUNC_SKEYMGMT_GET_KEY_ID:
100	0	if (skeymgmt->get_key_id == NULL)
101	0	skeymgmt->get_key_id = OSSL_FUNC_skeymgmt_get_key_id(fns);
102	0	break;
103	0	case OSSL_FUNC_SKEYMGMT_GET_LOCAL_KEYID:
104	0	if (skeymgmt->get_local_keyid == NULL)
105	0	skeymgmt->get_local_keyid = OSSL_FUNC_skeymgmt_get_local_keyid(fns);
106	0	break;
107	0	case OSSL_FUNC_SKEYMGMT_GET_ALGORITHM_ID:
108	0	if (skeymgmt->get_algorithm_id == NULL)
109	0	skeymgmt->get_algorithm_id = OSSL_FUNC_skeymgmt_get_algorithm_id(fns);
110	0	break;
111	0	case OSSL_FUNC_SKEYMGMT_IMP_SETTABLE_PARAMS:
112	0	if (skeymgmt->imp_params == NULL)
113	0	skeymgmt->imp_params = OSSL_FUNC_skeymgmt_imp_settable_params(fns);
114	0	break;
115	0	case OSSL_FUNC_SKEYMGMT_GEN_SETTABLE_PARAMS:
116	0	if (skeymgmt->gen_params == NULL)
117	0	skeymgmt->gen_params = OSSL_FUNC_skeymgmt_gen_settable_params(fns);
118	0	break;
119	0	}
120	0	}
121
122		/* Check that the provider is sensible */
123	0	if (skeymgmt->free == NULL
124	0	\|\| skeymgmt->import == NULL
125	0	\|\| skeymgmt->export == NULL) {
126	0	evp_skeymgmt_free(skeymgmt);
127	0	ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
128	0	return NULL;
129	0	}
130
131	0	if (!ossl_provider_up_ref(prov)) {
132	0	evp_skeymgmt_free(skeymgmt);
133	0	ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
134	0	return NULL;
135	0	}
136	0	skeymgmt->prov = prov;
137
138	0	return skeymgmt;
139	0	}
140
141		static int evp_skeymgmt_up_ref(void *s)
142	0	{
143	0	EVP_SKEYMGMT skeymgmt = (EVP_SKEYMGMT )s;
144	0	int ref = 0;
145
146	0	return CRYPTO_UP_REF(&skeymgmt->refcnt, &ref);
147	0	}
148
149		static void evp_skeymgmt_free(void *s)
150	0	{
151	0	EVP_SKEYMGMT skeymgmt = (EVP_SKEYMGMT )s;
152	0	int ref = 0;
153
154	0	if (skeymgmt == NULL)
155	0	return;
156
157	0	CRYPTO_DOWN_REF(&skeymgmt->refcnt, &ref);
158	0	if (ref > 0)
159	0	return;
160	0	OPENSSL_free(skeymgmt->type_name);
161	0	ossl_provider_free(skeymgmt->prov);
162	0	CRYPTO_FREE_REF(&skeymgmt->refcnt);
163	0	OPENSSL_free(skeymgmt);
164	0	}
165
166		EVP_SKEYMGMT evp_skeymgmt_fetch_from_prov(OSSL_PROVIDER prov,
167		const char *name,
168		const char *properties)
169	0	{
170	0	return evp_generic_fetch_from_prov(prov,
171	0	OSSL_OP_SKEYMGMT,
172	0	name, properties,
173	0	skeymgmt_from_algorithm,
174	0	evp_skeymgmt_up_ref,
175	0	evp_skeymgmt_free);
176	0	}
177
178		EVP_SKEYMGMT EVP_SKEYMGMT_fetch(OSSL_LIB_CTX ctx, const char *algorithm,
179		const char *properties)
180	0	{
181	0	return evp_generic_fetch(ctx, OSSL_OP_SKEYMGMT, algorithm, properties,
182	0	skeymgmt_from_algorithm,
183	0	evp_skeymgmt_up_ref,
184	0	evp_skeymgmt_free);
185	0	}
186
187		int EVP_SKEYMGMT_up_ref(EVP_SKEYMGMT *skeymgmt)
188	0	{
189		#ifdef OPENSSL_NO_CACHED_FETCH
190		return evp_skeymgmt_up_ref(skeymgmt);
191		#else
192	0	if (skeymgmt->no_store != 0)
193	0	return evp_skeymgmt_up_ref(skeymgmt);
194	0	return 1;
195	0	#endif
196	0	}
197
198		void EVP_SKEYMGMT_free(EVP_SKEYMGMT *skeymgmt)
199	0	{
200		#ifdef OPENSSL_NO_CACHED_FETCH
201		evp_skeymgmt_free(skeymgmt);
202		#else
203	0	if (skeymgmt != NULL && (skeymgmt->no_store != 0))
204	0	evp_skeymgmt_free(skeymgmt);
205	0	#endif
206	0	}
207
208		const OSSL_PROVIDER EVP_SKEYMGMT_get0_provider(const EVP_SKEYMGMT skeymgmt)
209	0	{
210	0	return (skeymgmt != NULL) ? skeymgmt->prov : NULL;
211	0	}
212
213		const char EVP_SKEYMGMT_get0_description(const EVP_SKEYMGMT skeymgmt)
214	0	{
215	0	return (skeymgmt != NULL) ? skeymgmt->description : NULL;
216	0	}
217
218		const char EVP_SKEYMGMT_get0_name(const EVP_SKEYMGMT skeymgmt)
219	0	{
220	0	return (skeymgmt != NULL) ? skeymgmt->type_name : NULL;
221	0	}
222
223		int EVP_SKEYMGMT_is_a(const EVP_SKEYMGMT skeymgmt, const char name)
224	0	{
225	0	return skeymgmt != NULL
226	0	&& evp_is_a(skeymgmt->prov, skeymgmt->name_id, NULL, name);
227	0	}
228
229		void EVP_SKEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
230		void (fn)(EVP_SKEYMGMT skeymgmt, void *arg),
231		void *arg)
232	0	{
233	0	struct EVP_SKEYMGMT_do_all_provided_thunk t;
234
235	0	t.fn = fn;
236	0	t.arg = arg;
237	0	evp_generic_do_all(libctx, OSSL_OP_SKEYMGMT,
238	0	EVP_SKEYMGMT_do_all_provided_thunk, &t,
239	0	skeymgmt_from_algorithm,
240	0	evp_skeymgmt_up_ref,
241	0	evp_skeymgmt_free);
242	0	}
243
244		int EVP_SKEYMGMT_names_do_all(const EVP_SKEYMGMT *skeymgmt,
245		void (fn)(const char name, void *data),
246		void *data)
247	0	{
248	0	if (skeymgmt == NULL)
249	0	return 0;
250
251	0	if (skeymgmt->prov != NULL)
252	0	return evp_names_do_all(skeymgmt->prov, skeymgmt->name_id, fn, data);
253
254	0	return 1;
255	0	}
256
257		const OSSL_PARAM EVP_SKEYMGMT_get0_gen_settable_params(const EVP_SKEYMGMT skeymgmt)
258	0	{
259	0	void *provctx = NULL;
260
261	0	if (skeymgmt == NULL)
262	0	return 0;
263
264	0	provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));
265
266	0	return (skeymgmt->gen_params != NULL) ? skeymgmt->gen_params(provctx) : NULL;
267	0	}
268
269		const OSSL_PARAM EVP_SKEYMGMT_get0_imp_settable_params(const EVP_SKEYMGMT skeymgmt)
270	0	{
271	0	void *provctx = NULL;
272
273	0	if (skeymgmt == NULL)
274	0	return 0;
275
276	0	provctx = ossl_provider_ctx(EVP_SKEYMGMT_get0_provider(skeymgmt));
277
278	0	return (skeymgmt->imp_params != NULL) ? skeymgmt->imp_params(provctx) : NULL;
279	0	}