Commit 6435f0f6 authored by Richard Levitte's avatar Richard Levitte
Browse files

Adapt builtin cipher implementations to opaque EVP_CIPHER 



They all stop including evp_locl.h, so we also take care of their
adaptation to opaque EVP_CIPHER_CTX, as was promised in an earlier
commit.

Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
parent 135727ab

crypto/evp/e_aes.c

+287 −191

File changed.

Preview size limit exceeded, changes collapsed.

crypto/evp/e_aes_cbc_hmac_sha1.c

+1 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ 
# include <openssl/sha.h>

# include <openssl/rand.h>

# include "modes_lcl.h"

# include "internal/evp_int.h"



# ifndef EVP_CIPH_FLAG_AEAD_CIPHER

#  define EVP_CIPH_FLAG_AEAD_CIPHER       0x200000

crypto/evp/e_aes_cbc_hmac_sha256.c

+1 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ 
# include <openssl/sha.h>

# include <openssl/rand.h>

# include "modes_lcl.h"

# include "internal/evp_int.h"



# ifndef EVP_CIPH_FLAG_AEAD_CIPHER

#  define EVP_CIPH_FLAG_AEAD_CIPHER       0x200000

crypto/evp/e_bf.c

+1 −1
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ 
#include "internal/cryptlib.h"

#ifndef OPENSSL_NO_BF

# include <openssl/evp.h>

# include "evp_locl.h"

# include "internal/evp_int.h"

# include <openssl/objects.h>

# include <openssl/blowfish.h>

crypto/evp/e_camellia.c

+49 −28
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ 
# include <string.h>

# include <assert.h>

# include <openssl/camellia.h>

# include "evp_locl.h"

# include "internal/evp_int.h"

# include "modes_lcl.h"



static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
@@ -256,15 +256,15 @@ static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, 
                             const unsigned char *iv, int enc)

{

    int ret, mode;

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    ret = Camellia_set_key(key, ctx->key_len * 8, &dat->ks);

    ret = Camellia_set_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8, &dat->ks);

    if (ret < 0) {

        EVPerr(EVP_F_CAMELLIA_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED);

        return 0;

    }



    mode = ctx->cipher->flags & EVP_CIPH_MODE;

    mode = EVP_CIPHER_CTX_mode(ctx);

    if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)

        && !enc) {

        dat->block = (block128_f) Camellia_decrypt;
@@ -282,14 +282,18 @@ static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, 
static int camellia_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                               const unsigned char *in, size_t len)

{

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    if (dat->stream.cbc)

        (*dat->stream.cbc) (in, out, len, &dat->ks, ctx->iv, ctx->encrypt);

    else if (ctx->encrypt)

        CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, ctx->iv, dat->block);

        (*dat->stream.cbc) (in, out, len, &dat->ks,

                            EVP_CIPHER_CTX_iv_noconst(ctx),

                            EVP_CIPHER_CTX_encrypting(ctx));

    else if (EVP_CIPHER_CTX_encrypting(ctx))

        CRYPTO_cbc128_encrypt(in, out, len, &dat->ks,

                              EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);

    else

        CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, ctx->iv, dat->block);

        CRYPTO_cbc128_decrypt(in, out, len, &dat->ks,

                              EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);



    return 1;

}
@@ -297,9 +301,9 @@ static int camellia_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 
static int camellia_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                               const unsigned char *in, size_t len)

{

    size_t bl = ctx->cipher->block_size;

    size_t bl = EVP_CIPHER_CTX_block_size(ctx);

    size_t i;

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    if (len < bl)

        return 1;
@@ -313,52 +317,65 @@ static int camellia_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 
static int camellia_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                               const unsigned char *in, size_t len)

{

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    int num = EVP_CIPHER_CTX_num(ctx);

    CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,

                          ctx->iv, &ctx->num, dat->block);

                          EVP_CIPHER_CTX_iv_noconst(ctx), &num, dat->block);

    EVP_CIPHER_CTX_set_num(ctx, num);

    return 1;

}



static int camellia_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                               const unsigned char *in, size_t len)

{

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    int num = EVP_CIPHER_CTX_num(ctx);

    CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,

                          ctx->iv, &ctx->num, ctx->encrypt, dat->block);

                          EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);

    EVP_CIPHER_CTX_set_num(ctx, num);

    return 1;

}



static int camellia_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                                const unsigned char *in, size_t len)

{

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    int num = EVP_CIPHER_CTX_num(ctx);

    CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,

                            ctx->iv, &ctx->num, ctx->encrypt, dat->block);

                            EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);

    EVP_CIPHER_CTX_set_num(ctx, num);

    return 1;

}



static int camellia_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                                const unsigned char *in, size_t len)

{

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    if (ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) {

    if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) {

        int num = EVP_CIPHER_CTX_num(ctx);

        CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,

                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);

                                EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);

        EVP_CIPHER_CTX_set_num(ctx, num);

        return 1;

    }



    while (len >= MAXBITCHUNK) {

        int num = EVP_CIPHER_CTX_num(ctx);

        CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,

                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);

                                EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);

        len -= MAXBITCHUNK;

        EVP_CIPHER_CTX_set_num(ctx, num);

    }

    if (len)

    if (len) {

        int num = EVP_CIPHER_CTX_num(ctx);

        CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,

                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);

                                EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);

        EVP_CIPHER_CTX_set_num(ctx, num);

    }



    return 1;

}
@@ -366,16 +383,20 @@ static int camellia_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 
static int camellia_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

                               const unsigned char *in, size_t len)

{

    unsigned int num = ctx->num;

    EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data;

    unsigned int num = EVP_CIPHER_CTX_num(ctx);

    EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);



    if (dat->stream.ctr)

        CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks,

                                    ctx->iv, ctx->buf, &num, dat->stream.ctr);

                                    EVP_CIPHER_CTX_iv_noconst(ctx),

                                    EVP_CIPHER_CTX_buf_noconst(ctx), &num,

                                    dat->stream.ctr);

    else

        CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,

                              ctx->iv, ctx->buf, &num, dat->block);

    ctx->num = (size_t)num;

                              EVP_CIPHER_CTX_iv_noconst(ctx),

                              EVP_CIPHER_CTX_buf_noconst(ctx), &num,

                              dat->block);

    EVP_CIPHER_CTX_set_num(ctx, num);

    return 1;

}