/src/msquic/submodules/quictls/providers/common/provider_util.c

Source (jump to first uncovered line)
/*
 * Copyright 2019-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
 */

/* We need to use some engine deprecated APIs */
#define OPENSSL_SUPPRESS_DEPRECATED

#include <openssl/evp.h>
#include <openssl/core_names.h>
#include <openssl/err.h>
#include <openssl/proverr.h>
#ifndef FIPS_MODULE
# include <openssl/engine.h>
# include "crypto/evp.h"
#endif
#include "prov/provider_util.h"

void ossl_prov_cipher_reset(PROV_CIPHER *pc)
{
    EVP_CIPHER_free(pc->alloc_cipher);
    pc->alloc_cipher = NULL;
    pc->cipher = NULL;
#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    ENGINE_finish(pc->engine);
#endif
    pc->engine = NULL;
}

int ossl_prov_cipher_copy(PROV_CIPHER *dst, const PROV_CIPHER *src)
{
    if (src->alloc_cipher != NULL && !EVP_CIPHER_up_ref(src->alloc_cipher))
        return 0;
#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    if (src->engine != NULL && !ENGINE_init(src->engine)) {
        EVP_CIPHER_free(src->alloc_cipher);
        return 0;
    }
#endif
    dst->engine = src->engine;
    dst->cipher = src->cipher;
    dst->alloc_cipher = src->alloc_cipher;
    return 1;
}

static int load_common(const OSSL_PARAM params[], const char **propquery,
                       ENGINE **engine)
{
    const OSSL_PARAM *p;

    *propquery = NULL;
    p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_PROPERTIES);
    if (p != NULL) {
        if (p->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        *propquery = p->data;
    }

#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    ENGINE_finish(*engine);
#endif
    *engine = NULL;
    /* Inside the FIPS module, we don't support legacy ciphers */
#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_ENGINE);
    if (p != NULL) {
        if (p->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        /* Get a structural reference */
        *engine = ENGINE_by_id(p->data);
        if (*engine == NULL)
            return 0;
        /* Get a functional reference */
        if (!ENGINE_init(*engine)) {
            ENGINE_free(*engine);
            *engine = NULL;
            return 0;
        }
        /* Free the structural reference */
        ENGINE_free(*engine);
    }
#endif
    return 1;
}

int ossl_prov_cipher_load_from_params(PROV_CIPHER *pc,
                                      const OSSL_PARAM params[],
                                      OSSL_LIB_CTX *ctx)
{
    const OSSL_PARAM *p;
    const char *propquery;

    if (params == NULL)
        return 1;

    if (!load_common(params, &propquery, &pc->engine))
        return 0;

    p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_CIPHER);
    if (p == NULL)
        return 1;
    if (p->data_type != OSSL_PARAM_UTF8_STRING)
        return 0;

    EVP_CIPHER_free(pc->alloc_cipher);
    ERR_set_mark();
    pc->cipher = pc->alloc_cipher = EVP_CIPHER_fetch(ctx, p->data, propquery);
#ifndef FIPS_MODULE /* Inside the FIPS module, we don't support legacy ciphers */
    if (pc->cipher == NULL) {
        const EVP_CIPHER *cipher;

        cipher = EVP_get_cipherbyname(p->data);
        /* Do not use global EVP_CIPHERs */
        if (cipher != NULL && cipher->origin != EVP_ORIG_GLOBAL)
            pc->cipher = cipher;
    }
#endif
    if (pc->cipher != NULL)
        ERR_pop_to_mark();
    else
        ERR_clear_last_mark();
    return pc->cipher != NULL;
}

const EVP_CIPHER *ossl_prov_cipher_cipher(const PROV_CIPHER *pc)
{
    return pc->cipher;
}

ENGINE *ossl_prov_cipher_engine(const PROV_CIPHER *pc)
{
    return pc->engine;
}

