1/*
2 * Copyright 2001-2023 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 */
17struct 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 */
31struct st_engine_table {
32    LHASH_OF(ENGINE_PILE) piles;
33};                              /* ENGINE_TABLE */
34
35typedef 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_***). */
41static unsigned int table_flags = 0;
42
43/* API function manipulating 'table_flags' */
44unsigned int ENGINE_get_table_flags(void)
45{
46    return table_flags;
47}
48
49void ENGINE_set_table_flags(unsigned int flags)
50{
51    table_flags = flags;
52}
53
54/* Internal functions for the "piles" hash table */
55static unsigned long engine_pile_hash(const ENGINE_PILE *c)
56{
57    return c->nid;
58}
59
60static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
61{
62    return a->nid - b->nid;
63}
64
65static 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 */
83int 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
151static 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
165IMPLEMENT_LHASH_DOALL_ARG(ENGINE_PILE, ENGINE);
166
167void 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
177static 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
187void 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' */
200ENGINE *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    ERR_set_mark();
219    if (!CRYPTO_THREAD_write_lock(global_engine_lock))
220        goto end;
221    /*
222     * Check again inside the lock otherwise we could race against cleanup
223     * operations. But don't worry about a debug printout
224     */
225    if (!int_table_check(table, 0))
226        goto end;
227    tmplate.nid = nid;
228    fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
229    if (!fnd)
230        goto end;
231    if (fnd->funct && engine_unlocked_init(fnd->funct)) {
232        OSSL_TRACE4(ENGINE_TABLE,
233                   "%s:%d, nid=%d, using ENGINE '%s' cached\n",
234                   f, l, nid, fnd->funct->id);
235        ret = fnd->funct;
236        goto end;
237    }
238    if (fnd->uptodate) {
239        ret = fnd->funct;
240        goto end;
241    }
242 trynext:
243    ret = sk_ENGINE_value(fnd->sk, loop++);
244    if (!ret) {
245        OSSL_TRACE3(ENGINE_TABLE,
246                    "%s:%d, nid=%d, "
247                    "no registered implementations would initialise\n",
248                    f, l, nid);
249        goto end;
250    }
251    /* Try to initialise the ENGINE? */
252    if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
253        initres = engine_unlocked_init(ret);
254    else
255        initres = 0;
256    if (initres) {
257        /* Update 'funct' */
258        if ((fnd->funct != ret) && engine_unlocked_init(ret)) {
259            /* If there was a previous default we release it. */
260            if (fnd->funct)
261                engine_unlocked_finish(fnd->funct, 0);
262            fnd->funct = ret;
263            OSSL_TRACE4(ENGINE_TABLE,
264                        "%s:%d, nid=%d, setting default to '%s'\n",
265                        f, l, nid, ret->id);
266        }
267        OSSL_TRACE4(ENGINE_TABLE,
268                    "%s:%d, nid=%d, using newly initialised '%s'\n",
269                    f, l, nid, ret->id);
270        goto end;
271    }
272    goto trynext;
273 end:
274    /*
275     * If it failed, it is unlikely to succeed again until some future
276     * registrations have taken place. In all cases, we cache.
277     */
278    if (fnd)
279        fnd->uptodate = 1;
280    if (ret)
281        OSSL_TRACE4(ENGINE_TABLE,
282                   "%s:%d, nid=%d, caching ENGINE '%s'\n",
283                   f, l, nid, ret->id);
284    else
285        OSSL_TRACE3(ENGINE_TABLE,
286                    "%s:%d, nid=%d, caching 'no matching ENGINE'\n",
287                    f, l, nid);
288    CRYPTO_THREAD_unlock(global_engine_lock);
289    /*
290     * Whatever happened, any failed init()s are not failures in this
291     * context, so clear our error state.
292     */
293    ERR_pop_to_mark();
294    return ret;
295}
296
297/* Table enumeration */
298
299static void int_dall(const ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
300{
301    dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
302}
303
304IMPLEMENT_LHASH_DOALL_ARG_CONST(ENGINE_PILE, ENGINE_PILE_DOALL);
305
306void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
307                        void *arg)
308{
309    ENGINE_PILE_DOALL dall;
310    dall.cb = cb;
311    dall.arg = arg;
312    if (table)
313        lh_ENGINE_PILE_doall_ENGINE_PILE_DOALL(&table->piles, int_dall, &dall);
314}
315