Remove --classic build entirely
[openssl.git] / crypto / asn1 / ameth_lib.c
1 /*
2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
3  * 2006.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include "internal/cryptlib.h"
61 #include <openssl/asn1t.h>
62 #include <openssl/x509.h>
63 #include <openssl/engine.h>
64 #include "internal/asn1_int.h"
65 #include "internal/evp_int.h"
66
67 /* Keep this sorted in type order !! */
68 static const EVP_PKEY_ASN1_METHOD *standard_methods[] = {
69 #ifndef OPENSSL_NO_RSA
70     &rsa_asn1_meths[0],
71     &rsa_asn1_meths[1],
72 #endif
73 #ifndef OPENSSL_NO_DH
74     &dh_asn1_meth,
75 #endif
76 #ifndef OPENSSL_NO_DSA
77     &dsa_asn1_meths[0],
78     &dsa_asn1_meths[1],
79     &dsa_asn1_meths[2],
80     &dsa_asn1_meths[3],
81     &dsa_asn1_meths[4],
82 #endif
83 #ifndef OPENSSL_NO_EC
84     &eckey_asn1_meth,
85 #endif
86     &hmac_asn1_meth,
87 #ifndef OPENSSL_NO_CMAC
88     &cmac_asn1_meth,
89 #endif
90 #ifndef OPENSSL_NO_DH
91     &dhx_asn1_meth
92 #endif
93 };
94
95 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
96 static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL;
97
98 #ifdef TEST
99 void main()
100 {
101     int i;
102     for (i = 0; i < OSSL_NELEM(standard_methods); i++)
103         fprintf(stderr, "Number %d id=%d (%s)\n", i,
104                 standard_methods[i]->pkey_id,
105                 OBJ_nid2sn(standard_methods[i]->pkey_id));
106 }
107 #endif
108
109 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
110                            const EVP_PKEY_ASN1_METHOD *, ameth);
111
112 static int ameth_cmp(const EVP_PKEY_ASN1_METHOD *const *a,
113                      const EVP_PKEY_ASN1_METHOD *const *b)
114 {
115     return ((*a)->pkey_id - (*b)->pkey_id);
116 }
117
118 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
119                              const EVP_PKEY_ASN1_METHOD *, ameth);
120
121 int EVP_PKEY_asn1_get_count(void)
122 {
123     int num = OSSL_NELEM(standard_methods);
124     if (app_methods)
125         num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods);
126     return num;
127 }
128
129 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
130 {
131     int num = OSSL_NELEM(standard_methods);
132     if (idx < 0)
133         return NULL;
134     if (idx < num)
135         return standard_methods[idx];
136     idx -= num;
137     return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
138 }
139
140 static const EVP_PKEY_ASN1_METHOD *pkey_asn1_find(int type)
141 {
142     EVP_PKEY_ASN1_METHOD tmp;
143     const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret;
144     tmp.pkey_id = type;
145     if (app_methods) {
146         int idx;
147         idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp);
148         if (idx >= 0)
149             return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
150     }
151     ret = OBJ_bsearch_ameth(&t, standard_methods, OSSL_NELEM(standard_methods));
152     if (!ret || !*ret)
153         return NULL;
154     return *ret;
155 }
156
157 /*
158  * Find an implementation of an ASN1 algorithm. If 'pe' is not NULL also
159  * search through engines and set *pe to a functional reference to the engine
160  * implementing 'type' or NULL if no engine implements it.
161  */
162
163 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type)
164 {
165     const EVP_PKEY_ASN1_METHOD *t;
166
167     for (;;) {
168         t = pkey_asn1_find(type);
169         if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS))
170             break;
171         type = t->pkey_base_id;
172     }
173     if (pe) {
174 #ifndef OPENSSL_NO_ENGINE
175         ENGINE *e;
176         /* type will contain the final unaliased type */
177         e = ENGINE_get_pkey_asn1_meth_engine(type);
178         if (e) {
179             *pe = e;
180             return ENGINE_get_pkey_asn1_meth(e, type);
181         }
182 #endif
183         *pe = NULL;
184     }
185     return t;
186 }
187
188 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
189                                                    const char *str, int len)
190 {
191     int i;
192     const EVP_PKEY_ASN1_METHOD *ameth;
193     if (len == -1)
194         len = strlen(str);
195     if (pe) {
196 #ifndef OPENSSL_NO_ENGINE
197         ENGINE *e;
198         ameth = ENGINE_pkey_asn1_find_str(&e, str, len);
199         if (ameth) {
200             /*
201              * Convert structural into functional reference
202              */
203             if (!ENGINE_init(e))
204                 ameth = NULL;
205             ENGINE_free(e);
206             *pe = e;
207             return ameth;
208         }
209 #endif
210         *pe = NULL;
211     }
212     for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
213         ameth = EVP_PKEY_asn1_get0(i);
214         if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
215             continue;
216         if (((int)strlen(ameth->pem_str) == len)
217             && (strncasecmp(ameth->pem_str, str, len) == 0))
218             return ameth;
219     }
220     return NULL;
221 }
222
223 int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
224 {
225     if (app_methods == NULL) {
226         app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp);
227         if (app_methods == NULL)
228             return 0;
229     }
230     if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth))
231         return 0;
232     sk_EVP_PKEY_ASN1_METHOD_sort(app_methods);
233     return 1;
234 }
235
236 int EVP_PKEY_asn1_add_alias(int to, int from)
237 {
238     EVP_PKEY_ASN1_METHOD *ameth;
239     ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL);
240     if (ameth == NULL)
241         return 0;
242     ameth->pkey_base_id = to;
243     if (!EVP_PKEY_asn1_add0(ameth)) {
244         EVP_PKEY_asn1_free(ameth);
245         return 0;
246     }
247     return 1;
248 }
249
250 int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id,
251                             int *ppkey_flags, const char **pinfo,
252                             const char **ppem_str,
253                             const EVP_PKEY_ASN1_METHOD *ameth)
254 {
255     if (!ameth)
256         return 0;
257     if (ppkey_id)
258         *ppkey_id = ameth->pkey_id;
259     if (ppkey_base_id)
260         *ppkey_base_id = ameth->pkey_base_id;
261     if (ppkey_flags)
262         *ppkey_flags = ameth->pkey_flags;
263     if (pinfo)
264         *pinfo = ameth->info;
265     if (ppem_str)
266         *ppem_str = ameth->pem_str;
267     return 1;
268 }
269
270 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(EVP_PKEY *pkey)
271 {
272     return pkey->ameth;
273 }
274
275 EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
276                                         const char *pem_str, const char *info)
277 {
278     EVP_PKEY_ASN1_METHOD *ameth = OPENSSL_zalloc(sizeof(*ameth));
279
280     if (ameth == NULL)
281         return NULL;
282
283     ameth->pkey_id = id;
284     ameth->pkey_base_id = id;
285     ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC;
286
287     if (info) {
288         ameth->info = OPENSSL_strdup(info);
289         if (!ameth->info)
290             goto err;
291     }
292
293     if (pem_str) {
294         ameth->pem_str = OPENSSL_strdup(pem_str);
295         if (!ameth->pem_str)
296             goto err;
297     }
298
299     return ameth;
300
301  err:
302     EVP_PKEY_asn1_free(ameth);
303     return NULL;
304
305 }
306
307 void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
308                         const EVP_PKEY_ASN1_METHOD *src)
309 {
310
311     dst->pub_decode = src->pub_decode;
312     dst->pub_encode = src->pub_encode;
313     dst->pub_cmp = src->pub_cmp;
314     dst->pub_print = src->pub_print;
315
316     dst->priv_decode = src->priv_decode;
317     dst->priv_encode = src->priv_encode;
318     dst->priv_print = src->priv_print;
319
320     dst->old_priv_encode = src->old_priv_encode;
321     dst->old_priv_decode = src->old_priv_decode;
322
323     dst->pkey_size = src->pkey_size;
324     dst->pkey_bits = src->pkey_bits;
325
326     dst->param_decode = src->param_decode;
327     dst->param_encode = src->param_encode;
328     dst->param_missing = src->param_missing;
329     dst->param_copy = src->param_copy;
330     dst->param_cmp = src->param_cmp;
331     dst->param_print = src->param_print;
332
333     dst->pkey_free = src->pkey_free;
334     dst->pkey_ctrl = src->pkey_ctrl;
335
336     dst->item_sign = src->item_sign;
337     dst->item_verify = src->item_verify;
338
339 }
340
341 void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
342 {
343     if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) {
344         OPENSSL_free(ameth->pem_str);
345         OPENSSL_free(ameth->info);
346         OPENSSL_free(ameth);
347     }
348 }
349
350 void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
351                               int (*pub_decode) (EVP_PKEY *pk,
352                                                  X509_PUBKEY *pub),
353                               int (*pub_encode) (X509_PUBKEY *pub,
354                                                  const EVP_PKEY *pk),
355                               int (*pub_cmp) (const EVP_PKEY *a,
356                                               const EVP_PKEY *b),
357                               int (*pub_print) (BIO *out,
358                                                 const EVP_PKEY *pkey,
359                                                 int indent, ASN1_PCTX *pctx),
360                               int (*pkey_size) (const EVP_PKEY *pk),
361                               int (*pkey_bits) (const EVP_PKEY *pk))
362 {
363     ameth->pub_decode = pub_decode;
364     ameth->pub_encode = pub_encode;
365     ameth->pub_cmp = pub_cmp;
366     ameth->pub_print = pub_print;
367     ameth->pkey_size = pkey_size;
368     ameth->pkey_bits = pkey_bits;
369 }
370
371 void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
372                                int (*priv_decode) (EVP_PKEY *pk,
373                                                    PKCS8_PRIV_KEY_INFO
374                                                    *p8inf),
375                                int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
376                                                    const EVP_PKEY *pk),
377                                int (*priv_print) (BIO *out,
378                                                   const EVP_PKEY *pkey,
379                                                   int indent,
380                                                   ASN1_PCTX *pctx))
381 {
382     ameth->priv_decode = priv_decode;
383     ameth->priv_encode = priv_encode;
384     ameth->priv_print = priv_print;
385 }
386
387 void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
388                              int (*param_decode) (EVP_PKEY *pkey,
389                                                   const unsigned char **pder,
390                                                   int derlen),
391                              int (*param_encode) (const EVP_PKEY *pkey,
392                                                   unsigned char **pder),
393                              int (*param_missing) (const EVP_PKEY *pk),
394                              int (*param_copy) (EVP_PKEY *to,
395                                                 const EVP_PKEY *from),
396                              int (*param_cmp) (const EVP_PKEY *a,
397                                                const EVP_PKEY *b),
398                              int (*param_print) (BIO *out,
399                                                  const EVP_PKEY *pkey,
400                                                  int indent, ASN1_PCTX *pctx))
401 {
402     ameth->param_decode = param_decode;
403     ameth->param_encode = param_encode;
404     ameth->param_missing = param_missing;
405     ameth->param_copy = param_copy;
406     ameth->param_cmp = param_cmp;
407     ameth->param_print = param_print;
408 }
409
410 void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
411                             void (*pkey_free) (EVP_PKEY *pkey))
412 {
413     ameth->pkey_free = pkey_free;
414 }
415
416 void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
417                             int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
418                                               long arg1, void *arg2))
419 {
420     ameth->pkey_ctrl = pkey_ctrl;
421 }
422
423 void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
424                                      int (*pkey_security_bits) (const EVP_PKEY
425                                                                 *pk))
426 {
427     ameth->pkey_security_bits = pkey_security_bits;
428 }
429
430 void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
431                             int (*item_verify) (EVP_MD_CTX *ctx,
432                                                 const ASN1_ITEM *it,
433                                                 void *asn,
434                                                 X509_ALGOR *a,
435                                                 ASN1_BIT_STRING *sig,
436                                                 EVP_PKEY *pkey),
437                             int (*item_sign) (EVP_MD_CTX *ctx,
438                                               const ASN1_ITEM *it,
439                                               void *asn,
440                                               X509_ALGOR *alg1,
441                                               X509_ALGOR *alg2,
442                                               ASN1_BIT_STRING *sig))
443 {
444     ameth->item_sign = item_sign;
445     ameth->item_verify = item_verify;
446 }