X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=crypto%2Fevp%2Fevp_enc.c;h=74d4afdac4c79833d4f5894f0da1e7fe33227211;hp=3f0e5a7e4a7b6cdd0c25bcf74c509f71a8583d07;hb=HEAD;hpb=6a36f209bcfbc958e30d544c3031ed002dbfe582 diff --git a/crypto/evp/evp_enc.c b/crypto/evp/evp_enc.c index 3f0e5a7e4a..c289b2f7b0 100644 --- a/crypto/evp/evp_enc.c +++ b/crypto/evp/evp_enc.c @@ -1,5 +1,5 @@ /* - * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. + * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy @@ -7,20 +7,29 @@ * https://www.openssl.org/source/license.html */ +/* We need to use some engine deprecated APIs */ +#define OPENSSL_SUPPRESS_DEPRECATED + #include +#include #include -#include "internal/cryptlib.h" #include #include #include -#include -#include +#ifndef FIPS_MODULE +# include +#endif #include #include -#include "crypto/evp.h" +#include "internal/cryptlib.h" #include "internal/provider.h" +#include "internal/core.h" +#include "internal/safe_math.h" +#include "crypto/evp.h" #include "evp_local.h" +OSSL_SAFE_MATH_SIGNED(int, int) + int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx) { if (ctx == NULL) @@ -29,18 +38,19 @@ int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx) if (ctx->cipher == NULL || ctx->cipher->prov == NULL) goto legacy; - if (ctx->provctx != NULL) { + if (ctx->algctx != NULL) { if (ctx->cipher->freectx != NULL) - ctx->cipher->freectx(ctx->provctx); - ctx->provctx = NULL; + ctx->cipher->freectx(ctx->algctx); + ctx->algctx = NULL; } if (ctx->fetched_cipher != NULL) EVP_CIPHER_free(ctx->fetched_cipher); memset(ctx, 0, sizeof(*ctx)); + ctx->iv_len = -1; return 1; - /* TODO(3.0): Remove legacy code below */ + /* Remove legacy code below when legacy support is removed. */ legacy: if (ctx->cipher != NULL) { @@ -51,40 +61,44 @@ int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx) OPENSSL_cleanse(ctx->cipher_data, ctx->cipher->ctx_size); } OPENSSL_free(ctx->cipher_data); -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) ENGINE_finish(ctx->engine); #endif memset(ctx, 0, sizeof(*ctx)); + ctx->iv_len = -1; return 1; } EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) { - return OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX)); + EVP_CIPHER_CTX *ctx; + + ctx = OPENSSL_zalloc(sizeof(EVP_CIPHER_CTX)); + if (ctx == NULL) + return NULL; + + ctx->iv_len = -1; + return ctx; } void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) { + if (ctx == NULL) + return; EVP_CIPHER_CTX_reset(ctx); OPENSSL_free(ctx); } -int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, - const unsigned char *key, const unsigned char *iv, int enc) +static int evp_cipher_init_internal(EVP_CIPHER_CTX *ctx, + const EVP_CIPHER *cipher, + ENGINE *impl, const unsigned char *key, + const unsigned char *iv, int enc, + const OSSL_PARAM params[]) { - if (cipher != NULL) - EVP_CIPHER_CTX_reset(ctx); - return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc); -} - -int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, - ENGINE *impl, const unsigned char *key, - const unsigned char *iv, int enc) -{ -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) + int n; +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) ENGINE *tmpimpl = NULL; #endif - const EVP_CIPHER *tmpcipher; /* * enc == 1 means we are encrypting. @@ -100,13 +114,13 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, } if (cipher == NULL && ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET); + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } - /* TODO(3.0): Legacy work around code below. Remove this */ + /* Code below to be removed when legacy support is dropped. */ -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) /* * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so * this context may already have an ENGINE! Try to avoid releasing the @@ -127,176 +141,31 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, * If there are engines involved then we should use legacy handling for now. */ if (ctx->engine != NULL -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) || tmpimpl != NULL #endif - || impl != NULL) { + || impl != NULL + || (cipher != NULL && cipher->origin == EVP_ORIG_METH) + || (cipher == NULL && ctx->cipher != NULL + && ctx->cipher->origin == EVP_ORIG_METH)) { if (ctx->cipher == ctx->fetched_cipher) ctx->cipher = NULL; EVP_CIPHER_free(ctx->fetched_cipher); ctx->fetched_cipher = NULL; goto legacy; } - - tmpcipher = (cipher == NULL) ? ctx->cipher : cipher; - - if (tmpcipher->prov == NULL) { - switch(tmpcipher->nid) { - case NID_aes_256_ecb: - case NID_aes_192_ecb: - case NID_aes_128_ecb: - case NID_aes_256_cbc: - case NID_aes_192_cbc: - case NID_aes_128_cbc: - case NID_aes_256_ofb128: - case NID_aes_192_ofb128: - case NID_aes_128_ofb128: - case NID_aes_256_cfb128: - case NID_aes_192_cfb128: - case NID_aes_128_cfb128: - case NID_aes_256_cfb1: - case NID_aes_192_cfb1: - case NID_aes_128_cfb1: - case NID_aes_256_cfb8: - case NID_aes_192_cfb8: - case NID_aes_128_cfb8: - case NID_aes_256_ctr: - case NID_aes_192_ctr: - case NID_aes_128_ctr: - case NID_aes_128_xts: - case NID_aes_256_xts: - case NID_aes_256_ocb: - case NID_aes_192_ocb: - case NID_aes_128_ocb: - case NID_aes_256_gcm: - case NID_aes_192_gcm: - case NID_aes_128_gcm: - case NID_id_aes256_wrap: - case NID_id_aes256_wrap_pad: - case NID_id_aes192_wrap: - case NID_id_aes192_wrap_pad: - case NID_id_aes128_wrap: - case NID_id_aes128_wrap_pad: - case NID_aria_256_gcm: - case NID_aria_192_gcm: - case NID_aria_128_gcm: - case NID_aes_256_ccm: - case NID_aes_192_ccm: - case NID_aes_128_ccm: - case NID_aria_256_ccm: - case NID_aria_192_ccm: - case NID_aria_128_ccm: - case NID_aria_256_ecb: - case NID_aria_192_ecb: - case NID_aria_128_ecb: - case NID_aria_256_cbc: - case NID_aria_192_cbc: - case NID_aria_128_cbc: - case NID_aria_256_ofb128: - case NID_aria_192_ofb128: - case NID_aria_128_ofb128: - case NID_aria_256_cfb128: - case NID_aria_192_cfb128: - case NID_aria_128_cfb128: - case NID_aria_256_cfb1: - case NID_aria_192_cfb1: - case NID_aria_128_cfb1: - case NID_aria_256_cfb8: - case NID_aria_192_cfb8: - case NID_aria_128_cfb8: - case NID_aria_256_ctr: - case NID_aria_192_ctr: - case NID_aria_128_ctr: - case NID_camellia_256_ecb: - case NID_camellia_192_ecb: - case NID_camellia_128_ecb: - case NID_camellia_256_cbc: - case NID_camellia_192_cbc: - case NID_camellia_128_cbc: - case NID_camellia_256_ofb128: - case NID_camellia_192_ofb128: - case NID_camellia_128_ofb128: - case NID_camellia_256_cfb128: - case NID_camellia_192_cfb128: - case NID_camellia_128_cfb128: - case NID_camellia_256_cfb1: - case NID_camellia_192_cfb1: - case NID_camellia_128_cfb1: - case NID_camellia_256_cfb8: - case NID_camellia_192_cfb8: - case NID_camellia_128_cfb8: - case NID_camellia_256_ctr: - case NID_camellia_192_ctr: - case NID_camellia_128_ctr: - case NID_des_ede3_cbc: - case NID_des_ede3_ecb: - case NID_des_ede3_ofb64: - case NID_des_ede3_cfb64: - case NID_des_ede3_cfb8: - case NID_des_ede3_cfb1: - case NID_des_ede_cbc: - case NID_des_ede_ecb: - case NID_des_ede_ofb64: - case NID_des_ede_cfb64: - case NID_desx_cbc: - case NID_des_cbc: - case NID_des_ecb: - case NID_des_cfb1: - case NID_des_cfb8: - case NID_des_cfb64: - case NID_des_ofb64: - case NID_id_smime_alg_CMS3DESwrap: - case NID_bf_cbc: - case NID_bf_ecb: - case NID_bf_cfb64: - case NID_bf_ofb64: - case NID_idea_cbc: - case NID_idea_ecb: - case NID_idea_cfb64: - case NID_idea_ofb64: - case NID_cast5_cbc: - case NID_cast5_ecb: - case NID_cast5_cfb64: - case NID_cast5_ofb64: - case NID_seed_cbc: - case NID_seed_ecb: - case NID_seed_cfb128: - case NID_seed_ofb128: - case NID_sm4_cbc: - case NID_sm4_ecb: - case NID_sm4_ctr: - case NID_sm4_cfb128: - case NID_sm4_ofb128: - case NID_rc4: - case NID_rc4_40: - case NID_rc5_cbc: - case NID_rc5_ecb: - case NID_rc5_cfb64: - case NID_rc5_ofb64: - case NID_rc2_cbc: - case NID_rc2_40_cbc: - case NID_rc2_64_cbc: - case NID_rc2_cfb64: - case NID_rc2_ofb64: - case NID_chacha20: - case NID_chacha20_poly1305: - break; - default: - goto legacy; - } - } - /* * Ensure a context left lying around from last time is cleared * (legacy code) */ if (cipher != NULL && ctx->cipher != NULL) { + if (ctx->cipher->cleanup != NULL && !ctx->cipher->cleanup(ctx)) + return 0; OPENSSL_clear_free(ctx->cipher_data, ctx->cipher->ctx_size); ctx->cipher_data = NULL; } - - /* TODO(3.0): Start of non-legacy code below */ + /* Start of non-legacy code below */ /* Ensure a context left lying around from last time is cleared */ if (cipher != NULL && ctx->cipher != NULL) { @@ -312,29 +181,45 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, cipher = ctx->cipher; if (cipher->prov == NULL) { -#ifdef FIPS_MODE - /* We only do explict fetches inside the FIPS module */ - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); +#ifdef FIPS_MODULE + /* We only do explicit fetches inside the FIPS module */ + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; #else EVP_CIPHER *provciph = - EVP_CIPHER_fetch(NULL, OBJ_nid2sn(cipher->nid), ""); + EVP_CIPHER_fetch(NULL, + cipher->nid == NID_undef ? "NULL" + : OBJ_nid2sn(cipher->nid), + ""); - if (provciph == NULL) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + if (provciph == NULL) return 0; - } cipher = provciph; EVP_CIPHER_free(ctx->fetched_cipher); ctx->fetched_cipher = provciph; #endif } + if (!ossl_assert(cipher->prov != NULL)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); + return 0; + } + + if (cipher != ctx->fetched_cipher) { + if (!EVP_CIPHER_up_ref((EVP_CIPHER *)cipher)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); + return 0; + } + EVP_CIPHER_free(ctx->fetched_cipher); + /* Coverity false positive, the reference counting is confusing it */ + /* coverity[use_after_free] */ + ctx->fetched_cipher = (EVP_CIPHER *)cipher; + } ctx->cipher = cipher; - if (ctx->provctx == NULL) { - ctx->provctx = ctx->cipher->newctx(ossl_provider_ctx(cipher->prov)); - if (ctx->provctx == NULL) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + if (ctx->algctx == NULL) { + ctx->algctx = ctx->cipher->newctx(ossl_provider_ctx(cipher->prov)); + if (ctx->algctx == NULL) { + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } } @@ -348,35 +233,73 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, return 0; } +#ifndef FIPS_MODULE + /* + * Fix for CVE-2023-5363 + * Passing in a size as part of the init call takes effect late + * so, force such to occur before the initialisation. + * + * The FIPS provider's internal library context is used in a manner + * such that this is not an issue. + */ + if (params != NULL) { + OSSL_PARAM param_lens[3] = { OSSL_PARAM_END, OSSL_PARAM_END, + OSSL_PARAM_END }; + OSSL_PARAM *q = param_lens; + const OSSL_PARAM *p; + + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN); + if (p != NULL) + memcpy(q++, p, sizeof(*q)); + + /* + * Note that OSSL_CIPHER_PARAM_AEAD_IVLEN is a synonym for + * OSSL_CIPHER_PARAM_IVLEN so both are covered here. + */ + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_IVLEN); + if (p != NULL) + memcpy(q++, p, sizeof(*q)); + + if (q != param_lens) { + if (!EVP_CIPHER_CTX_set_params(ctx, param_lens)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_LENGTH); + return 0; + } + } + } +#endif + if (enc) { if (ctx->cipher->einit == NULL) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } - return ctx->cipher->einit(ctx->provctx, + return ctx->cipher->einit(ctx->algctx, key, key == NULL ? 0 - : EVP_CIPHER_CTX_key_length(ctx), + : EVP_CIPHER_CTX_get_key_length(ctx), iv, iv == NULL ? 0 - : EVP_CIPHER_CTX_iv_length(ctx)); + : EVP_CIPHER_CTX_get_iv_length(ctx), + params); } if (ctx->cipher->dinit == NULL) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } - return ctx->cipher->dinit(ctx->provctx, + return ctx->cipher->dinit(ctx->algctx, key, key == NULL ? 0 - : EVP_CIPHER_CTX_key_length(ctx), + : EVP_CIPHER_CTX_get_key_length(ctx), iv, iv == NULL ? 0 - : EVP_CIPHER_CTX_iv_length(ctx)); + : EVP_CIPHER_CTX_get_iv_length(ctx), + params); - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: if (cipher != NULL) { @@ -392,10 +315,10 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ctx->encrypt = enc; ctx->flags = flags; } -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) if (impl != NULL) { if (!ENGINE_init(impl)) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } } else { @@ -411,7 +334,7 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, * is that we should at least be able to avoid using US * misspellings of "initialisation"? */ - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } /* We'll use the ENGINE's private cipher definition */ @@ -431,7 +354,6 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size); if (ctx->cipher_data == NULL) { ctx->cipher = NULL; - EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE); return 0; } } else { @@ -441,14 +363,14 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, /* Preserve wrap enable flag, zero everything else */ ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW; if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) { - if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) { + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL) <= 0) { ctx->cipher = NULL; - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } } } -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) skip_to_init: #endif if (ctx->cipher == NULL) @@ -460,13 +382,14 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, || ctx->cipher->block_size == 16); if (!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW) - && EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE) { - EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED); + && EVP_CIPHER_CTX_get_mode(ctx) == EVP_CIPH_WRAP_MODE) { + ERR_raise(ERR_LIB_EVP, EVP_R_WRAP_MODE_NOT_ALLOWED); return 0; } - if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_CUSTOM_IV)) { - switch (EVP_CIPHER_CTX_mode(ctx)) { + if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ctx)) + & EVP_CIPH_CUSTOM_IV) == 0) { + switch (EVP_CIPHER_CTX_get_mode(ctx)) { case EVP_CIPH_STREAM_CIPHER: case EVP_CIPH_ECB_MODE: @@ -479,19 +402,27 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, /* fall-through */ case EVP_CIPH_CBC_MODE: - - OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <= - (int)sizeof(ctx->iv)); - if (iv) - memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx)); - memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx)); + n = EVP_CIPHER_CTX_get_iv_length(ctx); + if (n < 0 || n > (int)sizeof(ctx->iv)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_IV_LENGTH); + return 0; + } + if (iv != NULL) + memcpy(ctx->oiv, iv, n); + memcpy(ctx->iv, ctx->oiv, n); break; case EVP_CIPH_CTR_MODE: ctx->num = 0; /* Don't reuse IV for CTR mode */ - if (iv) - memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx)); + if (iv != NULL) { + n = EVP_CIPHER_CTX_get_iv_length(ctx); + if (n <= 0 || n > (int)sizeof(ctx->iv)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_IV_LENGTH); + return 0; + } + memcpy(ctx->iv, iv, n); + } break; default: @@ -499,7 +430,7 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, } } - if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { + if (key != NULL || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { if (!ctx->cipher->init(ctx, key, iv, enc)) return 0; } @@ -509,6 +440,28 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, return 1; } +int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + const unsigned char *key, const unsigned char *iv, + int enc, const OSSL_PARAM params[]) +{ + return evp_cipher_init_internal(ctx, cipher, NULL, key, iv, enc, params); +} + +int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + const unsigned char *key, const unsigned char *iv, int enc) +{ + if (cipher != NULL) + EVP_CIPHER_CTX_reset(ctx); + return evp_cipher_init_internal(ctx, cipher, NULL, key, iv, enc, NULL); +} + +int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + ENGINE *impl, const unsigned char *key, + const unsigned char *iv, int enc) +{ + return evp_cipher_init_internal(ctx, cipher, impl, key, iv, enc, NULL); +} + int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, const unsigned char *in, int inl) { @@ -547,6 +500,13 @@ int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1); } +int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + const unsigned char *key, const unsigned char *iv, + const OSSL_PARAM params[]) +{ + return EVP_CipherInit_ex2(ctx, cipher, key, iv, 1, params); +} + int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, const unsigned char *key, const unsigned char *iv) { @@ -560,6 +520,13 @@ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0); } +int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + const unsigned char *key, const unsigned char *iv, + const OSSL_PARAM params[]) +{ + return EVP_CipherInit_ex2(ctx, cipher, key, iv, 0, params); +} + /* * According to the letter of standard difference between pointers * is specified to be valid only within same object. This makes @@ -583,7 +550,7 @@ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, # define PTRDIFF_T size_t #endif -int is_partially_overlapping(const void *ptr1, const void *ptr2, int len) +int ossl_is_partially_overlapping(const void *ptr1, const void *ptr2, int len) { PTRDIFF_T diff = (PTRDIFF_T)ptr1-(PTRDIFF_T)ptr2; /* @@ -604,14 +571,14 @@ static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx, int i, j, bl, cmpl = inl; if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) - cmpl = (cmpl + 7) / 8; + cmpl = safe_div_round_up_int(cmpl, 8, NULL); bl = ctx->cipher->block_size; if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { /* If block size > 1 then the cipher will have to do this check */ - if (bl == 1 && is_partially_overlapping(out, in, cmpl)) { - EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); + if (bl == 1 && ossl_is_partially_overlapping(out, in, cmpl)) { + ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING); return 0; } @@ -627,8 +594,8 @@ static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx, *outl = 0; return inl == 0; } - if (is_partially_overlapping(out + ctx->buf_len, in, cmpl)) { - EVPerr(EVP_F_EVP_ENCRYPTDECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); + if (ossl_is_partially_overlapping(out + ctx->buf_len, in, cmpl)) { + ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING); return 0; } @@ -651,6 +618,18 @@ static int evp_EncryptDecryptUpdate(EVP_CIPHER_CTX *ctx, return 1; } else { j = bl - i; + + /* + * Once we've processed the first j bytes from in, the amount of + * data left that is a multiple of the block length is: + * (inl - j) & ~(bl - 1) + * We must ensure that this amount of data, plus the one block that + * we process from ctx->buf does not exceed INT_MAX + */ + if (((inl - j) & ~(bl - 1)) > INT_MAX - bl) { + ERR_raise(ERR_LIB_EVP, EVP_R_OUTPUT_WOULD_OVERFLOW); + return 0; + } memcpy(&(ctx->buf[i]), in, j); inl -= j; in += j; @@ -680,36 +659,44 @@ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, const unsigned char *in, int inl) { int ret; - size_t soutl; + size_t soutl, inl_ = (size_t)inl; int blocksize; + if (ossl_likely(outl != NULL)) { + *outl = 0; + } else { + ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + /* Prevent accidental use of decryption context when encrypting */ - if (!ctx->encrypt) { - EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_INVALID_OPERATION); + if (ossl_unlikely(!ctx->encrypt)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION); return 0; } - if (ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_NO_CIPHER_SET); + if (ossl_unlikely(ctx->cipher == NULL)) { + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } - if (ctx->cipher->prov == NULL) + if (ossl_unlikely(ctx->cipher->prov == NULL)) goto legacy; - blocksize = EVP_CIPHER_CTX_block_size(ctx); + blocksize = ctx->cipher->block_size; - if (ctx->cipher->cupdate == NULL || blocksize < 1) { - EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR); + if (ossl_unlikely(ctx->cipher->cupdate == NULL || blocksize < 1)) { + ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR); return 0; } - ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl, - inl + (blocksize == 1 ? 0 : blocksize), in, - (size_t)inl); - if (ret) { + ret = ctx->cipher->cupdate(ctx->algctx, out, &soutl, + inl_ + (size_t)(blocksize == 1 ? 0 : blocksize), + in, inl_); + + if (ossl_likely(ret)) { if (soutl > INT_MAX) { - EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_UPDATE_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR); return 0; } *outl = soutl; @@ -717,7 +704,7 @@ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, return ret; - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: return evp_EncryptDecryptUpdate(ctx, out, outl, in, inl); @@ -737,32 +724,39 @@ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) size_t soutl; int blocksize; + if (outl != NULL) { + *outl = 0; + } else { + ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + /* Prevent accidental use of decryption context when encrypting */ if (!ctx->encrypt) { - EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_INVALID_OPERATION); + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION); return 0; } if (ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_NO_CIPHER_SET); + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } if (ctx->cipher->prov == NULL) goto legacy; - blocksize = EVP_CIPHER_CTX_block_size(ctx); + blocksize = EVP_CIPHER_CTX_get_block_size(ctx); if (blocksize < 1 || ctx->cipher->cfinal == NULL) { - EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR); return 0; } - ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl, + ret = ctx->cipher->cfinal(ctx->algctx, out, &soutl, blocksize == 1 ? 0 : blocksize); if (ret) { if (soutl > INT_MAX) { - EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_FINAL_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR); return 0; } *outl = soutl; @@ -770,7 +764,7 @@ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) return ret; - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { @@ -791,8 +785,7 @@ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) bl = ctx->buf_len; if (ctx->flags & EVP_CIPH_NO_PADDING) { if (bl) { - EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, - EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); + ERR_raise(ERR_LIB_EVP, EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); return 0; } *outl = 0; @@ -815,35 +808,42 @@ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, { int fix_len, cmpl = inl, ret; unsigned int b; - size_t soutl; + size_t soutl, inl_ = (size_t)inl; int blocksize; + if (ossl_likely(outl != NULL)) { + *outl = 0; + } else { + ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + /* Prevent accidental use of encryption context when decrypting */ - if (ctx->encrypt) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_INVALID_OPERATION); + if (ossl_unlikely(ctx->encrypt)) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION); return 0; } - if (ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_NO_CIPHER_SET); + if (ossl_unlikely(ctx->cipher == NULL)) { + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } - if (ctx->cipher->prov == NULL) + if (ossl_unlikely(ctx->cipher->prov == NULL)) goto legacy; - blocksize = EVP_CIPHER_CTX_block_size(ctx); + blocksize = EVP_CIPHER_CTX_get_block_size(ctx); - if (ctx->cipher->cupdate == NULL || blocksize < 1) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR); + if (ossl_unlikely(ctx->cipher->cupdate == NULL || blocksize < 1)) { + ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR); return 0; } - ret = ctx->cipher->cupdate(ctx->provctx, out, &soutl, - inl + (blocksize == 1 ? 0 : blocksize), in, - (size_t)inl); + ret = ctx->cipher->cupdate(ctx->algctx, out, &soutl, + inl_ + (size_t)(blocksize == 1 ? 0 : blocksize), + in, inl_); - if (ret) { + if (ossl_likely(ret)) { if (soutl > INT_MAX) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_UPDATE_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR); return 0; } *outl = soutl; @@ -851,17 +851,17 @@ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, return ret; - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: b = ctx->cipher->block_size; if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) - cmpl = (cmpl + 7) / 8; + cmpl = safe_div_round_up_int(cmpl, 8, NULL); if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER) { - if (b == 1 && is_partially_overlapping(out, in, cmpl)) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); + if (b == 1 && ossl_is_partially_overlapping(out, in, cmpl)) { + ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING); return 0; } @@ -887,8 +887,21 @@ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, if (ctx->final_used) { /* see comment about PTRDIFF_T comparison above */ if (((PTRDIFF_T)out == (PTRDIFF_T)in) - || is_partially_overlapping(out, in, b)) { - EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_PARTIALLY_OVERLAPPING); + || ossl_is_partially_overlapping(out, in, b)) { + ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING); + return 0; + } + /* + * final_used is only ever set if buf_len is 0. Therefore the maximum + * length output we will ever see from evp_EncryptDecryptUpdate is + * the maximum multiple of the block length that is <= inl, or just: + * inl & ~(b - 1) + * Since final_used has been set then the final output length is: + * (inl & ~(b - 1)) + b + * This must never exceed INT_MAX + */ + if ((inl & ~(b - 1)) > INT_MAX - b) { + ERR_raise(ERR_LIB_EVP, EVP_R_OUTPUT_WOULD_OVERFLOW); return 0; } memcpy(out, ctx->final, b); @@ -932,33 +945,40 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) int ret; int blocksize; + if (outl != NULL) { + *outl = 0; + } else { + ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + /* Prevent accidental use of encryption context when decrypting */ if (ctx->encrypt) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_INVALID_OPERATION); + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION); return 0; } if (ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_NO_CIPHER_SET); + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } if (ctx->cipher->prov == NULL) goto legacy; - blocksize = EVP_CIPHER_CTX_block_size(ctx); + blocksize = EVP_CIPHER_CTX_get_block_size(ctx); if (blocksize < 1 || ctx->cipher->cfinal == NULL) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR); return 0; } - ret = ctx->cipher->cfinal(ctx->provctx, out, &soutl, + ret = ctx->cipher->cfinal(ctx->algctx, out, &soutl, blocksize == 1 ? 0 : blocksize); if (ret) { if (soutl > INT_MAX) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_FINAL_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR); return 0; } *outl = soutl; @@ -966,7 +986,7 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) return ret; - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: *outl = 0; @@ -982,8 +1002,7 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) b = ctx->cipher->block_size; if (ctx->flags & EVP_CIPH_NO_PADDING) { if (ctx->buf_len) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, - EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); + ERR_raise(ERR_LIB_EVP, EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); return 0; } *outl = 0; @@ -991,7 +1010,7 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) } if (b > 1) { if (ctx->buf_len || !ctx->final_used) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_WRONG_FINAL_BLOCK_LENGTH); + ERR_raise(ERR_LIB_EVP, EVP_R_WRONG_FINAL_BLOCK_LENGTH); return 0; } OPENSSL_assert(b <= sizeof(ctx->final)); @@ -1002,12 +1021,12 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) */ n = ctx->final[b - 1]; if (n == 0 || n > (int)b) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); + ERR_raise(ERR_LIB_EVP, EVP_R_BAD_DECRYPT); return 0; } for (i = 0; i < n; i++) { if (ctx->final[--b] != n) { - EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT); + ERR_raise(ERR_LIB_EVP, EVP_R_BAD_DECRYPT); return 0; } } @@ -1022,26 +1041,46 @@ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) { - int ok; - OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END }; - size_t len = keylen; + if (c->cipher->prov != NULL) { + int ok; + OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END }; + size_t len; - params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_KEYLEN, &len); - ok = evp_do_ciph_ctx_setparams(c->cipher, c->provctx, params); + if (EVP_CIPHER_CTX_get_key_length(c) == keylen) + return 1; - if (ok != EVP_CTRL_RET_UNSUPPORTED) - return ok; + /* Check the cipher actually understands this parameter */ + if (OSSL_PARAM_locate_const(EVP_CIPHER_settable_ctx_params(c->cipher), + OSSL_CIPHER_PARAM_KEYLEN) == NULL) { + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY_LENGTH); + return 0; + } + + params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_KEYLEN, &len); + if (!OSSL_PARAM_set_int(params, keylen)) + return 0; + ok = evp_do_ciph_ctx_setparams(c->cipher, c->algctx, params); + if (ok <= 0) + return 0; + c->key_len = keylen; + return 1; + } - /* TODO(3.0) legacy code follows */ + /* Code below to be removed when legacy support is dropped. */ + + /* + * Note there have never been any built-in ciphers that define this flag + * since it was first introduced. + */ if (c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL); - if (EVP_CIPHER_CTX_key_length(c) == keylen) + if (EVP_CIPHER_CTX_get_key_length(c) == keylen) return 1; if ((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) { c->key_len = keylen; return 1; } - EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH); + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY_LENGTH); return 0; } @@ -1056,8 +1095,10 @@ int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad) else ctx->flags |= EVP_CIPH_NO_PADDING; + if (ctx->cipher != NULL && ctx->cipher->prov == NULL) + return 1; params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_PADDING, &pd); - ok = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params); + ok = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); return ok != 0; } @@ -1068,10 +1109,12 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) int set_params = 1; size_t sz = arg; unsigned int i; - OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END }; + OSSL_PARAM params[4] = { + OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END + }; if (ctx == NULL || ctx->cipher == NULL) { - EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); + ERR_raise(ERR_LIB_EVP, EVP_R_NO_CIPHER_SET); return 0; } @@ -1080,7 +1123,13 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) switch (type) { case EVP_CTRL_SET_KEY_LENGTH: + if (arg < 0) + return 0; + if (ctx->key_len == arg) + /* Skip calling into provider if unchanged. */ + return 1; params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_KEYLEN, &sz); + ctx->key_len = -1; break; case EVP_CTRL_RAND_KEY: /* Used by DES */ set_params = 0; @@ -1089,24 +1138,50 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) ptr, sz); break; + case EVP_CTRL_INIT: + /* + * EVP_CTRL_INIT is purely legacy, no provider counterpart. + * As a matter of fact, this should be dead code, but some caller + * might still do a direct control call with this command, so... + * Legacy methods return 1 except for exceptional circumstances, so + * we do the same here to not be disruptive. + */ + return 1; case EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS: /* Used by DASYNC */ - case EVP_CTRL_INIT: /* TODO(3.0) Purely legacy, no provider counterpart */ default: goto end; - case EVP_CTRL_GET_IV: - set_params = 0; - params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_IV, - ptr, sz); - break; case EVP_CTRL_AEAD_SET_IVLEN: if (arg < 0) return 0; + if (ctx->iv_len == arg) + /* Skip calling into provider if unchanged. */ + return 1; params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_IVLEN, &sz); + ctx->iv_len = -1; break; - case EVP_CTRL_GCM_SET_IV_FIXED: - params[0] = - OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, - ptr, sz); + case EVP_CTRL_CCM_SET_L: + if (arg < 2 || arg > 8) + return 0; + sz = 15 - arg; + params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_IVLEN, &sz); + ctx->iv_len = -1; + break; + case EVP_CTRL_AEAD_SET_IV_FIXED: + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, ptr, sz); + break; + case EVP_CTRL_GCM_IV_GEN: + set_params = 0; + if (arg < 0) + sz = 0; /* special case that uses the iv length */ + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, ptr, sz); + break; + case EVP_CTRL_GCM_SET_IV_INV: + if (arg < 0) + return 0; + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, ptr, sz); break; case EVP_CTRL_GET_RC5_ROUNDS: set_params = 0; /* Fall thru */ @@ -1116,28 +1191,29 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) i = (unsigned int)arg; params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_ROUNDS, &i); break; + case EVP_CTRL_SET_SPEED: + if (arg < 0) + return 0; + i = (unsigned int)arg; + params[0] = OSSL_PARAM_construct_uint(OSSL_CIPHER_PARAM_SPEED, &i); + break; case EVP_CTRL_AEAD_GET_TAG: set_params = 0; /* Fall thru */ case EVP_CTRL_AEAD_SET_TAG: params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, ptr, sz); break; - case EVP_CTRL_AEAD_SET_MAC_KEY: - params[0] = - OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_MAC_KEY, - ptr, sz); - break; case EVP_CTRL_AEAD_TLS1_AAD: - /* This one does a set and a get - since it returns a padding size */ + /* This one does a set and a get - since it returns a size */ params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, ptr, sz); - ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params); + ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); if (ret <= 0) goto end; params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, &sz); - ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->provctx, params); + ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params); if (ret <= 0) goto end; return sz; @@ -1148,18 +1224,88 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, &sz); break; #endif /* OPENSSL_NO_RC2 */ +#if !defined(OPENSSL_NO_MULTIBLOCK) + case EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE: + params[0] = OSSL_PARAM_construct_size_t( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT, &sz); + ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return 0; + + params[0] = OSSL_PARAM_construct_size_t( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, &sz); + params[1] = OSSL_PARAM_construct_end(); + ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return 0; + return sz; + case EVP_CTRL_TLS1_1_MULTIBLOCK_AAD: { + EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p = + (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr; + + if (arg < (int)sizeof(EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM)) + return 0; + + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD, (void*)p->inp, p->len); + params[1] = OSSL_PARAM_construct_uint( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave); + ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return ret; + /* Retrieve the return values changed by the set */ + params[0] = OSSL_PARAM_construct_size_t( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN, &sz); + params[1] = OSSL_PARAM_construct_uint( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave); + params[2] = OSSL_PARAM_construct_end(); + ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return 0; + return sz; + } + case EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT: { + EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p = + (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr; + + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC, p->out, p->len); + + params[1] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN, (void*)p->inp, + p->len); + params[2] = OSSL_PARAM_construct_uint( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave); + ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return ret; + params[0] = OSSL_PARAM_construct_size_t( + OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, &sz); + params[1] = OSSL_PARAM_construct_end(); + ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params); + if (ret <= 0) + return 0; + return sz; + } +#endif /* OPENSSL_NO_MULTIBLOCK */ + case EVP_CTRL_AEAD_SET_MAC_KEY: + if (arg < 0) + return -1; + params[0] = OSSL_PARAM_construct_octet_string( + OSSL_CIPHER_PARAM_AEAD_MAC_KEY, ptr, sz); + break; } if (set_params) - ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params); + ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->algctx, params); else - ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->provctx, params); + ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params); goto end; -/* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: if (ctx->cipher->ctrl == NULL) { - EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); + ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_NOT_IMPLEMENTED); return 0; } @@ -1167,8 +1313,7 @@ legacy: end: if (ret == EVP_CTRL_RET_UNSUPPORTED) { - EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, - EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); + ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); return 0; } return ret; @@ -1183,62 +1328,137 @@ int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[]) int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[]) { - if (ctx->cipher != NULL && ctx->cipher->set_ctx_params != NULL) - return ctx->cipher->set_ctx_params(ctx->provctx, params); - return 0; + int r = 0; + const OSSL_PARAM *p; + + if (ctx->cipher != NULL && ctx->cipher->set_ctx_params != NULL) { + r = ctx->cipher->set_ctx_params(ctx->algctx, params); + if (r > 0) { + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN); + if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->key_len)) { + r = 0; + ctx->key_len = -1; + } + } + if (r > 0) { + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_IVLEN); + if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->iv_len)) { + r = 0; + ctx->iv_len = -1; + } + } + } + return r; } int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[]) { if (ctx->cipher != NULL && ctx->cipher->get_ctx_params != NULL) - return ctx->cipher->get_ctx_params(ctx->provctx, params); + return ctx->cipher->get_ctx_params(ctx->algctx, params); return 0; } const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher) { if (cipher != NULL && cipher->gettable_params != NULL) - return cipher->gettable_params(); + return cipher->gettable_params( + ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher))); return NULL; } const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher) { - if (cipher != NULL && cipher->settable_ctx_params != NULL) - return cipher->settable_ctx_params(); + void *provctx; + + if (cipher != NULL && cipher->settable_ctx_params != NULL) { + provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher)); + return cipher->settable_ctx_params(NULL, provctx); + } return NULL; } const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher) { - if (cipher != NULL && cipher->gettable_ctx_params != NULL) - return cipher->gettable_ctx_params(); + void *provctx; + + if (cipher != NULL && cipher->gettable_ctx_params != NULL) { + provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cipher)); + return cipher->gettable_ctx_params(NULL, provctx); + } + return NULL; +} + +const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *cctx) +{ + void *alg; + + if (cctx != NULL && cctx->cipher->settable_ctx_params != NULL) { + alg = ossl_provider_ctx(EVP_CIPHER_get0_provider(cctx->cipher)); + return cctx->cipher->settable_ctx_params(cctx->algctx, alg); + } return NULL; } +const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *cctx) +{ + void *provctx; + + if (cctx != NULL && cctx->cipher->gettable_ctx_params != NULL) { + provctx = ossl_provider_ctx(EVP_CIPHER_get0_provider(cctx->cipher)); + return cctx->cipher->gettable_ctx_params(cctx->algctx, provctx); + } + return NULL; +} + +#ifndef FIPS_MODULE +static OSSL_LIB_CTX *EVP_CIPHER_CTX_get_libctx(EVP_CIPHER_CTX *ctx) +{ + const EVP_CIPHER *cipher = ctx->cipher; + const OSSL_PROVIDER *prov; + + if (cipher == NULL) + return NULL; + + prov = EVP_CIPHER_get0_provider(cipher); + return ossl_provider_libctx(prov); +} +#endif + int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key) { if (ctx->cipher->flags & EVP_CIPH_RAND_KEY) return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key); -#ifdef FIPS_MODE +#ifdef FIPS_MODULE return 0; #else { int kl; + OSSL_LIB_CTX *libctx = EVP_CIPHER_CTX_get_libctx(ctx); - kl = EVP_CIPHER_CTX_key_length(ctx); - if (kl <= 0 || RAND_priv_bytes(key, kl) <= 0) + kl = EVP_CIPHER_CTX_get_key_length(ctx); + if (kl <= 0 || RAND_priv_bytes_ex(libctx, key, kl, 0) <= 0) return 0; return 1; } -#endif /* FIPS_MODE */ +#endif /* FIPS_MODULE */ +} + +EVP_CIPHER_CTX *EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX *in) +{ + EVP_CIPHER_CTX *out = EVP_CIPHER_CTX_new(); + + if (out != NULL && !EVP_CIPHER_CTX_copy(out, in)) { + EVP_CIPHER_CTX_free(out); + out = NULL; + } + return out; } int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) { if ((in == NULL) || (in->cipher == NULL)) { - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED); + ERR_raise(ERR_LIB_EVP, EVP_R_INPUT_NOT_INITIALIZED); return 0; } @@ -1246,35 +1466,35 @@ int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) goto legacy; if (in->cipher->dupctx == NULL) { - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX); + ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX); return 0; } EVP_CIPHER_CTX_reset(out); *out = *in; - out->provctx = NULL; + out->algctx = NULL; if (in->fetched_cipher != NULL && !EVP_CIPHER_up_ref(in->fetched_cipher)) { out->fetched_cipher = NULL; return 0; } - out->provctx = in->cipher->dupctx(in->provctx); - if (out->provctx == NULL) { - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_NOT_ABLE_TO_COPY_CTX); + out->algctx = in->cipher->dupctx(in->algctx); + if (out->algctx == NULL) { + ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX); return 0; } return 1; - /* TODO(3.0): Remove legacy code below */ + /* Code below to be removed when legacy support is dropped. */ legacy: -#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODE) +#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) /* Make sure it's safe to copy a cipher context using an ENGINE */ if (in->engine && !ENGINE_init(in->engine)) { - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB); + ERR_raise(ERR_LIB_EVP, ERR_R_ENGINE_LIB); return 0; } #endif @@ -1286,7 +1506,6 @@ int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size); if (out->cipher_data == NULL) { out->cipher = NULL; - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE); return 0; } memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size); @@ -1295,7 +1514,7 @@ int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in) if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY) if (!in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out)) { out->cipher = NULL; - EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INITIALIZATION_ERROR); + ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); return 0; } return 1; @@ -1305,13 +1524,9 @@ EVP_CIPHER *evp_cipher_new(void) { EVP_CIPHER *cipher = OPENSSL_zalloc(sizeof(EVP_CIPHER)); - if (cipher != NULL) { - cipher->lock = CRYPTO_THREAD_lock_new(); - if (cipher->lock == NULL) { - OPENSSL_free(cipher); - return NULL; - } - cipher->refcnt = 1; + if (cipher != NULL && !CRYPTO_NEW_REF(&cipher->refcnt, 1)) { + OPENSSL_free(cipher); + return NULL; } return cipher; } @@ -1321,18 +1536,24 @@ EVP_CIPHER *evp_cipher_new(void) * provider based, we know that none of its code depends on legacy * NIDs or any functionality that use them. */ -#ifndef FIPS_MODE -/* TODO(3.x) get rid of the need for legacy NIDs */ +#ifndef FIPS_MODULE +/* After removal of legacy support get rid of the need for legacy NIDs */ static void set_legacy_nid(const char *name, void *vlegacy_nid) { int nid; int *legacy_nid = vlegacy_nid; + /* + * We use lowest level function to get the associated method, because + * higher level functions such as EVP_get_cipherbyname() have changed + * to look at providers too. + */ + const void *legacy_method = OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH); if (*legacy_nid == -1) /* We found a clash already */ return; - if ((nid = OBJ_sn2nid(name)) == NID_undef - && (nid = OBJ_ln2nid(name)) == NID_undef) + if (legacy_method == NULL) return; + nid = EVP_CIPHER_get_nid(legacy_method); if (*legacy_nid != NID_undef && *legacy_nid != nid) { *legacy_nid = -1; return; @@ -1341,24 +1562,23 @@ static void set_legacy_nid(const char *name, void *vlegacy_nid) } #endif -static void *evp_cipher_from_dispatch(const int name_id, - const OSSL_DISPATCH *fns, - OSSL_PROVIDER *prov, - void *unused) +static void *evp_cipher_from_algorithm(const int name_id, + const OSSL_ALGORITHM *algodef, + OSSL_PROVIDER *prov) { + const OSSL_DISPATCH *fns = algodef->implementation; EVP_CIPHER *cipher = NULL; int fnciphcnt = 0, fnctxcnt = 0; if ((cipher = evp_cipher_new()) == NULL) { - EVPerr(0, ERR_R_MALLOC_FAILURE); + ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB); return NULL; } -#ifndef FIPS_MODE - /* TODO(3.x) get rid of the need for legacy NIDs */ +#ifndef FIPS_MODULE cipher->nid = NID_undef; - evp_doall_names(prov, name_id, set_legacy_nid, &cipher->nid); - if (cipher->nid == -1) { + if (!evp_names_do_all(prov, name_id, set_legacy_nid, &cipher->nid) + || cipher->nid == -1) { ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR); EVP_CIPHER_free(cipher); return NULL; @@ -1366,86 +1586,91 @@ static void *evp_cipher_from_dispatch(const int name_id, #endif cipher->name_id = name_id; + if ((cipher->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) { + EVP_CIPHER_free(cipher); + return NULL; + } + cipher->description = algodef->algorithm_description; for (; fns->function_id != 0; fns++) { switch (fns->function_id) { case OSSL_FUNC_CIPHER_NEWCTX: if (cipher->newctx != NULL) break; - cipher->newctx = OSSL_get_OP_cipher_newctx(fns); + cipher->newctx = OSSL_FUNC_cipher_newctx(fns); fnctxcnt++; break; case OSSL_FUNC_CIPHER_ENCRYPT_INIT: if (cipher->einit != NULL) break; - cipher->einit = OSSL_get_OP_cipher_encrypt_init(fns); + cipher->einit = OSSL_FUNC_cipher_encrypt_init(fns); fnciphcnt++; break; case OSSL_FUNC_CIPHER_DECRYPT_INIT: if (cipher->dinit != NULL) break; - cipher->dinit = OSSL_get_OP_cipher_decrypt_init(fns); + cipher->dinit = OSSL_FUNC_cipher_decrypt_init(fns); fnciphcnt++; break; case OSSL_FUNC_CIPHER_UPDATE: if (cipher->cupdate != NULL) break; - cipher->cupdate = OSSL_get_OP_cipher_update(fns); + cipher->cupdate = OSSL_FUNC_cipher_update(fns); fnciphcnt++; break; case OSSL_FUNC_CIPHER_FINAL: if (cipher->cfinal != NULL) break; - cipher->cfinal = OSSL_get_OP_cipher_final(fns); + cipher->cfinal = OSSL_FUNC_cipher_final(fns); fnciphcnt++; break; case OSSL_FUNC_CIPHER_CIPHER: if (cipher->ccipher != NULL) break; - cipher->ccipher = OSSL_get_OP_cipher_cipher(fns); + cipher->ccipher = OSSL_FUNC_cipher_cipher(fns); break; case OSSL_FUNC_CIPHER_FREECTX: if (cipher->freectx != NULL) break; - cipher->freectx = OSSL_get_OP_cipher_freectx(fns); + cipher->freectx = OSSL_FUNC_cipher_freectx(fns); fnctxcnt++; break; case OSSL_FUNC_CIPHER_DUPCTX: if (cipher->dupctx != NULL) break; - cipher->dupctx = OSSL_get_OP_cipher_dupctx(fns); + cipher->dupctx = OSSL_FUNC_cipher_dupctx(fns); break; case OSSL_FUNC_CIPHER_GET_PARAMS: if (cipher->get_params != NULL) break; - cipher->get_params = OSSL_get_OP_cipher_get_params(fns); + cipher->get_params = OSSL_FUNC_cipher_get_params(fns); break; case OSSL_FUNC_CIPHER_GET_CTX_PARAMS: if (cipher->get_ctx_params != NULL) break; - cipher->get_ctx_params = OSSL_get_OP_cipher_get_ctx_params(fns); + cipher->get_ctx_params = OSSL_FUNC_cipher_get_ctx_params(fns); break; case OSSL_FUNC_CIPHER_SET_CTX_PARAMS: if (cipher->set_ctx_params != NULL) break; - cipher->set_ctx_params = OSSL_get_OP_cipher_set_ctx_params(fns); + cipher->set_ctx_params = OSSL_FUNC_cipher_set_ctx_params(fns); break; case OSSL_FUNC_CIPHER_GETTABLE_PARAMS: if (cipher->gettable_params != NULL) break; - cipher->gettable_params = OSSL_get_OP_cipher_gettable_params(fns); + cipher->gettable_params = OSSL_FUNC_cipher_gettable_params(fns); break; case OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS: if (cipher->gettable_ctx_params != NULL) break; cipher->gettable_ctx_params = - OSSL_get_OP_cipher_gettable_ctx_params(fns); + OSSL_FUNC_cipher_gettable_ctx_params(fns); break; case OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS: if (cipher->settable_ctx_params != NULL) break; cipher->settable_ctx_params = - OSSL_get_OP_cipher_settable_ctx_params(fns); + OSSL_FUNC_cipher_settable_ctx_params(fns); break; } } @@ -1459,13 +1684,19 @@ static void *evp_cipher_from_dispatch(const int name_id, * the "newctx" and "freectx" functions. */ EVP_CIPHER_free(cipher); - EVPerr(EVP_F_EVP_CIPHER_FROM_DISPATCH, EVP_R_INVALID_PROVIDER_FUNCTIONS); + ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS); return NULL; } cipher->prov = prov; if (prov != NULL) ossl_provider_up_ref(prov); + if (!evp_cipher_cache_constants(cipher)) { + EVP_CIPHER_free(cipher); + ERR_raise(ERR_LIB_EVP, EVP_R_CACHE_CONSTANTS_FAILED); + cipher = NULL; + } + return cipher; } @@ -1479,12 +1710,12 @@ static void evp_cipher_free(void *cipher) EVP_CIPHER_free(cipher); } -EVP_CIPHER *EVP_CIPHER_fetch(OPENSSL_CTX *ctx, const char *algorithm, +EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm, const char *properties) { EVP_CIPHER *cipher = evp_generic_fetch(ctx, OSSL_OP_CIPHER, algorithm, properties, - evp_cipher_from_dispatch, NULL, evp_cipher_up_ref, + evp_cipher_from_algorithm, evp_cipher_up_ref, evp_cipher_free); return cipher; @@ -1494,30 +1725,38 @@ int EVP_CIPHER_up_ref(EVP_CIPHER *cipher) { int ref = 0; - CRYPTO_UP_REF(&cipher->refcnt, &ref, cipher->lock); + if (cipher->origin == EVP_ORIG_DYNAMIC) + CRYPTO_UP_REF(&cipher->refcnt, &ref); return 1; } +void evp_cipher_free_int(EVP_CIPHER *cipher) +{ + OPENSSL_free(cipher->type_name); + ossl_provider_free(cipher->prov); + CRYPTO_FREE_REF(&cipher->refcnt); + OPENSSL_free(cipher); +} + void EVP_CIPHER_free(EVP_CIPHER *cipher) { int i; - if (cipher == NULL) + if (cipher == NULL || cipher->origin != EVP_ORIG_DYNAMIC) return; - CRYPTO_DOWN_REF(&cipher->refcnt, &i, cipher->lock); + CRYPTO_DOWN_REF(&cipher->refcnt, &i); if (i > 0) return; - ossl_provider_free(cipher->prov); - CRYPTO_THREAD_lock_free(cipher->lock); - OPENSSL_free(cipher); + evp_cipher_free_int(cipher); } -void EVP_CIPHER_do_all_ex(OPENSSL_CTX *libctx, - void (*fn)(EVP_CIPHER *mac, void *arg), - void *arg) +void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx, + void (*fn)(EVP_CIPHER *mac, void *arg), + void *arg) { evp_generic_do_all(libctx, OSSL_OP_CIPHER, (void (*)(void *, void *))fn, arg, - evp_cipher_from_dispatch, NULL, evp_cipher_free); + evp_cipher_from_algorithm, evp_cipher_up_ref, + evp_cipher_free); }