19e2bc4e406b6f0f9fbdc25d135f5de7074e4180
[jigit.git] / libjte / sha512.c
1 /* Functions to compute SHA512 message digest of files or memory blocks.
2    according to the definition of SHA512 in FIPS 180-2.
3    Copyright (C) 2007 Free Software Foundation, Inc.
4
5    Copied here from the GNU C Library version 2.7 on the 10 May 2009
6    by Steve McIntyre <93sam@debian.org>. This code was under LGPL v2.1
7    in glibc, and that license gives us the option to use and
8    distribute the code under the terms of the GPL v2 instead. I'm
9    taking that option.
10
11    This program is free software; you can redistribute it and/or modify it
12    under the terms of the GNU General Public License as published by the
13    Free Software Foundation; either version 2, or (at your option) any
14    later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software Foundation,
23    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
24
25 /* Written by Ulrich Drepper <drepper@redhat.com>, 2007.  */
26
27 #ifdef HAVE_CONFIG_H
28 #include "../config.h"
29 #endif
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/types.h>
34
35 #include "sha512.h"
36
37 #if __BYTE_ORDER == __LITTLE_ENDIAN
38 # ifdef _LIBC
39 #  include <byteswap.h>
40 #  define SWAP(n) bswap_64 (n)
41 # else
42 #  define SWAP(n) \
43   (((n) << 56)                                  \
44    | (((n) & 0xff00) << 40)                     \
45    | (((n) & 0xff0000) << 24)                   \
46    | (((n) & 0xff000000) << 8)                  \
47    | (((n) >> 8) & 0xff000000)                  \
48    | (((n) >> 24) & 0xff0000)                   \
49    | (((n) >> 40) & 0xff00)                     \
50    | ((n) >> 56))
51 # endif
52 #else
53 # define SWAP(n) (n)
54 #endif
55
56
57 /* This array contains the bytes used to pad the buffer to the next
58    64-byte boundary.  (FIPS 180-2:5.1.2)  */
59 static const unsigned char fillbuf[128] = { 0x80, 0 /* , 0, 0, ...  */ };
60
61
62 /* Constants for SHA512 from FIPS 180-2:4.2.3.  */
63
64 #define LIBJTE_INITIALIZE_32 yes
65
66 #ifdef LIBJTE_INITIALIZE_32 
67
68 static uint64_t K[80];
69 static int K_initialized = 0;
70 /* 64 bit numbers have been split into 32 bit patterns because some compilers
71    have problems with 64 bit constants.
72    The 64 bit array gets composed in the first call of sha512_init_ctx().
73    This is thread safe because any concurrent writes would write the same
74    value to the same address.
75 */
76 static const uint32_t K32[160] =
77   {
78     0x428a2f98 , 0xd728ae22 , 0x71374491 , 0x23ef65cd ,
79     0xb5c0fbcf , 0xec4d3b2f , 0xe9b5dba5 , 0x8189dbbc ,
80     0x3956c25b , 0xf348b538 , 0x59f111f1 , 0xb605d019 ,
81     0x923f82a4 , 0xaf194f9b , 0xab1c5ed5 , 0xda6d8118 ,
82     0xd807aa98 , 0xa3030242 , 0x12835b01 , 0x45706fbe ,
83     0x243185be , 0x4ee4b28c , 0x550c7dc3 , 0xd5ffb4e2 ,
84     0x72be5d74 , 0xf27b896f , 0x80deb1fe , 0x3b1696b1 ,
85     0x9bdc06a7 , 0x25c71235 , 0xc19bf174 , 0xcf692694 ,
86     0xe49b69c1 , 0x9ef14ad2 , 0xefbe4786 , 0x384f25e3 ,
87     0x0fc19dc6 , 0x8b8cd5b5 , 0x240ca1cc , 0x77ac9c65 ,
88     0x2de92c6f , 0x592b0275 , 0x4a7484aa , 0x6ea6e483 ,
89     0x5cb0a9dc , 0xbd41fbd4 , 0x76f988da , 0x831153b5 ,
90     0x983e5152 , 0xee66dfab , 0xa831c66d , 0x2db43210 ,
91     0xb00327c8 , 0x98fb213f , 0xbf597fc7 , 0xbeef0ee4 ,
92     0xc6e00bf3 , 0x3da88fc2 , 0xd5a79147 , 0x930aa725 ,
93     0x06ca6351 , 0xe003826f , 0x14292967 , 0x0a0e6e70 ,
94     0x27b70a85 , 0x46d22ffc , 0x2e1b2138 , 0x5c26c926 ,
95     0x4d2c6dfc , 0x5ac42aed , 0x53380d13 , 0x9d95b3df ,
96     0x650a7354 , 0x8baf63de , 0x766a0abb , 0x3c77b2a8 ,
97     0x81c2c92e , 0x47edaee6 , 0x92722c85 , 0x1482353b ,
98     0xa2bfe8a1 , 0x4cf10364 , 0xa81a664b , 0xbc423001 ,
99     0xc24b8b70 , 0xd0f89791 , 0xc76c51a3 , 0x0654be30 ,
100     0xd192e819 , 0xd6ef5218 , 0xd6990624 , 0x5565a910 ,
101     0xf40e3585 , 0x5771202a , 0x106aa070 , 0x32bbd1b8 ,
102     0x19a4c116 , 0xb8d2d0c8 , 0x1e376c08 , 0x5141ab53 ,
103     0x2748774c , 0xdf8eeb99 , 0x34b0bcb5 , 0xe19b48a8 ,
104     0x391c0cb3 , 0xc5c95a63 , 0x4ed8aa4a , 0xe3418acb ,
105     0x5b9cca4f , 0x7763e373 , 0x682e6ff3 , 0xd6b2b8a3 ,
106     0x748f82ee , 0x5defb2fc , 0x78a5636f , 0x43172f60 ,
107     0x84c87814 , 0xa1f0ab72 , 0x8cc70208 , 0x1a6439ec ,
108     0x90befffa , 0x23631e28 , 0xa4506ceb , 0xde82bde9 ,
109     0xbef9a3f7 , 0xb2c67915 , 0xc67178f2 , 0xe372532b ,
110     0xca273ece , 0xea26619c , 0xd186b8c7 , 0x21c0c207 ,
111     0xeada7dd6 , 0xcde0eb1e , 0xf57d4f7f , 0xee6ed178 ,
112     0x06f067aa , 0x72176fba , 0x0a637dc5 , 0xa2c898a6 ,
113     0x113f9804 , 0xbef90dae , 0x1b710b35 , 0x131c471b ,
114     0x28db77f5 , 0x23047d84 , 0x32caab7b , 0x40c72493 ,
115     0x3c9ebe0a , 0x15c9bebc , 0x431d67c4 , 0x9c100d4c ,
116     0x4cc5d4be , 0xcb3e42b6 , 0x597f299c , 0xfc657e2a ,
117     0x5fcb6fab , 0x3ad6faec , 0x6c44198c , 0x4a475817 
118   };
119
120 #else /* LIBJTE_INITIALIZE_32 */
121
122 static const uint64_t K[80] =
123  {
124     UINT64_C (0x428a2f98d728ae22), UINT64_C (0x7137449123ef65cd),
125     UINT64_C (0xb5c0fbcfec4d3b2f), UINT64_C (0xe9b5dba58189dbbc),
126     UINT64_C (0x3956c25bf348b538), UINT64_C (0x59f111f1b605d019),
127     UINT64_C (0x923f82a4af194f9b), UINT64_C (0xab1c5ed5da6d8118),
128     UINT64_C (0xd807aa98a3030242), UINT64_C (0x12835b0145706fbe),
129     UINT64_C (0x243185be4ee4b28c), UINT64_C (0x550c7dc3d5ffb4e2),
130     UINT64_C (0x72be5d74f27b896f), UINT64_C (0x80deb1fe3b1696b1),
131     UINT64_C (0x9bdc06a725c71235), UINT64_C (0xc19bf174cf692694),
132     UINT64_C (0xe49b69c19ef14ad2), UINT64_C (0xefbe4786384f25e3),
133     UINT64_C (0x0fc19dc68b8cd5b5), UINT64_C (0x240ca1cc77ac9c65),
134     UINT64_C (0x2de92c6f592b0275), UINT64_C (0x4a7484aa6ea6e483),
135     UINT64_C (0x5cb0a9dcbd41fbd4), UINT64_C (0x76f988da831153b5),
136     UINT64_C (0x983e5152ee66dfab), UINT64_C (0xa831c66d2db43210),
137     UINT64_C (0xb00327c898fb213f), UINT64_C (0xbf597fc7beef0ee4),
138     UINT64_C (0xc6e00bf33da88fc2), UINT64_C (0xd5a79147930aa725),
139     UINT64_C (0x06ca6351e003826f), UINT64_C (0x142929670a0e6e70),
140     UINT64_C (0x27b70a8546d22ffc), UINT64_C (0x2e1b21385c26c926),
141     UINT64_C (0x4d2c6dfc5ac42aed), UINT64_C (0x53380d139d95b3df),
142     UINT64_C (0x650a73548baf63de), UINT64_C (0x766a0abb3c77b2a8),
143     UINT64_C (0x81c2c92e47edaee6), UINT64_C (0x92722c851482353b),
144     UINT64_C (0xa2bfe8a14cf10364), UINT64_C (0xa81a664bbc423001),
145     UINT64_C (0xc24b8b70d0f89791), UINT64_C (0xc76c51a30654be30),
146     UINT64_C (0xd192e819d6ef5218), UINT64_C (0xd69906245565a910),
147     UINT64_C (0xf40e35855771202a), UINT64_C (0x106aa07032bbd1b8),
148     UINT64_C (0x19a4c116b8d2d0c8), UINT64_C (0x1e376c085141ab53),
149     UINT64_C (0x2748774cdf8eeb99), UINT64_C (0x34b0bcb5e19b48a8),
150     UINT64_C (0x391c0cb3c5c95a63), UINT64_C (0x4ed8aa4ae3418acb),
151     UINT64_C (0x5b9cca4f7763e373), UINT64_C (0x682e6ff3d6b2b8a3),
152     UINT64_C (0x748f82ee5defb2fc), UINT64_C (0x78a5636f43172f60),
153     UINT64_C (0x84c87814a1f0ab72), UINT64_C (0x8cc702081a6439ec),
154     UINT64_C (0x90befffa23631e28), UINT64_C (0xa4506cebde82bde9),
155     UINT64_C (0xbef9a3f7b2c67915), UINT64_C (0xc67178f2e372532b),
156     UINT64_C (0xca273eceea26619c), UINT64_C (0xd186b8c721c0c207),
157     UINT64_C (0xeada7dd6cde0eb1e), UINT64_C (0xf57d4f7fee6ed178),
158     UINT64_C (0x06f067aa72176fba), UINT64_C (0x0a637dc5a2c898a6),
159     UINT64_C (0x113f9804bef90dae), UINT64_C (0x1b710b35131c471b),
160     UINT64_C (0x28db77f523047d84), UINT64_C (0x32caab7b40c72493),
161     UINT64_C (0x3c9ebe0a15c9bebc), UINT64_C (0x431d67c49c100d4c),
162     UINT64_C (0x4cc5d4becb3e42b6), UINT64_C (0x597f299cfc657e2a),
163     UINT64_C (0x5fcb6fab3ad6faec), UINT64_C (0x6c44198c4a475817)
164   };
165
166 #endif /* ! LIBJTE_INITIALIZE_32 */
167
168
169 /* Process LEN bytes of BUFFER, accumulating context into CTX.
170    It is assumed that LEN % 128 == 0.  */
171 static void
172 sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
173 {
174   const uint64_t *words = buffer;
175   size_t nwords = len / sizeof (uint64_t);
176   uint64_t a = ctx->H[0];
177   uint64_t b = ctx->H[1];
178   uint64_t c = ctx->H[2];
179   uint64_t d = ctx->H[3];
180   uint64_t e = ctx->H[4];
181   uint64_t f = ctx->H[5];
182   uint64_t g = ctx->H[6];
183   uint64_t h = ctx->H[7];
184
185   /* First increment the byte count.  FIPS 180-2 specifies the possible
186      length of the file up to 2^128 bits.  Here we only compute the
187      number of bytes.  Do a double word increment.  */
188   ctx->total[0] += len;
189   if (ctx->total[0] < len)
190     ++ctx->total[1];
191
192   /* Process all bytes in the buffer with 128 bytes in each round of
193      the loop.  */
194   while (nwords > 0)
195     {
196       uint64_t W[80];
197       uint64_t a_save = a;
198       uint64_t b_save = b;
199       uint64_t c_save = c;
200       uint64_t d_save = d;
201       uint64_t e_save = e;
202       uint64_t f_save = f;
203       uint64_t g_save = g;
204       uint64_t h_save = h;
205       unsigned int t;
206
207       /* Operators defined in FIPS 180-2:4.1.2.  */
208 #define Ch(x, y, z) ((x & y) ^ (~x & z))
209 #define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
210 #define S0(x) (CYCLIC (x, 28) ^ CYCLIC (x, 34) ^ CYCLIC (x, 39))
211 #define S1(x) (CYCLIC (x, 14) ^ CYCLIC (x, 18) ^ CYCLIC (x, 41))
212 #define R0(x) (CYCLIC (x, 1) ^ CYCLIC (x, 8) ^ (x >> 7))
213 #define R1(x) (CYCLIC (x, 19) ^ CYCLIC (x, 61) ^ (x >> 6))
214
215       /* It is unfortunate that C does not provide an operator for
216          cyclic rotation.  Hope the C compiler is smart enough.  */
217 #define CYCLIC(w, s) ((w >> s) | (w << (64 - s)))
218
219       /* Compute the message schedule according to FIPS 180-2:6.3.2 step 2.  */
220       for (t = 0; t < 16; ++t)
221         {
222           W[t] = SWAP (*words);
223           ++words;
224         }
225       for (t = 16; t < 80; ++t)
226         W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
227
228       /* The actual computation according to FIPS 180-2:6.3.2 step 3.  */
229       for (t = 0; t < 80; ++t)
230         {
231           uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
232           uint64_t T2 = S0 (a) + Maj (a, b, c);
233           h = g;
234           g = f;
235           f = e;
236           e = d + T1;
237           d = c;
238           c = b;
239           b = a;
240           a = T1 + T2;
241         }
242
243       /* Add the starting values of the context according to FIPS 180-2:6.3.2
244          step 4.  */
245       a += a_save;
246       b += b_save;
247       c += c_save;
248       d += d_save;
249       e += e_save;
250       f += f_save;
251       g += g_save;
252       h += h_save;
253
254       /* Prepare for the next round.  */
255       nwords -= 16;
256     }
257
258   /* Put checksum in context given as argument.  */
259   ctx->H[0] = a;
260   ctx->H[1] = b;
261   ctx->H[2] = c;
262   ctx->H[3] = d;
263   ctx->H[4] = e;
264   ctx->H[5] = f;
265   ctx->H[6] = g;
266   ctx->H[7] = h;
267 }
268
269
270 /* Initialize structure containing state of computation.
271    (FIPS 180-2:5.3.3)  */
272 void
273 sha512_init_ctx (ctx)
274      struct sha512_ctx *ctx;
275 {
276
277 #ifdef LIBJTE_INITIALIZE_32
278
279   if (!K_initialized) {
280       int i;
281
282       for (i = 0; i < 80; i++)
283           K[i] = (((uint64_t) K32[2 * i]) << 32) | K32[2 * i + 1];
284       K_initialized = 1;
285   }
286
287   ctx->H[0] = (((uint64_t) 0x6a09e667) << 32) | 0xf3bcc908;
288   ctx->H[1] = (((uint64_t) 0xbb67ae85) << 32) | 0x84caa73b;
289   ctx->H[2] = (((uint64_t) 0x3c6ef372) << 32) | 0xfe94f82b;
290   ctx->H[3] = (((uint64_t) 0xa54ff53a) << 32) | 0x5f1d36f1;
291   ctx->H[4] = (((uint64_t) 0x510e527f) << 32) | 0xade682d1;
292   ctx->H[5] = (((uint64_t) 0x9b05688c) << 32) | 0x2b3e6c1f;
293   ctx->H[6] = (((uint64_t) 0x1f83d9ab) << 32) | 0xfb41bd6b;
294   ctx->H[7] = (((uint64_t) 0x5be0cd19) << 32) | 0x137e2179;
295
296 #else /* LIBJTE_INITIALIZE_32 */
297
298   ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
299   ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
300   ctx->H[2] = UINT64_C (0x3c6ef372fe94f82b);
301   ctx->H[3] = UINT64_C (0xa54ff53a5f1d36f1);
302   ctx->H[4] = UINT64_C (0x510e527fade682d1);
303   ctx->H[5] = UINT64_C (0x9b05688c2b3e6c1f);
304   ctx->H[6] = UINT64_C (0x1f83d9abfb41bd6b);
305   ctx->H[7] = UINT64_C (0x5be0cd19137e2179);
306
307 #endif /* LIBJTE_INITIALIZE_32 */
308
309   ctx->total[0] = ctx->total[1] = 0;
310   ctx->buflen = 0;
311 }
312
313
314 /* Process the remaining bytes in the internal buffer and the usual
315    prolog according to the standard and write the result to RESBUF.
316
317    IMPORTANT: On some systems it is required that RESBUF is correctly
318    aligned for a 32 bits value.  */
319 void *
320 sha512_finish_ctx (ctx, resbuf)
321      struct sha512_ctx *ctx;
322      void *resbuf;
323 {
324   /* Take yet unprocessed bytes into account.  */
325   uint64_t bytes = ctx->buflen;
326   size_t pad;
327   unsigned int i;
328
329   /* Now count remaining bytes.  */
330   ctx->total[0] += bytes;
331   if (ctx->total[0] < bytes)
332     ++ctx->total[1];
333
334   pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
335   memcpy (&ctx->buffer[bytes], fillbuf, pad);
336
337   /* Put the 128-bit file length in *bits* at the end of the buffer.  */
338   *(uint64_t *) &ctx->buffer[bytes + pad + 8] = SWAP (ctx->total[0] << 3);
339   *(uint64_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) |
340                                                   (ctx->total[0] >> 61));
341
342   /* Process last bytes.  */
343   sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
344
345   /* Put result from CTX in first 64 bytes following RESBUF.  */
346   for (i = 0; i < 8; ++i)
347     ((uint64_t *) resbuf)[i] = SWAP (ctx->H[i]);
348
349   return resbuf;
350 }
351
352
353 void
354 sha512_process_bytes (buffer, len, ctx)
355      const void *buffer;
356      size_t len;
357      struct sha512_ctx *ctx;
358 {
359   /* When we already have some bits in our internal buffer concatenate
360      both inputs first.  */
361   if (ctx->buflen != 0)
362     {
363       size_t left_over = ctx->buflen;
364       size_t add = 256 - left_over > len ? len : 256 - left_over;
365
366       memcpy (&ctx->buffer[left_over], buffer, add);
367       ctx->buflen += add;
368
369       if (ctx->buflen > 128)
370         {
371           sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
372
373           ctx->buflen &= 127;
374           /* The regions in the following copy operation cannot overlap.  */
375           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
376                   ctx->buflen);
377         }
378
379       buffer = (const char *) buffer + add;
380       len -= add;
381     }
382
383   /* Process available complete blocks.  */
384   if (len >= 128)
385     {
386 #if !_STRING_ARCH_unaligned
387 /* To check alignment gcc has an appropriate operator.  Other
388    compilers don't.  */
389 # if __GNUC__ >= 2
390 #  define UNALIGNED_P(p) (((uintptr_t) p) % __alignof__ (uint64_t) != 0)
391 # else
392 #  define UNALIGNED_P(p) (((uintptr_t) p) % sizeof (uint64_t) != 0)
393 # endif
394       if (UNALIGNED_P (buffer))
395         while (len > 128)
396           {
397             sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128,
398                                     ctx);
399             buffer = (const char *) buffer + 128;
400             len -= 128;
401           }
402       else
403 #endif
404         {
405           sha512_process_block (buffer, len & ~127, ctx);
406           buffer = (const char *) buffer + (len & ~127);
407           len &= 127;
408         }
409     }
410
411   /* Move remaining bytes into internal buffer.  */
412   if (len > 0)
413     {
414       size_t left_over = ctx->buflen;
415
416       memcpy (&ctx->buffer[left_over], buffer, len);
417       left_over += len;
418       if (left_over >= 128)
419         {
420           sha512_process_block (ctx->buffer, 128, ctx);
421           left_over -= 128;
422           memcpy (ctx->buffer, &ctx->buffer[128], left_over);
423         }
424       ctx->buflen = left_over;
425     }
426 }