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_freectx_fn *freectx; 345 OSSL_FUNC_cipher_dupctx_fn *dupctx; 346 OSSL_FUNC_cipher_get_params_fn *get_params; 347 OSSL_FUNC_cipher_get_ctx_params_fn *get_ctx_params; 348 OSSL_FUNC_cipher_set_ctx_params_fn *set_ctx_params; 349 OSSL_FUNC_cipher_gettable_params_fn *gettable_params; 350 OSSL_FUNC_cipher_gettable_ctx_params_fn *gettable_ctx_params; 351 OSSL_FUNC_cipher_settable_ctx_params_fn *settable_ctx_params; 352 } /* EVP_CIPHER */ ; 353 354 /* Macros to code block cipher wrappers */ 355 356 /* Wrapper functions for each cipher mode */ 357 358 #define EVP_C_DATA(kstruct, ctx) \ 359 ((kstruct *)EVP_CIPHER_CTX_get_cipher_data(ctx)) 360 361 #define BLOCK_CIPHER_ecb_loop() \ 362 size_t i, bl; \ 363 bl = EVP_CIPHER_CTX_get0_cipher(ctx)->block_size; \ 364 if (inl < bl) return 1;\ 365 inl -= bl; \ 366 for (i=0; i <= inl; i+=bl) 367 368 #define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \ 369 static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 370 {\ 371 BLOCK_CIPHER_ecb_loop() \ 372 cprefix##_ecb_encrypt(in + i, out + i, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_is_encrypting(ctx)); \ 373 return 1;\ 374 } 375 376 #define EVP_MAXCHUNK ((size_t)1 << 30) 377 378 #define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \ 379 static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 380 {\ 381 while(inl>=EVP_MAXCHUNK) {\ 382 int num = EVP_CIPHER_CTX_get_num(ctx);\ 383 cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, &num); \ 384 EVP_CIPHER_CTX_set_num(ctx, num);\ 385 inl-=EVP_MAXCHUNK;\ 386 in +=EVP_MAXCHUNK;\ 387 out+=EVP_MAXCHUNK;\ 388 }\ 389 if (inl) {\ 390 int num = EVP_CIPHER_CTX_get_num(ctx);\ 391 cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, &num); \ 392 EVP_CIPHER_CTX_set_num(ctx, num);\ 393 }\ 394 return 1;\ 395 } 396 397 #define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \ 398 static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 399 {\ 400 while(inl>=EVP_MAXCHUNK) {\ 401 cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\ 402 inl-=EVP_MAXCHUNK;\ 403 in +=EVP_MAXCHUNK;\ 404 out+=EVP_MAXCHUNK;\ 405 }\ 406 if (inl)\ 407 cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\ 408 return 1;\ 409 } 410 411 #define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \ 412 static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \ 413 {\ 414 size_t chunk = EVP_MAXCHUNK;\ 415 if (cbits == 1) chunk >>= 3;\ 416 if (inl < chunk) chunk = inl;\ 417 while (inl && inl >= chunk) {\ 418 int num = EVP_CIPHER_CTX_get_num(ctx);\ 419 cprefix##_cfb##cbits##_encrypt(in, out, (long) \ 420 ((cbits == 1) \ 421 && !EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) \ 422 ? chunk*8 : chunk), \ 423 &EVP_C_DATA(kstruct, ctx)->ksched, ctx->iv,\ 424 &num, EVP_CIPHER_CTX_is_encrypting(ctx));\ 425 EVP_CIPHER_CTX_set_num(ctx, num);\ 426 inl -= chunk;\ 427 in += chunk;\ 428 out += chunk;\ 429 if (inl < chunk) chunk = inl;\ 430 }\ 431 return 1;\ 432 } 433 434 #define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \ 435 BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \ 436 BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \ 437 BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \ 438 BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) 439 440 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \ 441 key_len, iv_len, flags, init_key, cleanup, \ 442 set_asn1, get_asn1, ctrl) \ 443 static const EVP_CIPHER cname##_##mode = { \ 444 nid##_##nmode, block_size, key_len, iv_len, \ 445 flags | EVP_CIPH_##MODE##_MODE, \ 446 EVP_ORIG_GLOBAL, \ 447 init_key, \ 448 cname##_##mode##_cipher, \ 449 cleanup, \ 450 sizeof(kstruct), \ 451 set_asn1, get_asn1,\ 452 ctrl, \ 453 NULL \ 454 }; \ 455 const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; } 456 457 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \ 458 iv_len, flags, init_key, cleanup, set_asn1, \ 459 get_asn1, ctrl) \ 460 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \ 461 iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) 462 463 #define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \ 464 iv_len, cbits, flags, init_key, cleanup, \ 465 set_asn1, get_asn1, ctrl) \ 466 BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \ 467 key_len, iv_len, flags, init_key, cleanup, set_asn1, \ 468 get_asn1, ctrl) 469 470 #define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \ 471 iv_len, cbits, flags, init_key, cleanup, \ 472 set_asn1, get_asn1, ctrl) \ 473 BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \ 474 key_len, iv_len, flags, init_key, cleanup, set_asn1, \ 475 get_asn1, ctrl) 476 477 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \ 478 flags, init_key, cleanup, set_asn1, \ 479 get_asn1, ctrl) \ 480 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \ 481 0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) 482 483 #define BLOCK_CIPHER_defs(cname, kstruct, \ 484 nid, block_size, key_len, iv_len, cbits, flags, \ 485 init_key, cleanup, set_asn1, get_asn1, ctrl) \ 486 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \ 487 init_key, cleanup, set_asn1, get_asn1, ctrl) \ 488 BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \ 489 flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \ 490 BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \ 491 flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \ 492 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \ 493 init_key, cleanup, set_asn1, get_asn1, ctrl) 494 495 /*- 496 #define BLOCK_CIPHER_defs(cname, kstruct, \ 497 nid, block_size, key_len, iv_len, flags,\ 498 init_key, cleanup, set_asn1, get_asn1, ctrl)\ 499 static const EVP_CIPHER cname##_cbc = {\ 500 nid##_cbc, block_size, key_len, iv_len, \ 501 flags | EVP_CIPH_CBC_MODE,\ 502 EVP_ORIG_GLOBAL,\ 503 init_key,\ 504 cname##_cbc_cipher,\ 505 cleanup,\ 506 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 507 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 508 set_asn1, get_asn1,\ 509 ctrl, \ 510 NULL \ 511 };\ 512 const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\ 513 static const EVP_CIPHER cname##_cfb = {\ 514 nid##_cfb64, 1, key_len, iv_len, \ 515 flags | EVP_CIPH_CFB_MODE,\ 516 EVP_ORIG_GLOBAL,\ 517 init_key,\ 518 cname##_cfb_cipher,\ 519 cleanup,\ 520 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 521 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 522 set_asn1, get_asn1,\ 523 ctrl,\ 524 NULL \ 525 };\ 526 const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\ 527 static const EVP_CIPHER cname##_ofb = {\ 528 nid##_ofb64, 1, key_len, iv_len, \ 529 flags | EVP_CIPH_OFB_MODE,\ 530 EVP_ORIG_GLOBAL,\ 531 init_key,\ 532 cname##_ofb_cipher,\ 533 cleanup,\ 534 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 535 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 536 set_asn1, get_asn1,\ 537 ctrl,\ 538 NULL \ 539 };\ 540 const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\ 541 static const EVP_CIPHER cname##_ecb = {\ 542 nid##_ecb, block_size, key_len, iv_len, \ 543 flags | EVP_CIPH_ECB_MODE,\ 544 EVP_ORIG_GLOBAL,\ 545 init_key,\ 546 cname##_ecb_cipher,\ 547 cleanup,\ 548 sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\ 549 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\ 550 set_asn1, get_asn1,\ 551 ctrl,\ 552 NULL \ 553 };\ 554 const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; } 555 */ 556 557 #define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \ 558 block_size, key_len, iv_len, cbits, \ 559 flags, init_key, \ 560 cleanup, set_asn1, get_asn1, ctrl) \ 561 BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \ 562 BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \ 563 cbits, flags, init_key, cleanup, set_asn1, \ 564 get_asn1, ctrl) 565 566 #define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \ 567 BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \ 568 BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \ 569 NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \ 570 (fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \ 571 cipher##_init_key, NULL, NULL, NULL, NULL) 572 573 typedef struct { 574 unsigned char iv[EVP_MAX_IV_LENGTH]; 575 unsigned int iv_len; 576 unsigned int tag_len; 577 } evp_cipher_aead_asn1_params; 578 579 int evp_cipher_param_to_asn1_ex(EVP_CIPHER_CTX *c, ASN1_TYPE *type, 580 evp_cipher_aead_asn1_params *params); 581 582 int evp_cipher_asn1_to_param_ex(EVP_CIPHER_CTX *c, ASN1_TYPE *type, 583 evp_cipher_aead_asn1_params *params); 584 585 /* 586 * To support transparent execution of operation in backends other 587 * than the "origin" key, we support transparent export/import to 588 * those providers, and maintain a cache of the imported keydata, 589 * so we don't need to redo the export/import every time we perform 590 * the same operation in that same provider. 591 * This requires that the "origin" backend (whether it's a legacy or a 592 * provider "origin") implements exports, and that the target provider 593 * has an EVP_KEYMGMT that implements import. 594 */ 595 typedef struct { 596 EVP_KEYMGMT *keymgmt; 597 void *keydata; 598 int selection; 599 } OP_CACHE_ELEM; 600 601 DEFINE_STACK_OF(OP_CACHE_ELEM) 602 603 /* 604 * An EVP_PKEY can have the following states: 605 * 606 * untyped & empty: 607 * 608 * type == EVP_PKEY_NONE && keymgmt == NULL 609 * 610 * typed & empty: 611 * 612 * (type != EVP_PKEY_NONE && pkey.ptr == NULL) ## legacy (libcrypto only) 613 * || (keymgmt != NULL && keydata == NULL) ## provider side 614 * 615 * fully assigned: 616 * 617 * (type != EVP_PKEY_NONE && pkey.ptr != NULL) ## legacy (libcrypto only) 618 * || (keymgmt != NULL && keydata != NULL) ## provider side 619 * 620 * The easiest way to detect a legacy key is: 621 * 622 * keymgmt == NULL && type != EVP_PKEY_NONE 623 * 624 * The easiest way to detect a provider side key is: 625 * 626 * keymgmt != NULL 627 */ 628 #define evp_pkey_is_blank(pk) \ 629 ((pk)->type == EVP_PKEY_NONE && (pk)->keymgmt == NULL) 630 #define evp_pkey_is_typed(pk) \ 631 ((pk)->type != EVP_PKEY_NONE || (pk)->keymgmt != NULL) 632 #ifndef FIPS_MODULE 633 # define evp_pkey_is_assigned(pk) \ 634 ((pk)->pkey.ptr != NULL || (pk)->keydata != NULL) 635 #else 636 # define evp_pkey_is_assigned(pk) \ 637 ((pk)->keydata != NULL) 638 #endif 639 #define evp_pkey_is_legacy(pk) \ 640 ((pk)->type != EVP_PKEY_NONE && (pk)->keymgmt == NULL) 641 #define evp_pkey_is_provided(pk) \ 642 ((pk)->keymgmt != NULL) 643 644 union legacy_pkey_st { 645 void *ptr; 646 struct rsa_st *rsa; /* RSA */ 647 # ifndef OPENSSL_NO_DSA 648 struct dsa_st *dsa; /* DSA */ 649 # endif 650 # ifndef OPENSSL_NO_DH 651 struct dh_st *dh; /* DH */ 652 # endif 653 # ifndef OPENSSL_NO_EC 654 struct ec_key_st *ec; /* ECC */ 655 # ifndef OPENSSL_NO_ECX 656 ECX_KEY *ecx; /* X25519, X448, Ed25519, Ed448 */ 657 # endif 658 # endif 659 }; 660 661 struct evp_pkey_st { 662 /* == Legacy attributes == */ 663 int type; 664 int save_type; 665 666 # ifndef FIPS_MODULE 667 /* 668 * Legacy key "origin" is composed of a pointer to an EVP_PKEY_ASN1_METHOD, 669 * a pointer to a low level key and possibly a pointer to an engine. 670 */ 671 const EVP_PKEY_ASN1_METHOD *ameth; 672 ENGINE *engine; 673 ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */ 674 675 /* Union to store the reference to an origin legacy key */ 676 union legacy_pkey_st pkey; 677 678 /* Union to store the reference to a non-origin legacy key */ 679 union legacy_pkey_st legacy_cache_pkey; 680 # endif 681 682 /* == Common attributes == */ 683 CRYPTO_REF_COUNT references; 684 CRYPTO_RWLOCK *lock; 685 #ifndef FIPS_MODULE 686 STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ 687 int save_parameters; 688 unsigned int foreign:1; /* the low-level key is using an engine or an app-method */ 689 CRYPTO_EX_DATA ex_data; 690 #endif 691 692 /* == Provider attributes == */ 693 694 /* 695 * Provider keydata "origin" is composed of a pointer to an EVP_KEYMGMT 696 * and a pointer to the provider side key data. This is never used at 697 * the same time as the legacy key data above. 698 */ 699 EVP_KEYMGMT *keymgmt; 700 void *keydata; 701 /* 702 * If any libcrypto code does anything that may modify the keydata 703 * contents, this dirty counter must be incremented. 704 */ 705 size_t dirty_cnt; 706 707 /* 708 * To support transparent execution of operation in backends other 709 * than the "origin" key, we support transparent export/import to 710 * those providers, and maintain a cache of the imported keydata, 711 * so we don't need to redo the export/import every time we perform 712 * the same operation in that same provider. 713 */ 714 STACK_OF(OP_CACHE_ELEM) *operation_cache; 715 716 /* 717 * We keep a copy of that "origin"'s dirty count, so we know if the 718 * operation cache needs flushing. 719 */ 720 size_t dirty_cnt_copy; 721 722 /* Cache of key object information */ 723 struct { 724 int bits; 725 int security_bits; 726 int size; 727 } cache; 728 }; /* EVP_PKEY */ 729 730 /* The EVP_PKEY_OP_TYPE_ macros are found in include/openssl/evp.h */ 731 732 # define EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx) \ 733 (((ctx)->operation & EVP_PKEY_OP_TYPE_SIG) != 0) 734 735 # define EVP_PKEY_CTX_IS_DERIVE_OP(ctx) \ 736 (((ctx)->operation & EVP_PKEY_OP_TYPE_DERIVE) != 0) 737 738 # define EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx) \ 739 (((ctx)->operation & EVP_PKEY_OP_TYPE_CRYPT) != 0) 740 741 # define EVP_PKEY_CTX_IS_GEN_OP(ctx) \ 742 (((ctx)->operation & EVP_PKEY_OP_TYPE_GEN) != 0) 743 744 # define EVP_PKEY_CTX_IS_FROMDATA_OP(ctx) \ 745 (((ctx)->operation & EVP_PKEY_OP_TYPE_DATA) != 0) 746 747 # define EVP_PKEY_CTX_IS_KEM_OP(ctx) \ 748 (((ctx)->operation & EVP_PKEY_OP_TYPE_KEM) != 0) 749 750 void openssl_add_all_ciphers_int(void); 751 void openssl_add_all_digests_int(void); 752 void evp_cleanup_int(void); 753 void evp_app_cleanup_int(void); 754 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OSSL_LIB_CTX *libctx, 755 EVP_KEYMGMT **keymgmt, 756 const char *propquery); 757 #ifndef FIPS_MODULE 758 int evp_pkey_copy_downgraded(EVP_PKEY **dest, const EVP_PKEY *src); 759 void *evp_pkey_get_legacy(EVP_PKEY *pk); 760 void evp_pkey_free_legacy(EVP_PKEY *x); 761 EVP_PKEY *evp_pkcs82pkey_legacy(const PKCS8_PRIV_KEY_INFO *p8inf, 762 OSSL_LIB_CTX *libctx, const char *propq); 763 #endif 764 765 /* 766 * KEYMGMT utility functions 767 */ 768 769 /* 770 * Key import structure and helper function, to be used as an export callback 771 */ 772 struct evp_keymgmt_util_try_import_data_st { 773 EVP_KEYMGMT *keymgmt; 774 void *keydata; 775 776 int selection; 777 }; 778 int evp_keymgmt_util_try_import(const OSSL_PARAM params[], void *arg); 779 int evp_keymgmt_util_assign_pkey(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt, 780 void *keydata); 781 EVP_PKEY *evp_keymgmt_util_make_pkey(EVP_KEYMGMT *keymgmt, void *keydata); 782 783 int evp_keymgmt_util_export(const EVP_PKEY *pk, int selection, 784 OSSL_CALLBACK *export_cb, void *export_cbarg); 785 void *evp_keymgmt_util_export_to_provider(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt, 786 int selection); 787 OP_CACHE_ELEM *evp_keymgmt_util_find_operation_cache(EVP_PKEY *pk, 788 EVP_KEYMGMT *keymgmt, 789 int selection); 790 int evp_keymgmt_util_clear_operation_cache(EVP_PKEY *pk); 791 int evp_keymgmt_util_cache_keydata(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt, 792 void *keydata, int selection); 793 void evp_keymgmt_util_cache_keyinfo(EVP_PKEY *pk); 794 void *evp_keymgmt_util_fromdata(EVP_PKEY *target, EVP_KEYMGMT *keymgmt, 795 int selection, const OSSL_PARAM params[]); 796 int evp_keymgmt_util_has(EVP_PKEY *pk, int selection); 797 int evp_keymgmt_util_match(EVP_PKEY *pk1, EVP_PKEY *pk2, int selection); 798 int evp_keymgmt_util_copy(EVP_PKEY *to, EVP_PKEY *from, int selection); 799 void *evp_keymgmt_util_gen(EVP_PKEY *target, EVP_KEYMGMT *keymgmt, 800 void *genctx, OSSL_CALLBACK *cb, void *cbarg); 801 int evp_keymgmt_util_get_deflt_digest_name(EVP_KEYMGMT *keymgmt, 802 void *keydata, 803 char *mdname, size_t mdname_sz); 804 const char *evp_keymgmt_util_query_operation_name(EVP_KEYMGMT *keymgmt, 805 int op_id); 806 807 /* 808 * KEYMGMT provider interface functions 809 */ 810 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt); 811 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keyddata); 812 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, 813 void *keydata, OSSL_PARAM params[]); 814 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, 815 void *keydata, const OSSL_PARAM params[]); 816 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection, 817 const OSSL_PARAM params[]); 818 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx, 819 void *templ); 820 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx, 821 const OSSL_PARAM params[]); 822 int evp_keymgmt_gen_get_params(const EVP_KEYMGMT *keymgmt, 823 void *genctx, OSSL_PARAM params[]); 824 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx, 825 OSSL_CALLBACK *cb, void *cbarg); 826 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx); 827 828 int evp_keymgmt_has_load(const EVP_KEYMGMT *keymgmt); 829 void *evp_keymgmt_load(const EVP_KEYMGMT *keymgmt, 830 const void *objref, size_t objref_sz); 831 832 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keyddata, int selection); 833 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata, 834 int selection, int checktype); 835 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt, 836 const void *keydata1, const void *keydata2, 837 int selection); 838 839 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata, 840 int selection, const OSSL_PARAM params[]); 841 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt, 842 int selection); 843 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata, 844 int selection, OSSL_CALLBACK *param_cb, void *cbarg); 845 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt, 846 int selection); 847 void *evp_keymgmt_dup(const EVP_KEYMGMT *keymgmt, 848 const void *keydata_from, int selection); 849 EVP_KEYMGMT *evp_keymgmt_fetch_from_prov(OSSL_PROVIDER *prov, 850 const char *name, 851 const char *properties); 852 853 /* Pulling defines out of C source files */ 854 855 # define EVP_RC4_KEY_SIZE 16 856 # ifndef TLS1_1_VERSION 857 # define TLS1_1_VERSION 0x0302 858 # endif 859 860 void evp_encode_ctx_set_flags(EVP_ENCODE_CTX *ctx, unsigned int flags); 861 862 /* EVP_ENCODE_CTX flags */ 863 /* Don't generate new lines when encoding */ 864 #define EVP_ENCODE_CTX_NO_NEWLINES 1 865 /* Use the SRP base64 alphabet instead of the standard one */ 866 #define EVP_ENCODE_CTX_USE_SRP_ALPHABET 2 867 868 const EVP_CIPHER *evp_get_cipherbyname_ex(OSSL_LIB_CTX *libctx, 869 const char *name); 870 const EVP_MD *evp_get_digestbyname_ex(OSSL_LIB_CTX *libctx, 871 const char *name); 872 873 int ossl_pkcs5_pbkdf2_hmac_ex(const char *pass, int passlen, 874 const unsigned char *salt, int saltlen, int iter, 875 const EVP_MD *digest, int keylen, 876 unsigned char *out, 877 OSSL_LIB_CTX *libctx, const char *propq); 878 879 # ifndef FIPS_MODULE 880 /* 881 * Internal helpers for stricter EVP_PKEY_CTX_{set,get}_params(). 882 * 883 * Return 1 on success, 0 or negative for errors. 884 * 885 * In particular they return -2 if any of the params is not supported. 886 * 887 * They are not available in FIPS_MODULE as they depend on 888 * - EVP_PKEY_CTX_{get,set}_params() 889 * - EVP_PKEY_CTX_{gettable,settable}_params() 890 * 891 */ 892 int evp_pkey_ctx_set_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 893 int evp_pkey_ctx_get_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 894 895 EVP_MD_CTX *evp_md_ctx_new_ex(EVP_PKEY *pkey, const ASN1_OCTET_STRING *id, 896 OSSL_LIB_CTX *libctx, const char *propq); 897 int evp_pkey_name2type(const char *name); 898 const char *evp_pkey_type2name(int type); 899 900 int evp_pkey_ctx_use_cached_data(EVP_PKEY_CTX *ctx); 901 # endif /* !defined(FIPS_MODULE) */ 902 903 int evp_method_store_cache_flush(OSSL_LIB_CTX *libctx); 904 int evp_method_store_remove_all_provided(const OSSL_PROVIDER *prov); 905 906 int evp_default_properties_enable_fips_int(OSSL_LIB_CTX *libctx, int enable, 907 int loadconfig); 908 int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq, 909 int loadconfig, int mirrored); 910 char *evp_get_global_properties_str(OSSL_LIB_CTX *libctx, int loadconfig); 911 912 void evp_md_ctx_clear_digest(EVP_MD_CTX *ctx, int force, int keep_digest); 913 /* just free the algctx if set, returns 0 on inconsistent state of ctx */ 914 int evp_md_ctx_free_algctx(EVP_MD_CTX *ctx); 915 916 /* Three possible states: */ 917 # define EVP_PKEY_STATE_UNKNOWN 0 918 # define EVP_PKEY_STATE_LEGACY 1 919 # define EVP_PKEY_STATE_PROVIDER 2 920 int evp_pkey_ctx_state(const EVP_PKEY_CTX *ctx); 921 922 /* These two must ONLY be called for provider side operations */ 923 int evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX *ctx, 924 int keytype, int optype, 925 int cmd, int p1, void *p2); 926 int evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX *ctx, 927 const char *name, const char *value); 928 929 /* These two must ONLY be called for legacy operations */ 930 int evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params); 931 int evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX *ctx, OSSL_PARAM *params); 932 933 /* This must ONLY be called for legacy EVP_PKEYs */ 934 int evp_pkey_get_params_to_ctrl(const EVP_PKEY *pkey, OSSL_PARAM *params); 935 936 /* Same as the public get0 functions but are not const */ 937 # ifndef OPENSSL_NO_DEPRECATED_3_0 938 DH *evp_pkey_get0_DH_int(const EVP_PKEY *pkey); 939 EC_KEY *evp_pkey_get0_EC_KEY_int(const EVP_PKEY *pkey); 940 RSA *evp_pkey_get0_RSA_int(const EVP_PKEY *pkey); 941 # endif 942 943 /* Get internal identification number routines */ 944 int evp_asym_cipher_get_number(const EVP_ASYM_CIPHER *cipher); 945 int evp_cipher_get_number(const EVP_CIPHER *cipher); 946 int evp_kdf_get_number(const EVP_KDF *kdf); 947 int evp_kem_get_number(const EVP_KEM *wrap); 948 int evp_keyexch_get_number(const EVP_KEYEXCH *keyexch); 949 int evp_keymgmt_get_number(const EVP_KEYMGMT *keymgmt); 950 int evp_keymgmt_get_legacy_alg(const EVP_KEYMGMT *keymgmt); 951 int evp_mac_get_number(const EVP_MAC *mac); 952 int evp_md_get_number(const EVP_MD *md); 953 int evp_rand_get_number(const EVP_RAND *rand); 954 int evp_rand_can_seed(EVP_RAND_CTX *ctx); 955 size_t evp_rand_get_seed(EVP_RAND_CTX *ctx, 956 unsigned char **buffer, 957 int entropy, size_t min_len, size_t max_len, 958 int prediction_resistance, 959 const unsigned char *adin, size_t adin_len); 960 void evp_rand_clear_seed(EVP_RAND_CTX *ctx, 961 unsigned char *buffer, size_t b_len); 962 int evp_signature_get_number(const EVP_SIGNATURE *signature); 963 964 int evp_pkey_decrypt_alloc(EVP_PKEY_CTX *ctx, unsigned char **outp, 965 size_t *outlenp, size_t expected_outlen, 966 const unsigned char *in, size_t inlen); 967 968 int ossl_md2hmacnid(int mdnid); 969 int ossl_hmac2mdnid(int hmac_nid); 970 971 #endif /* OSSL_CRYPTO_EVP_H */ 972
