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