lib/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-2013 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 <stdalign.h>
  28 #include <stdint.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #if USE_UNLOCKED_IO
  33 # include "unlocked-io.h"
  34 #endif
  35
  36 #ifdef WORDS_BIGENDIAN
  37 # define SWAP(n) (n)
  38 #else
  39 # define SWAP(n) \
  40     u64or (u64or (u64or (u64shl (n, 56),                                \
  41                          u64shl (u64and (n, u64lo (0x0000ff00)), 40)),  \
  42                   u64or (u64shl (u64and (n, u64lo (0x00ff0000)), 24),   \
  43                          u64shl (u64and (n, u64lo (0xff000000)),  8))), \
  44            u64or (u64or (u64and (u64shr (n,  8), u64lo (0xff000000)),   \
  45                          u64and (u64shr (n, 24), u64lo (0x00ff0000))),  \
  46                   u64or (u64and (u64shr (n, 40), u64lo (0x0000ff00)),   \
  47                          u64shr (n, 56))))
  48 #endif
  49
  50 #define BLOCKSIZE 32768
  51 #if BLOCKSIZE % 128 != 0
  52 # error "invalid BLOCKSIZE"
  53 #endif
  54
  55 /* This array contains the bytes used to pad the buffer to the next
  56    128-byte boundary.  */
  57 static const unsigned char fillbuf[128] = { 0x80, 0 /* , 0, 0, ...  */ };
  58
  59
  60 /*
  61   Takes a pointer to a 512 bit block of data (eight 64 bit ints) and
  62   initializes it to the start constants of the SHA512 algorithm.  This
  63   must be called before using hash in the call to sha512_hash
  64 */
  65 void
  66 sha512_init_ctx (struct sha512_ctx *ctx)
  67 {
  68   ctx->state[0] = u64hilo (0x6a09e667, 0xf3bcc908);
  69   ctx->state[1] = u64hilo (0xbb67ae85, 0x84caa73b);
  70   ctx->state[2] = u64hilo (0x3c6ef372, 0xfe94f82b);
  71   ctx->state[3] = u64hilo (0xa54ff53a, 0x5f1d36f1);
  72   ctx->state[4] = u64hilo (0x510e527f, 0xade682d1);
  73   ctx->state[5] = u64hilo (0x9b05688c, 0x2b3e6c1f);
  74   ctx->state[6] = u64hilo (0x1f83d9ab, 0xfb41bd6b);
  75   ctx->state[7] = u64hilo (0x5be0cd19, 0x137e2179);
  76
  77   ctx->total[0] = ctx->total[1] = u64lo (0);
  78   ctx->buflen = 0;
  79 }
  80
  81 void
  82 sha384_init_ctx (struct sha512_ctx *ctx)
  83 {
  84   ctx->state[0] = u64hilo (0xcbbb9d5d, 0xc1059ed8);
  85   ctx->state[1] = u64hilo (0x629a292a, 0x367cd507);
  86   ctx->state[2] = u64hilo (0x9159015a, 0x3070dd17);
  87   ctx->state[3] = u64hilo (0x152fecd8, 0xf70e5939);
  88   ctx->state[4] = u64hilo (0x67332667, 0xffc00b31);
  89   ctx->state[5] = u64hilo (0x8eb44a87, 0x68581511);
  90   ctx->state[6] = u64hilo (0xdb0c2e0d, 0x64f98fa7);
  91   ctx->state[7] = u64hilo (0x47b5481d, 0xbefa4fa4);
  92
  93   ctx->total[0] = ctx->total[1] = u64lo (0);
  94   ctx->buflen = 0;
  95 }
  96
  97 /* Copy the value from V into the memory location pointed to by *CP,
  98    If your architecture allows unaligned access, this is equivalent to
  99    * (__typeof__ (v) *) cp = v  */
 100 static void
 101 set_uint64 (char *cp, u64 v)
 102 {
 103   memcpy (cp, &v, sizeof v);
 104 }
 105
 106 /* Put result from CTX in first 64 bytes following RESBUF.
 107    The result must be in little endian byte order.  */
 108 void *
 109 sha512_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
 110 {
 111   int i;
 112   char *r = resbuf;
 113
 114   for (i = 0; i < 8; i++)
 115     set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
 116
 117   return resbuf;
 118 }
 119
 120 void *
 121 sha384_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
 122 {
 123   int i;
 124   char *r = resbuf;
 125
 126   for (i = 0; i < 6; i++)
 127     set_uint64 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
 128
 129   return resbuf;
 130 }
 131
 132 /* Process the remaining bytes in the internal buffer and the usual
 133    prolog according to the standard and write the result to RESBUF.  */
 134 static void
 135 sha512_conclude_ctx (struct sha512_ctx *ctx)
 136 {
 137   /* Take yet unprocessed bytes into account.  */
 138   size_t bytes = ctx->buflen;
 139   size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;
 140
 141   /* Now count remaining bytes.  */
 142   ctx->total[0] = u64plus (ctx->total[0], u64lo (bytes));
 143   if (u64lt (ctx->total[0], u64lo (bytes)))
 144     ctx->total[1] = u64plus (ctx->total[1], u64lo (1));
 145
 146   /* Put the 128-bit file length in *bits* at the end of the buffer.
 147      Use set_uint64 rather than a simple assignment, to avoid risk of
 148      unaligned access.  */
 149   set_uint64 ((char *) &ctx->buffer[size - 2],
 150               SWAP (u64or (u64shl (ctx->total[1], 3),
 151                            u64shr (ctx->total[0], 61))));
 152   set_uint64 ((char *) &ctx->buffer[size - 1],
 153               SWAP (u64shl (ctx->total[0], 3)));
 154
 155   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
 156
 157   /* Process last bytes.  */
 158   sha512_process_block (ctx->buffer, size * 8, ctx);
 159 }
 160
 161 void *
 162 sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
 163 {
 164   sha512_conclude_ctx (ctx);
 165   return sha512_read_ctx (ctx, resbuf);
 166 }
 167
 168 void *
 169 sha384_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
 170 {
 171   sha512_conclude_ctx (ctx);
 172   return sha384_read_ctx (ctx, resbuf);
 173 }
 174
 175 /* Compute SHA512 message digest for bytes read from STREAM.  The
 176    resulting message digest number will be written into the 64 bytes
 177    beginning at RESBLOCK.  */
 178 int
 179 sha512_stream (FILE *stream, void *resblock)
 180 {
 181   struct sha512_ctx ctx;
 182   size_t sum;
 183
 184   char *buffer = malloc (BLOCKSIZE + 72);
 185   if (!buffer)
 186     return 1;
 187
 188   /* Initialize the computation context.  */
 189   sha512_init_ctx (&ctx);
 190
 191   /* Iterate over full file contents.  */
 192   while (1)
 193     {
 194       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 195          computation function processes the whole buffer so that with the
 196          next round of the loop another block can be read.  */
 197       size_t n;
 198       sum = 0;
 199
 200       /* Read block.  Take care for partial reads.  */
 201       while (1)
 202         {
 203           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 204
 205           sum += n;
 206
 207           if (sum == BLOCKSIZE)
 208             break;
 209
 210           if (n == 0)
 211             {
 212               /* Check for the error flag IFF N == 0, so that we don't
 213                  exit the loop after a partial read due to e.g., EAGAIN
 214                  or EWOULDBLOCK.  */
 215               if (ferror (stream))
 216                 {
 217                   free (buffer);
 218                   return 1;
 219                 }
 220               goto process_partial_block;
 221             }
 222
 223           /* We've read at least one byte, so ignore errors.  But always
 224              check for EOF, since feof may be true even though N > 0.
 225              Otherwise, we could end up calling fread after EOF.  */
 226           if (feof (stream))
 227             goto process_partial_block;
 228         }
 229
 230       /* Process buffer with BLOCKSIZE bytes.  Note that
 231                         BLOCKSIZE % 128 == 0
 232        */
 233       sha512_process_block (buffer, BLOCKSIZE, &ctx);
 234     }
 235
 236  process_partial_block:;
 237
 238   /* Process any remaining bytes.  */
 239   if (sum > 0)
 240     sha512_process_bytes (buffer, sum, &ctx);
 241
 242   /* Construct result in desired memory.  */
 243   sha512_finish_ctx (&ctx, resblock);
 244   free (buffer);
 245   return 0;
 246 }
 247
 248 /* FIXME: Avoid code duplication */
 249 int
 250 sha384_stream (FILE *stream, void *resblock)
 251 {
 252   struct sha512_ctx ctx;
 253   size_t sum;
 254
 255   char *buffer = malloc (BLOCKSIZE + 72);
 256   if (!buffer)
 257     return 1;
 258
 259   /* Initialize the computation context.  */
 260   sha384_init_ctx (&ctx);
 261
 262   /* Iterate over full file contents.  */
 263   while (1)
 264     {
 265       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 266          computation function processes the whole buffer so that with the
 267          next round of the loop another block can be read.  */
 268       size_t n;
 269       sum = 0;
 270
 271       /* Read block.  Take care for partial reads.  */
 272       while (1)
 273         {
 274           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 275
 276           sum += n;
 277
 278           if (sum == BLOCKSIZE)
 279             break;
 280
 281           if (n == 0)
 282             {
 283               /* Check for the error flag IFF N == 0, so that we don't
 284                  exit the loop after a partial read due to e.g., EAGAIN
 285                  or EWOULDBLOCK.  */
 286               if (ferror (stream))
 287                 {
 288                   free (buffer);
 289                   return 1;
 290                 }
 291               goto process_partial_block;
 292             }
 293
 294           /* We've read at least one byte, so ignore errors.  But always
 295              check for EOF, since feof may be true even though N > 0.
 296              Otherwise, we could end up calling fread after EOF.  */
 297           if (feof (stream))
 298             goto process_partial_block;
 299         }
 300
 301       /* Process buffer with BLOCKSIZE bytes.  Note that
 302                         BLOCKSIZE % 128 == 0
 303        */
 304       sha512_process_block (buffer, BLOCKSIZE, &ctx);
 305     }
 306
 307  process_partial_block:;
 308
 309   /* Process any remaining bytes.  */
 310   if (sum > 0)
 311     sha512_process_bytes (buffer, sum, &ctx);
 312
 313   /* Construct result in desired memory.  */
 314   sha384_finish_ctx (&ctx, resblock);
 315   free (buffer);
 316   return 0;
 317 }
 318
 319 /* Compute SHA512 message digest for LEN bytes beginning at BUFFER.  The
 320    result is always in little endian byte order, so that a byte-wise
 321    output yields to the wanted ASCII representation of the message
 322    digest.  */
 323 void *
 324 sha512_buffer (const char *buffer, size_t len, void *resblock)
 325 {
 326   struct sha512_ctx ctx;
 327
 328   /* Initialize the computation context.  */
 329   sha512_init_ctx (&ctx);
 330
 331   /* Process whole buffer but last len % 128 bytes.  */
 332   sha512_process_bytes (buffer, len, &ctx);
 333
 334   /* Put result in desired memory area.  */
 335   return sha512_finish_ctx (&ctx, resblock);
 336 }
 337
 338 void *
 339 sha384_buffer (const char *buffer, size_t len, void *resblock)
 340 {
 341   struct sha512_ctx ctx;
 342
 343   /* Initialize the computation context.  */
 344   sha384_init_ctx (&ctx);
 345
 346   /* Process whole buffer but last len % 128 bytes.  */
 347   sha512_process_bytes (buffer, len, &ctx);
 348
 349   /* Put result in desired memory area.  */
 350   return sha384_finish_ctx (&ctx, resblock);
 351 }
 352
 353 void
 354 sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
 355 {
 356   /* When we already have some bits in our internal buffer concatenate
 357      both inputs first.  */
 358   if (ctx->buflen != 0)
 359     {
 360       size_t left_over = ctx->buflen;
 361       size_t add = 256 - left_over > len ? len : 256 - left_over;
 362
 363       memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
 364       ctx->buflen += add;
 365
 366       if (ctx->buflen > 128)
 367         {
 368           sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
 369
 370           ctx->buflen &= 127;
 371           /* The regions in the following copy operation cannot overlap.  */
 372           memcpy (ctx->buffer,
 373                   &((char *) ctx->buffer)[(left_over + add) & ~127],
 374                   ctx->buflen);
 375         }
 376
 377       buffer = (const char *) buffer + add;
 378       len -= add;
 379     }
 380
 381   /* Process available complete blocks.  */
 382   if (len >= 128)
 383     {
 384 #if !_STRING_ARCH_unaligned
 385 # define UNALIGNED_P(p) ((uintptr_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   u64 lolen = u64size (len);
 489
 490   /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
 491      length of the file up to 2^128 bits.  Here we only compute the
 492      number of bytes.  Do a double word increment.  */
 493   ctx->total[0] = u64plus (ctx->total[0], lolen);
 494   ctx->total[1] = u64plus (ctx->total[1],
 495                            u64plus (u64size (len >> 31 >> 31 >> 2),
 496                                     u64lo (u64lt (ctx->total[0], lolen))));
 497
 498 #define S0(x) u64xor (u64rol(x, 63), u64xor (u64rol (x, 56), u64shr (x, 7)))
 499 #define S1(x) u64xor (u64rol (x, 45), u64xor (u64rol (x, 3), u64shr (x, 6)))
 500 #define SS0(x) u64xor (u64rol (x, 36), u64xor (u64rol (x, 30), u64rol (x, 25)))
 501 #define SS1(x) u64xor (u64rol(x, 50), u64xor (u64rol (x, 46), u64rol (x, 23)))
 502
 503 #define M(I) (x[(I) & 15]                                                 \
 504               = u64plus (x[(I) & 15],                                     \
 505                          u64plus (S1 (x[((I) - 2) & 15]),                 \
 506                                   u64plus (x[((I) - 7) & 15],             \
 507                                            S0 (x[((I) - 15) & 15])))))
 508
 509 #define R(A, B, C, D, E, F, G, H, K, M)                                   \
 510   do                                                                      \
 511     {                                                                     \
 512       u64 t0 = u64plus (SS0 (A), F2 (A, B, C));                           \
 513       u64 t1 =                                                            \
 514         u64plus (H, u64plus (SS1 (E),                                     \
 515                              u64plus (F1 (E, F, G), u64plus (K, M))));    \
 516       D = u64plus (D, t1);                                                \
 517       H = u64plus (t0, t1);                                               \
 518     }                                                                     \
 519   while (0)
 520
 521   while (words < endp)
 522     {
 523       int t;
 524       /* FIXME: see sha1.c for a better implementation.  */
 525       for (t = 0; t < 16; t++)
 526         {
 527           x[t] = SWAP (*words);
 528           words++;
 529         }
 530
 531       R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
 532       R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );
 533       R( g, h, a, b, c, d, e, f, K( 2), x[ 2] );
 534       R( f, g, h, a, b, c, d, e, K( 3), x[ 3] );
 535       R( e, f, g, h, a, b, c, d, K( 4), x[ 4] );
 536       R( d, e, f, g, h, a, b, c, K( 5), x[ 5] );
 537       R( c, d, e, f, g, h, a, b, K( 6), x[ 6] );
 538       R( b, c, d, e, f, g, h, a, K( 7), x[ 7] );
 539       R( a, b, c, d, e, f, g, h, K( 8), x[ 8] );
 540       R( h, a, b, c, d, e, f, g, K( 9), x[ 9] );
 541       R( g, h, a, b, c, d, e, f, K(10), x[10] );
 542       R( f, g, h, a, b, c, d, e, K(11), x[11] );
 543       R( e, f, g, h, a, b, c, d, K(12), x[12] );
 544       R( d, e, f, g, h, a, b, c, K(13), x[13] );
 545       R( c, d, e, f, g, h, a, b, K(14), x[14] );
 546       R( b, c, d, e, f, g, h, a, K(15), x[15] );
 547       R( a, b, c, d, e, f, g, h, K(16), M(16) );
 548       R( h, a, b, c, d, e, f, g, K(17), M(17) );
 549       R( g, h, a, b, c, d, e, f, K(18), M(18) );
 550       R( f, g, h, a, b, c, d, e, K(19), M(19) );
 551       R( e, f, g, h, a, b, c, d, K(20), M(20) );
 552       R( d, e, f, g, h, a, b, c, K(21), M(21) );
 553       R( c, d, e, f, g, h, a, b, K(22), M(22) );
 554       R( b, c, d, e, f, g, h, a, K(23), M(23) );
 555       R( a, b, c, d, e, f, g, h, K(24), M(24) );
 556       R( h, a, b, c, d, e, f, g, K(25), M(25) );
 557       R( g, h, a, b, c, d, e, f, K(26), M(26) );
 558       R( f, g, h, a, b, c, d, e, K(27), M(27) );
 559       R( e, f, g, h, a, b, c, d, K(28), M(28) );
 560       R( d, e, f, g, h, a, b, c, K(29), M(29) );
 561       R( c, d, e, f, g, h, a, b, K(30), M(30) );
 562       R( b, c, d, e, f, g, h, a, K(31), M(31) );
 563       R( a, b, c, d, e, f, g, h, K(32), M(32) );
 564       R( h, a, b, c, d, e, f, g, K(33), M(33) );
 565       R( g, h, a, b, c, d, e, f, K(34), M(34) );
 566       R( f, g, h, a, b, c, d, e, K(35), M(35) );
 567       R( e, f, g, h, a, b, c, d, K(36), M(36) );
 568       R( d, e, f, g, h, a, b, c, K(37), M(37) );
 569       R( c, d, e, f, g, h, a, b, K(38), M(38) );
 570       R( b, c, d, e, f, g, h, a, K(39), M(39) );
 571       R( a, b, c, d, e, f, g, h, K(40), M(40) );
 572       R( h, a, b, c, d, e, f, g, K(41), M(41) );
 573       R( g, h, a, b, c, d, e, f, K(42), M(42) );
 574       R( f, g, h, a, b, c, d, e, K(43), M(43) );
 575       R( e, f, g, h, a, b, c, d, K(44), M(44) );
 576       R( d, e, f, g, h, a, b, c, K(45), M(45) );
 577       R( c, d, e, f, g, h, a, b, K(46), M(46) );
 578       R( b, c, d, e, f, g, h, a, K(47), M(47) );
 579       R( a, b, c, d, e, f, g, h, K(48), M(48) );
 580       R( h, a, b, c, d, e, f, g, K(49), M(49) );
 581       R( g, h, a, b, c, d, e, f, K(50), M(50) );
 582       R( f, g, h, a, b, c, d, e, K(51), M(51) );
 583       R( e, f, g, h, a, b, c, d, K(52), M(52) );
 584       R( d, e, f, g, h, a, b, c, K(53), M(53) );
 585       R( c, d, e, f, g, h, a, b, K(54), M(54) );
 586       R( b, c, d, e, f, g, h, a, K(55), M(55) );
 587       R( a, b, c, d, e, f, g, h, K(56), M(56) );
 588       R( h, a, b, c, d, e, f, g, K(57), M(57) );
 589       R( g, h, a, b, c, d, e, f, K(58), M(58) );
 590       R( f, g, h, a, b, c, d, e, K(59), M(59) );
 591       R( e, f, g, h, a, b, c, d, K(60), M(60) );
 592       R( d, e, f, g, h, a, b, c, K(61), M(61) );
 593       R( c, d, e, f, g, h, a, b, K(62), M(62) );
 594       R( b, c, d, e, f, g, h, a, K(63), M(63) );
 595       R( a, b, c, d, e, f, g, h, K(64), M(64) );
 596       R( h, a, b, c, d, e, f, g, K(65), M(65) );
 597       R( g, h, a, b, c, d, e, f, K(66), M(66) );
 598       R( f, g, h, a, b, c, d, e, K(67), M(67) );
 599       R( e, f, g, h, a, b, c, d, K(68), M(68) );
 600       R( d, e, f, g, h, a, b, c, K(69), M(69) );
 601       R( c, d, e, f, g, h, a, b, K(70), M(70) );
 602       R( b, c, d, e, f, g, h, a, K(71), M(71) );
 603       R( a, b, c, d, e, f, g, h, K(72), M(72) );
 604       R( h, a, b, c, d, e, f, g, K(73), M(73) );
 605       R( g, h, a, b, c, d, e, f, K(74), M(74) );
 606       R( f, g, h, a, b, c, d, e, K(75), M(75) );
 607       R( e, f, g, h, a, b, c, d, K(76), M(76) );
 608       R( d, e, f, g, h, a, b, c, K(77), M(77) );
 609       R( c, d, e, f, g, h, a, b, K(78), M(78) );
 610       R( b, c, d, e, f, g, h, a, K(79), M(79) );
 611
 612       a = ctx->state[0] = u64plus (ctx->state[0], a);
 613       b = ctx->state[1] = u64plus (ctx->state[1], b);
 614       c = ctx->state[2] = u64plus (ctx->state[2], c);
 615       d = ctx->state[3] = u64plus (ctx->state[3], d);
 616       e = ctx->state[4] = u64plus (ctx->state[4], e);
 617       f = ctx->state[5] = u64plus (ctx->state[5], f);
 618       g = ctx->state[6] = u64plus (ctx->state[6], g);
 619       h = ctx->state[7] = u64plus (ctx->state[7], h);
 620     }
 621 }