Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan | |
3 | * (Royal Institute of Technology, Stockholm, Sweden). | |
4 | * All rights reserved. | |
5 | * | |
6 | * Redistribution and use in source and binary forms, with or without | |
7 | * modification, are permitted provided that the following conditions | |
8 | * are met: | |
9 | * | |
10 | * 1. Redistributions of source code must retain the above copyright | |
11 | * notice, this list of conditions and the following disclaimer. | |
12 | * | |
13 | * 2. Redistributions in binary form must reproduce the above copyright | |
14 | * notice, this list of conditions and the following disclaimer in the | |
15 | * documentation and/or other materials provided with the distribution. | |
16 | * | |
17 | * 3. Neither the name of the Institute nor the names of its contributors | |
18 | * may be used to endorse or promote products derived from this software | |
19 | * without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE | |
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
31 | * SUCH DAMAGE. | |
32 | */ | |
33 | ||
34 | #include "config.h" | |
35 | ||
36 | #include "hash.h" | |
37 | #include "sha.h" | |
38 | ||
39 | #define A m->counter[0] | |
40 | #define B m->counter[1] | |
41 | #define C m->counter[2] | |
42 | #define D m->counter[3] | |
43 | #define E m->counter[4] | |
44 | #define X data | |
45 | ||
46 | void | |
47 | SHA1_Init (struct sha *m) | |
48 | { | |
49 | m->sz[0] = 0; | |
50 | m->sz[1] = 0; | |
51 | A = 0x67452301; | |
52 | B = 0xefcdab89; | |
53 | C = 0x98badcfe; | |
54 | D = 0x10325476; | |
55 | E = 0xc3d2e1f0; | |
56 | } | |
57 | ||
58 | ||
59 | #define F0(x,y,z) CRAYFIX((x & y) | (~x & z)) | |
60 | #define F1(x,y,z) (x ^ y ^ z) | |
61 | #define F2(x,y,z) ((x & y) | (x & z) | (y & z)) | |
62 | #define F3(x,y,z) F1(x,y,z) | |
63 | ||
64 | #define K0 0x5a827999 | |
65 | #define K1 0x6ed9eba1 | |
66 | #define K2 0x8f1bbcdc | |
67 | #define K3 0xca62c1d6 | |
68 | ||
69 | #define DO(t,f,k) \ | |
70 | do { \ | |
71 | uint32_t temp; \ | |
72 | \ | |
73 | temp = cshift(AA, 5) + f(BB,CC,DD) + EE + data[t] + k; \ | |
74 | EE = DD; \ | |
75 | DD = CC; \ | |
76 | CC = cshift(BB, 30); \ | |
77 | BB = AA; \ | |
78 | AA = temp; \ | |
79 | } while(0) | |
80 | ||
81 | static inline void | |
82 | calc (struct sha *m, uint32_t *in) | |
83 | { | |
84 | uint32_t AA, BB, CC, DD, EE; | |
85 | uint32_t data[80]; | |
86 | int i; | |
87 | ||
88 | AA = A; | |
89 | BB = B; | |
90 | CC = C; | |
91 | DD = D; | |
92 | EE = E; | |
93 | ||
94 | for (i = 0; i < 16; ++i) | |
95 | data[i] = in[i]; | |
96 | for (i = 16; i < 80; ++i) | |
97 | data[i] = cshift(data[i-3] ^ data[i-8] ^ data[i-14] ^ data[i-16], 1); | |
98 | ||
99 | /* t=[0,19] */ | |
100 | ||
101 | DO(0,F0,K0); | |
102 | DO(1,F0,K0); | |
103 | DO(2,F0,K0); | |
104 | DO(3,F0,K0); | |
105 | DO(4,F0,K0); | |
106 | DO(5,F0,K0); | |
107 | DO(6,F0,K0); | |
108 | DO(7,F0,K0); | |
109 | DO(8,F0,K0); | |
110 | DO(9,F0,K0); | |
111 | DO(10,F0,K0); | |
112 | DO(11,F0,K0); | |
113 | DO(12,F0,K0); | |
114 | DO(13,F0,K0); | |
115 | DO(14,F0,K0); | |
116 | DO(15,F0,K0); | |
117 | DO(16,F0,K0); | |
118 | DO(17,F0,K0); | |
119 | DO(18,F0,K0); | |
120 | DO(19,F0,K0); | |
121 | ||
122 | /* t=[20,39] */ | |
123 | ||
124 | DO(20,F1,K1); | |
125 | DO(21,F1,K1); | |
126 | DO(22,F1,K1); | |
127 | DO(23,F1,K1); | |
128 | DO(24,F1,K1); | |
129 | DO(25,F1,K1); | |
130 | DO(26,F1,K1); | |
131 | DO(27,F1,K1); | |
132 | DO(28,F1,K1); | |
133 | DO(29,F1,K1); | |
134 | DO(30,F1,K1); | |
135 | DO(31,F1,K1); | |
136 | DO(32,F1,K1); | |
137 | DO(33,F1,K1); | |
138 | DO(34,F1,K1); | |
139 | DO(35,F1,K1); | |
140 | DO(36,F1,K1); | |
141 | DO(37,F1,K1); | |
142 | DO(38,F1,K1); | |
143 | DO(39,F1,K1); | |
144 | ||
145 | /* t=[40,59] */ | |
146 | ||
147 | DO(40,F2,K2); | |
148 | DO(41,F2,K2); | |
149 | DO(42,F2,K2); | |
150 | DO(43,F2,K2); | |
151 | DO(44,F2,K2); | |
152 | DO(45,F2,K2); | |
153 | DO(46,F2,K2); | |
154 | DO(47,F2,K2); | |
155 | DO(48,F2,K2); | |
156 | DO(49,F2,K2); | |
157 | DO(50,F2,K2); | |
158 | DO(51,F2,K2); | |
159 | DO(52,F2,K2); | |
160 | DO(53,F2,K2); | |
161 | DO(54,F2,K2); | |
162 | DO(55,F2,K2); | |
163 | DO(56,F2,K2); | |
164 | DO(57,F2,K2); | |
165 | DO(58,F2,K2); | |
166 | DO(59,F2,K2); | |
167 | ||
168 | /* t=[60,79] */ | |
169 | ||
170 | DO(60,F3,K3); | |
171 | DO(61,F3,K3); | |
172 | DO(62,F3,K3); | |
173 | DO(63,F3,K3); | |
174 | DO(64,F3,K3); | |
175 | DO(65,F3,K3); | |
176 | DO(66,F3,K3); | |
177 | DO(67,F3,K3); | |
178 | DO(68,F3,K3); | |
179 | DO(69,F3,K3); | |
180 | DO(70,F3,K3); | |
181 | DO(71,F3,K3); | |
182 | DO(72,F3,K3); | |
183 | DO(73,F3,K3); | |
184 | DO(74,F3,K3); | |
185 | DO(75,F3,K3); | |
186 | DO(76,F3,K3); | |
187 | DO(77,F3,K3); | |
188 | DO(78,F3,K3); | |
189 | DO(79,F3,K3); | |
190 | ||
191 | A += AA; | |
192 | B += BB; | |
193 | C += CC; | |
194 | D += DD; | |
195 | E += EE; | |
196 | } | |
197 | ||
198 | /* | |
199 | * From `Performance analysis of MD5' by Joseph D. Touch <touch@isi.edu> | |
200 | */ | |
201 | ||
202 | #if !defined(WORDS_BIGENDIAN) || defined(_CRAY) | |
203 | static inline uint32_t | |
204 | swap_uint32_t (uint32_t t) | |
205 | { | |
206 | #define ROL(x,n) ((x)<<(n))|((x)>>(32-(n))) | |
207 | uint32_t temp1, temp2; | |
208 | ||
209 | temp1 = cshift(t, 16); | |
210 | temp2 = temp1 >> 8; | |
211 | temp1 &= 0x00ff00ff; | |
212 | temp2 &= 0x00ff00ff; | |
213 | temp1 <<= 8; | |
214 | return temp1 | temp2; | |
215 | } | |
216 | #endif | |
217 | ||
218 | struct x32{ | |
219 | unsigned int a:32; | |
220 | unsigned int b:32; | |
221 | }; | |
222 | ||
223 | void | |
224 | SHA1_Update (struct sha *m, const void *v, size_t len) | |
225 | { | |
226 | const unsigned char *p = v; | |
227 | size_t old_sz = m->sz[0]; | |
228 | size_t offset; | |
229 | ||
230 | m->sz[0] += len * 8; | |
231 | if (m->sz[0] < old_sz) | |
232 | ++m->sz[1]; | |
233 | offset = (old_sz / 8) % 64; | |
234 | while(len > 0){ | |
235 | size_t l = min(len, 64 - offset); | |
236 | memcpy(m->save + offset, p, l); | |
237 | offset += l; | |
238 | p += l; | |
239 | len -= l; | |
240 | if(offset == 64){ | |
241 | #if !defined(WORDS_BIGENDIAN) || defined(_CRAY) | |
242 | int i; | |
243 | uint32_t SHA1current[16]; | |
244 | struct x32 *us = (struct x32*)m->save; | |
245 | for(i = 0; i < 8; i++){ | |
246 | SHA1current[2*i+0] = swap_uint32_t(us[i].a); | |
247 | SHA1current[2*i+1] = swap_uint32_t(us[i].b); | |
248 | } | |
249 | calc(m, SHA1current); | |
250 | #else | |
251 | calc(m, (uint32_t*)m->save); | |
252 | #endif | |
253 | offset = 0; | |
254 | } | |
255 | } | |
256 | } | |
257 | ||
258 | void | |
259 | SHA1_Final (void *res, struct sha *m) | |
260 | { | |
261 | unsigned char zeros[72]; | |
262 | unsigned offset = (m->sz[0] / 8) % 64; | |
263 | unsigned int dstart = (120 - offset - 1) % 64 + 1; | |
264 | ||
265 | *zeros = 0x80; | |
266 | memset (zeros + 1, 0, sizeof(zeros) - 1); | |
267 | zeros[dstart+7] = (m->sz[0] >> 0) & 0xff; | |
268 | zeros[dstart+6] = (m->sz[0] >> 8) & 0xff; | |
269 | zeros[dstart+5] = (m->sz[0] >> 16) & 0xff; | |
270 | zeros[dstart+4] = (m->sz[0] >> 24) & 0xff; | |
271 | zeros[dstart+3] = (m->sz[1] >> 0) & 0xff; | |
272 | zeros[dstart+2] = (m->sz[1] >> 8) & 0xff; | |
273 | zeros[dstart+1] = (m->sz[1] >> 16) & 0xff; | |
274 | zeros[dstart+0] = (m->sz[1] >> 24) & 0xff; | |
275 | SHA1_Update (m, zeros, dstart + 8); | |
276 | { | |
277 | int i; | |
278 | unsigned char *r = (unsigned char*)res; | |
279 | ||
280 | for (i = 0; i < 5; ++i) { | |
281 | r[4*i+3] = m->counter[i] & 0xFF; | |
282 | r[4*i+2] = (m->counter[i] >> 8) & 0xFF; | |
283 | r[4*i+1] = (m->counter[i] >> 16) & 0xFF; | |
284 | r[4*i] = (m->counter[i] >> 24) & 0xFF; | |
285 | } | |
286 | } | |
287 | #if 0 | |
288 | { | |
289 | int i; | |
290 | uint32_t *r = (uint32_t *)res; | |
291 | ||
292 | for (i = 0; i < 5; ++i) | |
293 | r[i] = swap_uint32_t (m->counter[i]); | |
294 | } | |
295 | #endif | |
296 | } |