1 /*
2 * Copyright 2001-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 "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 if (added)
97 /* The cleanup callback needs to be added */
98 engine_cleanup_add_first(cleanup);
99 while (num_nids--) {
100 tmplate.nid = *nids;
101 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
102 if (!fnd) {
103 fnd = OPENSSL_malloc(sizeof(*fnd));
104 if (fnd == NULL)
105 goto end;
106 fnd->uptodate = 1;
107 fnd->nid = *nids;
108 fnd->sk = sk_ENGINE_new_null();
109 if (!fnd->sk) {
110 OPENSSL_free(fnd);
111 goto end;
112 }
113 fnd->funct = NULL;
114 (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
115 if (lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate) != fnd) {
116 sk_ENGINE_free(fnd->sk);
117 OPENSSL_free(fnd);
118 goto end;
119 }
120 }
121 /* A registration shouldn't add duplicate entries */
122 (void)sk_ENGINE_delete_ptr(fnd->sk, e);
123 /*
124 * if 'setdefault', this ENGINE goes to the head of the list
125 */
126 if (!sk_ENGINE_push(fnd->sk, e))
127 goto end;
128 /* "touch" this ENGINE_PILE */
129 fnd->uptodate = 0;
130 if (setdefault) {
131 if (!engine_unlocked_init(e)) {
132 ERR_raise(ERR_LIB_ENGINE, ENGINE_R_INIT_FAILED);
133 goto end;
134 }
135 if (fnd->funct)
136 engine_unlocked_finish(fnd->funct, 0);
137 fnd->funct = e;
138 fnd->uptodate = 1;
139 }
140 nids++;
141 }
142 ret = 1;
143 end:
144 CRYPTO_THREAD_unlock(global_engine_lock);
145 return ret;
146 }
147
int_unregister_cb(ENGINE_PILE * pile,ENGINE * e)148 static void int_unregister_cb(ENGINE_PILE *pile, ENGINE *e)
149 {
150 int n;
151 /* Iterate the 'c->sk' stack removing any occurrence of 'e' */
152 while ((n = sk_ENGINE_find(pile->sk, e)) >= 0) {
153 (void)sk_ENGINE_delete(pile->sk, n);
154 pile->uptodate = 0;
155 }
156 if (pile->funct == e) {
157 engine_unlocked_finish(e, 0);
158 pile->funct = NULL;
159 }
160 }
161
162 IMPLEMENT_LHASH_DOALL_ARG(ENGINE_PILE, ENGINE);
163
engine_table_unregister(ENGINE_TABLE ** table,ENGINE * e)164 void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
165 {
166 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
167 /* Can't return a value. :( */
168 return;
169 if (int_table_check(table, 0))
170 lh_ENGINE_PILE_doall_ENGINE(&(*table)->piles, int_unregister_cb, e);
171 CRYPTO_THREAD_unlock(global_engine_lock);
172 }
173
int_cleanup_cb_doall(ENGINE_PILE * p)174 static void int_cleanup_cb_doall(ENGINE_PILE *p)
175 {
176 if (p == NULL)
177 return;
178 sk_ENGINE_free(p->sk);
179 if (p->funct)
180 engine_unlocked_finish(p->funct, 0);
181 OPENSSL_free(p);
182 }
183
engine_table_cleanup(ENGINE_TABLE ** table)184 void engine_table_cleanup(ENGINE_TABLE **table)
185 {
186 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
187 return;
188 if (*table) {
189 lh_ENGINE_PILE_doall(&(*table)->piles, int_cleanup_cb_doall);
190 lh_ENGINE_PILE_free(&(*table)->piles);
191 *table = NULL;
192 }
193 CRYPTO_THREAD_unlock(global_engine_lock);
194 }
195
196 /* return a functional reference for a given 'nid' */
ossl_engine_table_select(ENGINE_TABLE ** table,int nid,const char * f,int l)197 ENGINE *ossl_engine_table_select(ENGINE_TABLE **table, int nid,
198 const char *f, int l)
199 {
200 ENGINE *ret = NULL;
201 ENGINE_PILE tmplate, *fnd = NULL;
202 int initres, loop = 0;
203
204 /* Load the config before trying to check if engines are available */
205 OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
206
207 if (!(*table)) {
208 OSSL_TRACE3(ENGINE_TABLE,
209 "%s:%d, nid=%d, nothing registered!\n",
210 f, l, nid);
211 return NULL;
212 }
213 ERR_set_mark();
214 if (!CRYPTO_THREAD_write_lock(global_engine_lock))
215 goto end;
216 /*
217 * Check again inside the lock otherwise we could race against cleanup
218 * operations. But don't worry about a debug printout
219 */
220 if (!int_table_check(table, 0))
221 goto end;
222 tmplate.nid = nid;
223 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
224 if (!fnd)
225 goto end;
226 if (fnd->funct && engine_unlocked_init(fnd->funct)) {
227 OSSL_TRACE4(ENGINE_TABLE,
228 "%s:%d, nid=%d, using ENGINE '%s' cached\n",
229 f, l, nid, fnd->funct->id);
230 ret = fnd->funct;
231 goto end;
232 }
233 if (fnd->uptodate) {
234 ret = fnd->funct;
235 goto end;
236 }
237 trynext:
238 ret = sk_ENGINE_value(fnd->sk, loop++);
239 if (!ret) {
240 OSSL_TRACE3(ENGINE_TABLE,
241 "%s:%d, nid=%d, "
242 "no registered implementations would initialise\n",
243 f, l, nid);
244 goto end;
245 }
246 /* Try to initialise the ENGINE? */
247 if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
248 initres = engine_unlocked_init(ret);
249 else
250 initres = 0;
251 if (initres) {
252 /* Update 'funct' */
253 if ((fnd->funct != ret) && engine_unlocked_init(ret)) {
254 /* If there was a previous default we release it. */
255 if (fnd->funct)
256 engine_unlocked_finish(fnd->funct, 0);
257 fnd->funct = ret;
258 OSSL_TRACE4(ENGINE_TABLE,
259 "%s:%d, nid=%d, setting default to '%s'\n",
260 f, l, nid, ret->id);
261 }
262 OSSL_TRACE4(ENGINE_TABLE,
263 "%s:%d, nid=%d, using newly initialised '%s'\n",
264 f, l, nid, ret->id);
265 goto end;
266 }
267 goto trynext;
268 end:
269 /*
270 * If it failed, it is unlikely to succeed again until some future
271 * registrations have taken place. In all cases, we cache.
272 */
273 if (fnd)
274 fnd->uptodate = 1;
275 if (ret)
276 OSSL_TRACE4(ENGINE_TABLE,
277 "%s:%d, nid=%d, caching ENGINE '%s'\n",
278 f, l, nid, ret->id);
279 else
280 OSSL_TRACE3(ENGINE_TABLE,
281 "%s:%d, nid=%d, caching 'no matching ENGINE'\n",
282 f, l, nid);
283 CRYPTO_THREAD_unlock(global_engine_lock);
284 /*
285 * Whatever happened, any failed init()s are not failures in this
286 * context, so clear our error state.
287 */
288 ERR_pop_to_mark();
289 return ret;
290 }
291
292 /* Table enumeration */
293
int_dall(const ENGINE_PILE * pile,ENGINE_PILE_DOALL * dall)294 static void int_dall(const ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
295 {
296 dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
297 }
298
299 IMPLEMENT_LHASH_DOALL_ARG_CONST(ENGINE_PILE, ENGINE_PILE_DOALL);
300
engine_table_doall(ENGINE_TABLE * table,engine_table_doall_cb * cb,void * arg)301 void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
302 void *arg)
303 {
304 ENGINE_PILE_DOALL dall;
305 dall.cb = cb;
306 dall.arg = arg;
307 if (table)
308 lh_ENGINE_PILE_doall_ENGINE_PILE_DOALL(&table->piles, int_dall, &dall);
309 }
310
