summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/sha
diff options
context:
space:
mode:
authorbeck <>2000-03-19 11:13:58 +0000
committerbeck <>2000-03-19 11:13:58 +0000
commit796d609550df3a33fc11468741c5d2f6d3df4c11 (patch)
tree6c6d539061caa20372dad0ac4ddb1dfae2fbe7fe /src/lib/libcrypto/sha
parent5be3114c1fd7e0dfea1e38d3abb4cbba75244419 (diff)
downloadopenbsd-796d609550df3a33fc11468741c5d2f6d3df4c11.tar.gz
openbsd-796d609550df3a33fc11468741c5d2f6d3df4c11.tar.bz2
openbsd-796d609550df3a33fc11468741c5d2f6d3df4c11.zip
OpenSSL 0.9.5 merge
*warning* this bumps shared lib minors for libssl and libcrypto from 2.1 to 2.2 if you are using the ssl26 packages for ssh and other things to work you will need to get new ones (see ~beck/libsslsnap/<arch>) on cvs or ~beck/src-patent.tar.gz on cvs
Diffstat (limited to 'src/lib/libcrypto/sha')
-rw-r--r--src/lib/libcrypto/sha/Makefile.ssl4
-rw-r--r--src/lib/libcrypto/sha/asm/s1-win32.asm1138
-rw-r--r--src/lib/libcrypto/sha/asm/sha1-586.pl107
-rw-r--r--src/lib/libcrypto/sha/sha.h10
-rw-r--r--src/lib/libcrypto/sha/sha1dgst.c437
-rw-r--r--src/lib/libcrypto/sha/sha1s.cpp5
-rw-r--r--src/lib/libcrypto/sha/sha1test.c10
-rw-r--r--src/lib/libcrypto/sha/sha_dgst.c435
-rw-r--r--src/lib/libcrypto/sha/sha_locl.h563
-rw-r--r--src/lib/libcrypto/sha/shatest.c10
10 files changed, 1082 insertions, 1637 deletions
diff --git a/src/lib/libcrypto/sha/Makefile.ssl b/src/lib/libcrypto/sha/Makefile.ssl
index 6ea5b1d719..79ef43aa34 100644
--- a/src/lib/libcrypto/sha/Makefile.ssl
+++ b/src/lib/libcrypto/sha/Makefile.ssl
@@ -104,8 +104,8 @@ clean:
104sha1_one.o: ../../include/openssl/sha.h 104sha1_one.o: ../../include/openssl/sha.h
105sha1dgst.o: ../../include/openssl/opensslconf.h 105sha1dgst.o: ../../include/openssl/opensslconf.h
106sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h 106sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h
107sha1dgst.o: sha_locl.h 107sha1dgst.o: ../md32_common.h sha_locl.h
108sha_dgst.o: ../../include/openssl/opensslconf.h 108sha_dgst.o: ../../include/openssl/opensslconf.h
109sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h 109sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h
110sha_dgst.o: sha_locl.h 110sha_dgst.o: ../md32_common.h sha_locl.h
111sha_one.o: ../../include/openssl/sha.h 111sha_one.o: ../../include/openssl/sha.h
diff --git a/src/lib/libcrypto/sha/asm/s1-win32.asm b/src/lib/libcrypto/sha/asm/s1-win32.asm
index 61335666b9..699afdb022 100644
--- a/src/lib/libcrypto/sha/asm/s1-win32.asm
+++ b/src/lib/libcrypto/sha/asm/s1-win32.asm
@@ -8,302 +8,303 @@
8 .486 8 .486
9.model FLAT 9.model FLAT
10_TEXT SEGMENT 10_TEXT SEGMENT
11PUBLIC _sha1_block_x86 11PUBLIC _sha1_block_asm_data_order
12 12
13_sha1_block_x86 PROC NEAR 13_sha1_block_asm_data_order PROC NEAR
14 mov ecx, DWORD PTR 12[esp]
14 push esi 15 push esi
16 shl ecx, 6
17 mov esi, DWORD PTR 12[esp]
15 push ebp 18 push ebp
16 mov eax, DWORD PTR 20[esp] 19 add ecx, esi
17 mov esi, DWORD PTR 16[esp]
18 add eax, esi
19 mov ebp, DWORD PTR 12[esp]
20 push ebx 20 push ebx
21 sub eax, 64 21 mov ebp, DWORD PTR 16[esp]
22 push edi 22 push edi
23 mov ebx, DWORD PTR 4[ebp]
24 sub esp, 72
25 mov edx, DWORD PTR 12[ebp] 23 mov edx, DWORD PTR 12[ebp]
24 sub esp, 108
26 mov edi, DWORD PTR 16[ebp] 25 mov edi, DWORD PTR 16[ebp]
27 mov ecx, DWORD PTR 8[ebp] 26 mov ebx, DWORD PTR 8[ebp]
28 mov DWORD PTR 68[esp],eax 27 mov DWORD PTR 68[esp],ecx
29 ; First we need to setup the X array 28 ; First we need to setup the X array
30 mov eax, DWORD PTR [esi]
31L000start: 29L000start:
32 ; First, load the words onto the stack in network byte order 30 ; First, load the words onto the stack in network byte order
31 mov eax, DWORD PTR [esi]
32 mov ecx, DWORD PTR 4[esi]
33 bswap eax 33 bswap eax
34 bswap ecx
34 mov DWORD PTR [esp],eax 35 mov DWORD PTR [esp],eax
35 mov eax, DWORD PTR 4[esi] 36 mov DWORD PTR 4[esp],ecx
36 bswap eax
37 mov DWORD PTR 4[esp],eax
38 mov eax, DWORD PTR 8[esi] 37 mov eax, DWORD PTR 8[esi]
38 mov ecx, DWORD PTR 12[esi]
39 bswap eax 39 bswap eax
40 bswap ecx
40 mov DWORD PTR 8[esp],eax 41 mov DWORD PTR 8[esp],eax
41 mov eax, DWORD PTR 12[esi] 42 mov DWORD PTR 12[esp],ecx
42 bswap eax
43 mov DWORD PTR 12[esp],eax
44 mov eax, DWORD PTR 16[esi] 43 mov eax, DWORD PTR 16[esi]
44 mov ecx, DWORD PTR 20[esi]
45 bswap eax 45 bswap eax
46 bswap ecx
46 mov DWORD PTR 16[esp],eax 47 mov DWORD PTR 16[esp],eax
47 mov eax, DWORD PTR 20[esi] 48 mov DWORD PTR 20[esp],ecx
48 bswap eax
49 mov DWORD PTR 20[esp],eax
50 mov eax, DWORD PTR 24[esi] 49 mov eax, DWORD PTR 24[esi]
50 mov ecx, DWORD PTR 28[esi]
51 bswap eax 51 bswap eax
52 bswap ecx
52 mov DWORD PTR 24[esp],eax 53 mov DWORD PTR 24[esp],eax
53 mov eax, DWORD PTR 28[esi] 54 mov DWORD PTR 28[esp],ecx
54 bswap eax
55 mov DWORD PTR 28[esp],eax
56 mov eax, DWORD PTR 32[esi] 55 mov eax, DWORD PTR 32[esi]
56 mov ecx, DWORD PTR 36[esi]
57 bswap eax 57 bswap eax
58 bswap ecx
58 mov DWORD PTR 32[esp],eax 59 mov DWORD PTR 32[esp],eax
59 mov eax, DWORD PTR 36[esi] 60 mov DWORD PTR 36[esp],ecx
60 bswap eax
61 mov DWORD PTR 36[esp],eax
62 mov eax, DWORD PTR 40[esi] 61 mov eax, DWORD PTR 40[esi]
62 mov ecx, DWORD PTR 44[esi]
63 bswap eax 63 bswap eax
64 bswap ecx
64 mov DWORD PTR 40[esp],eax 65 mov DWORD PTR 40[esp],eax
65 mov eax, DWORD PTR 44[esi] 66 mov DWORD PTR 44[esp],ecx
66 bswap eax
67 mov DWORD PTR 44[esp],eax
68 mov eax, DWORD PTR 48[esi] 67 mov eax, DWORD PTR 48[esi]
68 mov ecx, DWORD PTR 52[esi]
69 bswap eax 69 bswap eax
70 bswap ecx
70 mov DWORD PTR 48[esp],eax 71 mov DWORD PTR 48[esp],eax
71 mov eax, DWORD PTR 52[esi] 72 mov DWORD PTR 52[esp],ecx
72 bswap eax
73 mov DWORD PTR 52[esp],eax
74 mov eax, DWORD PTR 56[esi] 73 mov eax, DWORD PTR 56[esi]
74 mov ecx, DWORD PTR 60[esi]
75 bswap eax 75 bswap eax
76 bswap ecx
76 mov DWORD PTR 56[esp],eax 77 mov DWORD PTR 56[esp],eax
77 mov eax, DWORD PTR 60[esi] 78 mov DWORD PTR 60[esp],ecx
78 bswap eax
79 mov DWORD PTR 60[esp],eax
80 ; We now have the X array on the stack 79 ; We now have the X array on the stack
81 ; starting at sp-4 80 ; starting at sp-4
82 mov DWORD PTR 64[esp],esi 81 mov DWORD PTR 132[esp],esi
82L001shortcut:
83 ; 83 ;
84 ; Start processing 84 ; Start processing
85 mov eax, DWORD PTR [ebp] 85 mov eax, DWORD PTR [ebp]
86 mov ecx, DWORD PTR 4[ebp]
86 ; 00_15 0 87 ; 00_15 0
87 mov esi, ecx 88 mov esi, ebx
88 mov ebp, eax 89 mov ebp, eax
89 xor esi, edx 90 xor esi, edx
90 rol ebp, 5 91 rol ebp, 5
91 and esi, ebx 92 and esi, ecx
92 add ebp, edi 93 add ebp, edi
93 ror ebx, 1 94 ror ecx, 1
94 mov edi, DWORD PTR [esp] 95 mov edi, DWORD PTR [esp]
95 ror ebx, 1 96 ror ecx, 1
96 xor esi, edx 97 xor esi, edx
97 lea ebp, DWORD PTR 1518500249[edi*1+ebp] 98 lea ebp, DWORD PTR 1518500249[edi*1+ebp]
98 mov edi, ebx 99 mov edi, ecx
99 add esi, ebp 100 add esi, ebp
100 xor edi, ecx 101 xor edi, ebx
101 mov ebp, esi 102 mov ebp, esi
102 and edi, eax 103 and edi, eax
103 rol ebp, 5 104 rol ebp, 5
104 add ebp, edx 105 add ebp, edx
105 mov edx, DWORD PTR 4[esp] 106 mov edx, DWORD PTR 4[esp]
106 ror eax, 1 107 ror eax, 1
107 xor edi, ecx 108 xor edi, ebx
108 ror eax, 1 109 ror eax, 1
109 lea ebp, DWORD PTR 1518500249[edx*1+ebp] 110 lea ebp, DWORD PTR 1518500249[edx*1+ebp]
110 add edi, ebp 111 add edi, ebp
111 ; 00_15 2 112 ; 00_15 2
112 mov edx, eax 113 mov edx, eax
113 mov ebp, edi 114 mov ebp, edi
114 xor edx, ebx 115 xor edx, ecx
115 rol ebp, 5 116 rol ebp, 5
116 and edx, esi 117 and edx, esi
117 add ebp, ecx 118 add ebp, ebx
118 ror esi, 1 119 ror esi, 1
119 mov ecx, DWORD PTR 8[esp] 120 mov ebx, DWORD PTR 8[esp]
120 ror esi, 1 121 ror esi, 1
121 xor edx, ebx 122 xor edx, ecx
122 lea ebp, DWORD PTR 1518500249[ecx*1+ebp] 123 lea ebp, DWORD PTR 1518500249[ebx*1+ebp]
123 mov ecx, esi 124 mov ebx, esi
124 add edx, ebp 125 add edx, ebp
125 xor ecx, eax 126 xor ebx, eax
126 mov ebp, edx 127 mov ebp, edx
127 and ecx, edi 128 and ebx, edi
128 rol ebp, 5 129 rol ebp, 5
129 add ebp, ebx 130 add ebp, ecx
130 mov ebx, DWORD PTR 12[esp] 131 mov ecx, DWORD PTR 12[esp]
131 ror edi, 1 132 ror edi, 1
132 xor ecx, eax 133 xor ebx, eax
133 ror edi, 1 134 ror edi, 1
134 lea ebp, DWORD PTR 1518500249[ebx*1+ebp] 135 lea ebp, DWORD PTR 1518500249[ecx*1+ebp]
135 add ecx, ebp 136 add ebx, ebp
136 ; 00_15 4 137 ; 00_15 4
137 mov ebx, edi 138 mov ecx, edi
138 mov ebp, ecx 139 mov ebp, ebx
139 xor ebx, esi 140 xor ecx, esi
140 rol ebp, 5 141 rol ebp, 5
141 and ebx, edx 142 and ecx, edx
142 add ebp, eax 143 add ebp, eax
143 ror edx, 1 144 ror edx, 1
144 mov eax, DWORD PTR 16[esp] 145 mov eax, DWORD PTR 16[esp]
145 ror edx, 1 146 ror edx, 1
146 xor ebx, esi 147 xor ecx, esi
147 lea ebp, DWORD PTR 1518500249[eax*1+ebp] 148 lea ebp, DWORD PTR 1518500249[eax*1+ebp]
148 mov eax, edx 149 mov eax, edx
149 add ebx, ebp 150 add ecx, ebp
150 xor eax, edi 151 xor eax, edi
151 mov ebp, ebx 152 mov ebp, ecx
152 and eax, ecx 153 and eax, ebx
153 rol ebp, 5 154 rol ebp, 5
154 add ebp, esi 155 add ebp, esi
155 mov esi, DWORD PTR 20[esp] 156 mov esi, DWORD PTR 20[esp]
156 ror ecx, 1 157 ror ebx, 1
157 xor eax, edi 158 xor eax, edi
158 ror ecx, 1 159 ror ebx, 1
159 lea ebp, DWORD PTR 1518500249[esi*1+ebp] 160 lea ebp, DWORD PTR 1518500249[esi*1+ebp]
160 add eax, ebp 161 add eax, ebp
161 ; 00_15 6 162 ; 00_15 6
162 mov esi, ecx 163 mov esi, ebx
163 mov ebp, eax 164 mov ebp, eax
164 xor esi, edx 165 xor esi, edx
165 rol ebp, 5 166 rol ebp, 5
166 and esi, ebx 167 and esi, ecx
167 add ebp, edi 168 add ebp, edi
168 ror ebx, 1 169 ror ecx, 1
169 mov edi, DWORD PTR 24[esp] 170 mov edi, DWORD PTR 24[esp]
170 ror ebx, 1 171 ror ecx, 1
171 xor esi, edx 172 xor esi, edx
172 lea ebp, DWORD PTR 1518500249[edi*1+ebp] 173 lea ebp, DWORD PTR 1518500249[edi*1+ebp]
173 mov edi, ebx 174 mov edi, ecx
174 add esi, ebp 175 add esi, ebp
175 xor edi, ecx 176 xor edi, ebx
176 mov ebp, esi 177 mov ebp, esi
177 and edi, eax 178 and edi, eax
178 rol ebp, 5 179 rol ebp, 5
179 add ebp, edx 180 add ebp, edx
180 mov edx, DWORD PTR 28[esp] 181 mov edx, DWORD PTR 28[esp]
181 ror eax, 1 182 ror eax, 1
182 xor edi, ecx 183 xor edi, ebx
183 ror eax, 1 184 ror eax, 1
184 lea ebp, DWORD PTR 1518500249[edx*1+ebp] 185 lea ebp, DWORD PTR 1518500249[edx*1+ebp]
185 add edi, ebp 186 add edi, ebp
186 ; 00_15 8 187 ; 00_15 8
187 mov edx, eax 188 mov edx, eax
188 mov ebp, edi 189 mov ebp, edi
189 xor edx, ebx 190 xor edx, ecx
190 rol ebp, 5 191 rol ebp, 5
191 and edx, esi 192 and edx, esi
192 add ebp, ecx 193 add ebp, ebx
193 ror esi, 1 194 ror esi, 1
194 mov ecx, DWORD PTR 32[esp] 195 mov ebx, DWORD PTR 32[esp]
195 ror esi, 1 196 ror esi, 1
196 xor edx, ebx 197 xor edx, ecx
197 lea ebp, DWORD PTR 1518500249[ecx*1+ebp] 198 lea ebp, DWORD PTR 1518500249[ebx*1+ebp]
198 mov ecx, esi 199 mov ebx, esi
199 add edx, ebp 200 add edx, ebp
200 xor ecx, eax 201 xor ebx, eax
201 mov ebp, edx 202 mov ebp, edx
202 and ecx, edi 203 and ebx, edi
203 rol ebp, 5 204 rol ebp, 5
204 add ebp, ebx 205 add ebp, ecx
205 mov ebx, DWORD PTR 36[esp] 206 mov ecx, DWORD PTR 36[esp]
206 ror edi, 1 207 ror edi, 1
207 xor ecx, eax 208 xor ebx, eax
208 ror edi, 1 209 ror edi, 1
209 lea ebp, DWORD PTR 1518500249[ebx*1+ebp] 210 lea ebp, DWORD PTR 1518500249[ecx*1+ebp]
210 add ecx, ebp 211 add ebx, ebp
211 ; 00_15 10 212 ; 00_15 10
212 mov ebx, edi 213 mov ecx, edi
213 mov ebp, ecx 214 mov ebp, ebx
214 xor ebx, esi 215 xor ecx, esi
215 rol ebp, 5 216 rol ebp, 5
216 and ebx, edx 217 and ecx, edx
217 add ebp, eax 218 add ebp, eax
218 ror edx, 1 219 ror edx, 1
219 mov eax, DWORD PTR 40[esp] 220 mov eax, DWORD PTR 40[esp]
220 ror edx, 1 221 ror edx, 1
221 xor ebx, esi 222 xor ecx, esi
222 lea ebp, DWORD PTR 1518500249[eax*1+ebp] 223 lea ebp, DWORD PTR 1518500249[eax*1+ebp]
223 mov eax, edx 224 mov eax, edx
224 add ebx, ebp 225 add ecx, ebp
225 xor eax, edi 226 xor eax, edi
226 mov ebp, ebx 227 mov ebp, ecx
227 and eax, ecx 228 and eax, ebx
228 rol ebp, 5 229 rol ebp, 5
229 add ebp, esi 230 add ebp, esi
230 mov esi, DWORD PTR 44[esp] 231 mov esi, DWORD PTR 44[esp]
231 ror ecx, 1 232 ror ebx, 1
232 xor eax, edi 233 xor eax, edi
233 ror ecx, 1 234 ror ebx, 1
234 lea ebp, DWORD PTR 1518500249[esi*1+ebp] 235 lea ebp, DWORD PTR 1518500249[esi*1+ebp]
235 add eax, ebp 236 add eax, ebp
236 ; 00_15 12 237 ; 00_15 12
237 mov esi, ecx 238 mov esi, ebx
238 mov ebp, eax 239 mov ebp, eax
239 xor esi, edx 240 xor esi, edx
240 rol ebp, 5 241 rol ebp, 5
241 and esi, ebx 242 and esi, ecx
242 add ebp, edi 243 add ebp, edi
243 ror ebx, 1 244 ror ecx, 1
244 mov edi, DWORD PTR 48[esp] 245 mov edi, DWORD PTR 48[esp]
245 ror ebx, 1 246 ror ecx, 1
246 xor esi, edx 247 xor esi, edx
247 lea ebp, DWORD PTR 1518500249[edi*1+ebp] 248 lea ebp, DWORD PTR 1518500249[edi*1+ebp]
248 mov edi, ebx 249 mov edi, ecx
249 add esi, ebp 250 add esi, ebp
250 xor edi, ecx 251 xor edi, ebx
251 mov ebp, esi 252 mov ebp, esi
252 and edi, eax 253 and edi, eax
253 rol ebp, 5 254 rol ebp, 5
254 add ebp, edx 255 add ebp, edx
255 mov edx, DWORD PTR 52[esp] 256 mov edx, DWORD PTR 52[esp]
256 ror eax, 1 257 ror eax, 1
257 xor edi, ecx 258 xor edi, ebx
258 ror eax, 1 259 ror eax, 1
259 lea ebp, DWORD PTR 1518500249[edx*1+ebp] 260 lea ebp, DWORD PTR 1518500249[edx*1+ebp]
260 add edi, ebp 261 add edi, ebp
261 ; 00_15 14 262 ; 00_15 14
262 mov edx, eax 263 mov edx, eax
263 mov ebp, edi 264 mov ebp, edi
264 xor edx, ebx 265 xor edx, ecx
265 rol ebp, 5 266 rol ebp, 5
266 and edx, esi 267 and edx, esi
267 add ebp, ecx 268 add ebp, ebx
268 ror esi, 1 269 ror esi, 1
269 mov ecx, DWORD PTR 56[esp] 270 mov ebx, DWORD PTR 56[esp]
270 ror esi, 1 271 ror esi, 1
271 xor edx, ebx 272 xor edx, ecx
272 lea ebp, DWORD PTR 1518500249[ecx*1+ebp] 273 lea ebp, DWORD PTR 1518500249[ebx*1+ebp]
273 mov ecx, esi 274 mov ebx, esi
274 add edx, ebp 275 add edx, ebp
275 xor ecx, eax 276 xor ebx, eax
276 mov ebp, edx 277 mov ebp, edx
277 and ecx, edi 278 and ebx, edi
278 rol ebp, 5 279 rol ebp, 5
279 add ebp, ebx 280 add ebp, ecx
280 mov ebx, DWORD PTR 60[esp] 281 mov ecx, DWORD PTR 60[esp]
281 ror edi, 1 282 ror edi, 1
282 xor ecx, eax 283 xor ebx, eax
283 ror edi, 1 284 ror edi, 1
284 lea ebp, DWORD PTR 1518500249[ebx*1+ebp] 285 lea ebp, DWORD PTR 1518500249[ecx*1+ebp]
285 add ecx, ebp 286 add ebx, ebp
286 ; 16_19 16 287 ; 16_19 16
287 nop 288 nop
288 mov ebp, DWORD PTR [esp] 289 mov ebp, DWORD PTR [esp]
289 mov ebx, DWORD PTR 8[esp] 290 mov ecx, DWORD PTR 8[esp]
290 xor ebx, ebp 291 xor ecx, ebp
291 mov ebp, DWORD PTR 32[esp] 292 mov ebp, DWORD PTR 32[esp]
292 xor ebx, ebp 293 xor ecx, ebp
293 mov ebp, DWORD PTR 52[esp] 294 mov ebp, DWORD PTR 52[esp]
294 xor ebx, ebp 295 xor ecx, ebp
295 mov ebp, edi 296 mov ebp, edi
296 rol ebx, 1 297 rol ecx, 1
297 xor ebp, esi 298 xor ebp, esi
298 mov DWORD PTR [esp],ebx 299 mov DWORD PTR [esp],ecx
299 and ebp, edx 300 and ebp, edx
300 lea ebx, DWORD PTR 1518500249[eax*1+ebx] 301 lea ecx, DWORD PTR 1518500249[eax*1+ecx]
301 xor ebp, esi 302 xor ebp, esi
302 mov eax, ecx 303 mov eax, ebx
303 add ebx, ebp 304 add ecx, ebp
304 rol eax, 5 305 rol eax, 5
305 ror edx, 1 306 ror edx, 1
306 add ebx, eax 307 add ecx, eax
307 mov eax, DWORD PTR 4[esp] 308 mov eax, DWORD PTR 4[esp]
308 mov ebp, DWORD PTR 12[esp] 309 mov ebp, DWORD PTR 12[esp]
309 xor eax, ebp 310 xor eax, ebp
@@ -316,14 +317,14 @@ L000start:
316 mov ebp, edx 317 mov ebp, edx
317 xor ebp, edi 318 xor ebp, edi
318 mov DWORD PTR 4[esp],eax 319 mov DWORD PTR 4[esp],eax
319 and ebp, ecx 320 and ebp, ebx
320 lea eax, DWORD PTR 1518500249[esi*1+eax] 321 lea eax, DWORD PTR 1518500249[esi*1+eax]
321 xor ebp, edi 322 xor ebp, edi
322 mov esi, ebx 323 mov esi, ecx
323 rol esi, 5 324 rol esi, 5
324 ror ecx, 1 325 ror ebx, 1
325 add eax, esi 326 add eax, esi
326 ror ecx, 1 327 ror ebx, 1
327 add eax, ebp 328 add eax, ebp
328 ; 16_19 18 329 ; 16_19 18
329 mov ebp, DWORD PTR 8[esp] 330 mov ebp, DWORD PTR 8[esp]
@@ -333,17 +334,17 @@ L000start:
333 xor esi, ebp 334 xor esi, ebp
334 mov ebp, DWORD PTR 60[esp] 335 mov ebp, DWORD PTR 60[esp]
335 xor esi, ebp 336 xor esi, ebp
336 mov ebp, ecx 337 mov ebp, ebx
337 rol esi, 1 338 rol esi, 1
338 xor ebp, edx 339 xor ebp, edx
339 mov DWORD PTR 8[esp],esi 340 mov DWORD PTR 8[esp],esi
340 and ebp, ebx 341 and ebp, ecx
341 lea esi, DWORD PTR 1518500249[edi*1+esi] 342 lea esi, DWORD PTR 1518500249[edi*1+esi]
342 xor ebp, edx 343 xor ebp, edx
343 mov edi, eax 344 mov edi, eax
344 add esi, ebp 345 add esi, ebp
345 rol edi, 5 346 rol edi, 5
346 ror ebx, 1 347 ror ecx, 1
347 add esi, edi 348 add esi, edi
348 mov edi, DWORD PTR 12[esp] 349 mov edi, DWORD PTR 12[esp]
349 mov ebp, DWORD PTR 20[esp] 350 mov ebp, DWORD PTR 20[esp]
@@ -351,15 +352,15 @@ L000start:
351 mov ebp, DWORD PTR 44[esp] 352 mov ebp, DWORD PTR 44[esp]
352 xor edi, ebp 353 xor edi, ebp
353 mov ebp, DWORD PTR [esp] 354 mov ebp, DWORD PTR [esp]
354 ror ebx, 1 355 ror ecx, 1
355 xor edi, ebp 356 xor edi, ebp
356 rol edi, 1 357 rol edi, 1
357 mov ebp, ebx 358 mov ebp, ecx
358 xor ebp, ecx 359 xor ebp, ebx
359 mov DWORD PTR 12[esp],edi 360 mov DWORD PTR 12[esp],edi
360 and ebp, eax 361 and ebp, eax
361 lea edi, DWORD PTR 1518500249[edx*1+edi] 362 lea edi, DWORD PTR 1518500249[edx*1+edi]
362 xor ebp, ecx 363 xor ebp, ebx
363 mov edx, esi 364 mov edx, esi
364 rol edx, 5 365 rol edx, 5
365 ror eax, 1 366 ror eax, 1
@@ -378,54 +379,54 @@ L000start:
378 rol edx, 1 379 rol edx, 1
379 xor ebp, eax 380 xor ebp, eax
380 mov DWORD PTR 16[esp],edx 381 mov DWORD PTR 16[esp],edx
381 xor ebp, ebx 382 xor ebp, ecx
382 lea edx, DWORD PTR 1859775393[ecx*1+edx] 383 lea edx, DWORD PTR 1859775393[ebx*1+edx]
383 mov ecx, edi 384 mov ebx, edi
384 rol ecx, 5 385 rol ebx, 5
385 ror esi, 1 386 ror esi, 1
386 add ecx, ebp 387 add ebx, ebp
387 ror esi, 1 388 ror esi, 1
388 add edx, ecx 389 add edx, ebx
389 ; 20_39 21 390 ; 20_39 21
390 mov ecx, DWORD PTR 20[esp] 391 mov ebx, DWORD PTR 20[esp]
391 mov ebp, DWORD PTR 28[esp] 392 mov ebp, DWORD PTR 28[esp]
392 xor ecx, ebp 393 xor ebx, ebp
393 mov ebp, DWORD PTR 52[esp] 394 mov ebp, DWORD PTR 52[esp]
394 xor ecx, ebp 395 xor ebx, ebp
395 mov ebp, DWORD PTR 8[esp] 396 mov ebp, DWORD PTR 8[esp]
396 xor ecx, ebp 397 xor ebx, ebp
397 mov ebp, edi 398 mov ebp, edi
398 rol ecx, 1 399 rol ebx, 1
399 xor ebp, esi 400 xor ebp, esi
400 mov DWORD PTR 20[esp],ecx 401 mov DWORD PTR 20[esp],ebx
401 xor ebp, eax 402 xor ebp, eax
402 lea ecx, DWORD PTR 1859775393[ebx*1+ecx] 403 lea ebx, DWORD PTR 1859775393[ecx*1+ebx]
403 mov ebx, edx 404 mov ecx, edx
404 rol ebx, 5 405 rol ecx, 5
405 ror edi, 1 406 ror edi, 1
406 add ebx, ebp 407 add ecx, ebp
407 ror edi, 1 408 ror edi, 1
408 add ecx, ebx 409 add ebx, ecx
409 ; 20_39 22 410 ; 20_39 22
410 mov ebx, DWORD PTR 24[esp] 411 mov ecx, DWORD PTR 24[esp]
411 mov ebp, DWORD PTR 32[esp] 412 mov ebp, DWORD PTR 32[esp]
412 xor ebx, ebp 413 xor ecx, ebp
413 mov ebp, DWORD PTR 56[esp] 414 mov ebp, DWORD PTR 56[esp]
414 xor ebx, ebp 415 xor ecx, ebp
415 mov ebp, DWORD PTR 12[esp] 416 mov ebp, DWORD PTR 12[esp]
416 xor ebx, ebp 417 xor ecx, ebp
417 mov ebp, edx 418 mov ebp, edx
418 rol ebx, 1 419 rol ecx, 1
419 xor ebp, edi 420 xor ebp, edi
420 mov DWORD PTR 24[esp],ebx 421 mov DWORD PTR 24[esp],ecx
421 xor ebp, esi 422 xor ebp, esi
422 lea ebx, DWORD PTR 1859775393[eax*1+ebx] 423 lea ecx, DWORD PTR 1859775393[eax*1+ecx]
423 mov eax, ecx 424 mov eax, ebx
424 rol eax, 5 425 rol eax, 5
425 ror edx, 1 426 ror edx, 1
426 add eax, ebp 427 add eax, ebp
427 ror edx, 1 428 ror edx, 1
428 add ebx, eax 429 add ecx, eax
429 ; 20_39 23 430 ; 20_39 23
430 mov eax, DWORD PTR 28[esp] 431 mov eax, DWORD PTR 28[esp]
431 mov ebp, DWORD PTR 36[esp] 432 mov ebp, DWORD PTR 36[esp]
@@ -434,17 +435,17 @@ L000start:
434 xor eax, ebp 435 xor eax, ebp
435 mov ebp, DWORD PTR 16[esp] 436 mov ebp, DWORD PTR 16[esp]
436 xor eax, ebp 437 xor eax, ebp
437 mov ebp, ecx 438 mov ebp, ebx
438 rol eax, 1 439 rol eax, 1
439 xor ebp, edx 440 xor ebp, edx
440 mov DWORD PTR 28[esp],eax 441 mov DWORD PTR 28[esp],eax
441 xor ebp, edi 442 xor ebp, edi
442 lea eax, DWORD PTR 1859775393[esi*1+eax] 443 lea eax, DWORD PTR 1859775393[esi*1+eax]
443 mov esi, ebx 444 mov esi, ecx
444 rol esi, 5 445 rol esi, 5
445 ror ecx, 1 446 ror ebx, 1
446 add esi, ebp 447 add esi, ebp
447 ror ecx, 1 448 ror ebx, 1
448 add eax, esi 449 add eax, esi
449 ; 20_39 24 450 ; 20_39 24
450 mov esi, DWORD PTR 32[esp] 451 mov esi, DWORD PTR 32[esp]
@@ -454,17 +455,17 @@ L000start:
454 xor esi, ebp 455 xor esi, ebp
455 mov ebp, DWORD PTR 20[esp] 456 mov ebp, DWORD PTR 20[esp]
456 xor esi, ebp 457 xor esi, ebp
457 mov ebp, ebx 458 mov ebp, ecx
458 rol esi, 1 459 rol esi, 1
459 xor ebp, ecx 460 xor ebp, ebx
460 mov DWORD PTR 32[esp],esi 461 mov DWORD PTR 32[esp],esi
461 xor ebp, edx 462 xor ebp, edx
462 lea esi, DWORD PTR 1859775393[edi*1+esi] 463 lea esi, DWORD PTR 1859775393[edi*1+esi]
463 mov edi, eax 464 mov edi, eax
464 rol edi, 5 465 rol edi, 5
465 ror ebx, 1 466 ror ecx, 1
466 add edi, ebp 467 add edi, ebp
467 ror ebx, 1 468 ror ecx, 1
468 add esi, edi 469 add esi, edi
469 ; 20_39 25 470 ; 20_39 25
470 mov edi, DWORD PTR 36[esp] 471 mov edi, DWORD PTR 36[esp]
@@ -476,9 +477,9 @@ L000start:
476 xor edi, ebp 477 xor edi, ebp
477 mov ebp, eax 478 mov ebp, eax
478 rol edi, 1 479 rol edi, 1
479 xor ebp, ebx
480 mov DWORD PTR 36[esp],edi
481 xor ebp, ecx 480 xor ebp, ecx
481 mov DWORD PTR 36[esp],edi
482 xor ebp, ebx
482 lea edi, DWORD PTR 1859775393[edx*1+edi] 483 lea edi, DWORD PTR 1859775393[edx*1+edi]
483 mov edx, esi 484 mov edx, esi
484 rol edx, 5 485 rol edx, 5
@@ -498,54 +499,54 @@ L000start:
498 rol edx, 1 499 rol edx, 1
499 xor ebp, eax 500 xor ebp, eax
500 mov DWORD PTR 40[esp],edx 501 mov DWORD PTR 40[esp],edx
501 xor ebp, ebx 502 xor ebp, ecx
502 lea edx, DWORD PTR 1859775393[ecx*1+edx] 503 lea edx, DWORD PTR 1859775393[ebx*1+edx]
503 mov ecx, edi 504 mov ebx, edi
504 rol ecx, 5 505 rol ebx, 5
505 ror esi, 1 506 ror esi, 1
506 add ecx, ebp 507 add ebx, ebp
507 ror esi, 1 508 ror esi, 1
508 add edx, ecx 509 add edx, ebx
509 ; 20_39 27 510 ; 20_39 27
510 mov ecx, DWORD PTR 44[esp] 511 mov ebx, DWORD PTR 44[esp]
511 mov ebp, DWORD PTR 52[esp] 512 mov ebp, DWORD PTR 52[esp]
512 xor ecx, ebp 513 xor ebx, ebp
513 mov ebp, DWORD PTR 12[esp] 514 mov ebp, DWORD PTR 12[esp]
514 xor ecx, ebp 515 xor ebx, ebp
515 mov ebp, DWORD PTR 32[esp] 516 mov ebp, DWORD PTR 32[esp]
516 xor ecx, ebp 517 xor ebx, ebp
517 mov ebp, edi 518 mov ebp, edi
518 rol ecx, 1 519 rol ebx, 1
519 xor ebp, esi 520 xor ebp, esi
520 mov DWORD PTR 44[esp],ecx 521 mov DWORD PTR 44[esp],ebx
521 xor ebp, eax 522 xor ebp, eax
522 lea ecx, DWORD PTR 1859775393[ebx*1+ecx] 523 lea ebx, DWORD PTR 1859775393[ecx*1+ebx]
523 mov ebx, edx 524 mov ecx, edx
524 rol ebx, 5 525 rol ecx, 5
525 ror edi, 1 526 ror edi, 1
526 add ebx, ebp 527 add ecx, ebp
527 ror edi, 1 528 ror edi, 1
528 add ecx, ebx 529 add ebx, ecx
529 ; 20_39 28 530 ; 20_39 28
530 mov ebx, DWORD PTR 48[esp] 531 mov ecx, DWORD PTR 48[esp]
531 mov ebp, DWORD PTR 56[esp] 532 mov ebp, DWORD PTR 56[esp]
532 xor ebx, ebp 533 xor ecx, ebp
533 mov ebp, DWORD PTR 16[esp] 534 mov ebp, DWORD PTR 16[esp]
534 xor ebx, ebp 535 xor ecx, ebp
535 mov ebp, DWORD PTR 36[esp] 536 mov ebp, DWORD PTR 36[esp]
536 xor ebx, ebp 537 xor ecx, ebp
537 mov ebp, edx 538 mov ebp, edx
538 rol ebx, 1 539 rol ecx, 1
539 xor ebp, edi 540 xor ebp, edi
540 mov DWORD PTR 48[esp],ebx 541 mov DWORD PTR 48[esp],ecx
541 xor ebp, esi 542 xor ebp, esi
542 lea ebx, DWORD PTR 1859775393[eax*1+ebx] 543 lea ecx, DWORD PTR 1859775393[eax*1+ecx]
543 mov eax, ecx 544 mov eax, ebx
544 rol eax, 5 545 rol eax, 5
545 ror edx, 1 546 ror edx, 1
546 add eax, ebp 547 add eax, ebp
547 ror edx, 1 548 ror edx, 1
548 add ebx, eax 549 add ecx, eax
549 ; 20_39 29 550 ; 20_39 29
550 mov eax, DWORD PTR 52[esp] 551 mov eax, DWORD PTR 52[esp]
551 mov ebp, DWORD PTR 60[esp] 552 mov ebp, DWORD PTR 60[esp]
@@ -554,17 +555,17 @@ L000start:
554 xor eax, ebp 555 xor eax, ebp
555 mov ebp, DWORD PTR 40[esp] 556 mov ebp, DWORD PTR 40[esp]
556 xor eax, ebp 557 xor eax, ebp
557 mov ebp, ecx 558 mov ebp, ebx
558 rol eax, 1 559 rol eax, 1
559 xor ebp, edx 560 xor ebp, edx
560 mov DWORD PTR 52[esp],eax 561 mov DWORD PTR 52[esp],eax
561 xor ebp, edi 562 xor ebp, edi
562 lea eax, DWORD PTR 1859775393[esi*1+eax] 563 lea eax, DWORD PTR 1859775393[esi*1+eax]
563 mov esi, ebx 564 mov esi, ecx
564 rol esi, 5 565 rol esi, 5
565 ror ecx, 1 566 ror ebx, 1
566 add esi, ebp 567 add esi, ebp
567 ror ecx, 1 568 ror ebx, 1
568 add eax, esi 569 add eax, esi
569 ; 20_39 30 570 ; 20_39 30
570 mov esi, DWORD PTR 56[esp] 571 mov esi, DWORD PTR 56[esp]
@@ -574,17 +575,17 @@ L000start:
574 xor esi, ebp 575 xor esi, ebp
575 mov ebp, DWORD PTR 44[esp] 576 mov ebp, DWORD PTR 44[esp]
576 xor esi, ebp 577 xor esi, ebp
577 mov ebp, ebx 578 mov ebp, ecx
578 rol esi, 1 579 rol esi, 1
579 xor ebp, ecx 580 xor ebp, ebx
580 mov DWORD PTR 56[esp],esi 581 mov DWORD PTR 56[esp],esi
581 xor ebp, edx 582 xor ebp, edx
582 lea esi, DWORD PTR 1859775393[edi*1+esi] 583 lea esi, DWORD PTR 1859775393[edi*1+esi]
583 mov edi, eax 584 mov edi, eax
584 rol edi, 5 585 rol edi, 5
585 ror ebx, 1 586 ror ecx, 1
586 add edi, ebp 587 add edi, ebp
587 ror ebx, 1 588 ror ecx, 1
588 add esi, edi 589 add esi, edi
589 ; 20_39 31 590 ; 20_39 31
590 mov edi, DWORD PTR 60[esp] 591 mov edi, DWORD PTR 60[esp]
@@ -596,9 +597,9 @@ L000start:
596 xor edi, ebp 597 xor edi, ebp
597 mov ebp, eax 598 mov ebp, eax
598 rol edi, 1 599 rol edi, 1
599 xor ebp, ebx
600 mov DWORD PTR 60[esp],edi
601 xor ebp, ecx 600 xor ebp, ecx
601 mov DWORD PTR 60[esp],edi
602 xor ebp, ebx
602 lea edi, DWORD PTR 1859775393[edx*1+edi] 603 lea edi, DWORD PTR 1859775393[edx*1+edi]
603 mov edx, esi 604 mov edx, esi
604 rol edx, 5 605 rol edx, 5
@@ -618,54 +619,54 @@ L000start:
618 rol edx, 1 619 rol edx, 1
619 xor ebp, eax 620 xor ebp, eax
620 mov DWORD PTR [esp],edx 621 mov DWORD PTR [esp],edx
621 xor ebp, ebx 622 xor ebp, ecx
622 lea edx, DWORD PTR 1859775393[ecx*1+edx] 623 lea edx, DWORD PTR 1859775393[ebx*1+edx]
623 mov ecx, edi 624 mov ebx, edi
624 rol ecx, 5 625 rol ebx, 5
625 ror esi, 1 626 ror esi, 1
626 add ecx, ebp 627 add ebx, ebp
627 ror esi, 1 628 ror esi, 1
628 add edx, ecx 629 add edx, ebx
629 ; 20_39 33 630 ; 20_39 33
630 mov ecx, DWORD PTR 4[esp] 631 mov ebx, DWORD PTR 4[esp]
631 mov ebp, DWORD PTR 12[esp] 632 mov ebp, DWORD PTR 12[esp]
632 xor ecx, ebp 633 xor ebx, ebp
633 mov ebp, DWORD PTR 36[esp] 634 mov ebp, DWORD PTR 36[esp]
634 xor ecx, ebp 635 xor ebx, ebp
635 mov ebp, DWORD PTR 56[esp] 636 mov ebp, DWORD PTR 56[esp]
636 xor ecx, ebp 637 xor ebx, ebp
637 mov ebp, edi 638 mov ebp, edi
638 rol ecx, 1 639 rol ebx, 1
639 xor ebp, esi 640 xor ebp, esi
640 mov DWORD PTR 4[esp],ecx 641 mov DWORD PTR 4[esp],ebx
641 xor ebp, eax 642 xor ebp, eax
642 lea ecx, DWORD PTR 1859775393[ebx*1+ecx] 643 lea ebx, DWORD PTR 1859775393[ecx*1+ebx]
643 mov ebx, edx 644 mov ecx, edx
644 rol ebx, 5 645 rol ecx, 5
645 ror edi, 1 646 ror edi, 1
646 add ebx, ebp 647 add ecx, ebp
647 ror edi, 1 648 ror edi, 1
648 add ecx, ebx 649 add ebx, ecx
649 ; 20_39 34 650 ; 20_39 34
650 mov ebx, DWORD PTR 8[esp] 651 mov ecx, DWORD PTR 8[esp]
651 mov ebp, DWORD PTR 16[esp] 652 mov ebp, DWORD PTR 16[esp]
652 xor ebx, ebp 653 xor ecx, ebp
653 mov ebp, DWORD PTR 40[esp] 654 mov ebp, DWORD PTR 40[esp]
654 xor ebx, ebp 655 xor ecx, ebp
655 mov ebp, DWORD PTR 60[esp] 656 mov ebp, DWORD PTR 60[esp]
656 xor ebx, ebp 657 xor ecx, ebp
657 mov ebp, edx 658 mov ebp, edx
658 rol ebx, 1 659 rol ecx, 1
659 xor ebp, edi 660 xor ebp, edi
660 mov DWORD PTR 8[esp],ebx 661 mov DWORD PTR 8[esp],ecx
661 xor ebp, esi 662 xor ebp, esi
662 lea ebx, DWORD PTR 1859775393[eax*1+ebx] 663 lea ecx, DWORD PTR 1859775393[eax*1+ecx]
663 mov eax, ecx 664 mov eax, ebx
664 rol eax, 5 665 rol eax, 5
665 ror edx, 1 666 ror edx, 1
666 add eax, ebp 667 add eax, ebp
667 ror edx, 1 668 ror edx, 1
668 add ebx, eax 669 add ecx, eax
669 ; 20_39 35 670 ; 20_39 35
670 mov eax, DWORD PTR 12[esp] 671 mov eax, DWORD PTR 12[esp]
671 mov ebp, DWORD PTR 20[esp] 672 mov ebp, DWORD PTR 20[esp]
@@ -674,17 +675,17 @@ L000start:
674 xor eax, ebp 675 xor eax, ebp
675 mov ebp, DWORD PTR [esp] 676 mov ebp, DWORD PTR [esp]
676 xor eax, ebp 677 xor eax, ebp
677 mov ebp, ecx 678 mov ebp, ebx
678 rol eax, 1 679 rol eax, 1
679 xor ebp, edx 680 xor ebp, edx
680 mov DWORD PTR 12[esp],eax 681 mov DWORD PTR 12[esp],eax
681 xor ebp, edi 682 xor ebp, edi
682 lea eax, DWORD PTR 1859775393[esi*1+eax] 683 lea eax, DWORD PTR 1859775393[esi*1+eax]
683 mov esi, ebx 684 mov esi, ecx
684 rol esi, 5 685 rol esi, 5
685 ror ecx, 1 686 ror ebx, 1
686 add esi, ebp 687 add esi, ebp
687 ror ecx, 1 688 ror ebx, 1
688 add eax, esi 689 add eax, esi
689 ; 20_39 36 690 ; 20_39 36
690 mov esi, DWORD PTR 16[esp] 691 mov esi, DWORD PTR 16[esp]
@@ -694,17 +695,17 @@ L000start:
694 xor esi, ebp 695 xor esi, ebp
695 mov ebp, DWORD PTR 4[esp] 696 mov ebp, DWORD PTR 4[esp]
696 xor esi, ebp 697 xor esi, ebp
697 mov ebp, ebx 698 mov ebp, ecx
698 rol esi, 1 699 rol esi, 1
699 xor ebp, ecx 700 xor ebp, ebx
700 mov DWORD PTR 16[esp],esi 701 mov DWORD PTR 16[esp],esi
701 xor ebp, edx 702 xor ebp, edx
702 lea esi, DWORD PTR 1859775393[edi*1+esi] 703 lea esi, DWORD PTR 1859775393[edi*1+esi]
703 mov edi, eax 704 mov edi, eax
704 rol edi, 5 705 rol edi, 5
705 ror ebx, 1 706 ror ecx, 1
706 add edi, ebp 707 add edi, ebp
707 ror ebx, 1 708 ror ecx, 1
708 add esi, edi 709 add esi, edi
709 ; 20_39 37 710 ; 20_39 37
710 mov edi, DWORD PTR 20[esp] 711 mov edi, DWORD PTR 20[esp]
@@ -716,9 +717,9 @@ L000start:
716 xor edi, ebp 717 xor edi, ebp
717 mov ebp, eax 718 mov ebp, eax
718 rol edi, 1 719 rol edi, 1
719 xor ebp, ebx
720 mov DWORD PTR 20[esp],edi
721 xor ebp, ecx 720 xor ebp, ecx
721 mov DWORD PTR 20[esp],edi
722 xor ebp, ebx
722 lea edi, DWORD PTR 1859775393[edx*1+edi] 723 lea edi, DWORD PTR 1859775393[edx*1+edi]
723 mov edx, esi 724 mov edx, esi
724 rol edx, 5 725 rol edx, 5
@@ -738,57 +739,57 @@ L000start:
738 rol edx, 1 739 rol edx, 1
739 xor ebp, eax 740 xor ebp, eax
740 mov DWORD PTR 24[esp],edx 741 mov DWORD PTR 24[esp],edx
741 xor ebp, ebx 742 xor ebp, ecx
742 lea edx, DWORD PTR 1859775393[ecx*1+edx] 743 lea edx, DWORD PTR 1859775393[ebx*1+edx]
743 mov ecx, edi 744 mov ebx, edi
744 rol ecx, 5 745 rol ebx, 5
745 ror esi, 1 746 ror esi, 1
746 add ecx, ebp 747 add ebx, ebp
747 ror esi, 1 748 ror esi, 1
748 add edx, ecx 749 add edx, ebx
749 ; 20_39 39 750 ; 20_39 39
750 mov ecx, DWORD PTR 28[esp] 751 mov ebx, DWORD PTR 28[esp]
751 mov ebp, DWORD PTR 36[esp] 752 mov ebp, DWORD PTR 36[esp]
752 xor ecx, ebp 753 xor ebx, ebp
753 mov ebp, DWORD PTR 60[esp] 754 mov ebp, DWORD PTR 60[esp]
754 xor ecx, ebp 755 xor ebx, ebp
755 mov ebp, DWORD PTR 16[esp] 756 mov ebp, DWORD PTR 16[esp]
756 xor ecx, ebp 757 xor ebx, ebp
757 mov ebp, edi 758 mov ebp, edi
758 rol ecx, 1 759 rol ebx, 1
759 xor ebp, esi 760 xor ebp, esi
760 mov DWORD PTR 28[esp],ecx 761 mov DWORD PTR 28[esp],ebx
761 xor ebp, eax 762 xor ebp, eax
762 lea ecx, DWORD PTR 1859775393[ebx*1+ecx] 763 lea ebx, DWORD PTR 1859775393[ecx*1+ebx]
763 mov ebx, edx 764 mov ecx, edx
764 rol ebx, 5 765 rol ecx, 5
765 ror edi, 1 766 ror edi, 1
766 add ebx, ebp 767 add ecx, ebp
767 ror edi, 1 768 ror edi, 1
768 add ecx, ebx 769 add ebx, ecx
769 ; 40_59 40 770 ; 40_59 40
770 mov ebx, DWORD PTR 32[esp] 771 mov ecx, DWORD PTR 32[esp]
771 mov ebp, DWORD PTR 40[esp] 772 mov ebp, DWORD PTR 40[esp]
772 xor ebx, ebp 773 xor ecx, ebp
773 mov ebp, DWORD PTR [esp] 774 mov ebp, DWORD PTR [esp]
774 xor ebx, ebp 775 xor ecx, ebp
775 mov ebp, DWORD PTR 20[esp] 776 mov ebp, DWORD PTR 20[esp]
776 xor ebx, ebp 777 xor ecx, ebp
777 mov ebp, edx 778 mov ebp, edx
778 rol ebx, 1 779 rol ecx, 1
779 or ebp, edi 780 or ebp, edi
780 mov DWORD PTR 32[esp],ebx 781 mov DWORD PTR 32[esp],ecx
781 and ebp, esi 782 and ebp, esi
782 lea ebx, DWORD PTR 2400959708[eax*1+ebx] 783 lea ecx, DWORD PTR 2400959708[eax*1+ecx]
783 mov eax, edx 784 mov eax, edx
784 ror edx, 1 785 ror edx, 1
785 and eax, edi 786 and eax, edi
786 or ebp, eax 787 or ebp, eax
787 mov eax, ecx 788 mov eax, ebx
788 rol eax, 5 789 rol eax, 5
789 add ebp, eax 790 add ebp, eax
790 mov eax, DWORD PTR 36[esp] 791 mov eax, DWORD PTR 36[esp]
791 add ebx, ebp 792 add ecx, ebp
792 mov ebp, DWORD PTR 44[esp] 793 mov ebp, DWORD PTR 44[esp]
793 xor eax, ebp 794 xor eax, ebp
794 mov ebp, DWORD PTR 4[esp] 795 mov ebp, DWORD PTR 4[esp]
@@ -797,19 +798,19 @@ L000start:
797 ror edx, 1 798 ror edx, 1
798 xor eax, ebp 799 xor eax, ebp
799 rol eax, 1 800 rol eax, 1
800 mov ebp, ecx 801 mov ebp, ebx
801 mov DWORD PTR 36[esp],eax 802 mov DWORD PTR 36[esp],eax
802 or ebp, edx 803 or ebp, edx
803 lea eax, DWORD PTR 2400959708[esi*1+eax] 804 lea eax, DWORD PTR 2400959708[esi*1+eax]
804 mov esi, ecx 805 mov esi, ebx
805 and ebp, edi 806 and ebp, edi
806 and esi, edx 807 and esi, edx
807 or ebp, esi 808 or ebp, esi
808 mov esi, ebx 809 mov esi, ecx
809 rol esi, 5 810 rol esi, 5
810 ror ecx, 1 811 ror ebx, 1
811 add ebp, esi 812 add ebp, esi
812 ror ecx, 1 813 ror ebx, 1
813 add eax, ebp 814 add eax, ebp
814 ; 40_59 41 815 ; 40_59 41
815 ; 40_59 42 816 ; 40_59 42
@@ -820,15 +821,15 @@ L000start:
820 xor esi, ebp 821 xor esi, ebp
821 mov ebp, DWORD PTR 28[esp] 822 mov ebp, DWORD PTR 28[esp]
822 xor esi, ebp 823 xor esi, ebp
823 mov ebp, ebx 824 mov ebp, ecx
824 rol esi, 1 825 rol esi, 1
825 or ebp, ecx 826 or ebp, ebx
826 mov DWORD PTR 40[esp],esi 827 mov DWORD PTR 40[esp],esi
827 and ebp, edx 828 and ebp, edx
828 lea esi, DWORD PTR 2400959708[edi*1+esi] 829 lea esi, DWORD PTR 2400959708[edi*1+esi]
829 mov edi, ebx 830 mov edi, ecx
830 ror ebx, 1 831 ror ecx, 1
831 and edi, ecx 832 and edi, ebx
832 or ebp, edi 833 or ebp, edi
833 mov edi, eax 834 mov edi, eax
834 rol edi, 5 835 rol edi, 5
@@ -840,16 +841,16 @@ L000start:
840 mov ebp, DWORD PTR 12[esp] 841 mov ebp, DWORD PTR 12[esp]
841 xor edi, ebp 842 xor edi, ebp
842 mov ebp, DWORD PTR 32[esp] 843 mov ebp, DWORD PTR 32[esp]
843 ror ebx, 1 844 ror ecx, 1
844 xor edi, ebp 845 xor edi, ebp
845 rol edi, 1 846 rol edi, 1
846 mov ebp, eax 847 mov ebp, eax
847 mov DWORD PTR 44[esp],edi 848 mov DWORD PTR 44[esp],edi
848 or ebp, ebx 849 or ebp, ecx
849 lea edi, DWORD PTR 2400959708[edx*1+edi] 850 lea edi, DWORD PTR 2400959708[edx*1+edi]
850 mov edx, eax 851 mov edx, eax
851 and ebp, ecx 852 and ebp, ebx
852 and edx, ebx 853 and edx, ecx
853 or ebp, edx 854 or ebp, edx
854 mov edx, esi 855 mov edx, esi
855 rol edx, 5 856 rol edx, 5
@@ -870,63 +871,63 @@ L000start:
870 rol edx, 1 871 rol edx, 1
871 or ebp, eax 872 or ebp, eax
872 mov DWORD PTR 48[esp],edx 873 mov DWORD PTR 48[esp],edx
873 and ebp, ebx 874 and ebp, ecx
874 lea edx, DWORD PTR 2400959708[ecx*1+edx] 875 lea edx, DWORD PTR 2400959708[ebx*1+edx]
875 mov ecx, esi 876 mov ebx, esi
876 ror esi, 1 877 ror esi, 1
877 and ecx, eax 878 and ebx, eax
878 or ebp, ecx 879 or ebp, ebx
879 mov ecx, edi 880 mov ebx, edi
880 rol ecx, 5 881 rol ebx, 5
881 add ebp, ecx 882 add ebp, ebx
882 mov ecx, DWORD PTR 52[esp] 883 mov ebx, DWORD PTR 52[esp]
883 add edx, ebp 884 add edx, ebp
884 mov ebp, DWORD PTR 60[esp] 885 mov ebp, DWORD PTR 60[esp]
885 xor ecx, ebp 886 xor ebx, ebp
886 mov ebp, DWORD PTR 20[esp] 887 mov ebp, DWORD PTR 20[esp]
887 xor ecx, ebp 888 xor ebx, ebp
888 mov ebp, DWORD PTR 40[esp] 889 mov ebp, DWORD PTR 40[esp]
889 ror esi, 1 890 ror esi, 1
890 xor ecx, ebp 891 xor ebx, ebp
891 rol ecx, 1 892 rol ebx, 1
892 mov ebp, edi 893 mov ebp, edi
893 mov DWORD PTR 52[esp],ecx 894 mov DWORD PTR 52[esp],ebx
894 or ebp, esi 895 or ebp, esi
895 lea ecx, DWORD PTR 2400959708[ebx*1+ecx] 896 lea ebx, DWORD PTR 2400959708[ecx*1+ebx]
896 mov ebx, edi 897 mov ecx, edi
897 and ebp, eax 898 and ebp, eax
898 and ebx, esi 899 and ecx, esi
899 or ebp, ebx 900 or ebp, ecx
900 mov ebx, edx 901 mov ecx, edx
901 rol ebx, 5 902 rol ecx, 5
902 ror edi, 1 903 ror edi, 1
903 add ebp, ebx 904 add ebp, ecx
904 ror edi, 1 905 ror edi, 1
905 add ecx, ebp 906 add ebx, ebp
906 ; 40_59 45 907 ; 40_59 45
907 ; 40_59 46 908 ; 40_59 46
908 mov ebx, DWORD PTR 56[esp] 909 mov ecx, DWORD PTR 56[esp]
909 mov ebp, DWORD PTR [esp] 910 mov ebp, DWORD PTR [esp]
910 xor ebx, ebp 911 xor ecx, ebp
911 mov ebp, DWORD PTR 24[esp] 912 mov ebp, DWORD PTR 24[esp]
912 xor ebx, ebp 913 xor ecx, ebp
913 mov ebp, DWORD PTR 44[esp] 914 mov ebp, DWORD PTR 44[esp]
914 xor ebx, ebp 915 xor ecx, ebp
915 mov ebp, edx 916 mov ebp, edx
916 rol ebx, 1 917 rol ecx, 1
917 or ebp, edi 918 or ebp, edi
918 mov DWORD PTR 56[esp],ebx 919 mov DWORD PTR 56[esp],ecx
919 and ebp, esi 920 and ebp, esi
920 lea ebx, DWORD PTR 2400959708[eax*1+ebx] 921 lea ecx, DWORD PTR 2400959708[eax*1+ecx]
921 mov eax, edx 922 mov eax, edx
922 ror edx, 1 923 ror edx, 1
923 and eax, edi 924 and eax, edi
924 or ebp, eax 925 or ebp, eax
925 mov eax, ecx 926 mov eax, ebx
926 rol eax, 5 927 rol eax, 5
927 add ebp, eax 928 add ebp, eax
928 mov eax, DWORD PTR 60[esp] 929 mov eax, DWORD PTR 60[esp]
929 add ebx, ebp 930 add ecx, ebp
930 mov ebp, DWORD PTR 4[esp] 931 mov ebp, DWORD PTR 4[esp]
931 xor eax, ebp 932 xor eax, ebp
932 mov ebp, DWORD PTR 28[esp] 933 mov ebp, DWORD PTR 28[esp]
@@ -935,19 +936,19 @@ L000start:
935 ror edx, 1 936 ror edx, 1
936 xor eax, ebp 937 xor eax, ebp
937 rol eax, 1 938 rol eax, 1
938 mov ebp, ecx 939 mov ebp, ebx
939 mov DWORD PTR 60[esp],eax 940 mov DWORD PTR 60[esp],eax
940 or ebp, edx 941 or ebp, edx
941 lea eax, DWORD PTR 2400959708[esi*1+eax] 942 lea eax, DWORD PTR 2400959708[esi*1+eax]
942 mov esi, ecx 943 mov esi, ebx
943 and ebp, edi 944 and ebp, edi
944 and esi, edx 945 and esi, edx
945 or ebp, esi 946 or ebp, esi
946 mov esi, ebx 947 mov esi, ecx
947 rol esi, 5 948 rol esi, 5
948 ror ecx, 1 949 ror ebx, 1
949 add ebp, esi 950 add ebp, esi
950 ror ecx, 1 951 ror ebx, 1
951 add eax, ebp 952 add eax, ebp
952 ; 40_59 47 953 ; 40_59 47
953 ; 40_59 48 954 ; 40_59 48
@@ -958,15 +959,15 @@ L000start:
958 xor esi, ebp 959 xor esi, ebp
959 mov ebp, DWORD PTR 52[esp] 960 mov ebp, DWORD PTR 52[esp]
960 xor esi, ebp 961 xor esi, ebp
961 mov ebp, ebx 962 mov ebp, ecx
962 rol esi, 1 963 rol esi, 1
963 or ebp, ecx 964 or ebp, ebx
964 mov DWORD PTR [esp],esi 965 mov DWORD PTR [esp],esi
965 and ebp, edx 966 and ebp, edx
966 lea esi, DWORD PTR 2400959708[edi*1+esi] 967 lea esi, DWORD PTR 2400959708[edi*1+esi]
967 mov edi, ebx 968 mov edi, ecx
968 ror ebx, 1 969 ror ecx, 1
969 and edi, ecx 970 and edi, ebx
970 or ebp, edi 971 or ebp, edi
971 mov edi, eax 972 mov edi, eax
972 rol edi, 5 973 rol edi, 5
@@ -978,16 +979,16 @@ L000start:
978 mov ebp, DWORD PTR 36[esp] 979 mov ebp, DWORD PTR 36[esp]
979 xor edi, ebp 980 xor edi, ebp
980 mov ebp, DWORD PTR 56[esp] 981 mov ebp, DWORD PTR 56[esp]
981 ror ebx, 1 982 ror ecx, 1
982 xor edi, ebp 983 xor edi, ebp
983 rol edi, 1 984 rol edi, 1
984 mov ebp, eax 985 mov ebp, eax
985 mov DWORD PTR 4[esp],edi 986 mov DWORD PTR 4[esp],edi
986 or ebp, ebx 987 or ebp, ecx
987 lea edi, DWORD PTR 2400959708[edx*1+edi] 988 lea edi, DWORD PTR 2400959708[edx*1+edi]
988 mov edx, eax 989 mov edx, eax
989 and ebp, ecx 990 and ebp, ebx
990 and edx, ebx 991 and edx, ecx
991 or ebp, edx 992 or ebp, edx
992 mov edx, esi 993 mov edx, esi
993 rol edx, 5 994 rol edx, 5
@@ -1008,63 +1009,63 @@ L000start:
1008 rol edx, 1 1009 rol edx, 1
1009 or ebp, eax 1010 or ebp, eax
1010 mov DWORD PTR 8[esp],edx 1011 mov DWORD PTR 8[esp],edx
1011 and ebp, ebx 1012 and ebp, ecx
1012 lea edx, DWORD PTR 2400959708[ecx*1+edx] 1013 lea edx, DWORD PTR 2400959708[ebx*1+edx]
1013 mov ecx, esi 1014 mov ebx, esi
1014 ror esi, 1 1015 ror esi, 1
1015 and ecx, eax 1016 and ebx, eax
1016 or ebp, ecx 1017 or ebp, ebx
1017 mov ecx, edi 1018 mov ebx, edi
1018 rol ecx, 5 1019 rol ebx, 5
1019 add ebp, ecx 1020 add ebp, ebx
1020 mov ecx, DWORD PTR 12[esp] 1021 mov ebx, DWORD PTR 12[esp]
1021 add edx, ebp 1022 add edx, ebp
1022 mov ebp, DWORD PTR 20[esp] 1023 mov ebp, DWORD PTR 20[esp]
1023 xor ecx, ebp 1024 xor ebx, ebp
1024 mov ebp, DWORD PTR 44[esp] 1025 mov ebp, DWORD PTR 44[esp]
1025 xor ecx, ebp 1026 xor ebx, ebp
1026 mov ebp, DWORD PTR [esp] 1027 mov ebp, DWORD PTR [esp]
1027 ror esi, 1 1028 ror esi, 1
1028 xor ecx, ebp 1029 xor ebx, ebp
1029 rol ecx, 1 1030 rol ebx, 1
1030 mov ebp, edi 1031 mov ebp, edi
1031 mov DWORD PTR 12[esp],ecx 1032 mov DWORD PTR 12[esp],ebx
1032 or ebp, esi 1033 or ebp, esi
1033 lea ecx, DWORD PTR 2400959708[ebx*1+ecx] 1034 lea ebx, DWORD PTR 2400959708[ecx*1+ebx]
1034 mov ebx, edi 1035 mov ecx, edi
1035 and ebp, eax 1036 and ebp, eax
1036 and ebx, esi 1037 and ecx, esi
1037 or ebp, ebx 1038 or ebp, ecx
1038 mov ebx, edx 1039 mov ecx, edx
1039 rol ebx, 5 1040 rol ecx, 5
1040 ror edi, 1 1041 ror edi, 1
1041 add ebp, ebx 1042 add ebp, ecx
1042 ror edi, 1 1043 ror edi, 1
1043 add ecx, ebp 1044 add ebx, ebp
1044 ; 40_59 51 1045 ; 40_59 51
1045 ; 40_59 52 1046 ; 40_59 52
1046 mov ebx, DWORD PTR 16[esp] 1047 mov ecx, DWORD PTR 16[esp]
1047 mov ebp, DWORD PTR 24[esp] 1048 mov ebp, DWORD PTR 24[esp]
1048 xor ebx, ebp 1049 xor ecx, ebp
1049 mov ebp, DWORD PTR 48[esp] 1050 mov ebp, DWORD PTR 48[esp]
1050 xor ebx, ebp 1051 xor ecx, ebp
1051 mov ebp, DWORD PTR 4[esp] 1052 mov ebp, DWORD PTR 4[esp]
1052 xor ebx, ebp 1053 xor ecx, ebp
1053 mov ebp, edx 1054 mov ebp, edx
1054 rol ebx, 1 1055 rol ecx, 1
1055 or ebp, edi 1056 or ebp, edi
1056 mov DWORD PTR 16[esp],ebx 1057 mov DWORD PTR 16[esp],ecx
1057 and ebp, esi 1058 and ebp, esi
1058 lea ebx, DWORD PTR 2400959708[eax*1+ebx] 1059 lea ecx, DWORD PTR 2400959708[eax*1+ecx]
1059 mov eax, edx 1060 mov eax, edx
1060 ror edx, 1 1061 ror edx, 1
1061 and eax, edi 1062 and eax, edi
1062 or ebp, eax 1063 or ebp, eax
1063 mov eax, ecx 1064 mov eax, ebx
1064 rol eax, 5 1065 rol eax, 5
1065 add ebp, eax 1066 add ebp, eax
1066 mov eax, DWORD PTR 20[esp] 1067 mov eax, DWORD PTR 20[esp]
1067 add ebx, ebp 1068 add ecx, ebp
1068 mov ebp, DWORD PTR 28[esp] 1069 mov ebp, DWORD PTR 28[esp]
1069 xor eax, ebp 1070 xor eax, ebp
1070 mov ebp, DWORD PTR 52[esp] 1071 mov ebp, DWORD PTR 52[esp]
@@ -1073,19 +1074,19 @@ L000start:
1073 ror edx, 1 1074 ror edx, 1
1074 xor eax, ebp 1075 xor eax, ebp
1075 rol eax, 1 1076 rol eax, 1
1076 mov ebp, ecx 1077 mov ebp, ebx
1077 mov DWORD PTR 20[esp],eax 1078 mov DWORD PTR 20[esp],eax
1078 or ebp, edx 1079 or ebp, edx
1079 lea eax, DWORD PTR 2400959708[esi*1+eax] 1080 lea eax, DWORD PTR 2400959708[esi*1+eax]
1080 mov esi, ecx 1081 mov esi, ebx
1081 and ebp, edi 1082 and ebp, edi
1082 and esi, edx 1083 and esi, edx
1083 or ebp, esi 1084 or ebp, esi
1084 mov esi, ebx 1085 mov esi, ecx
1085 rol esi, 5 1086 rol esi, 5
1086 ror ecx, 1 1087 ror ebx, 1
1087 add ebp, esi 1088 add ebp, esi
1088 ror ecx, 1 1089 ror ebx, 1
1089 add eax, ebp 1090 add eax, ebp
1090 ; 40_59 53 1091 ; 40_59 53
1091 ; 40_59 54 1092 ; 40_59 54
@@ -1096,15 +1097,15 @@ L000start:
1096 xor esi, ebp 1097 xor esi, ebp
1097 mov ebp, DWORD PTR 12[esp] 1098 mov ebp, DWORD PTR 12[esp]
1098 xor esi, ebp 1099 xor esi, ebp
1099 mov ebp, ebx 1100 mov ebp, ecx
1100 rol esi, 1 1101 rol esi, 1
1101 or ebp, ecx 1102 or ebp, ebx
1102 mov DWORD PTR 24[esp],esi 1103 mov DWORD PTR 24[esp],esi
1103 and ebp, edx 1104 and ebp, edx
1104 lea esi, DWORD PTR 2400959708[edi*1+esi] 1105 lea esi, DWORD PTR 2400959708[edi*1+esi]
1105 mov edi, ebx 1106 mov edi, ecx
1106 ror ebx, 1 1107 ror ecx, 1
1107 and edi, ecx 1108 and edi, ebx
1108 or ebp, edi 1109 or ebp, edi
1109 mov edi, eax 1110 mov edi, eax
1110 rol edi, 5 1111 rol edi, 5
@@ -1116,16 +1117,16 @@ L000start:
1116 mov ebp, DWORD PTR 60[esp] 1117 mov ebp, DWORD PTR 60[esp]
1117 xor edi, ebp 1118 xor edi, ebp
1118 mov ebp, DWORD PTR 16[esp] 1119 mov ebp, DWORD PTR 16[esp]
1119 ror ebx, 1 1120 ror ecx, 1
1120 xor edi, ebp 1121 xor edi, ebp
1121 rol edi, 1 1122 rol edi, 1
1122 mov ebp, eax 1123 mov ebp, eax
1123 mov DWORD PTR 28[esp],edi 1124 mov DWORD PTR 28[esp],edi
1124 or ebp, ebx 1125 or ebp, ecx
1125 lea edi, DWORD PTR 2400959708[edx*1+edi] 1126 lea edi, DWORD PTR 2400959708[edx*1+edi]
1126 mov edx, eax 1127 mov edx, eax
1127 and ebp, ecx 1128 and ebp, ebx
1128 and edx, ebx 1129 and edx, ecx
1129 or ebp, edx 1130 or ebp, edx
1130 mov edx, esi 1131 mov edx, esi
1131 rol edx, 5 1132 rol edx, 5
@@ -1146,63 +1147,63 @@ L000start:
1146 rol edx, 1 1147 rol edx, 1
1147 or ebp, eax 1148 or ebp, eax
1148 mov DWORD PTR 32[esp],edx 1149 mov DWORD PTR 32[esp],edx
1149 and ebp, ebx 1150 and ebp, ecx
1150 lea edx, DWORD PTR 2400959708[ecx*1+edx] 1151 lea edx, DWORD PTR 2400959708[ebx*1+edx]
1151 mov ecx, esi 1152 mov ebx, esi
1152 ror esi, 1 1153 ror esi, 1
1153 and ecx, eax 1154 and ebx, eax
1154 or ebp, ecx 1155 or ebp, ebx
1155 mov ecx, edi 1156 mov ebx, edi
1156 rol ecx, 5 1157 rol ebx, 5
1157 add ebp, ecx 1158 add ebp, ebx
1158 mov ecx, DWORD PTR 36[esp] 1159 mov ebx, DWORD PTR 36[esp]
1159 add edx, ebp 1160 add edx, ebp
1160 mov ebp, DWORD PTR 44[esp] 1161 mov ebp, DWORD PTR 44[esp]
1161 xor ecx, ebp 1162 xor ebx, ebp
1162 mov ebp, DWORD PTR 4[esp] 1163 mov ebp, DWORD PTR 4[esp]
1163 xor ecx, ebp 1164 xor ebx, ebp
1164 mov ebp, DWORD PTR 24[esp] 1165 mov ebp, DWORD PTR 24[esp]
1165 ror esi, 1 1166 ror esi, 1
1166 xor ecx, ebp 1167 xor ebx, ebp
1167 rol ecx, 1 1168 rol ebx, 1
1168 mov ebp, edi 1169 mov ebp, edi
1169 mov DWORD PTR 36[esp],ecx 1170 mov DWORD PTR 36[esp],ebx
1170 or ebp, esi 1171 or ebp, esi
1171 lea ecx, DWORD PTR 2400959708[ebx*1+ecx] 1172 lea ebx, DWORD PTR 2400959708[ecx*1+ebx]
1172 mov ebx, edi 1173 mov ecx, edi
1173 and ebp, eax 1174 and ebp, eax
1174 and ebx, esi 1175 and ecx, esi
1175 or ebp, ebx 1176 or ebp, ecx
1176 mov ebx, edx 1177 mov ecx, edx
1177 rol ebx, 5 1178 rol ecx, 5
1178 ror edi, 1 1179 ror edi, 1
1179 add ebp, ebx 1180 add ebp, ecx
1180 ror edi, 1 1181 ror edi, 1
1181 add ecx, ebp 1182 add ebx, ebp
1182 ; 40_59 57 1183 ; 40_59 57
1183 ; 40_59 58 1184 ; 40_59 58
1184 mov ebx, DWORD PTR 40[esp] 1185 mov ecx, DWORD PTR 40[esp]
1185 mov ebp, DWORD PTR 48[esp] 1186 mov ebp, DWORD PTR 48[esp]
1186 xor ebx, ebp 1187 xor ecx, ebp
1187 mov ebp, DWORD PTR 8[esp] 1188 mov ebp, DWORD PTR 8[esp]
1188 xor ebx, ebp 1189 xor ecx, ebp
1189 mov ebp, DWORD PTR 28[esp] 1190 mov ebp, DWORD PTR 28[esp]
1190 xor ebx, ebp 1191 xor ecx, ebp
1191 mov ebp, edx 1192 mov ebp, edx
1192 rol ebx, 1 1193 rol ecx, 1
1193 or ebp, edi 1194 or ebp, edi
1194 mov DWORD PTR 40[esp],ebx 1195 mov DWORD PTR 40[esp],ecx
1195 and ebp, esi 1196 and ebp, esi
1196 lea ebx, DWORD PTR 2400959708[eax*1+ebx] 1197 lea ecx, DWORD PTR 2400959708[eax*1+ecx]
1197 mov eax, edx 1198 mov eax, edx
1198 ror edx, 1 1199 ror edx, 1
1199 and eax, edi 1200 and eax, edi
1200 or ebp, eax 1201 or ebp, eax
1201 mov eax, ecx 1202 mov eax, ebx
1202 rol eax, 5 1203 rol eax, 5
1203 add ebp, eax 1204 add ebp, eax
1204 mov eax, DWORD PTR 44[esp] 1205 mov eax, DWORD PTR 44[esp]
1205 add ebx, ebp 1206 add ecx, ebp
1206 mov ebp, DWORD PTR 52[esp] 1207 mov ebp, DWORD PTR 52[esp]
1207 xor eax, ebp 1208 xor eax, ebp
1208 mov ebp, DWORD PTR 12[esp] 1209 mov ebp, DWORD PTR 12[esp]
@@ -1211,19 +1212,19 @@ L000start:
1211 ror edx, 1 1212 ror edx, 1
1212 xor eax, ebp 1213 xor eax, ebp
1213 rol eax, 1 1214 rol eax, 1
1214 mov ebp, ecx 1215 mov ebp, ebx
1215 mov DWORD PTR 44[esp],eax 1216 mov DWORD PTR 44[esp],eax
1216 or ebp, edx 1217 or ebp, edx
1217 lea eax, DWORD PTR 2400959708[esi*1+eax] 1218 lea eax, DWORD PTR 2400959708[esi*1+eax]
1218 mov esi, ecx 1219 mov esi, ebx
1219 and ebp, edi 1220 and ebp, edi
1220 and esi, edx 1221 and esi, edx
1221 or ebp, esi 1222 or ebp, esi
1222 mov esi, ebx 1223 mov esi, ecx
1223 rol esi, 5 1224 rol esi, 5
1224 ror ecx, 1 1225 ror ebx, 1
1225 add ebp, esi 1226 add ebp, esi
1226 ror ecx, 1 1227 ror ebx, 1
1227 add eax, ebp 1228 add eax, ebp
1228 ; 40_59 59 1229 ; 40_59 59
1229 ; 20_39 60 1230 ; 20_39 60
@@ -1234,17 +1235,17 @@ L000start:
1234 xor esi, ebp 1235 xor esi, ebp
1235 mov ebp, DWORD PTR 36[esp] 1236 mov ebp, DWORD PTR 36[esp]
1236 xor esi, ebp 1237 xor esi, ebp
1237 mov ebp, ebx 1238 mov ebp, ecx
1238 rol esi, 1 1239 rol esi, 1
1239 xor ebp, ecx 1240 xor ebp, ebx
1240 mov DWORD PTR 48[esp],esi 1241 mov DWORD PTR 48[esp],esi
1241 xor ebp, edx 1242 xor ebp, edx
1242 lea esi, DWORD PTR 3395469782[edi*1+esi] 1243 lea esi, DWORD PTR 3395469782[edi*1+esi]
1243 mov edi, eax 1244 mov edi, eax
1244 rol edi, 5 1245 rol edi, 5
1245 ror ebx, 1 1246 ror ecx, 1
1246 add edi, ebp 1247 add edi, ebp
1247 ror ebx, 1 1248 ror ecx, 1
1248 add esi, edi 1249 add esi, edi
1249 ; 20_39 61 1250 ; 20_39 61
1250 mov edi, DWORD PTR 52[esp] 1251 mov edi, DWORD PTR 52[esp]
@@ -1256,9 +1257,9 @@ L000start:
1256 xor edi, ebp 1257 xor edi, ebp
1257 mov ebp, eax 1258 mov ebp, eax
1258 rol edi, 1 1259 rol edi, 1
1259 xor ebp, ebx
1260 mov DWORD PTR 52[esp],edi
1261 xor ebp, ecx 1260 xor ebp, ecx
1261 mov DWORD PTR 52[esp],edi
1262 xor ebp, ebx
1262 lea edi, DWORD PTR 3395469782[edx*1+edi] 1263 lea edi, DWORD PTR 3395469782[edx*1+edi]
1263 mov edx, esi 1264 mov edx, esi
1264 rol edx, 5 1265 rol edx, 5
@@ -1278,54 +1279,54 @@ L000start:
1278 rol edx, 1 1279 rol edx, 1
1279 xor ebp, eax 1280 xor ebp, eax
1280 mov DWORD PTR 56[esp],edx 1281 mov DWORD PTR 56[esp],edx
1281 xor ebp, ebx 1282 xor ebp, ecx
1282 lea edx, DWORD PTR 3395469782[ecx*1+edx] 1283 lea edx, DWORD PTR 3395469782[ebx*1+edx]
1283 mov ecx, edi 1284 mov ebx, edi
1284 rol ecx, 5 1285 rol ebx, 5
1285 ror esi, 1 1286 ror esi, 1
1286 add ecx, ebp 1287 add ebx, ebp
1287 ror esi, 1 1288 ror esi, 1
1288 add edx, ecx 1289 add edx, ebx
1289 ; 20_39 63 1290 ; 20_39 63
1290 mov ecx, DWORD PTR 60[esp] 1291 mov ebx, DWORD PTR 60[esp]
1291 mov ebp, DWORD PTR 4[esp] 1292 mov ebp, DWORD PTR 4[esp]
1292 xor ecx, ebp 1293 xor ebx, ebp
1293 mov ebp, DWORD PTR 28[esp] 1294 mov ebp, DWORD PTR 28[esp]
1294 xor ecx, ebp 1295 xor ebx, ebp
1295 mov ebp, DWORD PTR 48[esp] 1296 mov ebp, DWORD PTR 48[esp]
1296 xor ecx, ebp 1297 xor ebx, ebp
1297 mov ebp, edi 1298 mov ebp, edi
1298 rol ecx, 1 1299 rol ebx, 1
1299 xor ebp, esi 1300 xor ebp, esi
1300 mov DWORD PTR 60[esp],ecx 1301 mov DWORD PTR 60[esp],ebx
1301 xor ebp, eax 1302 xor ebp, eax
1302 lea ecx, DWORD PTR 3395469782[ebx*1+ecx] 1303 lea ebx, DWORD PTR 3395469782[ecx*1+ebx]
1303 mov ebx, edx 1304 mov ecx, edx
1304 rol ebx, 5 1305 rol ecx, 5
1305 ror edi, 1 1306 ror edi, 1
1306 add ebx, ebp 1307 add ecx, ebp
1307 ror edi, 1 1308 ror edi, 1
1308 add ecx, ebx 1309 add ebx, ecx
1309 ; 20_39 64 1310 ; 20_39 64
1310 mov ebx, DWORD PTR [esp] 1311 mov ecx, DWORD PTR [esp]
1311 mov ebp, DWORD PTR 8[esp] 1312 mov ebp, DWORD PTR 8[esp]
1312 xor ebx, ebp 1313 xor ecx, ebp
1313 mov ebp, DWORD PTR 32[esp] 1314 mov ebp, DWORD PTR 32[esp]
1314 xor ebx, ebp 1315 xor ecx, ebp
1315 mov ebp, DWORD PTR 52[esp] 1316 mov ebp, DWORD PTR 52[esp]
1316 xor ebx, ebp 1317 xor ecx, ebp
1317 mov ebp, edx 1318 mov ebp, edx
1318 rol ebx, 1 1319 rol ecx, 1
1319 xor ebp, edi 1320 xor ebp, edi
1320 mov DWORD PTR [esp],ebx 1321 mov DWORD PTR [esp],ecx
1321 xor ebp, esi 1322 xor ebp, esi
1322 lea ebx, DWORD PTR 3395469782[eax*1+ebx] 1323 lea ecx, DWORD PTR 3395469782[eax*1+ecx]
1323 mov eax, ecx 1324 mov eax, ebx
1324 rol eax, 5 1325 rol eax, 5
1325 ror edx, 1 1326 ror edx, 1
1326 add eax, ebp 1327 add eax, ebp
1327 ror edx, 1 1328 ror edx, 1
1328 add ebx, eax 1329 add ecx, eax
1329 ; 20_39 65 1330 ; 20_39 65
1330 mov eax, DWORD PTR 4[esp] 1331 mov eax, DWORD PTR 4[esp]
1331 mov ebp, DWORD PTR 12[esp] 1332 mov ebp, DWORD PTR 12[esp]
@@ -1334,17 +1335,17 @@ L000start:
1334 xor eax, ebp 1335 xor eax, ebp
1335 mov ebp, DWORD PTR 56[esp] 1336 mov ebp, DWORD PTR 56[esp]
1336 xor eax, ebp 1337 xor eax, ebp
1337 mov ebp, ecx 1338 mov ebp, ebx
1338 rol eax, 1 1339 rol eax, 1
1339 xor ebp, edx 1340 xor ebp, edx
1340 mov DWORD PTR 4[esp],eax 1341 mov DWORD PTR 4[esp],eax
1341 xor ebp, edi 1342 xor ebp, edi
1342 lea eax, DWORD PTR 3395469782[esi*1+eax] 1343 lea eax, DWORD PTR 3395469782[esi*1+eax]
1343 mov esi, ebx 1344 mov esi, ecx
1344 rol esi, 5 1345 rol esi, 5
1345 ror ecx, 1 1346 ror ebx, 1
1346 add esi, ebp 1347 add esi, ebp
1347 ror ecx, 1 1348 ror ebx, 1
1348 add eax, esi 1349 add eax, esi
1349 ; 20_39 66 1350 ; 20_39 66
1350 mov esi, DWORD PTR 8[esp] 1351 mov esi, DWORD PTR 8[esp]
@@ -1354,17 +1355,17 @@ L000start:
1354 xor esi, ebp 1355 xor esi, ebp
1355 mov ebp, DWORD PTR 60[esp] 1356 mov ebp, DWORD PTR 60[esp]
1356 xor esi, ebp 1357 xor esi, ebp
1357 mov ebp, ebx 1358 mov ebp, ecx
1358 rol esi, 1 1359 rol esi, 1
1359 xor ebp, ecx 1360 xor ebp, ebx
1360 mov DWORD PTR 8[esp],esi 1361 mov DWORD PTR 8[esp],esi
1361 xor ebp, edx 1362 xor ebp, edx
1362 lea esi, DWORD PTR 3395469782[edi*1+esi] 1363 lea esi, DWORD PTR 3395469782[edi*1+esi]
1363 mov edi, eax 1364 mov edi, eax
1364 rol edi, 5 1365 rol edi, 5
1365 ror ebx, 1 1366 ror ecx, 1
1366 add edi, ebp 1367 add edi, ebp
1367 ror ebx, 1 1368 ror ecx, 1
1368 add esi, edi 1369 add esi, edi
1369 ; 20_39 67 1370 ; 20_39 67
1370 mov edi, DWORD PTR 12[esp] 1371 mov edi, DWORD PTR 12[esp]
@@ -1376,9 +1377,9 @@ L000start:
1376 xor edi, ebp 1377 xor edi, ebp
1377 mov ebp, eax 1378 mov ebp, eax
1378 rol edi, 1 1379 rol edi, 1
1379 xor ebp, ebx
1380 mov DWORD PTR 12[esp],edi
1381 xor ebp, ecx 1380 xor ebp, ecx
1381 mov DWORD PTR 12[esp],edi
1382 xor ebp, ebx
1382 lea edi, DWORD PTR 3395469782[edx*1+edi] 1383 lea edi, DWORD PTR 3395469782[edx*1+edi]
1383 mov edx, esi 1384 mov edx, esi
1384 rol edx, 5 1385 rol edx, 5
@@ -1398,54 +1399,54 @@ L000start:
1398 rol edx, 1 1399 rol edx, 1
1399 xor ebp, eax 1400 xor ebp, eax
1400 mov DWORD PTR 16[esp],edx 1401 mov DWORD PTR 16[esp],edx
1401 xor ebp, ebx 1402 xor ebp, ecx
1402 lea edx, DWORD PTR 3395469782[ecx*1+edx] 1403 lea edx, DWORD PTR 3395469782[ebx*1+edx]
1403 mov ecx, edi 1404 mov ebx, edi
1404 rol ecx, 5 1405 rol ebx, 5
1405 ror esi, 1 1406 ror esi, 1
1406 add ecx, ebp 1407 add ebx, ebp
1407 ror esi, 1 1408 ror esi, 1
1408 add edx, ecx 1409 add edx, ebx
1409 ; 20_39 69 1410 ; 20_39 69
1410 mov ecx, DWORD PTR 20[esp] 1411 mov ebx, DWORD PTR 20[esp]
1411 mov ebp, DWORD PTR 28[esp] 1412 mov ebp, DWORD PTR 28[esp]
1412 xor ecx, ebp 1413 xor ebx, ebp
1413 mov ebp, DWORD PTR 52[esp] 1414 mov ebp, DWORD PTR 52[esp]
1414 xor ecx, ebp 1415 xor ebx, ebp
1415 mov ebp, DWORD PTR 8[esp] 1416 mov ebp, DWORD PTR 8[esp]
1416 xor ecx, ebp 1417 xor ebx, ebp
1417 mov ebp, edi 1418 mov ebp, edi
1418 rol ecx, 1 1419 rol ebx, 1
1419 xor ebp, esi 1420 xor ebp, esi
1420 mov DWORD PTR 20[esp],ecx 1421 mov DWORD PTR 20[esp],ebx
1421 xor ebp, eax 1422 xor ebp, eax
1422 lea ecx, DWORD PTR 3395469782[ebx*1+ecx] 1423 lea ebx, DWORD PTR 3395469782[ecx*1+ebx]
1423 mov ebx, edx 1424 mov ecx, edx
1424 rol ebx, 5 1425 rol ecx, 5
1425 ror edi, 1 1426 ror edi, 1
1426 add ebx, ebp 1427 add ecx, ebp
1427 ror edi, 1 1428 ror edi, 1
1428 add ecx, ebx 1429 add ebx, ecx
1429 ; 20_39 70 1430 ; 20_39 70
1430 mov ebx, DWORD PTR 24[esp] 1431 mov ecx, DWORD PTR 24[esp]
1431 mov ebp, DWORD PTR 32[esp] 1432 mov ebp, DWORD PTR 32[esp]
1432 xor ebx, ebp 1433 xor ecx, ebp
1433 mov ebp, DWORD PTR 56[esp] 1434 mov ebp, DWORD PTR 56[esp]
1434 xor ebx, ebp 1435 xor ecx, ebp
1435 mov ebp, DWORD PTR 12[esp] 1436 mov ebp, DWORD PTR 12[esp]
1436 xor ebx, ebp 1437 xor ecx, ebp
1437 mov ebp, edx 1438 mov ebp, edx
1438 rol ebx, 1 1439 rol ecx, 1
1439 xor ebp, edi 1440 xor ebp, edi
1440 mov DWORD PTR 24[esp],ebx 1441 mov DWORD PTR 24[esp],ecx
1441 xor ebp, esi 1442 xor ebp, esi
1442 lea ebx, DWORD PTR 3395469782[eax*1+ebx] 1443 lea ecx, DWORD PTR 3395469782[eax*1+ecx]
1443 mov eax, ecx 1444 mov eax, ebx
1444 rol eax, 5 1445 rol eax, 5
1445 ror edx, 1 1446 ror edx, 1
1446 add eax, ebp 1447 add eax, ebp
1447 ror edx, 1 1448 ror edx, 1
1448 add ebx, eax 1449 add ecx, eax
1449 ; 20_39 71 1450 ; 20_39 71
1450 mov eax, DWORD PTR 28[esp] 1451 mov eax, DWORD PTR 28[esp]
1451 mov ebp, DWORD PTR 36[esp] 1452 mov ebp, DWORD PTR 36[esp]
@@ -1454,17 +1455,17 @@ L000start:
1454 xor eax, ebp 1455 xor eax, ebp
1455 mov ebp, DWORD PTR 16[esp] 1456 mov ebp, DWORD PTR 16[esp]
1456 xor eax, ebp 1457 xor eax, ebp
1457 mov ebp, ecx 1458 mov ebp, ebx
1458 rol eax, 1 1459 rol eax, 1
1459 xor ebp, edx 1460 xor ebp, edx
1460 mov DWORD PTR 28[esp],eax 1461 mov DWORD PTR 28[esp],eax
1461 xor ebp, edi 1462 xor ebp, edi
1462 lea eax, DWORD PTR 3395469782[esi*1+eax] 1463 lea eax, DWORD PTR 3395469782[esi*1+eax]
1463 mov esi, ebx 1464 mov esi, ecx
1464 rol esi, 5 1465 rol esi, 5
1465 ror ecx, 1 1466 ror ebx, 1
1466 add esi, ebp 1467 add esi, ebp
1467 ror ecx, 1 1468 ror ebx, 1
1468 add eax, esi 1469 add eax, esi
1469 ; 20_39 72 1470 ; 20_39 72
1470 mov esi, DWORD PTR 32[esp] 1471 mov esi, DWORD PTR 32[esp]
@@ -1474,17 +1475,17 @@ L000start:
1474 xor esi, ebp 1475 xor esi, ebp
1475 mov ebp, DWORD PTR 20[esp] 1476 mov ebp, DWORD PTR 20[esp]
1476 xor esi, ebp 1477 xor esi, ebp
1477 mov ebp, ebx 1478 mov ebp, ecx
1478 rol esi, 1 1479 rol esi, 1
1479 xor ebp, ecx 1480 xor ebp, ebx
1480 mov DWORD PTR 32[esp],esi 1481 mov DWORD PTR 32[esp],esi
1481 xor ebp, edx 1482 xor ebp, edx
1482 lea esi, DWORD PTR 3395469782[edi*1+esi] 1483 lea esi, DWORD PTR 3395469782[edi*1+esi]
1483 mov edi, eax 1484 mov edi, eax
1484 rol edi, 5 1485 rol edi, 5
1485 ror ebx, 1 1486 ror ecx, 1
1486 add edi, ebp 1487 add edi, ebp
1487 ror ebx, 1 1488 ror ecx, 1
1488 add esi, edi 1489 add esi, edi
1489 ; 20_39 73 1490 ; 20_39 73
1490 mov edi, DWORD PTR 36[esp] 1491 mov edi, DWORD PTR 36[esp]
@@ -1496,9 +1497,9 @@ L000start:
1496 xor edi, ebp 1497 xor edi, ebp
1497 mov ebp, eax 1498 mov ebp, eax
1498 rol edi, 1 1499 rol edi, 1
1499 xor ebp, ebx
1500 mov DWORD PTR 36[esp],edi
1501 xor ebp, ecx 1500 xor ebp, ecx
1501 mov DWORD PTR 36[esp],edi
1502 xor ebp, ebx
1502 lea edi, DWORD PTR 3395469782[edx*1+edi] 1503 lea edi, DWORD PTR 3395469782[edx*1+edi]
1503 mov edx, esi 1504 mov edx, esi
1504 rol edx, 5 1505 rol edx, 5
@@ -1518,54 +1519,54 @@ L000start:
1518 rol edx, 1 1519 rol edx, 1
1519 xor ebp, eax 1520 xor ebp, eax
1520 mov DWORD PTR 40[esp],edx 1521 mov DWORD PTR 40[esp],edx
1521 xor ebp, ebx 1522 xor ebp, ecx
1522 lea edx, DWORD PTR 3395469782[ecx*1+edx] 1523 lea edx, DWORD PTR 3395469782[ebx*1+edx]
1523 mov ecx, edi 1524 mov ebx, edi
1524 rol ecx, 5 1525 rol ebx, 5
1525 ror esi, 1 1526 ror esi, 1
1526 add ecx, ebp 1527 add ebx, ebp
1527 ror esi, 1 1528 ror esi, 1
1528 add edx, ecx 1529 add edx, ebx
1529 ; 20_39 75 1530 ; 20_39 75
1530 mov ecx, DWORD PTR 44[esp] 1531 mov ebx, DWORD PTR 44[esp]
1531 mov ebp, DWORD PTR 52[esp] 1532 mov ebp, DWORD PTR 52[esp]
1532 xor ecx, ebp 1533 xor ebx, ebp
1533 mov ebp, DWORD PTR 12[esp] 1534 mov ebp, DWORD PTR 12[esp]
1534 xor ecx, ebp 1535 xor ebx, ebp
1535 mov ebp, DWORD PTR 32[esp] 1536 mov ebp, DWORD PTR 32[esp]
1536 xor ecx, ebp 1537 xor ebx, ebp
1537 mov ebp, edi 1538 mov ebp, edi
1538 rol ecx, 1 1539 rol ebx, 1
1539 xor ebp, esi 1540 xor ebp, esi
1540 mov DWORD PTR 44[esp],ecx 1541 mov DWORD PTR 44[esp],ebx
1541 xor ebp, eax 1542 xor ebp, eax
1542 lea ecx, DWORD PTR 3395469782[ebx*1+ecx] 1543 lea ebx, DWORD PTR 3395469782[ecx*1+ebx]
1543 mov ebx, edx 1544 mov ecx, edx
1544 rol ebx, 5 1545 rol ecx, 5
1545 ror edi, 1 1546 ror edi, 1
1546 add ebx, ebp 1547 add ecx, ebp
1547 ror edi, 1 1548 ror edi, 1
1548 add ecx, ebx 1549 add ebx, ecx
1549 ; 20_39 76 1550 ; 20_39 76
1550 mov ebx, DWORD PTR 48[esp] 1551 mov ecx, DWORD PTR 48[esp]
1551 mov ebp, DWORD PTR 56[esp] 1552 mov ebp, DWORD PTR 56[esp]
1552 xor ebx, ebp 1553 xor ecx, ebp
1553 mov ebp, DWORD PTR 16[esp] 1554 mov ebp, DWORD PTR 16[esp]
1554 xor ebx, ebp 1555 xor ecx, ebp
1555 mov ebp, DWORD PTR 36[esp] 1556 mov ebp, DWORD PTR 36[esp]
1556 xor ebx, ebp 1557 xor ecx, ebp
1557 mov ebp, edx 1558 mov ebp, edx
1558 rol ebx, 1 1559 rol ecx, 1
1559 xor ebp, edi 1560 xor ebp, edi
1560 mov DWORD PTR 48[esp],ebx 1561 mov DWORD PTR 48[esp],ecx
1561 xor ebp, esi 1562 xor ebp, esi
1562 lea ebx, DWORD PTR 3395469782[eax*1+ebx] 1563 lea ecx, DWORD PTR 3395469782[eax*1+ecx]
1563 mov eax, ecx 1564 mov eax, ebx
1564 rol eax, 5 1565 rol eax, 5
1565 ror edx, 1 1566 ror edx, 1
1566 add eax, ebp 1567 add eax, ebp
1567 ror edx, 1 1568 ror edx, 1
1568 add ebx, eax 1569 add ecx, eax
1569 ; 20_39 77 1570 ; 20_39 77
1570 mov eax, DWORD PTR 52[esp] 1571 mov eax, DWORD PTR 52[esp]
1571 mov ebp, DWORD PTR 60[esp] 1572 mov ebp, DWORD PTR 60[esp]
@@ -1574,17 +1575,17 @@ L000start:
1574 xor eax, ebp 1575 xor eax, ebp
1575 mov ebp, DWORD PTR 40[esp] 1576 mov ebp, DWORD PTR 40[esp]
1576 xor eax, ebp 1577 xor eax, ebp
1577 mov ebp, ecx 1578 mov ebp, ebx
1578 rol eax, 1 1579 rol eax, 1
1579 xor ebp, edx 1580 xor ebp, edx
1580 mov DWORD PTR 52[esp],eax 1581 mov DWORD PTR 52[esp],eax
1581 xor ebp, edi 1582 xor ebp, edi
1582 lea eax, DWORD PTR 3395469782[esi*1+eax] 1583 lea eax, DWORD PTR 3395469782[esi*1+eax]
1583 mov esi, ebx 1584 mov esi, ecx
1584 rol esi, 5 1585 rol esi, 5
1585 ror ecx, 1 1586 ror ebx, 1
1586 add esi, ebp 1587 add esi, ebp
1587 ror ecx, 1 1588 ror ebx, 1
1588 add eax, esi 1589 add eax, esi
1589 ; 20_39 78 1590 ; 20_39 78
1590 mov esi, DWORD PTR 56[esp] 1591 mov esi, DWORD PTR 56[esp]
@@ -1594,17 +1595,17 @@ L000start:
1594 xor esi, ebp 1595 xor esi, ebp
1595 mov ebp, DWORD PTR 44[esp] 1596 mov ebp, DWORD PTR 44[esp]
1596 xor esi, ebp 1597 xor esi, ebp
1597 mov ebp, ebx 1598 mov ebp, ecx
1598 rol esi, 1 1599 rol esi, 1
1599 xor ebp, ecx 1600 xor ebp, ebx
1600 mov DWORD PTR 56[esp],esi 1601 mov DWORD PTR 56[esp],esi
1601 xor ebp, edx 1602 xor ebp, edx
1602 lea esi, DWORD PTR 3395469782[edi*1+esi] 1603 lea esi, DWORD PTR 3395469782[edi*1+esi]
1603 mov edi, eax 1604 mov edi, eax
1604 rol edi, 5 1605 rol edi, 5
1605 ror ebx, 1 1606 ror ecx, 1
1606 add edi, ebp 1607 add edi, ebp
1607 ror ebx, 1 1608 ror ecx, 1
1608 add esi, edi 1609 add esi, edi
1609 ; 20_39 79 1610 ; 20_39 79
1610 mov edi, DWORD PTR 60[esp] 1611 mov edi, DWORD PTR 60[esp]
@@ -1616,49 +1617,100 @@ L000start:
1616 xor edi, ebp 1617 xor edi, ebp
1617 mov ebp, eax 1618 mov ebp, eax
1618 rol edi, 1 1619 rol edi, 1
1619 xor ebp, ebx
1620 mov DWORD PTR 60[esp],edi
1621 xor ebp, ecx 1620 xor ebp, ecx
1621 mov DWORD PTR 60[esp],edi
1622 xor ebp, ebx
1622 lea edi, DWORD PTR 3395469782[edx*1+edi] 1623 lea edi, DWORD PTR 3395469782[edx*1+edi]
1623 mov edx, esi 1624 mov edx, esi
1624 rol edx, 5 1625 rol edx, 5
1625 add edx, ebp 1626 add edx, ebp
1626 mov ebp, DWORD PTR 92[esp] 1627 mov ebp, DWORD PTR 128[esp]
1627 ror eax, 1 1628 ror eax, 1
1628 add edi, edx 1629 add edi, edx
1629 ror eax, 1 1630 ror eax, 1
1630 ; End processing 1631 ; End processing
1631 ; 1632 ;
1632 mov edx, DWORD PTR 12[ebp] 1633 mov edx, DWORD PTR 12[ebp]
1633 add edx, ebx 1634 add edx, ecx
1634 mov ebx, DWORD PTR 4[ebp] 1635 mov ecx, DWORD PTR 4[ebp]
1635 add ebx, esi 1636 add ecx, esi
1636 mov esi, eax 1637 mov esi, eax
1637 mov eax, DWORD PTR [ebp] 1638 mov eax, DWORD PTR [ebp]
1638 mov DWORD PTR 12[ebp],edx 1639 mov DWORD PTR 12[ebp],edx
1639 add eax, edi 1640 add eax, edi
1640 mov edi, DWORD PTR 16[ebp] 1641 mov edi, DWORD PTR 16[ebp]
1641 add edi, ecx 1642 add edi, ebx
1642 mov ecx, DWORD PTR 8[ebp] 1643 mov ebx, DWORD PTR 8[ebp]
1643 add ecx, esi 1644 add ebx, esi
1644 mov DWORD PTR [ebp],eax 1645 mov DWORD PTR [ebp],eax
1645 mov esi, DWORD PTR 64[esp] 1646 mov esi, DWORD PTR 132[esp]
1646 mov DWORD PTR 8[ebp],ecx 1647 mov DWORD PTR 8[ebp],ebx
1647 add esi, 64 1648 add esi, 64
1648 mov eax, DWORD PTR 68[esp] 1649 mov eax, DWORD PTR 68[esp]
1649 mov DWORD PTR 16[ebp],edi 1650 mov DWORD PTR 16[ebp],edi
1650 cmp eax, esi 1651 cmp esi, eax
1651 mov DWORD PTR 4[ebp],ebx 1652 mov DWORD PTR 4[ebp],ecx
1652 jl $L001end 1653 jl L000start
1653 mov eax, DWORD PTR [esi] 1654 add esp, 108
1654 jmp L000start
1655$L001end:
1656 add esp, 72
1657 pop edi 1655 pop edi
1658 pop ebx 1656 pop ebx
1659 pop ebp 1657 pop ebp
1660 pop esi 1658 pop esi
1661 ret 1659 ret
1662_sha1_block_x86 ENDP 1660_TEXT SEGMENT
1661PUBLIC _sha1_block_asm_host_order
1662
1663_sha1_block_asm_host_order PROC NEAR
1664 mov ecx, DWORD PTR 12[esp]
1665 push esi
1666 shl ecx, 6
1667 mov esi, DWORD PTR 12[esp]
1668 push ebp
1669 add ecx, esi
1670 push ebx
1671 mov ebp, DWORD PTR 16[esp]
1672 push edi
1673 mov edx, DWORD PTR 12[ebp]
1674 sub esp, 108
1675 mov edi, DWORD PTR 16[ebp]
1676 mov ebx, DWORD PTR 8[ebp]
1677 mov DWORD PTR 68[esp],ecx
1678 ; First we need to setup the X array
1679 mov eax, DWORD PTR [esi]
1680 mov ecx, DWORD PTR 4[esi]
1681 mov DWORD PTR [esp],eax
1682 mov DWORD PTR 4[esp],ecx
1683 mov eax, DWORD PTR 8[esi]
1684 mov ecx, DWORD PTR 12[esi]
1685 mov DWORD PTR 8[esp],eax
1686 mov DWORD PTR 12[esp],ecx
1687 mov eax, DWORD PTR 16[esi]
1688 mov ecx, DWORD PTR 20[esi]
1689 mov DWORD PTR 16[esp],eax
1690 mov DWORD PTR 20[esp],ecx
1691 mov eax, DWORD PTR 24[esi]
1692 mov ecx, DWORD PTR 28[esi]
1693 mov DWORD PTR 24[esp],eax
1694 mov DWORD PTR 28[esp],ecx
1695 mov eax, DWORD PTR 32[esi]
1696 mov ecx, DWORD PTR 36[esi]
1697 mov DWORD PTR 32[esp],eax
1698 mov DWORD PTR 36[esp],ecx
1699 mov eax, DWORD PTR 40[esi]
1700 mov ecx, DWORD PTR 44[esi]
1701 mov DWORD PTR 40[esp],eax
1702 mov DWORD PTR 44[esp],ecx
1703 mov eax, DWORD PTR 48[esi]
1704 mov ecx, DWORD PTR 52[esi]
1705 mov DWORD PTR 48[esp],eax
1706 mov DWORD PTR 52[esp],ecx
1707 mov eax, DWORD PTR 56[esi]
1708 mov ecx, DWORD PTR 60[esi]
1709 mov DWORD PTR 56[esp],eax
1710 mov DWORD PTR 60[esp],ecx
1711 jmp L001shortcut
1712_sha1_block_asm_host_order ENDP
1713_TEXT ENDS
1714_sha1_block_asm_data_order ENDP
1663_TEXT ENDS 1715_TEXT ENDS
1664END 1716END
diff --git a/src/lib/libcrypto/sha/asm/sha1-586.pl b/src/lib/libcrypto/sha/asm/sha1-586.pl
index 04e42ab09f..48d9192a4e 100644
--- a/src/lib/libcrypto/sha/asm/sha1-586.pl
+++ b/src/lib/libcrypto/sha/asm/sha1-586.pl
@@ -8,8 +8,8 @@ require "x86asm.pl";
8&asm_init($ARGV[0],"sha1-586.pl",$ARGV[$#ARGV] eq "386"); 8&asm_init($ARGV[0],"sha1-586.pl",$ARGV[$#ARGV] eq "386");
9 9
10$A="eax"; 10$A="eax";
11$B="ebx"; 11$B="ecx";
12$C="ecx"; 12$C="ebx";
13$D="edx"; 13$D="edx";
14$E="edi"; 14$E="edi";
15$T="esi"; 15$T="esi";
@@ -19,7 +19,7 @@ $off=9*4;
19 19
20@K=(0x5a827999,0x6ed9eba1,0x8f1bbcdc,0xca62c1d6); 20@K=(0x5a827999,0x6ed9eba1,0x8f1bbcdc,0xca62c1d6);
21 21
22&sha1_block("sha1_block_x86"); 22&sha1_block_data("sha1_block_asm_data_order");
23 23
24&asm_finish(); 24&asm_finish();
25 25
@@ -53,11 +53,14 @@ sub X_expand
53 local($in)=@_; 53 local($in)=@_;
54 54
55 &comment("First, load the words onto the stack in network byte order"); 55 &comment("First, load the words onto the stack in network byte order");
56 for ($i=0; $i<16; $i++) 56 for ($i=0; $i<16; $i+=2)
57 { 57 {
58 &mov("eax",&DWP(($i+0)*4,$in,"",0)) unless $i == 0; 58 &mov($A,&DWP(($i+0)*4,$in,"",0));# unless $i == 0;
59 &bswap("eax"); 59 &mov($B,&DWP(($i+1)*4,$in,"",0));
60 &mov(&swtmp($i+0),"eax"); 60 &bswap($A);
61 &bswap($B);
62 &mov(&swtmp($i+0),$A);
63 &mov(&swtmp($i+1),$B);
61 } 64 }
62 65
63 &comment("We now have the X array on the stack"); 66 &comment("We now have the X array on the stack");
@@ -312,7 +315,7 @@ sub BODY_60_79
312 &BODY_20_39(@_); 315 &BODY_20_39(@_);
313 } 316 }
314 317
315sub sha1_block 318sub sha1_block_host
316 { 319 {
317 local($name)=@_; 320 local($name)=@_;
318 321
@@ -325,35 +328,77 @@ sub sha1_block
325 # D 12 328 # D 12
326 # E 16 329 # E 16
327 330
328 &push("esi"); 331 &mov("ecx", &wparam(2));
329 &push("ebp"); 332 &push("esi");
330 &mov("eax", &wparam(2)); 333 &shl("ecx",6);
331 &mov("esi", &wparam(1)); 334 &mov("esi", &wparam(1));
332 &add("eax", "esi"); # offset to leave on 335 &push("ebp");
336 &add("ecx","esi"); # offset to leave on
337 &push("ebx");
333 &mov("ebp", &wparam(0)); 338 &mov("ebp", &wparam(0));
339 &push("edi");
340 &mov($D, &DWP(12,"ebp","",0));
341 &stack_push(18+9);
342 &mov($E, &DWP(16,"ebp","",0));
343 &mov($C, &DWP( 8,"ebp","",0));
344 &mov(&swtmp(17),"ecx");
345
346 &comment("First we need to setup the X array");
347
348 for ($i=0; $i<16; $i+=2)
349 {
350 &mov($A,&DWP(($i+0)*4,"esi","",0));# unless $i == 0;
351 &mov($B,&DWP(($i+1)*4,"esi","",0));
352 &mov(&swtmp($i+0),$A);
353 &mov(&swtmp($i+1),$B);
354 }
355 &jmp(&label("shortcut"));
356 &function_end_B($name);
357 }
358
359
360sub sha1_block_data
361 {
362 local($name)=@_;
363
364 &function_begin_B($name,"");
365
366 # parameter 1 is the MD5_CTX structure.
367 # A 0
368 # B 4
369 # C 8
370 # D 12
371 # E 16
372
373 &mov("ecx", &wparam(2));
374 &push("esi");
375 &shl("ecx",6);
376 &mov("esi", &wparam(1));
377 &push("ebp");
378 &add("ecx","esi"); # offset to leave on
334 &push("ebx"); 379 &push("ebx");
335 &sub("eax", 64); 380 &mov("ebp", &wparam(0));
336 &push("edi"); 381 &push("edi");
337 &mov($B, &DWP( 4,"ebp","",0));
338 &stack_push(18);
339 &mov($D, &DWP(12,"ebp","",0)); 382 &mov($D, &DWP(12,"ebp","",0));
340 &mov($E, &DWP(16,"ebp","",0)); 383 &stack_push(18+9);
341 &mov($C, &DWP( 8,"ebp","",0)); 384 &mov($E, &DWP(16,"ebp","",0));
342 &mov(&swtmp(17),"eax"); 385 &mov($C, &DWP( 8,"ebp","",0));
386 &mov(&swtmp(17),"ecx");
343 387
344 &comment("First we need to setup the X array"); 388 &comment("First we need to setup the X array");
345 &mov("eax",&DWP(0,"esi","",0)); # pulled out of X_expand
346 389
347 &set_label("start") unless $normal; 390 &set_label("start") unless $normal;
348 391
349 &X_expand("esi"); 392 &X_expand("esi");
350 &mov(&swtmp(16),"esi"); 393 &mov(&wparam(1),"esi");
351 394
395 &set_label("shortcut", 1);
352 &comment(""); 396 &comment("");
353 &comment("Start processing"); 397 &comment("Start processing");
354 398
355 # odd start 399 # odd start
356 &mov($A, &DWP( 0,"ebp","",0)); 400 &mov($A, &DWP( 0,"ebp","",0));
401 &mov($B, &DWP( 4,"ebp","",0));
357 $X="esp"; 402 $X="esp";
358 &BODY_00_15(-2,$K[0],$X, 0,$A,$B,$C,$D,$E,$T); 403 &BODY_00_15(-2,$K[0],$X, 0,$A,$B,$C,$D,$E,$T);
359 &BODY_00_15( 0,$K[0],$X, 1,$T,$A,$B,$C,$D,$E); 404 &BODY_00_15( 0,$K[0],$X, 1,$T,$A,$B,$C,$D,$E);
@@ -468,24 +513,26 @@ sub sha1_block
468 &add($C,$T); 513 &add($C,$T);
469 514
470 &mov(&DWP( 0,$tmp1,"",0),$A); 515 &mov(&DWP( 0,$tmp1,"",0),$A);
471 &mov("esi",&swtmp(16)); 516 &mov("esi",&wparam(1));
472 &mov(&DWP( 8,$tmp1,"",0),$C); # This is for looping 517 &mov(&DWP( 8,$tmp1,"",0),$C);
473 &add("esi",64); 518 &add("esi",64);
474 &mov("eax",&swtmp(17)); 519 &mov("eax",&swtmp(17));
475 &mov(&DWP(16,$tmp1,"",0),$E); 520 &mov(&DWP(16,$tmp1,"",0),$E);
476 &cmp("eax","esi"); 521 &cmp("esi","eax");
477 &mov(&DWP( 4,$tmp1,"",0),$B); # This is for looping 522 &mov(&DWP( 4,$tmp1,"",0),$B);
478 &jl(&label("end")); 523 &jl(&label("start"));
479 &mov("eax",&DWP(0,"esi","",0)); # Pulled down from 524
480 &jmp(&label("start")); 525 &stack_pop(18+9);
481
482 &set_label("end");
483 &stack_pop(18);
484 &pop("edi"); 526 &pop("edi");
485 &pop("ebx"); 527 &pop("ebx");
486 &pop("ebp"); 528 &pop("ebp");
487 &pop("esi"); 529 &pop("esi");
488 &ret(); 530 &ret();
531
532 # it has to reside within sha1_block_asm_host_order body
533 # because it calls &jmp(&label("shortcut"));
534 &sha1_block_host("sha1_block_asm_host_order");
535
489 &function_end_B($name); 536 &function_end_B($name);
490 } 537 }
491 538
diff --git a/src/lib/libcrypto/sha/sha.h b/src/lib/libcrypto/sha/sha.h
index cd6960ee1a..77f6d9695e 100644
--- a/src/lib/libcrypto/sha/sha.h
+++ b/src/lib/libcrypto/sha/sha.h
@@ -63,7 +63,7 @@
63extern "C" { 63extern "C" {
64#endif 64#endif
65 65
66#ifdef NO_SHA 66#if defined(NO_SHA) || (defined(NO_SHA0) && defined(NO_SHA1))
67#error SHA is disabled. 67#error SHA is disabled.
68#endif 68#endif
69 69
@@ -100,17 +100,17 @@ typedef struct SHAstate_st
100 100
101#ifndef NO_SHA0 101#ifndef NO_SHA0
102void SHA_Init(SHA_CTX *c); 102void SHA_Init(SHA_CTX *c);
103void SHA_Update(SHA_CTX *c, const unsigned char *data, unsigned long len); 103void SHA_Update(SHA_CTX *c, const void *data, unsigned long len);
104void SHA_Final(unsigned char *md, SHA_CTX *c); 104void SHA_Final(unsigned char *md, SHA_CTX *c);
105unsigned char *SHA(const unsigned char *d, unsigned long n,unsigned char *md); 105unsigned char *SHA(const unsigned char *d, unsigned long n,unsigned char *md);
106void SHA_Transform(SHA_CTX *c, unsigned char *data); 106void SHA_Transform(SHA_CTX *c, const unsigned char *data);
107#endif 107#endif
108#ifndef NO_SHA1 108#ifndef NO_SHA1
109void SHA1_Init(SHA_CTX *c); 109void SHA1_Init(SHA_CTX *c);
110void SHA1_Update(SHA_CTX *c, const unsigned char *data, unsigned long len); 110void SHA1_Update(SHA_CTX *c, const void *data, unsigned long len);
111void SHA1_Final(unsigned char *md, SHA_CTX *c); 111void SHA1_Final(unsigned char *md, SHA_CTX *c);
112unsigned char *SHA1(const unsigned char *d, unsigned long n,unsigned char *md); 112unsigned char *SHA1(const unsigned char *d, unsigned long n,unsigned char *md);
113void SHA1_Transform(SHA_CTX *c, unsigned char *data); 113void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
114#endif 114#endif
115#ifdef __cplusplus 115#ifdef __cplusplus
116} 116}
diff --git a/src/lib/libcrypto/sha/sha1dgst.c b/src/lib/libcrypto/sha/sha1dgst.c
index 66e885dd76..c09edb4cd7 100644
--- a/src/lib/libcrypto/sha/sha1dgst.c
+++ b/src/lib/libcrypto/sha/sha1dgst.c
@@ -56,443 +56,18 @@
56 * [including the GNU Public Licence.] 56 * [including the GNU Public Licence.]
57 */ 57 */
58 58
59#include <stdio.h> 59#if !defined(NO_SHA1) && !defined(NO_SHA)
60#include <string.h> 60
61#undef SHA_0 61#undef SHA_0
62#define SHA_1 62#define SHA_1
63#include <openssl/sha.h>
64#include "sha_locl.h"
65#include <openssl/opensslv.h>
66
67#ifndef NO_SHA1
68char *SHA1_version="SHA1" OPENSSL_VERSION_PTEXT;
69
70/* Implemented from SHA-1 document - The Secure Hash Algorithm
71 */
72
73#define INIT_DATA_h0 0x67452301UL
74#define INIT_DATA_h1 0xefcdab89UL
75#define INIT_DATA_h2 0x98badcfeUL
76#define INIT_DATA_h3 0x10325476UL
77#define INIT_DATA_h4 0xc3d2e1f0UL
78
79#define K_00_19 0x5a827999UL
80#define K_20_39 0x6ed9eba1UL
81#define K_40_59 0x8f1bbcdcUL
82#define K_60_79 0xca62c1d6UL
83
84#ifdef SHA1_ASM
85 void sha1_block_x86(SHA_CTX *c, register SHA_LONG *p, int num);
86# define sha1_block(c,p,n) sha1_block_x86((c),(p),(n)*SHA_CBLOCK)
87#else
88 static void sha1_block(SHA_CTX *c, register SHA_LONG *p, int num);
89#endif
90
91#if !defined(B_ENDIAN) && defined(SHA1_ASM)
92# define M_c2nl c2l
93# define M_p_c2nl p_c2l
94# define M_c2nl_p c2l_p
95# define M_p_c2nl_p p_c2l_p
96# define M_nl2c l2c
97#else
98# define M_c2nl c2nl
99# define M_p_c2nl p_c2nl
100# define M_c2nl_p c2nl_p
101# define M_p_c2nl_p p_c2nl_p
102# define M_nl2c nl2c
103#endif
104
105void SHA1_Init(SHA_CTX *c)
106 {
107 c->h0=INIT_DATA_h0;
108 c->h1=INIT_DATA_h1;
109 c->h2=INIT_DATA_h2;
110 c->h3=INIT_DATA_h3;
111 c->h4=INIT_DATA_h4;
112 c->Nl=0;
113 c->Nh=0;
114 c->num=0;
115 }
116
117void SHA1_Update(SHA_CTX *c, register const unsigned char *data,
118 unsigned long len)
119 {
120 register SHA_LONG *p;
121 int ew,ec,sw,sc;
122 SHA_LONG l;
123
124 if (len == 0) return;
125
126 l=(c->Nl+(len<<3))&0xffffffffL;
127 if (l < c->Nl) /* overflow */
128 c->Nh++;
129 c->Nh+=(len>>29);
130 c->Nl=l;
131
132 if (c->num != 0)
133 {
134 p=c->data;
135 sw=c->num>>2;
136 sc=c->num&0x03;
137
138 if ((c->num+len) >= SHA_CBLOCK)
139 {
140 l= p[sw];
141 M_p_c2nl(data,l,sc);
142 p[sw++]=l;
143 for (; sw<SHA_LBLOCK; sw++)
144 {
145 M_c2nl(data,l);
146 p[sw]=l;
147 }
148 len-=(SHA_CBLOCK-c->num);
149
150 sha1_block(c,p,1);
151 c->num=0;
152 /* drop through and do the rest */
153 }
154 else
155 {
156 c->num+=(int)len;
157 if ((sc+len) < 4) /* ugly, add char's to a word */
158 {
159 l= p[sw];
160 M_p_c2nl_p(data,l,sc,len);
161 p[sw]=l;
162 }
163 else
164 {
165 ew=(c->num>>2);
166 ec=(c->num&0x03);
167 l= p[sw];
168 M_p_c2nl(data,l,sc);
169 p[sw++]=l;
170 for (; sw < ew; sw++)
171 { M_c2nl(data,l); p[sw]=l; }
172 if (ec)
173 {
174 M_c2nl_p(data,l,ec);
175 p[sw]=l;
176 }
177 }
178 return;
179 }
180 }
181 /* We can only do the following code for assember, the reason
182 * being that the sha1_block 'C' version changes the values
183 * in the 'data' array. The assember code avoids this and
184 * copies it to a local array. I should be able to do this for
185 * the C version as well....
186 */
187#if SHA_LONG_LOG2==2
188#if defined(B_ENDIAN) || defined(SHA1_ASM)
189 if ((((unsigned long)data)%sizeof(SHA_LONG)) == 0)
190 {
191 sw=len/SHA_CBLOCK;
192 if (sw)
193 {
194 sha1_block(c,(SHA_LONG *)data,sw);
195 sw*=SHA_CBLOCK;
196 data+=sw;
197 len-=sw;
198 }
199 }
200#endif
201#endif
202 /* we now can process the input data in blocks of SHA_CBLOCK
203 * chars and save the leftovers to c->data. */
204 p=c->data;
205 while (len >= SHA_CBLOCK)
206 {
207#if SHA_LONG_LOG2==2
208#if defined(B_ENDIAN) || defined(SHA1_ASM)
209#define SHA_NO_TAIL_CODE
210 /*
211 * Basically we get here only when data happens
212 * to be unaligned.
213 */
214 if (p != (SHA_LONG *)data)
215 memcpy(p,data,SHA_CBLOCK);
216 data+=SHA_CBLOCK;
217 sha1_block(c,p=c->data,1);
218 len-=SHA_CBLOCK;
219#elif defined(L_ENDIAN)
220#define BE_COPY(dst,src,i) { \
221 l = ((SHA_LONG *)src)[i]; \
222 Endian_Reverse32(l); \
223 dst[i] = l; \
224 }
225 if ((((unsigned long)data)%sizeof(SHA_LONG)) == 0)
226 {
227 for (sw=(SHA_LBLOCK/4); sw; sw--)
228 {
229 BE_COPY(p,data,0);
230 BE_COPY(p,data,1);
231 BE_COPY(p,data,2);
232 BE_COPY(p,data,3);
233 p+=4;
234 data += 4*sizeof(SHA_LONG);
235 }
236 sha1_block(c,p=c->data,1);
237 len-=SHA_CBLOCK;
238 continue;
239 }
240#endif
241#endif
242#ifndef SHA_NO_TAIL_CODE
243 /*
244 * In addition to "sizeof(SHA_LONG)!= 4" case the
245 * following code covers unaligned access cases on
246 * little-endian machines.
247 * <appro@fy.chalmers.se>
248 */
249 p=c->data;
250 for (sw=(SHA_LBLOCK/4); sw; sw--)
251 {
252 M_c2nl(data,l); p[0]=l;
253 M_c2nl(data,l); p[1]=l;
254 M_c2nl(data,l); p[2]=l;
255 M_c2nl(data,l); p[3]=l;
256 p+=4;
257 }
258 p=c->data;
259 sha1_block(c,p,1);
260 len-=SHA_CBLOCK;
261#endif
262 }
263 ec=(int)len;
264 c->num=ec;
265 ew=(ec>>2);
266 ec&=0x03;
267
268 for (sw=0; sw < ew; sw++)
269 { M_c2nl(data,l); p[sw]=l; }
270 M_c2nl_p(data,l,ec);
271 p[sw]=l;
272 }
273
274void SHA1_Transform(SHA_CTX *c, unsigned char *b)
275 {
276 SHA_LONG p[SHA_LBLOCK];
277
278#if SHA_LONG_LOG2==2
279#if defined(B_ENDIAN) || defined(SHA1_ASM)
280 memcpy(p,b,SHA_CBLOCK);
281 sha1_block(c,p,1);
282 return;
283#elif defined(L_ENDIAN)
284 if (((unsigned long)b%sizeof(SHA_LONG)) == 0)
285 {
286 SHA_LONG *q;
287 int i;
288
289 q=p;
290 for (i=(SHA_LBLOCK/4); i; i--)
291 {
292 unsigned long l;
293 BE_COPY(q,b,0); /* BE_COPY was defined above */
294 BE_COPY(q,b,1);
295 BE_COPY(q,b,2);
296 BE_COPY(q,b,3);
297 q+=4;
298 b+=4*sizeof(SHA_LONG);
299 }
300 sha1_block(c,p,1);
301 return;
302 }
303#endif
304#endif
305#ifndef SHA_NO_TAIL_CODE /* defined above, see comment */
306 {
307 SHA_LONG *q;
308 int i;
309
310 q=p;
311 for (i=(SHA_LBLOCK/4); i; i--)
312 {
313 SHA_LONG l;
314 c2nl(b,l); *(q++)=l;
315 c2nl(b,l); *(q++)=l;
316 c2nl(b,l); *(q++)=l;
317 c2nl(b,l); *(q++)=l;
318 }
319 sha1_block(c,p,1);
320 }
321#endif
322 }
323
324#ifndef SHA1_ASM
325static void sha1_block(SHA_CTX *c, register SHA_LONG *W, int num)
326 {
327 register SHA_LONG A,B,C,D,E,T;
328 SHA_LONG X[SHA_LBLOCK];
329
330 A=c->h0;
331 B=c->h1;
332 C=c->h2;
333 D=c->h3;
334 E=c->h4;
335 63
336 for (;;) 64#include <openssl/opensslv.h>
337 {
338 BODY_00_15( 0,A,B,C,D,E,T,W);
339 BODY_00_15( 1,T,A,B,C,D,E,W);
340 BODY_00_15( 2,E,T,A,B,C,D,W);
341 BODY_00_15( 3,D,E,T,A,B,C,W);
342 BODY_00_15( 4,C,D,E,T,A,B,W);
343 BODY_00_15( 5,B,C,D,E,T,A,W);
344 BODY_00_15( 6,A,B,C,D,E,T,W);
345 BODY_00_15( 7,T,A,B,C,D,E,W);
346 BODY_00_15( 8,E,T,A,B,C,D,W);
347 BODY_00_15( 9,D,E,T,A,B,C,W);
348 BODY_00_15(10,C,D,E,T,A,B,W);
349 BODY_00_15(11,B,C,D,E,T,A,W);
350 BODY_00_15(12,A,B,C,D,E,T,W);
351 BODY_00_15(13,T,A,B,C,D,E,W);
352 BODY_00_15(14,E,T,A,B,C,D,W);
353 BODY_00_15(15,D,E,T,A,B,C,W);
354 BODY_16_19(16,C,D,E,T,A,B,W,W,W,W);
355 BODY_16_19(17,B,C,D,E,T,A,W,W,W,W);
356 BODY_16_19(18,A,B,C,D,E,T,W,W,W,W);
357 BODY_16_19(19,T,A,B,C,D,E,W,W,W,X);
358
359 BODY_20_31(20,E,T,A,B,C,D,W,W,W,X);
360 BODY_20_31(21,D,E,T,A,B,C,W,W,W,X);
361 BODY_20_31(22,C,D,E,T,A,B,W,W,W,X);
362 BODY_20_31(23,B,C,D,E,T,A,W,W,W,X);
363 BODY_20_31(24,A,B,C,D,E,T,W,W,X,X);
364 BODY_20_31(25,T,A,B,C,D,E,W,W,X,X);
365 BODY_20_31(26,E,T,A,B,C,D,W,W,X,X);
366 BODY_20_31(27,D,E,T,A,B,C,W,W,X,X);
367 BODY_20_31(28,C,D,E,T,A,B,W,W,X,X);
368 BODY_20_31(29,B,C,D,E,T,A,W,W,X,X);
369 BODY_20_31(30,A,B,C,D,E,T,W,X,X,X);
370 BODY_20_31(31,T,A,B,C,D,E,W,X,X,X);
371 BODY_32_39(32,E,T,A,B,C,D,X);
372 BODY_32_39(33,D,E,T,A,B,C,X);
373 BODY_32_39(34,C,D,E,T,A,B,X);
374 BODY_32_39(35,B,C,D,E,T,A,X);
375 BODY_32_39(36,A,B,C,D,E,T,X);
376 BODY_32_39(37,T,A,B,C,D,E,X);
377 BODY_32_39(38,E,T,A,B,C,D,X);
378 BODY_32_39(39,D,E,T,A,B,C,X);
379
380 BODY_40_59(40,C,D,E,T,A,B,X);
381 BODY_40_59(41,B,C,D,E,T,A,X);
382 BODY_40_59(42,A,B,C,D,E,T,X);
383 BODY_40_59(43,T,A,B,C,D,E,X);
384 BODY_40_59(44,E,T,A,B,C,D,X);
385 BODY_40_59(45,D,E,T,A,B,C,X);
386 BODY_40_59(46,C,D,E,T,A,B,X);
387 BODY_40_59(47,B,C,D,E,T,A,X);
388 BODY_40_59(48,A,B,C,D,E,T,X);
389 BODY_40_59(49,T,A,B,C,D,E,X);
390 BODY_40_59(50,E,T,A,B,C,D,X);
391 BODY_40_59(51,D,E,T,A,B,C,X);
392 BODY_40_59(52,C,D,E,T,A,B,X);
393 BODY_40_59(53,B,C,D,E,T,A,X);
394 BODY_40_59(54,A,B,C,D,E,T,X);
395 BODY_40_59(55,T,A,B,C,D,E,X);
396 BODY_40_59(56,E,T,A,B,C,D,X);
397 BODY_40_59(57,D,E,T,A,B,C,X);
398 BODY_40_59(58,C,D,E,T,A,B,X);
399 BODY_40_59(59,B,C,D,E,T,A,X);
400
401 BODY_60_79(60,A,B,C,D,E,T,X);
402 BODY_60_79(61,T,A,B,C,D,E,X);
403 BODY_60_79(62,E,T,A,B,C,D,X);
404 BODY_60_79(63,D,E,T,A,B,C,X);
405 BODY_60_79(64,C,D,E,T,A,B,X);
406 BODY_60_79(65,B,C,D,E,T,A,X);
407 BODY_60_79(66,A,B,C,D,E,T,X);
408 BODY_60_79(67,T,A,B,C,D,E,X);
409 BODY_60_79(68,E,T,A,B,C,D,X);
410 BODY_60_79(69,D,E,T,A,B,C,X);
411 BODY_60_79(70,C,D,E,T,A,B,X);
412 BODY_60_79(71,B,C,D,E,T,A,X);
413 BODY_60_79(72,A,B,C,D,E,T,X);
414 BODY_60_79(73,T,A,B,C,D,E,X);
415 BODY_60_79(74,E,T,A,B,C,D,X);
416 BODY_60_79(75,D,E,T,A,B,C,X);
417 BODY_60_79(76,C,D,E,T,A,B,X);
418 BODY_60_79(77,B,C,D,E,T,A,X);
419 BODY_60_79(78,A,B,C,D,E,T,X);
420 BODY_60_79(79,T,A,B,C,D,E,X);
421
422 c->h0=(c->h0+E)&0xffffffffL;
423 c->h1=(c->h1+T)&0xffffffffL;
424 c->h2=(c->h2+A)&0xffffffffL;
425 c->h3=(c->h3+B)&0xffffffffL;
426 c->h4=(c->h4+C)&0xffffffffL;
427
428 if (--num <= 0) break;
429 65
430 A=c->h0; 66const char *SHA1_version="SHA1" OPENSSL_VERSION_PTEXT;
431 B=c->h1;
432 C=c->h2;
433 D=c->h3;
434 E=c->h4;
435 67
436 W+=SHA_LBLOCK; /* Note! This can happen only when sizeof(SHA_LONG) 68/* The implementation is in ../md32_common.h */
437 * is 4. Whenever it's not the actual case this
438 * function is never called with num larger than 1
439 * and we never advance down here.
440 * <appro@fy.chalmers.se>
441 */
442 }
443 }
444#endif
445 69
446void SHA1_Final(unsigned char *md, SHA_CTX *c) 70#include "sha_locl.h"
447 {
448 register int i,j;
449 register SHA_LONG l;
450 register SHA_LONG *p;
451 static unsigned char end[4]={0x80,0x00,0x00,0x00};
452 unsigned char *cp=end;
453
454 /* c->num should definitly have room for at least one more byte. */
455 p=c->data;
456 j=c->num;
457 i=j>>2;
458#ifdef PURIFY
459 if ((j&0x03) == 0) p[i]=0;
460#endif
461 l=p[i];
462 M_p_c2nl(cp,l,j&0x03);
463 p[i]=l;
464 i++;
465 /* i is the next 'undefined word' */
466 if (c->num >= SHA_LAST_BLOCK)
467 {
468 for (; i<SHA_LBLOCK; i++)
469 p[i]=0;
470 sha1_block(c,p,1);
471 i=0;
472 }
473 for (; i<(SHA_LBLOCK-2); i++)
474 p[i]=0;
475 p[SHA_LBLOCK-2]=c->Nh;
476 p[SHA_LBLOCK-1]=c->Nl;
477#if SHA_LONG_LOG2==2
478#if !defined(B_ENDIAN) && defined(SHA1_ASM)
479 Endian_Reverse32(p[SHA_LBLOCK-2]);
480 Endian_Reverse32(p[SHA_LBLOCK-1]);
481#endif
482#endif
483 sha1_block(c,p,1);
484 cp=md;
485 l=c->h0; nl2c(l,cp);
486 l=c->h1; nl2c(l,cp);
487 l=c->h2; nl2c(l,cp);
488 l=c->h3; nl2c(l,cp);
489 l=c->h4; nl2c(l,cp);
490 71
491 c->num=0;
492 /* sha_block may be leaving some stuff on the stack
493 * but I'm not worried :-)
494 memset((void *)c,0,sizeof(SHA_CTX));
495 */
496 }
497#endif 72#endif
498 73
diff --git a/src/lib/libcrypto/sha/sha1s.cpp b/src/lib/libcrypto/sha/sha1s.cpp
index 3103e1871b..af23d1e0f2 100644
--- a/src/lib/libcrypto/sha/sha1s.cpp
+++ b/src/lib/libcrypto/sha/sha1s.cpp
@@ -34,6 +34,7 @@ void GetTSC(unsigned long& tsc)
34#include <stdlib.h> 34#include <stdlib.h>
35#include <openssl/sha.h> 35#include <openssl/sha.h>
36 36
37#define sha1_block_x86 sha1_block_asm_data_order
37extern "C" { 38extern "C" {
38void sha1_block_x86(SHA_CTX *ctx, unsigned char *buffer,int num); 39void sha1_block_x86(SHA_CTX *ctx, unsigned char *buffer,int num);
39} 40}
@@ -55,8 +56,10 @@ void main(int argc,char *argv[])
55 if (num == 0) num=16; 56 if (num == 0) num=16;
56 if (num > 250) num=16; 57 if (num > 250) num=16;
57 numm=num+2; 58 numm=num+2;
59#if 0
58 num*=64; 60 num*=64;
59 numm*=64; 61 numm*=64;
62#endif
60 63
61 for (j=0; j<6; j++) 64 for (j=0; j<6; j++)
62 { 65 {
@@ -72,7 +75,7 @@ void main(int argc,char *argv[])
72 sha1_block_x86(&ctx,buffer,num); 75 sha1_block_x86(&ctx,buffer,num);
73 } 76 }
74 77
75 printf("sha1 (%d bytes) %d %d (%.2f)\n",num, 78 printf("sha1 (%d bytes) %d %d (%.2f)\n",num*64,
76 e1-s1,e2-s2,(double)((e1-s1)-(e2-s2))/2); 79 e1-s1,e2-s2,(double)((e1-s1)-(e2-s2))/2);
77 } 80 }
78 } 81 }
diff --git a/src/lib/libcrypto/sha/sha1test.c b/src/lib/libcrypto/sha/sha1test.c
index 9400ad2a61..688d06c637 100644
--- a/src/lib/libcrypto/sha/sha1test.c
+++ b/src/lib/libcrypto/sha/sha1test.c
@@ -76,26 +76,26 @@ int main(int argc, char *argv[])
76#undef SHA_0 /* FIPS 180 */ 76#undef SHA_0 /* FIPS 180 */
77#define SHA_1 /* FIPS 180-1 */ 77#define SHA_1 /* FIPS 180-1 */
78 78
79char *test[]={ 79static char *test[]={
80 "abc", 80 "abc",
81 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 81 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
82 NULL, 82 NULL,
83 }; 83 };
84 84
85#ifdef SHA_0 85#ifdef SHA_0
86char *ret[]={ 86static char *ret[]={
87 "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", 87 "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
88 "d2516ee1acfa5baf33dfc1c471e438449ef134c8", 88 "d2516ee1acfa5baf33dfc1c471e438449ef134c8",
89 }; 89 };
90char *bigret= 90static char *bigret=
91 "3232affa48628a26653b5aaa44541fd90d690603"; 91 "3232affa48628a26653b5aaa44541fd90d690603";
92#endif 92#endif
93#ifdef SHA_1 93#ifdef SHA_1
94char *ret[]={ 94static char *ret[]={
95 "a9993e364706816aba3e25717850c26c9cd0d89d", 95 "a9993e364706816aba3e25717850c26c9cd0d89d",
96 "84983e441c3bd26ebaae4aa1f95129e5e54670f1", 96 "84983e441c3bd26ebaae4aa1f95129e5e54670f1",
97 }; 97 };
98char *bigret= 98static char *bigret=
99 "34aa973cd4c4daa4f61eeb2bdbad27316534016f"; 99 "34aa973cd4c4daa4f61eeb2bdbad27316534016f";
100#endif 100#endif
101 101
diff --git a/src/lib/libcrypto/sha/sha_dgst.c b/src/lib/libcrypto/sha/sha_dgst.c
index 4df535360f..894a96274a 100644
--- a/src/lib/libcrypto/sha/sha_dgst.c
+++ b/src/lib/libcrypto/sha/sha_dgst.c
@@ -1,4 +1,4 @@
1/* crypto/sha/sha_dgst.c */ 1/* crypto/sha/sha1dgst.c */
2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved. 3 * All rights reserved.
4 * 4 *
@@ -56,437 +56,18 @@
56 * [including the GNU Public Licence.] 56 * [including the GNU Public Licence.]
57 */ 57 */
58 58
59#include <stdio.h> 59#if !defined(NO_SHA0) && !defined(NO_SHA)
60#include <string.h>
61#define SHA_0
62#undef SHA_1
63#include <openssl/sha.h>
64#include "sha_locl.h"
65#include <openssl/opensslv.h>
66
67#ifndef NO_SHA0
68char *SHA_version="SHA" OPENSSL_VERSION_PTEXT;
69
70/* Implemented from SHA-0 document - The Secure Hash Algorithm
71 */
72
73#define INIT_DATA_h0 0x67452301UL
74#define INIT_DATA_h1 0xefcdab89UL
75#define INIT_DATA_h2 0x98badcfeUL
76#define INIT_DATA_h3 0x10325476UL
77#define INIT_DATA_h4 0xc3d2e1f0UL
78
79#define K_00_19 0x5a827999UL
80#define K_20_39 0x6ed9eba1UL
81#define K_40_59 0x8f1bbcdcUL
82#define K_60_79 0xca62c1d6UL
83
84static void sha_block(SHA_CTX *c, register SHA_LONG *p, int num);
85
86#if !defined(B_ENDIAN) && defined(SHA_ASM)
87# define M_c2nl c2l
88# define M_p_c2nl p_c2l
89# define M_c2nl_p c2l_p
90# define M_p_c2nl_p p_c2l_p
91# define M_nl2c l2c
92#else
93# define M_c2nl c2nl
94# define M_p_c2nl p_c2nl
95# define M_c2nl_p c2nl_p
96# define M_p_c2nl_p p_c2nl_p
97# define M_nl2c nl2c
98#endif
99
100void SHA_Init(SHA_CTX *c)
101 {
102 c->h0=INIT_DATA_h0;
103 c->h1=INIT_DATA_h1;
104 c->h2=INIT_DATA_h2;
105 c->h3=INIT_DATA_h3;
106 c->h4=INIT_DATA_h4;
107 c->Nl=0;
108 c->Nh=0;
109 c->num=0;
110 }
111 60
112void SHA_Update(SHA_CTX *c, register const unsigned char *data, 61#undef SHA_1
113 unsigned long len) 62#define SHA_0
114 {
115 register SHA_LONG *p;
116 int ew,ec,sw,sc;
117 SHA_LONG l;
118
119 if (len == 0) return;
120
121 l=(c->Nl+(len<<3))&0xffffffffL;
122 if (l < c->Nl) /* overflow */
123 c->Nh++;
124 c->Nh+=(len>>29);
125 c->Nl=l;
126
127 if (c->num != 0)
128 {
129 p=c->data;
130 sw=c->num>>2;
131 sc=c->num&0x03;
132
133 if ((c->num+len) >= SHA_CBLOCK)
134 {
135 l= p[sw];
136 M_p_c2nl(data,l,sc);
137 p[sw++]=l;
138 for (; sw<SHA_LBLOCK; sw++)
139 {
140 M_c2nl(data,l);
141 p[sw]=l;
142 }
143 len-=(SHA_CBLOCK-c->num);
144
145 sha_block(c,p,1);
146 c->num=0;
147 /* drop through and do the rest */
148 }
149 else
150 {
151 c->num+=(int)len;
152 if ((sc+len) < 4) /* ugly, add char's to a word */
153 {
154 l= p[sw];
155 M_p_c2nl_p(data,l,sc,len);
156 p[sw]=l;
157 }
158 else
159 {
160 ew=(c->num>>2);
161 ec=(c->num&0x03);
162 l= p[sw];
163 M_p_c2nl(data,l,sc);
164 p[sw++]=l;
165 for (; sw < ew; sw++)
166 { M_c2nl(data,l); p[sw]=l; }
167 if (ec)
168 {
169 M_c2nl_p(data,l,ec);
170 p[sw]=l;
171 }
172 }
173 return;
174 }
175 }
176 /* We can only do the following code for assember, the reason
177 * being that the sha_block 'C' version changes the values
178 * in the 'data' array. The assember code avoids this and
179 * copies it to a local array. I should be able to do this for
180 * the C version as well....
181 */
182#if SHA_LONG_LOG2==2
183#if defined(B_ENDIAN) || defined(SHA_ASM)
184 if ((((unsigned long)data)%sizeof(SHA_LONG)) == 0)
185 {
186 sw=len/SHA_CBLOCK;
187 if (sw)
188 {
189 sha_block(c,(SHA_LONG *)data,sw);
190 sw*=SHA_CBLOCK;
191 data+=sw;
192 len-=sw;
193 }
194 }
195#endif
196#endif
197 /* we now can process the input data in blocks of SHA_CBLOCK
198 * chars and save the leftovers to c->data. */
199 p=c->data;
200 while (len >= SHA_CBLOCK)
201 {
202#if SHA_LONG_LOG2==2
203#if defined(B_ENDIAN) || defined(SHA_ASM)
204#define SHA_NO_TAIL_CODE
205 /*
206 * Basically we get here only when data happens
207 * to be unaligned.
208 */
209 if (p != (SHA_LONG *)data)
210 memcpy(p,data,SHA_CBLOCK);
211 data+=SHA_CBLOCK;
212 sha_block(c,p=c->data,1);
213 len-=SHA_CBLOCK;
214#elif defined(L_ENDIAN)
215#define BE_COPY(dst,src,i) { \
216 l = ((SHA_LONG *)src)[i]; \
217 Endian_Reverse32(l); \
218 dst[i] = l; \
219 }
220 if ((((unsigned long)data)%sizeof(SHA_LONG)) == 0)
221 {
222 for (sw=(SHA_LBLOCK/4); sw; sw--)
223 {
224 BE_COPY(p,data,0);
225 BE_COPY(p,data,1);
226 BE_COPY(p,data,2);
227 BE_COPY(p,data,3);
228 p+=4;
229 data += 4*sizeof(SHA_LONG);
230 }
231 sha_block(c,p=c->data,1);
232 len-=SHA_CBLOCK;
233 continue;
234 }
235#endif
236#endif
237#ifndef SHA_NO_TAIL_CODE
238 /*
239 * In addition to "sizeof(SHA_LONG)!= 4" case the
240 * following code covers unaligned access cases on
241 * little-endian machines.
242 * <appro@fy.chalmers.se>
243 */
244 p=c->data;
245 for (sw=(SHA_LBLOCK/4); sw; sw--)
246 {
247 M_c2nl(data,l); p[0]=l;
248 M_c2nl(data,l); p[1]=l;
249 M_c2nl(data,l); p[2]=l;
250 M_c2nl(data,l); p[3]=l;
251 p+=4;
252 }
253 p=c->data;
254 sha_block(c,p,1);
255 len-=SHA_CBLOCK;
256#endif
257 }
258 ec=(int)len;
259 c->num=ec;
260 ew=(ec>>2);
261 ec&=0x03;
262 63
263 for (sw=0; sw < ew; sw++) 64#include <openssl/opensslv.h>
264 { M_c2nl(data,l); p[sw]=l; }
265 M_c2nl_p(data,l,ec);
266 p[sw]=l;
267 }
268
269void SHA_Transform(SHA_CTX *c, unsigned char *b)
270 {
271 SHA_LONG p[SHA_LBLOCK];
272
273#if SHA_LONG_LOG2==2
274#if defined(B_ENDIAN) || defined(SHA_ASM)
275 memcpy(p,b,SHA_CBLOCK);
276 sha_block(c,p,1);
277 return;
278#elif defined(L_ENDIAN)
279 if (((unsigned long)b%sizeof(SHA_LONG)) == 0)
280 {
281 SHA_LONG *q;
282 int i;
283
284 q=p;
285 for (i=(SHA_LBLOCK/4); i; i--)
286 {
287 unsigned long l;
288 BE_COPY(q,b,0); /* BE_COPY was defined above */
289 BE_COPY(q,b,1);
290 BE_COPY(q,b,2);
291 BE_COPY(q,b,3);
292 q+=4;
293 b+=4*sizeof(SHA_LONG);
294 }
295 sha_block(c,p,1);
296 return;
297 }
298#endif
299#endif
300#ifndef SHA_NO_TAIL_CODE /* defined above, see comment */
301 {
302 SHA_LONG *q;
303 int i;
304
305 q=p;
306 for (i=(SHA_LBLOCK/4); i; i--)
307 {
308 SHA_LONG l;
309 c2nl(b,l); *(q++)=l;
310 c2nl(b,l); *(q++)=l;
311 c2nl(b,l); *(q++)=l;
312 c2nl(b,l); *(q++)=l;
313 }
314 sha_block(c,p,1);
315 }
316#endif
317 }
318
319#ifndef SHA_ASM
320static void sha_block(SHA_CTX *c, register SHA_LONG *W, int num)
321 {
322 register SHA_LONG A,B,C,D,E,T;
323 SHA_LONG X[SHA_LBLOCK];
324
325 A=c->h0;
326 B=c->h1;
327 C=c->h2;
328 D=c->h3;
329 E=c->h4;
330
331 for (;;)
332 {
333 BODY_00_15( 0,A,B,C,D,E,T,W);
334 BODY_00_15( 1,T,A,B,C,D,E,W);
335 BODY_00_15( 2,E,T,A,B,C,D,W);
336 BODY_00_15( 3,D,E,T,A,B,C,W);
337 BODY_00_15( 4,C,D,E,T,A,B,W);
338 BODY_00_15( 5,B,C,D,E,T,A,W);
339 BODY_00_15( 6,A,B,C,D,E,T,W);
340 BODY_00_15( 7,T,A,B,C,D,E,W);
341 BODY_00_15( 8,E,T,A,B,C,D,W);
342 BODY_00_15( 9,D,E,T,A,B,C,W);
343 BODY_00_15(10,C,D,E,T,A,B,W);
344 BODY_00_15(11,B,C,D,E,T,A,W);
345 BODY_00_15(12,A,B,C,D,E,T,W);
346 BODY_00_15(13,T,A,B,C,D,E,W);
347 BODY_00_15(14,E,T,A,B,C,D,W);
348 BODY_00_15(15,D,E,T,A,B,C,W);
349 BODY_16_19(16,C,D,E,T,A,B,W,W,W,W);
350 BODY_16_19(17,B,C,D,E,T,A,W,W,W,W);
351 BODY_16_19(18,A,B,C,D,E,T,W,W,W,W);
352 BODY_16_19(19,T,A,B,C,D,E,W,W,W,X);
353
354 BODY_20_31(20,E,T,A,B,C,D,W,W,W,X);
355 BODY_20_31(21,D,E,T,A,B,C,W,W,W,X);
356 BODY_20_31(22,C,D,E,T,A,B,W,W,W,X);
357 BODY_20_31(23,B,C,D,E,T,A,W,W,W,X);
358 BODY_20_31(24,A,B,C,D,E,T,W,W,X,X);
359 BODY_20_31(25,T,A,B,C,D,E,W,W,X,X);
360 BODY_20_31(26,E,T,A,B,C,D,W,W,X,X);
361 BODY_20_31(27,D,E,T,A,B,C,W,W,X,X);
362 BODY_20_31(28,C,D,E,T,A,B,W,W,X,X);
363 BODY_20_31(29,B,C,D,E,T,A,W,W,X,X);
364 BODY_20_31(30,A,B,C,D,E,T,W,X,X,X);
365 BODY_20_31(31,T,A,B,C,D,E,W,X,X,X);
366 BODY_32_39(32,E,T,A,B,C,D,X);
367 BODY_32_39(33,D,E,T,A,B,C,X);
368 BODY_32_39(34,C,D,E,T,A,B,X);
369 BODY_32_39(35,B,C,D,E,T,A,X);
370 BODY_32_39(36,A,B,C,D,E,T,X);
371 BODY_32_39(37,T,A,B,C,D,E,X);
372 BODY_32_39(38,E,T,A,B,C,D,X);
373 BODY_32_39(39,D,E,T,A,B,C,X);
374
375 BODY_40_59(40,C,D,E,T,A,B,X);
376 BODY_40_59(41,B,C,D,E,T,A,X);
377 BODY_40_59(42,A,B,C,D,E,T,X);
378 BODY_40_59(43,T,A,B,C,D,E,X);
379 BODY_40_59(44,E,T,A,B,C,D,X);
380 BODY_40_59(45,D,E,T,A,B,C,X);
381 BODY_40_59(46,C,D,E,T,A,B,X);
382 BODY_40_59(47,B,C,D,E,T,A,X);
383 BODY_40_59(48,A,B,C,D,E,T,X);
384 BODY_40_59(49,T,A,B,C,D,E,X);
385 BODY_40_59(50,E,T,A,B,C,D,X);
386 BODY_40_59(51,D,E,T,A,B,C,X);
387 BODY_40_59(52,C,D,E,T,A,B,X);
388 BODY_40_59(53,B,C,D,E,T,A,X);
389 BODY_40_59(54,A,B,C,D,E,T,X);
390 BODY_40_59(55,T,A,B,C,D,E,X);
391 BODY_40_59(56,E,T,A,B,C,D,X);
392 BODY_40_59(57,D,E,T,A,B,C,X);
393 BODY_40_59(58,C,D,E,T,A,B,X);
394 BODY_40_59(59,B,C,D,E,T,A,X);
395
396 BODY_60_79(60,A,B,C,D,E,T,X);
397 BODY_60_79(61,T,A,B,C,D,E,X);
398 BODY_60_79(62,E,T,A,B,C,D,X);
399 BODY_60_79(63,D,E,T,A,B,C,X);
400 BODY_60_79(64,C,D,E,T,A,B,X);
401 BODY_60_79(65,B,C,D,E,T,A,X);
402 BODY_60_79(66,A,B,C,D,E,T,X);
403 BODY_60_79(67,T,A,B,C,D,E,X);
404 BODY_60_79(68,E,T,A,B,C,D,X);
405 BODY_60_79(69,D,E,T,A,B,C,X);
406 BODY_60_79(70,C,D,E,T,A,B,X);
407 BODY_60_79(71,B,C,D,E,T,A,X);
408 BODY_60_79(72,A,B,C,D,E,T,X);
409 BODY_60_79(73,T,A,B,C,D,E,X);
410 BODY_60_79(74,E,T,A,B,C,D,X);
411 BODY_60_79(75,D,E,T,A,B,C,X);
412 BODY_60_79(76,C,D,E,T,A,B,X);
413 BODY_60_79(77,B,C,D,E,T,A,X);
414 BODY_60_79(78,A,B,C,D,E,T,X);
415 BODY_60_79(79,T,A,B,C,D,E,X);
416
417 c->h0=(c->h0+E)&0xffffffffL;
418 c->h1=(c->h1+T)&0xffffffffL;
419 c->h2=(c->h2+A)&0xffffffffL;
420 c->h3=(c->h3+B)&0xffffffffL;
421 c->h4=(c->h4+C)&0xffffffffL;
422
423 if (--num <= 0) break;
424 65
425 A=c->h0; 66const char *SHA_version="SHA" OPENSSL_VERSION_PTEXT;
426 B=c->h1;
427 C=c->h2;
428 D=c->h3;
429 E=c->h4;
430 67
431 W+=SHA_LBLOCK; /* Note! This can happen only when sizeof(SHA_LONG) 68/* The implementation is in ../md32_common.h */
432 * is 4. Whenever it's not the actual case this
433 * function is never called with num larger than 1
434 * and we never advance down here.
435 * <appro@fy.chalmers.se>
436 */
437 }
438 }
439#endif
440 69
441void SHA_Final(unsigned char *md, SHA_CTX *c) 70#include "sha_locl.h"
442 {
443 register int i,j;
444 register SHA_LONG l;
445 register SHA_LONG *p;
446 static unsigned char end[4]={0x80,0x00,0x00,0x00};
447 unsigned char *cp=end;
448 71
449 /* c->num should definitly have room for at least one more byte. */
450 p=c->data;
451 j=c->num;
452 i=j>>2;
453#ifdef PURIFY
454 if ((j&0x03) == 0) p[i]=0;
455#endif
456 l=p[i];
457 M_p_c2nl(cp,l,j&0x03);
458 p[i]=l;
459 i++;
460 /* i is the next 'undefined word' */
461 if (c->num >= SHA_LAST_BLOCK)
462 {
463 for (; i<SHA_LBLOCK; i++)
464 p[i]=0;
465 sha_block(c,p,1);
466 i=0;
467 }
468 for (; i<(SHA_LBLOCK-2); i++)
469 p[i]=0;
470 p[SHA_LBLOCK-2]=c->Nh;
471 p[SHA_LBLOCK-1]=c->Nl;
472#if SHA_LONG_LOG2==2
473#if !defined(B_ENDIAN) && defined(SHA_ASM)
474 Endian_Reverse32(p[SHA_LBLOCK-2]);
475 Endian_Reverse32(p[SHA_LBLOCK-1]);
476#endif 72#endif
477#endif
478 sha_block(c,p,1);
479 cp=md;
480 l=c->h0; nl2c(l,cp);
481 l=c->h1; nl2c(l,cp);
482 l=c->h2; nl2c(l,cp);
483 l=c->h3; nl2c(l,cp);
484 l=c->h4; nl2c(l,cp);
485 73
486 c->num=0;
487 /* sha_block may be leaving some stuff on the stack
488 * but I'm not worried :-)
489 memset((void *)c,0,sizeof(SHA_CTX));
490 */
491 }
492#endif
diff --git a/src/lib/libcrypto/sha/sha_locl.h b/src/lib/libcrypto/sha/sha_locl.h
index 6646a8915b..3e6f489b87 100644
--- a/src/lib/libcrypto/sha/sha_locl.h
+++ b/src/lib/libcrypto/sha/sha_locl.h
@@ -60,180 +60,105 @@
60#include <string.h> 60#include <string.h>
61 61
62#include <openssl/opensslconf.h> 62#include <openssl/opensslconf.h>
63 63#include <openssl/sha.h>
64#ifdef undef
65/* one or the other needs to be defined */
66#ifndef SHA_1 /* FIPE 180-1 */
67#define SHA_0 /* FIPS 180 */
68#endif
69#endif
70
71#undef c2nl
72#define c2nl(c,l) (l =(((unsigned long)(*((c)++)))<<24), \
73 l|=(((unsigned long)(*((c)++)))<<16), \
74 l|=(((unsigned long)(*((c)++)))<< 8), \
75 l|=(((unsigned long)(*((c)++))) ))
76
77#undef p_c2nl
78#define p_c2nl(c,l,n) { \
79 switch (n) { \
80 case 0: l =((unsigned long)(*((c)++)))<<24; \
81 case 1: l|=((unsigned long)(*((c)++)))<<16; \
82 case 2: l|=((unsigned long)(*((c)++)))<< 8; \
83 case 3: l|=((unsigned long)(*((c)++))); \
84 } \
85 }
86
87#undef c2nl_p
88/* NOTE the pointer is not incremented at the end of this */
89#define c2nl_p(c,l,n) { \
90 l=0; \
91 (c)+=n; \
92 switch (n) { \
93 case 3: l =((unsigned long)(*(--(c))))<< 8; \
94 case 2: l|=((unsigned long)(*(--(c))))<<16; \
95 case 1: l|=((unsigned long)(*(--(c))))<<24; \
96 } \
97 }
98
99#undef p_c2nl_p
100#define p_c2nl_p(c,l,sc,len) { \
101 switch (sc) \
102 { \
103 case 0: l =((unsigned long)(*((c)++)))<<24; \
104 if (--len == 0) break; \
105 case 1: l|=((unsigned long)(*((c)++)))<<16; \
106 if (--len == 0) break; \
107 case 2: l|=((unsigned long)(*((c)++)))<< 8; \
108 } \
109 }
110
111#undef nl2c
112#define nl2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
113 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
114 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
115 *((c)++)=(unsigned char)(((l) )&0xff))
116
117#undef c2l
118#define c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \
119 l|=(((unsigned long)(*((c)++)))<< 8), \
120 l|=(((unsigned long)(*((c)++)))<<16), \
121 l|=(((unsigned long)(*((c)++)))<<24))
122
123#undef p_c2l
124#define p_c2l(c,l,n) { \
125 switch (n) { \
126 case 0: l =((unsigned long)(*((c)++))); \
127 case 1: l|=((unsigned long)(*((c)++)))<< 8; \
128 case 2: l|=((unsigned long)(*((c)++)))<<16; \
129 case 3: l|=((unsigned long)(*((c)++)))<<24; \
130 } \
131 }
132
133#undef c2l_p
134/* NOTE the pointer is not incremented at the end of this */
135#define c2l_p(c,l,n) { \
136 l=0; \
137 (c)+=n; \
138 switch (n) { \
139 case 3: l =((unsigned long)(*(--(c))))<<16; \
140 case 2: l|=((unsigned long)(*(--(c))))<< 8; \
141 case 1: l|=((unsigned long)(*(--(c)))); \
142 } \
143 }
144
145#undef p_c2l_p
146#define p_c2l_p(c,l,sc,len) { \
147 switch (sc) \
148 { \
149 case 0: l =((unsigned long)(*((c)++))); \
150 if (--len == 0) break; \
151 case 1: l|=((unsigned long)(*((c)++)))<< 8; \
152 if (--len == 0) break; \
153 case 2: l|=((unsigned long)(*((c)++)))<<16; \
154 } \
155 }
156
157#undef l2c
158#define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
159 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
160 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
161 *((c)++)=(unsigned char)(((l)>>24)&0xff))
162 64
163#ifndef SHA_LONG_LOG2 65#ifndef SHA_LONG_LOG2
164#define SHA_LONG_LOG2 2 /* default to 32 bits */ 66#define SHA_LONG_LOG2 2 /* default to 32 bits */
165#endif 67#endif
166 68
167#undef ROTATE 69#define DATA_ORDER_IS_BIG_ENDIAN
168#undef Endian_Reverse32 70
169#if defined(WIN32) 71#define HASH_LONG SHA_LONG
170#define ROTATE(a,n) _lrotl(a,n) 72#define HASH_LONG_LOG2 SHA_LONG_LOG2
171#elif defined(__GNUC__) && !defined(PEDANTIC) 73#define HASH_CTX SHA_CTX
172/* some inline assembler templates by <appro@fy.chalmers.se> */ 74#define HASH_CBLOCK SHA_CBLOCK
173#if defined(__i386) && !defined(NO_ASM) 75#define HASH_LBLOCK SHA_LBLOCK
174#define ROTATE(a,n) ({ register unsigned int ret; \ 76#define HASH_MAKE_STRING(c,s) do { \
175 asm ("roll %1,%0" \ 77 unsigned long ll; \
176 : "=r"(ret) \ 78 ll=(c)->h0; HOST_l2c(ll,(s)); \
177 : "I"(n), "0"(a) \ 79 ll=(c)->h1; HOST_l2c(ll,(s)); \
178 : "cc"); \ 80 ll=(c)->h2; HOST_l2c(ll,(s)); \
179 ret; \ 81 ll=(c)->h3; HOST_l2c(ll,(s)); \
180 }) 82 ll=(c)->h4; HOST_l2c(ll,(s)); \
181#ifndef I386_ONLY 83 } while (0)
182#define Endian_Reverse32(a) \ 84
183 { register unsigned int ltmp=(a); \ 85#if defined(SHA_0)
184 asm ("bswapl %0" \ 86
185 : "=r"(ltmp) : "0"(ltmp)); \ 87# define HASH_UPDATE SHA_Update
186 (a)=ltmp; \ 88# define HASH_TRANSFORM SHA_Transform
187 } 89# define HASH_FINAL SHA_Final
188#endif 90# define HASH_INIT SHA_Init
189#elif defined(__powerpc) 91# define HASH_BLOCK_HOST_ORDER sha_block_host_order
190#define ROTATE(a,n) ({ register unsigned int ret; \ 92# define HASH_BLOCK_DATA_ORDER sha_block_data_order
191 asm ("rlwinm %0,%1,%2,0,31" \ 93# define Xupdate(a,ix,ia,ib,ic,id) (ix=(a)=(ia^ib^ic^id))
192 : "=r"(ret) \ 94
193 : "r"(a), "I"(n)); \ 95 void sha_block_host_order (SHA_CTX *c, const void *p,int num);
194 ret; \ 96 void sha_block_data_order (SHA_CTX *c, const void *p,int num);
195 }) 97
196/* Endian_Reverse32 is not needed for PowerPC */ 98#elif defined(SHA_1)
197#endif 99
198#endif 100# define HASH_UPDATE SHA1_Update
101# define HASH_TRANSFORM SHA1_Transform
102# define HASH_FINAL SHA1_Final
103# define HASH_INIT SHA1_Init
104# define HASH_BLOCK_HOST_ORDER sha1_block_host_order
105# define HASH_BLOCK_DATA_ORDER sha1_block_data_order
106# if defined(__MWERKS__) && defined(__MC68K__)
107 /* Metrowerks for Motorola fails otherwise:-( <appro@fy.chalmers.se> */
108# define Xupdate(a,ix,ia,ib,ic,id) do { (a)=(ia^ib^ic^id); \
109 ix=(a)=ROTATE((a),1); \
110 } while (0)
111# else
112# define Xupdate(a,ix,ia,ib,ic,id) ( (a)=(ia^ib^ic^id), \
113 ix=(a)=ROTATE((a),1) \
114 )
115# endif
116
117# ifdef SHA1_ASM
118# if defined(__i386) || defined(_M_IX86) || defined(__INTEL__)
119# define sha1_block_host_order sha1_block_asm_host_order
120# define DONT_IMPLEMENT_BLOCK_HOST_ORDER
121# define sha1_block_data_order sha1_block_asm_data_order
122# define DONT_IMPLEMENT_BLOCK_DATA_ORDER
123# define HASH_BLOCK_DATA_ORDER_ALIGNED sha1_block_asm_data_order
124# endif
125# endif
126 void sha1_block_host_order (SHA_CTX *c, const void *p,int num);
127 void sha1_block_data_order (SHA_CTX *c, const void *p,int num);
199 128
200/* A nice byte order reversal from Wei Dai <weidai@eskimo.com> */
201#ifdef ROTATE
202#ifndef Endian_Reverse32
203/* 5 instructions with rotate instruction, else 9 */
204#define Endian_Reverse32(a) \
205 { \
206 unsigned long t=(a); \
207 (a)=((ROTATE(t,8)&0x00FF00FF)|(ROTATE((t&0x00FF00FF),24))); \
208 }
209#endif
210#else 129#else
211#define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n)))) 130# error "Either SHA_0 or SHA_1 must be defined."
212#ifndef Endian_Reverse32
213/* 6 instructions with rotate instruction, else 8 */
214#define Endian_Reverse32(a) \
215 { \
216 unsigned long t=(a); \
217 t=(((t>>8)&0x00FF00FF)|((t&0x00FF00FF)<<8)); \
218 (a)=ROTATE(t,16); \
219 }
220#endif 131#endif
221/* 132
222 * Originally the middle line started with l=(((l&0xFF00FF00)>>8)|... 133#ifndef FLAT_INC
223 * It's rewritten as above for two reasons: 134#include "../md32_common.h"
224 * - RISCs aren't good at long constants and have to explicitely 135#else
225 * compose 'em with several (well, usually 2) instructions in a 136#include "md32_common.h"
226 * register before performing the actual operation and (as you
227 * already realized:-) having same constant should inspire the
228 * compiler to permanently allocate the only register for it;
229 * - most modern CPUs have two ALUs, but usually only one has
230 * circuitry for shifts:-( this minor tweak inspires compiler
231 * to schedule shift instructions in a better way...
232 *
233 * <appro@fy.chalmers.se>
234 */
235#endif 137#endif
236 138
139#define INIT_DATA_h0 0x67452301UL
140#define INIT_DATA_h1 0xefcdab89UL
141#define INIT_DATA_h2 0x98badcfeUL
142#define INIT_DATA_h3 0x10325476UL
143#define INIT_DATA_h4 0xc3d2e1f0UL
144
145void HASH_INIT (SHA_CTX *c)
146 {
147 c->h0=INIT_DATA_h0;
148 c->h1=INIT_DATA_h1;
149 c->h2=INIT_DATA_h2;
150 c->h3=INIT_DATA_h3;
151 c->h4=INIT_DATA_h4;
152 c->Nl=0;
153 c->Nh=0;
154 c->num=0;
155 }
156
157#define K_00_19 0x5a827999UL
158#define K_20_39 0x6ed9eba1UL
159#define K_40_59 0x8f1bbcdcUL
160#define K_60_79 0xca62c1d6UL
161
237/* As pointed out by Wei Dai <weidai@eskimo.com>, F() below can be 162/* As pointed out by Wei Dai <weidai@eskimo.com>, F() below can be
238 * simplified to the code in F_00_19. Wei attributes these optimisations 163 * simplified to the code in F_00_19. Wei attributes these optimisations
239 * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel. 164 * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
@@ -246,43 +171,305 @@
246#define F_40_59(b,c,d) (((b) & (c)) | (((b)|(c)) & (d))) 171#define F_40_59(b,c,d) (((b) & (c)) | (((b)|(c)) & (d)))
247#define F_60_79(b,c,d) F_20_39(b,c,d) 172#define F_60_79(b,c,d) F_20_39(b,c,d)
248 173
249#undef Xupdate 174#define BODY_00_15(i,a,b,c,d,e,f,xi) \
250#ifdef SHA_0 175 (f)=xi+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
251#define Xupdate(a,i,ia,ib,ic,id) X[(i)&0x0f]=(a)=\
252 (ia[(i)&0x0f]^ib[((i)+2)&0x0f]^ic[((i)+8)&0x0f]^id[((i)+13)&0x0f]);
253#endif
254#ifdef SHA_1
255#define Xupdate(a,i,ia,ib,ic,id) (a)=\
256 (ia[(i)&0x0f]^ib[((i)+2)&0x0f]^ic[((i)+8)&0x0f]^id[((i)+13)&0x0f]);\
257 X[(i)&0x0f]=(a)=ROTATE((a),1);
258#endif
259
260#define BODY_00_15(i,a,b,c,d,e,f,xa) \
261 (f)=xa[i]+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
262 (b)=ROTATE((b),30); 176 (b)=ROTATE((b),30);
263 177
264#define BODY_16_19(i,a,b,c,d,e,f,xa,xb,xc,xd) \ 178#define BODY_16_19(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
265 Xupdate(f,i,xa,xb,xc,xd); \ 179 Xupdate(f,xi,xa,xb,xc,xd); \
266 (f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \ 180 (f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
267 (b)=ROTATE((b),30); 181 (b)=ROTATE((b),30);
268 182
269#define BODY_20_31(i,a,b,c,d,e,f,xa,xb,xc,xd) \ 183#define BODY_20_31(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
270 Xupdate(f,i,xa,xb,xc,xd); \ 184 Xupdate(f,xi,xa,xb,xc,xd); \
271 (f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \ 185 (f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
272 (b)=ROTATE((b),30); 186 (b)=ROTATE((b),30);
273 187
274#define BODY_32_39(i,a,b,c,d,e,f,xa) \ 188#define BODY_32_39(i,a,b,c,d,e,f,xa,xb,xc,xd) \
275 Xupdate(f,i,xa,xa,xa,xa); \ 189 Xupdate(f,xa,xa,xb,xc,xd); \
276 (f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \ 190 (f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
277 (b)=ROTATE((b),30); 191 (b)=ROTATE((b),30);
278 192
279#define BODY_40_59(i,a,b,c,d,e,f,xa) \ 193#define BODY_40_59(i,a,b,c,d,e,f,xa,xb,xc,xd) \
280 Xupdate(f,i,xa,xa,xa,xa); \ 194 Xupdate(f,xa,xa,xb,xc,xd); \
281 (f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \ 195 (f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \
282 (b)=ROTATE((b),30); 196 (b)=ROTATE((b),30);
283 197
284#define BODY_60_79(i,a,b,c,d,e,f,xa) \ 198#define BODY_60_79(i,a,b,c,d,e,f,xa,xb,xc,xd) \
285 Xupdate(f,i,xa,xa,xa,xa); \ 199 Xupdate(f,xa,xa,xb,xc,xd); \
286 (f)=X[(i)&0x0f]+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \ 200 (f)=xa+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \
287 (b)=ROTATE((b),30); 201 (b)=ROTATE((b),30);
288 202
203#ifdef X
204#undef X
205#endif
206#ifndef MD32_XARRAY
207 /*
208 * Originally X was an array. As it's automatic it's natural
209 * to expect RISC compiler to accomodate at least part of it in
210 * the register bank, isn't it? Unfortunately not all compilers
211 * "find" this expectation reasonable:-( On order to make such
212 * compilers generate better code I replace X[] with a bunch of
213 * X0, X1, etc. See the function body below...
214 * <appro@fy.chalmers.se>
215 */
216# define X(i) XX##i
217#else
218 /*
219 * However! Some compilers (most notably HP C) get overwhelmed by
220 * that many local variables so that we have to have the way to
221 * fall down to the original behavior.
222 */
223# define X(i) XX[i]
224#endif
225
226#ifndef DONT_IMPLEMENT_BLOCK_HOST_ORDER
227void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, int num)
228 {
229 const SHA_LONG *W=d;
230 register unsigned long A,B,C,D,E,T;
231#ifndef MD32_XARRAY
232 unsigned long XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
233 XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
234#else
235 SHA_LONG XX[16];
236#endif
237
238 A=c->h0;
239 B=c->h1;
240 C=c->h2;
241 D=c->h3;
242 E=c->h4;
243
244 for (;;)
245 {
246 BODY_00_15( 0,A,B,C,D,E,T,W[ 0]);
247 BODY_00_15( 1,T,A,B,C,D,E,W[ 1]);
248 BODY_00_15( 2,E,T,A,B,C,D,W[ 2]);
249 BODY_00_15( 3,D,E,T,A,B,C,W[ 3]);
250 BODY_00_15( 4,C,D,E,T,A,B,W[ 4]);
251 BODY_00_15( 5,B,C,D,E,T,A,W[ 5]);
252 BODY_00_15( 6,A,B,C,D,E,T,W[ 6]);
253 BODY_00_15( 7,T,A,B,C,D,E,W[ 7]);
254 BODY_00_15( 8,E,T,A,B,C,D,W[ 8]);
255 BODY_00_15( 9,D,E,T,A,B,C,W[ 9]);
256 BODY_00_15(10,C,D,E,T,A,B,W[10]);
257 BODY_00_15(11,B,C,D,E,T,A,W[11]);
258 BODY_00_15(12,A,B,C,D,E,T,W[12]);
259 BODY_00_15(13,T,A,B,C,D,E,W[13]);
260 BODY_00_15(14,E,T,A,B,C,D,W[14]);
261 BODY_00_15(15,D,E,T,A,B,C,W[15]);
262
263 BODY_16_19(16,C,D,E,T,A,B,X( 0),W[ 0],W[ 2],W[ 8],W[13]);
264 BODY_16_19(17,B,C,D,E,T,A,X( 1),W[ 1],W[ 3],W[ 9],W[14]);
265 BODY_16_19(18,A,B,C,D,E,T,X( 2),W[ 2],W[ 4],W[10],W[15]);
266 BODY_16_19(19,T,A,B,C,D,E,X( 3),W[ 3],W[ 5],W[11],X( 0));
267
268 BODY_20_31(20,E,T,A,B,C,D,X( 4),W[ 4],W[ 6],W[12],X( 1));
269 BODY_20_31(21,D,E,T,A,B,C,X( 5),W[ 5],W[ 7],W[13],X( 2));
270 BODY_20_31(22,C,D,E,T,A,B,X( 6),W[ 6],W[ 8],W[14],X( 3));
271 BODY_20_31(23,B,C,D,E,T,A,X( 7),W[ 7],W[ 9],W[15],X( 4));
272 BODY_20_31(24,A,B,C,D,E,T,X( 8),W[ 8],W[10],X( 0),X( 5));
273 BODY_20_31(25,T,A,B,C,D,E,X( 9),W[ 9],W[11],X( 1),X( 6));
274 BODY_20_31(26,E,T,A,B,C,D,X(10),W[10],W[12],X( 2),X( 7));
275 BODY_20_31(27,D,E,T,A,B,C,X(11),W[11],W[13],X( 3),X( 8));
276 BODY_20_31(28,C,D,E,T,A,B,X(12),W[12],W[14],X( 4),X( 9));
277 BODY_20_31(29,B,C,D,E,T,A,X(13),W[13],W[15],X( 5),X(10));
278 BODY_20_31(30,A,B,C,D,E,T,X(14),W[14],X( 0),X( 6),X(11));
279 BODY_20_31(31,T,A,B,C,D,E,X(15),W[15],X( 1),X( 7),X(12));
280
281 BODY_32_39(32,E,T,A,B,C,D,X( 0),X( 2),X( 8),X(13));
282 BODY_32_39(33,D,E,T,A,B,C,X( 1),X( 3),X( 9),X(14));
283 BODY_32_39(34,C,D,E,T,A,B,X( 2),X( 4),X(10),X(15));
284 BODY_32_39(35,B,C,D,E,T,A,X( 3),X( 5),X(11),X( 0));
285 BODY_32_39(36,A,B,C,D,E,T,X( 4),X( 6),X(12),X( 1));
286 BODY_32_39(37,T,A,B,C,D,E,X( 5),X( 7),X(13),X( 2));
287 BODY_32_39(38,E,T,A,B,C,D,X( 6),X( 8),X(14),X( 3));
288 BODY_32_39(39,D,E,T,A,B,C,X( 7),X( 9),X(15),X( 4));
289
290 BODY_40_59(40,C,D,E,T,A,B,X( 8),X(10),X( 0),X( 5));
291 BODY_40_59(41,B,C,D,E,T,A,X( 9),X(11),X( 1),X( 6));
292 BODY_40_59(42,A,B,C,D,E,T,X(10),X(12),X( 2),X( 7));
293 BODY_40_59(43,T,A,B,C,D,E,X(11),X(13),X( 3),X( 8));
294 BODY_40_59(44,E,T,A,B,C,D,X(12),X(14),X( 4),X( 9));
295 BODY_40_59(45,D,E,T,A,B,C,X(13),X(15),X( 5),X(10));
296 BODY_40_59(46,C,D,E,T,A,B,X(14),X( 0),X( 6),X(11));
297 BODY_40_59(47,B,C,D,E,T,A,X(15),X( 1),X( 7),X(12));
298 BODY_40_59(48,A,B,C,D,E,T,X( 0),X( 2),X( 8),X(13));
299 BODY_40_59(49,T,A,B,C,D,E,X( 1),X( 3),X( 9),X(14));
300 BODY_40_59(50,E,T,A,B,C,D,X( 2),X( 4),X(10),X(15));
301 BODY_40_59(51,D,E,T,A,B,C,X( 3),X( 5),X(11),X( 0));
302 BODY_40_59(52,C,D,E,T,A,B,X( 4),X( 6),X(12),X( 1));
303 BODY_40_59(53,B,C,D,E,T,A,X( 5),X( 7),X(13),X( 2));
304 BODY_40_59(54,A,B,C,D,E,T,X( 6),X( 8),X(14),X( 3));
305 BODY_40_59(55,T,A,B,C,D,E,X( 7),X( 9),X(15),X( 4));
306 BODY_40_59(56,E,T,A,B,C,D,X( 8),X(10),X( 0),X( 5));
307 BODY_40_59(57,D,E,T,A,B,C,X( 9),X(11),X( 1),X( 6));
308 BODY_40_59(58,C,D,E,T,A,B,X(10),X(12),X( 2),X( 7));
309 BODY_40_59(59,B,C,D,E,T,A,X(11),X(13),X( 3),X( 8));
310
311 BODY_60_79(60,A,B,C,D,E,T,X(12),X(14),X( 4),X( 9));
312 BODY_60_79(61,T,A,B,C,D,E,X(13),X(15),X( 5),X(10));
313 BODY_60_79(62,E,T,A,B,C,D,X(14),X( 0),X( 6),X(11));
314 BODY_60_79(63,D,E,T,A,B,C,X(15),X( 1),X( 7),X(12));
315 BODY_60_79(64,C,D,E,T,A,B,X( 0),X( 2),X( 8),X(13));
316 BODY_60_79(65,B,C,D,E,T,A,X( 1),X( 3),X( 9),X(14));
317 BODY_60_79(66,A,B,C,D,E,T,X( 2),X( 4),X(10),X(15));
318 BODY_60_79(67,T,A,B,C,D,E,X( 3),X( 5),X(11),X( 0));
319 BODY_60_79(68,E,T,A,B,C,D,X( 4),X( 6),X(12),X( 1));
320 BODY_60_79(69,D,E,T,A,B,C,X( 5),X( 7),X(13),X( 2));
321 BODY_60_79(70,C,D,E,T,A,B,X( 6),X( 8),X(14),X( 3));
322 BODY_60_79(71,B,C,D,E,T,A,X( 7),X( 9),X(15),X( 4));
323 BODY_60_79(72,A,B,C,D,E,T,X( 8),X(10),X( 0),X( 5));
324 BODY_60_79(73,T,A,B,C,D,E,X( 9),X(11),X( 1),X( 6));
325 BODY_60_79(74,E,T,A,B,C,D,X(10),X(12),X( 2),X( 7));
326 BODY_60_79(75,D,E,T,A,B,C,X(11),X(13),X( 3),X( 8));
327 BODY_60_79(76,C,D,E,T,A,B,X(12),X(14),X( 4),X( 9));
328 BODY_60_79(77,B,C,D,E,T,A,X(13),X(15),X( 5),X(10));
329 BODY_60_79(78,A,B,C,D,E,T,X(14),X( 0),X( 6),X(11));
330 BODY_60_79(79,T,A,B,C,D,E,X(15),X( 1),X( 7),X(12));
331
332 c->h0=(c->h0+E)&0xffffffffL;
333 c->h1=(c->h1+T)&0xffffffffL;
334 c->h2=(c->h2+A)&0xffffffffL;
335 c->h3=(c->h3+B)&0xffffffffL;
336 c->h4=(c->h4+C)&0xffffffffL;
337
338 if (--num <= 0) break;
339
340 A=c->h0;
341 B=c->h1;
342 C=c->h2;
343 D=c->h3;
344 E=c->h4;
345
346 W+=SHA_LBLOCK;
347 }
348 }
349#endif
350
351#ifndef DONT_IMPLEMENT_BLOCK_DATA_ORDER
352void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, int num)
353 {
354 const unsigned char *data=p;
355 register unsigned long A,B,C,D,E,T,l;
356#ifndef MD32_XARRAY
357 unsigned long XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
358 XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
359#else
360 SHA_LONG XX[16];
361#endif
362
363 A=c->h0;
364 B=c->h1;
365 C=c->h2;
366 D=c->h3;
367 E=c->h4;
368
369 for (;;)
370 {
371
372 HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l;
373 BODY_00_15( 0,A,B,C,D,E,T,X( 0)); HOST_c2l(data,l); X( 2)=l;
374 BODY_00_15( 1,T,A,B,C,D,E,X( 1)); HOST_c2l(data,l); X( 3)=l;
375 BODY_00_15( 2,E,T,A,B,C,D,X( 2)); HOST_c2l(data,l); X( 4)=l;
376 BODY_00_15( 3,D,E,T,A,B,C,X( 3)); HOST_c2l(data,l); X( 5)=l;
377 BODY_00_15( 4,C,D,E,T,A,B,X( 4)); HOST_c2l(data,l); X( 6)=l;
378 BODY_00_15( 5,B,C,D,E,T,A,X( 5)); HOST_c2l(data,l); X( 7)=l;
379 BODY_00_15( 6,A,B,C,D,E,T,X( 6)); HOST_c2l(data,l); X( 8)=l;
380 BODY_00_15( 7,T,A,B,C,D,E,X( 7)); HOST_c2l(data,l); X( 9)=l;
381 BODY_00_15( 8,E,T,A,B,C,D,X( 8)); HOST_c2l(data,l); X(10)=l;
382 BODY_00_15( 9,D,E,T,A,B,C,X( 9)); HOST_c2l(data,l); X(11)=l;
383 BODY_00_15(10,C,D,E,T,A,B,X(10)); HOST_c2l(data,l); X(12)=l;
384 BODY_00_15(11,B,C,D,E,T,A,X(11)); HOST_c2l(data,l); X(13)=l;
385 BODY_00_15(12,A,B,C,D,E,T,X(12)); HOST_c2l(data,l); X(14)=l;
386 BODY_00_15(13,T,A,B,C,D,E,X(13)); HOST_c2l(data,l); X(15)=l;
387 BODY_00_15(14,E,T,A,B,C,D,X(14));
388 BODY_00_15(15,D,E,T,A,B,C,X(15));
389
390 BODY_16_19(16,C,D,E,T,A,B,X( 0),X( 0),X( 2),X( 8),X(13));
391 BODY_16_19(17,B,C,D,E,T,A,X( 1),X( 1),X( 3),X( 9),X(14));
392 BODY_16_19(18,A,B,C,D,E,T,X( 2),X( 2),X( 4),X(10),X(15));
393 BODY_16_19(19,T,A,B,C,D,E,X( 3),X( 3),X( 5),X(11),X( 0));
394
395 BODY_20_31(20,E,T,A,B,C,D,X( 4),X( 4),X( 6),X(12),X( 1));
396 BODY_20_31(21,D,E,T,A,B,C,X( 5),X( 5),X( 7),X(13),X( 2));
397 BODY_20_31(22,C,D,E,T,A,B,X( 6),X( 6),X( 8),X(14),X( 3));
398 BODY_20_31(23,B,C,D,E,T,A,X( 7),X( 7),X( 9),X(15),X( 4));
399 BODY_20_31(24,A,B,C,D,E,T,X( 8),X( 8),X(10),X( 0),X( 5));
400 BODY_20_31(25,T,A,B,C,D,E,X( 9),X( 9),X(11),X( 1),X( 6));
401 BODY_20_31(26,E,T,A,B,C,D,X(10),X(10),X(12),X( 2),X( 7));
402 BODY_20_31(27,D,E,T,A,B,C,X(11),X(11),X(13),X( 3),X( 8));
403 BODY_20_31(28,C,D,E,T,A,B,X(12),X(12),X(14),X( 4),X( 9));
404 BODY_20_31(29,B,C,D,E,T,A,X(13),X(13),X(15),X( 5),X(10));
405 BODY_20_31(30,A,B,C,D,E,T,X(14),X(14),X( 0),X( 6),X(11));
406 BODY_20_31(31,T,A,B,C,D,E,X(15),X(15),X( 1),X( 7),X(12));
407
408 BODY_32_39(32,E,T,A,B,C,D,X( 0),X( 2),X( 8),X(13));
409 BODY_32_39(33,D,E,T,A,B,C,X( 1),X( 3),X( 9),X(14));
410 BODY_32_39(34,C,D,E,T,A,B,X( 2),X( 4),X(10),X(15));
411 BODY_32_39(35,B,C,D,E,T,A,X( 3),X( 5),X(11),X( 0));
412 BODY_32_39(36,A,B,C,D,E,T,X( 4),X( 6),X(12),X( 1));
413 BODY_32_39(37,T,A,B,C,D,E,X( 5),X( 7),X(13),X( 2));
414 BODY_32_39(38,E,T,A,B,C,D,X( 6),X( 8),X(14),X( 3));
415 BODY_32_39(39,D,E,T,A,B,C,X( 7),X( 9),X(15),X( 4));
416
417 BODY_40_59(40,C,D,E,T,A,B,X( 8),X(10),X( 0),X( 5));
418 BODY_40_59(41,B,C,D,E,T,A,X( 9),X(11),X( 1),X( 6));
419 BODY_40_59(42,A,B,C,D,E,T,X(10),X(12),X( 2),X( 7));
420 BODY_40_59(43,T,A,B,C,D,E,X(11),X(13),X( 3),X( 8));
421 BODY_40_59(44,E,T,A,B,C,D,X(12),X(14),X( 4),X( 9));
422 BODY_40_59(45,D,E,T,A,B,C,X(13),X(15),X( 5),X(10));
423 BODY_40_59(46,C,D,E,T,A,B,X(14),X( 0),X( 6),X(11));
424 BODY_40_59(47,B,C,D,E,T,A,X(15),X( 1),X( 7),X(12));
425 BODY_40_59(48,A,B,C,D,E,T,X( 0),X( 2),X( 8),X(13));
426 BODY_40_59(49,T,A,B,C,D,E,X( 1),X( 3),X( 9),X(14));
427 BODY_40_59(50,E,T,A,B,C,D,X( 2),X( 4),X(10),X(15));
428 BODY_40_59(51,D,E,T,A,B,C,X( 3),X( 5),X(11),X( 0));
429 BODY_40_59(52,C,D,E,T,A,B,X( 4),X( 6),X(12),X( 1));
430 BODY_40_59(53,B,C,D,E,T,A,X( 5),X( 7),X(13),X( 2));
431 BODY_40_59(54,A,B,C,D,E,T,X( 6),X( 8),X(14),X( 3));
432 BODY_40_59(55,T,A,B,C,D,E,X( 7),X( 9),X(15),X( 4));
433 BODY_40_59(56,E,T,A,B,C,D,X( 8),X(10),X( 0),X( 5));
434 BODY_40_59(57,D,E,T,A,B,C,X( 9),X(11),X( 1),X( 6));
435 BODY_40_59(58,C,D,E,T,A,B,X(10),X(12),X( 2),X( 7));
436 BODY_40_59(59,B,C,D,E,T,A,X(11),X(13),X( 3),X( 8));
437
438 BODY_60_79(60,A,B,C,D,E,T,X(12),X(14),X( 4),X( 9));
439 BODY_60_79(61,T,A,B,C,D,E,X(13),X(15),X( 5),X(10));
440 BODY_60_79(62,E,T,A,B,C,D,X(14),X( 0),X( 6),X(11));
441 BODY_60_79(63,D,E,T,A,B,C,X(15),X( 1),X( 7),X(12));
442 BODY_60_79(64,C,D,E,T,A,B,X( 0),X( 2),X( 8),X(13));
443 BODY_60_79(65,B,C,D,E,T,A,X( 1),X( 3),X( 9),X(14));
444 BODY_60_79(66,A,B,C,D,E,T,X( 2),X( 4),X(10),X(15));
445 BODY_60_79(67,T,A,B,C,D,E,X( 3),X( 5),X(11),X( 0));
446 BODY_60_79(68,E,T,A,B,C,D,X( 4),X( 6),X(12),X( 1));
447 BODY_60_79(69,D,E,T,A,B,C,X( 5),X( 7),X(13),X( 2));
448 BODY_60_79(70,C,D,E,T,A,B,X( 6),X( 8),X(14),X( 3));
449 BODY_60_79(71,B,C,D,E,T,A,X( 7),X( 9),X(15),X( 4));
450 BODY_60_79(72,A,B,C,D,E,T,X( 8),X(10),X( 0),X( 5));
451 BODY_60_79(73,T,A,B,C,D,E,X( 9),X(11),X( 1),X( 6));
452 BODY_60_79(74,E,T,A,B,C,D,X(10),X(12),X( 2),X( 7));
453 BODY_60_79(75,D,E,T,A,B,C,X(11),X(13),X( 3),X( 8));
454 BODY_60_79(76,C,D,E,T,A,B,X(12),X(14),X( 4),X( 9));
455 BODY_60_79(77,B,C,D,E,T,A,X(13),X(15),X( 5),X(10));
456 BODY_60_79(78,A,B,C,D,E,T,X(14),X( 0),X( 6),X(11));
457 BODY_60_79(79,T,A,B,C,D,E,X(15),X( 1),X( 7),X(12));
458
459 c->h0=(c->h0+E)&0xffffffffL;
460 c->h1=(c->h1+T)&0xffffffffL;
461 c->h2=(c->h2+A)&0xffffffffL;
462 c->h3=(c->h3+B)&0xffffffffL;
463 c->h4=(c->h4+C)&0xffffffffL;
464
465 if (--num <= 0) break;
466
467 A=c->h0;
468 B=c->h1;
469 C=c->h2;
470 D=c->h3;
471 E=c->h4;
472
473 }
474 }
475#endif
diff --git a/src/lib/libcrypto/sha/shatest.c b/src/lib/libcrypto/sha/shatest.c
index 2b0744d937..a5786bbf76 100644
--- a/src/lib/libcrypto/sha/shatest.c
+++ b/src/lib/libcrypto/sha/shatest.c
@@ -76,26 +76,26 @@ int main(int argc, char *argv[])
76#define SHA_0 /* FIPS 180 */ 76#define SHA_0 /* FIPS 180 */
77#undef SHA_1 /* FIPS 180-1 */ 77#undef SHA_1 /* FIPS 180-1 */
78 78
79char *test[]={ 79static char *test[]={
80 "abc", 80 "abc",
81 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 81 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
82 NULL, 82 NULL,
83 }; 83 };
84 84
85#ifdef SHA_0 85#ifdef SHA_0
86char *ret[]={ 86static char *ret[]={
87 "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", 87 "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
88 "d2516ee1acfa5baf33dfc1c471e438449ef134c8", 88 "d2516ee1acfa5baf33dfc1c471e438449ef134c8",
89 }; 89 };
90char *bigret= 90static char *bigret=
91 "3232affa48628a26653b5aaa44541fd90d690603"; 91 "3232affa48628a26653b5aaa44541fd90d690603";
92#endif 92#endif
93#ifdef SHA_1 93#ifdef SHA_1
94char *ret[]={ 94static char *ret[]={
95 "a9993e364706816aba3e25717850c26c9cd0d89d", 95 "a9993e364706816aba3e25717850c26c9cd0d89d",
96 "84983e441c3bd26ebaae4aa1f95129e5e54670f1", 96 "84983e441c3bd26ebaae4aa1f95129e5e54670f1",
97 }; 97 };
98char *bigret= 98static char *bigret=
99 "34aa973cd4c4daa4f61eeb2bdbad27316534016f"; 99 "34aa973cd4c4daa4f61eeb2bdbad27316534016f";
100#endif 100#endif
101 101
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-10 20:51:41 +0000