x86/crypto: Fix crypto function casts
Subsystems (2)
v2 cover x86/crypto: Fix crypto function casts
It is possible to indirectly invoke functions with prototypes that do not match those of the respectively used function pointers by using void types. This feature is frequently used as a way of relaxing function invocation, making it possible that different data structures are passed to different functions through the same pointer.
Despite the benefits, this can lead to a situation where functions with a given prototype are invoked by pointers with a different prototype, what is undesirable as it may prevent the use of heuristics such as prototype matching-based Control-Flow Integrity, which can be used to prevent ROP-based attacks.
One way of fixing this situation is through the use of helper functions with prototypes that match the one in the respective invoking pointer.
Given the above, the current efforts to improve the Linux security, and the upcoming kernel support to compilers with CFI features, fix the prototype casting of x86/crypto algorithms camellia, cast6, serpent and twofish with the use of a macro that generates the helper function.
This patch does not introduce semantic changes to the cryptographic algorithms, yet, if someone finds relevant, the affected algorithms were tested with the help of tcrypt.ko without any visible harm.
Joao Moreira (4):
Fix serpent crypto function prototypes
Fix camellia crypto function prototypes
Fix twofish crypto function prototypes
Fix cast6 crypto function prototypes
arch/x86/crypto/camellia_aesni_avx2_glue.c | 69 ++++++++-------------- arch/x86/crypto/camellia_aesni_avx_glue.c | 45 +++++++-------- arch/x86/crypto/camellia_glue.c | 19 +++--- arch/x86/crypto/cast6_avx_glue.c | 54 +++++++---------- arch/x86/crypto/serpent_avx2_glue.c | 68 ++++++++++------------ arch/x86/crypto/serpent_avx_glue.c | 63 ++++++++------------ arch/x86/crypto/serpent_sse2_glue.c | 24 +++++--- arch/x86/crypto/twofish_avx_glue.c | 65 ++++++++++----------- arch/x86/crypto/twofish_glue_3way.c | 33 ++++++----- arch/x86/include/asm/crypto/camellia.h | 93 +++++++++++++++--------------- arch/x86/include/asm/crypto/serpent-avx.h | 39 ++++++++----- arch/x86/include/asm/crypto/serpent-sse2.h | 10 ++++ arch/x86/include/asm/crypto/twofish.h | 33 ++++++++--- include/crypto/cast6.h | 23 +++++++- 14 files changed, 320 insertions(+), 318 deletions(-)
Signature · 1 line
2.16.4
RFC PATCH v2 1/4 Fix serpent crypto functions prototype casts
Add macros that generate glue functions for serpent crypto functions.
Remove GLUE_FUNC_CAST macros from function pointer assignement and use the helper instead, making the prototypes compliant.
--- arch/x86/crypto/serpent_avx2_glue.c | 68 ++++++++++++++---------------- arch/x86/crypto/serpent_avx_glue.c | 63 ++++++++++----------------- arch/x86/crypto/serpent_sse2_glue.c | 24 +++++++---- arch/x86/include/asm/crypto/serpent-avx.h | 39 +++++++++++------ arch/x86/include/asm/crypto/serpent-sse2.h | 10 +++++ 5 files changed, 105 insertions(+), 99 deletions(-)
arch/x86/crypto/serpent_avx2_glue.c +32 -36
@@ -24,18 +24,15 @@#define SERPENT_AVX2_PARALLEL_BLOCKS 16/* 16-way AVX2 parallel cipher functions */ -asmlinkage void serpent_ecb_enc_16way(struct serpent_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void serpent_ecb_dec_16way(struct serpent_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void serpent_cbc_dec_16way(void *ctx, u128 *dst, const u128 *src); - -asmlinkage void serpent_ctr_16way(void *ctx, u128 *dst, const u128 *src, -le128 *iv); -asmlinkage void serpent_xts_enc_16way(struct serpent_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void serpent_xts_dec_16way(struct serpent_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); +SERPENT_GLUE (serpent_ecb_enc_16way); +SERPENT_GLUE (serpent_ecb_dec_16way); +SERPENT_GLUE_CBC (serpent_cbc_dec_16way, serpent_cbc_dec_16way_glue); +SERPENT_GLUE_CTR (serpent_ctr_16way); +SERPENT_GLUE_XTS (serpent_xts_enc_16way); +SERPENT_GLUE_XTS (serpent_xts_dec_16way); +SERPENT_GLUE (__serpent_encrypt); +SERPENT_GLUE (__serpent_decrypt); +SERPENT_GLUE_CBC (__serpent_decrypt, __serpent_decrypt_cbc_glue);static int serpent_setkey_skcipher (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen)
@@ -49,13 +46,13 @@ static const struct common_glue_ctx serpent_enc = { .funcs = { { .num_blocks = 16, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_16way) } + .fn_u = { .ecb = serpent_ecb_enc_16way_glue } }, { .num_blocks = 8, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) } + .fn_u = { .ecb = serpent_ecb_enc_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) } + .fn_u = { .ecb = __serpent_encrypt_glue } } } };
@@ -65,13 +62,13 @@ static const struct common_glue_ctx serpent_ctr = { .funcs = { { .num_blocks = 16, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_16way) } + .fn_u = { .ctr = serpent_ctr_16way_glue } }, { .num_blocks = 8, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) } + .fn_u = { .ctr = serpent_ctr_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) } + .fn_u = { .ctr = __serpent_crypt_ctr } } } };
@@ -81,13 +78,13 @@ static const struct common_glue_ctx serpent_enc_xts = { .funcs = { { .num_blocks = 16, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_16way) } + .fn_u = { .xts = serpent_xts_enc_16way_glue } }, { .num_blocks = 8, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) } + .fn_u = { .xts = serpent_xts_enc_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) } + .fn_u = { .xts = serpent_xts_enc } } } };
@@ -97,13 +94,13 @@ static const struct common_glue_ctx serpent_dec = { .funcs = { { .num_blocks = 16, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_16way) } + .fn_u = { .ecb = serpent_ecb_dec_16way_glue } }, { .num_blocks = 8, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) } + .fn_u = { .ecb = serpent_ecb_dec_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) } + .fn_u = { .ecb = __serpent_decrypt_glue } } } };
@@ -113,13 +110,13 @@ static const struct common_glue_ctx serpent_dec_cbc = { .funcs = { { .num_blocks = 16, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_16way) } + .fn_u = { .cbc = serpent_cbc_dec_16way_glue } }, { .num_blocks = 8, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) } + .fn_u = { .cbc = serpent_cbc_dec_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) } + .fn_u = { .cbc = __serpent_decrypt_cbc_glue } } } };
@@ -129,13 +126,13 @@ static const struct common_glue_ctx serpent_dec_xts = { .funcs = { { .num_blocks = 16, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_16way) } + .fn_u = { .xts = serpent_xts_dec_16way_glue } }, { .num_blocks = 8, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) } + .fn_u = { .xts = serpent_xts_dec_8way_avx_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) } + .fn_u = { .xts = serpent_xts_dec } } } };
@@ -151,8 +148,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (__serpent_encrypt), - req); +return glue_cbc_encrypt_req_128bit (__serpent_encrypt_glue, req); }static int cbc_decrypt (struct skcipher_request *req)
@@ -171,8 +167,8 @@ static int xts_encrypt(struct skcipher_request *req)struct serpent_xts_ctx *ctx =crypto_skcipher_ctx (tfm);return glue_xts_req_128bit (&serpent_enc_xts, req, -XTS_TWEAK_CAST (__serpent_encrypt), - &ctx->tweak_ctx, &ctx->crypt_ctx); + __serpent_encrypt_glue, &ctx->tweak_ctx, + &ctx->crypt_ctx); }static int xts_decrypt (struct skcipher_request *req)
@@ -181,8 +177,8 @@ static int xts_decrypt(struct skcipher_request *req)struct serpent_xts_ctx *ctx =crypto_skcipher_ctx (tfm);return glue_xts_req_128bit (&serpent_dec_xts, req, -XTS_TWEAK_CAST (__serpent_encrypt), - &ctx->tweak_ctx, &ctx->crypt_ctx); + __serpent_encrypt_glue, &ctx->tweak_ctx, + &ctx->crypt_ctx); }static struct skcipher_alg serpent_algs[] = {
arch/x86/crypto/serpent_avx_glue.c +23 -40
151 lines not on this page · raw message
arch/x86/crypto/serpent_sse2_glue.c +15 -9
@@ -40,6 +40,12 @@#include <asm/crypto/serpent-sse2.h> #include <asm/crypto/glue_helper.h> +SERPENT_GLUE (__serpent_encrypt); +SERPENT_GLUE (__serpent_decrypt); +SERPENT_GLUE_CBC (__serpent_decrypt, __serpent_decrypt_cbc_glue); +SERPENT_GLUE (serpent_enc_blk_xway); +SERPENT_GLUE (serpent_dec_blk_xway); +static int serpent_setkey_skcipher (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen) {
@@ -94,10 +100,10 @@ static const struct common_glue_ctx serpent_enc = { .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_enc_blk_xway) } + .fn_u = { .ecb = serpent_enc_blk_xway_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) } + .fn_u = { .ecb = __serpent_encrypt_glue } } } };
@@ -107,10 +113,10 @@ static const struct common_glue_ctx serpent_ctr = { .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr_xway) } + .fn_u = { .ctr = serpent_crypt_ctr_xway } }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr) } + .fn_u = { .ctr = serpent_crypt_ctr } } } };
@@ -120,10 +126,10 @@ static const struct common_glue_ctx serpent_dec = { .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_dec_blk_xway) } + .fn_u = { .ecb = serpent_dec_blk_xway_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) } + .fn_u = { .ecb = __serpent_decrypt_glue } } } };
@@ -133,10 +139,10 @@ static const struct common_glue_ctx serpent_dec_cbc = { .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_decrypt_cbc_xway) } + .fn_u = { .cbc = serpent_decrypt_cbc_xway } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) } + .fn_u = { .cbc = __serpent_decrypt_cbc_glue } } } };
@@ -152,7 +158,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (__serpent_encrypt), +return glue_cbc_encrypt_req_128bit (__serpent_encrypt_glue, req); }
arch/x86/include/asm/crypto/serpent-avx.h +25 -14
@@ -15,20 +15,31 @@ struct serpent_xts_ctx {struct serpent_ctx crypt_ctx; }; -asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src); - -asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); - -asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); +#define SERPENT_GLUE (func) \ +asmlinkage void func(struct serpent_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void func ## _glue(void *ctx, u8 *dst, const u8 *src) \ +{ func((struct serpent_ctx *) ctx, dst, src); } + +#define SERPENT_GLUE_CBC (func, helper) \ +asmlinkage void func(struct serpent_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void helper(void *ctx, u128 *dst, const u128 *src) \ +{ func((struct serpent_ctx *) ctx, (u8 *) dst, (u8 *) src); } + +#define SERPENT_GLUE_CTR (func) \ +asmlinkage void func(struct serpent_ctx *ctx, u8 *dst, const u8 *src, \ + le128 *iv); \ +asmlinkage static inline void func ## _glue(void *ctx, u128 *dst, \ + const u128 *src, le128 *iv) \ +{ func((struct serpent_ctx *) ctx, (u8 *) dst, (u8 *) src, iv); } + +#define SERPENT_GLUE_XTS (func) SERPENT_GLUE_CTR(func) + +SERPENT_GLUE (serpent_ecb_enc_8way_avx); +SERPENT_GLUE (serpent_ecb_dec_8way_avx); +SERPENT_GLUE_CBC (serpent_cbc_dec_8way_avx, serpent_cbc_dec_8way_avx_glue); +SERPENT_GLUE_CTR (serpent_ctr_8way_avx); +SERPENT_GLUE_XTS (serpent_xts_enc_8way_avx); +SERPENT_GLUE_XTS (serpent_xts_dec_8way_avx);extern void __serpent_crypt_ctr (void *ctx,u128 *dst,const u128 *src,le128 *iv);
arch/x86/include/asm/crypto/serpent-sse2.h +10 -0
@@ -5,6 +5,16 @@#include <linux/crypto.h> #include <crypto/serpent.h> +#define SERPENT_GLUE (func) \ +asmlinkage void func(struct serpent_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void func ## _glue(void *ctx, u8 *dst, const u8 *src) \ +{ func((struct serpent_ctx *) ctx, dst, src); } + +#define SERPENT_GLUE_CBC (func, helper) \ +asmlinkage void func(struct serpent_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void helper(void *ctx, u128 *dst, const u128 *src) \ +{ func((struct serpent_ctx *) ctx, (u8 *) dst, (u8 *) src); } +#ifdef CONFIG_X86_32 #define SERPENT_PARALLEL_BLOCKS 4
Signature · 1 line
2.16.4
RFC PATCH v2 2/4 Fix camellia crypto functions prototype casts
In reply to Joao MoreiraAdd macros that generate glue functions for camellia crypto functions.
Remove GLUE_FUNC_CAST macros from function pointer assignement and use the helper instead, making the prototypes compliant.
--- arch/x86/crypto/camellia_aesni_avx2_glue.c | 69 ++++++++-------------- arch/x86/crypto/camellia_aesni_avx_glue.c | 45 +++++++-------- arch/x86/crypto/camellia_glue.c | 19 +++--- arch/x86/include/asm/crypto/camellia.h | 93 +++++++++++++++--------------- 4 files changed, 101 insertions(+), 125 deletions(-)
arch/x86/crypto/camellia_aesni_avx2_glue.c +25 -44
@@ -23,38 +23,22 @@#define CAMELLIA_AESNI_PARALLEL_BLOCKS 16#define CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS 32 -/* 32-way AVX2/AES-NI parallel cipher functions */ -asmlinkage void camellia_ecb_enc_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void camellia_ecb_dec_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src); - -asmlinkage void camellia_cbc_dec_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void camellia_ctr_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); - -asmlinkage void camellia_xts_enc_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void camellia_xts_dec_32way(struct camellia_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -static const struct common_glue_ctx camellia_enc = { .num_funcs =4 , .fpu_blocks_limit =CAMELLIA_AESNI_PARALLEL_BLOCKS , .funcs = { { .num_blocks =CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS , - .fn_u = { .ecb =GLUE_FUNC_CAST (camellia_ecb_enc_32way) } + .fn_u = { .ecb = camellia_ecb_enc_32way_glue } }, { .num_blocks =CAMELLIA_AESNI_PARALLEL_BLOCKS , - .fn_u = { .ecb =GLUE_FUNC_CAST (camellia_ecb_enc_16way) } + .fn_u = { .ecb = camellia_ecb_enc_16way_glue } }, { .num_blocks =2 , - .fn_u = { .ecb =GLUE_FUNC_CAST (camellia_enc_blk_2way) } + .fn_u = { .ecb = camellia_enc_blk_2way } }, { .num_blocks =1 , - .fn_u = { .ecb =GLUE_FUNC_CAST (camellia_enc_blk) } + .fn_u = { .ecb = camellia_enc_blk } } } };
@@ -64,16 +48,16 @@ static const struct common_glue_ctx camellia_ctr = { .funcs = { { .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_32way) } + .fn_u = { .ctr = camellia_ctr_32way_glue } }, { .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_16way) } + .fn_u = { .ctr = camellia_ctr_16way_glue } }, { .num_blocks = 2, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) } + .fn_u = { .ctr = camellia_crypt_ctr_2way } }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) } + .fn_u = { .ctr = camellia_crypt_ctr } } } };
@@ -83,13 +67,13 @@ static const struct common_glue_ctx camellia_enc_xts = { .funcs = { { .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc_32way) } + .fn_u = { .xts = camellia_xts_enc_32way_glue } }, { .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc_16way) } + .fn_u = { .xts = camellia_xts_enc_16way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc) } + .fn_u = { .xts = camellia_xts_enc } } } };
@@ -99,16 +83,16 @@ static const struct common_glue_ctx camellia_dec = { .funcs = { { .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_32way) } + .fn_u = { .ecb = camellia_ecb_dec_32way_glue } }, { .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_16way) } + .fn_u = { .ecb = camellia_ecb_dec_16way_glue } }, { .num_blocks = 2, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) } + .fn_u = { .ecb = camellia_dec_blk_2way_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) } + .fn_u = { .ecb = camellia_dec_blk_glue } } } };
@@ -118,16 +102,16 @@ static const struct common_glue_ctx camellia_dec_cbc = { .funcs = { { .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_32way) } + .fn_u = { .cbc = camellia_cbc_dec_32way_glue } }, { .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_16way) } + .fn_u = { .cbc = camellia_cbc_dec_16way_glue } }, { .num_blocks = 2, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) } + .fn_u = { .cbc = camellia_decrypt_cbc_2way } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) } + .fn_u = { .cbc = camellia_dec_cbc_blk_glue } } } };
@@ -137,13 +121,13 @@ static const struct common_glue_ctx camellia_dec_xts = { .funcs = { { .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec_32way) } + .fn_u = { .xts = camellia_xts_dec_32way_glue } }, { .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec_16way) } + .fn_u = { .xts = camellia_xts_dec_16way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec) } + .fn_u = { .xts = camellia_xts_dec } } } };
@@ -166,8 +150,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (camellia_enc_blk), - req); +return glue_cbc_encrypt_req_128bit (camellia_enc_blk, req); }static int cbc_decrypt (struct skcipher_request *req)
@@ -185,8 +168,7 @@ static int xts_encrypt(struct skcipher_request *req)struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct camellia_xts_ctx *ctx =crypto_skcipher_ctx (tfm); -return glue_xts_req_128bit (&camellia_enc_xts, req, -XTS_TWEAK_CAST (camellia_enc_blk), +return glue_xts_req_128bit (&camellia_enc_xts, req, camellia_enc_blk, &ctx->tweak_ctx, &ctx->crypt_ctx); }
@@ -195,8 +177,7 @@ static int xts_decrypt(struct skcipher_request *req)struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req);struct camellia_xts_ctx *ctx =crypto_skcipher_ctx (tfm); -return glue_xts_req_128bit (&camellia_dec_xts, req, -XTS_TWEAK_CAST (camellia_enc_blk), +return glue_xts_req_128bit (&camellia_dec_xts, req, camellia_enc_blk, &ctx->tweak_ctx, &ctx->crypt_ctx); }
arch/x86/crypto/camellia_aesni_avx_glue.c +21 -24
130 lines not on this page · raw message
arch/x86/crypto/camellia_glue.c +9 -10
@@ -1330,10 +1330,10 @@ static const struct common_glue_ctx camellia_enc = { .funcs = { { .num_blocks = 2, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) } + .fn_u = { .ecb = camellia_enc_blk_2way } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) } + .fn_u = { .ecb = camellia_enc_blk } } } };
@@ -1343,10 +1343,10 @@ static const struct common_glue_ctx camellia_ctr = { .funcs = { { .num_blocks = 2, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) } + .fn_u = { .ctr = camellia_crypt_ctr_2way } }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) } + .fn_u = { .ctr = camellia_crypt_ctr } } } };
@@ -1356,10 +1356,10 @@ static const struct common_glue_ctx camellia_dec = { .funcs = { { .num_blocks = 2, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) } + .fn_u = { .ecb = camellia_dec_blk_2way_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) } + .fn_u = { .ecb = camellia_dec_blk_glue } } } };
@@ -1369,10 +1369,10 @@ static const struct common_glue_ctx camellia_dec_cbc = { .funcs = { { .num_blocks = 2, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) } + .fn_u = { .cbc = camellia_decrypt_cbc_2way } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) } + .fn_u = { .cbc = camellia_dec_cbc_blk_glue } } } };
@@ -1388,8 +1388,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (camellia_enc_blk), - req); +return glue_cbc_encrypt_req_128bit (camellia_enc_blk, req); }static int cbc_decrypt (struct skcipher_request *req)
arch/x86/include/asm/crypto/camellia.h +46 -47
116 lines not on this page · raw message
Signature · 1 line
2.16.4
RFC PATCH v2 3/4 Fix twofish crypto functions prototype casts
In reply to Joao MoreiraAdd macros that generate glue functions for twofish crypto functions.
Remove GLUE_FUNC_CAST macros from function pointer assignement and use the helper instead, making the prototypes compliant.
RFC: twofish_enc_blk_ctr_3way is assigned both to .ecb and to .ctr, what makes its declaration through the macro undoable, as thought in this patch. Suggestions on how to fix this are welcome.
--- arch/x86/crypto/twofish_avx_glue.c | 65 ++++++++++++++++------------------- arch/x86/crypto/twofish_glue_3way.c | 33 +++++++++--------- arch/x86/include/asm/crypto/twofish.h | 33 +++++++++++++----- 3 files changed, 71 insertions(+), 60 deletions(-)
arch/x86/crypto/twofish_avx_glue.c +30 -35
@@ -37,20 +37,19 @@#define TWOFISH_PARALLEL_BLOCKS 8/* 8-way parallel cipher functions */ -asmlinkage void twofish_ecb_enc_8way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void twofish_ecb_dec_8way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src); +TWOFISH_GLUE (twofish_ecb_enc_8way, twofish_ecb_enc_8way_glue); +TWOFISH_GLUE (twofish_ecb_dec_8way, twofish_ecb_dec_8way_glue); +TWOFISH_GLUE_CTR (twofish_ctr_8way, twofish_ctr_8way_glue); +TWOFISH_GLUE_CTR (twofish_enc_blk_ctr, twofish_enc_blk_ctr_glue); +TWOFISH_GLUE_XTS (twofish_xts_enc_8way, twofish_xts_enc_8way_glue); +TWOFISH_GLUE_XTS (twofish_xts_dec_8way, twofish_xts_dec_8way_glue); +TWOFISH_GLUE_CBC (twofish_cbc_dec_8way, twofish_cbc_dec_8way_glue); asmlinkage void twofish_cbc_dec_8way(struct twofish_ctx *ctx, u8 *dst,const u8 *src); -asmlinkage void twofish_ctr_8way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void twofish_xts_enc_8way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void twofish_xts_dec_8way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); +asmlinkage void twofish_xts_dec_8way(struct twofish_ctx *ctx, u128 *dst, +const u128 *src,le128 *iv);static int twofish_setkey_skcipher (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen)
@@ -58,22 +57,19 @@ static int twofish_setkey_skcipher(struct crypto_skcipher *tfm,return twofish_setkey (&tfm->base, key, keylen); } -static inline void twofish_enc_blk_3way (struct twofish_ctx *ctx,u8 *dst, -const u8 *src) +static inline void twofish_enc_blk_3way (void *ctx,u8 *dst,const u8 *src) { -__twofish_enc_blk_3way (ctx, dst, src, false); +__twofish_enc_blk_3way ((struct twofish_ctx *) ctx, dst, src, false); }static void twofish_xts_enc (void *ctx,u128 *dst,const u128 *src,le128 *iv) { -glue_xts_crypt_128bit_one (ctx, dst, src, iv, -GLUE_FUNC_CAST (twofish_enc_blk)); +glue_xts_crypt_128bit_one (ctx, dst, src, iv, twofish_enc_blk_glue); }static void twofish_xts_dec (void *ctx,u128 *dst,const u128 *src,le128 *iv) { -glue_xts_crypt_128bit_one (ctx, dst, src, iv, -GLUE_FUNC_CAST (twofish_dec_blk)); +glue_xts_crypt_128bit_one (ctx, dst, src, iv, twofish_dec_blk_glue); }struct twofish_xts_ctx {
@@ -108,13 +104,13 @@ static const struct common_glue_ctx twofish_enc = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_ecb_enc_8way) } + .fn_u = { .ecb = twofish_ecb_enc_8way_glue } }, { .num_blocks = 3, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_3way) } + .fn_u = { .ecb = twofish_enc_blk_3way } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk) } + .fn_u = { .ecb = twofish_enc_blk_glue } } } };
@@ -124,13 +120,13 @@ static const struct common_glue_ctx twofish_ctr = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_ctr_8way) } + .fn_u = { .ctr = twofish_ctr_8way_glue } }, { .num_blocks = 3, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_enc_blk_ctr_3way) } + .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_enc_blk_ctr_3way)} }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_enc_blk_ctr) } + .fn_u = { .ctr = twofish_enc_blk_ctr_glue } } } };
@@ -140,10 +136,10 @@ static const struct common_glue_ctx twofish_enc_xts = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_enc_8way) } + .fn_u = { .xts = twofish_xts_enc_8way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_enc) } + .fn_u = { .xts = twofish_xts_enc } } } };
@@ -153,13 +149,13 @@ static const struct common_glue_ctx twofish_dec = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_ecb_dec_8way) } + .fn_u = { .ecb = twofish_ecb_dec_8way_glue } }, { .num_blocks = 3, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk_3way) } + .fn_u = { .ecb = twofish_dec_blk_3way_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk) } + .fn_u = { .ecb = twofish_dec_blk_glue } } } };
@@ -169,13 +165,13 @@ static const struct common_glue_ctx twofish_dec_cbc = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_cbc_dec_8way) } + .fn_u = { .cbc = twofish_cbc_dec_8way_glue } }, { .num_blocks = 3, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk_cbc_3way) } + .fn_u = { .cbc = twofish_dec_blk_cbc_3way } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk) } + .fn_u = { .cbc = twofish_dec_blk_cbc_glue } } } };
@@ -185,10 +181,10 @@ static const struct common_glue_ctx twofish_dec_xts = { .funcs = { { .num_blocks = TWOFISH_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_dec_8way) } + .fn_u = { .xts = twofish_xts_dec_8way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_dec) } + .fn_u = { .xts = twofish_xts_dec } } } };
@@ -204,8 +200,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (twofish_enc_blk), - req); +return glue_cbc_encrypt_req_128bit (twofish_enc_blk_glue, req); }static int cbc_decrypt (struct skcipher_request *req)
arch/x86/crypto/twofish_glue_3way.c +17 -16
@@ -31,6 +31,8 @@#include <linux/module.h> #include <linux/types.h> +TWOFISH_GLUE_CTR(twofish_enc_blk_ctr, twofish_enc_blk_ctr_glue) +EXPORT_SYMBOL_GPL (__twofish_enc_blk_3way);EXPORT_SYMBOL_GPL (twofish_dec_blk_3way);
@@ -40,10 +42,9 @@ static int twofish_setkey_skcipher(struct crypto_skcipher *tfm,return twofish_setkey (&tfm->base, key, keylen); } -static inline void twofish_enc_blk_3way (struct twofish_ctx *ctx,u8 *dst, -const u8 *src) +static inline void twofish_enc_blk_3way (void *ctx,u8 *dst,const u8 *src) { -__twofish_enc_blk_3way (ctx, dst, src, false); +__twofish_enc_blk_3way ((struct twofish_ctx *) ctx, dst, src, false); } static inline void twofish_enc_blk_xor_3way(struct twofish_ctx *ctx, u8 *dst,
@@ -66,7 +67,8 @@ void twofish_dec_blk_cbc_3way(void *ctx, u128 *dst, const u128 *src) }EXPORT_SYMBOL_GPL (twofish_dec_blk_cbc_3way); -void twofish_enc_blk_ctr (void *ctx,u128 *dst,const u128 *src,le128 *iv) +void twofish_enc_blk_ctr (struct twofish_ctx *ctx,u128 *dst,const u128 *src, +le128 *iv) {be128 ctrblk;
@@ -81,8 +83,8 @@ void twofish_enc_blk_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv) }EXPORT_SYMBOL_GPL (twofish_enc_blk_ctr); -void twofish_enc_blk_ctr_3way (void *ctx,u128 *dst,const u128 *src, -le128 *iv) +void twofish_enc_blk_ctr_3way (void *ctx,u128 *dst, +const u128 *src,le128 *iv) {be128 ctrblks[3 ];
@@ -109,10 +111,10 @@ static const struct common_glue_ctx twofish_enc = { .funcs = { { .num_blocks = 3, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_3way) } + .fn_u = { .ecb = twofish_enc_blk_3way } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk) } + .fn_u = { .ecb = twofish_enc_blk_glue } } } };
@@ -122,10 +124,10 @@ static const struct common_glue_ctx twofish_ctr = { .funcs = { { .num_blocks = 3, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr_3way) } + .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr_3way)} }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr) } + .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr)} } } };
@@ -135,10 +137,10 @@ static const struct common_glue_ctx twofish_dec = { .funcs = { { .num_blocks = 3, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk_3way) } + .fn_u = { .ecb = twofish_dec_blk_3way_glue} }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk) } + .fn_u = { .ecb = twofish_dec_blk_glue} } } };
@@ -148,10 +150,10 @@ static const struct common_glue_ctx twofish_dec_cbc = { .funcs = { { .num_blocks = 3, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk_cbc_3way) } + .fn_u = { .cbc = twofish_dec_blk_cbc_3way } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk) } + .fn_u = { .cbc = twofish_dec_blk_cbc_glue } } } };
@@ -167,8 +169,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (twofish_enc_blk), - req); +return glue_cbc_encrypt_req_128bit (twofish_enc_blk_glue, req); }static int cbc_decrypt (struct skcipher_request *req)
arch/x86/include/asm/crypto/twofish.h +24 -9
@@ -6,22 +6,37 @@#include <crypto/twofish.h> #include <crypto/b128ops.h> -/* regular block cipher functions from twofish_x86_64 module */ -asmlinkage void twofish_enc_blk(struct twofish_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void twofish_dec_blk(struct twofish_ctx *ctx, u8 *dst, -const u8 *src); +#define TWOFISH_GLUE (func, helper) \ +asmlinkage void func(struct twofish_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void helper(void *ctx, u8 *dst, const u8 *src) \ +{ func((struct twofish_ctx *) ctx, dst, src); } + +#define TWOFISH_GLUE_CBC (func, helper) \ +asmlinkage void func(struct twofish_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void helper(void *ctx, u128 *dst, \ + const u128 *src) \ +{ func((struct twofish_ctx *) ctx, (u8 *) dst, (u8 *) src); } + +#define TWOFISH_GLUE_CTR (func, helper) \ +asmlinkage void func(struct twofish_ctx *ctx, u128 *dst, const u128 *src, \ + le128 *iv); \ +asmlinkage static inline void helper(void *ctx, u128 *dst, \ + const u128 *src, le128 *iv) \ +{ func((struct twofish_ctx *) ctx, dst, src, iv); } + +#define TWOFISH_GLUE_XTS (func, helper) TWOFISH_GLUE_CTR(func, helper) + +TWOFISH_GLUE (twofish_enc_blk, twofish_enc_blk_glue); +TWOFISH_GLUE (twofish_dec_blk, twofish_dec_blk_glue); +TWOFISH_GLUE_CBC (twofish_dec_blk, twofish_dec_blk_cbc_glue); +TWOFISH_GLUE(twofish_dec_blk_3way, twofish_dec_blk_3way_glue) /* 3-way parallel cipher functions */ asmlinkage void __twofish_enc_blk_3way(struct twofish_ctx *ctx, u8 *dst,const u8 *src,bool xor); -asmlinkage void twofish_dec_blk_3way(struct twofish_ctx *ctx, u8 *dst, -const u8 *src);/* helpers from twofish_x86_64-3way module */ extern void twofish_dec_blk_cbc_3way (void *ctx,u128 *dst,const u128 *src); -extern void twofish_enc_blk_ctr (void *ctx,u128 *dst,const u128 *src, -le128 *iv);extern void twofish_enc_blk_ctr_3way (void *ctx,u128 *dst,const u128 *src,le128 *iv);
Signature · 1 line
2.16.4
Re: [RFC PATCH v2 3/4] Fix twofish crypto functions prototype casts
Quoted 3 lines · Joao Moreira
RFC:
twofish_enc_blk_ctr_3wayis assigned both to .ecb and to .ctr, what makes its declaration through the macro undoable, as thought in this patch. Suggestions on how to fix this are welcome.
This looks like a typo in the original code (due to the lack of type checking!)
typedef void (*common_glue_func_t)(void *ctx, u8 *dst, const u8 *src);
...
#define GLUE_FUNC_CAST(fn) ((common_glue_func_t)(fn))
...
void twofish_enc_blk_ctr_3way(void *ctx, u128 *dst, const u128 *src,
le128 *iv)
static const struct common_glue_ctx twofish_ctr = {
...
.fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr_3way) }
...
return glue_ctr_req_128bit(&twofish_ctr, req);int glue_ctr_req_128bit(const struct common_glue_ctx *gctx,
struct skcipher_request *req)
...
gctx->funcs[i].fn_u.ctr(ctx, dst, src, &ctrblk);
The twofish_ctr structure is actually only ever using the .ctr assignment in the code, but it's a union, so the assignment via .ecb is the same as .ctr.
Signature · 1 line
Kees Cook
RFC PATCH v2 4/4 Fix cast6 crypto functions prototype casts
In reply to Joao MoreiraAdd macros that generate glue functions for cast6 crypto functions.
Remove GLUE_FUNC_CAST macros from function pointer assignement and use the helper instead, making the prototypes compliant.
--- arch/x86/crypto/cast6_avx_glue.c | 54 ++++++++++++++++------------------------ include/crypto/cast6.h | 23 +++++++++++++++-- 2 files changed, 43 insertions(+), 34 deletions(-)
arch/x86/crypto/cast6_avx_glue.c +22 -32
@@ -35,20 +35,13 @@#define CAST6_PARALLEL_BLOCKS 8 -asmlinkage void cast6_ecb_enc_8way(struct cast6_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void cast6_ecb_dec_8way(struct cast6_ctx *ctx, u8 *dst, -const u8 *src); - -asmlinkage void cast6_cbc_dec_8way(struct cast6_ctx *ctx, u8 *dst, -const u8 *src); -asmlinkage void cast6_ctr_8way(struct cast6_ctx *ctx, u8 *dst, const u8 *src, -le128 *iv); - -asmlinkage void cast6_xts_enc_8way(struct cast6_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); -asmlinkage void cast6_xts_dec_8way(struct cast6_ctx *ctx, u8 *dst, -const u8 *src,le128 *iv); +CAST6_GLUE (cast6_ecb_enc_8way); +CAST6_GLUE (cast6_ecb_dec_8way); +CAST6_GLUE_CTR (cast6_ctr_8way); +CAST6_GLUE_XTS (cast6_xts_enc_8way); +CAST6_GLUE_XTS (cast6_xts_dec_8way); +CAST6_GLUE_CBC (cast6_cbc_dec_8way, cast6_cbc_dec_8way_glue); +CAST6_GLUE_CBC (__cast6_decrypt, __cast6_decrypt_cbc_glue);static int cast6_setkey_skcipher (struct crypto_skcipher *tfm,const u8 *key,unsigned int keylen)
@@ -58,14 +51,12 @@ static int cast6_setkey_skcipher(struct crypto_skcipher *tfm,static void cast6_xts_enc (void *ctx,u128 *dst,const u128 *src,le128 *iv) { -glue_xts_crypt_128bit_one (ctx, dst, src, iv, -GLUE_FUNC_CAST (__cast6_encrypt)); +glue_xts_crypt_128bit_one (ctx, dst, src, iv, __cast6_encrypt_glue); }static void cast6_xts_dec (void *ctx,u128 *dst,const u128 *src,le128 *iv) { -glue_xts_crypt_128bit_one (ctx, dst, src, iv, -GLUE_FUNC_CAST (__cast6_decrypt)); +glue_xts_crypt_128bit_one (ctx, dst, src, iv, __cast6_decrypt_glue); }static void cast6_crypt_ctr (void *ctx,u128 *dst,const u128 *src,le128 *iv)
@@ -85,10 +76,10 @@ static const struct common_glue_ctx cast6_enc = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(cast6_ecb_enc_8way) } + .fn_u = { .ecb = cast6_ecb_enc_8way_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__cast6_encrypt) } + .fn_u = { .ecb = __cast6_encrypt_glue } } } };
@@ -98,10 +89,10 @@ static const struct common_glue_ctx cast6_ctr = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(cast6_ctr_8way) } + .fn_u = { .ctr = cast6_ctr_8way_glue } }, { .num_blocks = 1, - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(cast6_crypt_ctr) } + .fn_u = { .ctr = cast6_crypt_ctr } } } };
@@ -111,10 +102,10 @@ static const struct common_glue_ctx cast6_enc_xts = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_enc_8way) } + .fn_u = { .xts = cast6_xts_enc_8way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_enc) } + .fn_u = { .xts = cast6_xts_enc } } } };
@@ -124,10 +115,10 @@ static const struct common_glue_ctx cast6_dec = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .ecb = GLUE_FUNC_CAST(cast6_ecb_dec_8way) } + .fn_u = { .ecb = cast6_ecb_dec_8way_glue } }, { .num_blocks = 1, - .fn_u = { .ecb = GLUE_FUNC_CAST(__cast6_decrypt) } + .fn_u = { .ecb = __cast6_decrypt_glue } } } };
@@ -137,10 +128,10 @@ static const struct common_glue_ctx cast6_dec_cbc = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(cast6_cbc_dec_8way) } + .fn_u = { .cbc = cast6_cbc_dec_8way_glue } }, { .num_blocks = 1, - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__cast6_decrypt) } + .fn_u = { .cbc = __cast6_decrypt_cbc_glue } } } };
@@ -150,10 +141,10 @@ static const struct common_glue_ctx cast6_dec_xts = { .funcs = { { .num_blocks = CAST6_PARALLEL_BLOCKS, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_dec_8way) } + .fn_u = { .xts = cast6_xts_dec_8way_glue } }, { .num_blocks = 1, - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_dec) } + .fn_u = { .xts = cast6_xts_dec } } } };
@@ -169,8 +160,7 @@ static int ecb_decrypt(struct skcipher_request *req)static int cbc_encrypt (struct skcipher_request *req) { -return glue_cbc_encrypt_req_128bit (GLUE_FUNC_CAST (__cast6_encrypt), - req); +return glue_cbc_encrypt_req_128bit (__cast6_encrypt_glue, req); }static int cbc_decrypt (struct skcipher_request *req)
include/crypto/cast6.h +21 -2
@@ -10,6 +10,25 @@#define CAST6_MIN_KEY_SIZE 16#define CAST6_MAX_KEY_SIZE 32 +#define CAST6_GLUE (func) \ +asmlinkage void func(struct cast6_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void func ## _glue(void *ctx, u8 *dst, const u8 *src) \ +{ func((struct cast6_ctx *) ctx, dst, src); } + +#define CAST6_GLUE_CBC (func, helper) \ +asmlinkage void func(struct cast6_ctx *ctx, u8 *dst, const u8 *src); \ +asmlinkage static inline void helper(void *ctx, u128 *dst, const u128 *src) \ +{ func((struct cast6_ctx *) ctx, (u8 *) dst, (u8 *) src); } + +#define CAST6_GLUE_CTR (func) \ +asmlinkage void func(struct cast6_ctx *ctx, u8 *dst, const u8 *src, le128 *iv);\ +asmlinkage static inline void func ## _glue(void *ctx, u128 *dst, \ + const u128 *src, le128 *iv) \ +{ func((struct cast6_ctx *) ctx, (u8 *) dst, (u8 *) src, iv); } + +#define CAST6_GLUE_XTS (func) CAST6_GLUE_CTR(func) + +struct cast6_ctx {u32 Km[12 ][4 ];u8 Kr[12 ][4 ];
@@ -19,7 +38,7 @@ int __cast6_setkey(struct cast6_ctx *ctx, const u8 *key, unsigned int keylen, u32 *flags);int cast6_setkey (struct crypto_tfm *tfm,const u8 *key,unsigned int keylen); -void __cast6_encrypt (struct cast6_ctx *ctx,u8 *dst,const u8 *src); -void __cast6_decrypt (struct cast6_ctx *ctx,u8 *dst,const u8 *src); +CAST6_GLUE (__cast6_encrypt); +CAST6_GLUE (__cast6_decrypt);#endif
Signature · 1 line
2.16.4
Quoted 15 lines · Joao Moreira
It is possible to indirectly invoke functions with prototypes that do not match those of the respectively used function pointers by using void types. This feature is frequently used as a way of relaxing function invocation, making it possible that different data structures are passed to different functions through the same pointer.
Despite the benefits, this can lead to a situation where functions with a given prototype are invoked by pointers with a different prototype, what is undesirable as it may prevent the use of heuristics such as prototype matching-based Control-Flow Integrity, which can be used to prevent ROP-based attacks.
One way of fixing this situation is through the use of helper functions with prototypes that match the one in the respective invoking pointer.
Quoted 8 lines
Given the above, the current efforts to improve the Linux security, and the upcoming kernel support to compilers with CFI features, fix the prototype casting of x86/crypto algorithms camellia, cast6, serpent and twofish with the use of a macro that generates the helper function.
This patch does not introduce semantic changes to the cryptographic algorithms, yet, if someone finds relevant, the affected algorithms were tested with the help of tcrypt.ko without any visible harm.
Awesome; thanks for working on this! I'm looking through the patches now and pondering solutions to the RFC in twofish. I'll send notes in a bit...
Signature · 1 line
Kees Cook