1 /* $OpenBSD: ameth_lib.c,v 1.21 2019/11/02 16:06:25 inoguchi Exp $ */ 2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 3 * project 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 <string.h> 61 62 #include <openssl/opensslconf.h> 63 64 #include <openssl/asn1t.h> 65 #include <openssl/x509.h> 66 67 #ifndef OPENSSL_NO_ENGINE 68 #include <openssl/engine.h> 69 #endif 70 71 #include "asn1_locl.h" 72 73 extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[]; 74 extern const EVP_PKEY_ASN1_METHOD rsa_pss_asn1_meth; 75 extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[]; 76 extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth; 77 extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth; 78 extern const EVP_PKEY_ASN1_METHOD gostr01_asn1_meths[]; 79 extern const EVP_PKEY_ASN1_METHOD gostimit_asn1_meth; 80 extern const EVP_PKEY_ASN1_METHOD hmac_asn1_meth; 81 extern const EVP_PKEY_ASN1_METHOD cmac_asn1_meth; 82 83 /* Keep this sorted in type order !! */ 84 static const EVP_PKEY_ASN1_METHOD *standard_methods[] = { 85 #ifndef OPENSSL_NO_RSA 86 &rsa_asn1_meths[0], 87 &rsa_asn1_meths[1], 88 #endif 89 #ifndef OPENSSL_NO_DH 90 &dh_asn1_meth, 91 #endif 92 #ifndef OPENSSL_NO_DSA 93 &dsa_asn1_meths[0], 94 &dsa_asn1_meths[1], 95 &dsa_asn1_meths[2], 96 &dsa_asn1_meths[3], 97 &dsa_asn1_meths[4], 98 #endif 99 #ifndef OPENSSL_NO_EC 100 &eckey_asn1_meth, 101 #endif 102 #ifndef OPENSSL_NO_GOST 103 &gostr01_asn1_meths[0], 104 &gostimit_asn1_meth, 105 #endif 106 &hmac_asn1_meth, 107 &cmac_asn1_meth, 108 #ifndef OPENSSL_NO_RSA 109 &rsa_pss_asn1_meth, 110 #endif 111 #ifndef OPENSSL_NO_GOST 112 &gostr01_asn1_meths[1], 113 &gostr01_asn1_meths[2], 114 #endif 115 }; 116 117 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b); 118 DECLARE_STACK_OF(EVP_PKEY_ASN1_METHOD) 119 static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL; 120 121 static int ameth_cmp_BSEARCH_CMP_FN(const void *, const void *); 122 static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *, const EVP_PKEY_ASN1_METHOD * const *); 123 static const EVP_PKEY_ASN1_METHOD * *OBJ_bsearch_ameth(const EVP_PKEY_ASN1_METHOD * *key, const EVP_PKEY_ASN1_METHOD * const *base, int num); 124 125 static int 126 ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a, 127 const EVP_PKEY_ASN1_METHOD * const *b) 128 { 129 return ((*a)->pkey_id - (*b)->pkey_id); 130 } 131 132 133 static int 134 ameth_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) 135 { 136 const EVP_PKEY_ASN1_METHOD * const *a = a_; 137 const EVP_PKEY_ASN1_METHOD * const *b = b_; 138 return ameth_cmp(a, b); 139 } 140 141 static const EVP_PKEY_ASN1_METHOD * * 142 OBJ_bsearch_ameth(const EVP_PKEY_ASN1_METHOD * *key, const EVP_PKEY_ASN1_METHOD * const *base, int num) 143 { 144 return (const EVP_PKEY_ASN1_METHOD * *)OBJ_bsearch_(key, base, num, sizeof(const EVP_PKEY_ASN1_METHOD *), 145 ameth_cmp_BSEARCH_CMP_FN); 146 } 147 148 int 149 EVP_PKEY_asn1_get_count(void) 150 { 151 int num = sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *); 152 if (app_methods) 153 num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods); 154 return num; 155 } 156 157 const EVP_PKEY_ASN1_METHOD * 158 EVP_PKEY_asn1_get0(int idx) 159 { 160 int num = sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *); 161 if (idx < 0) 162 return NULL; 163 if (idx < num) 164 return standard_methods[idx]; 165 idx -= num; 166 return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); 167 } 168 169 static const EVP_PKEY_ASN1_METHOD * 170 pkey_asn1_find(int type) 171 { 172 EVP_PKEY_ASN1_METHOD tmp; 173 const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret; 174 tmp.pkey_id = type; 175 if (app_methods) { 176 int idx; 177 idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp); 178 if (idx >= 0) 179 return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); 180 } 181 ret = OBJ_bsearch_ameth(&t, standard_methods, 182 sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *)); 183 if (!ret || !*ret) 184 return NULL; 185 return *ret; 186 } 187 188 /* Find an implementation of an ASN1 algorithm. If 'pe' is not NULL 189 * also search through engines and set *pe to a functional reference 190 * to the engine implementing 'type' or NULL if no engine implements 191 * it. 192 */ 193 194 const EVP_PKEY_ASN1_METHOD * 195 EVP_PKEY_asn1_find(ENGINE **pe, int type) 196 { 197 const EVP_PKEY_ASN1_METHOD *t; 198 199 for (;;) { 200 t = pkey_asn1_find(type); 201 if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS)) 202 break; 203 type = t->pkey_base_id; 204 } 205 if (pe) { 206 #ifndef OPENSSL_NO_ENGINE 207 ENGINE *e; 208 /* type will contain the final unaliased type */ 209 e = ENGINE_get_pkey_asn1_meth_engine(type); 210 if (e) { 211 *pe = e; 212 return ENGINE_get_pkey_asn1_meth(e, type); 213 } 214 #endif 215 *pe = NULL; 216 } 217 return t; 218 } 219 220 const EVP_PKEY_ASN1_METHOD * 221 EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len) 222 { 223 int i; 224 const EVP_PKEY_ASN1_METHOD *ameth; 225 if (len == -1) 226 len = strlen(str); 227 if (pe) { 228 #ifndef OPENSSL_NO_ENGINE 229 ENGINE *e; 230 ameth = ENGINE_pkey_asn1_find_str(&e, str, len); 231 if (ameth) { 232 /* Convert structural into 233 * functional reference 234 */ 235 if (!ENGINE_init(e)) 236 ameth = NULL; 237 ENGINE_free(e); 238 *pe = e; 239 return ameth; 240 } 241 #endif 242 *pe = NULL; 243 } 244 for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) { 245 ameth = EVP_PKEY_asn1_get0(i); 246 if (ameth->pkey_flags & ASN1_PKEY_ALIAS) 247 continue; 248 if (((int)strlen(ameth->pem_str) == len) && 249 !strncasecmp(ameth->pem_str, str, len)) 250 return ameth; 251 } 252 return NULL; 253 } 254 255 int 256 EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth) 257 { 258 if (app_methods == NULL) { 259 app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp); 260 if (!app_methods) 261 return 0; 262 } 263 if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth)) 264 return 0; 265 sk_EVP_PKEY_ASN1_METHOD_sort(app_methods); 266 return 1; 267 } 268 269 int 270 EVP_PKEY_asn1_add_alias(int to, int from) 271 { 272 EVP_PKEY_ASN1_METHOD *ameth; 273 274 ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL); 275 if (!ameth) 276 return 0; 277 ameth->pkey_base_id = to; 278 if (!EVP_PKEY_asn1_add0(ameth)) { 279 EVP_PKEY_asn1_free(ameth); 280 return 0; 281 } 282 return 1; 283 } 284 285 int 286 EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags, 287 const char **pinfo, const char **ppem_str, 288 const EVP_PKEY_ASN1_METHOD *ameth) 289 { 290 if (!ameth) 291 return 0; 292 if (ppkey_id) 293 *ppkey_id = ameth->pkey_id; 294 if (ppkey_base_id) 295 *ppkey_base_id = ameth->pkey_base_id; 296 if (ppkey_flags) 297 *ppkey_flags = ameth->pkey_flags; 298 if (pinfo) 299 *pinfo = ameth->info; 300 if (ppem_str) 301 *ppem_str = ameth->pem_str; 302 return 1; 303 } 304 305 const EVP_PKEY_ASN1_METHOD* 306 EVP_PKEY_get0_asn1(const EVP_PKEY *pkey) 307 { 308 return pkey->ameth; 309 } 310 311 EVP_PKEY_ASN1_METHOD* 312 EVP_PKEY_asn1_new(int id, int flags, const char *pem_str, const char *info) 313 { 314 EVP_PKEY_ASN1_METHOD *ameth; 315 316 if ((ameth = calloc(1, sizeof(EVP_PKEY_ASN1_METHOD))) == NULL) 317 return NULL; 318 319 ameth->pkey_id = id; 320 ameth->pkey_base_id = id; 321 ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC; 322 323 if (info != NULL) { 324 if ((ameth->info = strdup(info)) == NULL) 325 goto err; 326 } 327 328 if (pem_str != NULL) { 329 if ((ameth->pem_str = strdup(pem_str)) == NULL) 330 goto err; 331 } 332 333 return ameth; 334 335 err: 336 EVP_PKEY_asn1_free(ameth); 337 return NULL; 338 } 339 340 void 341 EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, const EVP_PKEY_ASN1_METHOD *src) 342 { 343 dst->pub_decode = src->pub_decode; 344 dst->pub_encode = src->pub_encode; 345 dst->pub_cmp = src->pub_cmp; 346 dst->pub_print = src->pub_print; 347 348 dst->priv_decode = src->priv_decode; 349 dst->priv_encode = src->priv_encode; 350 dst->priv_print = src->priv_print; 351 352 dst->old_priv_encode = src->old_priv_encode; 353 dst->old_priv_decode = src->old_priv_decode; 354 355 dst->pkey_size = src->pkey_size; 356 dst->pkey_bits = src->pkey_bits; 357 358 dst->param_decode = src->param_decode; 359 dst->param_encode = src->param_encode; 360 dst->param_missing = src->param_missing; 361 dst->param_copy = src->param_copy; 362 dst->param_cmp = src->param_cmp; 363 dst->param_print = src->param_print; 364 dst->sig_print = src->sig_print; 365 366 dst->pkey_free = src->pkey_free; 367 dst->pkey_ctrl = src->pkey_ctrl; 368 369 dst->item_sign = src->item_sign; 370 dst->item_verify = src->item_verify; 371 } 372 373 void 374 EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth) 375 { 376 if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) { 377 free(ameth->pem_str); 378 free(ameth->info); 379 free(ameth); 380 } 381 } 382 383 void 384 EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, 385 int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub), 386 int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk), 387 int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), 388 int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, 389 ASN1_PCTX *pctx), 390 int (*pkey_size)(const EVP_PKEY *pk), 391 int (*pkey_bits)(const EVP_PKEY *pk)) 392 { 393 ameth->pub_decode = pub_decode; 394 ameth->pub_encode = pub_encode; 395 ameth->pub_cmp = pub_cmp; 396 ameth->pub_print = pub_print; 397 ameth->pkey_size = pkey_size; 398 ameth->pkey_bits = pkey_bits; 399 } 400 401 void 402 EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, 403 int (*priv_decode)(EVP_PKEY *pk, const PKCS8_PRIV_KEY_INFO *p8inf), 404 int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk), 405 int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, 406 ASN1_PCTX *pctx)) 407 { 408 ameth->priv_decode = priv_decode; 409 ameth->priv_encode = priv_encode; 410 ameth->priv_print = priv_print; 411 } 412 413 void 414 EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, 415 int (*param_decode)(EVP_PKEY *pkey, const unsigned char **pder, int derlen), 416 int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder), 417 int (*param_missing)(const EVP_PKEY *pk), 418 int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from), 419 int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), 420 int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, 421 ASN1_PCTX *pctx)) 422 { 423 ameth->param_decode = param_decode; 424 ameth->param_encode = param_encode; 425 ameth->param_missing = param_missing; 426 ameth->param_copy = param_copy; 427 ameth->param_cmp = param_cmp; 428 ameth->param_print = param_print; 429 } 430 431 void 432 EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, 433 void (*pkey_free)(EVP_PKEY *pkey)) 434 { 435 ameth->pkey_free = pkey_free; 436 } 437 438 void 439 EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, 440 int (*pkey_ctrl)(EVP_PKEY *pkey, int op, long arg1, void *arg2)) 441 { 442 ameth->pkey_ctrl = pkey_ctrl; 443 } 444