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