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