remove remaining users of SHA-1
Subsystems (7)
v2 cover remove remaining users of SHA-1
Hi,
There are currently two remaining users of SHA-1 left in the kernel: bpf tag generation, and ipv6 address calculation. In an effort to reduce code size and rid ourselves of insecure primitives, this RFC patchset moves to using the more secure BLAKE2s function. I wanted to get your feedback on how feasible this patchset is, and if there is some remaining attachment to SHA-1, why exactly, and what could be done to mitigate it. Rather than sending a mailing list post just asking, "what do you think?" I figured it'd be easier to send this as an RFC patchset, so you see specifically what I mean.
Version 2 makes the ipv6 handling a bit cleaner and fixes a build warning from the last commit. Since this is just an RFC-for-discussion, there's not technically a need to be sending this, but from the looks of it, a real solution here might involve a bit more heavy lifting, so I wanted to at least get my latest on the list in case others want to play around with solutions in this space too. Also, the original recipient list was too narrow, so this v2 expands that a bit.
Thoughts? Comments?
Thanks,
Jason
Jason A. Donenfeld (3):
bpf: move from sha1 to blake2s in tag calculation
ipv6: move from sha1 to blake2s in address calculation
crypto: sha1_generic - import lib/sha1.c locally
crypto/sha1_generic.c | 182 +++++++++++++++++++++++++++++++++++++ include/crypto/sha1.h | 10 --- kernel/bpf/core.c | 39 +------- lib/Makefile | 2 +- lib/sha1.c | 204 ------------------------------------------ net/ipv6/addrconf.c | 56 +++--------- 6 files changed, 201 insertions(+), 292 deletions(-) delete mode 100644 lib/sha1.c
Signature · 1 line
2.34.1
RFC PATCH v2 1/3 bpf: move from sha1 to blake2s in tag calculation
BLAKE2s is faster and more secure. SHA-1 has been broken for a long time now. This also removes quite a bit of code, and lets us potentially remove sha1 from lib, which would further reduce vmlinux size.
--- kernel/bpf/core.c | 39 ++++----------------------------------- 1 file changed, 4 insertions(+), 35 deletions(-)
kernel/bpf/core.c +4 -35
@@ -33,6 +33,7 @@#include <linux/extable.h> #include <linux/log2.h> #include <linux/bpf_verifier.h> +#include <crypto/blake2s.h> #include <asm/barrier.h> #include <asm/unaligned.h>
@@ -265,24 +266,16 @@ void __bpf_prog_free(struct bpf_prog *fp)int bpf_prog_calc_tag (struct bpf_prog *fp) { -const u32 bits_offset =SHA1_BLOCK_SIZE -sizeof (__be64);u32 raw_size =bpf_prog_tag_scratch_size (fp); -u32 digest[SHA1_DIGEST_WORDS ]; -u32 ws[SHA1_WORKSPACE_WORDS ]; -u32 i, bsize, psize, blocks;struct bpf_insn *dst;bool was_ld_map; -u8 *raw, *todo; -__be32 *result; -__be64 *bits; +u8 *raw; +int i; raw =vmalloc (raw_size);if (!raw)return -ENOMEM ; -sha1_init (digest); -memset (ws,0 ,sizeof (ws)); -/* We need to take out the map fd for the digest calculation * since they are unstable from user space side. */
@@ -307,31 +300,7 @@ int bpf_prog_calc_tag(struct bpf_prog *fp) } } - psize =bpf_prog_insn_size (fp); -memset (&raw[psize],0 , raw_size - psize); - raw[psize++] =0x80 ; - - bsize =round_up (psize,SHA1_BLOCK_SIZE ); - blocks = bsize /SHA1_BLOCK_SIZE ; - todo = raw; -if (bsize - psize >=sizeof (__be64)) { - bits = (__be64 *)(todo + bsize -sizeof (__be64)); - }else { - bits = (__be64 *)(todo + bsize + bits_offset); - blocks++; - } - *bits =cpu_to_be64 ((psize -1 ) <<3 ); - -while (blocks--) { -sha1_transform (digest, todo, ws); - todo +=SHA1_BLOCK_SIZE ; - } - - result = (__force __be32 *)digest; -for (i =0 ; i <SHA1_DIGEST_WORDS ; i++) - result[i] =cpu_to_be32 (digest[i]); -memcpy (fp->tag, result,sizeof (fp->tag)); - +blake2s (fp->tag, raw,NULL ,sizeof (fp->tag),bpf_prog_insn_size (fp),0 );vfree (raw);return 0 ; }
Signature · 1 line
2.34.1
Re: [PATCH RFC v2 1/3] bpf: move from sha1 to blake2s in tag calculation
Quoted 4 lines · Jason A. Donenfeld
BLAKE2s is faster and more secure. SHA-1 has been broken for a long time now. This also removes quite a bit of code, and lets us potentially remove sha1 from lib, which would further reduce vmlinux size.
Same NACK as before.
Stop this spam. Pls.
Re: [PATCH RFC v2 1/3] bpf: move from sha1 to blake2s in tag calculation
Quoted 9 lines · Alexei Starovoitov
Quoted 4 lines · Jason A. Donenfeld
BLAKE2s is faster and more secure. SHA-1 has been broken for a long time now. This also removes quite a bit of code, and lets us potentially remove sha1 from lib, which would further reduce vmlinux size.
Same NACK as before.
Stop this spam. Pls.
You can read the 0/3 for an explanation of why I sent this v2. I reject your characterization of this as "spam".
Thanks,
Jason
RFC PATCH v2 2/3 ipv6: move from sha1 to blake2s in address calculation
In reply to Jason A. DonenfeldBLAKE2s is faster and more secure. SHA-1 has been broken for a long time now. This also removes some code complexity, and lets us potentially remove sha1 from lib, which would further reduce vmlinux size. This also lets us use the secret in the proper field for a secret, rather than the prepending done in the prior construction.
--- net/ipv6/addrconf.c | 56 ++++++++++++--------------------------------- 1 file changed, 14 insertions(+), 42 deletions(-)
net/ipv6/addrconf.c +14 -42
@@ -61,7 +61,7 @@#include <linux/delay.h> #include <linux/notifier.h> #include <linux/string.h> -#include <linux/hash.h> +#include <crypto/blake2s.h> #include <net/net_namespace.h> #include <net/sock.h>
@@ -3224,61 +3224,33 @@ static int ipv6_generate_stable_address(struct in6_addr *address,u8 dad_count, const struct inet6_dev *idev) { - static DEFINE_SPINLOCK(lock); -static __u32 digest[SHA1_DIGEST_WORDS ]; -static __u32 workspace[SHA1_WORKSPACE_WORDS ]; - -static union { -char __data[SHA1_BLOCK_SIZE ]; -struct { -struct in6_addr secret; -__be32 prefix[2 ]; -unsigned char hwaddr[MAX_ADDR_LEN ]; -u8 dad_count; - } __packed; - } data; - -struct in6_addr secret; -struct in6_addr temp; struct net *net = dev_net(idev->dev); - -BUILD_BUG_ON (sizeof (data.__data) !=sizeof (data)); +const struct in6_addr *secret; +struct blake2s_state hash; +struct in6_addr proposal;if (idev->cnf.stable_secret.initialized) - secret = idev->cnf.stable_secret.secret; + secret = &idev->cnf.stable_secret.secret;else if (net->ipv6.devconf_dflt->stable_secret.initialized) - secret = net->ipv6.devconf_dflt->stable_secret.secret; + secret = &net->ipv6.devconf_dflt->stable_secret.secret;else return -1 ; retry: -spin_lock_bh (&lock); - -sha1_init (digest); -memset (&data,0 ,sizeof (data)); -memset (workspace,0 ,sizeof (workspace)); -memcpy (data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len); - data.prefix[0 ] = address->s6_addr32[0 ]; - data.prefix[1 ] = address->s6_addr32[1 ]; - data.secret = secret; - data.dad_count = dad_count; - -sha1_transform (digest, data.__data, workspace); - - temp = *address; - temp.s6_addr32[2 ] = (__force __be32 )digest[0 ]; - temp.s6_addr32[3 ] = (__force __be32 )digest[1 ]; - -spin_unlock_bh (&lock); +blake2s_init_key (&hash,sizeof (proposal.s6_addr32[2 ]) *2 , secret,sizeof (*secret)); +blake2s_update (&hash, (u8 *)&address->s6_addr32[0 ],sizeof (address->s6_addr32[0 ]) *2 ); +blake2s_update (&hash, idev->dev->perm_addr, idev->dev->addr_len); +blake2s_update (&hash, (u8 *)&dad_count,sizeof (dad_count)); +blake2s_final (&hash, (u8 *)&proposal.s6_addr32[2 ]); -if (ipv6_reserved_interfaceid (temp)) { +if (ipv6_reserved_interfaceid (proposal)) { dad_count++; -if (dad_count >dev_net (idev->dev)->ipv6.sysctl.idgen_retries) +if (dad_count > net->ipv6.sysctl.idgen_retries)return -1 ; goto retry; } - *address = temp; + *address = proposal;return 0 ; }
Signature · 1 line
2.34.1
RFC PATCH v2 3/3 crypto: sha1_generic - import lib/sha1.c locally
In reply to Jason A. DonenfeldWith no non-crypto API users of this function, we can move it into the generic crypto/ code where it belongs.
--- crypto/sha1_generic.c | 182 +++++++++++++++++++++++++++++++++++++ include/crypto/sha1.h | 10 --- lib/Makefile | 2 +- lib/sha1.c | 204 ------------------------------------------ 4 files changed, 183 insertions(+), 215 deletions(-) delete mode 100644 lib/sha1.c
crypto/sha1_generic.c +182 -0
@@ -16,9 +16,191 @@#include <linux/module.h> #include <linux/mm.h> #include <linux/types.h> +#include <linux/bitops.h> +#include <linux/string.h> #include <crypto/sha1.h> #include <crypto/sha1_base.h> #include <asm/byteorder.h> +#include <asm/unaligned.h> + +#define SHA1_DIGEST_WORDS (SHA1_DIGEST_SIZE / 4) +#define SHA1_WORKSPACE_WORDS 16 + +/* +* If you have 32 registers or more, the compiler can (and should) +* try to change the array[] accesses into registers. However, on +* machines with less than ~25 registers, that won't really work, +* and at least gcc will make an unholy mess of it. +* +* So to avoid that mess which just slows things down, we force +* the stores to memory to actually happen (we might be better off +* with a 'W(t)=(val);asm("":"+m" (W(t))' there instead, as +* suggested by Artur Skawina - that will also make gcc unable to +* try to do the silly "optimize away loads" part because it won't +* see what the value will be). +* +* Ben Herrenschmidt reports that on PPC, the C version comes close +* to the optimized asm with this (ie on PPC you don't want that +* 'volatile', since there are lots of registers). +* +* On ARM we get the best code generation by forcing a full memory barrier +* between each SHA_ROUND, otherwise gcc happily get wild with spilling and +* the stack frame size simply explode and performance goes down the drain. +*/ + +#ifdef CONFIG_X86 +#define setW (x, val) (*(volatile __u32 *)&W(x) = (val)) +#elif defined(CONFIG_ARM ) +#define setW (x, val) do { W(x) = (val); __asm__("":::"memory"); } while (0) +#else +#define setW (x, val) (W(x) = (val)) +#endif + +/* This "rolls" over the 512-bit array */ +#define W (x) (array[(x)&15]) + +/* +* Where do we get the source from? The first 16 iterations get it from +* the input data, the next mix it from the 512-bit array. +*/ +#define SHA_SRC (t) get_unaligned_be32((__u32 *)data + t) +#define SHA_MIX (t) rol32(W(t+13) ^ W(t+8) ^ W(t+2) ^ W(t), 1) + +#define SHA_ROUND (t, input, fn, constant,A ,B ,C ,D ,E ) do { \ + __u32 TEMP = input(t); setW(t, TEMP); \ + E += TEMP + rol32(A,5) + (fn) + (constant); \ + B = ror32(B, 2); } while (0) + +#define T_0_15 (t,A ,B ,C ,D ,E ) SHA_ROUND(t, SHA_SRC, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E ) +#define T_16_19 (t,A ,B ,C ,D ,E ) SHA_ROUND(t, SHA_MIX, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E ) +#define T_20_39 (t,A ,B ,C ,D ,E ) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0x6ed9eba1, A, B, C, D, E ) +#define T_40_59 (t,A ,B ,C ,D ,E ) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E ) +#define T_60_79 (t,A ,B ,C ,D ,E ) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0xca62c1d6, A, B, C, D, E ) + +/** +* sha1_transform - single block SHA1 transform (deprecated) +* +* @digest: 160 bit digest to update +* @data: 512 bits of data to hash +* @array: 16 words of workspace (see note) +* +* This function executes SHA-1's internal compression function. It updates the +* 160-bit internal state (@digest) with a single 512-bit data block (@data). +* +* Don't use this function. SHA-1 is no longer considered secure. And even if +* you do have to use SHA-1, this isn't the correct way to hash something with +* SHA-1 as this doesn't handle padding and finalization. +* +* Note: If the hash is security sensitive, the caller should be sure +* to clear the workspace. This is left to the caller to avoid +* unnecessary clears between chained hashing operations. +*/ +static void sha1_transform (__u32 *digest,const char *data,__u32 *array) +{ +__u32 A ,B ,C ,D ,E ; + +A = digest[0 ]; +B = digest[1 ]; +C = digest[2 ]; +D = digest[3 ]; +E = digest[4 ]; + +/* Round 1 - iterations 0-16 take their input from 'data' */ +T_0_15 (0 ,A ,B ,C ,D ,E ); +T_0_15 (1 ,E ,A ,B ,C ,D ); +T_0_15 (2 ,D ,E ,A ,B ,C ); +T_0_15 (3 ,C ,D ,E ,A ,B ); +T_0_15 (4 ,B ,C ,D ,E ,A ); +T_0_15 (5 ,A ,B ,C ,D ,E ); +T_0_15 (6 ,E ,A ,B ,C ,D ); +T_0_15 (7 ,D ,E ,A ,B ,C ); +T_0_15 (8 ,C ,D ,E ,A ,B ); +T_0_15 (9 ,B ,C ,D ,E ,A ); +T_0_15 (10 ,A ,B ,C ,D ,E ); +T_0_15 (11 ,E ,A ,B ,C ,D ); +T_0_15 (12 ,D ,E ,A ,B ,C ); +T_0_15 (13 ,C ,D ,E ,A ,B ); +T_0_15 (14 ,B ,C ,D ,E ,A ); +T_0_15 (15 ,A ,B ,C ,D ,E ); + +/* Round 1 - tail. Input from 512-bit mixing array */ +T_16_19 (16 ,E ,A ,B ,C ,D ); +T_16_19 (17 ,D ,E ,A ,B ,C ); +T_16_19 (18 ,C ,D ,E ,A ,B ); +T_16_19 (19 ,B ,C ,D ,E ,A ); + +/* Round 2 */ +T_20_39 (20 ,A ,B ,C ,D ,E ); +T_20_39 (21 ,E ,A ,B ,C ,D ); +T_20_39 (22 ,D ,E ,A ,B ,C ); +T_20_39 (23 ,C ,D ,E ,A ,B ); +T_20_39 (24 ,B ,C ,D ,E ,A ); +T_20_39 (25 ,A ,B ,C ,D ,E ); +T_20_39 (26 ,E ,A ,B ,C ,D ); +T_20_39 (27 ,D ,E ,A ,B ,C ); +T_20_39 (28 ,C ,D ,E ,A ,B ); +T_20_39 (29 ,B ,C ,D ,E ,A ); +T_20_39 (30 ,A ,B ,C ,D ,E ); +T_20_39 (31 ,E ,A ,B ,C ,D ); +T_20_39 (32 ,D ,E ,A ,B ,C ); +T_20_39 (33 ,C ,D ,E ,A ,B ); +T_20_39 (34 ,B ,C ,D ,E ,A ); +T_20_39 (35 ,A ,B ,C ,D ,E ); +T_20_39 (36 ,E ,A ,B ,C ,D ); +T_20_39 (37 ,D ,E ,A ,B ,C ); +T_20_39 (38 ,C ,D ,E ,A ,B ); +T_20_39 (39 ,B ,C ,D ,E ,A ); + +/* Round 3 */ +T_40_59 (40 ,A ,B ,C ,D ,E ); +T_40_59 (41 ,E ,A ,B ,C ,D ); +T_40_59 (42 ,D ,E ,A ,B ,C ); +T_40_59 (43 ,C ,D ,E ,A ,B ); +T_40_59 (44 ,B ,C ,D ,E ,A ); +T_40_59 (45 ,A ,B ,C ,D ,E ); +T_40_59 (46 ,E ,A ,B ,C ,D ); +T_40_59 (47 ,D ,E ,A ,B ,C ); +T_40_59 (48 ,C ,D ,E ,A ,B ); +T_40_59 (49 ,B ,C ,D ,E ,A ); +T_40_59 (50 ,A ,B ,C ,D ,E ); +T_40_59 (51 ,E ,A ,B ,C ,D ); +T_40_59 (52 ,D ,E ,A ,B ,C ); +T_40_59 (53 ,C ,D ,E ,A ,B ); +T_40_59 (54 ,B ,C ,D ,E ,A ); +T_40_59 (55 ,A ,B ,C ,D ,E ); +T_40_59 (56 ,E ,A ,B ,C ,D ); +T_40_59 (57 ,D ,E ,A ,B ,C ); +T_40_59 (58 ,C ,D ,E ,A ,B ); +T_40_59 (59 ,B ,C ,D ,E ,A ); + +/* Round 4 */ +T_60_79 (60 ,A ,B ,C ,D ,E ); +T_60_79 (61 ,E ,A ,B ,C ,D ); +T_60_79 (62 ,D ,E ,A ,B ,C ); +T_60_79 (63 ,C ,D ,E ,A ,B ); +T_60_79 (64 ,B ,C ,D ,E ,A ); +T_60_79 (65 ,A ,B ,C ,D ,E ); +T_60_79 (66 ,E ,A ,B ,C ,D ); +T_60_79 (67 ,D ,E ,A ,B ,C ); +T_60_79 (68 ,C ,D ,E ,A ,B ); +T_60_79 (69 ,B ,C ,D ,E ,A ); +T_60_79 (70 ,A ,B ,C ,D ,E ); +T_60_79 (71 ,E ,A ,B ,C ,D ); +T_60_79 (72 ,D ,E ,A ,B ,C ); +T_60_79 (73 ,C ,D ,E ,A ,B ); +T_60_79 (74 ,B ,C ,D ,E ,A ); +T_60_79 (75 ,A ,B ,C ,D ,E ); +T_60_79 (76 ,E ,A ,B ,C ,D ); +T_60_79 (77 ,D ,E ,A ,B ,C ); +T_60_79 (78 ,C ,D ,E ,A ,B ); +T_60_79 (79 ,B ,C ,D ,E ,A ); + + digest[0 ] +=A ; + digest[1 ] +=B ; + digest[2 ] +=C ; + digest[3 ] +=D ; + digest[4 ] +=E ; +}const u8 sha1_zero_message_hash[SHA1_DIGEST_SIZE ] = {0xda ,0x39 ,0xa3 ,0xee ,0x5e ,0x6b ,0x4b ,0x0d ,
include/crypto/sha1.h +0 -10
@@ -33,14 +33,4 @@ extern int crypto_sha1_update(struct shash_desc *desc, const u8 *data,extern int crypto_sha1_finup (struct shash_desc *desc,const u8 *data,unsigned int len,u8 *hash); -/* -* An implementation of SHA-1's compression function. Don't use in new code! -* You shouldn't be using SHA-1, and even if you *have* to use SHA-1, this isn't -* the correct way to hash something with SHA-1 (use crypto_shash instead). -*/ -#define SHA1_DIGEST_WORDS (SHA1_DIGEST_SIZE / 4) -#define SHA1_WORKSPACE_WORDS 16 -void sha1_init (__u32 *buf); -void sha1_transform (__u32 *digest,const char *data,__u32 *W ); -#endif /* _CRYPTO_SHA1_H */
lib/Makefile +1 -1
@@ -29,7 +29,7 @@ endif lib-y := ctype.o string.o vsprintf.o cmdline.o \ rbtree.o radix-tree.o timerqueue.o xarray.o \ - idr.o extable.o sha1.o irq_regs.o argv_split.o \ + idr.o extable.o irq_regs.o argv_split.o \ flex_proportions.o ratelimit.o show_mem.o \ is_single_threaded.o plist.o decompress.o kobject_uevent.o \ earlycpio.o seq_buf.o siphash.o dec_and_lock.o \
lib/sha1.c deleted +0 -204
204 lines not on this page · raw message
Signature · 1 line
2.34.1