int ret, mode;
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- mode = EVP_CIPHER_CTX_mode(ctx);
+ mode = EVP_CIPHER_CTX_get_mode(ctx);
if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
&& !enc) {
- ret = aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = aesni_set_decrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) aesni_decrypt;
dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
(cbc128_f) aesni_cbc_encrypt : NULL;
} else {
- ret = aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = aesni_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) aesni_encrypt;
if (mode == EVP_CIPH_CBC_MODE)
const unsigned char *in, size_t len)
{
aesni_cbc_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
- ctx->iv, EVP_CIPHER_CTX_encrypting(ctx));
+ ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));
return 1;
}
static int aesni_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len)
{
- size_t bl = EVP_CIPHER_CTX_block_size(ctx);
+ size_t bl = EVP_CIPHER_CTX_get_block_size(ctx);
if (len < bl)
return 1;
aesni_ecb_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
- EVP_CIPHER_CTX_encrypting(ctx));
+ EVP_CIPHER_CTX_is_encrypting(ctx));
return 1;
}
if (!iv && !key)
return 1;
if (key) {
- aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aesni_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&gctx->ks.ks);
CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks, (block128_f) aesni_encrypt);
gctx->ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
if (key) {
/* The key is two half length keys in reality */
- const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
+ const int bytes = EVP_CIPHER_CTX_get_key_length(ctx) / 2;
const int bits = bytes * 8;
/*
if (!iv && !key)
return 1;
if (key) {
- aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aesni_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
&cctx->ks, (block128_f) aesni_encrypt);
* needs both. We could possibly optimise to remove setting the
* decrypt for an encryption operation.
*/
- aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aesni_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksenc.ks);
- aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aesni_set_decrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksdec.ks);
if (!CRYPTO_ocb128_init(&octx->ocb,
&octx->ksenc.ks, &octx->ksdec.ks,
int ret, mode, bits;
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- mode = EVP_CIPHER_CTX_mode(ctx);
- bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
+ mode = EVP_CIPHER_CTX_get_mode(ctx);
+ bits = EVP_CIPHER_CTX_get_key_length(ctx) * 8;
if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
&& !enc) {
ret = 0;
if (!iv && !key)
return 1;
if (key) {
- int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
+ int bits = EVP_CIPHER_CTX_get_key_length(ctx) * 8;
aes_t4_set_encrypt_key(key, bits, &gctx->ks.ks);
CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
(block128_f) aes_t4_encrypt);
if (key) {
/* The key is two half length keys in reality */
- const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
+ const int bytes = EVP_CIPHER_CTX_get_key_length(ctx) / 2;
const int bits = bytes * 8;
/*
if (!iv && !key)
return 1;
if (key) {
- int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
+ int bits = EVP_CIPHER_CTX_get_key_length(ctx) * 8;
aes_t4_set_encrypt_key(key, bits, &cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
&cctx->ks, (block128_f) aes_t4_encrypt);
* needs both. We could possibly optimise to remove setting the
* decrypt for an encryption operation.
*/
- aes_t4_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aes_t4_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksenc.ks);
- aes_t4_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ aes_t4_set_decrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksdec.ks);
if (!CRYPTO_ocb128_init(&octx->ocb,
&octx->ksenc.ks, &octx->ksdec.ks,
const unsigned char *iv, int enc)
{
S390X_AES_ECB_CTX *cctx = EVP_C_DATA(S390X_AES_ECB_CTX, ctx);
- const int keylen = EVP_CIPHER_CTX_key_length(ctx);
+ const int keylen = EVP_CIPHER_CTX_get_key_length(ctx);
cctx->fc = S390X_AES_FC(keylen);
if (!enc)
{
S390X_AES_OFB_CTX *cctx = EVP_C_DATA(S390X_AES_OFB_CTX, ctx);
const unsigned char *iv = ctx->oiv;
- const int keylen = EVP_CIPHER_CTX_key_length(ctx);
- const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
+ const int keylen = EVP_CIPHER_CTX_get_key_length(ctx);
+ const int ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
memcpy(cctx->kmo.param.cv, iv, ivlen);
memcpy(cctx->kmo.param.k, key, keylen);
{
S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
const unsigned char *iv = ctx->oiv;
- const int keylen = EVP_CIPHER_CTX_key_length(ctx);
- const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
+ const int keylen = EVP_CIPHER_CTX_get_key_length(ctx);
+ const int ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
cctx->fc = S390X_AES_FC(keylen);
cctx->fc |= 16 << 24; /* 16 bytes cipher feedback */
const unsigned char *in, size_t len)
{
S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
- const int keylen = EVP_CIPHER_CTX_key_length(ctx);
- const int enc = EVP_CIPHER_CTX_encrypting(ctx);
+ const int keylen = EVP_CIPHER_CTX_get_key_length(ctx);
+ const int enc = EVP_CIPHER_CTX_is_encrypting(ctx);
int n = cctx->res;
int rem;
unsigned char tmp;
{
S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
const unsigned char *iv = ctx->oiv;
- const int keylen = EVP_CIPHER_CTX_key_length(ctx);
- const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
+ const int keylen = EVP_CIPHER_CTX_get_key_length(ctx);
+ const int ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
cctx->fc = S390X_AES_FC(keylen);
cctx->fc |= 1 << 24; /* 1 byte cipher feedback */
switch (type) {
case EVP_CTRL_INIT:
- ivlen = EVP_CIPHER_iv_length(c->cipher);
+ ivlen = EVP_CIPHER_get_iv_length(c->cipher);
gctx->key_set = 0;
gctx->iv_set = 0;
gctx->ivlen = ivlen;
case EVP_CTRL_AEAD_SET_TAG:
buf = EVP_CIPHER_CTX_buf_noconst(c);
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (arg <= 0 || arg > 16 || enc)
return 0;
return 1;
case EVP_CTRL_AEAD_GET_TAG:
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (arg <= 0 || arg > 16 || !enc || gctx->taglen < 0)
return 0;
if (arg)
memcpy(gctx->iv, ptr, arg);
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (enc && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
return 0;
return 1;
case EVP_CTRL_GCM_SET_IV_INV:
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (gctx->iv_gen == 0 || gctx->key_set == 0 || enc)
return 0;
len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
/* If decrypting correct for tag too. */
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (!enc) {
if (len < EVP_GCM_TLS_TAG_LEN)
return 0;
return 1;
if (key != NULL) {
- keylen = EVP_CIPHER_CTX_key_length(ctx);
+ keylen = EVP_CIPHER_CTX_get_key_length(ctx);
memcpy(&gctx->kma.param.k, key, keylen);
gctx->fc = S390X_AES_FC(keylen);
{
S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
const unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
- const int enc = EVP_CIPHER_CTX_encrypting(ctx);
+ const int enc = EVP_CIPHER_CTX_is_encrypting(ctx);
int rv = -1;
if (out != in || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
OPENSSL_cleanse(tmp, gctx->mreslen);
gctx->iv_set = 0;
- enc = EVP_CIPHER_CTX_encrypting(ctx);
+ enc = EVP_CIPHER_CTX_is_encrypting(ctx);
if (enc) {
gctx->taglen = 16;
} else {
S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, ctx);
unsigned char *ivec = ctx->iv;
unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
- const int enc = EVP_CIPHER_CTX_encrypting(ctx);
+ const int enc = EVP_CIPHER_CTX_is_encrypting(ctx);
if (out != in
|| len < (EVP_CCM_TLS_EXPLICIT_IV_LEN + (size_t)cctx->aes.ccm.m))
return 1;
if (key != NULL) {
- keylen = EVP_CIPHER_CTX_key_length(ctx);
+ keylen = EVP_CIPHER_CTX_get_key_length(ctx);
cctx->aes.ccm.fc = S390X_AES_FC(keylen);
memcpy(cctx->aes.ccm.kmac_param.k, key, keylen);
const unsigned char *in, size_t len)
{
S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, ctx);
- const int enc = EVP_CIPHER_CTX_encrypting(ctx);
+ const int enc = EVP_CIPHER_CTX_is_encrypting(ctx);
int rv;
unsigned char *buf;
/* Correct length for explicit iv. */
len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (!enc) {
if (len < cctx->aes.ccm.m)
return 0;
if ((arg & 1) || arg < 4 || arg > 16)
return 0;
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (enc && ptr)
return 0;
return 1;
case EVP_CTRL_AEAD_GET_TAG:
- enc = EVP_CIPHER_CTX_encrypting(c);
+ enc = EVP_CIPHER_CTX_is_encrypting(c);
if (!enc || !cctx->aes.ccm.tag_set)
return 0;
int ret, mode;
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- mode = EVP_CIPHER_CTX_mode(ctx);
+ mode = EVP_CIPHER_CTX_get_mode(ctx);
if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
&& !enc) {
#ifdef HWAES_CAPABLE
if (HWAES_CAPABLE) {
ret = HWAES_set_decrypt_key(key,
- EVP_CIPHER_CTX_key_length(ctx) * 8,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) HWAES_decrypt;
dat->stream.cbc = NULL;
#endif
#ifdef BSAES_CAPABLE
if (BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE) {
- ret = AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = AES_set_decrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) AES_decrypt;
dat->stream.cbc = (cbc128_f) ossl_bsaes_cbc_encrypt;
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
ret = vpaes_set_decrypt_key(key,
- EVP_CIPHER_CTX_key_length(ctx) * 8,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) vpaes_decrypt;
dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
#endif
{
ret = AES_set_decrypt_key(key,
- EVP_CIPHER_CTX_key_length(ctx) * 8,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) AES_decrypt;
dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
} else
#ifdef HWAES_CAPABLE
if (HWAES_CAPABLE) {
- ret = HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = HWAES_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) HWAES_encrypt;
dat->stream.cbc = NULL;
#endif
#ifdef BSAES_CAPABLE
if (BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE) {
- ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) AES_encrypt;
dat->stream.ctr = (ctr128_f) ossl_bsaes_ctr32_encrypt_blocks;
#endif
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
- ret = vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = vpaes_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) vpaes_encrypt;
dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
} else
#endif
{
- ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&dat->ks.ks);
dat->block = (block128_f) AES_encrypt;
dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
if (dat->stream.cbc)
(*dat->stream.cbc) (in, out, len, &dat->ks, ctx->iv,
- EVP_CIPHER_CTX_encrypting(ctx));
- else if (EVP_CIPHER_CTX_encrypting(ctx))
+ EVP_CIPHER_CTX_is_encrypting(ctx));
+ else if (EVP_CIPHER_CTX_is_encrypting(ctx))
CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, ctx->iv,
dat->block);
else
static int aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len)
{
- size_t bl = EVP_CIPHER_CTX_block_size(ctx);
+ size_t bl = EVP_CIPHER_CTX_get_block_size(ctx);
size_t i;
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
{
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,
ctx->iv, &num, dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
{
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,
ctx->iv, &num,
- EVP_CIPHER_CTX_encrypting(ctx), dat->block);
+ EVP_CIPHER_CTX_is_encrypting(ctx), dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
return 1;
}
{
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,
ctx->iv, &num,
- EVP_CIPHER_CTX_encrypting(ctx), dat->block);
+ EVP_CIPHER_CTX_is_encrypting(ctx), dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
return 1;
}
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) {
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,
ctx->iv, &num,
- EVP_CIPHER_CTX_encrypting(ctx), dat->block);
+ EVP_CIPHER_CTX_is_encrypting(ctx), dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
return 1;
}
while (len >= MAXBITCHUNK) {
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
ctx->iv, &num,
- EVP_CIPHER_CTX_encrypting(ctx), dat->block);
+ EVP_CIPHER_CTX_is_encrypting(ctx), dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
len -= MAXBITCHUNK;
out += MAXBITCHUNK;
in += MAXBITCHUNK;
}
if (len) {
- int num = EVP_CIPHER_CTX_num(ctx);
+ int num = EVP_CIPHER_CTX_get_num(ctx);
CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,
ctx->iv, &num,
- EVP_CIPHER_CTX_encrypting(ctx), dat->block);
+ EVP_CIPHER_CTX_is_encrypting(ctx), dat->block);
EVP_CIPHER_CTX_set_num(ctx, num);
}
static int aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len)
{
- unsigned int num = EVP_CIPHER_CTX_num(ctx);
+ unsigned int num = EVP_CIPHER_CTX_get_num(ctx);
EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
if (dat->stream.ctr)
case EVP_CTRL_INIT:
gctx->key_set = 0;
gctx->iv_set = 0;
- gctx->ivlen = EVP_CIPHER_iv_length(c->cipher);
+ gctx->ivlen = EVP_CIPHER_get_iv_length(c->cipher);
gctx->iv = c->iv;
gctx->taglen = -1;
gctx->iv_gen = 0;
if (key) {
do {
/* The key is two half length keys in reality */
- const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
+ const int bytes = EVP_CIPHER_CTX_get_key_length(ctx) / 2;
const int bits = bytes * 8;
/*
xctx->xts.key1, xctx->xts.key2,
ctx->iv);
else if (CRYPTO_xts128_encrypt(&xctx->xts, ctx->iv, in, out, len,
- EVP_CIPHER_CTX_encrypting(ctx)))
+ EVP_CIPHER_CTX_is_encrypting(ctx)))
return 0;
return 1;
}
return 0;
len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
/* If decrypting correct for tag too */
- if (!EVP_CIPHER_CTX_encrypting(c)) {
+ if (!EVP_CIPHER_CTX_is_encrypting(c)) {
if (len < cctx->M)
return 0;
len -= cctx->M;
case EVP_CTRL_AEAD_SET_TAG:
if ((arg & 1) || arg < 4 || arg > 16)
return 0;
- if (EVP_CIPHER_CTX_encrypting(c) && ptr)
+ if (EVP_CIPHER_CTX_is_encrypting(c) && ptr)
return 0;
if (ptr) {
cctx->tag_set = 1;
return 1;
case EVP_CTRL_AEAD_GET_TAG:
- if (!EVP_CIPHER_CTX_encrypting(c) || !cctx->tag_set)
+ if (!EVP_CIPHER_CTX_is_encrypting(c) || !cctx->tag_set)
return 0;
if (!CRYPTO_ccm128_tag(&cctx->ccm, ptr, (size_t)arg))
return 0;
do {
#ifdef HWAES_CAPABLE
if (HWAES_CAPABLE) {
- HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ HWAES_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
#endif
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
- vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ vpaes_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
&cctx->ks, (block128_f) vpaes_encrypt);
break;
}
#endif
- AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ AES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
&cctx->ks, (block128_f) AES_encrypt);
if (out != in || len < (EVP_CCM_TLS_EXPLICIT_IV_LEN + (size_t)cctx->M))
return -1;
/* If encrypting set explicit IV from sequence number (start of AAD) */
- if (EVP_CIPHER_CTX_encrypting(ctx))
+ if (EVP_CIPHER_CTX_is_encrypting(ctx))
memcpy(out, EVP_CIPHER_CTX_buf_noconst(ctx),
EVP_CCM_TLS_EXPLICIT_IV_LEN);
/* Get rest of IV from explicit IV */
len))
return -1;
/* Use saved AAD */
- CRYPTO_ccm128_aad(ccm, EVP_CIPHER_CTX_buf_noconst(ctx), cctx->tls_aad_len);
+ CRYPTO_ccm128_aad(ccm, EVP_CIPHER_CTX_buf_noconst(ctx),
+ cctx->tls_aad_len);
/* Fix buffer to point to payload */
in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
- if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
cctx->str) :
CRYPTO_ccm128_encrypt(ccm, in, out, len))
}
/* The tag must be set before actually decrypting data */
- if (!EVP_CIPHER_CTX_encrypting(ctx) && !cctx->tag_set)
+ if (!EVP_CIPHER_CTX_is_encrypting(ctx) && !cctx->tag_set)
return -1;
/* If not set length yet do it */
return -1;
cctx->len_set = 1;
}
- if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
cctx->str) :
CRYPTO_ccm128_encrypt(ccm, in, out, len))
if (!iv && !key)
return 1;
if (key) {
- if (EVP_CIPHER_CTX_encrypting(ctx))
- AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ if (EVP_CIPHER_CTX_is_encrypting(ctx))
+ AES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&wctx->ks.ks);
else
- AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ AES_set_decrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&wctx->ks.ks);
if (!iv)
wctx->iv = NULL;
}
if (iv) {
- memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx));
+ memcpy(ctx->iv, iv, EVP_CIPHER_CTX_get_iv_length(ctx));
wctx->iv = ctx->iv;
}
return 1;
EVP_AES_WRAP_CTX *wctx = EVP_C_DATA(EVP_AES_WRAP_CTX,ctx);
size_t rv;
/* AES wrap with padding has IV length of 4, without padding 8 */
- int pad = EVP_CIPHER_CTX_iv_length(ctx) == 4;
+ int pad = EVP_CIPHER_CTX_get_iv_length(ctx) == 4;
/* No final operation so always return zero length */
if (!in)
return 0;
if (!inlen)
return -1;
/* If decrypting need at least 16 bytes and multiple of 8 */
- if (!EVP_CIPHER_CTX_encrypting(ctx) && (inlen < 16 || inlen & 0x7))
+ if (!EVP_CIPHER_CTX_is_encrypting(ctx) && (inlen < 16 || inlen & 0x7))
return -1;
/* If not padding input must be multiple of 8 */
if (!pad && inlen & 0x7)
return 0;
}
if (!out) {
- if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
/* If padding round up to multiple of 8 */
if (pad)
inlen = (inlen + 7) / 8 * 8;
}
}
if (pad) {
- if (EVP_CIPHER_CTX_encrypting(ctx))
+ if (EVP_CIPHER_CTX_is_encrypting(ctx))
rv = CRYPTO_128_wrap_pad(&wctx->ks.ks, wctx->iv,
out, in, inlen,
(block128_f) AES_encrypt);
out, in, inlen,
(block128_f) AES_decrypt);
} else {
- if (EVP_CIPHER_CTX_encrypting(ctx))
+ if (EVP_CIPHER_CTX_is_encrypting(ctx))
rv = CRYPTO_128_wrap(&wctx->ks.ks, wctx->iv,
out, in, inlen, (block128_f) AES_encrypt);
else
case EVP_CTRL_INIT:
octx->key_set = 0;
octx->iv_set = 0;
- octx->ivlen = EVP_CIPHER_iv_length(c->cipher);
+ octx->ivlen = EVP_CIPHER_get_iv_length(c->cipher);
octx->iv = c->iv;
octx->taglen = 16;
octx->data_buf_len = 0;
octx->taglen = arg;
return 1;
}
- if (arg != octx->taglen || EVP_CIPHER_CTX_encrypting(c))
+ if (arg != octx->taglen || EVP_CIPHER_CTX_is_encrypting(c))
return 0;
memcpy(octx->tag, ptr, arg);
return 1;
case EVP_CTRL_AEAD_GET_TAG:
- if (arg != octx->taglen || !EVP_CIPHER_CTX_encrypting(c))
+ if (arg != octx->taglen || !EVP_CIPHER_CTX_is_encrypting(c))
return 0;
memcpy(ptr, octx->tag, arg);
*/
# ifdef HWAES_CAPABLE
if (HWAES_CAPABLE) {
- HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksenc.ks);
- HWAES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ HWAES_set_decrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksdec.ks);
if (!CRYPTO_ocb128_init(&octx->ocb,
&octx->ksenc.ks, &octx->ksdec.ks,
# endif
# ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
- vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ vpaes_set_encrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksenc.ks);
- vpaes_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ vpaes_set_decrypt_key(key,
+ EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksdec.ks);
if (!CRYPTO_ocb128_init(&octx->ocb,
&octx->ksenc.ks, &octx->ksdec.ks,
break;
}
# endif
- AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ AES_set_encrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksenc.ks);
- AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
+ AES_set_decrypt_key(key, EVP_CIPHER_CTX_get_key_length(ctx) * 8,
&octx->ksdec.ks);
if (!CRYPTO_ocb128_init(&octx->ocb,
&octx->ksenc.ks, &octx->ksdec.ks,
if (out == NULL) {
if (!CRYPTO_ocb128_aad(&octx->ocb, buf, AES_BLOCK_SIZE))
return -1;
- } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ } else if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (!CRYPTO_ocb128_encrypt(&octx->ocb, buf, out,
AES_BLOCK_SIZE))
return -1;
if (out == NULL) {
if (!CRYPTO_ocb128_aad(&octx->ocb, in, len - trailing_len))
return -1;
- } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ } else if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (!CRYPTO_ocb128_encrypt
(&octx->ocb, in, out, len - trailing_len))
return -1;
* have been provided - both for data and AAD
*/
if (octx->data_buf_len > 0) {
- if (EVP_CIPHER_CTX_encrypting(ctx)) {
+ if (EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (!CRYPTO_ocb128_encrypt(&octx->ocb, octx->data_buf, out,
octx->data_buf_len))
return -1;
octx->aad_buf_len = 0;
}
/* If decrypting then verify */
- if (!EVP_CIPHER_CTX_encrypting(ctx)) {
+ if (!EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (octx->taglen < 0)
return -1;
if (CRYPTO_ocb128_finish(&octx->ocb,
projects / openssl.git / blobdiff