1 #include <stdint.h>
2
3 /* Process LEN bytes of BUFFER, accumulating context into CTX.
4 It is assumed that LEN % 128 == 0. */
5 void
__sha512_process_block(const void * buffer,size_t len,struct sha512_ctx * ctx)6 __sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
7 {
8 const uint64_t *words = buffer;
9 size_t nwords = len / sizeof (uint64_t);
10 uint64_t a = ctx->H[0];
11 uint64_t b = ctx->H[1];
12 uint64_t c = ctx->H[2];
13 uint64_t d = ctx->H[3];
14 uint64_t e = ctx->H[4];
15 uint64_t f = ctx->H[5];
16 uint64_t g = ctx->H[6];
17 uint64_t h = ctx->H[7];
18
19 /* First increment the byte count. FIPS 180-2 specifies the possible
20 length of the file up to 2^128 bits. Here we only compute the
21 number of bytes. Do a double word increment. */
22 #ifdef USE_TOTAL128
23 ctx->total128 += len;
24 #else
25 uint64_t lolen = len;
26 ctx->total[TOTAL128_low] += lolen;
27 ctx->total[TOTAL128_high] += ((len >> 31 >> 31 >> 2)
28 + (ctx->total[TOTAL128_low] < lolen));
29 #endif
30
31 /* Process all bytes in the buffer with 128 bytes in each round of
32 the loop. */
33 while (nwords > 0)
34 {
35 uint64_t W[80];
36 uint64_t a_save = a;
37 uint64_t b_save = b;
38 uint64_t c_save = c;
39 uint64_t d_save = d;
40 uint64_t e_save = e;
41 uint64_t f_save = f;
42 uint64_t g_save = g;
43 uint64_t h_save = h;
44
45 /* Operators defined in FIPS 180-2:4.1.2. */
46 #define Ch(x, y, z) ((x & y) ^ (~x & z))
47 #define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
48 #define S0(x) (CYCLIC (x, 28) ^ CYCLIC (x, 34) ^ CYCLIC (x, 39))
49 #define S1(x) (CYCLIC (x, 14) ^ CYCLIC (x, 18) ^ CYCLIC (x, 41))
50 #define R0(x) (CYCLIC (x, 1) ^ CYCLIC (x, 8) ^ (x >> 7))
51 #define R1(x) (CYCLIC (x, 19) ^ CYCLIC (x, 61) ^ (x >> 6))
52
53 /* It is unfortunate that C does not provide an operator for
54 cyclic rotation. Hope the C compiler is smart enough. */
55 #define CYCLIC(w, s) ((w >> s) | (w << (64 - s)))
56
57 /* Compute the message schedule according to FIPS 180-2:6.3.2 step 2. */
58 for (unsigned int t = 0; t < 16; ++t)
59 {
60 W[t] = SWAP (*words);
61 ++words;
62 }
63 for (unsigned int t = 16; t < 80; ++t)
64 W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
65
66 /* The actual computation according to FIPS 180-2:6.3.2 step 3. */
67 for (unsigned int t = 0; t < 80; ++t)
68 {
69 uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
70 uint64_t T2 = S0 (a) + Maj (a, b, c);
71 h = g;
72 g = f;
73 f = e;
74 e = d + T1;
75 d = c;
76 c = b;
77 b = a;
78 a = T1 + T2;
79 }
80
81 /* Add the starting values of the context according to FIPS 180-2:6.3.2
82 step 4. */
83 a += a_save;
84 b += b_save;
85 c += c_save;
86 d += d_save;
87 e += e_save;
88 f += f_save;
89 g += g_save;
90 h += h_save;
91
92 /* Prepare for the next round. */
93 nwords -= 16;
94 }
95
96 /* Put checksum in context given as argument. */
97 ctx->H[0] = a;
98 ctx->H[1] = b;
99 ctx->H[2] = c;
100 ctx->H[3] = d;
101 ctx->H[4] = e;
102 ctx->H[5] = f;
103 ctx->H[6] = g;
104 ctx->H[7] = h;
105 }
106