diff options
Diffstat (limited to 'src/lib/libcrypto/sha')
-rw-r--r-- | src/lib/libcrypto/sha/Makefile.ssl | 4 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/asm/s1-win32.asm | 1138 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/asm/sha1-586.pl | 107 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha.h | 10 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha1dgst.c | 437 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha1s.cpp | 5 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha1test.c | 10 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha_dgst.c | 435 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/sha_locl.h | 563 | ||||
-rw-r--r-- | src/lib/libcrypto/sha/shatest.c | 10 |
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: | |||
104 | sha1_one.o: ../../include/openssl/sha.h | 104 | sha1_one.o: ../../include/openssl/sha.h |
105 | sha1dgst.o: ../../include/openssl/opensslconf.h | 105 | sha1dgst.o: ../../include/openssl/opensslconf.h |
106 | sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h | 106 | sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h |
107 | sha1dgst.o: sha_locl.h | 107 | sha1dgst.o: ../md32_common.h sha_locl.h |
108 | sha_dgst.o: ../../include/openssl/opensslconf.h | 108 | sha_dgst.o: ../../include/openssl/opensslconf.h |
109 | sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h | 109 | sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h |
110 | sha_dgst.o: sha_locl.h | 110 | sha_dgst.o: ../md32_common.h sha_locl.h |
111 | sha_one.o: ../../include/openssl/sha.h | 111 | sha_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 |
11 | PUBLIC _sha1_block_x86 | 11 | PUBLIC _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] | ||
31 | L000start: | 29 | L000start: |
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 |
82 | L001shortcut: | ||
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 |
1661 | PUBLIC _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 |
1664 | END | 1716 | END |
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 | ||
315 | sub sha1_block | 318 | sub 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 | |||
360 | sub 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 @@ | |||
63 | extern "C" { | 63 | extern "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 |
102 | void SHA_Init(SHA_CTX *c); | 102 | void SHA_Init(SHA_CTX *c); |
103 | void SHA_Update(SHA_CTX *c, const unsigned char *data, unsigned long len); | 103 | void SHA_Update(SHA_CTX *c, const void *data, unsigned long len); |
104 | void SHA_Final(unsigned char *md, SHA_CTX *c); | 104 | void SHA_Final(unsigned char *md, SHA_CTX *c); |
105 | unsigned char *SHA(const unsigned char *d, unsigned long n,unsigned char *md); | 105 | unsigned char *SHA(const unsigned char *d, unsigned long n,unsigned char *md); |
106 | void SHA_Transform(SHA_CTX *c, unsigned char *data); | 106 | void SHA_Transform(SHA_CTX *c, const unsigned char *data); |
107 | #endif | 107 | #endif |
108 | #ifndef NO_SHA1 | 108 | #ifndef NO_SHA1 |
109 | void SHA1_Init(SHA_CTX *c); | 109 | void SHA1_Init(SHA_CTX *c); |
110 | void SHA1_Update(SHA_CTX *c, const unsigned char *data, unsigned long len); | 110 | void SHA1_Update(SHA_CTX *c, const void *data, unsigned long len); |
111 | void SHA1_Final(unsigned char *md, SHA_CTX *c); | 111 | void SHA1_Final(unsigned char *md, SHA_CTX *c); |
112 | unsigned char *SHA1(const unsigned char *d, unsigned long n,unsigned char *md); | 112 | unsigned char *SHA1(const unsigned char *d, unsigned long n,unsigned char *md); |
113 | void SHA1_Transform(SHA_CTX *c, unsigned char *data); | 113 | void 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 | ||
68 | char *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 | |||
105 | void 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 | |||
117 | void 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 | |||
274 | void 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 | ||
325 | static 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; | 66 | const 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 | ||
446 | void 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 | ||
37 | extern "C" { | 38 | extern "C" { |
38 | void sha1_block_x86(SHA_CTX *ctx, unsigned char *buffer,int num); | 39 | void 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 | ||
79 | char *test[]={ | 79 | static 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 |
86 | char *ret[]={ | 86 | static char *ret[]={ |
87 | "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", | 87 | "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", |
88 | "d2516ee1acfa5baf33dfc1c471e438449ef134c8", | 88 | "d2516ee1acfa5baf33dfc1c471e438449ef134c8", |
89 | }; | 89 | }; |
90 | char *bigret= | 90 | static char *bigret= |
91 | "3232affa48628a26653b5aaa44541fd90d690603"; | 91 | "3232affa48628a26653b5aaa44541fd90d690603"; |
92 | #endif | 92 | #endif |
93 | #ifdef SHA_1 | 93 | #ifdef SHA_1 |
94 | char *ret[]={ | 94 | static char *ret[]={ |
95 | "a9993e364706816aba3e25717850c26c9cd0d89d", | 95 | "a9993e364706816aba3e25717850c26c9cd0d89d", |
96 | "84983e441c3bd26ebaae4aa1f95129e5e54670f1", | 96 | "84983e441c3bd26ebaae4aa1f95129e5e54670f1", |
97 | }; | 97 | }; |
98 | char *bigret= | 98 | static 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 | ||
68 | char *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 | |||
84 | static 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 | |||
100 | void 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 | ||
112 | void 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 | |||
269 | void 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 | ||
320 | static 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; | 66 | const 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 | ||
441 | void 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 | |||
145 | void 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 | ||
227 | void 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 | ||
352 | void 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 | ||
79 | char *test[]={ | 79 | static 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 |
86 | char *ret[]={ | 86 | static char *ret[]={ |
87 | "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", | 87 | "0164b8a914cd2a5e74c4f7ff082c4d97f1edf880", |
88 | "d2516ee1acfa5baf33dfc1c471e438449ef134c8", | 88 | "d2516ee1acfa5baf33dfc1c471e438449ef134c8", |
89 | }; | 89 | }; |
90 | char *bigret= | 90 | static char *bigret= |
91 | "3232affa48628a26653b5aaa44541fd90d690603"; | 91 | "3232affa48628a26653b5aaa44541fd90d690603"; |
92 | #endif | 92 | #endif |
93 | #ifdef SHA_1 | 93 | #ifdef SHA_1 |
94 | char *ret[]={ | 94 | static char *ret[]={ |
95 | "a9993e364706816aba3e25717850c26c9cd0d89d", | 95 | "a9993e364706816aba3e25717850c26c9cd0d89d", |
96 | "84983e441c3bd26ebaae4aa1f95129e5e54670f1", | 96 | "84983e441c3bd26ebaae4aa1f95129e5e54670f1", |
97 | }; | 97 | }; |
98 | char *bigret= | 98 | static char *bigret= |
99 | "34aa973cd4c4daa4f61eeb2bdbad27316534016f"; | 99 | "34aa973cd4c4daa4f61eeb2bdbad27316534016f"; |
100 | #endif | 100 | #endif |
101 | 101 | ||