chiark / gitweb /
netlink: Set "unused" in ICMP header (SECURITY)
[secnet.git] / sha512.c
1 /* sha512.c - Functions to compute SHA512 and SHA384 message digest of files or
2    memory blocks according to the NIST specification FIPS-180-2.
3
4    Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6    This program is free software: you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation, either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19 /* Written by David Madore, considerably copypasting from
20    Scott G. Miller's sha1.c
21 */
22
23 #include <config.h>
24
25 #include "sha512.h"
26
27 #include <stddef.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #if USE_UNLOCKED_IO
32 # include "unlocked-io.h"
33 #endif
34
35 #ifdef WORDS_BIGENDIAN
36 # define SWAP(n) (n)
37 #else
38 # define SWAP(n) \
39     u64or (u64or (u64or (u64shl (n, 56),                                \
40                          u64shl (u64and (n, u64lo (0x0000ff00)), 40)),  \
41                   u64or (u64shl (u64and (n, u64lo (0x00ff0000)), 24),   \
42                          u64shl (u64and (n, u64lo (0xff000000)),  8))), \
43            u64or (u64or (u64and (u64shr (n,  8), u64lo (0xff000000)),   \
44                          u64and (u64shr (n, 24), u64lo (0x00ff0000))),  \
45                   u64or (u64and (u64shr (n, 40), u64lo (0x0000ff00)),   \
46                          u64shr (n, 56))))
47 #endif
48
49 #define BLOCKSIZE 32768
50 #if BLOCKSIZE % 128 != 0
51 # error "invalid BLOCKSIZE"
52 #endif
53
54 /* This array contains the bytes used to pad the buffer to the next
55    128-byte boundary.  */
56 static const unsigned char fillbuf[128] = { 0x80, 0 /* , 0, 0, ...  */ };
57
58
59 /*
60   Takes a pointer to a 512 bit block of data (eight 64 bit ints) and
61   intializes it to the start constants of the SHA512 algorithm.  This
62   must be called before using hash in the call to sha512_hash
63 */
64 void
65 sha512_init_ctx (struct sha512_ctx *ctx)
66 {
67   ctx->state[0] = u64hilo (0x6a09e667, 0xf3bcc908);
68   ctx->state[1] = u64hilo (0xbb67ae85, 0x84caa73b);
69   ctx->state[2] = u64hilo (0x3c6ef372, 0xfe94f82b);
70   ctx->state[3] = u64hilo (0xa54ff53a, 0x5f1d36f1);
71   ctx->state[4] = u64hilo (0x510e527f, 0xade682d1);
72   ctx->state[5] = u64hilo (0x9b05688c, 0x2b3e6c1f);
73   ctx->state[6] = u64hilo (0x1f83d9ab, 0xfb41bd6b);
74   ctx->state[7] = u64hilo (0x5be0cd19, 0x137e2179);
75
76   ctx->total[0] = ctx->total[1] = u64lo (0);
77   ctx->buflen = 0;
78 }
79
80 void
81 sha384_init_ctx (struct sha512_ctx *ctx)
82 {
83   ctx->state[0] = u64hilo (0xcbbb9d5d, 0xc1059ed8);
84   ctx->state[1] = u64hilo (0x629a292a, 0x367cd507);
85   ctx->state[2] = u64hilo (0x9159015a, 0x3070dd17);
86   ctx->state[3] = u64hilo (0x152fecd8, 0xf70e5939);
87   ctx->state[4] = u64hilo (0x67332667, 0xffc00b31);
88   ctx->state[5] = u64hilo (0x8eb44a87, 0x68581511);
89   ctx->state[6] = u64hilo (0xdb0c2e0d, 0x64f98fa7);
90   ctx->state[7] = u64hilo (0x47b5481d, 0xbefa4fa4);
91
92   ctx->total[0] = ctx->total[1] = u64lo (0);
93   ctx->buflen = 0;
94 }
95
96 /* Copy the value from V into the memory location pointed to by *CP,
97    If your architecture allows unaligned access, this is equivalent to
98    * (__typeof__ (v) *) cp = v  */
99 static inline void
100 set_uint64 (char *cp, u64 v)
101 {
102   memcpy (cp, &v, sizeof v);
103 }
104
105 /* Put result from CTX in first 64 bytes following RESBUF.
106    The result must be in little endian byte order.  */
107 void *
108 sha512_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
109 {
110   int i;
111   char *r = resbuf;
112
113   for (i = 0; i < 8; i++)
114     set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
115
116   return resbuf;
117 }
118
119 void *
120 sha384_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
121 {
122   int i;
123   char *r = resbuf;
124
125   for (i = 0; i < 6; i++)
126     set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
127
128   return resbuf;
129 }
130
131 /* Process the remaining bytes in the internal buffer and the usual
132    prolog according to the standard and write the result to RESBUF.  */
133 static void
134 sha512_conclude_ctx (struct sha512_ctx *ctx)
135 {
136   /* Take yet unprocessed bytes into account.  */
137   size_t bytes = ctx->buflen;
138   size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;
139
140   /* Now count remaining bytes.  */
141   ctx->total[0] = u64plus (ctx->total[0], u64lo (bytes));
142   if (u64lt (ctx->total[0], u64lo (bytes)))
143     ctx->total[1] = u64plus (ctx->total[1], u64lo (1));
144
145   /* Put the 128-bit file length in *bits* at the end of the buffer.
146      Use set_uint64 rather than a simple assignment, to avoid risk of
147      unaligned access.  */
148   set_uint64 ((char *) &ctx->buffer[size - 2],
149               SWAP (u64or (u64shl (ctx->total[1], 3),
150                            u64shr (ctx->total[0], 61))));
151   set_uint64 ((char *) &ctx->buffer[size - 1],
152               SWAP (u64shl (ctx->total[0], 3)));
153
154   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
155
156   /* Process last bytes.  */
157   sha512_process_block (ctx->buffer, size * 8, ctx);
158 }
159
160 void *
161 sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
162 {
163   sha512_conclude_ctx (ctx);
164   return sha512_read_ctx (ctx, resbuf);
165 }
166
167 void *
168 sha384_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
169 {
170   sha512_conclude_ctx (ctx);
171   return sha384_read_ctx (ctx, resbuf);
172 }
173
174 /* Compute SHA512 message digest for bytes read from STREAM.  The
175    resulting message digest number will be written into the 64 bytes
176    beginning at RESBLOCK.  */
177 int
178 sha512_stream (FILE *stream, void *resblock)
179 {
180   struct sha512_ctx ctx;
181   size_t sum;
182
183   char *buffer = malloc (BLOCKSIZE + 72);
184   if (!buffer)
185     return 1;
186
187   /* Initialize the computation context.  */
188   sha512_init_ctx (&ctx);
189
190   /* Iterate over full file contents.  */
191   while (1)
192     {
193       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
194          computation function processes the whole buffer so that with the
195          next round of the loop another block can be read.  */
196       size_t n;
197       sum = 0;
198
199       /* Read block.  Take care for partial reads.  */
200       while (1)
201         {
202           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
203
204           sum += n;
205
206           if (sum == BLOCKSIZE)
207             break;
208
209           if (n == 0)
210             {
211               /* Check for the error flag IFF N == 0, so that we don't
212                  exit the loop after a partial read due to e.g., EAGAIN
213                  or EWOULDBLOCK.  */
214               if (ferror (stream))
215                 {
216                   free (buffer);
217                   return 1;
218                 }
219               goto process_partial_block;
220             }
221
222           /* We've read at least one byte, so ignore errors.  But always
223              check for EOF, since feof may be true even though N > 0.
224              Otherwise, we could end up calling fread after EOF.  */
225           if (feof (stream))
226             goto process_partial_block;
227         }
228
229       /* Process buffer with BLOCKSIZE bytes.  Note that
230                         BLOCKSIZE % 128 == 0
231        */
232       sha512_process_block (buffer, BLOCKSIZE, &ctx);
233     }
234
235  process_partial_block:;
236
237   /* Process any remaining bytes.  */
238   if (sum > 0)
239     sha512_process_bytes (buffer, sum, &ctx);
240
241   /* Construct result in desired memory.  */
242   sha512_finish_ctx (&ctx, resblock);
243   free (buffer);
244   return 0;
245 }
246
247 /* FIXME: Avoid code duplication */
248 int
249 sha384_stream (FILE *stream, void *resblock)
250 {
251   struct sha512_ctx ctx;
252   size_t sum;
253
254   char *buffer = malloc (BLOCKSIZE + 72);
255   if (!buffer)
256     return 1;
257
258   /* Initialize the computation context.  */
259   sha384_init_ctx (&ctx);
260
261   /* Iterate over full file contents.  */
262   while (1)
263     {
264       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
265          computation function processes the whole buffer so that with the
266          next round of the loop another block can be read.  */
267       size_t n;
268       sum = 0;
269
270       /* Read block.  Take care for partial reads.  */
271       while (1)
272         {
273           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
274
275           sum += n;
276
277           if (sum == BLOCKSIZE)
278             break;
279
280           if (n == 0)
281             {
282               /* Check for the error flag IFF N == 0, so that we don't
283                  exit the loop after a partial read due to e.g., EAGAIN
284                  or EWOULDBLOCK.  */
285               if (ferror (stream))
286                 {
287                   free (buffer);
288                   return 1;
289                 }
290               goto process_partial_block;
291             }
292
293           /* We've read at least one byte, so ignore errors.  But always
294              check for EOF, since feof may be true even though N > 0.
295              Otherwise, we could end up calling fread after EOF.  */
296           if (feof (stream))
297             goto process_partial_block;
298         }
299
300       /* Process buffer with BLOCKSIZE bytes.  Note that
301                         BLOCKSIZE % 128 == 0
302        */
303       sha512_process_block (buffer, BLOCKSIZE, &ctx);
304     }
305
306  process_partial_block:;
307
308   /* Process any remaining bytes.  */
309   if (sum > 0)
310     sha512_process_bytes (buffer, sum, &ctx);
311
312   /* Construct result in desired memory.  */
313   sha384_finish_ctx (&ctx, resblock);
314   free (buffer);
315   return 0;
316 }
317
318 /* Compute SHA512 message digest for LEN bytes beginning at BUFFER.  The
319    result is always in little endian byte order, so that a byte-wise
320    output yields to the wanted ASCII representation of the message
321    digest.  */
322 void *
323 sha512_buffer (const char *buffer, size_t len, void *resblock)
324 {
325   struct sha512_ctx ctx;
326
327   /* Initialize the computation context.  */
328   sha512_init_ctx (&ctx);
329
330   /* Process whole buffer but last len % 128 bytes.  */
331   sha512_process_bytes (buffer, len, &ctx);
332
333   /* Put result in desired memory area.  */
334   return sha512_finish_ctx (&ctx, resblock);
335 }
336
337 void *
338 sha384_buffer (const char *buffer, size_t len, void *resblock)
339 {
340   struct sha512_ctx ctx;
341
342   /* Initialize the computation context.  */
343   sha384_init_ctx (&ctx);
344
345   /* Process whole buffer but last len % 128 bytes.  */
346   sha512_process_bytes (buffer, len, &ctx);
347
348   /* Put result in desired memory area.  */
349   return sha384_finish_ctx (&ctx, resblock);
350 }
351
352 void
353 sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
354 {
355   /* When we already have some bits in our internal buffer concatenate
356      both inputs first.  */
357   if (ctx->buflen != 0)
358     {
359       size_t left_over = ctx->buflen;
360       size_t add = 256 - left_over > len ? len : 256 - left_over;
361
362       memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
363       ctx->buflen += add;
364
365       if (ctx->buflen > 128)
366         {
367           sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
368
369           ctx->buflen &= 127;
370           /* The regions in the following copy operation cannot overlap.  */
371           memcpy (ctx->buffer,
372                   &((char *) ctx->buffer)[(left_over + add) & ~127],
373                   ctx->buflen);
374         }
375
376       buffer = (const char *) buffer + add;
377       len -= add;
378     }
379
380   /* Process available complete blocks.  */
381   if (len >= 128)
382     {
383 #if !_STRING_ARCH_unaligned
384 # define alignof(type) offsetof (struct { char c; type x; }, x)
385 # define UNALIGNED_P(p) (((size_t) p) % alignof (u64) != 0)
386       if (UNALIGNED_P (buffer))
387         while (len > 128)
388           {
389             sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128, ctx);
390             buffer = (const char *) buffer + 128;
391             len -= 128;
392           }
393       else
394 #endif
395         {
396           sha512_process_block (buffer, len & ~127, ctx);
397           buffer = (const char *) buffer + (len & ~127);
398           len &= 127;
399         }
400     }
401
402   /* Move remaining bytes in internal buffer.  */
403   if (len > 0)
404     {
405       size_t left_over = ctx->buflen;
406
407       memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
408       left_over += len;
409       if (left_over >= 128)
410         {
411           sha512_process_block (ctx->buffer, 128, ctx);
412           left_over -= 128;
413           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
414         }
415       ctx->buflen = left_over;
416     }
417 }
418
419 /* --- Code below is the primary difference between sha1.c and sha512.c --- */
420
421 /* SHA512 round constants */
422 #define K(I) sha512_round_constants[I]
423 static u64 const sha512_round_constants[80] = {
424   u64init (0x428a2f98, 0xd728ae22), u64init (0x71374491, 0x23ef65cd),
425   u64init (0xb5c0fbcf, 0xec4d3b2f), u64init (0xe9b5dba5, 0x8189dbbc),
426   u64init (0x3956c25b, 0xf348b538), u64init (0x59f111f1, 0xb605d019),
427   u64init (0x923f82a4, 0xaf194f9b), u64init (0xab1c5ed5, 0xda6d8118),
428   u64init (0xd807aa98, 0xa3030242), u64init (0x12835b01, 0x45706fbe),
429   u64init (0x243185be, 0x4ee4b28c), u64init (0x550c7dc3, 0xd5ffb4e2),
430   u64init (0x72be5d74, 0xf27b896f), u64init (0x80deb1fe, 0x3b1696b1),
431   u64init (0x9bdc06a7, 0x25c71235), u64init (0xc19bf174, 0xcf692694),
432   u64init (0xe49b69c1, 0x9ef14ad2), u64init (0xefbe4786, 0x384f25e3),
433   u64init (0x0fc19dc6, 0x8b8cd5b5), u64init (0x240ca1cc, 0x77ac9c65),
434   u64init (0x2de92c6f, 0x592b0275), u64init (0x4a7484aa, 0x6ea6e483),
435   u64init (0x5cb0a9dc, 0xbd41fbd4), u64init (0x76f988da, 0x831153b5),
436   u64init (0x983e5152, 0xee66dfab), u64init (0xa831c66d, 0x2db43210),
437   u64init (0xb00327c8, 0x98fb213f), u64init (0xbf597fc7, 0xbeef0ee4),
438   u64init (0xc6e00bf3, 0x3da88fc2), u64init (0xd5a79147, 0x930aa725),
439   u64init (0x06ca6351, 0xe003826f), u64init (0x14292967, 0x0a0e6e70),
440   u64init (0x27b70a85, 0x46d22ffc), u64init (0x2e1b2138, 0x5c26c926),
441   u64init (0x4d2c6dfc, 0x5ac42aed), u64init (0x53380d13, 0x9d95b3df),
442   u64init (0x650a7354, 0x8baf63de), u64init (0x766a0abb, 0x3c77b2a8),
443   u64init (0x81c2c92e, 0x47edaee6), u64init (0x92722c85, 0x1482353b),
444   u64init (0xa2bfe8a1, 0x4cf10364), u64init (0xa81a664b, 0xbc423001),
445   u64init (0xc24b8b70, 0xd0f89791), u64init (0xc76c51a3, 0x0654be30),
446   u64init (0xd192e819, 0xd6ef5218), u64init (0xd6990624, 0x5565a910),
447   u64init (0xf40e3585, 0x5771202a), u64init (0x106aa070, 0x32bbd1b8),
448   u64init (0x19a4c116, 0xb8d2d0c8), u64init (0x1e376c08, 0x5141ab53),
449   u64init (0x2748774c, 0xdf8eeb99), u64init (0x34b0bcb5, 0xe19b48a8),
450   u64init (0x391c0cb3, 0xc5c95a63), u64init (0x4ed8aa4a, 0xe3418acb),
451   u64init (0x5b9cca4f, 0x7763e373), u64init (0x682e6ff3, 0xd6b2b8a3),
452   u64init (0x748f82ee, 0x5defb2fc), u64init (0x78a5636f, 0x43172f60),
453   u64init (0x84c87814, 0xa1f0ab72), u64init (0x8cc70208, 0x1a6439ec),
454   u64init (0x90befffa, 0x23631e28), u64init (0xa4506ceb, 0xde82bde9),
455   u64init (0xbef9a3f7, 0xb2c67915), u64init (0xc67178f2, 0xe372532b),
456   u64init (0xca273ece, 0xea26619c), u64init (0xd186b8c7, 0x21c0c207),
457   u64init (0xeada7dd6, 0xcde0eb1e), u64init (0xf57d4f7f, 0xee6ed178),
458   u64init (0x06f067aa, 0x72176fba), u64init (0x0a637dc5, 0xa2c898a6),
459   u64init (0x113f9804, 0xbef90dae), u64init (0x1b710b35, 0x131c471b),
460   u64init (0x28db77f5, 0x23047d84), u64init (0x32caab7b, 0x40c72493),
461   u64init (0x3c9ebe0a, 0x15c9bebc), u64init (0x431d67c4, 0x9c100d4c),
462   u64init (0x4cc5d4be, 0xcb3e42b6), u64init (0x597f299c, 0xfc657e2a),
463   u64init (0x5fcb6fab, 0x3ad6faec), u64init (0x6c44198c, 0x4a475817),
464 };
465
466 /* Round functions.  */
467 #define F2(A, B, C) u64or (u64and (A, B), u64and (C, u64or (A, B)))
468 #define F1(E, F, G) u64xor (G, u64and (E, u64xor (F, G)))
469
470 /* Process LEN bytes of BUFFER, accumulating context into CTX.
471    It is assumed that LEN % 128 == 0.
472    Most of this code comes from GnuPG's cipher/sha1.c.  */
473
474 void
475 sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
476 {
477   u64 const *words = buffer;
478   u64 const *endp = words + len / sizeof (u64);
479   u64 x[16];
480   u64 a = ctx->state[0];
481   u64 b = ctx->state[1];
482   u64 c = ctx->state[2];
483   u64 d = ctx->state[3];
484   u64 e = ctx->state[4];
485   u64 f = ctx->state[5];
486   u64 g = ctx->state[6];
487   u64 h = ctx->state[7];
488
489   /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
490      length of the file up to 2^128 bits.  Here we only compute the
491      number of bytes.  Do a double word increment.  */
492   ctx->total[0] = u64plus (ctx->total[0], u64lo (len));
493   if (u64lt (ctx->total[0], u64lo (len)))
494     ctx->total[1] = u64plus (ctx->total[1], u64lo (1));
495
496 #define S0(x) u64xor (u64rol(x, 63), u64xor (u64rol (x, 56), u64shr (x, 7)))
497 #define S1(x) u64xor (u64rol (x, 45), u64xor (u64rol (x, 3), u64shr (x, 6)))
498 #define SS0(x) u64xor (u64rol (x, 36), u64xor (u64rol (x, 30), u64rol (x, 25)))
499 #define SS1(x) u64xor (u64rol(x, 50), u64xor (u64rol (x, 46), u64rol (x, 23)))
500
501 #define M(I) (x[(I) & 15]                                                 \
502               = u64plus (x[(I) & 15],                                     \
503                          u64plus (S1 (x[((I) - 2) & 15]),                 \
504                                   u64plus (x[((I) - 7) & 15],             \
505                                            S0 (x[((I) - 15) & 15])))))
506
507 #define R(A, B, C, D, E, F, G, H, K, M)                                   \
508   do                                                                      \
509     {                                                                     \
510       u64 t0 = u64plus (SS0 (A), F2 (A, B, C));                           \
511       u64 t1 =                                                            \
512         u64plus (H, u64plus (SS1 (E),                                     \
513                              u64plus (F1 (E, F, G), u64plus (K, M))));    \
514       D = u64plus (D, t1);                                                \
515       H = u64plus (t0, t1);                                               \
516     }                                                                     \
517   while (0)
518
519   while (words < endp)
520     {
521       int t;
522       /* FIXME: see sha1.c for a better implementation.  */
523       for (t = 0; t < 16; t++)
524         {
525           x[t] = SWAP (*words);
526           words++;
527         }
528
529       R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
530       R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );
531       R( g, h, a, b, c, d, e, f, K( 2), x[ 2] );
532       R( f, g, h, a, b, c, d, e, K( 3), x[ 3] );
533       R( e, f, g, h, a, b, c, d, K( 4), x[ 4] );
534       R( d, e, f, g, h, a, b, c, K( 5), x[ 5] );
535       R( c, d, e, f, g, h, a, b, K( 6), x[ 6] );
536       R( b, c, d, e, f, g, h, a, K( 7), x[ 7] );
537       R( a, b, c, d, e, f, g, h, K( 8), x[ 8] );
538       R( h, a, b, c, d, e, f, g, K( 9), x[ 9] );
539       R( g, h, a, b, c, d, e, f, K(10), x[10] );
540       R( f, g, h, a, b, c, d, e, K(11), x[11] );
541       R( e, f, g, h, a, b, c, d, K(12), x[12] );
542       R( d, e, f, g, h, a, b, c, K(13), x[13] );
543       R( c, d, e, f, g, h, a, b, K(14), x[14] );
544       R( b, c, d, e, f, g, h, a, K(15), x[15] );
545       R( a, b, c, d, e, f, g, h, K(16), M(16) );
546       R( h, a, b, c, d, e, f, g, K(17), M(17) );
547       R( g, h, a, b, c, d, e, f, K(18), M(18) );
548       R( f, g, h, a, b, c, d, e, K(19), M(19) );
549       R( e, f, g, h, a, b, c, d, K(20), M(20) );
550       R( d, e, f, g, h, a, b, c, K(21), M(21) );
551       R( c, d, e, f, g, h, a, b, K(22), M(22) );
552       R( b, c, d, e, f, g, h, a, K(23), M(23) );
553       R( a, b, c, d, e, f, g, h, K(24), M(24) );
554       R( h, a, b, c, d, e, f, g, K(25), M(25) );
555       R( g, h, a, b, c, d, e, f, K(26), M(26) );
556       R( f, g, h, a, b, c, d, e, K(27), M(27) );
557       R( e, f, g, h, a, b, c, d, K(28), M(28) );
558       R( d, e, f, g, h, a, b, c, K(29), M(29) );
559       R( c, d, e, f, g, h, a, b, K(30), M(30) );
560       R( b, c, d, e, f, g, h, a, K(31), M(31) );
561       R( a, b, c, d, e, f, g, h, K(32), M(32) );
562       R( h, a, b, c, d, e, f, g, K(33), M(33) );
563       R( g, h, a, b, c, d, e, f, K(34), M(34) );
564       R( f, g, h, a, b, c, d, e, K(35), M(35) );
565       R( e, f, g, h, a, b, c, d, K(36), M(36) );
566       R( d, e, f, g, h, a, b, c, K(37), M(37) );
567       R( c, d, e, f, g, h, a, b, K(38), M(38) );
568       R( b, c, d, e, f, g, h, a, K(39), M(39) );
569       R( a, b, c, d, e, f, g, h, K(40), M(40) );
570       R( h, a, b, c, d, e, f, g, K(41), M(41) );
571       R( g, h, a, b, c, d, e, f, K(42), M(42) );
572       R( f, g, h, a, b, c, d, e, K(43), M(43) );
573       R( e, f, g, h, a, b, c, d, K(44), M(44) );
574       R( d, e, f, g, h, a, b, c, K(45), M(45) );
575       R( c, d, e, f, g, h, a, b, K(46), M(46) );
576       R( b, c, d, e, f, g, h, a, K(47), M(47) );
577       R( a, b, c, d, e, f, g, h, K(48), M(48) );
578       R( h, a, b, c, d, e, f, g, K(49), M(49) );
579       R( g, h, a, b, c, d, e, f, K(50), M(50) );
580       R( f, g, h, a, b, c, d, e, K(51), M(51) );
581       R( e, f, g, h, a, b, c, d, K(52), M(52) );
582       R( d, e, f, g, h, a, b, c, K(53), M(53) );
583       R( c, d, e, f, g, h, a, b, K(54), M(54) );
584       R( b, c, d, e, f, g, h, a, K(55), M(55) );
585       R( a, b, c, d, e, f, g, h, K(56), M(56) );
586       R( h, a, b, c, d, e, f, g, K(57), M(57) );
587       R( g, h, a, b, c, d, e, f, K(58), M(58) );
588       R( f, g, h, a, b, c, d, e, K(59), M(59) );
589       R( e, f, g, h, a, b, c, d, K(60), M(60) );
590       R( d, e, f, g, h, a, b, c, K(61), M(61) );
591       R( c, d, e, f, g, h, a, b, K(62), M(62) );
592       R( b, c, d, e, f, g, h, a, K(63), M(63) );
593       R( a, b, c, d, e, f, g, h, K(64), M(64) );
594       R( h, a, b, c, d, e, f, g, K(65), M(65) );
595       R( g, h, a, b, c, d, e, f, K(66), M(66) );
596       R( f, g, h, a, b, c, d, e, K(67), M(67) );
597       R( e, f, g, h, a, b, c, d, K(68), M(68) );
598       R( d, e, f, g, h, a, b, c, K(69), M(69) );
599       R( c, d, e, f, g, h, a, b, K(70), M(70) );
600       R( b, c, d, e, f, g, h, a, K(71), M(71) );
601       R( a, b, c, d, e, f, g, h, K(72), M(72) );
602       R( h, a, b, c, d, e, f, g, K(73), M(73) );
603       R( g, h, a, b, c, d, e, f, K(74), M(74) );
604       R( f, g, h, a, b, c, d, e, K(75), M(75) );
605       R( e, f, g, h, a, b, c, d, K(76), M(76) );
606       R( d, e, f, g, h, a, b, c, K(77), M(77) );
607       R( c, d, e, f, g, h, a, b, K(78), M(78) );
608       R( b, c, d, e, f, g, h, a, K(79), M(79) );
609
610       a = ctx->state[0] = u64plus (ctx->state[0], a);
611       b = ctx->state[1] = u64plus (ctx->state[1], b);
612       c = ctx->state[2] = u64plus (ctx->state[2], c);
613       d = ctx->state[3] = u64plus (ctx->state[3], d);
614       e = ctx->state[4] = u64plus (ctx->state[4], e);
615       f = ctx->state[5] = u64plus (ctx->state[5], f);
616       g = ctx->state[6] = u64plus (ctx->state[6], g);
617       h = ctx->state[7] = u64plus (ctx->state[7], h);
618     }
619 }