/src/openssl33/crypto/store/store_register.c

Source
/*
 * Copyright 2016-2021 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 <string.h>
#include "crypto/ctype.h"
#include <assert.h>

#include <openssl/err.h>
#include <openssl/lhash.h>
#include "store_local.h"

static CRYPTO_RWLOCK *registry_lock;
static CRYPTO_ONCE registry_init = CRYPTO_ONCE_STATIC_INIT;

DEFINE_RUN_ONCE_STATIC(do_registry_init)
{
    registry_lock = CRYPTO_THREAD_lock_new();
    return registry_lock != NULL;
}

/*
 *  Functions for manipulating OSSL_STORE_LOADERs
 */

OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme)
{
    OSSL_STORE_LOADER *res = NULL;

    /*
     * We usually don't check NULL arguments.  For loaders, though, the
     * scheme is crucial and must never be NULL, or the user will get
     * mysterious errors when trying to register the created loader
     * later on.
     */
    if (scheme == NULL) {
        ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_INVALID_SCHEME);
        return NULL;
    }

    if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL)
        return NULL;

    res->engine = e;
    res->scheme = scheme;
    return res;
}

const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader)
{
    return loader->engine;
}

const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader)
{
    return loader->scheme;
}

int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
    OSSL_STORE_open_fn open_function)
{
    loader->open = open_function;
    return 1;
}

int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER *loader,
    OSSL_STORE_open_ex_fn open_ex_function)
{
    loader->open_ex = open_ex_function;
    return 1;
}

int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER *loader,
    OSSL_STORE_attach_fn attach_function)
{
    loader->attach = attach_function;
    return 1;
}

int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
    OSSL_STORE_ctrl_fn ctrl_function)
{
    loader->ctrl = ctrl_function;
    return 1;
}

int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
    OSSL_STORE_expect_fn expect_function)
{
    loader->expect = expect_function;
    return 1;
}

int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
    OSSL_STORE_find_fn find_function)
{
    loader->find = find_function;
    return 1;
}

int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
    OSSL_STORE_load_fn load_function)
{
    loader->load = load_function;
    return 1;
}

int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
    OSSL_STORE_eof_fn eof_function)
{
    loader->eof = eof_function;
    return 1;
}

int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
    OSSL_STORE_error_fn error_function)
{
    loader->error = error_function;
    return 1;
}

int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
    OSSL_STORE_close_fn close_function)
{
    loader->closefn = close_function;
    return 1;
}

/*
 *  Functions for registering OSSL_STORE_LOADERs
 */

static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v)
{
    return OPENSSL_LH_strhash(v->scheme);
}

static int store_loader_cmp(const OSSL_STORE_LOADER *a,
    const OSSL_STORE_LOADER *b)
{
    assert(a->scheme != NULL && b->scheme != NULL);
    return strcmp(a->scheme, b->scheme);
}

static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL;
static int ossl_store_register_init(void)
{
    if (loader_register == NULL) {
        loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash,
            store_loader_cmp);
    }
    return loader_register != NULL;
}

int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader)
{
    const char *scheme = loader->scheme;
    int ok = 0;

    /*
     * Check that the given scheme conforms to correct scheme syntax as per
     * RFC 3986:
     *
     * scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
     */
    if (ossl_isalpha(*scheme))
        while (*scheme != '\0'
            && (ossl_isalpha(*scheme)
                || ossl_isdigit(*scheme)
                || strchr("+-.", *scheme) != NULL))
            scheme++;
    if (*scheme != '\0') {
        ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_INVALID_SCHEME,
            "scheme=%s", loader->scheme);
        return 0;
    }

    /* Check that functions we absolutely require are present */
    if (loader->open == NULL || loader->load == NULL || loader->eof == NULL
        || loader->error == NULL || loader->closefn == NULL) {
        ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_LOADER_INCOMPLETE);
        return 0;
    }

    if (!RUN_ONCE(&registry_init, do_registry_init)) {
        /* Should this error be raised in do_registry_init()? */
        ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
        return 0;
    }
    if (!CRYPTO_THREAD_write_lock(registry_lock))
        return 0;

    if (ossl_store_register_init()
        && (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL
            || lh_OSSL_STORE_LOADER_error(loader_register) == 0))
        ok = 1;

    CRYPTO_THREAD_unlock(registry_lock);

    return ok;
}
int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader)
{
    return ossl_store_register_loader_int(loader);
}

