1 /* 2 * Copyright 2015-2024 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 #ifndef OSSL_CRYPTO_EVP_H 11 # define OSSL_CRYPTO_EVP_H 12 # pragma once 13 14 # include <openssl/evp.h> 15 # include <openssl/core_dispatch.h> 16 # include "internal/refcount.h" 17 # include "crypto/ecx.h" 18 19 /* 20 * Default PKCS5 PBE KDF salt lengths 21 * In RFC 8018, PBE1 uses 8 bytes (64 bits) for its salt length. 22 * It also specifies to use at least 8 bytes for PBES2. 23 * The NIST requirement for PBKDF2 is 128 bits so we use this as the 24 * default for PBE2 (scrypt and HKDF2) 25 */ 26 # define PKCS5_DEFAULT_PBE1_SALT_LEN PKCS5_SALT_LEN 27 # define PKCS5_DEFAULT_PBE2_SALT_LEN 16 28 /* 29 * Don't free up md_ctx->pctx in EVP_MD_CTX_reset, use the reserved flag 30 * values in evp.h 31 */ 32 #define EVP_MD_CTX_FLAG_KEEP_PKEY_CTX 0x0400 33 #define EVP_MD_CTX_FLAG_FINALISED 0x0800 34 35 #define evp_pkey_ctx_is_legacy(ctx) \ 36 ((ctx)->keymgmt == NULL) 37 #define evp_pkey_ctx_is_provided(ctx) \ 38 (!evp_pkey_ctx_is_legacy(ctx)) 39 40 struct evp_pkey_ctx_st { 41 /* Actual operation */ 42 int operation; 43 44 /* 45 * Library context, property query, keytype and keymgmt associated with 46 * this context 47 */ 48 OSSL_LIB_CTX *libctx; 49 char *propquery; 50 const char *keytype; 51 /* If |pkey| below is set, this field is always a reference to its keymgmt */ 52 EVP_KEYMGMT *keymgmt; 53 54 union { 55 struct { 56 void *genctx; 57 } keymgmt; 58 59 struct { 60 EVP_KEYEXCH *exchange; 61 /* 62 * Opaque ctx returned from a providers exchange algorithm 63 * implementation OSSL_FUNC_keyexch_newctx() 64 */ 65 void *algctx; 66 } kex; 67 68 struct { 69 EVP_SIGNATURE *signature; 70 /* 71 * Opaque ctx returned from a providers signature algorithm 72 * implementation OSSL_FUNC_signature_newctx() 73 */ 74 void *algctx; 75 } sig; 76 77 struct { 78 EVP_ASYM_CIPHER *cipher; 79 /* 80 * Opaque ctx returned from a providers asymmetric cipher algorithm 81 * implementation OSSL_FUNC_asym_cipher_newctx() 82 */ 83 void *algctx; 84 } ciph; 85 struct { 86 EVP_KEM *kem; 87 /* 88 * Opaque ctx returned from a providers KEM algorithm 89 * implementation OSSL_FUNC_kem_newctx() 90 */ 91 void *algctx; 92 } encap; 93 } op; 94 95 /* 96 * Cached parameters. Inits of operations that depend on these should 97 * call evp_pkey_ctx_use_delayed_data() when the operation has been set 98 * up properly. 99 */ 100 struct { 101 /* Distinguishing Identifier, ISO/IEC 15946-3, FIPS 196 */ 102 char *dist_id_name; /* The name used with EVP_PKEY_CTX_ctrl_str() */ 103 void *dist_id; /* The distinguishing ID itself */ 104 size_t dist_id_len; /* The length of the distinguishing ID */ 105 106 /* Indicators of what has been set. Keep them together! */ 107 unsigned int dist_id_set : 1; 108 } cached_parameters; 109 110 /* Application specific data, usually used by the callback */ 111 void *app_data; 112 /* Keygen callback */ 113 EVP_PKEY_gen_cb *pkey_gencb; 114 /* implementation specific keygen data */ 115 int *keygen_info; 116 int keygen_info_count; 117 118 /* Legacy fields below */ 119 120 /* EVP_PKEY identity */ 121 int legacy_keytype; 122 /* Method associated with this operation */ 123 const EVP_PKEY_METHOD *pmeth; 124 /* Engine that implements this method or NULL if builtin */ 125 ENGINE *engine; 126 /* Key: may be NULL */ 127 EVP_PKEY *pkey; 128 /* Peer key for key agreement, may be NULL */ 129 EVP_PKEY *peerkey; 130 /* Algorithm specific data */ 131 void *data; 132 /* Indicator if digest_custom needs to be called */ 133 unsigned int flag_call_digest_custom:1; 134 /* 135 * Used to support taking custody of memory in the case of a provider being 136 * used with the deprecated EVP_PKEY_CTX_set_rsa_keygen_pubexp() API. This 137 * member should NOT be used for any other purpose and should be removed 138 * when said deprecated API is excised completely. 139 */ 140 BIGNUM *rsa_pubexp; 141 } /* EVP_PKEY_CTX */ ; 142 143 #define EVP_PKEY_FLAG_DYNAMIC 1 144 145 struct evp_pkey_method_st { 146 int pkey_id; 147 int flags; 148 int (*init) (EVP_PKEY_CTX *ctx); 149 int (*copy) (EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src); 150 void (*cleanup) (EVP_PKEY_CTX *ctx); 151 int (*paramgen_init) (EVP_PKEY_CTX *ctx); 152 int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); 153 int (*keygen_init) (EVP_PKEY_CTX *ctx); 154 int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); 155 int (*sign_init) (EVP_PKEY_CTX *ctx); 156 int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, 157 const unsigned char *tbs, size_t tbslen); 158 int (*verify_init) (EVP_PKEY_CTX *ctx); 159 int (*verify) (EVP_PKEY_CTX *ctx, 160 const unsigned char *sig, size_t siglen, 161 const unsigned char *tbs, size_t tbslen); 162 int (*verify_recover_init) (EVP_PKEY_CTX *ctx); 163 int (*verify_recover) (EVP_PKEY_CTX *ctx, 164 unsigned char *rout, size_t *routlen, 165 const unsigned char *sig, size_t siglen); 166 int (*signctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx); 167 int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, 168 EVP_MD_CTX *mctx); 169 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx); 170 int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen, 171 EVP_MD_CTX *mctx); 172 int (*encrypt_init) (EVP_PKEY_CTX *ctx); 173 int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, 174 const unsigned char *in, size_t inlen); 175 int (*decrypt_init) (EVP_PKEY_CTX *ctx); 176 int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, 177 const unsigned char *in, size_t inlen); 178 int (*derive_init) (EVP_PKEY_CTX *ctx); 179 int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); 180 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2); 181 int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value); 182 int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen, 183 const unsigned char *tbs, size_t tbslen); 184 int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig, 185 size_t siglen, const unsigned char *tbs, 186 size_t tbslen); 187 int (*check) (EVP_PKEY *pkey); 188 int (*public_check) (EVP_PKEY *pkey); 189 int (*param_check) (EVP_PKEY *pkey); 190 191 int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx); 192 } /* EVP_PKEY_METHOD */ ; 193 194 DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD) 195 196 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx); 197 198 const EVP_PKEY_METHOD *ossl_dh_pkey_method(void); 199 const EVP_PKEY_METHOD *ossl_dhx_pkey_method(void); 200 const EVP_PKEY_METHOD *ossl_dsa_pkey_method(void); 201 const EVP_PKEY_METHOD *ossl_ec_pkey_method(void); 202 const EVP_PKEY_METHOD *ossl_ecx25519_pkey_method(void); 203 const EVP_PKEY_METHOD *ossl_ecx448_pkey_method(void); 204 const EVP_PKEY_METHOD *ossl_ed25519_pkey_method(void); 205 const EVP_PKEY_METHOD *ossl_ed448_pkey_method(void); 206 const EVP_PKEY_METHOD *ossl_rsa_pkey_method(void); 207 const EVP_PKEY_METHOD *ossl_rsa_pss_pkey_method(void); 208 209 struct evp_mac_st { 210 OSSL_PROVIDER *prov; 211 int name_id; 212 char *type_name; 213 const char *description; 214 215 CRYPTO_REF_COUNT refcnt; 216 217 OSSL_FUNC_mac_newctx_fn *newctx; 218 OSSL_FUNC_mac_dupctx_fn *dupctx; 219 OSSL_FUNC_mac_freectx_fn *freectx; 220 OSSL_FUNC_mac_init_fn *init; 221 OSSL_FUNC_mac_update_fn *update; 222 OSSL_FUNC_mac_final_fn *final; 223 OSSL_FUNC_mac_gettable_params_fn *gettable_params; 224 OSSL_FUNC_mac_gettable_ctx_params_fn *gettable_ctx_params; 225 OSSL_FUNC_mac_settable_ctx_params_fn *settable_ctx_params; 226 OSSL_FUNC_mac_get_params_fn *get_params; 227 OSSL_FUNC_mac_get_ctx_params_fn *get_ctx_params; 228 OSSL_FUNC_mac_set_ctx_params_fn *set_ctx_params; 229 }; 230 231 struct evp_kdf_st { 232 OSSL_PROVIDER *prov; 233 int name_id; 234 char *type_name; 235 const char *description; 236 CRYPTO_REF_COUNT refcnt; 237 238 OSSL_FUNC_kdf_newctx_fn *newctx; 239 OSSL_FUNC_kdf_dupctx_fn *dupctx; 240 OSSL_FUNC_kdf_freectx_fn *freectx; 241 OSSL_FUNC_kdf_reset_fn *reset; 242 OSSL_FUNC_kdf_derive_fn *derive; 243 OSSL_FUNC_kdf_gettable_params_fn *gettable_params; 244 OSSL_FUNC_kdf_gettable_ctx_params_fn *gettable_ctx_params; 245 OSSL_FUNC_kdf_settable_ctx_params_fn *settable_ctx_params; 246 OSSL_FUNC_kdf_get_params_fn *get_params; 247 OSSL_FUNC_kdf_get_ctx_params_fn *get_ctx_params; 248 OSSL_FUNC_kdf_set_ctx_params_fn *set_ctx_params; 249 }; 250 251 #define EVP_ORIG_DYNAMIC 0 252 #define EVP_ORIG_GLOBAL 1 253 #define EVP_ORIG_METH 2 254 255 struct evp_md_st { 256 /* nid */ 257 int type; 258 259 /* Legacy structure members */ 260 int pkey_type; 261 int md_size; 262 unsigned long flags; 263 int origin; 264 int (*init) (EVP_MD_CTX *ctx); 265 int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count); 266 int (*final) (EVP_MD_CTX *ctx, unsigned char *md); 267 int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from); 268 int (*cleanup) (EVP_MD_CTX *ctx); 269 int block_size; 270 int ctx_size; /* how big does the ctx->md_data need to be */ 271 /* control function */ 272 int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2); 273 274 /* New structure members */ 275 /* Above comment to be removed when legacy has gone */ 276 int name_id; 277 char *type_name; 278 const char *description; 279 OSSL_PROVIDER *prov; 280 CRYPTO_REF_COUNT refcnt; 281 OSSL_FUNC_digest_newctx_fn *newctx; 282 OSSL_FUNC_digest_init_fn *dinit; 283 OSSL_FUNC_digest_update_fn *dupdate; 284 OSSL_FUNC_digest_final_fn *dfinal; 285 OSSL_FUNC_digest_squeeze_fn *dsqueeze; 286 OSSL_FUNC_digest_digest_fn *digest; 287 OSSL_FUNC_digest_freectx_fn *freectx; 288 OSSL_FUNC_digest_copyctx_fn *copyctx; 289 OSSL_FUNC_digest_dupctx_fn *dupctx; 290 OSSL_FUNC_digest_get_params_fn *get_params; 291 OSSL_FUNC_digest_set_ctx_params_fn *set_ctx_params; 292 OSSL_FUNC_digest_get_ctx_params_fn *get_ctx_params; 293 OSSL_FUNC_digest_gettable_params_fn *gettable_params; 294 OSSL_FUNC_digest_settable_ctx_params_fn *settable_ctx_params; 295 OSSL_FUNC_digest_gettable_ctx_params_fn *gettable_ctx_params; 296 297 } /* EVP_MD */ ; 298 299 struct evp_cipher_st { 300 int nid; 301 302 int block_size; 303 /* Default value for variable length ciphers */ 304 int key_len; 305 int iv_len; 306 307 /* Legacy structure members */ 308 /* Various flags */ 309 unsigned long flags; 310 /* How the EVP_CIPHER was created. */ 311 int origin; 312 /* init key */ 313 int (*init) (EVP_CIPHER_CTX *ctx, const unsigned char *key, 314 const unsigned char *iv, int enc); 315 /* encrypt/decrypt data */ 316 int (*do_cipher) (EVP_CIPHER_CTX *ctx, unsigned char *out, 317 const unsigned char *in, size_t inl); 318 /* cleanup ctx */ 319 int (*cleanup) (EVP_CIPHER_CTX *); 320 /* how big ctx->cipher_data needs to be */ 321 int ctx_size; 322 /* Populate a ASN1_TYPE with parameters */ 323 int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); 324 /* Get parameters from a ASN1_TYPE */ 325 int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); 326 /* Miscellaneous operations */ 327 int (*ctrl) (EVP_CIPHER_CTX *, int type, int arg, void *ptr); 328 /* Application data */ 329 void *app_data; 330 331 /* New structure members */ 332 /* Above comment to be removed when legacy has gone */ 333 int name_id; 334 char *type_name; 335 const char *description; 336 OSSL_PROVIDER *prov; 337 CRYPTO_REF_COUNT refcnt; 338 OSSL_FUNC_cipher_newctx_fn *newctx; 339 OSSL_FUNC_cipher_encrypt_init_fn *einit; 340 OSSL_FUNC_cipher_decrypt_init_fn *dinit; 341 OSSL_FUNC_cipher_update_fn *cupdate; 342 OSSL_FUNC_cipher_final_fn *cfinal; 343 OSSL_FUNC_cipher_cipher_fn *ccipher; 344 OSSL_FUNC_cipher_pipeline_encrypt_init_fn *p_einit; 345 OSSL_FUNC_cipher_pipeline_decrypt_init_fn *p_dinit; 346 OSSL_FUNC_cipher_pipeline_update_fn *p_cupdate; 347 OSSL_FUNC_cipher_pipeline_final_fn *p_cfinal; 348 OSSL_FUNC_cipher_freectx_fn *freectx; 349 OSSL_FUNC_cipher_dupctx_fn *dupctx; 350 OSSL_FUNC_cipher_get_params_fn *get_params; 351 OSSL_FUNC_cipher_get_ctx_params_fn *get_ctx_params; 352 OSSL_FUNC_cipher_set_ctx_params_fn *set_ctx_params; 353 OSSL_FUNC_cipher_gettable_params_fn *gettable_params; 354 OSSL_FUNC_cipher_gettable_ctx_params_fn *gettable_ctx_params; 355 OSSL_FUNC_cipher_settable_ctx_params_fn *settable_ctx_params; 356 } /* EVP_CIPHER */ ; 357 358 /* Macros to code block cipher wrappers */ 359 360 /* Wrapper functions for each cipher mode */ 361 362 #define EVP_C_DATA(kstruct, ctx) \ 363 ((kstruct *)EVP_CIPHER_CTX_get_cipher_data(ctx)) 364 365 #define BLOCK_CIPHER_ecb_loop() \ 366 size_t i, bl; \ 367 bl = EVP_CIPHER_CTX_get0_cipher(ctx)->block_size; \ 368 if (inl < bl) return 1;\ 369 inl -= bl; \ 370 for (i=0; i <= inl; i+=bl) 371 372 #define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \ 373 static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 374 {\ 375 BLOCK_CIPHER_ecb_loop() \ 376 cprefix##_ecb_encrypt(in + i, out + i, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_is_encrypting(ctx)); \ 377 return 1;\ 378 } 379 380 #define EVP_MAXCHUNK ((size_t)1 << 30) 381 382 #define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \ 383 static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 384 {\ 385 while(inl>=EVP_MAXCHUNK) {\ 386 int num = EVP_CIPHER_CTX_get_num(ctx);\ 387 cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, &num); \ 388 EVP_CIPHER_CTX_set_num(ctx, num);\ 389 inl-=EVP_MAXCHUNK;\ 390 in +=EVP_MAXCHUNK;\ 391 out+=EVP_MAXCHUNK;\ 392 }\ 393 if (inl) {\ 394 int num = EVP_CIPHER_CTX_get_num(ctx);\ 395 cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, &num); \ 396 EVP_CIPHER_CTX_set_num(ctx, num);\ 397 }\ 398 return 1;\ 399 } 400 401 #define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \ 402 static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 403 {\ 404 while(inl>=EVP_MAXCHUNK) {\ 405 cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\ 406 inl-=EVP_MAXCHUNK;\ 407 in +=EVP_MAXCHUNK;\ 408 out+=EVP_MAXCHUNK;\ 409 }\ 410 if (inl)\ 411 cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\ 412 return 1;\ 413 } 414 415 #define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \ 416 static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 417 {\ 418 size_t chunk = EVP_MAXCHUNK;\ 419 if (cbits == 1) chunk >>= 3;\ 420 if (inl < chunk) chunk = inl;\ 421 while (inl && inl >= chunk) {\ 422 int num = EVP_CIPHER_CTX_get_num(ctx);\ 423 cprefix##_cfb##cbits##_encrypt(in, out, (long) \ 424 ((cbits == 1) \ 425 && !EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) \ 426 ? chunk*8 : chunk), \ 427 &EVP_C_DATA(kstruct, ctx)->ksched, ctx->iv,\ 428 &num, EVP_CIPHER_CTX_is_encrypting(ctx));\ 429 EVP_CIPHER_CTX_set_num(ctx, num);\ 430 inl -= chunk;\ 431 in += chunk;\ 432 out += chunk;\ 433 if (inl < chunk) chunk = inl;\ 434 }\ 435 return 1;\ 436 } 437 438 #define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \ 439 BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \ 440 BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \ 441 BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \ 442 BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) 443 444 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \ 445 key_len, iv_len, flags, init_key, cleanup, \ 446 set_asn1, get_asn1, ctrl) \ 447 static const EVP_CIPHER cname##_##mode = { \ 448 nid##_##nmode, block_size, key_len, iv_len, \ 449 flags | EVP_CIPH_##MODE##_MODE, \ 450 EVP_ORIG_GLOBAL, \ 451 init_key, \ 452 cname##_##mode##_cipher, \ 453 cleanup, \ 454 sizeof(kstruct), \ 455 set_asn1, get_asn1,\ 456 ctrl, \ 457 NULL \ 458 }; \ 459 const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; } 460 461 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \ 462 iv_len, flags, init_key, cleanup, set_asn1, \ 463 get_asn1, ctrl) \ 464 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \ 465 iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) 466 467 #define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \ 468 iv_len, cbits, flags, init_key, cleanup, \ 469 set_asn1, get_asn1, ctrl) \ 470 BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \ 471 key_len, iv_len, flags, init_key, cleanup, set_asn1, \ 472 get_asn1, ctrl) 473 474 #define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \ 475 iv_len, cbits, flags, init_key, cleanup, \ 476 set_asn1, get_asn1, ctrl) \ 477 BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \ 478 key_len, iv_len, flags, init_key, cleanup, set_asn1, \ 479 get_asn1, ctrl) 480 481 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \ 482 flags, init_key, cleanup, set_asn1, \ 483 get_asn1, ctrl) \ 484 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \ 485 0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) 486 487 #define BLOCK_CIPHER_defs(cname, kstruct, \ 488 nid, block_size, key_len, iv_len, cbits, flags, \ 489 init_key, cleanup, set_asn1, get_asn1, ctrl) \ 490 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \ 491 init_key, cleanup, set_asn1, get_asn1, ctrl) \ 492 BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \ 493 flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \ 494 BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \ 495 flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \ 496 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \ 497 init_key, cleanup, set_asn1, get_asn1, ctrl) 498 499 /*- 500 #define BLOCK_CIPHER_defs(cname, kstruct, \ 501 nid, block_size, key_len, iv_len, flags,\ 502 init_key, cleanup, set_asn1, get_asn1, ctrl)\ 503 static const EVP_CIPHER cname##_cbc = {\ 504 nid##_cbc, block_size, key_len, iv_len, \ 505 flags | EVP_CIPH_CBC_MODE,\ 506 EVP_ORIG_GLOBAL,\ 507 init_key,\ 508 cname##_cbc_cipher,\ 509 cleanup,\ 510 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 511 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 512 set_asn1, get_asn1,\ 513 ctrl, \ 514 NULL \ 515 };\ 516 const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\ 517 static const EVP_CIPHER cname##_cfb = {\ 518 nid##_cfb64, 1, key_len, iv_len, \ 519 flags | EVP_CIPH_CFB_MODE,\ 520 EVP_ORIG_GLOBAL,\ 521 init_key,\ 522 cname##_cfb_cipher,\ 523 cleanup,\ 524 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 525 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 526 set_asn1, get_asn1,\ 527 ctrl,\ 528 NULL \ 529 };\ 530 const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\ 531 static const EVP_CIPHER cname##_ofb = {\ 532 nid##_ofb64, 1, key_len, iv_len, \ 533 flags | EVP_CIPH_OFB_MODE,\ 534 EVP_ORIG_GLOBAL,\ 535 init_key,\ 536 cname##_ofb_cipher,\ 537 cleanup,\ 538 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 539 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 540 set_asn1, get_asn1,\ 541 ctrl,\ 542 NULL \ 543 };\ 544 const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\ 545 static const EVP_CIPHER cname##_ecb = {\ 546 nid##_ecb, block_size, key_len, iv_len, \ 547 flags | EVP_CIPH_ECB_MODE,\ 548 EVP_ORIG_GLOBAL,\ 549 init_key,\ 550 cname##_ecb_cipher,\ 551 cleanup,\ 552 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 553 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 554 set_asn1, get_asn1,\ 555 ctrl,\ 556 NULL \ 557 };\ 558 const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; } 559 */ 560 561 #define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \ 562 block_size, key_len, iv_len, cbits, \ 563 flags, init_key, \ 564 cleanup, set_asn1, get_asn1, ctrl) \ 565 BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \ 566 BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \ 567 cbits, flags, init_key, cleanup, set_asn1, \ 568 get_asn1, ctrl) 569 570 #define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \ 571 BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \ 572 BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \ 573 NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \ 574 (fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \ 575 cipher##_init_key, NULL, NULL, NULL, NULL) 576 577 typedef struct { 578 unsigned char iv[EVP_MAX_IV_LENGTH]; 579 unsigned int iv_len; 580 unsigned int tag_len; 581 } evp_cipher_aead_asn1_params; 582 583 int evp_cipher_param_to_asn1_ex(EVP_CIPHER_CTX *c, ASN1_TYPE *type, 584 evp_cipher_aead_asn1_params *params); 585 586 int evp_cipher_asn1_to_param_ex(EVP_CIPHER_CTX *c, ASN1_TYPE *type, 587 evp_cipher_aead_asn1_params *params); 588 589 /* 590 * To support transparent execution of operation in backends other 591 * than the "origin" key, we support transparent export/import to 592 * those providers, and maintain a cache of the imported keydata, 593 * so we don't need to redo the export/import every time we perform 594 * the same operation in that same provider. 595 * This requires that the "origin" backend (whether it's a legacy or a 596 * provider "origin") implements exports, and that the target provider 597 * has an EVP_KEYMGMT that implements import. 598 */ 599 typedef struct { 600 EVP_KEYMGMT *keymgmt; 601 void *keydata; 602 int selection; 603 } OP_CACHE_ELEM; 604 605 DEFINE_STACK_OF(OP_CACHE_ELEM) 606 607 /* 608 * An EVP_PKEY can have the following states: 609 * 610 * untyped & empty: 611 * 612 * type == EVP_PKEY_NONE && keymgmt == NULL 613 * 614 * typed & empty: 615 * 616 * (type != EVP_PKEY_NONE && pkey.ptr == NULL) ## legacy (libcrypto only) 617 * || (keymgmt != NULL && keydata == NULL) ## provider side 618 * 619 * fully assigned: 620 * 621 * (type != EVP_PKEY_NONE && pkey.ptr != NULL) ## legacy (libcrypto only) 622 * || (keymgmt != NULL && keydata != NULL) ## provider side 623 * 624 * The easiest way to detect a legacy key is: 625 * 626 * keymgmt == NULL && type != EVP_PKEY_NONE 627 * 628 * The easiest way to detect a provider side key is: 629 * 630 * keymgmt != NULL 631 */ 632 #define evp_pkey_is_blank(pk) \ 633 ((pk)->type == EVP_PKEY_NONE && (pk)->keymgmt == NULL) 634 #define evp_pkey_is_typed(pk) \ 635 ((pk)->type != EVP_PKEY_NONE || (pk)->keymgmt != NULL) 636 #ifndef FIPS_MODULE 637 # define evp_pkey_is_assigned(pk) \ 638 ((pk)->pkey.ptr != NULL || (pk)->keydata != NULL) 639 #else 640 # define evp_pkey_is_assigned(pk) \ 641 ((pk)->keydata != NULL) 642 #endif 643 #define evp_pkey_is_legacy(pk) \ 644 ((pk)->type != EVP_PKEY_NONE && (pk)->keymgmt == NULL) 645 #define evp_pkey_is_provided(pk) \ 646 ((pk)->keymgmt != NULL) 647 648 union legacy_pkey_st { 649 void *ptr; 650 struct rsa_st *rsa; /* RSA */ 651 # ifndef OPENSSL_NO_DSA 652 struct dsa_st *dsa; /* DSA */ 653 # endif 654 # ifndef OPENSSL_NO_DH 655 struct dh_st *dh; /* DH */ 656 # endif 657 # ifndef OPENSSL_NO_EC 658 struct ec_key_st *ec; /* ECC */ 659 # ifndef OPENSSL_NO_ECX 660 ECX_KEY *ecx; /* X25519, X448, Ed25519, Ed448 */ 661 # endif 662 # endif 663 }; 664 665 struct evp_pkey_st { 666 /* == Legacy attributes == */ 667 int type; 668 int save_type; 669 670 # ifndef FIPS_MODULE 671 /* 672 * Legacy key "origin" is composed of a pointer to an EVP_PKEY_ASN1_METHOD, 673 * a pointer to a low level key and possibly a pointer to an engine. 674 */ 675 const EVP_PKEY_ASN1_METHOD *ameth; 676 ENGINE *engine; 677 ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */ 678 679 /* Union to store the reference to an origin legacy key */ 680 union legacy_pkey_st pkey; 681 682 /* Union to store the reference to a non-origin legacy key */ 683 union legacy_pkey_st legacy_cache_pkey; 684 # endif 685 686 /* == Common attributes == */ 687 CRYPTO_REF_COUNT references; 688 CRYPTO_RWLOCK *lock; 689 #ifndef FIPS_MODULE 690 STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ 691 int save_parameters; 692 unsigned int foreign:1; /* the low-level key is using an engine or an app-method */ 693 CRYPTO_EX_DATA ex_data; 694 #endif 695 696 /* == Provider attributes == */ 697 698 /* 699 * Provider keydata "origin" is composed of a pointer to an EVP_KEYMGMT 700 * and a pointer to the provider side key data. This is never used at 701 * the same time as the legacy key data above. 702 */ 703 EVP_KEYMGMT *keymgmt; 704 void *keydata; 705 /* 706 * If any libcrypto code does anything that may modify the keydata 707 * contents, this dirty counter must be incremented. 708 */ 709 size_t dirty_cnt; 710 711 /* 712 * To support transparent execution of operation in backends other 713 * than the "origin" key, we support transparent export/import to 714 * those providers, and maintain a cache of the imported keydata, 715 * so we don't need to redo the export/import every time we perform 716 * the same operation in that same provider. 717 */ 718 STACK_OF(OP_CACHE_ELEM) *operation_cache; 719 720 /* 721 * We keep a copy of that "origin"'s dirty count, so we know if the 722 * operation cache needs flushing. 723 */ 724 size_t dirty_cnt_copy; 725 726 /* Cache of key object information */ 727 struct { 728 int bits; 729 int security_bits; 730 int size; 731 } cache; 732 }; /* EVP_PKEY */ 733 734 /* The EVP_PKEY_OP_TYPE_ macros are found in include/openssl/evp.h */ 735 736 # define EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx) \ 737 (((ctx)->operation & EVP_PKEY_OP_TYPE_SIG) != 0) 738 739 # define EVP_PKEY_CTX_IS_DERIVE_OP(ctx) \ 740 (((ctx)->operation & EVP_PKEY_OP_TYPE_DERIVE) != 0) 741 742 # define EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx) \ 743 (((ctx)->operation & EVP_PKEY_OP_TYPE_CRYPT) != 0) 744 745 # define EVP_PKEY_CTX_IS_GEN_OP(ctx) \ 746 (((ctx)->operation & EVP_PKEY_OP_TYPE_GEN) != 0) 747 748 # define EVP_PKEY_CTX_IS_FROMDATA_OP(ctx) \ 749 (((ctx)->operation & EVP_PKEY_OP_TYPE_DATA) != 0) 750 751 # define EVP_PKEY_CTX_IS_KEM_OP(ctx) \ 752 (((ctx)->operation & EVP_PKEY_OP_TYPE_KEM) != 0) 753 754 void openssl_add_all_ciphers_int(void); 755 void openssl_add_all_digests_int(void); 756 void evp_cleanup_int(void); 757 void evp_app_cleanup_int(void); 758 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OSSL_LIB_CTX *libctx, 759 EVP_KEYMGMT **keymgmt, 760 const char *propquery); 761 #ifndef FIPS_MODULE 762 int evp_pkey_copy_downgraded(EVP_PKEY **dest, const EVP_PKEY *src); 763 void *evp_pkey_get_legacy(EVP_PKEY *pk); 764 void evp_pkey_free_legacy(EVP_PKEY *x); 765 EVP_PKEY *evp_pkcs82pkey_legacy(const PKCS8_PRIV_KEY_INFO *p8inf, 766 OSSL_LIB_CTX *libctx, const char *propq); 767 #endif 768 769 /* 770 * KEYMGMT utility functions 771 */ 772 773 /* 774 * Key import structure and helper function, to be used as an export callback 775 */ 776 struct evp_keymgmt_util_try_import_data_st { 777 EVP_KEYMGMT *keymgmt; 778 void *keydata; 779 780 int selection; 781 }; 782 int evp_keymgmt_util_try_import(const OSSL_PARAM params[], void *arg); 783 int evp_keymgmt_util_assign_pkey(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt, 784 void *keydata); 785 EVP_PKEY *evp_keymgmt_util_make_pkey(EVP_KEYMGMT *keymgmt, void *keydata); 786 787 int evp_keymgmt_util_export(const EVP_PKEY *pk, int selection, 788 OSSL_CALLBACK *export_cb, void *export_cbarg); 789 void *evp_keymgmt_util_export_to_provider(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt, 790 int selection); 791 OP_CACHE_ELEM *evp_keymgmt_util_find_operation_cache(EVP_PKEY *pk, 792 EVP_KEYMGMT *keymgmt, 793 int selection); 794 int evp_keymgmt_util_clear_operation_cache(EVP_PKEY *pk); 795 int evp_keymgmt_util_cache_keydata(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt, 796 void *keydata, int selection); 797 void evp_keymgmt_util_cache_keyinfo(EVP_PKEY *pk); 798 void *evp_keymgmt_util_fromdata(EVP_PKEY *target, EVP_KEYMGMT *keymgmt, 799 int selection, const OSSL_PARAM params[]); 800 int evp_keymgmt_util_has(EVP_PKEY *pk, int selection); 801 int evp_keymgmt_util_match(EVP_PKEY *pk1, EVP_PKEY *pk2, int selection); 802 int evp_keymgmt_util_copy(EVP_PKEY *to, EVP_PKEY *from, int selection); 803 void *evp_keymgmt_util_gen(EVP_PKEY *target, EVP_KEYMGMT *keymgmt, 804 void *genctx, OSSL_CALLBACK *cb, void *cbarg); 805 int evp_keymgmt_util_get_deflt_digest_name(EVP_KEYMGMT *keymgmt, 806 void *keydata, 807 char *mdname, size_t mdname_sz); 808 const char *evp_keymgmt_util_query_operation_name(EVP_KEYMGMT *keymgmt, 809 int op_id); 810 811 /* 812 * KEYMGMT provider interface functions 813 */ 814 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt); 815 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keyddata); 816 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, 817 void *keydata, OSSL_PARAM params[]); 818 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, 819 void *keydata, const OSSL_PARAM params[]); 820 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection, 821 const OSSL_PARAM params[]); 822 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx, 823 void *templ); 824 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx, 825 const OSSL_PARAM params[]); 826 int evp_keymgmt_gen_get_params(const EVP_KEYMGMT *keymgmt, 827 void *genctx, OSSL_PARAM params[]); 828 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx, 829 OSSL_CALLBACK *cb, void *cbarg); 830 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx); 831 832 int evp_keymgmt_has_load(const EVP_KEYMGMT *keymgmt); 833 void *evp_keymgmt_load(const EVP_KEYMGMT *keymgmt, 834 const void *objref, size_t objref_sz); 835 836 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keyddata, int selection); 837 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata, 838 int selection, int checktype); 839 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt, 840 const void *keydata1, const void *keydata2, 841 int selection); 842 843 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata, 844 int selection, const OSSL_PARAM params[]); 845 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt, 846 int selection); 847 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata, 848 int selection, OSSL_CALLBACK *param_cb, void *cbarg); 849 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt, 850 int selection); 851 void *evp_keymgmt_dup(const EVP_KEYMGMT *keymgmt, 852 const void *keydata_from, int selection); 853 EVP_KEYMGMT *evp_keymgmt_fetch_from_prov(OSSL_PROVIDER *prov, 854 const char *name, 855 const char *properties); 856 857 /* Pulling defines out of C source files */ 858 859 # define EVP_RC4_KEY_SIZE 16 860 # ifndef TLS1_1_VERSION 861 # define TLS1_1_VERSION 0x0302 862 # endif 863 864 void evp_encode_ctx_set_flags(EVP_ENCODE_CTX *ctx, unsigned int flags); 865 866 /* EVP_ENCODE_CTX flags */ 867 /* Don't generate new lines when encoding */ 868 #define EVP_ENCODE_CTX_NO_NEWLINES 1 869 /* Use the SRP base64 alphabet instead of the standard one */ 870 #define EVP_ENCODE_CTX_USE_SRP_ALPHABET 2 871 872 const EVP_CIPHER *evp_get_cipherbyname_ex(OSSL_LIB_CTX *libctx, 873 const char *name); 874 const EVP_MD *evp_get_digestbyname_ex(OSSL_LIB_CTX *libctx, 875 const char *name); 876 877 int ossl_pkcs5_pbkdf2_hmac_ex(const char *pass, int passlen, 878 const unsigned char *salt, int saltlen, int iter, 879 const EVP_MD *digest, int keylen, 880 unsigned char *out, 881 OSSL_LIB_CTX *libctx, const char *propq); 882 883 # ifndef FIPS_MODULE 884 /* 885 * Internal helpers for stricter EVP_PKEY_CTX_{set,get}_params(). 886 * 887 * Return 1 on success, 0 or negative for errors. 888 * 889 * In particular they return -2 if any of the params is not supported. 890 * 891 * They are not available in FIPS_MODULE as they depend on 892 * - EVP_PKEY_CTX_{get,set}_params() 893 * - EVP_PKEY_CTX_{gettable,settable}_params() 894 * 895 */ 896 int evp_pkey_ctx_set_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 897 int evp_pkey_ctx_get_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 898 899 EVP_MD_CTX *evp_md_ctx_new_ex(EVP_PKEY *pkey, const ASN1_OCTET_STRING *id, 900 OSSL_LIB_CTX *libctx, const char *propq); 901 int evp_pkey_name2type(const char *name); 902 const char *evp_pkey_type2name(int type); 903 904 int evp_pkey_ctx_use_cached_data(EVP_PKEY_CTX *ctx); 905 # endif /* !defined(FIPS_MODULE) */ 906 907 int evp_method_store_cache_flush(OSSL_LIB_CTX *libctx); 908 int evp_method_store_remove_all_provided(const OSSL_PROVIDER *prov); 909 910 int evp_default_properties_enable_fips_int(OSSL_LIB_CTX *libctx, int enable, 911 int loadconfig); 912 int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq, 913 int loadconfig, int mirrored); 914 char *evp_get_global_properties_str(OSSL_LIB_CTX *libctx, int loadconfig); 915 916 void evp_md_ctx_clear_digest(EVP_MD_CTX *ctx, int force, int keep_digest); 917 /* just free the algctx if set, returns 0 on inconsistent state of ctx */ 918 int evp_md_ctx_free_algctx(EVP_MD_CTX *ctx); 919 920 /* Three possible states: */ 921 # define EVP_PKEY_STATE_UNKNOWN 0 922 # define EVP_PKEY_STATE_LEGACY 1 923 # define EVP_PKEY_STATE_PROVIDER 2 924 int evp_pkey_ctx_state(const EVP_PKEY_CTX *ctx); 925 926 /* These two must ONLY be called for provider side operations */ 927 int evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX *ctx, 928 int keytype, int optype, 929 int cmd, int p1, void *p2); 930 int evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX *ctx, 931 const char *name, const char *value); 932 933 /* These two must ONLY be called for legacy operations */ 934 int evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params); 935 int evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 936 937 /* This must ONLY be called for legacy EVP_PKEYs */ 938 int evp_pkey_get_params_to_ctrl(const EVP_PKEY *pkey, OSSL_PARAM *params); 939 940 /* Same as the public get0 functions but are not const */ 941 # ifndef OPENSSL_NO_DEPRECATED_3_0 942 DH *evp_pkey_get0_DH_int(const EVP_PKEY *pkey); 943 EC_KEY *evp_pkey_get0_EC_KEY_int(const EVP_PKEY *pkey); 944 RSA *evp_pkey_get0_RSA_int(const EVP_PKEY *pkey); 945 # endif 946 947 /* Get internal identification number routines */ 948 int evp_asym_cipher_get_number(const EVP_ASYM_CIPHER *cipher); 949 int evp_cipher_get_number(const EVP_CIPHER *cipher); 950 int evp_kdf_get_number(const EVP_KDF *kdf); 951 int evp_kem_get_number(const EVP_KEM *wrap); 952 int evp_keyexch_get_number(const EVP_KEYEXCH *keyexch); 953 int evp_keymgmt_get_number(const EVP_KEYMGMT *keymgmt); 954 int evp_keymgmt_get_legacy_alg(const EVP_KEYMGMT *keymgmt); 955 int evp_mac_get_number(const EVP_MAC *mac); 956 int evp_md_get_number(const EVP_MD *md); 957 int evp_rand_get_number(const EVP_RAND *rand); 958 int evp_rand_can_seed(EVP_RAND_CTX *ctx); 959 size_t evp_rand_get_seed(EVP_RAND_CTX *ctx, 960 unsigned char **buffer, 961 int entropy, size_t min_len, size_t max_len, 962 int prediction_resistance, 963 const unsigned char *adin, size_t adin_len); 964 void evp_rand_clear_seed(EVP_RAND_CTX *ctx, 965 unsigned char *buffer, size_t b_len); 966 int evp_signature_get_number(const EVP_SIGNATURE *signature); 967 968 int evp_pkey_decrypt_alloc(EVP_PKEY_CTX *ctx, unsigned char **outp, 969 size_t *outlenp, size_t expected_outlen, 970 const unsigned char *in, size_t inlen); 971 972 int ossl_md2hmacnid(int mdnid); 973 int ossl_hmac2mdnid(int hmac_nid); 974 975 #endif /* OSSL_CRYPTO_EVP_H */ 976
