Final cleanup after move to leaner EVP_PKEY methods
[openssl.git] / crypto / evp / evp_fetch.c
1 /*
2  * Copyright 2019 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 <stddef.h>
11 #include <openssl/types.h>
12 #include <openssl/evp.h>
13 #include <openssl/core.h>
14 #include "internal/cryptlib.h"
15 #include "internal/thread_once.h"
16 #include "internal/property.h"
17 #include "internal/core.h"
18 #include "internal/provider.h"
19 #include "internal/namemap.h"
20 #include "crypto/evp.h"    /* evp_local.h needs it */
21 #include "evp_local.h"
22
23 #define NAME_SEPARATOR ':'
24
25 static void evp_method_store_free(void *vstore)
26 {
27     ossl_method_store_free(vstore);
28 }
29
30 static void *evp_method_store_new(OPENSSL_CTX *ctx)
31 {
32     return ossl_method_store_new(ctx);
33 }
34
35
36 static const OPENSSL_CTX_METHOD evp_method_store_method = {
37     evp_method_store_new,
38     evp_method_store_free,
39 };
40
41 /* Data to be passed through ossl_method_construct() */
42 struct evp_method_data_st {
43     OPENSSL_CTX *libctx;
44     OSSL_METHOD_CONSTRUCT_METHOD *mcm;
45     int operation_id;            /* For get_evp_method_from_store() */
46     int name_id;                 /* For get_evp_method_from_store() */
47     const char *names;           /* For get_evp_method_from_store() */
48     const char *propquery;       /* For get_evp_method_from_store() */
49     void *(*method_from_dispatch)(int name_id, const OSSL_DISPATCH *,
50                                   OSSL_PROVIDER *);
51     int (*refcnt_up_method)(void *method);
52     void (*destruct_method)(void *method);
53 };
54
55 static int add_names_to_namemap(OSSL_NAMEMAP *namemap,
56                                 const char *names)
57 {
58     const char *p, *q;
59     size_t l;
60     int id = 0;
61
62     /* Check that we have a namemap and that there is at least one name */
63     if (namemap == NULL) {
64         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
65         return 0;
66     }
67
68     /*
69      * Check that no name is an empty string, and that all names have at
70      * most one numeric identity together.
71      */
72     for (p = names; *p != '\0'; p = (q == NULL ? p + l : q + 1)) {
73         int this_id;
74
75         if ((q = strchr(p, NAME_SEPARATOR)) == NULL)
76             l = strlen(p);       /* offset to \0 */
77         else
78             l = q - p;           /* offset to the next separator */
79
80         this_id = ossl_namemap_name2num_n(namemap, p, l);
81
82         if (*p == '\0' || *p == NAME_SEPARATOR) {
83             ERR_raise(ERR_LIB_EVP, EVP_R_BAD_ALGORITHM_NAME);
84             return 0;
85         }
86         if (id == 0)
87             id = this_id;
88         else if (this_id != 0 && this_id != id) {
89             ERR_raise_data(ERR_LIB_EVP, EVP_R_CONFLICTING_ALGORITHM_NAME,
90                            "\"%.*s\" has an existing different identity %d (from \"%s\")",
91                            l, p, this_id, names);
92             return 0;
93         }
94     }
95
96     /* Now that we have checked, register all names */
97     for (p = names; *p != '\0'; p = (q == NULL ? p + l : q + 1)) {
98         int this_id;
99
100         if ((q = strchr(p, NAME_SEPARATOR)) == NULL)
101             l = strlen(p);       /* offset to \0 */
102         else
103             l = q - p;           /* offset to the next separator */
104
105         this_id = ossl_namemap_add_n(namemap, id, p, l);
106         if (id == 0)
107             id = this_id;
108         else if (this_id != id) {
109             ERR_raise_data(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR,
110                            "Got id %d when expecting %d", this_id, id);
111             return 0;
112         }
113     }
114
115     return id;
116 }
117
118 /*
119  * Generic routines to fetch / create EVP methods with ossl_method_construct()
120  */
121 static void *alloc_tmp_evp_method_store(OPENSSL_CTX *ctx)
122 {
123     return ossl_method_store_new(ctx);
124 }
125
126  static void dealloc_tmp_evp_method_store(void *store)
127 {
128     if (store != NULL)
129         ossl_method_store_free(store);
130 }
131
132 static OSSL_METHOD_STORE *get_evp_method_store(OPENSSL_CTX *libctx)
133 {
134     return openssl_ctx_get_data(libctx, OPENSSL_CTX_EVP_METHOD_STORE_INDEX,
135                                 &evp_method_store_method);
136 }
137
138 /*
139  * To identity the method in the EVP method store, we mix the name identity
140  * with the operation identity, with the assumption that we don't have more
141  * than 2^24 names or more than 2^8 operation types.
142  *
143  * The resulting identity is a 32-bit integer, composed like this:
144  *
145  * +---------24 bits--------+-8 bits-+
146  * |      name identity     | op id  |
147  * +------------------------+--------+
148  */
149 static uint32_t evp_method_id(unsigned int operation_id, int name_id)
150 {
151     if (!ossl_assert(name_id < (1 << 24) || operation_id < (1 << 8))
152         || !ossl_assert(name_id > 0 && operation_id > 0))
153         return 0;
154     return ((name_id << 8) & 0xFFFFFF00) | (operation_id & 0x000000FF);
155 }
156
157 static void *get_evp_method_from_store(OPENSSL_CTX *libctx, void *store,
158                                        void *data)
159 {
160     struct evp_method_data_st *methdata = data;
161     void *method = NULL;
162     int name_id;
163     uint32_t meth_id;
164
165     /*
166      * get_evp_method_from_store() is only called to try and get the method
167      * that evp_generic_fetch() is asking for, and the operation id as well
168      * as the name or name id are passed via methdata.
169      */
170     if ((name_id = methdata->name_id) == 0) {
171         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
172         const char *names = methdata->names;
173         const char *q = strchr(names, NAME_SEPARATOR);
174         size_t l = (q == NULL ? strlen(names) : (size_t)(q - names));
175
176         if (namemap == 0)
177             return NULL;
178         name_id = ossl_namemap_name2num_n(namemap, names, l);
179     }
180
181     if (name_id == 0
182         || (meth_id = evp_method_id(methdata->operation_id, name_id)) == 0)
183         return NULL;
184
185     if (store == NULL
186         && (store = get_evp_method_store(libctx)) == NULL)
187         return NULL;
188
189     (void)ossl_method_store_fetch(store, meth_id, methdata->propquery,
190                                   &method);
191
192     if (method != NULL
193         && !methdata->refcnt_up_method(method)) {
194         method = NULL;
195     }
196     return method;
197 }
198
199 static int put_evp_method_in_store(OPENSSL_CTX *libctx, void *store,
200                                    void *method, const OSSL_PROVIDER *prov,
201                                    int operation_id, const char *names,
202                                    const char *propdef, void *data)
203 {
204     struct evp_method_data_st *methdata = data;
205     OSSL_NAMEMAP *namemap;
206     int name_id;
207     uint32_t meth_id;
208     size_t l = 0;
209
210     /*
211      * put_evp_method_in_store() is only called with an EVP method that was
212      * successfully created by construct_method() below, which means that
213      * all the names should already be stored in the namemap with the same
214      * numeric identity, so just use the first to get that identity.
215      */
216     if (names != NULL) {
217         const char *q = strchr(names, NAME_SEPARATOR);
218
219         l = (q == NULL ? strlen(names) : (size_t)(q - names));
220     }
221
222     if ((namemap = ossl_namemap_stored(libctx)) == NULL
223         || (name_id = ossl_namemap_name2num_n(namemap, names, l)) == 0
224         || (meth_id = evp_method_id(operation_id, name_id)) == 0)
225         return 0;
226
227     if (store == NULL
228         && (store = get_evp_method_store(libctx)) == NULL)
229         return 0;
230
231     return ossl_method_store_add(store, prov, meth_id, propdef, method,
232                                  methdata->refcnt_up_method,
233                                  methdata->destruct_method);
234 }
235
236 /*
237  * The core fetching functionality passes the name of the implementation.
238  * This function is responsible to getting an identity number for it.
239  */
240 static void *construct_evp_method(const char *names, const OSSL_DISPATCH *fns,
241                                   OSSL_PROVIDER *prov, void *data)
242 {
243     /*
244      * This function is only called if get_evp_method_from_store() returned
245      * NULL, so it's safe to say that of all the spots to create a new
246      * namemap entry, this is it.  Should the name already exist there, we
247      * know that ossl_namemap_add() will return its corresponding number.
248      */
249     struct evp_method_data_st *methdata = data;
250     OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
251     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
252     int name_id = add_names_to_namemap(namemap, names);
253
254     if (name_id == 0)
255         return NULL;
256     return methdata->method_from_dispatch(name_id, fns, prov);
257 }
258
259 static void destruct_evp_method(void *method, void *data)
260 {
261     struct evp_method_data_st *methdata = data;
262
263     methdata->destruct_method(method);
264 }
265
266 static void *
267 inner_evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
268                         int name_id, const char *name,
269                         const char *properties,
270                         void *(*new_method)(int name_id,
271                                             const OSSL_DISPATCH *fns,
272                                             OSSL_PROVIDER *prov),
273                         int (*up_ref_method)(void *),
274                         void (*free_method)(void *))
275 {
276     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
277     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
278     uint32_t meth_id = 0;
279     void *method = NULL;
280
281     if (store == NULL || namemap == NULL)
282         return NULL;
283
284     /*
285      * If there's ever an operation_id == 0 passed, we have an internal
286      * programming error.
287      */
288     if (!ossl_assert(operation_id > 0))
289         return NULL;
290
291     /*
292      * If we have been passed neither a name_id or a name, we have an
293      * internal programming error.
294      */
295     if (!ossl_assert(name_id != 0 || name != NULL))
296         return NULL;
297
298     /* If we haven't received a name id yet, try to get one for the name */
299     if (name_id == 0)
300         name_id = ossl_namemap_name2num(namemap, name);
301
302     /*
303      * If we have a name id, calculate a method id with evp_method_id().
304      *
305      * evp_method_id returns 0 if we have too many operations (more than
306      * about 2^8) or too many names (more than about 2^24).  In that case,
307      * we can't create any new method.
308      */
309     if (name_id != 0 && (meth_id = evp_method_id(operation_id, name_id)) == 0)
310         return NULL;
311
312     if (meth_id == 0
313         || !ossl_method_store_cache_get(store, meth_id, properties, &method)) {
314         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
315             alloc_tmp_evp_method_store,
316             dealloc_tmp_evp_method_store,
317             get_evp_method_from_store,
318             put_evp_method_in_store,
319             construct_evp_method,
320             destruct_evp_method
321         };
322         struct evp_method_data_st mcmdata;
323
324         mcmdata.mcm = &mcm;
325         mcmdata.libctx = libctx;
326         mcmdata.operation_id = operation_id;
327         mcmdata.name_id = name_id;
328         mcmdata.names = name;
329         mcmdata.propquery = properties;
330         mcmdata.method_from_dispatch = new_method;
331         mcmdata.destruct_method = free_method;
332         mcmdata.refcnt_up_method = up_ref_method;
333         mcmdata.destruct_method = free_method;
334         if ((method = ossl_method_construct(libctx, operation_id,
335                                             0 /* !force_cache */,
336                                             &mcm, &mcmdata)) != NULL) {
337             /*
338              * If construction did create a method for us, we know that
339              * there is a correct name_id and meth_id, since those have
340              * already been calculated in get_evp_method_from_store() and
341              * put_evp_method_in_store() above.
342              */
343             if (name_id == 0)
344                 name_id = ossl_namemap_name2num(namemap, name);
345             meth_id = evp_method_id(operation_id, name_id);
346             ossl_method_store_cache_set(store, meth_id, properties, method);
347         }
348     } else {
349         up_ref_method(method);
350     }
351
352     return method;
353 }
354
355 void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
356                         const char *name, const char *properties,
357                         void *(*new_method)(int name_id,
358                                             const OSSL_DISPATCH *fns,
359                                             OSSL_PROVIDER *prov),
360                         int (*up_ref_method)(void *),
361                         void (*free_method)(void *))
362 {
363     return inner_evp_generic_fetch(libctx,
364                                    operation_id, 0, name, properties,
365                                    new_method, up_ref_method, free_method);
366 }
367
368 /*
369  * evp_generic_fetch_by_number() is special, and only returns methods for
370  * already known names, i.e. it refuses to work if no name_id can be found
371  * (it's considered an internal programming error).
372  * This is meant to be used when one method needs to fetch an associated
373  * other method.
374  */
375 void *evp_generic_fetch_by_number(OPENSSL_CTX *libctx, int operation_id,
376                                   int name_id, const char *properties,
377                                   void *(*new_method)(int name_id,
378                                                       const OSSL_DISPATCH *fns,
379                                                       OSSL_PROVIDER *prov),
380                                   int (*up_ref_method)(void *),
381                                   void (*free_method)(void *))
382 {
383     return inner_evp_generic_fetch(libctx,
384                                    operation_id, name_id, NULL, properties,
385                                    new_method, up_ref_method, free_method);
386 }
387
388 int EVP_set_default_properties(OPENSSL_CTX *libctx, const char *propq)
389 {
390     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
391
392     if (store != NULL)
393         return ossl_method_store_set_global_properties(store, propq);
394     EVPerr(EVP_F_EVP_SET_DEFAULT_PROPERTIES, ERR_R_INTERNAL_ERROR);
395     return 0;
396 }
397
398 struct do_all_data_st {
399     void (*user_fn)(void *method, void *arg);
400     void *user_arg;
401     void *(*new_method)(const int name_id, const OSSL_DISPATCH *fns,
402                         OSSL_PROVIDER *prov);
403     void (*free_method)(void *);
404 };
405
406 static void do_one(OSSL_PROVIDER *provider, const OSSL_ALGORITHM *algo,
407                    int no_store, void *vdata)
408 {
409     struct do_all_data_st *data = vdata;
410     OPENSSL_CTX *libctx = ossl_provider_library_context(provider);
411     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
412     int name_id = add_names_to_namemap(namemap, algo->algorithm_names);
413     void *method = NULL;
414
415     if (name_id != 0)
416         method = data->new_method(name_id, algo->implementation, provider);
417
418     if (method != NULL) {
419         data->user_fn(method, data->user_arg);
420         data->free_method(method);
421     }
422 }
423
424 void evp_generic_do_all(OPENSSL_CTX *libctx, int operation_id,
425                         void (*user_fn)(void *method, void *arg),
426                         void *user_arg,
427                         void *(*new_method)(int name_id,
428                                             const OSSL_DISPATCH *fns,
429                                             OSSL_PROVIDER *prov),
430                         void (*free_method)(void *))
431 {
432     struct do_all_data_st data;
433
434     data.new_method = new_method;
435     data.free_method = free_method;
436     data.user_fn = user_fn;
437     data.user_arg = user_arg;
438     ossl_algorithm_do_all(libctx, operation_id, NULL, do_one, &data);
439 }
440
441 const char *evp_first_name(OSSL_PROVIDER *prov, int name_id)
442 {
443     OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
444     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
445
446     return ossl_namemap_num2name(namemap, name_id, 0);
447 }
448
449 int evp_is_a(OSSL_PROVIDER *prov, int number, const char *name)
450 {
451     OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
452     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
453
454     return ossl_namemap_name2num(namemap, name) == number;
455 }
456
457 void evp_names_do_all(OSSL_PROVIDER *prov, int number,
458                       void (*fn)(const char *name, void *data),
459                       void *data)
460 {
461     OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
462     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
463
464     ossl_namemap_doall_names(namemap, number, fn, data);
465 }