const OSSL_STORE_LOADER *ossl_store_get0_loader_int(const char *scheme)
{
    OSSL_STORE_LOADER template;
    OSSL_STORE_LOADER *loader = NULL;

    template.scheme = scheme;
    template.open = NULL;
    template.load = NULL;
    template.eof = NULL;
    template.closefn = NULL;
    template.open_ex = NULL;

    if (!RUN_ONCE(&registry_init, do_registry_init)) {
        /* Should this error be raised in do_registry_init()? */
        ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
        return NULL;
    }
    if (!CRYPTO_THREAD_write_lock(registry_lock))
        return NULL;

    if (!ossl_store_register_init())
        ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_INTERNAL_ERROR);
    else if ((loader = lh_OSSL_STORE_LOADER_retrieve(loader_register,
                  &template))
        == NULL)
        ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNREGISTERED_SCHEME,
            "scheme=%s", scheme);

    CRYPTO_THREAD_unlock(registry_lock);

    return loader;
}

OSSL_STORE_LOADER *ossl_store_unregister_loader_int(const char *scheme)
{
    OSSL_STORE_LOADER template;
    OSSL_STORE_LOADER *loader = NULL;

    template.scheme = scheme;
    template.open = NULL;
    template.load = NULL;
    template.eof = NULL;
    template.closefn = NULL;

    if (!RUN_ONCE(&registry_init, do_registry_init)) {
        /* Should this error be raised in do_registry_init()? */
        ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
        return NULL;
    }
    if (!CRYPTO_THREAD_write_lock(registry_lock))
        return NULL;

    if (!ossl_store_register_init())
        ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_INTERNAL_ERROR);
    else if ((loader = lh_OSSL_STORE_LOADER_delete(loader_register,
                  &template))
        == NULL)
        ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNREGISTERED_SCHEME,
            "scheme=%s", scheme);

    CRYPTO_THREAD_unlock(registry_lock);

    return loader;
}
OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme)
{
    return ossl_store_unregister_loader_int(scheme);
}

void ossl_store_destroy_loaders_int(void)
{
    lh_OSSL_STORE_LOADER_free(loader_register);
    loader_register = NULL;
    CRYPTO_THREAD_lock_free(registry_lock);
    registry_lock = NULL;
}

/*
 *  Functions to list OSSL_STORE loaders
 */

IMPLEMENT_LHASH_DOALL_ARG_CONST(OSSL_STORE_LOADER, void);
int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER
                                                      *loader,
                                  void *do_arg),
    void *do_arg)
{
    if (ossl_store_register_init())
        lh_OSSL_STORE_LOADER_doall_void(loader_register, do_function, do_arg);
    return 1;
}

Coverage Report

Created: 2025-12-31 06:58

