crypto/sha/keccak1600.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/e_os2.h>
  11 #include <string.h>
  12 #include <assert.h>
  13
  14 #define ROL64(a, offset) ((offset) ? (((a) << offset) | ((a) >> (64-offset))) \
  15                                    : a)
  16
  17 #if defined(KECCAK_REF)
  18 /*
  19  * This is straightforward or "maximum clarity" implementation aiming
  20  * to resemble section 3.2 of the FIPS PUB 202 "SHA-3 Standard:
  21  * Permutation-Based Hash and Extendible-Output Functions" as much as
  22  * possible. With one caveat. Because of the way C stores matrices,
  23  * references to A[x,y] in the specification are presented as A[y][x].
  24  * Implementation unrolls inner x-loops so that modulo 5 operations are
  25  * explicitly pre-computed.
  26  */
  27 static void Theta(uint64_t A[5][5])
  28 {
  29     uint64_t C[5], D[5];
  30     size_t y;
  31
  32     C[0] = A[0][0];
  33     C[1] = A[0][1];
  34     C[2] = A[0][2];
  35     C[3] = A[0][3];
  36     C[4] = A[0][4];
  37
  38     for (y = 1; y < 5; y++) {
  39         C[0] ^= A[y][0];
  40         C[1] ^= A[y][1];
  41         C[2] ^= A[y][2];
  42         C[3] ^= A[y][3];
  43         C[4] ^= A[y][4];
  44     }
  45
  46     D[0] = ROL64(C[1], 1) ^ C[4];
  47     D[1] = ROL64(C[2], 1) ^ C[0];
  48     D[2] = ROL64(C[3], 1) ^ C[1];
  49     D[3] = ROL64(C[4], 1) ^ C[2];
  50     D[4] = ROL64(C[0], 1) ^ C[3];
  51
  52     for (y = 0; y < 5; y++) {
  53         A[y][0] ^= D[0];
  54         A[y][1] ^= D[1];
  55         A[y][2] ^= D[2];
  56         A[y][3] ^= D[3];
  57         A[y][4] ^= D[4];
  58     }
  59 }
  60
  61 static void Rho(uint64_t A[5][5])
  62 {
  63     static const unsigned char rhotates[5][5] = {
  64         {  0,  1, 62, 28, 27 },
  65         { 36, 44,  6, 55, 20 },
  66         {  3, 10, 43, 25, 39 },
  67         { 41, 45, 15, 21,  8 },
  68         { 18,  2, 61, 56, 14 }
  69     };
  70     size_t y;
  71
  72     for (y = 0; y < 5; y++) {
  73         A[y][0] = ROL64(A[y][0], rhotates[y][0]);
  74         A[y][1] = ROL64(A[y][1], rhotates[y][1]);
  75         A[y][2] = ROL64(A[y][2], rhotates[y][2]);
  76         A[y][3] = ROL64(A[y][3], rhotates[y][3]);
  77         A[y][4] = ROL64(A[y][4], rhotates[y][4]);
  78     }
  79 }
  80
  81 static void Pi(uint64_t A[5][5])
  82 {
  83     uint64_t T[5][5];
  84
  85     /*
  86      * T = A
  87      * A[y][x] = T[x][(3*y+x)%5]
  88      */
  89     memcpy(T, A, sizeof(T));
  90
  91     A[0][0] = T[0][0];
  92     A[0][1] = T[1][1];
  93     A[0][2] = T[2][2];
  94     A[0][3] = T[3][3];
  95     A[0][4] = T[4][4];
  96
  97     A[1][0] = T[0][3];
  98     A[1][1] = T[1][4];
  99     A[1][2] = T[2][0];
 100     A[1][3] = T[3][1];
 101     A[1][4] = T[4][2];
 102
 103     A[2][0] = T[0][1];
 104     A[2][1] = T[1][2];
 105     A[2][2] = T[2][3];
 106     A[2][3] = T[3][4];
 107     A[2][4] = T[4][0];
 108
 109     A[3][0] = T[0][4];
 110     A[3][1] = T[1][0];
 111     A[3][2] = T[2][1];
 112     A[3][3] = T[3][2];
 113     A[3][4] = T[4][3];
 114
 115     A[4][0] = T[0][2];
 116     A[4][1] = T[1][3];
 117     A[4][2] = T[2][4];
 118     A[4][3] = T[3][0];
 119     A[4][4] = T[4][1];
 120 }
 121
 122 static void Chi(uint64_t A[5][5])
 123 {
 124     uint64_t C[5];
 125     size_t y;
 126
 127     for (y = 0; y < 5; y++) {
 128         C[0] = A[y][0] ^ (~A[y][1] & A[y][2]);
 129         C[1] = A[y][1] ^ (~A[y][2] & A[y][3]);
 130         C[2] = A[y][2] ^ (~A[y][3] & A[y][4]);
 131         C[3] = A[y][3] ^ (~A[y][4] & A[y][0]);
 132         C[4] = A[y][4] ^ (~A[y][0] & A[y][1]);
 133
 134         A[y][0] = C[0];
 135         A[y][1] = C[1];
 136         A[y][2] = C[2];
 137         A[y][3] = C[3];
 138         A[y][4] = C[4];
 139     }
 140 }
 141
 142 static void Iota(uint64_t A[5][5], size_t i)
 143 {
 144     static const uint64_t iotas[] = {
 145         0x0000000000000001U, 0x0000000000008082U, 0x800000000000808aU,
 146         0x8000000080008000U, 0x000000000000808bU, 0x0000000080000001U,
 147         0x8000000080008081U, 0x8000000000008009U, 0x000000000000008aU,
 148         0x0000000000000088U, 0x0000000080008009U, 0x000000008000000aU,
 149         0x000000008000808bU, 0x800000000000008bU, 0x8000000000008089U,
 150         0x8000000000008003U, 0x8000000000008002U, 0x8000000000000080U,
 151         0x000000000000800aU, 0x800000008000000aU, 0x8000000080008081U,
 152         0x8000000000008080U, 0x0000000080000001U, 0x8000000080008008U
 153     };
 154
 155     assert(i < (sizeof(iotas) / sizeof(iotas[0])));
 156     A[0][0] ^= iotas[i];
 157 }
 158
 159 void KeccakF1600(uint64_t A[5][5])
 160 {
 161     size_t i;
 162
 163     for (i = 0; i < 24; i++) {
 164         Theta(A);
 165         Rho(A);
 166         Pi(A);
 167         Chi(A);
 168         Iota(A, i);
 169     }
 170 }
 171
 172 #elif defined(KECCAK_1X)
 173 /*
 174  * This implementation is optimization of above code featuring unroll
 175  * of even y-loops, their fusion and code motion. It also minimizes
 176  * temporary storage. Compiler would normally do all these things for
 177  * you, purpose of manual optimization is to provide "unobscured"
 178  * reference for assembly implementation [in case this approach is
 179  * chosen for implementation on some platform]. In the nutshell it's
 180  * equivalent of "plane-per-plane processing" approach discussed in
 181  * section 2.4 of "Keccak implementation overview".
 182  */
 183 static void Round(uint64_t A[5][5], size_t i)
 184 {
 185     uint64_t C[5], D[5], T[2][5];
 186     static const unsigned char rhotates[5][5] = {
 187         {  0,  1, 62, 28, 27 },
 188         { 36, 44,  6, 55, 20 },
 189         {  3, 10, 43, 25, 39 },
 190         { 41, 45, 15, 21,  8 },
 191         { 18,  2, 61, 56, 14 }
 192     };
 193     static const uint64_t iotas[] = {
 194         0x0000000000000001U, 0x0000000000008082U, 0x800000000000808aU,
 195         0x8000000080008000U, 0x000000000000808bU, 0x0000000080000001U,
 196         0x8000000080008081U, 0x8000000000008009U, 0x000000000000008aU,
 197         0x0000000000000088U, 0x0000000080008009U, 0x000000008000000aU,
 198         0x000000008000808bU, 0x800000000000008bU, 0x8000000000008089U,
 199         0x8000000000008003U, 0x8000000000008002U, 0x8000000000000080U,
 200         0x000000000000800aU, 0x800000008000000aU, 0x8000000080008081U,
 201         0x8000000000008080U, 0x0000000080000001U, 0x8000000080008008U
 202     };
 203
 204     assert(i < (sizeof(iotas) / sizeof(iotas[0])));
 205
 206     C[0] = A[0][0] ^ A[1][0] ^ A[2][0] ^ A[3][0] ^ A[4][0];
 207     C[1] = A[0][1] ^ A[1][1] ^ A[2][1] ^ A[3][1] ^ A[4][1];
 208     C[2] = A[0][2] ^ A[1][2] ^ A[2][2] ^ A[3][2] ^ A[4][2];
 209     C[3] = A[0][3] ^ A[1][3] ^ A[2][3] ^ A[3][3] ^ A[4][3];
 210     C[4] = A[0][4] ^ A[1][4] ^ A[2][4] ^ A[3][4] ^ A[4][4];
 211
 212     D[0] = ROL64(C[1], 1) ^ C[4];
 213     D[1] = ROL64(C[2], 1) ^ C[0];
 214     D[2] = ROL64(C[3], 1) ^ C[1];
 215     D[3] = ROL64(C[4], 1) ^ C[2];
 216     D[4] = ROL64(C[0], 1) ^ C[3];
 217
 218     C[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 219     C[1] = ROL64(A[1][1] ^ D[1], rhotates[1][1]);
 220     C[2] = ROL64(A[2][2] ^ D[2], rhotates[2][2]);
 221     C[3] = ROL64(A[3][3] ^ D[3], rhotates[3][3]);
 222     C[4] = ROL64(A[4][4] ^ D[4], rhotates[4][4]);
 223
 224     T[0][0] = A[3][0] ^ D[0]; /* borrow T[0][0] */
 225     T[0][1] = A[0][1] ^ D[1];
 226     T[0][2] = A[0][2] ^ D[2];
 227     T[0][3] = A[0][3] ^ D[3];
 228     T[0][4] = A[0][4] ^ D[4];
 229
 230     A[0][0] = C[0] ^ (~C[1] & C[2]) ^ iotas[i];
 231     A[0][1] = C[1] ^ (~C[2] & C[3]);
 232     A[0][2] = C[2] ^ (~C[3] & C[4]);
 233     A[0][3] = C[3] ^ (~C[4] & C[0]);
 234     A[0][4] = C[4] ^ (~C[0] & C[1]);
 235
 236     C[0] = ROL64(T[0][3],        rhotates[0][3]);
 237     C[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 238     C[2] = ROL64(A[2][0] ^ D[0], rhotates[2][0]);
 239     C[3] = ROL64(A[3][1] ^ D[1], rhotates[3][1]);
 240     C[4] = ROL64(A[4][2] ^ D[2], rhotates[4][2]);
 241
 242     T[1][0] = A[1][0] ^ D[0];
 243     T[1][1] = A[2][1] ^ D[1]; /* borrow T[1][1] */
 244     T[1][2] = A[1][2] ^ D[2];
 245     T[1][3] = A[1][3] ^ D[3];
 246     T[1][4] = A[2][4] ^ D[4]; /* borrow T[1][4] */
 247
 248     A[1][0] = C[0] ^ (~C[1] & C[2]);
 249     A[1][1] = C[1] ^ (~C[2] & C[3]);
 250     A[1][2] = C[2] ^ (~C[3] & C[4]);
 251     A[1][3] = C[3] ^ (~C[4] & C[0]);
 252     A[1][4] = C[4] ^ (~C[0] & C[1]);
 253
 254     C[0] = ROL64(T[0][1],        rhotates[0][1]);
 255     C[1] = ROL64(T[1][2],        rhotates[1][2]);
 256     C[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 257     C[3] = ROL64(A[3][4] ^ D[4], rhotates[3][4]);
 258     C[4] = ROL64(A[4][0] ^ D[0], rhotates[4][0]);
 259
 260     A[2][0] = C[0] ^ (~C[1] & C[2]);
 261     A[2][1] = C[1] ^ (~C[2] & C[3]);
 262     A[2][2] = C[2] ^ (~C[3] & C[4]);
 263     A[2][3] = C[3] ^ (~C[4] & C[0]);
 264     A[2][4] = C[4] ^ (~C[0] & C[1]);
 265
 266     C[0] = ROL64(T[0][4],        rhotates[0][4]);
 267     C[1] = ROL64(T[1][0],        rhotates[1][0]);
 268     C[2] = ROL64(T[1][1],        rhotates[2][1]); /* originally A[2][1] */
 269     C[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 270     C[4] = ROL64(A[4][3] ^ D[3], rhotates[4][3]);
 271
 272     A[3][0] = C[0] ^ (~C[1] & C[2]);
 273     A[3][1] = C[1] ^ (~C[2] & C[3]);
 274     A[3][2] = C[2] ^ (~C[3] & C[4]);
 275     A[3][3] = C[3] ^ (~C[4] & C[0]);
 276     A[3][4] = C[4] ^ (~C[0] & C[1]);
 277
 278     C[0] = ROL64(T[0][2],        rhotates[0][2]);
 279     C[1] = ROL64(T[1][3],        rhotates[1][3]);
 280     C[2] = ROL64(T[1][4],        rhotates[2][4]); /* originally A[2][4] */
 281     C[3] = ROL64(T[0][0],        rhotates[3][0]); /* originally A[3][0] */
 282     C[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 283
 284     A[4][0] = C[0] ^ (~C[1] & C[2]);
 285     A[4][1] = C[1] ^ (~C[2] & C[3]);
 286     A[4][2] = C[2] ^ (~C[3] & C[4]);
 287     A[4][3] = C[3] ^ (~C[4] & C[0]);
 288     A[4][4] = C[4] ^ (~C[0] & C[1]);
 289 }
 290
 291 void KeccakF1600(uint64_t A[5][5])
 292 {
 293     size_t i;
 294
 295     for (i = 0; i < 24; i++) {
 296         Round(A, i);
 297     }
 298 }
 299
 300 #elif defined(KECCAK_2X)
 301 /*
 302  * This implementation is variant of KECCAK_1X above with outer-most
 303  * round loop unrolled twice. This allows to take temporary storage
 304  * out of round procedure and simplify references to it by alternating
 305  * it with actual data (see round loop below). Just like original, it's
 306  * rather meant as reference for an assembly implementation. It's likely
 307  * to provide best instruction per processed byte ratio at minimal
 308  * round unroll factor...
 309  */
 310 static void Round(uint64_t R[5][5], uint64_t A[5][5], size_t i)
 311 {
 312     uint64_t C[5], D[5];
 313     static const unsigned char rhotates[5][5] = {
 314         {  0,  1, 62, 28, 27 },
 315         { 36, 44,  6, 55, 20 },
 316         {  3, 10, 43, 25, 39 },
 317         { 41, 45, 15, 21,  8 },
 318         { 18,  2, 61, 56, 14 }
 319     };
 320     static const uint64_t iotas[] = {
 321         0x0000000000000001U, 0x0000000000008082U, 0x800000000000808aU,
 322         0x8000000080008000U, 0x000000000000808bU, 0x0000000080000001U,
 323         0x8000000080008081U, 0x8000000000008009U, 0x000000000000008aU,
 324         0x0000000000000088U, 0x0000000080008009U, 0x000000008000000aU,
 325         0x000000008000808bU, 0x800000000000008bU, 0x8000000000008089U,
 326         0x8000000000008003U, 0x8000000000008002U, 0x8000000000000080U,
 327         0x000000000000800aU, 0x800000008000000aU, 0x8000000080008081U,
 328         0x8000000000008080U, 0x0000000080000001U, 0x8000000080008008U
 329     };
 330
 331     assert(i < (sizeof(iotas) / sizeof(iotas[0])));
 332
 333     C[0] = A[0][0] ^ A[1][0] ^ A[2][0] ^ A[3][0] ^ A[4][0];
 334     C[1] = A[0][1] ^ A[1][1] ^ A[2][1] ^ A[3][1] ^ A[4][1];
 335     C[2] = A[0][2] ^ A[1][2] ^ A[2][2] ^ A[3][2] ^ A[4][2];
 336     C[3] = A[0][3] ^ A[1][3] ^ A[2][3] ^ A[3][3] ^ A[4][3];
 337     C[4] = A[0][4] ^ A[1][4] ^ A[2][4] ^ A[3][4] ^ A[4][4];
 338
 339     D[0] = ROL64(C[1], 1) ^ C[4];
 340     D[1] = ROL64(C[2], 1) ^ C[0];
 341     D[2] = ROL64(C[3], 1) ^ C[1];
 342     D[3] = ROL64(C[4], 1) ^ C[2];
 343     D[4] = ROL64(C[0], 1) ^ C[3];
 344
 345     C[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 346     C[1] = ROL64(A[1][1] ^ D[1], rhotates[1][1]);
 347     C[2] = ROL64(A[2][2] ^ D[2], rhotates[2][2]);
 348     C[3] = ROL64(A[3][3] ^ D[3], rhotates[3][3]);
 349     C[4] = ROL64(A[4][4] ^ D[4], rhotates[4][4]);
 350
 351     R[0][0] = C[0] ^ (~C[1] & C[2]) ^ iotas[i];
 352     R[0][1] = C[1] ^ (~C[2] & C[3]);
 353     R[0][2] = C[2] ^ (~C[3] & C[4]);
 354     R[0][3] = C[3] ^ (~C[4] & C[0]);
 355     R[0][4] = C[4] ^ (~C[0] & C[1]);
 356
 357     C[0] = ROL64(A[0][3] ^ D[3], rhotates[0][3]);
 358     C[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 359     C[2] = ROL64(A[2][0] ^ D[0], rhotates[2][0]);
 360     C[3] = ROL64(A[3][1] ^ D[1], rhotates[3][1]);
 361     C[4] = ROL64(A[4][2] ^ D[2], rhotates[4][2]);
 362
 363     R[1][0] = C[0] ^ (~C[1] & C[2]);
 364     R[1][1] = C[1] ^ (~C[2] & C[3]);
 365     R[1][2] = C[2] ^ (~C[3] & C[4]);
 366     R[1][3] = C[3] ^ (~C[4] & C[0]);
 367     R[1][4] = C[4] ^ (~C[0] & C[1]);
 368
 369     C[0] = ROL64(A[0][1] ^ D[1], rhotates[0][1]);
 370     C[1] = ROL64(A[1][2] ^ D[2], rhotates[1][2]);
 371     C[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 372     C[3] = ROL64(A[3][4] ^ D[4], rhotates[3][4]);
 373     C[4] = ROL64(A[4][0] ^ D[0], rhotates[4][0]);
 374
 375     R[2][0] = C[0] ^ (~C[1] & C[2]);
 376     R[2][1] = C[1] ^ (~C[2] & C[3]);
 377     R[2][2] = C[2] ^ (~C[3] & C[4]);
 378     R[2][3] = C[3] ^ (~C[4] & C[0]);
 379     R[2][4] = C[4] ^ (~C[0] & C[1]);
 380
 381     C[0] = ROL64(A[0][4] ^ D[4], rhotates[0][4]);
 382     C[1] = ROL64(A[1][0] ^ D[0], rhotates[1][0]);
 383     C[2] = ROL64(A[2][1] ^ D[1], rhotates[2][1]);
 384     C[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 385     C[4] = ROL64(A[4][3] ^ D[3], rhotates[4][3]);
 386
 387     R[3][0] = C[0] ^ (~C[1] & C[2]);
 388     R[3][1] = C[1] ^ (~C[2] & C[3]);
 389     R[3][2] = C[2] ^ (~C[3] & C[4]);
 390     R[3][3] = C[3] ^ (~C[4] & C[0]);
 391     R[3][4] = C[4] ^ (~C[0] & C[1]);
 392
 393     C[0] = ROL64(A[0][2] ^ D[2], rhotates[0][2]);
 394     C[1] = ROL64(A[1][3] ^ D[3], rhotates[1][3]);
 395     C[2] = ROL64(A[2][4] ^ D[4], rhotates[2][4]);
 396     C[3] = ROL64(A[3][0] ^ D[0], rhotates[3][0]);
 397     C[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 398
 399     R[4][0] = C[0] ^ (~C[1] & C[2]);
 400     R[4][1] = C[1] ^ (~C[2] & C[3]);
 401     R[4][2] = C[2] ^ (~C[3] & C[4]);
 402     R[4][3] = C[3] ^ (~C[4] & C[0]);
 403     R[4][4] = C[4] ^ (~C[0] & C[1]);
 404 }
 405
 406 void KeccakF1600(uint64_t A[5][5])
 407 {
 408     uint64_t T[5][5];
 409     size_t i;
 410
 411     for (i = 0; i < 24; i += 2) {
 412         Round(T, A, i);
 413         Round(A, T, i + 1);
 414     }
 415 }
 416
 417 #else
 418 /*
 419  * This implementation is KECCAK_1X from above combined 4 times with
 420  * a twist that allows to omit temporary storage and perform in-place
 421  * processing. It's discussed in section 2.5 of "Keccak implementation
 422  * overview". It's likely to be best suited for processors with large
 423  * register bank...
 424  */
 425 static void FourRounds(uint64_t A[5][5], size_t i)
 426 {
 427     uint64_t B[5], C[5], D[5];
 428     static const unsigned char rhotates[5][5] = {
 429         {  0,  1, 62, 28, 27 },
 430         { 36, 44,  6, 55, 20 },
 431         {  3, 10, 43, 25, 39 },
 432         { 41, 45, 15, 21,  8 },
 433         { 18,  2, 61, 56, 14 }
 434     };
 435     static const uint64_t iotas[] = {
 436         0x0000000000000001U, 0x0000000000008082U, 0x800000000000808aU,
 437         0x8000000080008000U, 0x000000000000808bU, 0x0000000080000001U,
 438         0x8000000080008081U, 0x8000000000008009U, 0x000000000000008aU,
 439         0x0000000000000088U, 0x0000000080008009U, 0x000000008000000aU,
 440         0x000000008000808bU, 0x800000000000008bU, 0x8000000000008089U,
 441         0x8000000000008003U, 0x8000000000008002U, 0x8000000000000080U,
 442         0x000000000000800aU, 0x800000008000000aU, 0x8000000080008081U,
 443         0x8000000000008080U, 0x0000000080000001U, 0x8000000080008008U
 444     };
 445
 446     assert(i <= (sizeof(iotas) / sizeof(iotas[0]) - 4));
 447
 448     /* Round 4*n */
 449     C[0] = A[0][0] ^ A[1][0] ^ A[2][0] ^ A[3][0] ^ A[4][0];
 450     C[1] = A[0][1] ^ A[1][1] ^ A[2][1] ^ A[3][1] ^ A[4][1];
 451     C[2] = A[0][2] ^ A[1][2] ^ A[2][2] ^ A[3][2] ^ A[4][2];
 452     C[3] = A[0][3] ^ A[1][3] ^ A[2][3] ^ A[3][3] ^ A[4][3];
 453     C[4] = A[0][4] ^ A[1][4] ^ A[2][4] ^ A[3][4] ^ A[4][4];
 454
 455     D[0] = ROL64(C[1], 1) ^ C[4];
 456     D[1] = ROL64(C[2], 1) ^ C[0];
 457     D[2] = ROL64(C[3], 1) ^ C[1];
 458     D[3] = ROL64(C[4], 1) ^ C[2];
 459     D[4] = ROL64(C[0], 1) ^ C[3];
 460
 461     B[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 462     B[1] = ROL64(A[1][1] ^ D[1], rhotates[1][1]);
 463     B[2] = ROL64(A[2][2] ^ D[2], rhotates[2][2]);
 464     B[3] = ROL64(A[3][3] ^ D[3], rhotates[3][3]);
 465     B[4] = ROL64(A[4][4] ^ D[4], rhotates[4][4]);
 466
 467     C[0] = A[0][0] = B[0] ^ (~B[1] & B[2]) ^ iotas[i];
 468     C[1] = A[1][1] = B[1] ^ (~B[2] & B[3]);
 469     C[2] = A[2][2] = B[2] ^ (~B[3] & B[4]);
 470     C[3] = A[3][3] = B[3] ^ (~B[4] & B[0]);
 471     C[4] = A[4][4] = B[4] ^ (~B[0] & B[1]);
 472
 473     B[0] = ROL64(A[0][3] ^ D[3], rhotates[0][3]);
 474     B[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 475     B[2] = ROL64(A[2][0] ^ D[0], rhotates[2][0]);
 476     B[3] = ROL64(A[3][1] ^ D[1], rhotates[3][1]);
 477     B[4] = ROL64(A[4][2] ^ D[2], rhotates[4][2]);
 478
 479     C[0] ^= A[2][0] = B[0] ^ (~B[1] & B[2]);
 480     C[1] ^= A[3][1] = B[1] ^ (~B[2] & B[3]);
 481     C[2] ^= A[4][2] = B[2] ^ (~B[3] & B[4]);
 482     C[3] ^= A[0][3] = B[3] ^ (~B[4] & B[0]);
 483     C[4] ^= A[1][4] = B[4] ^ (~B[0] & B[1]);
 484
 485     B[0] = ROL64(A[0][1] ^ D[1], rhotates[0][1]);
 486     B[1] = ROL64(A[1][2] ^ D[2], rhotates[1][2]);
 487     B[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 488     B[3] = ROL64(A[3][4] ^ D[4], rhotates[3][4]);
 489     B[4] = ROL64(A[4][0] ^ D[0], rhotates[4][0]);
 490
 491     C[0] ^= A[4][0] = B[0] ^ (~B[1] & B[2]);
 492     C[1] ^= A[0][1] = B[1] ^ (~B[2] & B[3]);
 493     C[2] ^= A[1][2] = B[2] ^ (~B[3] & B[4]);
 494     C[3] ^= A[2][3] = B[3] ^ (~B[4] & B[0]);
 495     C[4] ^= A[3][4] = B[4] ^ (~B[0] & B[1]);
 496
 497     B[0] = ROL64(A[0][4] ^ D[4], rhotates[0][4]);
 498     B[1] = ROL64(A[1][0] ^ D[0], rhotates[1][0]);
 499     B[2] = ROL64(A[2][1] ^ D[1], rhotates[2][1]);
 500     B[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 501     B[4] = ROL64(A[4][3] ^ D[3], rhotates[4][3]);
 502
 503     C[0] ^= A[1][0] = B[0] ^ (~B[1] & B[2]);
 504     C[1] ^= A[2][1] = B[1] ^ (~B[2] & B[3]);
 505     C[2] ^= A[3][2] = B[2] ^ (~B[3] & B[4]);
 506     C[3] ^= A[4][3] = B[3] ^ (~B[4] & B[0]);
 507     C[4] ^= A[0][4] = B[4] ^ (~B[0] & B[1]);
 508
 509     B[0] = ROL64(A[0][2] ^ D[2], rhotates[0][2]);
 510     B[1] = ROL64(A[1][3] ^ D[3], rhotates[1][3]);
 511     B[2] = ROL64(A[2][4] ^ D[4], rhotates[2][4]);
 512     B[3] = ROL64(A[3][0] ^ D[0], rhotates[3][0]);
 513     B[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 514
 515     C[0] ^= A[3][0] = B[0] ^ (~B[1] & B[2]);
 516     C[1] ^= A[4][1] = B[1] ^ (~B[2] & B[3]);
 517     C[2] ^= A[0][2] = B[2] ^ (~B[3] & B[4]);
 518     C[3] ^= A[1][3] = B[3] ^ (~B[4] & B[0]);
 519     C[4] ^= A[2][4] = B[4] ^ (~B[0] & B[1]);
 520
 521     /* Round 4*n+1 */
 522     D[0] = ROL64(C[1], 1) ^ C[4];
 523     D[1] = ROL64(C[2], 1) ^ C[0];
 524     D[2] = ROL64(C[3], 1) ^ C[1];
 525     D[3] = ROL64(C[4], 1) ^ C[2];
 526     D[4] = ROL64(C[0], 1) ^ C[3];
 527
 528     B[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 529     B[1] = ROL64(A[3][1] ^ D[1], rhotates[1][1]);
 530     B[2] = ROL64(A[1][2] ^ D[2], rhotates[2][2]);
 531     B[3] = ROL64(A[4][3] ^ D[3], rhotates[3][3]);
 532     B[4] = ROL64(A[2][4] ^ D[4], rhotates[4][4]);
 533
 534     C[0] = A[0][0] = B[0] ^ (~B[1] & B[2]) ^ iotas[i + 1];
 535     C[1] = A[3][1] = B[1] ^ (~B[2] & B[3]);
 536     C[2] = A[1][2] = B[2] ^ (~B[3] & B[4]);
 537     C[3] = A[4][3] = B[3] ^ (~B[4] & B[0]);
 538     C[4] = A[2][4] = B[4] ^ (~B[0] & B[1]);
 539
 540     B[0] = ROL64(A[3][3] ^ D[3], rhotates[0][3]);
 541     B[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 542     B[2] = ROL64(A[4][0] ^ D[0], rhotates[2][0]);
 543     B[3] = ROL64(A[2][1] ^ D[1], rhotates[3][1]);
 544     B[4] = ROL64(A[0][2] ^ D[2], rhotates[4][2]);
 545
 546     C[0] ^= A[4][0] = B[0] ^ (~B[1] & B[2]);
 547     C[1] ^= A[2][1] = B[1] ^ (~B[2] & B[3]);
 548     C[2] ^= A[0][2] = B[2] ^ (~B[3] & B[4]);
 549     C[3] ^= A[3][3] = B[3] ^ (~B[4] & B[0]);
 550     C[4] ^= A[1][4] = B[4] ^ (~B[0] & B[1]);
 551
 552     B[0] = ROL64(A[1][1] ^ D[1], rhotates[0][1]);
 553     B[1] = ROL64(A[4][2] ^ D[2], rhotates[1][2]);
 554     B[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 555     B[3] = ROL64(A[0][4] ^ D[4], rhotates[3][4]);
 556     B[4] = ROL64(A[3][0] ^ D[0], rhotates[4][0]);
 557
 558     C[0] ^= A[3][0] = B[0] ^ (~B[1] & B[2]);
 559     C[1] ^= A[1][1] = B[1] ^ (~B[2] & B[3]);
 560     C[2] ^= A[4][2] = B[2] ^ (~B[3] & B[4]);
 561     C[3] ^= A[2][3] = B[3] ^ (~B[4] & B[0]);
 562     C[4] ^= A[0][4] = B[4] ^ (~B[0] & B[1]);
 563
 564     B[0] = ROL64(A[4][4] ^ D[4], rhotates[0][4]);
 565     B[1] = ROL64(A[2][0] ^ D[0], rhotates[1][0]);
 566     B[2] = ROL64(A[0][1] ^ D[1], rhotates[2][1]);
 567     B[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 568     B[4] = ROL64(A[1][3] ^ D[3], rhotates[4][3]);
 569
 570     C[0] ^= A[2][0] = B[0] ^ (~B[1] & B[2]);
 571     C[1] ^= A[0][1] = B[1] ^ (~B[2] & B[3]);
 572     C[2] ^= A[3][2] = B[2] ^ (~B[3] & B[4]);
 573     C[3] ^= A[1][3] = B[3] ^ (~B[4] & B[0]);
 574     C[4] ^= A[4][4] = B[4] ^ (~B[0] & B[1]);
 575
 576     B[0] = ROL64(A[2][2] ^ D[2], rhotates[0][2]);
 577     B[1] = ROL64(A[0][3] ^ D[3], rhotates[1][3]);
 578     B[2] = ROL64(A[3][4] ^ D[4], rhotates[2][4]);
 579     B[3] = ROL64(A[1][0] ^ D[0], rhotates[3][0]);
 580     B[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 581
 582     C[0] ^= A[1][0] = B[0] ^ (~B[1] & B[2]);
 583     C[1] ^= A[4][1] = B[1] ^ (~B[2] & B[3]);
 584     C[2] ^= A[2][2] = B[2] ^ (~B[3] & B[4]);
 585     C[3] ^= A[0][3] = B[3] ^ (~B[4] & B[0]);
 586     C[4] ^= A[3][4] = B[4] ^ (~B[0] & B[1]);
 587
 588     /* Round 4*n+2 */
 589     D[0] = ROL64(C[1], 1) ^ C[4];
 590     D[1] = ROL64(C[2], 1) ^ C[0];
 591     D[2] = ROL64(C[3], 1) ^ C[1];
 592     D[3] = ROL64(C[4], 1) ^ C[2];
 593     D[4] = ROL64(C[0], 1) ^ C[3];
 594
 595     B[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 596     B[1] = ROL64(A[2][1] ^ D[1], rhotates[1][1]);
 597     B[2] = ROL64(A[4][2] ^ D[2], rhotates[2][2]);
 598     B[3] = ROL64(A[1][3] ^ D[3], rhotates[3][3]);
 599     B[4] = ROL64(A[3][4] ^ D[4], rhotates[4][4]);
 600
 601     C[0] = A[0][0] = B[0] ^ (~B[1] & B[2]) ^ iotas[i + 2];
 602     C[1] = A[2][1] = B[1] ^ (~B[2] & B[3]);
 603     C[2] = A[4][2] = B[2] ^ (~B[3] & B[4]);
 604     C[3] = A[1][3] = B[3] ^ (~B[4] & B[0]);
 605     C[4] = A[3][4] = B[4] ^ (~B[0] & B[1]);
 606
 607     B[0] = ROL64(A[4][3] ^ D[3], rhotates[0][3]);
 608     B[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 609     B[2] = ROL64(A[3][0] ^ D[0], rhotates[2][0]);
 610     B[3] = ROL64(A[0][1] ^ D[1], rhotates[3][1]);
 611     B[4] = ROL64(A[2][2] ^ D[2], rhotates[4][2]);
 612
 613     C[0] ^= A[3][0] = B[0] ^ (~B[1] & B[2]);
 614     C[1] ^= A[0][1] = B[1] ^ (~B[2] & B[3]);
 615     C[2] ^= A[2][2] = B[2] ^ (~B[3] & B[4]);
 616     C[3] ^= A[4][3] = B[3] ^ (~B[4] & B[0]);
 617     C[4] ^= A[1][4] = B[4] ^ (~B[0] & B[1]);
 618
 619     B[0] = ROL64(A[3][1] ^ D[1], rhotates[0][1]);
 620     B[1] = ROL64(A[0][2] ^ D[2], rhotates[1][2]);
 621     B[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 622     B[3] = ROL64(A[4][4] ^ D[4], rhotates[3][4]);
 623     B[4] = ROL64(A[1][0] ^ D[0], rhotates[4][0]);
 624
 625     C[0] ^= A[1][0] = B[0] ^ (~B[1] & B[2]);
 626     C[1] ^= A[3][1] = B[1] ^ (~B[2] & B[3]);
 627     C[2] ^= A[0][2] = B[2] ^ (~B[3] & B[4]);
 628     C[3] ^= A[2][3] = B[3] ^ (~B[4] & B[0]);
 629     C[4] ^= A[4][4] = B[4] ^ (~B[0] & B[1]);
 630
 631     B[0] = ROL64(A[2][4] ^ D[4], rhotates[0][4]);
 632     B[1] = ROL64(A[4][0] ^ D[0], rhotates[1][0]);
 633     B[2] = ROL64(A[1][1] ^ D[1], rhotates[2][1]);
 634     B[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 635     B[4] = ROL64(A[0][3] ^ D[3], rhotates[4][3]);
 636
 637     C[0] ^= A[4][0] = B[0] ^ (~B[1] & B[2]);
 638     C[1] ^= A[1][1] = B[1] ^ (~B[2] & B[3]);
 639     C[2] ^= A[3][2] = B[2] ^ (~B[3] & B[4]);
 640     C[3] ^= A[0][3] = B[3] ^ (~B[4] & B[0]);
 641     C[4] ^= A[2][4] = B[4] ^ (~B[0] & B[1]);
 642
 643     B[0] = ROL64(A[1][2] ^ D[2], rhotates[0][2]);
 644     B[1] = ROL64(A[3][3] ^ D[3], rhotates[1][3]);
 645     B[2] = ROL64(A[0][4] ^ D[4], rhotates[2][4]);
 646     B[3] = ROL64(A[2][0] ^ D[0], rhotates[3][0]);
 647     B[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 648
 649     C[0] ^= A[2][0] = B[0] ^ (~B[1] & B[2]);
 650     C[1] ^= A[4][1] = B[1] ^ (~B[2] & B[3]);
 651     C[2] ^= A[1][2] = B[2] ^ (~B[3] & B[4]);
 652     C[3] ^= A[3][3] = B[3] ^ (~B[4] & B[0]);
 653     C[4] ^= A[0][4] = B[4] ^ (~B[0] & B[1]);
 654
 655     /* Round 4*n+3 */
 656     D[0] = ROL64(C[1], 1) ^ C[4];
 657     D[1] = ROL64(C[2], 1) ^ C[0];
 658     D[2] = ROL64(C[3], 1) ^ C[1];
 659     D[3] = ROL64(C[4], 1) ^ C[2];
 660     D[4] = ROL64(C[0], 1) ^ C[3];
 661
 662     B[0] =       A[0][0] ^ D[0]; /* rotate by 0 */
 663     B[1] = ROL64(A[0][1] ^ D[1], rhotates[1][1]);
 664     B[2] = ROL64(A[0][2] ^ D[2], rhotates[2][2]);
 665     B[3] = ROL64(A[0][3] ^ D[3], rhotates[3][3]);
 666     B[4] = ROL64(A[0][4] ^ D[4], rhotates[4][4]);
 667
 668     /* C[0] = */ A[0][0] = B[0] ^ (~B[1] & B[2]) ^ iotas[i + 3];
 669     /* C[1] = */ A[0][1] = B[1] ^ (~B[2] & B[3]);
 670     /* C[2] = */ A[0][2] = B[2] ^ (~B[3] & B[4]);
 671     /* C[3] = */ A[0][3] = B[3] ^ (~B[4] & B[0]);
 672     /* C[4] = */ A[0][4] = B[4] ^ (~B[0] & B[1]);
 673
 674     B[0] = ROL64(A[1][3] ^ D[3], rhotates[0][3]);
 675     B[1] = ROL64(A[1][4] ^ D[4], rhotates[1][4]);
 676     B[2] = ROL64(A[1][0] ^ D[0], rhotates[2][0]);
 677     B[3] = ROL64(A[1][1] ^ D[1], rhotates[3][1]);
 678     B[4] = ROL64(A[1][2] ^ D[2], rhotates[4][2]);
 679
 680     /* C[0] ^= */ A[1][0] = B[0] ^ (~B[1] & B[2]);
 681     /* C[1] ^= */ A[1][1] = B[1] ^ (~B[2] & B[3]);
 682     /* C[2] ^= */ A[1][2] = B[2] ^ (~B[3] & B[4]);
 683     /* C[3] ^= */ A[1][3] = B[3] ^ (~B[4] & B[0]);
 684     /* C[4] ^= */ A[1][4] = B[4] ^ (~B[0] & B[1]);
 685
 686     B[0] = ROL64(A[2][1] ^ D[1], rhotates[0][1]);
 687     B[1] = ROL64(A[2][2] ^ D[2], rhotates[1][2]);
 688     B[2] = ROL64(A[2][3] ^ D[3], rhotates[2][3]);
 689     B[3] = ROL64(A[2][4] ^ D[4], rhotates[3][4]);
 690     B[4] = ROL64(A[2][0] ^ D[0], rhotates[4][0]);
 691
 692     /* C[0] ^= */ A[2][0] = B[0] ^ (~B[1] & B[2]);
 693     /* C[1] ^= */ A[2][1] = B[1] ^ (~B[2] & B[3]);
 694     /* C[2] ^= */ A[2][2] = B[2] ^ (~B[3] & B[4]);
 695     /* C[3] ^= */ A[2][3] = B[3] ^ (~B[4] & B[0]);
 696     /* C[4] ^= */ A[2][4] = B[4] ^ (~B[0] & B[1]);
 697
 698     B[0] = ROL64(A[3][4] ^ D[4], rhotates[0][4]);
 699     B[1] = ROL64(A[3][0] ^ D[0], rhotates[1][0]);
 700     B[2] = ROL64(A[3][1] ^ D[1], rhotates[2][1]);
 701     B[3] = ROL64(A[3][2] ^ D[2], rhotates[3][2]);
 702     B[4] = ROL64(A[3][3] ^ D[3], rhotates[4][3]);
 703
 704     /* C[0] ^= */ A[3][0] = B[0] ^ (~B[1] & B[2]);
 705     /* C[1] ^= */ A[3][1] = B[1] ^ (~B[2] & B[3]);
 706     /* C[2] ^= */ A[3][2] = B[2] ^ (~B[3] & B[4]);
 707     /* C[3] ^= */ A[3][3] = B[3] ^ (~B[4] & B[0]);
 708     /* C[4] ^= */ A[3][4] = B[4] ^ (~B[0] & B[1]);
 709
 710     B[0] = ROL64(A[4][2] ^ D[2], rhotates[0][2]);
 711     B[1] = ROL64(A[4][3] ^ D[3], rhotates[1][3]);
 712     B[2] = ROL64(A[4][4] ^ D[4], rhotates[2][4]);
 713     B[3] = ROL64(A[4][0] ^ D[0], rhotates[3][0]);
 714     B[4] = ROL64(A[4][1] ^ D[1], rhotates[4][1]);
 715
 716     /* C[0] ^= */ A[4][0] = B[0] ^ (~B[1] & B[2]);
 717     /* C[1] ^= */ A[4][1] = B[1] ^ (~B[2] & B[3]);
 718     /* C[2] ^= */ A[4][2] = B[2] ^ (~B[3] & B[4]);
 719     /* C[3] ^= */ A[4][3] = B[3] ^ (~B[4] & B[0]);
 720     /* C[4] ^= */ A[4][4] = B[4] ^ (~B[0] & B[1]);
 721 }
 722
 723 void KeccakF1600(uint64_t A[5][5])
 724 {
 725     size_t i;
 726
 727     for (i = 0; i < 24; i += 4) {
 728         FourRounds(A, i);
 729     }
 730 }
 731
 732 #endif
 733
 734 /*
 735  * SHA3_absorb can be called multiple times, but at each invocation
 736  * largest multiple of |r| out of |len| bytes are processed. Then
 737  * remaining amount of bytes are returned. This is done to spare caller
 738  * trouble of calculating the largest multiple of |r|, effectively the
 739  * blocksize. It is commonly (1600 - 256*n)/8, e.g. 168, 136, 104, 72,
 740  * but can also be (1600 - 448)/8 = 144. All this means that message
 741  * padding and intermediate sub-block buffering, byte- or bitwise, is
 742  * caller's reponsibility.
 743  */
 744 size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
 745                    size_t r)
 746 {
 747     uint64_t *A_flat = (uint64_t *)A;
 748     size_t i, w = r / 8;
 749
 750     assert(r < (25 * sizeof(A[0][0])) && (r % 8) == 0);
 751
 752     while (len >= r) {
 753         for (i = 0; i < w; i++) {
 754             A_flat[i] ^= (uint64_t)inp[0]       | (uint64_t)inp[1] << 8  |
 755                          (uint64_t)inp[2] << 16 | (uint64_t)inp[3] << 24 |
 756                          (uint64_t)inp[4] << 32 | (uint64_t)inp[5] << 40 |
 757                          (uint64_t)inp[6] << 48 | (uint64_t)inp[7] << 56;
 758             inp += 8;
 759         }
 760         KeccakF1600(A);
 761         len -= r;
 762     }
 763
 764     return len;
 765 }
 766
 767 /*
 768  * SHA3_squeeze is called once at the end to generate |out| hash value
 769  * of |len| bytes.
 770  */
 771 void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r)
 772 {
 773     uint64_t *A_flat = (uint64_t *)A;
 774     size_t i, rem, w = r / 8;
 775
 776     assert(r < (25 * sizeof(A[0][0])) && (r % 8) == 0);
 777
 778     while (len >= r) {
 779         for (i = 0; i < w; i++) {
 780             uint64_t Ai = A_flat[i];
 781
 782             out[0] = (unsigned char)(Ai);
 783             out[1] = (unsigned char)(Ai >> 8);
 784             out[2] = (unsigned char)(Ai >> 16);
 785             out[3] = (unsigned char)(Ai >> 24);
 786             out[4] = (unsigned char)(Ai >> 32);
 787             out[5] = (unsigned char)(Ai >> 40);
 788             out[6] = (unsigned char)(Ai >> 48);
 789             out[7] = (unsigned char)(Ai >> 56);
 790             out += 8;
 791         }
 792         len -= r;
 793         if (len)
 794             KeccakF1600(A);
 795     }
 796
 797     rem = len % 8;
 798     len /= 8;
 799
 800     for (i = 0; i < len; i++) {
 801         uint64_t Ai = A_flat[i];
 802
 803         out[0] = (unsigned char)(Ai);
 804         out[1] = (unsigned char)(Ai >> 8);
 805         out[2] = (unsigned char)(Ai >> 16);
 806         out[3] = (unsigned char)(Ai >> 24);
 807         out[4] = (unsigned char)(Ai >> 32);
 808         out[5] = (unsigned char)(Ai >> 40);
 809         out[6] = (unsigned char)(Ai >> 48);
 810         out[7] = (unsigned char)(Ai >> 56);
 811         out += 8;
 812     }
 813
 814     if (rem) {
 815         uint64_t Ai = A_flat[i];
 816
 817         for (i = 0; i < rem; i++) {
 818             *out++ = (unsigned char)Ai;
 819             Ai >>= 8;
 820         }
 821     }
 822 }
 823
 824 #ifdef SELFTEST
 825 /*
 826  * Post-padding one-shot implementations would look as following:
 827  *
 828  * SHA3_224     SHA3_sponge(inp, len, out, 224/8, (1600-448)/8);
 829  * SHA3_256     SHA3_sponge(inp, len, out, 256/8, (1600-512)/8);
 830  * SHA3_384     SHA3_sponge(inp, len, out, 384/8, (1600-768)/8);
 831  * SHA3_512     SHA3_sponge(inp, len, out, 512/8, (1600-1024)/8);
 832  * SHAKE_128    SHA3_sponge(inp, len, out, d, (1600-256)/8);
 833  * SHAKE_256    SHA3_sponge(inp, len, out, d, (1600-512)/8);
 834  */
 835
 836 void SHA3_sponge(const unsigned char *inp, size_t len,
 837                  unsigned char *out, size_t d, size_t r)
 838 {
 839     uint64_t A[5][5];
 840
 841     memset(A, 0, sizeof(A));
 842     SHA3_absorb(A, inp, len, r);
 843     SHA3_squeeze(A, out, d, r);
 844 }
 845
 846 # include <stdio.h>
 847
 848 int main()
 849 {
 850     /*
 851      * This is 5-bit SHAKE128 test from http://csrc.nist.gov/groups/ST/toolkit/examples.html#aHashing
 852      */
 853     unsigned char test[168] = { '\xf3', '\x3' };
 854     unsigned char out[512];
 855     size_t i;
 856     static const unsigned char result[512] = {
 857         0x2E, 0x0A, 0xBF, 0xBA, 0x83, 0xE6, 0x72, 0x0B,
 858         0xFB, 0xC2, 0x25, 0xFF, 0x6B, 0x7A, 0xB9, 0xFF,
 859         0xCE, 0x58, 0xBA, 0x02, 0x7E, 0xE3, 0xD8, 0x98,
 860         0x76, 0x4F, 0xEF, 0x28, 0x7D, 0xDE, 0xCC, 0xCA,
 861         0x3E, 0x6E, 0x59, 0x98, 0x41, 0x1E, 0x7D, 0xDB,
 862         0x32, 0xF6, 0x75, 0x38, 0xF5, 0x00, 0xB1, 0x8C,
 863         0x8C, 0x97, 0xC4, 0x52, 0xC3, 0x70, 0xEA, 0x2C,
 864         0xF0, 0xAF, 0xCA, 0x3E, 0x05, 0xDE, 0x7E, 0x4D,
 865         0xE2, 0x7F, 0xA4, 0x41, 0xA9, 0xCB, 0x34, 0xFD,
 866         0x17, 0xC9, 0x78, 0xB4, 0x2D, 0x5B, 0x7E, 0x7F,
 867         0x9A, 0xB1, 0x8F, 0xFE, 0xFF, 0xC3, 0xC5, 0xAC,
 868         0x2F, 0x3A, 0x45, 0x5E, 0xEB, 0xFD, 0xC7, 0x6C,
 869         0xEA, 0xEB, 0x0A, 0x2C, 0xCA, 0x22, 0xEE, 0xF6,
 870         0xE6, 0x37, 0xF4, 0xCA, 0xBE, 0x5C, 0x51, 0xDE,
 871         0xD2, 0xE3, 0xFA, 0xD8, 0xB9, 0x52, 0x70, 0xA3,
 872         0x21, 0x84, 0x56, 0x64, 0xF1, 0x07, 0xD1, 0x64,
 873         0x96, 0xBB, 0x7A, 0xBF, 0xBE, 0x75, 0x04, 0xB6,
 874         0xED, 0xE2, 0xE8, 0x9E, 0x4B, 0x99, 0x6F, 0xB5,
 875         0x8E, 0xFD, 0xC4, 0x18, 0x1F, 0x91, 0x63, 0x38,
 876         0x1C, 0xBE, 0x7B, 0xC0, 0x06, 0xA7, 0xA2, 0x05,
 877         0x98, 0x9C, 0x52, 0x6C, 0xD1, 0xBD, 0x68, 0x98,
 878         0x36, 0x93, 0xB4, 0xBD, 0xC5, 0x37, 0x28, 0xB2,
 879         0x41, 0xC1, 0xCF, 0xF4, 0x2B, 0xB6, 0x11, 0x50,
 880         0x2C, 0x35, 0x20, 0x5C, 0xAB, 0xB2, 0x88, 0x75,
 881         0x56, 0x55, 0xD6, 0x20, 0xC6, 0x79, 0x94, 0xF0,
 882         0x64, 0x51, 0x18, 0x7F, 0x6F, 0xD1, 0x7E, 0x04,
 883         0x66, 0x82, 0xBA, 0x12, 0x86, 0x06, 0x3F, 0xF8,
 884         0x8F, 0xE2, 0x50, 0x8D, 0x1F, 0xCA, 0xF9, 0x03,
 885         0x5A, 0x12, 0x31, 0xAD, 0x41, 0x50, 0xA9, 0xC9,
 886         0xB2, 0x4C, 0x9B, 0x2D, 0x66, 0xB2, 0xAD, 0x1B,
 887         0xDE, 0x0B, 0xD0, 0xBB, 0xCB, 0x8B, 0xE0, 0x5B,
 888         0x83, 0x52, 0x29, 0xEF, 0x79, 0x19, 0x73, 0x73,
 889         0x23, 0x42, 0x44, 0x01, 0xE1, 0xD8, 0x37, 0xB6,
 890         0x6E, 0xB4, 0xE6, 0x30, 0xFF, 0x1D, 0xE7, 0x0C,
 891         0xB3, 0x17, 0xC2, 0xBA, 0xCB, 0x08, 0x00, 0x1D,
 892         0x34, 0x77, 0xB7, 0xA7, 0x0A, 0x57, 0x6D, 0x20,
 893         0x86, 0x90, 0x33, 0x58, 0x9D, 0x85, 0xA0, 0x1D,
 894         0xDB, 0x2B, 0x66, 0x46, 0xC0, 0x43, 0xB5, 0x9F,
 895         0xC0, 0x11, 0x31, 0x1D, 0xA6, 0x66, 0xFA, 0x5A,
 896         0xD1, 0xD6, 0x38, 0x7F, 0xA9, 0xBC, 0x40, 0x15,
 897         0xA3, 0x8A, 0x51, 0xD1, 0xDA, 0x1E, 0xA6, 0x1D,
 898         0x64, 0x8D, 0xC8, 0xE3, 0x9A, 0x88, 0xB9, 0xD6,
 899         0x22, 0xBD, 0xE2, 0x07, 0xFD, 0xAB, 0xC6, 0xF2,
 900         0x82, 0x7A, 0x88, 0x0C, 0x33, 0x0B, 0xBF, 0x6D,
 901         0xF7, 0x33, 0x77, 0x4B, 0x65, 0x3E, 0x57, 0x30,
 902         0x5D, 0x78, 0xDC, 0xE1, 0x12, 0xF1, 0x0A, 0x2C,
 903         0x71, 0xF4, 0xCD, 0xAD, 0x92, 0xED, 0x11, 0x3E,
 904         0x1C, 0xEA, 0x63, 0xB9, 0x19, 0x25, 0xED, 0x28,
 905         0x19, 0x1E, 0x6D, 0xBB, 0xB5, 0xAA, 0x5A, 0x2A,
 906         0xFD, 0xA5, 0x1F, 0xC0, 0x5A, 0x3A, 0xF5, 0x25,
 907         0x8B, 0x87, 0x66, 0x52, 0x43, 0x55, 0x0F, 0x28,
 908         0x94, 0x8A, 0xE2, 0xB8, 0xBE, 0xB6, 0xBC, 0x9C,
 909         0x77, 0x0B, 0x35, 0xF0, 0x67, 0xEA, 0xA6, 0x41,
 910         0xEF, 0xE6, 0x5B, 0x1A, 0x44, 0x90, 0x9D, 0x1B,
 911         0x14, 0x9F, 0x97, 0xEE, 0xA6, 0x01, 0x39, 0x1C,
 912         0x60, 0x9E, 0xC8, 0x1D, 0x19, 0x30, 0xF5, 0x7C,
 913         0x18, 0xA4, 0xE0, 0xFA, 0xB4, 0x91, 0xD1, 0xCA,
 914         0xDF, 0xD5, 0x04, 0x83, 0x44, 0x9E, 0xDC, 0x0F,
 915         0x07, 0xFF, 0xB2, 0x4D, 0x2C, 0x6F, 0x9A, 0x9A,
 916         0x3B, 0xFF, 0x39, 0xAE, 0x3D, 0x57, 0xF5, 0x60,
 917         0x65, 0x4D, 0x7D, 0x75, 0xC9, 0x08, 0xAB, 0xE6,
 918         0x25, 0x64, 0x75, 0x3E, 0xAC, 0x39, 0xD7, 0x50,
 919         0x3D, 0xA6, 0xD3, 0x7C, 0x2E, 0x32, 0xE1, 0xAF,
 920         0x3B, 0x8A, 0xEC, 0x8A, 0xE3, 0x06, 0x9C, 0xD9
 921     };
 922
 923     test[167] = '\x80';
 924     SHA3_sponge(test, sizeof(test), out, sizeof(out), sizeof(test));
 925
 926     /*
 927      * Rationale behind keeping output [formatted as below] is that
 928      * one should be able to redirect it to a file, then copy-n-paste
 929      * final "output val" from official example to another file, and
 930      * compare the two with diff(1).
 931      */
 932     for (i = 0; i < sizeof(out);) {
 933         printf("%02X", out[i]);
 934         printf(++i % 16 && i != sizeof(out) ? " " : "\n");
 935     }
 936
 937     if (memcmp(out,result,sizeof(out))) {
 938         fprintf(stderr,"failure\n");
 939         return 1;
 940     } else {
 941         fprintf(stderr,"success\n");
 942         return 0;
 943     }
 944 }
 945 #endif