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