Line	Count	Source
1		/*
2		* Copyright 2016-2021 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 <string.h>
11		#include "crypto/ctype.h"
12		#include <assert.h>
13
14		#include <openssl/err.h>
15		#include <openssl/lhash.h>
16		#include "store_local.h"
17
18		static CRYPTO_RWLOCK *registry_lock;
19		static CRYPTO_ONCE registry_init = CRYPTO_ONCE_STATIC_INIT;
20
21		DEFINE_RUN_ONCE_STATIC(do_registry_init)
22	0	{
23	0	registry_lock = CRYPTO_THREAD_lock_new();
24	0	return registry_lock != NULL;
25	0	}
26
27		/*
28		* Functions for manipulating OSSL_STORE_LOADERs
29		*/
30
31		OSSL_STORE_LOADER OSSL_STORE_LOADER_new(ENGINE e, const char *scheme)
32	0	{
33	0	OSSL_STORE_LOADER *res = NULL;
34
35		/*
36		* We usually don't check NULL arguments. For loaders, though, the
37		* scheme is crucial and must never be NULL, or the user will get
38		* mysterious errors when trying to register the created loader
39		* later on.
40		*/
41	0	if (scheme == NULL) {
42	0	ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_INVALID_SCHEME);
43	0	return NULL;
44	0	}
45
46	0	if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL)
47	0	return NULL;
48
49	0	res->engine = e;
50	0	res->scheme = scheme;
51	0	return res;
52	0	}
53
54		const ENGINE OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER loader)
55	0	{
56	0	return loader->engine;
57	0	}
58
59		const char OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER loader)
60	0	{
61	0	return loader->scheme;
62	0	}
63
64		int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
65		OSSL_STORE_open_fn open_function)
66	0	{
67	0	loader->open = open_function;
68	0	return 1;
69	0	}
70
71		int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER *loader,
72		OSSL_STORE_open_ex_fn open_ex_function)
73	0	{
74	0	loader->open_ex = open_ex_function;
75	0	return 1;
76	0	}
77
78		int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER *loader,
79		OSSL_STORE_attach_fn attach_function)
80	0	{
81	0	loader->attach = attach_function;
82	0	return 1;
83	0	}
84
85		int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
86		OSSL_STORE_ctrl_fn ctrl_function)
87	0	{
88	0	loader->ctrl = ctrl_function;
89	0	return 1;
90	0	}
91
92		int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
93		OSSL_STORE_expect_fn expect_function)
94	0	{
95	0	loader->expect = expect_function;
96	0	return 1;
97	0	}
98
99		int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
100		OSSL_STORE_find_fn find_function)
101	0	{
102	0	loader->find = find_function;
103	0	return 1;
104	0	}
105
106		int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
107		OSSL_STORE_load_fn load_function)
108	0	{
109	0	loader->load = load_function;
110	0	return 1;
111	0	}
112
113		int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
114		OSSL_STORE_eof_fn eof_function)
115	0	{
116	0	loader->eof = eof_function;
117	0	return 1;
118	0	}
119
120		int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
121		OSSL_STORE_error_fn error_function)
122	0	{
123	0	loader->error = error_function;
124	0	return 1;
125	0	}
126
127		int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
128		OSSL_STORE_close_fn close_function)
129	0	{
130	0	loader->closefn = close_function;
131	0	return 1;
132	0	}
133
134		/*
135		* Functions for registering OSSL_STORE_LOADERs
136		*/
137
138		static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v)
139	0	{
140	0	return OPENSSL_LH_strhash(v->scheme);
141	0	}
142
143		static int store_loader_cmp(const OSSL_STORE_LOADER *a,
144		const OSSL_STORE_LOADER *b)
145	0	{
146	0	assert(a->scheme != NULL && b->scheme != NULL);
147	0	return strcmp(a->scheme, b->scheme);
148	0	}
149
150		static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL;
151		static int ossl_store_register_init(void)
152	0	{
153	0	if (loader_register == NULL) {
154	0	loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash,
155	0	store_loader_cmp);
156	0	}
157	0	return loader_register != NULL;
158	0	}
159
160		int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader)
161	0	{
162	0	const char *scheme = loader->scheme;
163	0	int ok = 0;
164
165		/*
166		* Check that the given scheme conforms to correct scheme syntax as per
167		* RFC 3986:
168		*
169		* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
170		*/
171	0	if (ossl_isalpha(*scheme))
172	0	while (*scheme != '\0'
173	0	&& (ossl_isalpha(*scheme)
174	0	\|\| ossl_isdigit(*scheme)
175	0	\|\| strchr("+-.", *scheme) != NULL))
176	0	scheme++;
177	0	if (*scheme != '\0') {
178	0	ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_INVALID_SCHEME,
179	0	"scheme=%s", loader->scheme);
180	0	return 0;
181	0	}
182
183		/* Check that functions we absolutely require are present */
184	0	if (loader->open == NULL \|\| loader->load == NULL \|\| loader->eof == NULL
185	0	\|\| loader->error == NULL \|\| loader->closefn == NULL) {
186	0	ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_LOADER_INCOMPLETE);
187	0	return 0;
188	0	}
189
190	0	if (!RUN_ONCE(&registry_init, do_registry_init)) {
191		/* Should this error be raised in do_registry_init()? */
192	0	ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
193	0	return 0;
194	0	}
195	0	if (!CRYPTO_THREAD_write_lock(registry_lock))
196	0	return 0;
197
198	0	if (ossl_store_register_init()
199	0	&& (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL
200	0	\|\| lh_OSSL_STORE_LOADER_error(loader_register) == 0))
201	0	ok = 1;
202
203	0	CRYPTO_THREAD_unlock(registry_lock);
204
205	0	return ok;
206	0	}
207		int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader)
208	0	{
209	0	return ossl_store_register_loader_int(loader);
210	0	}
211
212		const OSSL_STORE_LOADER ossl_store_get0_loader_int(const char scheme)
213	0	{
214	0	OSSL_STORE_LOADER template;
215	0	OSSL_STORE_LOADER *loader = NULL;
216
217	0	template.scheme = scheme;
218	0	template.open = NULL;
219	0	template.load = NULL;
220	0	template.eof = NULL;
221	0	template.closefn = NULL;
222	0	template.open_ex = NULL;
223
224	0	if (!RUN_ONCE(&registry_init, do_registry_init)) {
225		/* Should this error be raised in do_registry_init()? */
226	0	ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
227	0	return NULL;
228	0	}
229	0	if (!CRYPTO_THREAD_write_lock(registry_lock))
230	0	return NULL;
231
232	0	if (!ossl_store_register_init())
233	0	ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_INTERNAL_ERROR);
234	0	else if ((loader = lh_OSSL_STORE_LOADER_retrieve(loader_register,
235	0	&template))
236	0	== NULL)
237	0	ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNREGISTERED_SCHEME,
238	0	"scheme=%s", scheme);
239
240	0	CRYPTO_THREAD_unlock(registry_lock);
241
242	0	return loader;
243	0	}
244
245		OSSL_STORE_LOADER ossl_store_unregister_loader_int(const char scheme)
246	0	{
247	0	OSSL_STORE_LOADER template;
248	0	OSSL_STORE_LOADER *loader = NULL;
249
250	0	template.scheme = scheme;
251	0	template.open = NULL;
252	0	template.load = NULL;
253	0	template.eof = NULL;
254	0	template.closefn = NULL;
255
256	0	if (!RUN_ONCE(&registry_init, do_registry_init)) {
257		/* Should this error be raised in do_registry_init()? */
258	0	ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
259	0	return NULL;
260	0	}
261	0	if (!CRYPTO_THREAD_write_lock(registry_lock))
262	0	return NULL;
263
264	0	if (!ossl_store_register_init())
265	0	ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_INTERNAL_ERROR);
266	0	else if ((loader = lh_OSSL_STORE_LOADER_delete(loader_register,
267	0	&template))
268	0	== NULL)
269	0	ERR_raise_data(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNREGISTERED_SCHEME,
270	0	"scheme=%s", scheme);
271
272	0	CRYPTO_THREAD_unlock(registry_lock);
273
274	0	return loader;
275	0	}
276		OSSL_STORE_LOADER OSSL_STORE_unregister_loader(const char scheme)
277	0	{
278	0	return ossl_store_unregister_loader_int(scheme);
279	0	}
280
281		void ossl_store_destroy_loaders_int(void)
282	220	{
283	220	lh_OSSL_STORE_LOADER_free(loader_register);
284	220	loader_register = NULL;
285	220	CRYPTO_THREAD_lock_free(registry_lock);
286	220	registry_lock = NULL;
287	220	}
288
289		/*
290		* Functions to list OSSL_STORE loaders
291		*/
292
293		IMPLEMENT_LHASH_DOALL_ARG_CONST(OSSL_STORE_LOADER, void);
294		int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER
295		*loader,
296		void *do_arg),
297		void *do_arg)
298	0	{
299	0	if (ossl_store_register_init())
300	0	lh_OSSL_STORE_LOADER_doall_void(loader_register, do_function, do_arg);
301	0	return 1;
302	0	}