Skip to contentSkip to conversation

crypto: arm64/chacha - correctly walk through blocks

PATCH Superseded Jason A. Donenfeld 3 participants 11 messages Mar 18, 2020 – Mar 20, 2020

Subsystems (4)
lore
Share & tools
lore

Jason A. Donenfeld

author maintainer
#0 lore raw

PATCH 1/1 crypto: arm64/chacha - correctly walk through blocks

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln, dating back to 2018. WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed.

Fixes f2ca1cbd0fb5 ("crypto: arm64/chacha - optimize for arbitrary length inputs")
Cc Ard Biesheuvel <[email protected]>
---
 arch/arm64/crypto/chacha-neon-glue.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
arch/arm64/crypto/chacha-neon-glue.c +4 -4
index c1f9660d104c..debb1de0d3dd 100644
@@ -55,10 +55,10 @@ static void chacha_doneon(u32 *state, u8 *dst, const u8 *src,
 			break;
 		}
 		chacha_4block_xor_neon(state, dst, src, nrounds, l);
-		bytes -= CHACHA_BLOCK_SIZE * 5;
-		src += CHACHA_BLOCK_SIZE * 5;
-		dst += CHACHA_BLOCK_SIZE * 5;
-		state[12] += 5;
+		bytes -= l;
+		src += l;
+		dst += l;
+		state[12] += round_up(l, CHACHA_BLOCK_SIZE) / CHACHA_BLOCK_SIZE;
 	}
 }
 
Signature · 1 line
2.25.1
maintainer
#1 lore raw

Hi Jason,

Quoted 9 lines · Jason A. Donenfeld

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln, dating back to 2018. WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed.

Quoted 5 lines
Fixes f2ca1cbd0fb5 ("crypto: arm64/chacha - optimize for arbitrary length inputs")
Cc Ard Biesheuvel <[email protected]>

Thanks for fixing this! We definitely should get this fix to Linus for 5.6. But I don't think your description of this bug dating back to 2018 is accurate, because this bug only affects the new library interface to ChaCha20 which was added in v5.5. In the "regular" crypto API case, the "walksize" is set to '5 * CHACHA_BLOCK_SIZE', and chacha_doneon() is guaranteed to be called with a multiple of '5 * CHACHA_BLOCK_SIZE' except at the end. Thus the code worked fine with the regular crypto API.

In fact we have fuzz tests for the regular crypto API which find bugs exactly like these. For example, they try dividing the data up randomly into chunks. It would be great if the new library interface had fuzz tests too.

Quoted 6 lines
arch/arm64/crypto/chacha-neon-glue.c +0 -0
index c1f9660d104c..debb1de0d3dd 100644
@@ -55,10 +55,10 @@ static void chacha_doneon(u32 *state, u8 *dst, const u8 *src,
 			break;

arch/arm64/crypto/chacha-neon-glue.c static void chacha_doneon(u32 *state, u8 *dst, const u8 *src, · line 61

Quoted 10 lines
arch/arm64/crypto/chacha-neon-glue.c +4 -4
 		}
 		chacha_4block_xor_neon(state, dst, src, nrounds, l);
-		bytes -= CHACHA_BLOCK_SIZE * 5;
-		src += CHACHA_BLOCK_SIZE * 5;
-		dst += CHACHA_BLOCK_SIZE * 5;
-		state[12] += 5;
+		bytes -= l;
+		src += l;
+		dst += l;
+		state[12] += round_up(l, CHACHA_BLOCK_SIZE) / CHACHA_BLOCK_SIZE;

Use DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE)?

- Eric

maintainer
#2 lore raw
Quoted 18 lines · Eric Biggers

Hi Jason,

Quoted 9 lines · Jason A. Donenfeld

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln, dating back to 2018. WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed.

Quoted 5 lines
Fixes f2ca1cbd0fb5 ("crypto: arm64/chacha - optimize for arbitrary length inputs")
Cc Ard Biesheuvel <[email protected]>
Quoted 7 lines

