Make the generic EVP fetching mechanism use the namenum map
[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/ossl_typ.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/namemap.h"
19 #include "internal/evp_int.h"    /* evp_locl.h needs it */
20 #include "evp_locl.h"
21
22 static void default_method_store_free(void *vstore)
23 {
24     ossl_method_store_free(vstore);
25 }
26
27 static void *default_method_store_new(OPENSSL_CTX *ctx)
28 {
29     return ossl_method_store_new(ctx);
30 }
31
32
33 static const OPENSSL_CTX_METHOD default_method_store_method = {
34     default_method_store_new,
35     default_method_store_free,
36 };
37
38 /* Data to be passed through ossl_method_construct() */
39 struct method_data_st {
40     OPENSSL_CTX *libctx;
41     const char *name;
42     int nid;
43     OSSL_METHOD_CONSTRUCT_METHOD *mcm;
44     void *(*method_from_dispatch)(int nid, const OSSL_DISPATCH *,
45                                   OSSL_PROVIDER *);
46     int (*refcnt_up_method)(void *method);
47     void (*destruct_method)(void *method);
48     int (*nid_method)(void *method);
49 };
50
51 /*
52  * Generic routines to fetch / create EVP methods with ossl_method_construct()
53  */
54 static void *alloc_tmp_method_store(OPENSSL_CTX *ctx)
55 {
56     return ossl_method_store_new(ctx);
57 }
58
59  static void dealloc_tmp_method_store(void *store)
60 {
61     if (store != NULL)
62         ossl_method_store_free(store);
63 }
64
65 static OSSL_METHOD_STORE *get_default_method_store(OPENSSL_CTX *libctx)
66 {
67     return openssl_ctx_get_data(libctx, OPENSSL_CTX_DEFAULT_METHOD_STORE_INDEX,
68                                 &default_method_store_method);
69 }
70
71 static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
72                                    const char *propquery, void *data)
73 {
74     struct method_data_st *methdata = data;
75     void *method = NULL;
76
77     if (store == NULL
78         && (store = get_default_method_store(libctx)) == NULL)
79         return NULL;
80
81     (void)ossl_method_store_fetch(store, methdata->nid, propquery, &method);
82
83     if (method != NULL
84         && !methdata->refcnt_up_method(method)) {
85         method = NULL;
86     }
87     return method;
88 }
89
90 static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
91                                const char *propdef,
92                                void *method, void *data)
93 {
94     struct method_data_st *methdata = data;
95     int nid = methdata->nid_method(method);
96
97     if (nid == 0)
98         return 0;
99
100     if (store == NULL
101         && (store = get_default_method_store(libctx)) == NULL)
102         return 0;
103
104     if (methdata->refcnt_up_method(method)
105         && ossl_method_store_add(store, nid, propdef, method,
106                                  methdata->destruct_method))
107         return 1;
108     return 0;
109 }
110
111 static void *construct_method(const char *algorithm_name,
112                               const OSSL_DISPATCH *fns, OSSL_PROVIDER *prov,
113                               void *data)
114 {
115     struct method_data_st *methdata = data;
116     OSSL_NAMEMAP *namemap;
117     int nid;
118
119     if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
120         || (nid = ossl_namemap_add(namemap, algorithm_name)) == 0)
121         return NULL;
122
123     return methdata->method_from_dispatch(nid, fns, prov);
124 }
125
126 static void destruct_method(void *method, void *data)
127 {
128     struct method_data_st *methdata = data;
129
130     methdata->destruct_method(method);
131 }
132
133 void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
134                         const char *algorithm, const char *properties,
135                         void *(*new_method)(int nid, const OSSL_DISPATCH *fns,
136                                             OSSL_PROVIDER *prov),
137                         int (*upref_method)(void *),
138                         void (*free_method)(void *),
139                         int (*nid_method)(void *))
140 {
141     OSSL_METHOD_STORE *store = get_default_method_store(libctx);
142     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
143     int nid;
144     void *method = NULL;
145
146     if (store == NULL || namemap == NULL)
147         return NULL;
148
149     if ((nid = ossl_namemap_number(namemap, algorithm)) == 0
150         || !ossl_method_store_cache_get(store, nid, properties, &method)) {
151         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
152             alloc_tmp_method_store,
153             dealloc_tmp_method_store,
154             get_method_from_store,
155             put_method_in_store,
156             construct_method,
157             destruct_method
158         };
159         struct method_data_st mcmdata;
160
161         mcmdata.nid = nid;
162         mcmdata.mcm = &mcm;
163         mcmdata.libctx = libctx;
164         mcmdata.method_from_dispatch = new_method;
165         mcmdata.destruct_method = free_method;
166         mcmdata.refcnt_up_method = upref_method;
167         mcmdata.destruct_method = free_method;
168         mcmdata.nid_method = nid_method;
169         method = ossl_method_construct(libctx, operation_id, algorithm,
170                                        properties, 0 /* !force_cache */,
171                                        &mcm, &mcmdata);
172         ossl_method_store_cache_set(store, nid, properties, method);
173     } else {
174         upref_method(method);
175     }
176
177     return method;
178 }
179
180 int EVP_set_default_properties(OPENSSL_CTX *libctx, const char *propq)
181 {
182     OSSL_METHOD_STORE *store = get_default_method_store(libctx);
183
184     if (store != NULL)
185         return ossl_method_store_set_global_properties(store, propq);
186     EVPerr(EVP_F_EVP_SET_DEFAULT_PROPERTIES, ERR_R_INTERNAL_ERROR);
187     return 0;
188 }