1 /*
2 * Copyright 2001-2024 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 "internal/cryptlib.h"
11 #include <openssl/evp.h>
12 #include <openssl/lhash.h>
13 #include <openssl/trace.h>
14 #include "eng_local.h"
15
16 /* The type of the items in the table */
17 struct st_engine_pile {
18 /* The 'nid' of this algorithm/mode */
19 int nid;
20 /* ENGINEs that implement this algorithm/mode. */
21 STACK_OF(ENGINE) *sk;
22 /* The default ENGINE to perform this algorithm/mode. */
23 ENGINE *funct;
24 /*
25 * Zero if 'sk' is newer than the cached 'funct', non-zero otherwise
26 */
27 int uptodate;
28 };
29
30 /* The type exposed in eng_local.h */
31 struct st_engine_table {
32 LHASH_OF(ENGINE_PILE) piles;
33 }; /* ENGINE_TABLE */
34
35 typedef struct st_engine_pile_doall {
36 engine_table_doall_cb *cb;
37 void *arg;
38 } ENGINE_PILE_DOALL;
39
40 /* Global flags (ENGINE_TABLE_FLAG_***). */
41 static unsigned int table_flags = 0;
42
43 /* API function manipulating 'table_flags' */
ENGINE_get_table_flags(void)44 unsigned int ENGINE_get_table_flags(void)
45 {
46 return table_flags;
47 }
48
ENGINE_set_table_flags(unsigned int flags)49 void ENGINE_set_table_flags(unsigned int flags)
50 {
51 table_flags = flags;
52 }
53
54 /* Internal functions for the "piles" hash table */
engine_pile_hash(const ENGINE_PILE * c)55 static unsigned long engine_pile_hash(const ENGINE_PILE *c)
56 {
57 return c->nid;
58 }
59
engine_pile_cmp(const ENGINE_PILE * a,const ENGINE_PILE * b)60 static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
61 {
62 return a->nid - b->nid;
63 }
64
int_table_check(ENGINE_TABLE ** t,int create)65 static int int_table_check(ENGINE_TABLE **t, int create)
66 {
67 LHASH_OF(ENGINE_PILE) *lh;
68
69 if (*t)
70 return 1;
71 if (!create)
72 return 0;
73 if ((lh = lh_ENGINE_PILE_new(engine_pile_hash, engine_pile_cmp)) == NULL)
74 return 0;
75 *t = (ENGINE_TABLE *)lh;
76 return 1;
77 }
78
79 /*
80 * Privately exposed (via eng_local.h) functions for adding and/or removing
81 * ENGINEs from the implementation table
82 */
engine_table_register(ENGINE_TABLE ** table,ENGINE_CLEANUP_CB * cleanup,ENGINE * e,const int * nids,int num_nids,int setdefault)83 int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
84 ENGINE *e, const int *nids, int num_nids,
85 int setdefault)
86 {
87 int ret = 0, added = 0;
88 ENGINE_PILE tmplate, *fnd;
89
90 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
91 return 0;
92 if (!(*table))
93 added = 1;
94 if (!int_table_check(table, 1))
95 goto end;
96 /* The cleanup callback needs to be added */
97 if (added && !engine_cleanup_add_first(cleanup)) {
98 lh_ENGINE_PILE_free(&(*table)->piles);
99 *table = NULL;
100 goto end;
101 }
102 while (num_nids--) {
103 tmplate.nid = *nids;
104 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
105 if (!fnd) {
106 fnd = OPENSSL_malloc(sizeof(*fnd));
107 if (fnd == NULL)
108 goto end;
109 fnd->uptodate = 1;
110 fnd->nid = *nids;
111 fnd->sk = sk_ENGINE_new_null();
112 if (!fnd->sk) {
113 OPENSSL_free(fnd);
114 goto end;
115 }
116 fnd->funct = NULL;
117 (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
118 if (lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate) != fnd) {
119 sk_ENGINE_free(fnd->sk);
120 OPENSSL_free(fnd);
121 goto end;
122 }
123 }
124 /* A registration shouldn't add duplicate entries */
125 (void)sk_ENGINE_delete_ptr(fnd->sk, e);
126 /*
127 * if 'setdefault', this ENGINE goes to the head of the list
128 */
129 if (!sk_ENGINE_push(fnd->sk, e))
130 goto end;
131 /* "touch" this ENGINE_PILE */
132 fnd->uptodate = 0;
133 if (setdefault) {
134 if (!engine_unlocked_init(e)) {
135 ERR_raise(ERR_LIB_ENGINE, ENGINE_R_INIT_FAILED);
136 goto end;
137 }
138 if (fnd->funct)
139 engine_unlocked_finish(fnd->funct, 0);
140 fnd->funct = e;
141 fnd->uptodate = 1;
142 }
143 nids++;
144 }
145 ret = 1;
146 end:
147 CRYPTO_THREAD_unlock(global_engine_lock);
148 return ret;
149 }
150
int_unregister_cb(ENGINE_PILE * pile,ENGINE * e)151 static void int_unregister_cb(ENGINE_PILE *pile, ENGINE *e)
152 {
153 int n;
154 /* Iterate the 'c->sk' stack removing any occurrence of 'e' */
155 while ((n = sk_ENGINE_find(pile->sk, e)) >= 0) {
156 (void)sk_ENGINE_delete(pile->sk, n);
157 pile->uptodate = 0;
158 }
159 if (pile->funct == e) {
160 engine_unlocked_finish(e, 0);
161 pile->funct = NULL;
162 }
163 }
164
165 IMPLEMENT_LHASH_DOALL_ARG(ENGINE_PILE, ENGINE);
166
engine_table_unregister(ENGINE_TABLE ** table,ENGINE * e)167 void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
168 {
169 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
170 /* Can't return a value. :( */
171 return;
172 if (int_table_check(table, 0))
173 lh_ENGINE_PILE_doall_ENGINE(&(*table)->piles, int_unregister_cb, e);
174 CRYPTO_THREAD_unlock(global_engine_lock);
175 }
176
int_cleanup_cb_doall(ENGINE_PILE * p)177 static void int_cleanup_cb_doall(ENGINE_PILE *p)
178 {
179 if (p == NULL)
180 return;
181 sk_ENGINE_free(p->sk);
182 if (p->funct)
183 engine_unlocked_finish(p->funct, 0);
184 OPENSSL_free(p);
185 }
186
engine_table_cleanup(ENGINE_TABLE ** table)187 void engine_table_cleanup(ENGINE_TABLE **table)
188 {
189 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
190 return;
191 if (*table) {
192 lh_ENGINE_PILE_doall(&(*table)->piles, int_cleanup_cb_doall);
193 lh_ENGINE_PILE_free(&(*table)->piles);
194 *table = NULL;
195 }
196 CRYPTO_THREAD_unlock(global_engine_lock);
197 }
198
199 /* return a functional reference for a given 'nid' */
ossl_engine_table_select(ENGINE_TABLE ** table,int nid,const char * f,int l)200 ENGINE *ossl_engine_table_select(ENGINE_TABLE **table, int nid,
201 const char *f, int l)
202 {
203 ENGINE *ret = NULL;
204 ENGINE_PILE tmplate, *fnd = NULL;
205 int initres, loop = 0;
206
207 #ifndef OPENSSL_NO_AUTOLOAD_CONFIG
208 /* Load the config before trying to check if engines are available */
209 OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
210 #endif
211
212 if (!(*table)) {
213 OSSL_TRACE3(ENGINE_TABLE,
214 "%s:%d, nid=%d, nothing registered!\n",
215 f, l, nid);
216 return NULL;
217 }
218
219 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
220 return NULL;
221
222 ERR_set_mark();
223 /*
224 * Check again inside the lock otherwise we could race against cleanup
225 * operations. But don't worry about a debug printout
226 */
227 if (!int_table_check(table, 0))
228 goto end;
229 tmplate.nid = nid;
230 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
231 if (!fnd)
232 goto end;
233 if (fnd->funct && engine_unlocked_init(fnd->funct)) {
234 OSSL_TRACE4(ENGINE_TABLE,
235 "%s:%d, nid=%d, using ENGINE '%s' cached\n",
236 f, l, nid, fnd->funct->id);
237 ret = fnd->funct;
238 goto end;
239 }
240 if (fnd->uptodate) {
241 ret = fnd->funct;
242 goto end;
243 }
244 trynext:
245 ret = sk_ENGINE_value(fnd->sk, loop++);
246 if (!ret) {
247 OSSL_TRACE3(ENGINE_TABLE,
248 "%s:%d, nid=%d, "
249 "no registered implementations would initialise\n",
250 f, l, nid);
251 goto end;
252 }
253 /* Try to initialise the ENGINE? */
254 if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
255 initres = engine_unlocked_init(ret);
256 else
257 initres = 0;
258 if (initres) {
259 /* Update 'funct' */
260 if ((fnd->funct != ret) && engine_unlocked_init(ret)) {
261 /* If there was a previous default we release it. */
262 if (fnd->funct)
263 engine_unlocked_finish(fnd->funct, 0);
264 fnd->funct = ret;
265 OSSL_TRACE4(ENGINE_TABLE,
266 "%s:%d, nid=%d, setting default to '%s'\n",
267 f, l, nid, ret->id);
268 }
269 OSSL_TRACE4(ENGINE_TABLE,
270 "%s:%d, nid=%d, using newly initialised '%s'\n",
271 f, l, nid, ret->id);
272 goto end;
273 }
274 goto trynext;
275 end:
276 /*
277 * If it failed, it is unlikely to succeed again until some future
278 * registrations have taken place. In all cases, we cache.
279 */
280 if (fnd)
281 fnd->uptodate = 1;
282 if (ret)
283 OSSL_TRACE4(ENGINE_TABLE,
284 "%s:%d, nid=%d, caching ENGINE '%s'\n",
285 f, l, nid, ret->id);
286 else
287 OSSL_TRACE3(ENGINE_TABLE,
288 "%s:%d, nid=%d, caching 'no matching ENGINE'\n",
289 f, l, nid);
290 CRYPTO_THREAD_unlock(global_engine_lock);
291 /*
292 * Whatever happened, any failed init()s are not failures in this
293 * context, so clear our error state.
294 */
295 ERR_pop_to_mark();
296 return ret;
297 }
298
299 /* Table enumeration */
300
int_dall(const ENGINE_PILE * pile,ENGINE_PILE_DOALL * dall)301 static void int_dall(const ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
302 {
303 dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
304 }
305
306 IMPLEMENT_LHASH_DOALL_ARG_CONST(ENGINE_PILE, ENGINE_PILE_DOALL);
307
engine_table_doall(ENGINE_TABLE * table,engine_table_doall_cb * cb,void * arg)308 void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
309 void *arg)
310 {
311 ENGINE_PILE_DOALL dall;
312 dall.cb = cb;
313 dall.arg = arg;
314 if (table)
315 lh_ENGINE_PILE_doall_ENGINE_PILE_DOALL(&table->piles, int_dall, &dall);
316 }
317