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