2 * SHA1 routine optimized to do word accesses rather than byte accesses,
3 * and to avoid unnecessary copies into the context array.
5 * This was based on the git SHA1 implementation.
8 #include <linux/kernel.h>
9 #include <linux/export.h>
10 #include <linux/bitops.h>
11 #include <linux/cryptohash.h>
12 #include <asm/unaligned.h>
15 * If you have 32 registers or more, the compiler can (and should)
16 * try to change the array[] accesses into registers. However, on
17 * machines with less than ~25 registers, that won't really work,
18 * and at least gcc will make an unholy mess of it.
20 * So to avoid that mess which just slows things down, we force
21 * the stores to memory to actually happen (we might be better off
22 * with a 'W(t)=(val);asm("":"+m" (W(t))' there instead, as
23 * suggested by Artur Skawina - that will also make gcc unable to
24 * try to do the silly "optimize away loads" part because it won't
25 * see what the value will be).
27 * Ben Herrenschmidt reports that on PPC, the C version comes close
28 * to the optimized asm with this (ie on PPC you don't want that
29 * 'volatile', since there are lots of registers).
31 * On ARM we get the best code generation by forcing a full memory barrier
32 * between each SHA_ROUND, otherwise gcc happily get wild with spilling and
33 * the stack frame size simply explode and performance goes down the drain.
37 #define setW(x, val) (*(volatile __u32 *)&W(x) = (val))
38 #elif defined(CONFIG_ARM)
39 #define setW(x, val) do { W(x) = (val); __asm__("":::"memory"); } while (0)
41 #define setW(x, val) (W(x) = (val))
44 /* This "rolls" over the 512-bit array */
45 #define W(x) (array[(x)&15])
48 * Where do we get the source from? The first 16 iterations get it from
49 * the input data, the next mix it from the 512-bit array.
51 #define SHA_SRC(t) get_unaligned_be32((__u32 *)data + t)
52 #define SHA_MIX(t) rol32(W(t+13) ^ W(t+8) ^ W(t+2) ^ W(t), 1)
54 #define SHA_ROUND(t, input, fn, constant, A, B, C, D, E) do { \
55 __u32 TEMP = input(t); setW(t, TEMP); \
56 E += TEMP + rol32(A,5) + (fn) + (constant); \
57 B = ror32(B, 2); } while (0)
59 #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 )
60 #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 )
61 #define T_20_39(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0x6ed9eba1, A, B, C, D, E )
62 #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 )
63 #define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0xca62c1d6, A, B, C, D, E )
66 * sha_transform - single block SHA1 transform
68 * @digest: 160 bit digest to update
69 * @data: 512 bits of data to hash
70 * @array: 16 words of workspace (see note)
72 * This function generates a SHA1 digest for a single 512-bit block.
73 * Be warned, it does not handle padding and message digest, do not
74 * confuse it with the full FIPS 180-1 digest algorithm for variable
77 * Note: If the hash is security sensitive, the caller should be sure
78 * to clear the workspace. This is left to the caller to avoid
79 * unnecessary clears between chained hashing operations.
81 void sha_transform(__u32
*digest
, const char *data
, __u32
*array
)
91 /* Round 1 - iterations 0-16 take their input from 'data' */
92 T_0_15( 0, A
, B
, C
, D
, E
);
93 T_0_15( 1, E
, A
, B
, C
, D
);
94 T_0_15( 2, D
, E
, A
, B
, C
);
95 T_0_15( 3, C
, D
, E
, A
, B
);
96 T_0_15( 4, B
, C
, D
, E
, A
);
97 T_0_15( 5, A
, B
, C
, D
, E
);
98 T_0_15( 6, E
, A
, B
, C
, D
);
99 T_0_15( 7, D
, E
, A
, B
, C
);
100 T_0_15( 8, C
, D
, E
, A
, B
);
101 T_0_15( 9, B
, C
, D
, E
, A
);
102 T_0_15(10, A
, B
, C
, D
, E
);
103 T_0_15(11, E
, A
, B
, C
, D
);
104 T_0_15(12, D
, E
, A
, B
, C
);
105 T_0_15(13, C
, D
, E
, A
, B
);
106 T_0_15(14, B
, C
, D
, E
, A
);
107 T_0_15(15, A
, B
, C
, D
, E
);
109 /* Round 1 - tail. Input from 512-bit mixing array */
110 T_16_19(16, E
, A
, B
, C
, D
);
111 T_16_19(17, D
, E
, A
, B
, C
);
112 T_16_19(18, C
, D
, E
, A
, B
);
113 T_16_19(19, B
, C
, D
, E
, A
);
116 T_20_39(20, A
, B
, C
, D
, E
);
117 T_20_39(21, E
, A
, B
, C
, D
);
118 T_20_39(22, D
, E
, A
, B
, C
);
119 T_20_39(23, C
, D
, E
, A
, B
);
120 T_20_39(24, B
, C
, D
, E
, A
);
121 T_20_39(25, A
, B
, C
, D
, E
);
122 T_20_39(26, E
, A
, B
, C
, D
);
123 T_20_39(27, D
, E
, A
, B
, C
);
124 T_20_39(28, C
, D
, E
, A
, B
);
125 T_20_39(29, B
, C
, D
, E
, A
);
126 T_20_39(30, A
, B
, C
, D
, E
);
127 T_20_39(31, E
, A
, B
, C
, D
);
128 T_20_39(32, D
, E
, A
, B
, C
);
129 T_20_39(33, C
, D
, E
, A
, B
);
130 T_20_39(34, B
, C
, D
, E
, A
);
131 T_20_39(35, A
, B
, C
, D
, E
);
132 T_20_39(36, E
, A
, B
, C
, D
);
133 T_20_39(37, D
, E
, A
, B
, C
);
134 T_20_39(38, C
, D
, E
, A
, B
);
135 T_20_39(39, B
, C
, D
, E
, A
);
138 T_40_59(40, A
, B
, C
, D
, E
);
139 T_40_59(41, E
, A
, B
, C
, D
);
140 T_40_59(42, D
, E
, A
, B
, C
);
141 T_40_59(43, C
, D
, E
, A
, B
);
142 T_40_59(44, B
, C
, D
, E
, A
);
143 T_40_59(45, A
, B
, C
, D
, E
);
144 T_40_59(46, E
, A
, B
, C
, D
);
145 T_40_59(47, D
, E
, A
, B
, C
);
146 T_40_59(48, C
, D
, E
, A
, B
);
147 T_40_59(49, B
, C
, D
, E
, A
);
148 T_40_59(50, A
, B
, C
, D
, E
);
149 T_40_59(51, E
, A
, B
, C
, D
);
150 T_40_59(52, D
, E
, A
, B
, C
);
151 T_40_59(53, C
, D
, E
, A
, B
);
152 T_40_59(54, B
, C
, D
, E
, A
);
153 T_40_59(55, A
, B
, C
, D
, E
);
154 T_40_59(56, E
, A
, B
, C
, D
);
155 T_40_59(57, D
, E
, A
, B
, C
);
156 T_40_59(58, C
, D
, E
, A
, B
);
157 T_40_59(59, B
, C
, D
, E
, A
);
160 T_60_79(60, A
, B
, C
, D
, E
);
161 T_60_79(61, E
, A
, B
, C
, D
);
162 T_60_79(62, D
, E
, A
, B
, C
);
163 T_60_79(63, C
, D
, E
, A
, B
);
164 T_60_79(64, B
, C
, D
, E
, A
);
165 T_60_79(65, A
, B
, C
, D
, E
);
166 T_60_79(66, E
, A
, B
, C
, D
);
167 T_60_79(67, D
, E
, A
, B
, C
);
168 T_60_79(68, C
, D
, E
, A
, B
);
169 T_60_79(69, B
, C
, D
, E
, A
);
170 T_60_79(70, A
, B
, C
, D
, E
);
171 T_60_79(71, E
, A
, B
, C
, D
);
172 T_60_79(72, D
, E
, A
, B
, C
);
173 T_60_79(73, C
, D
, E
, A
, B
);
174 T_60_79(74, B
, C
, D
, E
, A
);
175 T_60_79(75, A
, B
, C
, D
, E
);
176 T_60_79(76, E
, A
, B
, C
, D
);
177 T_60_79(77, D
, E
, A
, B
, C
);
178 T_60_79(78, C
, D
, E
, A
, B
);
179 T_60_79(79, B
, C
, D
, E
, A
);
187 EXPORT_SYMBOL(sha_transform
);
190 * sha_init - initialize the vectors for a SHA1 digest
191 * @buf: vector to initialize
193 void sha_init(__u32
*buf
)
This page took 0.036648 seconds and 5 git commands to generate.