void ossl_prov_digest_reset(PROV_DIGEST *pd)
{
    EVP_MD_free(pd->alloc_md);
    pd->alloc_md = NULL;
    pd->md = NULL;
#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    ENGINE_finish(pd->engine);
#endif
    pd->engine = NULL;
}

int ossl_prov_digest_copy(PROV_DIGEST *dst, const PROV_DIGEST *src)
{
    if (src->alloc_md != NULL && !EVP_MD_up_ref(src->alloc_md))
        return 0;
#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
    if (src->engine != NULL && !ENGINE_init(src->engine)) {
        EVP_MD_free(src->alloc_md);
        return 0;
    }
#endif
    dst->engine = src->engine;
    dst->md = src->md;
    dst->alloc_md = src->alloc_md;
    return 1;
}

const EVP_MD *ossl_prov_digest_fetch(PROV_DIGEST *pd, OSSL_LIB_CTX *libctx,
                                     const char *mdname, const char *propquery)
{
    EVP_MD_free(pd->alloc_md);
    pd->md = pd->alloc_md = EVP_MD_fetch(libctx, mdname, propquery);

    return pd->md;
}

int ossl_prov_digest_load_from_params(PROV_DIGEST *pd,
                                      const OSSL_PARAM params[],
                                      OSSL_LIB_CTX *ctx)
{
    const OSSL_PARAM *p;
    const char *propquery;

    if (params == NULL)
        return 1;

    if (!load_common(params, &propquery, &pd->engine))
        return 0;

    p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_DIGEST);
    if (p == NULL)
        return 1;
    if (p->data_type != OSSL_PARAM_UTF8_STRING)
        return 0;

    ERR_set_mark();
    ossl_prov_digest_fetch(pd, ctx, p->data, propquery);
#ifndef FIPS_MODULE /* Inside the FIPS module, we don't support legacy digests */
    if (pd->md == NULL) {
        const EVP_MD *md;

        md = EVP_get_digestbyname(p->data);
        /* Do not use global EVP_MDs */
        if (md != NULL && md->origin != EVP_ORIG_GLOBAL)
            pd->md = md;
    }
#endif
    if (pd->md != NULL)
        ERR_pop_to_mark();
    else
        ERR_clear_last_mark();
    return pd->md != NULL;
}

const EVP_MD *ossl_prov_digest_md(const PROV_DIGEST *pd)
{
    return pd->md;
}

ENGINE *ossl_prov_digest_engine(const PROV_DIGEST *pd)
{
    return pd->engine;
}

int ossl_prov_set_macctx(EVP_MAC_CTX *macctx,
                         const OSSL_PARAM params[],
                         const char *ciphername,
                         const char *mdname,
                         const char *engine,
                         const char *properties,
                         const unsigned char *key,
                         size_t keylen)
{
    const OSSL_PARAM *p;
    OSSL_PARAM mac_params[6], *mp = mac_params;

    if (params != NULL) {
        if (mdname == NULL) {
            if ((p = OSSL_PARAM_locate_const(params,
                                            OSSL_ALG_PARAM_DIGEST)) != NULL) {
                if (p->data_type != OSSL_PARAM_UTF8_STRING)
                    return 0;
                mdname = p->data;
            }
        }
        if (ciphername == NULL) {
            if ((p = OSSL_PARAM_locate_const(params,
                                            OSSL_ALG_PARAM_CIPHER)) != NULL) {
                if (p->data_type != OSSL_PARAM_UTF8_STRING)
                    return 0;
                ciphername = p->data;
            }
        }
        if (engine == NULL) {
            if ((p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_ENGINE))
                    != NULL) {
                if (p->data_type != OSSL_PARAM_UTF8_STRING)
                    return 0;
                engine = p->data;
            }
        }
    }

    if (mdname != NULL)
        *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
                                                 (char *)mdname, 0);
    if (ciphername != NULL)
        *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
                                                 (char *)ciphername, 0);
    if (properties != NULL)
        *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_PROPERTIES,
                                                 (char *)properties, 0);

