5237bcaf24821716010a8156359431b96d17a405
[openssl.git] / crypto / evp / names.c
1 /*
2  * Copyright 1995-2018 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 <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/evp.h>
13 #include <openssl/kdf.h>
14 #include "internal/objects.h"
15 #include <openssl/x509.h>
16 #include "internal/evp_int.h"
17
18 int EVP_add_cipher(const EVP_CIPHER *c)
19 {
20     int r;
21
22     if (c == NULL)
23         return 0;
24
25     r = OBJ_NAME_add(OBJ_nid2sn(c->nid), OBJ_NAME_TYPE_CIPHER_METH,
26                      (const char *)c);
27     if (r == 0)
28         return 0;
29     r = OBJ_NAME_add(OBJ_nid2ln(c->nid), OBJ_NAME_TYPE_CIPHER_METH,
30                      (const char *)c);
31     return r;
32 }
33
34 int EVP_add_digest(const EVP_MD *md)
35 {
36     int r;
37     const char *name;
38
39     name = OBJ_nid2sn(md->type);
40     r = OBJ_NAME_add(name, OBJ_NAME_TYPE_MD_METH, (const char *)md);
41     if (r == 0)
42         return 0;
43     r = OBJ_NAME_add(OBJ_nid2ln(md->type), OBJ_NAME_TYPE_MD_METH,
44                      (const char *)md);
45     if (r == 0)
46         return 0;
47
48     if (md->pkey_type && md->type != md->pkey_type) {
49         r = OBJ_NAME_add(OBJ_nid2sn(md->pkey_type),
50                          OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS, name);
51         if (r == 0)
52             return 0;
53         r = OBJ_NAME_add(OBJ_nid2ln(md->pkey_type),
54                          OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS, name);
55     }
56     return r;
57 }
58
59 int EVP_add_mac(const EVP_MAC *m)
60 {
61     int r;
62
63     if (m == NULL)
64         return 0;
65
66     r = OBJ_NAME_add(OBJ_nid2sn(m->type), OBJ_NAME_TYPE_MAC_METH,
67                      (const char *)m);
68     if (r == 0)
69         return 0;
70     r = OBJ_NAME_add(OBJ_nid2ln(m->type), OBJ_NAME_TYPE_MAC_METH,
71                      (const char *)m);
72     return r;
73 }
74
75 /* TODO(3.0) Is this needed after changing to providers? */
76 int EVP_add_kdf(const EVP_KDF *k)
77 {
78     int r;
79
80     if (k == NULL)
81         return 0;
82
83     r = OBJ_NAME_add(OBJ_nid2sn(k->type), OBJ_NAME_TYPE_KDF_METH,
84                      (const char *)k);
85     if (r == 0)
86         return 0;
87     r = OBJ_NAME_add(OBJ_nid2ln(k->type), OBJ_NAME_TYPE_KDF_METH,
88                      (const char *)k);
89     return r;
90 }
91
92 const EVP_CIPHER *EVP_get_cipherbyname(const char *name)
93 {
94     const EVP_CIPHER *cp;
95
96     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL))
97         return NULL;
98
99     cp = (const EVP_CIPHER *)OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH);
100     return cp;
101 }
102
103 const EVP_MD *EVP_get_digestbyname(const char *name)
104 {
105     const EVP_MD *cp;
106
107     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL))
108         return NULL;
109
110     cp = (const EVP_MD *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
111     return cp;
112 }
113
114 const EVP_MAC *EVP_get_macbyname(const char *name)
115 {
116     const EVP_MAC *mp;
117
118     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL))
119         return NULL;
120
121     mp = (const EVP_MAC *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MAC_METH);
122     return mp;
123 }
124
125 /* TODO(3.0) Is this API needed after implementing providers? */
126 const EVP_KDF *EVP_get_kdfbyname(const char *name)
127 {
128     const EVP_KDF *kdf;
129
130     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_KDFS, NULL))
131         return NULL;
132
133     kdf = (const EVP_KDF *)OBJ_NAME_get(name, OBJ_NAME_TYPE_KDF_METH);
134     return kdf;
135 }
136
137 void evp_cleanup_int(void)
138 {
139     OBJ_NAME_cleanup(OBJ_NAME_TYPE_MAC_METH);
140     OBJ_NAME_cleanup(OBJ_NAME_TYPE_KDF_METH);
141     OBJ_NAME_cleanup(OBJ_NAME_TYPE_CIPHER_METH);
142     OBJ_NAME_cleanup(OBJ_NAME_TYPE_MD_METH);
143     /*
144      * The above calls will only clean out the contents of the name hash
145      * table, but not the hash table itself.  The following line does that
146      * part.  -- Richard Levitte
147      */
148     OBJ_NAME_cleanup(-1);
149
150     EVP_PBE_cleanup();
151     OBJ_sigid_free();
152
153     evp_app_cleanup_int();
154 }
155
156 struct doall_cipher {
157     void *arg;
158     void (*fn) (const EVP_CIPHER *ciph,
159                 const char *from, const char *to, void *arg);
160 };
161
162 static void do_all_cipher_fn(const OBJ_NAME *nm, void *arg)
163 {
164     struct doall_cipher *dc = arg;
165     if (nm->alias)
166         dc->fn(NULL, nm->name, nm->data, dc->arg);
167     else
168         dc->fn((const EVP_CIPHER *)nm->data, nm->name, NULL, dc->arg);
169 }
170
171 void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
172                                    const char *from, const char *to, void *x),
173                        void *arg)
174 {
175     struct doall_cipher dc;
176
177     /* Ignore errors */
178     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
179
180     dc.fn = fn;
181     dc.arg = arg;
182     OBJ_NAME_do_all(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
183 }
184
185 void EVP_CIPHER_do_all_sorted(void (*fn) (const EVP_CIPHER *ciph,
186                                           const char *from, const char *to,
187                                           void *x), void *arg)
188 {
189     struct doall_cipher dc;
190
191     /* Ignore errors */
192     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
193
194     dc.fn = fn;
195     dc.arg = arg;
196     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
197 }
198
199 struct doall_md {
200     void *arg;
201     void (*fn) (const EVP_MD *ciph,
202                 const char *from, const char *to, void *arg);
203 };
204
205 static void do_all_md_fn(const OBJ_NAME *nm, void *arg)
206 {
207     struct doall_md *dc = arg;
208     if (nm->alias)
209         dc->fn(NULL, nm->name, nm->data, dc->arg);
210     else
211         dc->fn((const EVP_MD *)nm->data, nm->name, NULL, dc->arg);
212 }
213
214 void EVP_MD_do_all(void (*fn) (const EVP_MD *md,
215                                const char *from, const char *to, void *x),
216                    void *arg)
217 {
218     struct doall_md dc;
219
220     /* Ignore errors */
221     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
222
223     dc.fn = fn;
224     dc.arg = arg;
225     OBJ_NAME_do_all(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
226 }
227
228 void EVP_MD_do_all_sorted(void (*fn) (const EVP_MD *md,
229                                       const char *from, const char *to,
230                                       void *x), void *arg)
231 {
232     struct doall_md dc;
233
234     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
235
236     dc.fn = fn;
237     dc.arg = arg;
238     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
239 }
240
241 /* TODO(3.0) Are these do_all API's needed for MAC? */
242 struct doall_mac {
243     void *arg;
244     void (*fn) (const EVP_MAC *ciph,
245                 const char *from, const char *to, void *arg);
246 };
247
248 static void do_all_mac_fn(const OBJ_NAME *nm, void *arg)
249 {
250     struct doall_mac *dc = arg;
251
252     if (nm->alias)
253         dc->fn(NULL, nm->name, nm->data, dc->arg);
254     else
255         dc->fn((const EVP_MAC *)nm->data, nm->name, NULL, dc->arg);
256 }
257
258 void EVP_MAC_do_all(void (*fn)
259                     (const EVP_MAC *ciph, const char *from, const char *to,
260                      void *x), void *arg)
261 {
262     struct doall_mac dc;
263
264     /* Ignore errors */
265     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL);
266
267     dc.fn = fn;
268     dc.arg = arg;
269     OBJ_NAME_do_all(OBJ_NAME_TYPE_MAC_METH, do_all_mac_fn, &dc);
270 }
271
272 void EVP_MAC_do_all_sorted(void (*fn)
273                            (const EVP_MAC *ciph, const char *from,
274                             const char *to, void *x), void *arg)
275 {
276     struct doall_mac dc;
277
278     /* Ignore errors */
279     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL);
280
281     dc.fn = fn;
282     dc.arg = arg;
283     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MAC_METH, do_all_mac_fn, &dc);
284 }