Thanks for fixing this! We definitely should get this fix to Linus for 5.6. But I don't think your description of this bug dating back to 2018 is accurate, because this bug only affects the new library interface to ChaCha20 which was added in v5.5. In the "regular" crypto API case, the "walksize" is set to '5 * CHACHA_BLOCK_SIZE', and chacha_doneon() is guaranteed to be called with a multiple of '5 * CHACHA_BLOCK_SIZE' except at the end. Thus the code worked fine with the regular crypto API.

So I think it's actually:

Fixes b3aad5bad26a ("crypto: arm64/chacha - expose arm64 ChaCha routine as library function")
Cc <[email protected]> # v5.5+
author maintainer
#3 lore raw
In reply to Eric Biggers

Hey Eric,

Quoted 7 lines · Eric Biggers

Thanks for fixing this! We definitely should get this fix to Linus for 5.6. But I don't think your description of this bug dating back to 2018 is accurate, because this bug only affects the new library interface to ChaCha20 which was added in v5.5. In the "regular" crypto API case, the "walksize" is set to '5 * CHACHA_BLOCK_SIZE', and chacha_doneon() is guaranteed to be called with a multiple of '5 * CHACHA_BLOCK_SIZE' except at the end. Thus the code worked fine with the regular crypto API.

Ahhh, that seems correct.

Quoted 3 lines
Quoted 1 line

+ state[12] += round_up(l, CHACHA_BLOCK_SIZE) / CHACHA_BLOCK_SIZE;

Use DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE)?

Duh, oops, thanks. Will send a v2 in a few minutes.

By the way, I took a brief look at the other implementations accessible from lib/crypto and I didn't see the same issue over there. But I wouldn't mind an extra pair of eyes, if you want to give it a quick look too.

Jason

author maintainer
#4 lore raw

PATCH v2 1/1 crypto: arm64/chacha - correctly walk through blocks

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln: "why do images look weird on webpages?" WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed. It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

Fixes b3aad5bad26a ("crypto: arm64/chacha - expose arm64 ChaCha routine as library function")
Cc Ard Biesheuvel <[email protected]>
---
 arch/arm64/crypto/chacha-neon-glue.c   |  8 ++++----
 lib/crypto/chacha20poly1305-selftest.c | 11 ++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)
arch/arm64/crypto/chacha-neon-glue.c +4 -4
index c1f9660d104c..37ca3e889848 100644
@@ -55,10 +55,10 @@ static void chacha_doneon(u32 *state, u8 *dst, const u8 *src,
 			break;
 		}
 		chacha_4block_xor_neon(state, dst, src, nrounds, l);
-		bytes -= CHACHA_BLOCK_SIZE * 5;
-		src += CHACHA_BLOCK_SIZE * 5;
-		dst += CHACHA_BLOCK_SIZE * 5;
-		state[12] += 5;
+		bytes -= l;
+		src += l;
+		dst += l;
+		state[12] += DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE);
 	}
 }
 