#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
    if (engine != NULL)
        *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_ENGINE,
                                                 (char *) engine, 0);
#endif

    if (key != NULL)
        *mp++ = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
                                                  (unsigned char *)key,
                                                  keylen);

    *mp = OSSL_PARAM_construct_end();

    return EVP_MAC_CTX_set_params(macctx, mac_params);

}

int ossl_prov_macctx_load_from_params(EVP_MAC_CTX **macctx,
                                      const OSSL_PARAM params[],
                                      const char *macname,
                                      const char *ciphername,
                                      const char *mdname,
                                      OSSL_LIB_CTX *libctx)
{
    const OSSL_PARAM *p;
    const char *properties = NULL;

    if (macname == NULL
        && (p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_MAC)) != NULL) {
        if (p->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        macname = p->data;
    }
    if ((p = OSSL_PARAM_locate_const(params,
                                     OSSL_ALG_PARAM_PROPERTIES)) != NULL) {
        if (p->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        properties = p->data;
    }

    /* If we got a new mac name, we make a new EVP_MAC_CTX */
    if (macname != NULL) {
        EVP_MAC *mac = EVP_MAC_fetch(libctx, macname, properties);

        EVP_MAC_CTX_free(*macctx);
        *macctx = mac == NULL ? NULL : EVP_MAC_CTX_new(mac);
        /* The context holds on to the MAC */
        EVP_MAC_free(mac);
        if (*macctx == NULL)
            return 0;
    }

    /*
     * If there is no MAC yet (and therefore, no MAC context), we ignore
     * all other parameters.
     */
    if (*macctx == NULL)
        return 1;

    if (ossl_prov_set_macctx(*macctx, params, ciphername, mdname, NULL,
                             properties, NULL, 0))
        return 1;

    EVP_MAC_CTX_free(*macctx);
    *macctx = NULL;
    return 0;
}

void ossl_prov_cache_exported_algorithms(const OSSL_ALGORITHM_CAPABLE *in,
                                         OSSL_ALGORITHM *out)
{
    int i, j;

    if (out[0].algorithm_names == NULL) {
        for (i = j = 0; in[i].alg.algorithm_names != NULL; ++i) {
            if (in[i].capable == NULL || in[i].capable())
                out[j++] = in[i].alg;
        }
        out[j++] = in[i].alg;
    }
}

/* Duplicate a lump of memory safely */
int ossl_prov_memdup(const void *src, size_t src_len,
                     unsigned char **dest, size_t *dest_len)
{
    if (src != NULL) {
        if ((*dest = OPENSSL_memdup(src, src_len)) == NULL) {
            ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
            return 0;
        }
        *dest_len = src_len;
    } else {
        *dest = NULL;
        *dest_len = 0;
    }
    return 1;
}

Coverage Report

Created: 2025-06-24 07:26

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2019-2022 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		/* We need to use some engine deprecated APIs */
11		#define OPENSSL_SUPPRESS_DEPRECATED
12
13		#include <openssl/evp.h>
14		#include <openssl/core_names.h>
15		#include <openssl/err.h>
16		#include <openssl/proverr.h>
17		#ifndef FIPS_MODULE
18		# include <openssl/engine.h>
19		# include "crypto/evp.h"
20		#endif
21		#include "prov/provider_util.h"
22
23		void ossl_prov_cipher_reset(PROV_CIPHER *pc)
24	0	{
25	0	EVP_CIPHER_free(pc->alloc_cipher);
26	0	pc->alloc_cipher = NULL;
27	0	pc->cipher = NULL;
28		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
29		ENGINE_finish(pc->engine);
30		#endif
31	0	pc->engine = NULL;
32	0	}
33
34		int ossl_prov_cipher_copy(PROV_CIPHER dst, const PROV_CIPHER src)
35	0	{
36	0	if (src->alloc_cipher != NULL && !EVP_CIPHER_up_ref(src->alloc_cipher))
37	0	return 0;
38		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
39		if (src->engine != NULL && !ENGINE_init(src->engine)) {
40		EVP_CIPHER_free(src->alloc_cipher);
41		return 0;
42		}
43		#endif
44	0	dst->engine = src->engine;
45	0	dst->cipher = src->cipher;
46	0	dst->alloc_cipher = src->alloc_cipher;
47	0	return 1;
48	0	}
49
50		static int load_common(const OSSL_PARAM params[], const char **propquery,
51		ENGINE **engine)
52	103k	{
53	103k	const OSSL_PARAM *p;
54
55	103k	*propquery = NULL;
56	103k	p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_PROPERTIES);
57	103k	if (p != NULL) {
58	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
59	0	return 0;
60	0	*propquery = p->data;
61	0	}
62
63		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
64		ENGINE_finish(*engine);
65		#endif
66	103k	*engine = NULL;
67		/* Inside the FIPS module, we don't support legacy ciphers */
68		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
69		p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_ENGINE);
70		if (p != NULL) {
71		if (p->data_type != OSSL_PARAM_UTF8_STRING)
72		return 0;
73		/* Get a structural reference */
74		*engine = ENGINE_by_id(p->data);
75		if (*engine == NULL)
76		return 0;
77		/* Get a functional reference */
78		if (!ENGINE_init(*engine)) {
79		ENGINE_free(*engine);
80		*engine = NULL;
81		return 0;
82		}
83		/* Free the structural reference */
84		ENGINE_free(*engine);
85		}
86		#endif
87	103k	return 1;
88	103k	}
89
90		int ossl_prov_cipher_load_from_params(PROV_CIPHER *pc,
91		const OSSL_PARAM params[],
92		OSSL_LIB_CTX *ctx)
93	0	{
94	0	const OSSL_PARAM *p;
95	0	const char *propquery;
96
97	0	if (params == NULL)
98	0	return 1;
99
100	0	if (!load_common(params, &propquery, &pc->engine))
101	0	return 0;
102
103	0	p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_CIPHER);
104	0	if (p == NULL)
105	0	return 1;
106	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
107	0	return 0;
108
109	0	EVP_CIPHER_free(pc->alloc_cipher);
110	0	ERR_set_mark();
111	0	pc->cipher = pc->alloc_cipher = EVP_CIPHER_fetch(ctx, p->data, propquery);
112	0	#ifndef FIPS_MODULE /* Inside the FIPS module, we don't support legacy ciphers */
113	0	if (pc->cipher == NULL) {
114	0	const EVP_CIPHER *cipher;
115
116	0	cipher = EVP_get_cipherbyname(p->data);
117		/* Do not use global EVP_CIPHERs */
118	0	if (cipher != NULL && cipher->origin != EVP_ORIG_GLOBAL)
119	0	pc->cipher = cipher;
120	0	}
121	0	#endif
122	0	if (pc->cipher != NULL)
123	0	ERR_pop_to_mark();
124	0	else
125	0	ERR_clear_last_mark();
126	0	return pc->cipher != NULL;
127	0	}
128
129		const EVP_CIPHER ossl_prov_cipher_cipher(const PROV_CIPHER pc)
130	0	{
131	0	return pc->cipher;
132	0	}
133
134		ENGINE ossl_prov_cipher_engine(const PROV_CIPHER pc)
135	0	{
136	0	return pc->engine;
137	0	}
138
139		void ossl_prov_digest_reset(PROV_DIGEST *pd)
140	528k	{
141	528k	EVP_MD_free(pd->alloc_md);
142	528k	pd->alloc_md = NULL;
143	528k	pd->md = NULL;
144		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
145		ENGINE_finish(pd->engine);
146		#endif
147	528k	pd->engine = NULL;
148	528k	}
149
150		int ossl_prov_digest_copy(PROV_DIGEST dst, const PROV_DIGEST src)
151	446k	{
152	446k	if (src->alloc_md != NULL && !EVP_MD_up_ref(src->alloc_md))
153	0	return 0;
154		#if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
155		if (src->engine != NULL && !ENGINE_init(src->engine)) {
156		EVP_MD_free(src->alloc_md);
157		return 0;
158		}
159		#endif
160	446k	dst->engine = src->engine;
161	446k	dst->md = src->md;
162	446k	dst->alloc_md = src->alloc_md;
163	446k	return 1;
164	446k	}
165
166		const EVP_MD ossl_prov_digest_fetch(PROV_DIGEST pd, OSSL_LIB_CTX *libctx,
167		const char mdname, const char propquery)
168	84.8k	{
169	84.8k	EVP_MD_free(pd->alloc_md);
170	84.8k	pd->md = pd->alloc_md = EVP_MD_fetch(libctx, mdname, propquery);
171
172	84.8k	return pd->md;
173	84.8k	}
174
175		int ossl_prov_digest_load_from_params(PROV_DIGEST *pd,
176		const OSSL_PARAM params[],
177		OSSL_LIB_CTX *ctx)
178	103k	{
179	103k	const OSSL_PARAM *p;
180	103k	const char *propquery;
181
182	103k	if (params == NULL)
183	0	return 1;
184
185	103k	if (!load_common(params, &propquery, &pd->engine))
186	0	return 0;
187
188	103k	p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_DIGEST);
189	103k	if (p == NULL)
190	18.6k	return 1;
191	84.8k	if (p->data_type != OSSL_PARAM_UTF8_STRING)
192	0	return 0;
193
194	84.8k	ERR_set_mark();
195	84.8k	ossl_prov_digest_fetch(pd, ctx, p->data, propquery);
196	84.8k	#ifndef FIPS_MODULE /* Inside the FIPS module, we don't support legacy digests */
197	84.8k	if (pd->md == NULL) {
198	0	const EVP_MD *md;
199
200	0	md = EVP_get_digestbyname(p->data);
201		/* Do not use global EVP_MDs */
202	0	if (md != NULL && md->origin != EVP_ORIG_GLOBAL)
203	0	pd->md = md;
204	0	}
205	84.8k	#endif
206	84.8k	if (pd->md != NULL)
207	84.8k	ERR_pop_to_mark();
208	0	else
209	0	ERR_clear_last_mark();
210	84.8k	return pd->md != NULL;
211	84.8k	}
212
213		const EVP_MD ossl_prov_digest_md(const PROV_DIGEST pd)
214	1.02M	{
215	1.02M	return pd->md;
216	1.02M	}
217
218		ENGINE ossl_prov_digest_engine(const PROV_DIGEST pd)
219	972k	{
220	972k	return pd->engine;
221	972k	}
222
223		int ossl_prov_set_macctx(EVP_MAC_CTX *macctx,
224		const OSSL_PARAM params[],
225		const char *ciphername,
226		const char *mdname,
227		const char *engine,
228		const char *properties,
229		const unsigned char *key,
230		size_t keylen)
231	0	{
232	0	const OSSL_PARAM *p;
233	0	OSSL_PARAM mac_params[6], *mp = mac_params;
234
235	0	if (params != NULL) {
236	0	if (mdname == NULL) {
237	0	if ((p = OSSL_PARAM_locate_const(params,
238	0	OSSL_ALG_PARAM_DIGEST)) != NULL) {
239	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
240	0	return 0;
241	0	mdname = p->data;
242	0	}
243	0	}
244	0	if (ciphername == NULL) {
245	0	if ((p = OSSL_PARAM_locate_const(params,
246	0	OSSL_ALG_PARAM_CIPHER)) != NULL) {
247	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
248	0	return 0;
249	0	ciphername = p->data;
250	0	}
251	0	}
252	0	if (engine == NULL) {
253	0	if ((p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_ENGINE))
254	0	!= NULL) {
255	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
256	0	return 0;
257	0	engine = p->data;
258	0	}
259	0	}
260	0	}
261
262	0	if (mdname != NULL)
263	0	*mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
264	0	(char *)mdname, 0);
265	0	if (ciphername != NULL)
266	0	*mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
267	0	(char *)ciphername, 0);
268	0	if (properties != NULL)
269	0	*mp++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_PROPERTIES,
270	0	(char *)properties, 0);
271
272		#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
273		if (engine != NULL)
274		*mp++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_ENGINE,
275		(char *) engine, 0);
276		#endif
277
278	0	if (key != NULL)
279	0	*mp++ = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
280	0	(unsigned char *)key,
281	0	keylen);
282
283	0	*mp = OSSL_PARAM_construct_end();
284
285	0	return EVP_MAC_CTX_set_params(macctx, mac_params);
286
287	0	}
288
289		int ossl_prov_macctx_load_from_params(EVP_MAC_CTX **macctx,
290		const OSSL_PARAM params[],
291		const char *macname,
292		const char *ciphername,
293		const char *mdname,
294		OSSL_LIB_CTX *libctx)
295	0	{
296	0	const OSSL_PARAM *p;
297	0	const char *properties = NULL;
298
299	0	if (macname == NULL
300	0	&& (p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_MAC)) != NULL) {
301	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
302	0	return 0;
303	0	macname = p->data;
304	0	}
305	0	if ((p = OSSL_PARAM_locate_const(params,
306	0	OSSL_ALG_PARAM_PROPERTIES)) != NULL) {
307	0	if (p->data_type != OSSL_PARAM_UTF8_STRING)
308	0	return 0;
309	0	properties = p->data;
310	0	}
311
312		/* If we got a new mac name, we make a new EVP_MAC_CTX */
313	0	if (macname != NULL) {
314	0	EVP_MAC *mac = EVP_MAC_fetch(libctx, macname, properties);
315
316	0	EVP_MAC_CTX_free(*macctx);
317	0	*macctx = mac == NULL ? NULL : EVP_MAC_CTX_new(mac);
318		/* The context holds on to the MAC */
319	0	EVP_MAC_free(mac);
320	0	if (*macctx == NULL)
321	0	return 0;
322	0	}
323
324		/*
325		* If there is no MAC yet (and therefore, no MAC context), we ignore
326		* all other parameters.
327		*/
328	0	if (*macctx == NULL)
329	0	return 1;
330
331	0	if (ossl_prov_set_macctx(*macctx, params, ciphername, mdname, NULL,
332	0	properties, NULL, 0))
333	0	return 1;
334
335	0	EVP_MAC_CTX_free(*macctx);
336	0	*macctx = NULL;
337	0	return 0;
338	0	}
339
340		void ossl_prov_cache_exported_algorithms(const OSSL_ALGORITHM_CAPABLE *in,
341		OSSL_ALGORITHM *out)
342	2	{
343	2	int i, j;
344
345	2	if (out[0].algorithm_names == NULL) {
346	126	for (i = j = 0; in[i].alg.algorithm_names != NULL; ++i) {
347	124	if (in[i].capable == NULL \|\| in[i].capable())
348	124	out[j++] = in[i].alg;
349	124	}
350	2	out[j++] = in[i].alg;
351	2	}
352	2	}
353
354		/* Duplicate a lump of memory safely */
355		int ossl_prov_memdup(const void *src, size_t src_len,
356		unsigned char *dest, size_t dest_len)
357	0	{
358	0	if (src != NULL) {
359	0	if ((*dest = OPENSSL_memdup(src, src_len)) == NULL) {
360	0	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
361	0	return 0;
362	0	}
363	0	*dest_len = src_len;
364	0	} else {
365	0	*dest = NULL;
366	0	*dest_len = 0;
367	0	}
368	0	return 1;
369	0	}