blame | history | patch | commit | commitdiff
hc
2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf 
 kernel/lib/sha1.c
....@@ -9,7 +9,8 @@
99 #include <linux/kernel.h>
1010 #include <linux/export.h>
1111 #include <linux/bitops.h>
12
-#include <linux/cryptohash.h>
12
+#include <linux/string.h>
13
+#include <crypto/sha.h>
1314 #include <asm/unaligned.h>
1415 
1516 /*
....@@ -55,7 +56,8 @@
5556 #define SHA_ROUND(t, input, fn, constant, A, B, C, D, E) do { \
5657 	__u32 TEMP = input(t); setW(t, TEMP); \
5758 	E += TEMP + rol32(A,5) + (fn) + (constant); \
58
-	B = ror32(B, 2); } while (0)
59
+	B = ror32(B, 2); \
60
+	TEMP = E; E = D; D = C; C = B; B = A; A = TEMP; } while (0)
5961 
6062 #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 )
6163 #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 )
....@@ -64,24 +66,27 @@
6466 #define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) ,  0xca62c1d6, A, B, C, D, E )
6567 
6668 /**
67
- * sha_transform - single block SHA1 transform
69
+ * sha1_transform - single block SHA1 transform (deprecated)
6870  *
6971  * @digest: 160 bit digest to update
7072  * @data:   512 bits of data to hash
7173  * @array:  16 words of workspace (see note)
7274  *
73
- * This function generates a SHA1 digest for a single 512-bit block.
74
- * Be warned, it does not handle padding and message digest, do not
75
- * confuse it with the full FIPS 180-1 digest algorithm for variable
76
- * length messages.
75
+ * This function executes SHA-1's internal compression function.  It updates the
76
+ * 160-bit internal state (@digest) with a single 512-bit data block (@data).
77
+ *
78
+ * Don't use this function.  SHA-1 is no longer considered secure.  And even if
79
+ * you do have to use SHA-1, this isn't the correct way to hash something with
80
+ * SHA-1 as this doesn't handle padding and finalization.
7781  *
7882  * Note: If the hash is security sensitive, the caller should be sure
7983  * to clear the workspace. This is left to the caller to avoid
8084  * unnecessary clears between chained hashing operations.
8185  */
82
-void sha_transform(__u32 *digest, const char *data, __u32 *array)
86
+void sha1_transform(__u32 *digest, const char *data, __u32 *array)
8387 {
8488 	__u32 A, B, C, D, E;
89
+	unsigned int i = 0;
8590 
8691 	A = digest[0];
8792 	B = digest[1];
....@@ -90,94 +95,24 @@
9095 	E = digest[4];
9196 
9297 	/* Round 1 - iterations 0-16 take their input from 'data' */
93
-	T_0_15( 0, A, B, C, D, E);
94
-	T_0_15( 1, E, A, B, C, D);
95
-	T_0_15( 2, D, E, A, B, C);
96
-	T_0_15( 3, C, D, E, A, B);
97
-	T_0_15( 4, B, C, D, E, A);
98
-	T_0_15( 5, A, B, C, D, E);
99
-	T_0_15( 6, E, A, B, C, D);
100
-	T_0_15( 7, D, E, A, B, C);
101
-	T_0_15( 8, C, D, E, A, B);
102
-	T_0_15( 9, B, C, D, E, A);
103
-	T_0_15(10, A, B, C, D, E);
104
-	T_0_15(11, E, A, B, C, D);
105
-	T_0_15(12, D, E, A, B, C);
106
-	T_0_15(13, C, D, E, A, B);
107
-	T_0_15(14, B, C, D, E, A);
108
-	T_0_15(15, A, B, C, D, E);
98
+	for (; i < 16; ++i)
99
+		T_0_15(i, A, B, C, D, E);
109100 
110101 	/* Round 1 - tail. Input from 512-bit mixing array */
111
-	T_16_19(16, E, A, B, C, D);
112
-	T_16_19(17, D, E, A, B, C);
113
-	T_16_19(18, C, D, E, A, B);
114
-	T_16_19(19, B, C, D, E, A);
102
+	for (; i < 20; ++i)
103
+		T_16_19(i, A, B, C, D, E);
115104 
116105 	/* Round 2 */
117
-	T_20_39(20, A, B, C, D, E);
118
-	T_20_39(21, E, A, B, C, D);
119
-	T_20_39(22, D, E, A, B, C);
120
-	T_20_39(23, C, D, E, A, B);
121
-	T_20_39(24, B, C, D, E, A);
122
-	T_20_39(25, A, B, C, D, E);
123
-	T_20_39(26, E, A, B, C, D);
124
-	T_20_39(27, D, E, A, B, C);
125
-	T_20_39(28, C, D, E, A, B);
126
-	T_20_39(29, B, C, D, E, A);
127
-	T_20_39(30, A, B, C, D, E);
128
-	T_20_39(31, E, A, B, C, D);
129
-	T_20_39(32, D, E, A, B, C);
130
-	T_20_39(33, C, D, E, A, B);
131
-	T_20_39(34, B, C, D, E, A);
132
-	T_20_39(35, A, B, C, D, E);
133
-	T_20_39(36, E, A, B, C, D);
134
-	T_20_39(37, D, E, A, B, C);
135
-	T_20_39(38, C, D, E, A, B);
136
-	T_20_39(39, B, C, D, E, A);
106
+	for (; i < 40; ++i)
107
+		T_20_39(i, A, B, C, D, E);
137108 
138109 	/* Round 3 */
139
-	T_40_59(40, A, B, C, D, E);
140
-	T_40_59(41, E, A, B, C, D);
141
-	T_40_59(42, D, E, A, B, C);
142
-	T_40_59(43, C, D, E, A, B);
143
-	T_40_59(44, B, C, D, E, A);
144
-	T_40_59(45, A, B, C, D, E);
145
-	T_40_59(46, E, A, B, C, D);
146
-	T_40_59(47, D, E, A, B, C);
147
-	T_40_59(48, C, D, E, A, B);
148
-	T_40_59(49, B, C, D, E, A);
149
-	T_40_59(50, A, B, C, D, E);
150
-	T_40_59(51, E, A, B, C, D);
151
-	T_40_59(52, D, E, A, B, C);
152
-	T_40_59(53, C, D, E, A, B);
153
-	T_40_59(54, B, C, D, E, A);
154
-	T_40_59(55, A, B, C, D, E);
155
-	T_40_59(56, E, A, B, C, D);
156
-	T_40_59(57, D, E, A, B, C);
157
-	T_40_59(58, C, D, E, A, B);
158
-	T_40_59(59, B, C, D, E, A);
110
+	for (; i < 60; ++i)
111
+		T_40_59(i, A, B, C, D, E);
159112 
160113 	/* Round 4 */
161
-	T_60_79(60, A, B, C, D, E);
162
-	T_60_79(61, E, A, B, C, D);
163
-	T_60_79(62, D, E, A, B, C);
164
-	T_60_79(63, C, D, E, A, B);
165
-	T_60_79(64, B, C, D, E, A);
166
-	T_60_79(65, A, B, C, D, E);
167
-	T_60_79(66, E, A, B, C, D);
168
-	T_60_79(67, D, E, A, B, C);
169
-	T_60_79(68, C, D, E, A, B);
170
-	T_60_79(69, B, C, D, E, A);
171
-	T_60_79(70, A, B, C, D, E);
172
-	T_60_79(71, E, A, B, C, D);
173
-	T_60_79(72, D, E, A, B, C);
174
-	T_60_79(73, C, D, E, A, B);
175
-	T_60_79(74, B, C, D, E, A);
176
-	T_60_79(75, A, B, C, D, E);
177
-	T_60_79(76, E, A, B, C, D);
178
-	T_60_79(77, D, E, A, B, C);
179
-	T_60_79(78, C, D, E, A, B);
180
-	T_60_79(79, B, C, D, E, A);
114
+	for (; i < 80; ++i)
115
+		T_60_79(i, A, B, C, D, E);
181116 
182117 	digest[0] += A;
183118 	digest[1] += B;
....@@ -185,13 +120,13 @@
185120 	digest[3] += D;
186121 	digest[4] += E;
187122 }
188
-EXPORT_SYMBOL(sha_transform);
123
+EXPORT_SYMBOL(sha1_transform);
189124 
190125 /**
191
- * sha_init - initialize the vectors for a SHA1 digest
126
+ * sha1_init - initialize the vectors for a SHA1 digest
192127  * @buf: vector to initialize
193128  */
194
-void sha_init(__u32 *buf)
129
+void sha1_init(__u32 *buf)
195130 {
196131 	buf[0] = 0x67452301;
197132 	buf[1] = 0xefcdab89;
....@@ -199,4 +134,4 @@
199134 	buf[3] = 0x10325476;
200135 	buf[4] = 0xc3d2e1f0;
201136 }
202
-EXPORT_SYMBOL(sha_init);
137
+EXPORT_SYMBOL(sha1_init);