lib/crypto/chacha20poly1305-selftest.c +8 -3
index c391a91364e9..fa43deda2660 100644
@@ -9028,10 +9028,15 @@ bool __init chacha20poly1305_selftest(void)
 	     && total_len <= 1 << 10; ++total_len) {
 		for (i = 0; i <= total_len; ++i) {
 			for (j = i; j <= total_len; ++j) {
+				k = 0;
 				sg_init_table(sg_src, 3);
-				sg_set_buf(&sg_src[0], input, i);
-				sg_set_buf(&sg_src[1], input + i, j - i);
-				sg_set_buf(&sg_src[2], input + j, total_len - j);
+				if (i)
+					sg_set_buf(&sg_src[k++], input, i);
+				if (j - i)
+					sg_set_buf(&sg_src[k++], input + i, j - i);
+				if (total_len - j)
+					sg_set_buf(&sg_src[k++], input + j, total_len - j);
+				sg_init_marker(sg_src, k);
 				memset(computed_output, 0, total_len);
 				memset(input, 0, total_len);
 
Signature · 1 line
2.25.1
maintainer
#5 lore raw
Quoted 2 lines · Jason A. Donenfeld

It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

[...]

Quoted 12 lines
lib/crypto/chacha20poly1305-selftest.c +1 -2
index c391a91364e9..fa43deda2660 100644
@@ -9028,10 +9028,15 @@ bool __init chacha20poly1305_selftest(void)
 	     && total_len <= 1 << 10; ++total_len) {
 		for (i = 0; i <= total_len; ++i) {
 			for (j = i; j <= total_len; ++j) {
+				k = 0;
 				sg_init_table(sg_src, 3);
-				sg_set_buf(&sg_src[0], input, i);
-				sg_set_buf(&sg_src[1], input + i, j - i);

lib/crypto/chacha20poly1305-selftest.c bool __init chacha20poly1305_selftest(void) · line 9041

Quoted 10 lines
lib/crypto/chacha20poly1305-selftest.c +7 -1
-				sg_set_buf(&sg_src[2], input + j, total_len - j);
+				if (i)
+					sg_set_buf(&sg_src[k++], input, i);
+				if (j - i)
+					sg_set_buf(&sg_src[k++], input + i, j - i);
+				if (total_len - j)
+					sg_set_buf(&sg_src[k++], input + j, total_len - j);
+				sg_init_marker(sg_src, k);
 				memset(computed_output, 0, total_len);
 				memset(input, 0, total_len);

So with this test fix, does this test find the bug?

Apparently the empty scatterlist elements caused some problem? What was that problem exactly? And what do you mean by this "prevented the test from running on arm64"? If there is a problem it seems we should something else about about it, e.g. debug checks that work in consistent way on all architectures, documenting what the function expects, or make it just work properly with empty scatterlist elements.

- Eric

author maintainer
#6 lore raw
Quoted 21 lines · Eric Biggers
Quoted 2 lines · Jason A. Donenfeld

It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

[...]

Quoted 16 lines
lib/crypto/chacha20poly1305-selftest.c +4 -3
index c391a91364e9..fa43deda2660 100644
@@ -9028,10 +9028,15 @@ bool __init chacha20poly1305_selftest(void)
           && total_len <= 1 << 10; ++total_len) {
              for (i = 0; i <= total_len; ++i) {
                      for (j = i; j <= total_len; ++j) {
+                             k = 0;
                              sg_init_table(sg_src, 3);
-                             sg_set_buf(&sg_src[0], input, i);
-                             sg_set_buf(&sg_src[1], input + i, j - i);
-                             sg_set_buf(&sg_src[2], input + j, total_len - j);
+                             if (i)
+                                     sg_set_buf(&sg_src[k++], input, i);
+                             if (j - i)
Quoted 8 lines

lib/crypto/chacha20poly1305-selftest.c bool __init chacha20poly1305_selftest(void) · line 9041

Quoted 6 lines
lib/crypto/chacha20poly1305-selftest.c +4 -0
+                                     sg_set_buf(&sg_src[k++], input + i, j - i);
+                             if (total_len - j)
+                                     sg_set_buf(&sg_src[k++], input + j, total_len - j);
+                             sg_init_marker(sg_src, k);
                              memset(computed_output, 0, total_len);
                              memset(input, 0, total_len);

So with this test fix, does this test find the bug?

Yes.

Quoted 6 lines

Apparently the empty scatterlist elements caused some problem? What was that problem exactly? And what do you mean by this "prevented the test from running on arm64"? If there is a problem it seems we should something else about about it, e.g. debug checks that work in consistent way on all architectures, documenting what the function expects, or make it just work properly with empty scatterlist elements.

Yea, my next plan was to look into what's going on there. In case you're curious, here's what happens:

[    0.355761] [ffffffff041e9508] pgd=000000004ffe9003,
pud=000000004ffe9003, pmd=0000000000000000
[    0.356212] Internal error: Oops: 96000006 [#1] PREEMPT SMP
[    0.356587] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc5+ #10
[    0.356695] Hardware name: linux,dummy-virt (DT)
[    0.356972] pstate: 20000005 (nzCv daif -PAN -UAO)
[    0.357158] pc : scatterwalk_copychunks+0x13c/0x1e0
[    0.357257] lr : scatterwalk_copychunks+0xe0/0x1e0
[    0.357379] sp : ffffff800f82f970
[    0.357450] x29: ffffff800f82f970 x28: ffffff800f838000
[    0.357607] x27: ffffff800f838000 x26: 0000000000000001
[    0.357725] x25: ffffff800f82faf0 x24: ffffff800f82fa10
[    0.357820] x23: 0000000000000010 x22: 0000000000000000
[    0.357898] x21: 0000000000000000 x20: 0000000100200000
[    0.357978] x19: ffffff8000000000 x18: 0000000000000014
[    0.358132] x17: 0000000000000000 x16: 0000000000000002
[    0.358214] x15: 00000000074c5755 x14: 0000000000000002
[    0.358310] x13: 074c57550311ac67 x12: 09579e470077af1a
[    0.358453] x11: 1d3f98018ec6f5bb x10: 3e6144a223343e11
[    0.358560] x9 : 0000000000000000 x8 : ffffff800f82fcc0
[    0.358638] x7 : 0000000000000000 x6 : ffffff800fa55000
[    0.358711] x5 : 0000000000001000 x4 : 0000000000000000
[    0.358781] x3 : ffffffff001e9540 x2 : ffffffff001e9540
[    0.358855] x1 : ffffffff041e9500 x0 : ffffff800f82fd60
[    0.359007] Call trace:
[    0.359177]  scatterwalk_copychunks+0x13c/0x1e0
[    0.359269]  scatterwalk_map_and_copy+0x50/0xa8
[    0.359339]  chacha20poly1305_crypt_sg_inplace+0x3f4/0x418
[    0.359418]  chacha20poly1305_encrypt_sg_inplace+0x10/0x18
[    0.359511]  chacha20poly1305_selftest+0x4dc/0x618
[    0.359581]  mod_init+0xc/0x2c
[    0.359630]  do_one_initcall+0x58/0x11c
[    0.359687]  kernel_init_freeable+0x174/0x1e0
[    0.359751]  kernel_init+0x10/0x100
[    0.359803]  ret_from_fork+0x10/0x18
[    0.360074] Code: f9400002 530c7c21 927ef442 8b011841 (f9400423)
[    0.360257] ---[ end trace 0b64264f8a25dbdf ]---
[    0.360453] Kernel panic - not syncing: Fatal exception
[    0.360597] SMP: stopping secondary CPUs
[    0.360835] Kernel Offset: disabled
[    0.360985] CPU features: 0x00002,00002000
[    0.361042] Memory Limit: none
author maintainer
#7 lore raw
Quoted 78 lines · Jason A. Donenfeld
Quoted 21 lines · Eric Biggers
Quoted 2 lines · Jason A. Donenfeld

It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

[...]

Quoted 16 lines
lib/crypto/chacha20poly1305-selftest.c +4 -3
index c391a91364e9..fa43deda2660 100644
@@ -9028,10 +9028,15 @@ bool __init chacha20poly1305_selftest(void)
           && total_len <= 1 << 10; ++total_len) {
              for (i = 0; i <= total_len; ++i) {
                      for (j = i; j <= total_len; ++j) {
+                             k = 0;
                              sg_init_table(sg_src, 3);
-                             sg_set_buf(&sg_src[0], input, i);
-                             sg_set_buf(&sg_src[1], input + i, j - i);
-                             sg_set_buf(&sg_src[2], input + j, total_len - j);
+                             if (i)
+                                     sg_set_buf(&sg_src[k++], input, i);
+                             if (j - i)
Quoted 8 lines

lib/crypto/chacha20poly1305-selftest.c bool __init chacha20poly1305_selftest(void) · line 9041

Quoted 6 lines
lib/crypto/chacha20poly1305-selftest.c +4 -0
+                                     sg_set_buf(&sg_src[k++], input + i, j - i);
+                             if (total_len - j)
+                                     sg_set_buf(&sg_src[k++], input + j, total_len - j);
+                             sg_init_marker(sg_src, k);
                              memset(computed_output, 0, total_len);
                              memset(input, 0, total_len);

So with this test fix, does this test find the bug?

Yes.

Quoted 6 lines

Apparently the empty scatterlist elements caused some problem? What was that problem exactly? And what do you mean by this "prevented the test from running on arm64"? If there is a problem it seems we should something else about about it, e.g. debug checks that work in consistent way on all architectures, documenting what the function expects, or make it just work properly with empty scatterlist elements.

Yea, my next plan was to look into what's going on there. In case you're curious, here's what happens:

[    0.355761] [ffffffff041e9508] pgd=000000004ffe9003,
pud=000000004ffe9003, pmd=0000000000000000
[    0.356212] Internal error: Oops: 96000006 [#1] PREEMPT SMP
[    0.356587] CPU: 1 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc5+ #10
[    0.356695] Hardware name: linux,dummy-virt (DT)
[    0.356972] pstate: 20000005 (nzCv daif -PAN -UAO)
[    0.357158] pc : scatterwalk_copychunks+0x13c/0x1e0
[    0.357257] lr : scatterwalk_copychunks+0xe0/0x1e0
[    0.357379] sp : ffffff800f82f970
[    0.357450] x29: ffffff800f82f970 x28: ffffff800f838000
[    0.357607] x27: ffffff800f838000 x26: 0000000000000001
[    0.357725] x25: ffffff800f82faf0 x24: ffffff800f82fa10
[    0.357820] x23: 0000000000000010 x22: 0000000000000000
[    0.357898] x21: 0000000000000000 x20: 0000000100200000
[    0.357978] x19: ffffff8000000000 x18: 0000000000000014
[    0.358132] x17: 0000000000000000 x16: 0000000000000002
[    0.358214] x15: 00000000074c5755 x14: 0000000000000002
[    0.358310] x13: 074c57550311ac67 x12: 09579e470077af1a
[    0.358453] x11: 1d3f98018ec6f5bb x10: 3e6144a223343e11
[    0.358560] x9 : 0000000000000000 x8 : ffffff800f82fcc0
[    0.358638] x7 : 0000000000000000 x6 : ffffff800fa55000
[    0.358711] x5 : 0000000000001000 x4 : 0000000000000000
[    0.358781] x3 : ffffffff001e9540 x2 : ffffffff001e9540
[    0.358855] x1 : ffffffff041e9500 x0 : ffffff800f82fd60
[    0.359007] Call trace:
[    0.359177]  scatterwalk_copychunks+0x13c/0x1e0
[    0.359269]  scatterwalk_map_and_copy+0x50/0xa8
[    0.359339]  chacha20poly1305_crypt_sg_inplace+0x3f4/0x418
[    0.359418]  chacha20poly1305_encrypt_sg_inplace+0x10/0x18
[    0.359511]  chacha20poly1305_selftest+0x4dc/0x618
[    0.359581]  mod_init+0xc/0x2c
[    0.359630]  do_one_initcall+0x58/0x11c
[    0.359687]  kernel_init_freeable+0x174/0x1e0
[    0.359751]  kernel_init+0x10/0x100
Quoted 8 lines
[    0.359803]  ret_from_fork+0x10/0x18
[    0.360074] Code: f9400002 530c7c21 927ef442 8b011841 (f9400423)
[    0.360257] ---[ end trace 0b64264f8a25dbdf ]---
[    0.360453] Kernel panic - not syncing: Fatal exception
[    0.360597] SMP: stopping secondary CPUs
[    0.360835] Kernel Offset: disabled
[    0.360985] CPU features: 0x00002,00002000
[    0.361042] Memory Limit: none

__read_once_size at include/linux/compiler.h:199
(inlined by) compound_head at include/linux/page-flags.h:174 (inlined by) PageSlab at include/linux/page-flags.h:325 (inlined by) scatterwalk_pagedone at include/crypto/scatterwalk.h:88 (inlined by) scatterwalk_copychunks at crypto/scatterwalk.c:50

Bug makes sense.

scatterwalk_copychunks->scatterwalk_pagedone->PageSlab, but length zero page means we're looking at nonsense.

So this v2 seems to be the correct fix.

maintainer Reviewed-by on v2 1/1
#8 lore raw
In reply to Jason A. Donenfeld
Quoted 52 lines · Jason A. Donenfeld

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln: "why do images look weird on webpages?" WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed. It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

Fixes b3aad5bad26a ("crypto: arm64/chacha - expose arm64 ChaCha routine as library function")
Cc Ard Biesheuvel <[email protected]>
---
 arch/arm64/crypto/chacha-neon-glue.c   |  8 ++++----
 lib/crypto/chacha20poly1305-selftest.c | 11 ++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)
arch/arm64/crypto/chacha-neon-glue.c +4 -4
index c1f9660d104c..37ca3e889848 100644
@@ -55,10 +55,10 @@ static void chacha_doneon(u32 *state, u8 *dst, const u8 *src,
 			break;
 		}
 		chacha_4block_xor_neon(state, dst, src, nrounds, l);
-		bytes -= CHACHA_BLOCK_SIZE * 5;
-		src += CHACHA_BLOCK_SIZE * 5;
-		dst += CHACHA_BLOCK_SIZE * 5;
-		state[12] += 5;
+		bytes -= l;
+		src += l;
+		dst += l;
+		state[12] += DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE);
 	}
 }
 
lib/crypto/chacha20poly1305-selftest.c +1 -3
index c391a91364e9..fa43deda2660 100644
@@ -9028,10 +9028,15 @@ bool __init chacha20poly1305_selftest(void)
 	     && total_len <= 1 << 10; ++total_len) {
 		for (i = 0; i <= total_len; ++i) {
 			for (j = i; j <= total_len; ++j) {
+				k = 0;
 				sg_init_table(sg_src, 3);
-				sg_set_buf(&sg_src[0], input, i);
-				sg_set_buf(&sg_src[1], input + i, j - i);
-				sg_set_buf(&sg_src[2], input + j, total_len - j);

lib/crypto/chacha20poly1305-selftest.c bool __init chacha20poly1305_selftest(void) · line 9042

Quoted 10 lines
lib/crypto/chacha20poly1305-selftest.c +7 -0
+				if (i)
+					sg_set_buf(&sg_src[k++], input, i);
+				if (j - i)
+					sg_set_buf(&sg_src[k++], input + i, j - i);
+				if (total_len - j)
+					sg_set_buf(&sg_src[k++], input + j, total_len - j);
+				sg_init_marker(sg_src, k);
 				memset(computed_output, 0, total_len);
 				memset(input, 0, total_len);
 

Herbert, can you send this to Linus for 5.6?

- Eric

maintainer
#9 lore raw
In reply to Jason A. Donenfeld
Quoted 15 lines · Jason A. Donenfeld

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln: "why do images look weird on webpages?" WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed. It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

Fixes b3aad5bad26a ("crypto: arm64/chacha - expose arm64 ChaCha routine as library function")
Cc Ard Biesheuvel <[email protected]>
Quoted 4 lines
---
 arch/arm64/crypto/chacha-neon-glue.c   |  8 ++++----
 lib/crypto/chacha20poly1305-selftest.c | 11 ++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)

Patch applied. Thanks.

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
author maintainer
#10 lore raw
Quoted 22 lines · Herbert Xu
Quoted 15 lines · Jason A. Donenfeld

Prior, passing in chunks of 2, 3, or 4, followed by any additional chunks would result in the chacha state counter getting out of sync, resulting in incorrect encryption/decryption, which is a pretty nasty crypto vuln: "why do images look weird on webpages?" WireGuard users never experienced this prior, because we have always, out of tree, used a different crypto library, until the recent Frankenzinc addition. This commit fixes the issue by advancing the pointers and state counter by the actual size processed. It also fixes up a bug in the (optional, costly) stride test that prevented it from running on arm64.

Fixes b3aad5bad26a ("crypto: arm64/chacha - expose arm64 ChaCha routine as library function")
Cc Ard Biesheuvel <[email protected]>
Quoted 4 lines
---
 arch/arm64/crypto/chacha-neon-glue.c   |  8 ++++----
 lib/crypto/chacha20poly1305-selftest.c | 11 ++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)
Quoted 1 line

Patch applied. Thanks.

Thanks! No idea whether Linus will skip a 5.6-rc7 with people not at work due to the quarantines, so given the gravity of this bug, it might be prudent to send a PR to him _now_, rather then waiting until next week.

Jason