5f523b2969e916bac15585bf08bc060dee4a96c6
[openssl.git] / crypto / asn1 / ameth_lib.c
1 /*
2  * Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 "e_os.h"               /* for strncasecmp */
11 #include "internal/cryptlib.h"
12 #include <stdio.h>
13 #include <openssl/asn1t.h>
14 #include <openssl/x509.h>
15 #include <openssl/engine.h>
16 #include "internal/asn1_int.h"
17 #include "internal/evp_int.h"
18
19 #include "standard_methods.h"
20
21 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
22 static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL;
23
24 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
25                            const EVP_PKEY_ASN1_METHOD *, ameth);
26
27 static int ameth_cmp(const EVP_PKEY_ASN1_METHOD *const *a,
28                      const EVP_PKEY_ASN1_METHOD *const *b)
29 {
30     return ((*a)->pkey_id - (*b)->pkey_id);
31 }
32
33 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
34                              const EVP_PKEY_ASN1_METHOD *, ameth);
35
36 int EVP_PKEY_asn1_get_count(void)
37 {
38     int num = OSSL_NELEM(standard_methods);
39     if (app_methods)
40         num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods);
41     return num;
42 }
43
44 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
45 {
46     int num = OSSL_NELEM(standard_methods);
47     if (idx < 0)
48         return NULL;
49     if (idx < num)
50         return standard_methods[idx];
51     idx -= num;
52     return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
53 }
54
55 static const EVP_PKEY_ASN1_METHOD *pkey_asn1_find(int type)
56 {
57     EVP_PKEY_ASN1_METHOD tmp;
58     const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret;
59     tmp.pkey_id = type;
60     if (app_methods) {
61         int idx;
62         idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp);
63         if (idx >= 0)
64             return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
65     }
66     ret = OBJ_bsearch_ameth(&t, standard_methods, OSSL_NELEM(standard_methods));
67     if (!ret || !*ret)
68         return NULL;
69     return *ret;
70 }
71
72 /*
73  * Find an implementation of an ASN1 algorithm. If 'pe' is not NULL also
74  * search through engines and set *pe to a functional reference to the engine
75  * implementing 'type' or NULL if no engine implements it.
76  */
77
78 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type)
79 {
80     const EVP_PKEY_ASN1_METHOD *t;
81
82     for (;;) {
83         t = pkey_asn1_find(type);
84         if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS))
85             break;
86         type = t->pkey_base_id;
87     }
88     if (pe) {
89 #ifndef OPENSSL_NO_ENGINE
90         ENGINE *e;
91         /* type will contain the final unaliased type */
92         e = ENGINE_get_pkey_asn1_meth_engine(type);
93         if (e) {
94             *pe = e;
95             return ENGINE_get_pkey_asn1_meth(e, type);
96         }
97 #endif
98         *pe = NULL;
99     }
100     return t;
101 }
102
103 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
104                                                    const char *str, int len)
105 {
106     int i;
107     const EVP_PKEY_ASN1_METHOD *ameth;
108     if (len == -1)
109         len = strlen(str);
110     if (pe) {
111 #ifndef OPENSSL_NO_ENGINE
112         ENGINE *e;
113         ameth = ENGINE_pkey_asn1_find_str(&e, str, len);
114         if (ameth) {
115             /*
116              * Convert structural into functional reference
117              */
118             if (!ENGINE_init(e))
119                 ameth = NULL;
120             ENGINE_free(e);
121             *pe = e;
122             return ameth;
123         }
124 #endif
125         *pe = NULL;
126     }
127     for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
128         ameth = EVP_PKEY_asn1_get0(i);
129         if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
130             continue;
131         if (((int)strlen(ameth->pem_str) == len)
132             && (strncasecmp(ameth->pem_str, str, len) == 0))
133             return ameth;
134     }
135     return NULL;
136 }
137
138 int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
139 {
140     if (app_methods == NULL) {
141         app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp);
142         if (app_methods == NULL)
143             return 0;
144     }
145     if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth))
146         return 0;
147     sk_EVP_PKEY_ASN1_METHOD_sort(app_methods);
148     return 1;
149 }
150
151 int EVP_PKEY_asn1_add_alias(int to, int from)
152 {
153     EVP_PKEY_ASN1_METHOD *ameth;
154     ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL);
155     if (ameth == NULL)
156         return 0;
157     ameth->pkey_base_id = to;
158     if (!EVP_PKEY_asn1_add0(ameth)) {
159         EVP_PKEY_asn1_free(ameth);
160         return 0;
161     }
162     return 1;
163 }
164
165 int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id,
166                             int *ppkey_flags, const char **pinfo,
167                             const char **ppem_str,
168                             const EVP_PKEY_ASN1_METHOD *ameth)
169 {
170     if (!ameth)
171         return 0;
172     if (ppkey_id)
173         *ppkey_id = ameth->pkey_id;
174     if (ppkey_base_id)
175         *ppkey_base_id = ameth->pkey_base_id;
176     if (ppkey_flags)
177         *ppkey_flags = ameth->pkey_flags;
178     if (pinfo)
179         *pinfo = ameth->info;
180     if (ppem_str)
181         *ppem_str = ameth->pem_str;
182     return 1;
183 }
184
185 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey)
186 {
187     return pkey->ameth;
188 }
189
190 EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
191                                         const char *pem_str, const char *info)
192 {
193     EVP_PKEY_ASN1_METHOD *ameth = OPENSSL_zalloc(sizeof(*ameth));
194
195     if (ameth == NULL)
196         return NULL;
197
198     ameth->pkey_id = id;
199     ameth->pkey_base_id = id;
200     ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC;
201
202     if (info) {
203         ameth->info = OPENSSL_strdup(info);
204         if (!ameth->info)
205             goto err;
206     }
207
208     if (pem_str) {
209         ameth->pem_str = OPENSSL_strdup(pem_str);
210         if (!ameth->pem_str)
211             goto err;
212     }
213
214     return ameth;
215
216  err:
217     EVP_PKEY_asn1_free(ameth);
218     return NULL;
219
220 }
221
222 void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
223                         const EVP_PKEY_ASN1_METHOD *src)
224 {
225
226     dst->pub_decode = src->pub_decode;
227     dst->pub_encode = src->pub_encode;
228     dst->pub_cmp = src->pub_cmp;
229     dst->pub_print = src->pub_print;
230
231     dst->priv_decode = src->priv_decode;
232     dst->priv_encode = src->priv_encode;
233     dst->priv_print = src->priv_print;
234
235     dst->old_priv_encode = src->old_priv_encode;
236     dst->old_priv_decode = src->old_priv_decode;
237
238     dst->pkey_size = src->pkey_size;
239     dst->pkey_bits = src->pkey_bits;
240
241     dst->param_decode = src->param_decode;
242     dst->param_encode = src->param_encode;
243     dst->param_missing = src->param_missing;
244     dst->param_copy = src->param_copy;
245     dst->param_cmp = src->param_cmp;
246     dst->param_print = src->param_print;
247
248     dst->pkey_free = src->pkey_free;
249     dst->pkey_ctrl = src->pkey_ctrl;
250
251     dst->item_sign = src->item_sign;
252     dst->item_verify = src->item_verify;
253
254     dst->siginf_set = src->siginf_set;
255
256     dst->pkey_check = src->pkey_check;
257
258 }
259
260 void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
261 {
262     if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) {
263         OPENSSL_free(ameth->pem_str);
264         OPENSSL_free(ameth->info);
265         OPENSSL_free(ameth);
266     }
267 }
268
269 void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
270                               int (*pub_decode) (EVP_PKEY *pk,
271                                                  X509_PUBKEY *pub),
272                               int (*pub_encode) (X509_PUBKEY *pub,
273                                                  const EVP_PKEY *pk),
274                               int (*pub_cmp) (const EVP_PKEY *a,
275                                               const EVP_PKEY *b),
276                               int (*pub_print) (BIO *out,
277                                                 const EVP_PKEY *pkey,
278                                                 int indent, ASN1_PCTX *pctx),
279                               int (*pkey_size) (const EVP_PKEY *pk),
280                               int (*pkey_bits) (const EVP_PKEY *pk))
281 {
282     ameth->pub_decode = pub_decode;
283     ameth->pub_encode = pub_encode;
284     ameth->pub_cmp = pub_cmp;
285     ameth->pub_print = pub_print;
286     ameth->pkey_size = pkey_size;
287     ameth->pkey_bits = pkey_bits;
288 }
289
290 void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
291                                int (*priv_decode) (EVP_PKEY *pk,
292                                                    const PKCS8_PRIV_KEY_INFO
293                                                    *p8inf),
294                                int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
295                                                    const EVP_PKEY *pk),
296                                int (*priv_print) (BIO *out,
297                                                   const EVP_PKEY *pkey,
298                                                   int indent,
299                                                   ASN1_PCTX *pctx))
300 {
301     ameth->priv_decode = priv_decode;
302     ameth->priv_encode = priv_encode;
303     ameth->priv_print = priv_print;
304 }
305
306 void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
307                              int (*param_decode) (EVP_PKEY *pkey,
308                                                   const unsigned char **pder,
309                                                   int derlen),
310                              int (*param_encode) (const EVP_PKEY *pkey,
311                                                   unsigned char **pder),
312                              int (*param_missing) (const EVP_PKEY *pk),
313                              int (*param_copy) (EVP_PKEY *to,
314                                                 const EVP_PKEY *from),
315                              int (*param_cmp) (const EVP_PKEY *a,
316                                                const EVP_PKEY *b),
317                              int (*param_print) (BIO *out,
318                                                  const EVP_PKEY *pkey,
319                                                  int indent, ASN1_PCTX *pctx))
320 {
321     ameth->param_decode = param_decode;
322     ameth->param_encode = param_encode;
323     ameth->param_missing = param_missing;
324     ameth->param_copy = param_copy;
325     ameth->param_cmp = param_cmp;
326     ameth->param_print = param_print;
327 }
328
329 void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
330                             void (*pkey_free) (EVP_PKEY *pkey))
331 {
332     ameth->pkey_free = pkey_free;
333 }
334
335 void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
336                             int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
337                                               long arg1, void *arg2))
338 {
339     ameth->pkey_ctrl = pkey_ctrl;
340 }
341
342 void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
343                                      int (*pkey_security_bits) (const EVP_PKEY
344                                                                 *pk))
345 {
346     ameth->pkey_security_bits = pkey_security_bits;
347 }
348
349 void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
350                             int (*item_verify) (EVP_MD_CTX *ctx,
351                                                 const ASN1_ITEM *it,
352                                                 void *asn,
353                                                 X509_ALGOR *a,
354                                                 ASN1_BIT_STRING *sig,
355                                                 EVP_PKEY *pkey),
356                             int (*item_sign) (EVP_MD_CTX *ctx,
357                                               const ASN1_ITEM *it,
358                                               void *asn,
359                                               X509_ALGOR *alg1,
360                                               X509_ALGOR *alg2,
361                                               ASN1_BIT_STRING *sig))
362 {
363     ameth->item_sign = item_sign;
364     ameth->item_verify = item_verify;
365 }
366
367 void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth,
368                               int (*siginf_set) (X509_SIG_INFO *siginf,
369                                                  const X509_ALGOR *alg,
370                                                  const ASN1_STRING *sig))
371 {
372     ameth->siginf_set = siginf_set;
373 }
374
375 void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
376                              int (*pkey_check) (const EVP_PKEY *pk))
377 {
378     ameth->pkey_check = pkey_check;
379 }