Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: skcipher - Make skcipher_walk src.virt.addr const
Mark the src.virt.addr field in struct skcipher_walk as a pointer
to const data. This guarantees that the user won't modify the data
which should be done through dst.virt.addr to ensure that flushing
is done when necessary.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+33
-32
+1
-1
arch/arm/crypto/aes-ce-glue.c
+1
-1
arch/arm/crypto/aes-ce-glue.c
···
399
399
}
400
400
if (walk.nbytes) {
401
401
u8 __aligned(8) tail[AES_BLOCK_SIZE];
402
+
const u8 *tsrc = walk.src.virt.addr;
402
403
unsigned int nbytes = walk.nbytes;
403
404
u8 *tdst = walk.dst.virt.addr;
404
-
u8 *tsrc = walk.src.virt.addr;
405
405
406
406
/*
407
407
* Tell aes_ctr_encrypt() to process a tail block.
+2
-1
arch/arm64/crypto/aes-neonbs-glue.c
+2
-1
arch/arm64/crypto/aes-neonbs-glue.c
+3
-3
arch/powerpc/crypto/aes-gcm-p10-glue.c
+3
-3
arch/powerpc/crypto/aes-gcm-p10-glue.c
···
35
35
asmlinkage int aes_p10_set_encrypt_key(const u8 *userKey, const int bits,
36
36
void *key);
37
37
asmlinkage void aes_p10_encrypt(const u8 *in, u8 *out, const void *key);
38
-
asmlinkage void aes_p10_gcm_encrypt(u8 *in, u8 *out, size_t len,
38
+
asmlinkage void aes_p10_gcm_encrypt(const u8 *in, u8 *out, size_t len,
39
39
void *rkey, u8 *iv, void *Xi);
40
-
asmlinkage void aes_p10_gcm_decrypt(u8 *in, u8 *out, size_t len,
40
+
asmlinkage void aes_p10_gcm_decrypt(const u8 *in, u8 *out, size_t len,
41
41
void *rkey, u8 *iv, void *Xi);
42
42
asmlinkage void gcm_init_htable(unsigned char htable[], unsigned char Xi[]);
43
43
asmlinkage void gcm_ghash_p10(unsigned char *Xi, unsigned char *Htable,
···
261
261
return ret;
262
262
263
263
while ((nbytes = walk.nbytes) > 0 && ret == 0) {
264
-
u8 *src = walk.src.virt.addr;
264
+
const u8 *src = walk.src.virt.addr;
265
265
u8 *dst = walk.dst.virt.addr;
266
266
u8 buf[AES_BLOCK_SIZE];
267
267
+1
-1
arch/powerpc/crypto/aes_ctr.c
+1
-1
arch/powerpc/crypto/aes_ctr.c
···
69
69
static void p8_aes_ctr_final(const struct p8_aes_ctr_ctx *ctx,
70
70
struct skcipher_walk *walk)
71
71
{
72
+
const u8 *src = walk->src.virt.addr;
72
73
u8 *ctrblk = walk->iv;
73
74
u8 keystream[AES_BLOCK_SIZE];
74
-
u8 *src = walk->src.virt.addr;
75
75
u8 *dst = walk->dst.virt.addr;
76
76
unsigned int nbytes = walk->nbytes;
77
77
+1
-1
arch/sparc/crypto/aes_glue.c
+1
-1
arch/sparc/crypto/aes_glue.c
+1
-1
arch/x86/crypto/des3_ede_glue.c
+1
-1
arch/x86/crypto/des3_ede_glue.c
+5
-5
crypto/ctr.c
+5
-5
crypto/ctr.c
···
33
33
u8 *ctrblk = walk->iv;
34
34
u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
35
35
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
36
-
u8 *src = walk->src.virt.addr;
36
+
const u8 *src = walk->src.virt.addr;
37
37
u8 *dst = walk->dst.virt.addr;
38
38
unsigned int nbytes = walk->nbytes;
39
39
···
50
50
crypto_cipher_alg(tfm)->cia_encrypt;
51
51
unsigned int bsize = crypto_cipher_blocksize(tfm);
52
52
u8 *ctrblk = walk->iv;
53
-
u8 *src = walk->src.virt.addr;
53
+
const u8 *src = walk->src.virt.addr;
54
54
u8 *dst = walk->dst.virt.addr;
55
55
unsigned int nbytes = walk->nbytes;
56
56
···
77
77
unsigned int bsize = crypto_cipher_blocksize(tfm);
78
78
unsigned long alignmask = crypto_cipher_alignmask(tfm);
79
79
unsigned int nbytes = walk->nbytes;
80
+
u8 *dst = walk->dst.virt.addr;
80
81
u8 *ctrblk = walk->iv;
81
-
u8 *src = walk->src.virt.addr;
82
82
u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
83
83
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
84
84
85
85
do {
86
86
/* create keystream */
87
87
fn(crypto_cipher_tfm(tfm), keystream, ctrblk);
88
-
crypto_xor(src, keystream, bsize);
88
+
crypto_xor(dst, keystream, bsize);
89
89
90
90
/* increment counter in counterblock */
91
91
crypto_inc(ctrblk, bsize);
92
92
93
-
src += bsize;
93
+
dst += bsize;
94
94
} while ((nbytes -= bsize) >= bsize);
95
95
96
96
return nbytes;
+1
-1
crypto/lrw.c
+1
-1
crypto/lrw.c
+14
-14
crypto/pcbc.c
+14
-14
crypto/pcbc.c
···
22
22
struct crypto_cipher *tfm)
23
23
{
24
24
int bsize = crypto_cipher_blocksize(tfm);
25
+
const u8 *src = walk->src.virt.addr;
25
26
unsigned int nbytes = walk->nbytes;
26
-
u8 *src = walk->src.virt.addr;
27
27
u8 *dst = walk->dst.virt.addr;
28
28
u8 * const iv = walk->iv;
29
29
···
45
45
{
46
46
int bsize = crypto_cipher_blocksize(tfm);
47
47
unsigned int nbytes = walk->nbytes;
48
-
u8 *src = walk->src.virt.addr;
48
+
u8 *dst = walk->dst.virt.addr;
49
49
u8 * const iv = walk->iv;
50
50
u8 tmpbuf[MAX_CIPHER_BLOCKSIZE];
51
51
52
52
do {
53
-
memcpy(tmpbuf, src, bsize);
54
-
crypto_xor(iv, src, bsize);
55
-
crypto_cipher_encrypt_one(tfm, src, iv);
56
-
crypto_xor_cpy(iv, tmpbuf, src, bsize);
53
+
memcpy(tmpbuf, dst, bsize);
54
+
crypto_xor(iv, dst, bsize);
55
+
crypto_cipher_encrypt_one(tfm, dst, iv);
56
+
crypto_xor_cpy(iv, tmpbuf, dst, bsize);
57
57
58
-
src += bsize;
58
+
dst += bsize;
59
59
} while ((nbytes -= bsize) >= bsize);
60
60
61
61
return nbytes;
···
89
89
struct crypto_cipher *tfm)
90
90
{
91
91
int bsize = crypto_cipher_blocksize(tfm);
92
+
const u8 *src = walk->src.virt.addr;
92
93
unsigned int nbytes = walk->nbytes;
93
-
u8 *src = walk->src.virt.addr;
94
94
u8 *dst = walk->dst.virt.addr;
95
95
u8 * const iv = walk->iv;
96
96
···
112
112
{
113
113
int bsize = crypto_cipher_blocksize(tfm);
114
114
unsigned int nbytes = walk->nbytes;
115
-
u8 *src = walk->src.virt.addr;
115
+
u8 *dst = walk->dst.virt.addr;
116
116
u8 * const iv = walk->iv;
117
117
u8 tmpbuf[MAX_CIPHER_BLOCKSIZE] __aligned(__alignof__(u32));
118
118
119
119
do {
120
-
memcpy(tmpbuf, src, bsize);
121
-
crypto_cipher_decrypt_one(tfm, src, src);
122
-
crypto_xor(src, iv, bsize);
123
-
crypto_xor_cpy(iv, src, tmpbuf, bsize);
120
+
memcpy(tmpbuf, dst, bsize);
121
+
crypto_cipher_decrypt_one(tfm, dst, dst);
122
+
crypto_xor(dst, iv, bsize);
123
+
crypto_xor_cpy(iv, dst, tmpbuf, bsize);
124
124
125
-
src += bsize;
125
+
dst += bsize;
126
126
} while ((nbytes -= bsize) >= bsize);
127
127
128
128
return nbytes;
+1
-1
crypto/xctr.c
+1
-1
crypto/xctr.c
···
78
78
crypto_cipher_alg(tfm)->cia_encrypt;
79
79
unsigned long alignmask = crypto_cipher_alignmask(tfm);
80
80
unsigned int nbytes = walk->nbytes;
81
-
u8 *data = walk->src.virt.addr;
81
+
u8 *data = walk->dst.virt.addr;
82
82
u8 tmp[XCTR_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
83
83
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
84
84
__le32 ctr32 = cpu_to_le32(byte_ctr / XCTR_BLOCKSIZE + 1);
+1
-1
crypto/xts.c
+1
-1
crypto/xts.c
+1
-1
include/crypto/ctr.h
+1
-1
include/crypto/ctr.h