This source file includes following definitions.
- sha512_init_ctx
- sha384_init_ctx
- set_uint64
- sha512_read_ctx
- sha384_read_ctx
- sha512_conclude_ctx
- sha512_finish_ctx
- sha384_finish_ctx
- sha512_buffer
- sha384_buffer
- sha512_process_bytes
- sha512_process_block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 #include <config.h>
24
25
26 #if HAVE_OPENSSL_SHA512
27 # define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
28 #endif
29 #include "sha512.h"
30
31 #include <stdint.h>
32 #include <string.h>
33
34 #include <byteswap.h>
35 #ifdef WORDS_BIGENDIAN
36 # define SWAP(n) (n)
37 #else
38 # define SWAP(n) bswap_64 (n)
39 #endif
40
41 #if ! HAVE_OPENSSL_SHA512
42
43
44
45 static const unsigned char fillbuf[128] = { 0x80, 0 };
46
47
48
49
50
51
52
53 void
54 sha512_init_ctx (struct sha512_ctx *ctx)
55 {
56 ctx->state[0] = u64hilo (0x6a09e667, 0xf3bcc908);
57 ctx->state[1] = u64hilo (0xbb67ae85, 0x84caa73b);
58 ctx->state[2] = u64hilo (0x3c6ef372, 0xfe94f82b);
59 ctx->state[3] = u64hilo (0xa54ff53a, 0x5f1d36f1);
60 ctx->state[4] = u64hilo (0x510e527f, 0xade682d1);
61 ctx->state[5] = u64hilo (0x9b05688c, 0x2b3e6c1f);
62 ctx->state[6] = u64hilo (0x1f83d9ab, 0xfb41bd6b);
63 ctx->state[7] = u64hilo (0x5be0cd19, 0x137e2179);
64
65 ctx->total[0] = ctx->total[1] = u64lo (0);
66 ctx->buflen = 0;
67 }
68
69 void
70 sha384_init_ctx (struct sha512_ctx *ctx)
71 {
72 ctx->state[0] = u64hilo (0xcbbb9d5d, 0xc1059ed8);
73 ctx->state[1] = u64hilo (0x629a292a, 0x367cd507);
74 ctx->state[2] = u64hilo (0x9159015a, 0x3070dd17);
75 ctx->state[3] = u64hilo (0x152fecd8, 0xf70e5939);
76 ctx->state[4] = u64hilo (0x67332667, 0xffc00b31);
77 ctx->state[5] = u64hilo (0x8eb44a87, 0x68581511);
78 ctx->state[6] = u64hilo (0xdb0c2e0d, 0x64f98fa7);
79 ctx->state[7] = u64hilo (0x47b5481d, 0xbefa4fa4);
80
81 ctx->total[0] = ctx->total[1] = u64lo (0);
82 ctx->buflen = 0;
83 }
84
85
86
87
88 static void
89 set_uint64 (char *cp, u64 v)
90 {
91 memcpy (cp, &v, sizeof v);
92 }
93
94
95
96 void *
97 sha512_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
98 {
99 int i;
100 char *r = resbuf;
101
102 for (i = 0; i < 8; i++)
103 set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
104
105 return resbuf;
106 }
107
108 void *
109 sha384_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
110 {
111 int i;
112 char *r = resbuf;
113
114 for (i = 0; i < 6; i++)
115 set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
116
117 return resbuf;
118 }
119
120
121
122 static void
123 sha512_conclude_ctx (struct sha512_ctx *ctx)
124 {
125
126 size_t bytes = ctx->buflen;
127 size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;
128
129
130 ctx->total[0] = u64plus (ctx->total[0], u64lo (bytes));
131 if (u64lt (ctx->total[0], u64lo (bytes)))
132 ctx->total[1] = u64plus (ctx->total[1], u64lo (1));
133
134
135
136
137 set_uint64 ((char *) &ctx->buffer[size - 2],
138 SWAP (u64or (u64shl (ctx->total[1], 3),
139 u64shr (ctx->total[0], 61))));
140 set_uint64 ((char *) &ctx->buffer[size - 1],
141 SWAP (u64shl (ctx->total[0], 3)));
142
143 memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
144
145
146 sha512_process_block (ctx->buffer, size * 8, ctx);
147 }
148
149 void *
150 sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
151 {
152 sha512_conclude_ctx (ctx);
153 return sha512_read_ctx (ctx, resbuf);
154 }
155
156 void *
157 sha384_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
158 {
159 sha512_conclude_ctx (ctx);
160 return sha384_read_ctx (ctx, resbuf);
161 }
162
163
164
165
166
167 void *
168 sha512_buffer (const char *buffer, size_t len, void *resblock)
169 {
170 struct sha512_ctx ctx;
171
172
173 sha512_init_ctx (&ctx);
174
175
176 sha512_process_bytes (buffer, len, &ctx);
177
178
179 return sha512_finish_ctx (&ctx, resblock);
180 }
181
182 void *
183 sha384_buffer (const char *buffer, size_t len, void *resblock)
184 {
185 struct sha512_ctx ctx;
186
187
188 sha384_init_ctx (&ctx);
189
190
191 sha512_process_bytes (buffer, len, &ctx);
192
193
194 return sha384_finish_ctx (&ctx, resblock);
195 }
196
197 void
198 sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
199 {
200
201
202 if (ctx->buflen != 0)
203 {
204 size_t left_over = ctx->buflen;
205 size_t add = 256 - left_over > len ? len : 256 - left_over;
206
207 memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
208 ctx->buflen += add;
209
210 if (ctx->buflen > 128)
211 {
212 sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
213
214 ctx->buflen &= 127;
215
216
217 memcpy (ctx->buffer,
218 &((char *) ctx->buffer)[(left_over + add) & ~127],
219 ctx->buflen);
220 }
221
222 buffer = (const char *) buffer + add;
223 len -= add;
224 }
225
226
227 if (len >= 128)
228 {
229 #if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
230 # define UNALIGNED_P(p) ((uintptr_t) (p) % alignof (u64) != 0)
231 if (UNALIGNED_P (buffer))
232 while (len > 128)
233 {
234 sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128, ctx);
235 buffer = (const char *) buffer + 128;
236 len -= 128;
237 }
238 else
239 #endif
240 {
241 sha512_process_block (buffer, len & ~127, ctx);
242 buffer = (const char *) buffer + (len & ~127);
243 len &= 127;
244 }
245 }
246
247
248 if (len > 0)
249 {
250 size_t left_over = ctx->buflen;
251
252 memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
253 left_over += len;
254 if (left_over >= 128)
255 {
256 sha512_process_block (ctx->buffer, 128, ctx);
257 left_over -= 128;
258
259
260 memcpy (ctx->buffer, &ctx->buffer[16], left_over);
261 }
262 ctx->buflen = left_over;
263 }
264 }
265
266
267
268
269 #define K(I) sha512_round_constants[I]
270 static u64 const sha512_round_constants[80] = {
271 u64init (0x428a2f98, 0xd728ae22), u64init (0x71374491, 0x23ef65cd),
272 u64init (0xb5c0fbcf, 0xec4d3b2f), u64init (0xe9b5dba5, 0x8189dbbc),
273 u64init (0x3956c25b, 0xf348b538), u64init (0x59f111f1, 0xb605d019),
274 u64init (0x923f82a4, 0xaf194f9b), u64init (0xab1c5ed5, 0xda6d8118),
275 u64init (0xd807aa98, 0xa3030242), u64init (0x12835b01, 0x45706fbe),
276 u64init (0x243185be, 0x4ee4b28c), u64init (0x550c7dc3, 0xd5ffb4e2),
277 u64init (0x72be5d74, 0xf27b896f), u64init (0x80deb1fe, 0x3b1696b1),
278 u64init (0x9bdc06a7, 0x25c71235), u64init (0xc19bf174, 0xcf692694),
279 u64init (0xe49b69c1, 0x9ef14ad2), u64init (0xefbe4786, 0x384f25e3),
280 u64init (0x0fc19dc6, 0x8b8cd5b5), u64init (0x240ca1cc, 0x77ac9c65),
281 u64init (0x2de92c6f, 0x592b0275), u64init (0x4a7484aa, 0x6ea6e483),
282 u64init (0x5cb0a9dc, 0xbd41fbd4), u64init (0x76f988da, 0x831153b5),
283 u64init (0x983e5152, 0xee66dfab), u64init (0xa831c66d, 0x2db43210),
284 u64init (0xb00327c8, 0x98fb213f), u64init (0xbf597fc7, 0xbeef0ee4),
285 u64init (0xc6e00bf3, 0x3da88fc2), u64init (0xd5a79147, 0x930aa725),
286 u64init (0x06ca6351, 0xe003826f), u64init (0x14292967, 0x0a0e6e70),
287 u64init (0x27b70a85, 0x46d22ffc), u64init (0x2e1b2138, 0x5c26c926),
288 u64init (0x4d2c6dfc, 0x5ac42aed), u64init (0x53380d13, 0x9d95b3df),
289 u64init (0x650a7354, 0x8baf63de), u64init (0x766a0abb, 0x3c77b2a8),
290 u64init (0x81c2c92e, 0x47edaee6), u64init (0x92722c85, 0x1482353b),
291 u64init (0xa2bfe8a1, 0x4cf10364), u64init (0xa81a664b, 0xbc423001),
292 u64init (0xc24b8b70, 0xd0f89791), u64init (0xc76c51a3, 0x0654be30),
293 u64init (0xd192e819, 0xd6ef5218), u64init (0xd6990624, 0x5565a910),
294 u64init (0xf40e3585, 0x5771202a), u64init (0x106aa070, 0x32bbd1b8),
295 u64init (0x19a4c116, 0xb8d2d0c8), u64init (0x1e376c08, 0x5141ab53),
296 u64init (0x2748774c, 0xdf8eeb99), u64init (0x34b0bcb5, 0xe19b48a8),
297 u64init (0x391c0cb3, 0xc5c95a63), u64init (0x4ed8aa4a, 0xe3418acb),
298 u64init (0x5b9cca4f, 0x7763e373), u64init (0x682e6ff3, 0xd6b2b8a3),
299 u64init (0x748f82ee, 0x5defb2fc), u64init (0x78a5636f, 0x43172f60),
300 u64init (0x84c87814, 0xa1f0ab72), u64init (0x8cc70208, 0x1a6439ec),
301 u64init (0x90befffa, 0x23631e28), u64init (0xa4506ceb, 0xde82bde9),
302 u64init (0xbef9a3f7, 0xb2c67915), u64init (0xc67178f2, 0xe372532b),
303 u64init (0xca273ece, 0xea26619c), u64init (0xd186b8c7, 0x21c0c207),
304 u64init (0xeada7dd6, 0xcde0eb1e), u64init (0xf57d4f7f, 0xee6ed178),
305 u64init (0x06f067aa, 0x72176fba), u64init (0x0a637dc5, 0xa2c898a6),
306 u64init (0x113f9804, 0xbef90dae), u64init (0x1b710b35, 0x131c471b),
307 u64init (0x28db77f5, 0x23047d84), u64init (0x32caab7b, 0x40c72493),
308 u64init (0x3c9ebe0a, 0x15c9bebc), u64init (0x431d67c4, 0x9c100d4c),
309 u64init (0x4cc5d4be, 0xcb3e42b6), u64init (0x597f299c, 0xfc657e2a),
310 u64init (0x5fcb6fab, 0x3ad6faec), u64init (0x6c44198c, 0x4a475817),
311 };
312
313
314 #define F2(A, B, C) u64or (u64and (A, B), u64and (C, u64or (A, B)))
315 #define F1(E, F, G) u64xor (G, u64and (E, u64xor (F, G)))
316
317
318
319
320
321 void
322 sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
323 {
324 u64 const *words = buffer;
325 u64 const *endp = words + len / sizeof (u64);
326 u64 x[16];
327 u64 a = ctx->state[0];
328 u64 b = ctx->state[1];
329 u64 c = ctx->state[2];
330 u64 d = ctx->state[3];
331 u64 e = ctx->state[4];
332 u64 f = ctx->state[5];
333 u64 g = ctx->state[6];
334 u64 h = ctx->state[7];
335 u64 lolen = u64size (len);
336
337
338
339
340 ctx->total[0] = u64plus (ctx->total[0], lolen);
341 ctx->total[1] = u64plus (ctx->total[1],
342 u64plus (u64size (len >> 31 >> 31 >> 2),
343 u64lo (u64lt (ctx->total[0], lolen))));
344
345 #define S0(x) u64xor (u64rol(x, 63), u64xor (u64rol (x, 56), u64shr (x, 7)))
346 #define S1(x) u64xor (u64rol (x, 45), u64xor (u64rol (x, 3), u64shr (x, 6)))
347 #define SS0(x) u64xor (u64rol (x, 36), u64xor (u64rol (x, 30), u64rol (x, 25)))
348 #define SS1(x) u64xor (u64rol(x, 50), u64xor (u64rol (x, 46), u64rol (x, 23)))
349
350 #define M(I) (x[(I) & 15] \
351 = u64plus (x[(I) & 15], \
352 u64plus (S1 (x[((I) - 2) & 15]), \
353 u64plus (x[((I) - 7) & 15], \
354 S0 (x[((I) - 15) & 15])))))
355
356 #define R(A, B, C, D, E, F, G, H, K, M) \
357 do \
358 { \
359 u64 t0 = u64plus (SS0 (A), F2 (A, B, C)); \
360 u64 t1 = \
361 u64plus (H, u64plus (SS1 (E), \
362 u64plus (F1 (E, F, G), u64plus (K, M)))); \
363 D = u64plus (D, t1); \
364 H = u64plus (t0, t1); \
365 } \
366 while (0)
367
368 while (words < endp)
369 {
370 int t;
371
372 for (t = 0; t < 16; t++)
373 {
374 x[t] = SWAP (*words);
375 words++;
376 }
377
378 R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
379 R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );
380 R( g, h, a, b, c, d, e, f, K( 2), x[ 2] );
381 R( f, g, h, a, b, c, d, e, K( 3), x[ 3] );
382 R( e, f, g, h, a, b, c, d, K( 4), x[ 4] );
383 R( d, e, f, g, h, a, b, c, K( 5), x[ 5] );
384 R( c, d, e, f, g, h, a, b, K( 6), x[ 6] );
385 R( b, c, d, e, f, g, h, a, K( 7), x[ 7] );
386 R( a, b, c, d, e, f, g, h, K( 8), x[ 8] );
387 R( h, a, b, c, d, e, f, g, K( 9), x[ 9] );
388 R( g, h, a, b, c, d, e, f, K(10), x[10] );
389 R( f, g, h, a, b, c, d, e, K(11), x[11] );
390 R( e, f, g, h, a, b, c, d, K(12), x[12] );
391 R( d, e, f, g, h, a, b, c, K(13), x[13] );
392 R( c, d, e, f, g, h, a, b, K(14), x[14] );
393 R( b, c, d, e, f, g, h, a, K(15), x[15] );
394 R( a, b, c, d, e, f, g, h, K(16), M(16) );
395 R( h, a, b, c, d, e, f, g, K(17), M(17) );
396 R( g, h, a, b, c, d, e, f, K(18), M(18) );
397 R( f, g, h, a, b, c, d, e, K(19), M(19) );
398 R( e, f, g, h, a, b, c, d, K(20), M(20) );
399 R( d, e, f, g, h, a, b, c, K(21), M(21) );
400 R( c, d, e, f, g, h, a, b, K(22), M(22) );
401 R( b, c, d, e, f, g, h, a, K(23), M(23) );
402 R( a, b, c, d, e, f, g, h, K(24), M(24) );
403 R( h, a, b, c, d, e, f, g, K(25), M(25) );
404 R( g, h, a, b, c, d, e, f, K(26), M(26) );
405 R( f, g, h, a, b, c, d, e, K(27), M(27) );
406 R( e, f, g, h, a, b, c, d, K(28), M(28) );
407 R( d, e, f, g, h, a, b, c, K(29), M(29) );
408 R( c, d, e, f, g, h, a, b, K(30), M(30) );
409 R( b, c, d, e, f, g, h, a, K(31), M(31) );
410 R( a, b, c, d, e, f, g, h, K(32), M(32) );
411 R( h, a, b, c, d, e, f, g, K(33), M(33) );
412 R( g, h, a, b, c, d, e, f, K(34), M(34) );
413 R( f, g, h, a, b, c, d, e, K(35), M(35) );
414 R( e, f, g, h, a, b, c, d, K(36), M(36) );
415 R( d, e, f, g, h, a, b, c, K(37), M(37) );
416 R( c, d, e, f, g, h, a, b, K(38), M(38) );
417 R( b, c, d, e, f, g, h, a, K(39), M(39) );
418 R( a, b, c, d, e, f, g, h, K(40), M(40) );
419 R( h, a, b, c, d, e, f, g, K(41), M(41) );
420 R( g, h, a, b, c, d, e, f, K(42), M(42) );
421 R( f, g, h, a, b, c, d, e, K(43), M(43) );
422 R( e, f, g, h, a, b, c, d, K(44), M(44) );
423 R( d, e, f, g, h, a, b, c, K(45), M(45) );
424 R( c, d, e, f, g, h, a, b, K(46), M(46) );
425 R( b, c, d, e, f, g, h, a, K(47), M(47) );
426 R( a, b, c, d, e, f, g, h, K(48), M(48) );
427 R( h, a, b, c, d, e, f, g, K(49), M(49) );
428 R( g, h, a, b, c, d, e, f, K(50), M(50) );
429 R( f, g, h, a, b, c, d, e, K(51), M(51) );
430 R( e, f, g, h, a, b, c, d, K(52), M(52) );
431 R( d, e, f, g, h, a, b, c, K(53), M(53) );
432 R( c, d, e, f, g, h, a, b, K(54), M(54) );
433 R( b, c, d, e, f, g, h, a, K(55), M(55) );
434 R( a, b, c, d, e, f, g, h, K(56), M(56) );
435 R( h, a, b, c, d, e, f, g, K(57), M(57) );
436 R( g, h, a, b, c, d, e, f, K(58), M(58) );
437 R( f, g, h, a, b, c, d, e, K(59), M(59) );
438 R( e, f, g, h, a, b, c, d, K(60), M(60) );
439 R( d, e, f, g, h, a, b, c, K(61), M(61) );
440 R( c, d, e, f, g, h, a, b, K(62), M(62) );
441 R( b, c, d, e, f, g, h, a, K(63), M(63) );
442 R( a, b, c, d, e, f, g, h, K(64), M(64) );
443 R( h, a, b, c, d, e, f, g, K(65), M(65) );
444 R( g, h, a, b, c, d, e, f, K(66), M(66) );
445 R( f, g, h, a, b, c, d, e, K(67), M(67) );
446 R( e, f, g, h, a, b, c, d, K(68), M(68) );
447 R( d, e, f, g, h, a, b, c, K(69), M(69) );
448 R( c, d, e, f, g, h, a, b, K(70), M(70) );
449 R( b, c, d, e, f, g, h, a, K(71), M(71) );
450 R( a, b, c, d, e, f, g, h, K(72), M(72) );
451 R( h, a, b, c, d, e, f, g, K(73), M(73) );
452 R( g, h, a, b, c, d, e, f, K(74), M(74) );
453 R( f, g, h, a, b, c, d, e, K(75), M(75) );
454 R( e, f, g, h, a, b, c, d, K(76), M(76) );
455 R( d, e, f, g, h, a, b, c, K(77), M(77) );
456 R( c, d, e, f, g, h, a, b, K(78), M(78) );
457 R( b, c, d, e, f, g, h, a, K(79), M(79) );
458
459 a = ctx->state[0] = u64plus (ctx->state[0], a);
460 b = ctx->state[1] = u64plus (ctx->state[1], b);
461 c = ctx->state[2] = u64plus (ctx->state[2], c);
462 d = ctx->state[3] = u64plus (ctx->state[3], d);
463 e = ctx->state[4] = u64plus (ctx->state[4], e);
464 f = ctx->state[5] = u64plus (ctx->state[5], f);
465 g = ctx->state[6] = u64plus (ctx->state[6], g);
466 h = ctx->state[7] = u64plus (ctx->state[7], h);
467 }
468 }
469
470 #endif
471
472
473
474
475
476
477