crypto/whrlpool/wp_block.c

   1 /**
   2  * The Whirlpool hashing function.
   3  *
   4  * <P>
   5  * <b>References</b>
   6  *
   7  * <P>
   8  * The Whirlpool algorithm was developed by
   9  * <a href="mailto:pbarreto@scopus.com.br">Paulo S. L. M. Barreto</a> and
  10  * <a href="mailto:vincent.rijmen@cryptomathic.com">Vincent Rijmen</a>.
  11  *
  12  * See
  13  *      P.S.L.M. Barreto, V. Rijmen,
  14  *      ``The Whirlpool hashing function,''
  15  *      NESSIE submission, 2000 (tweaked version, 2001),
  16  *      <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip>
  17  *
  18  * Based on "@version 3.0 (2003.03.12)" by Paulo S.L.M. Barreto and
  19  * Vincent Rijmen. Lookup "reference implementations" on
  20  * <http://planeta.terra.com.br/informatica/paulobarreto/>
  21  *
  22  * =============================================================================
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
  25  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  26  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  31  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  32  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  33  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  34  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include "wp_locl.h"
  39 #include <string.h>
  40
  41 typedef unsigned char u8;
  42 #if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32)
  43 typedef unsigned __int64 u64;
  44 #elif defined(__arch64__)
  45 typedef unsigned long u64;
  46 #else
  47 typedef unsigned long long u64;
  48 #endif
  49
  50 #define ROUNDS  10
  51
  52 #define STRICT_ALIGNMENT
  53 #if !defined(PEDANTIC) && (defined(__i386) || defined(__i386__) || \
  54                            defined(__x86_64) || defined(__x86_64__) || \
  55                            defined(_M_IX86) || defined(_M_AMD64) || \
  56                            defined(_M_X64))
  57 /*
  58  * Well, formally there're couple of other architectures, which permit
  59  * unaligned loads, specifically those not crossing cache lines, IA-64 and
  60  * PowerPC...
  61  */
  62 # undef STRICT_ALIGNMENT
  63 #endif
  64
  65 #undef SMALL_REGISTER_BANK
  66 #if defined(__i386) || defined(__i386__) || defined(_M_IX86)
  67 # define SMALL_REGISTER_BANK
  68 # if defined(WHIRLPOOL_ASM)
  69 #  ifndef OPENSSL_SMALL_FOOTPRINT
  70 /*
  71  * it appears that for elder non-MMX
  72  * CPUs this is actually faster!
  73  */
  74 #   define OPENSSL_SMALL_FOOTPRINT
  75 #  endif
  76 #  define GO_FOR_MMX(ctx,inp,num)     do {                    \
  77         extern unsigned long OPENSSL_ia32cap_P[];               \
  78         void whirlpool_block_mmx(void *,const void *,size_t);   \
  79         if (!(OPENSSL_ia32cap_P[0] & (1<<23)))  break;          \
  80         whirlpool_block_mmx(ctx->H.c,inp,num);  return;         \
  81                                         } while (0)
  82 # endif
  83 #endif
  84
  85 #undef ROTATE
  86 #ifndef PEDANTIC
  87 # if defined(_MSC_VER)
  88 #  if defined(_WIN64)            /* applies to both IA-64 and AMD64 */
  89 #   pragma intrinsic(_rotl64)
  90 #   define ROTATE(a,n) _rotl64((a),n)
  91 #  endif
  92 # elif defined(__GNUC__) && __GNUC__>=2
  93 #  if defined(__x86_64) || defined(__x86_64__)
  94 #   if defined(L_ENDIAN)
  95 #    define ROTATE(a,n)       ({ u64 ret; asm ("rolq %1,%0"   \
  96                                    : "=r"(ret) : "J"(n),"0"(a) : "cc"); ret; })
  97 #   elif defined(B_ENDIAN)
  98        /*
  99         * Most will argue that x86_64 is always little-endian. Well, yes, but
 100         * then we have stratus.com who has modified gcc to "emulate"
 101         * big-endian on x86. Is there evidence that they [or somebody else]
 102         * won't do same for x86_64? Naturally no. And this line is waiting
 103         * ready for that brave soul:-)
 104         */
 105 #    define ROTATE(a,n)       ({ u64 ret; asm ("rorq %1,%0"   \
 106                                    : "=r"(ret) : "J"(n),"0"(a) : "cc"); ret; })
 107 #   endif
 108 #  elif defined(__ia64) || defined(__ia64__)
 109 #   if defined(L_ENDIAN)
 110 #    define ROTATE(a,n)       ({ u64 ret; asm ("shrp %0=%1,%1,%2"     \
 111                                    : "=r"(ret) : "r"(a),"M"(64-(n))); ret; })
 112 #   elif defined(B_ENDIAN)
 113 #    define ROTATE(a,n)       ({ u64 ret; asm ("shrp %0=%1,%1,%2"     \
 114                                    : "=r"(ret) : "r"(a),"M"(n)); ret; })
 115 #   endif
 116 #  endif
 117 # endif
 118 #endif
 119
 120 #if defined(OPENSSL_SMALL_FOOTPRINT)
 121 # if !defined(ROTATE)
 122 #  if defined(L_ENDIAN)         /* little-endians have to rotate left */
 123 #   define ROTATE(i,n)       ((i)<<(n) ^ (i)>>(64-n))
 124 #  elif defined(B_ENDIAN)       /* big-endians have to rotate right */
 125 #   define ROTATE(i,n)       ((i)>>(n) ^ (i)<<(64-n))
 126 #  endif
 127 # endif
 128 # if defined(ROTATE) && !defined(STRICT_ALIGNMENT)
 129 #  define STRICT_ALIGNMENT      /* ensure smallest table size */
 130 # endif
 131 #endif
 132
 133 /*
 134  * Table size depends on STRICT_ALIGNMENT and whether or not endian-
 135  * specific ROTATE macro is defined. If STRICT_ALIGNMENT is not
 136  * defined, which is normally the case on x86[_64] CPUs, the table is
 137  * 4KB large unconditionally. Otherwise if ROTATE is defined, the
 138  * table is 2KB large, and otherwise - 16KB. 2KB table requires a
 139  * whole bunch of additional rotations, but I'm willing to "trade,"
 140  * because 16KB table certainly trashes L1 cache. I wish all CPUs
 141  * could handle unaligned load as 4KB table doesn't trash the cache,
 142  * nor does it require additional rotations.
 143  */
 144 /*
 145  * Note that every Cn macro expands as two loads: one byte load and
 146  * one quadword load. One can argue that that many single-byte loads
 147  * is too excessive, as one could load a quadword and "milk" it for
 148  * eight 8-bit values instead. Well, yes, but in order to do so *and*
 149  * avoid excessive loads you have to accomodate a handful of 64-bit
 150  * values in the register bank and issue a bunch of shifts and mask.
 151  * It's a tradeoff: loads vs. shift and mask in big register bank[!].
 152  * On most CPUs eight single-byte loads are faster and I let other
 153  * ones to depend on smart compiler to fold byte loads if beneficial.
 154  * Hand-coded assembler would be another alternative:-)
 155  */
 156 #ifdef STRICT_ALIGNMENT
 157 # if defined(ROTATE)
 158 #  define N   1
 159 #  define LL(c0,c1,c2,c3,c4,c5,c6,c7) c0,c1,c2,c3,c4,c5,c6,c7
 160 #  define C0(K,i)     (Cx.q[K.c[(i)*8+0]])
 161 #  define C1(K,i)     ROTATE(Cx.q[K.c[(i)*8+1]],8)
 162 #  define C2(K,i)     ROTATE(Cx.q[K.c[(i)*8+2]],16)
 163 #  define C3(K,i)     ROTATE(Cx.q[K.c[(i)*8+3]],24)
 164 #  define C4(K,i)     ROTATE(Cx.q[K.c[(i)*8+4]],32)
 165 #  define C5(K,i)     ROTATE(Cx.q[K.c[(i)*8+5]],40)
 166 #  define C6(K,i)     ROTATE(Cx.q[K.c[(i)*8+6]],48)
 167 #  define C7(K,i)     ROTATE(Cx.q[K.c[(i)*8+7]],56)
 168 # else
 169 #  define N   8
 170 #  define LL(c0,c1,c2,c3,c4,c5,c6,c7) c0,c1,c2,c3,c4,c5,c6,c7, \
 171                                         c7,c0,c1,c2,c3,c4,c5,c6, \
 172                                         c6,c7,c0,c1,c2,c3,c4,c5, \
 173                                         c5,c6,c7,c0,c1,c2,c3,c4, \
 174                                         c4,c5,c6,c7,c0,c1,c2,c3, \
 175                                         c3,c4,c5,c6,c7,c0,c1,c2, \
 176                                         c2,c3,c4,c5,c6,c7,c0,c1, \
 177                                         c1,c2,c3,c4,c5,c6,c7,c0
 178 #  define C0(K,i)     (Cx.q[0+8*K.c[(i)*8+0]])
 179 #  define C1(K,i)     (Cx.q[1+8*K.c[(i)*8+1]])
 180 #  define C2(K,i)     (Cx.q[2+8*K.c[(i)*8+2]])
 181 #  define C3(K,i)     (Cx.q[3+8*K.c[(i)*8+3]])
 182 #  define C4(K,i)     (Cx.q[4+8*K.c[(i)*8+4]])
 183 #  define C5(K,i)     (Cx.q[5+8*K.c[(i)*8+5]])
 184 #  define C6(K,i)     (Cx.q[6+8*K.c[(i)*8+6]])
 185 #  define C7(K,i)     (Cx.q[7+8*K.c[(i)*8+7]])
 186 # endif
 187 #else
 188 # define N     2
 189 # define LL(c0,c1,c2,c3,c4,c5,c6,c7)   c0,c1,c2,c3,c4,c5,c6,c7, \
 190                                         c0,c1,c2,c3,c4,c5,c6,c7
 191 # define C0(K,i)       (((u64*)(Cx.c+0))[2*K.c[(i)*8+0]])
 192 # define C1(K,i)       (((u64*)(Cx.c+7))[2*K.c[(i)*8+1]])
 193 # define C2(K,i)       (((u64*)(Cx.c+6))[2*K.c[(i)*8+2]])
 194 # define C3(K,i)       (((u64*)(Cx.c+5))[2*K.c[(i)*8+3]])
 195 # define C4(K,i)       (((u64*)(Cx.c+4))[2*K.c[(i)*8+4]])
 196 # define C5(K,i)       (((u64*)(Cx.c+3))[2*K.c[(i)*8+5]])
 197 # define C6(K,i)       (((u64*)(Cx.c+2))[2*K.c[(i)*8+6]])
 198 # define C7(K,i)       (((u64*)(Cx.c+1))[2*K.c[(i)*8+7]])
 199 #endif
 200
 201 static const
 202     union {
 203     u8 c[(256 * N + ROUNDS) * sizeof(u64)];
 204     u64 q[(256 * N + ROUNDS)];
 205 } Cx = {
 206         {
 207             /* Note endian-neutral representation:-) */
 208             LL(0x18, 0x18, 0x60, 0x18, 0xc0, 0x78, 0x30, 0xd8),
 209             LL(0x23, 0x23, 0x8c, 0x23, 0x05, 0xaf, 0x46, 0x26),
 210             LL(0xc6, 0xc6, 0x3f, 0xc6, 0x7e, 0xf9, 0x91, 0xb8),
 211             LL(0xe8, 0xe8, 0x87, 0xe8, 0x13, 0x6f, 0xcd, 0xfb),
 212             LL(0x87, 0x87, 0x26, 0x87, 0x4c, 0xa1, 0x13, 0xcb),
 213             LL(0xb8, 0xb8, 0xda, 0xb8, 0xa9, 0x62, 0x6d, 0x11),
 214             LL(0x01, 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, 0x09),
 215             LL(0x4f, 0x4f, 0x21, 0x4f, 0x42, 0x6e, 0x9e, 0x0d),
 216             LL(0x36, 0x36, 0xd8, 0x36, 0xad, 0xee, 0x6c, 0x9b),
 217             LL(0xa6, 0xa6, 0xa2, 0xa6, 0x59, 0x04, 0x51, 0xff),
 218             LL(0xd2, 0xd2, 0x6f, 0xd2, 0xde, 0xbd, 0xb9, 0x0c),
 219             LL(0xf5, 0xf5, 0xf3, 0xf5, 0xfb, 0x06, 0xf7, 0x0e),
 220             LL(0x79, 0x79, 0xf9, 0x79, 0xef, 0x80, 0xf2, 0x96),
 221             LL(0x6f, 0x6f, 0xa1, 0x6f, 0x5f, 0xce, 0xde, 0x30),
 222             LL(0x91, 0x91, 0x7e, 0x91, 0xfc, 0xef, 0x3f, 0x6d),
 223             LL(0x52, 0x52, 0x55, 0x52, 0xaa, 0x07, 0xa4, 0xf8),
 224             LL(0x60, 0x60, 0x9d, 0x60, 0x27, 0xfd, 0xc0, 0x47),
 225             LL(0xbc, 0xbc, 0xca, 0xbc, 0x89, 0x76, 0x65, 0x35),
 226             LL(0x9b, 0x9b, 0x56, 0x9b, 0xac, 0xcd, 0x2b, 0x37),
 227             LL(0x8e, 0x8e, 0x02, 0x8e, 0x04, 0x8c, 0x01, 0x8a),
 228             LL(0xa3, 0xa3, 0xb6, 0xa3, 0x71, 0x15, 0x5b, 0xd2),
 229             LL(0x0c, 0x0c, 0x30, 0x0c, 0x60, 0x3c, 0x18, 0x6c),
 230             LL(0x7b, 0x7b, 0xf1, 0x7b, 0xff, 0x8a, 0xf6, 0x84),
 231             LL(0x35, 0x35, 0xd4, 0x35, 0xb5, 0xe1, 0x6a, 0x80),
 232             LL(0x1d, 0x1d, 0x74, 0x1d, 0xe8, 0x69, 0x3a, 0xf5),
 233             LL(0xe0, 0xe0, 0xa7, 0xe0, 0x53, 0x47, 0xdd, 0xb3),
 234             LL(0xd7, 0xd7, 0x7b, 0xd7, 0xf6, 0xac, 0xb3, 0x21),
 235             LL(0xc2, 0xc2, 0x2f, 0xc2, 0x5e, 0xed, 0x99, 0x9c),
 236             LL(0x2e, 0x2e, 0xb8, 0x2e, 0x6d, 0x96, 0x5c, 0x43),
 237             LL(0x4b, 0x4b, 0x31, 0x4b, 0x62, 0x7a, 0x96, 0x29),
 238             LL(0xfe, 0xfe, 0xdf, 0xfe, 0xa3, 0x21, 0xe1, 0x5d),
 239             LL(0x57, 0x57, 0x41, 0x57, 0x82, 0x16, 0xae, 0xd5),
 240             LL(0x15, 0x15, 0x54, 0x15, 0xa8, 0x41, 0x2a, 0xbd),
 241             LL(0x77, 0x77, 0xc1, 0x77, 0x9f, 0xb6, 0xee, 0xe8),
 242             LL(0x37, 0x37, 0xdc, 0x37, 0xa5, 0xeb, 0x6e, 0x92),
 243             LL(0xe5, 0xe5, 0xb3, 0xe5, 0x7b, 0x56, 0xd7, 0x9e),
 244             LL(0x9f, 0x9f, 0x46, 0x9f, 0x8c, 0xd9, 0x23, 0x13),
 245             LL(0xf0, 0xf0, 0xe7, 0xf0, 0xd3, 0x17, 0xfd, 0x23),
 246             LL(0x4a, 0x4a, 0x35, 0x4a, 0x6a, 0x7f, 0x94, 0x20),
 247             LL(0xda, 0xda, 0x4f, 0xda, 0x9e, 0x95, 0xa9, 0x44),
 248             LL(0x58, 0x58, 0x7d, 0x58, 0xfa, 0x25, 0xb0, 0xa2),
 249             LL(0xc9, 0xc9, 0x03, 0xc9, 0x06, 0xca, 0x8f, 0xcf),
 250             LL(0x29, 0x29, 0xa4, 0x29, 0x55, 0x8d, 0x52, 0x7c),
 251             LL(0x0a, 0x0a, 0x28, 0x0a, 0x50, 0x22, 0x14, 0x5a),
 252             LL(0xb1, 0xb1, 0xfe, 0xb1, 0xe1, 0x4f, 0x7f, 0x50),
 253             LL(0xa0, 0xa0, 0xba, 0xa0, 0x69, 0x1a, 0x5d, 0xc9),
 254             LL(0x6b, 0x6b, 0xb1, 0x6b, 0x7f, 0xda, 0xd6, 0x14),
 255             LL(0x85, 0x85, 0x2e, 0x85, 0x5c, 0xab, 0x17, 0xd9),
 256             LL(0xbd, 0xbd, 0xce, 0xbd, 0x81, 0x73, 0x67, 0x3c),
 257             LL(0x5d, 0x5d, 0x69, 0x5d, 0xd2, 0x34, 0xba, 0x8f),
 258             LL(0x10, 0x10, 0x40, 0x10, 0x80, 0x50, 0x20, 0x90),
 259             LL(0xf4, 0xf4, 0xf7, 0xf4, 0xf3, 0x03, 0xf5, 0x07),
 260             LL(0xcb, 0xcb, 0x0b, 0xcb, 0x16, 0xc0, 0x8b, 0xdd),
 261             LL(0x3e, 0x3e, 0xf8, 0x3e, 0xed, 0xc6, 0x7c, 0xd3),
 262             LL(0x05, 0x05, 0x14, 0x05, 0x28, 0x11, 0x0a, 0x2d),
 263             LL(0x67, 0x67, 0x81, 0x67, 0x1f, 0xe6, 0xce, 0x78),
 264             LL(0xe4, 0xe4, 0xb7, 0xe4, 0x73, 0x53, 0xd5, 0x97),
 265             LL(0x27, 0x27, 0x9c, 0x27, 0x25, 0xbb, 0x4e, 0x02),
 266             LL(0x41, 0x41, 0x19, 0x41, 0x32, 0x58, 0x82, 0x73),
 267             LL(0x8b, 0x8b, 0x16, 0x8b, 0x2c, 0x9d, 0x0b, 0xa7),
 268             LL(0xa7, 0xa7, 0xa6, 0xa7, 0x51, 0x01, 0x53, 0xf6),
 269             LL(0x7d, 0x7d, 0xe9, 0x7d, 0xcf, 0x94, 0xfa, 0xb2),
 270             LL(0x95, 0x95, 0x6e, 0x95, 0xdc, 0xfb, 0x37, 0x49),
 271             LL(0xd8, 0xd8, 0x47, 0xd8, 0x8e, 0x9f, 0xad, 0x56),
 272             LL(0xfb, 0xfb, 0xcb, 0xfb, 0x8b, 0x30, 0xeb, 0x70),
 273             LL(0xee, 0xee, 0x9f, 0xee, 0x23, 0x71, 0xc1, 0xcd),
 274             LL(0x7c, 0x7c, 0xed, 0x7c, 0xc7, 0x91, 0xf8, 0xbb),
 275             LL(0x66, 0x66, 0x85, 0x66, 0x17, 0xe3, 0xcc, 0x71),
 276             LL(0xdd, 0xdd, 0x53, 0xdd, 0xa6, 0x8e, 0xa7, 0x7b),
 277             LL(0x17, 0x17, 0x5c, 0x17, 0xb8, 0x4b, 0x2e, 0xaf),
 278             LL(0x47, 0x47, 0x01, 0x47, 0x02, 0x46, 0x8e, 0x45),
 279             LL(0x9e, 0x9e, 0x42, 0x9e, 0x84, 0xdc, 0x21, 0x1a),
 280             LL(0xca, 0xca, 0x0f, 0xca, 0x1e, 0xc5, 0x89, 0xd4),
 281             LL(0x2d, 0x2d, 0xb4, 0x2d, 0x75, 0x99, 0x5a, 0x58),
 282             LL(0xbf, 0xbf, 0xc6, 0xbf, 0x91, 0x79, 0x63, 0x2e),
 283             LL(0x07, 0x07, 0x1c, 0x07, 0x38, 0x1b, 0x0e, 0x3f),
 284             LL(0xad, 0xad, 0x8e, 0xad, 0x01, 0x23, 0x47, 0xac),
 285             LL(0x5a, 0x5a, 0x75, 0x5a, 0xea, 0x2f, 0xb4, 0xb0),
 286             LL(0x83, 0x83, 0x36, 0x83, 0x6c, 0xb5, 0x1b, 0xef),
 287             LL(0x33, 0x33, 0xcc, 0x33, 0x85, 0xff, 0x66, 0xb6),
 288             LL(0x63, 0x63, 0x91, 0x63, 0x3f, 0xf2, 0xc6, 0x5c),
 289             LL(0x02, 0x02, 0x08, 0x02, 0x10, 0x0a, 0x04, 0x12),
 290             LL(0xaa, 0xaa, 0x92, 0xaa, 0x39, 0x38, 0x49, 0x93),
 291             LL(0x71, 0x71, 0xd9, 0x71, 0xaf, 0xa8, 0xe2, 0xde),
 292             LL(0xc8, 0xc8, 0x07, 0xc8, 0x0e, 0xcf, 0x8d, 0xc6),
 293             LL(0x19, 0x19, 0x64, 0x19, 0xc8, 0x7d, 0x32, 0xd1),
 294             LL(0x49, 0x49, 0x39, 0x49, 0x72, 0x70, 0x92, 0x3b),
 295             LL(0xd9, 0xd9, 0x43, 0xd9, 0x86, 0x9a, 0xaf, 0x5f),
 296             LL(0xf2, 0xf2, 0xef, 0xf2, 0xc3, 0x1d, 0xf9, 0x31),
 297             LL(0xe3, 0xe3, 0xab, 0xe3, 0x4b, 0x48, 0xdb, 0xa8),
 298             LL(0x5b, 0x5b, 0x71, 0x5b, 0xe2, 0x2a, 0xb6, 0xb9),
 299             LL(0x88, 0x88, 0x1a, 0x88, 0x34, 0x92, 0x0d, 0xbc),
 300             LL(0x9a, 0x9a, 0x52, 0x9a, 0xa4, 0xc8, 0x29, 0x3e),
 301             LL(0x26, 0x26, 0x98, 0x26, 0x2d, 0xbe, 0x4c, 0x0b),
 302             LL(0x32, 0x32, 0xc8, 0x32, 0x8d, 0xfa, 0x64, 0xbf),
 303             LL(0xb0, 0xb0, 0xfa, 0xb0, 0xe9, 0x4a, 0x7d, 0x59),
 304             LL(0xe9, 0xe9, 0x83, 0xe9, 0x1b, 0x6a, 0xcf, 0xf2),
 305             LL(0x0f, 0x0f, 0x3c, 0x0f, 0x78, 0x33, 0x1e, 0x77),
 306             LL(0xd5, 0xd5, 0x73, 0xd5, 0xe6, 0xa6, 0xb7, 0x33),
 307             LL(0x80, 0x80, 0x3a, 0x80, 0x74, 0xba, 0x1d, 0xf4),
 308             LL(0xbe, 0xbe, 0xc2, 0xbe, 0x99, 0x7c, 0x61, 0x27),
 309             LL(0xcd, 0xcd, 0x13, 0xcd, 0x26, 0xde, 0x87, 0xeb),
 310             LL(0x34, 0x34, 0xd0, 0x34, 0xbd, 0xe4, 0x68, 0x89),
 311             LL(0x48, 0x48, 0x3d, 0x48, 0x7a, 0x75, 0x90, 0x32),
 312             LL(0xff, 0xff, 0xdb, 0xff, 0xab, 0x24, 0xe3, 0x54),
 313             LL(0x7a, 0x7a, 0xf5, 0x7a, 0xf7, 0x8f, 0xf4, 0x8d),
 314             LL(0x90, 0x90, 0x7a, 0x90, 0xf4, 0xea, 0x3d, 0x64),
 315             LL(0x5f, 0x5f, 0x61, 0x5f, 0xc2, 0x3e, 0xbe, 0x9d),
 316             LL(0x20, 0x20, 0x80, 0x20, 0x1d, 0xa0, 0x40, 0x3d),
 317             LL(0x68, 0x68, 0xbd, 0x68, 0x67, 0xd5, 0xd0, 0x0f),
 318             LL(0x1a, 0x1a, 0x68, 0x1a, 0xd0, 0x72, 0x34, 0xca),
 319             LL(0xae, 0xae, 0x82, 0xae, 0x19, 0x2c, 0x41, 0xb7),
 320             LL(0xb4, 0xb4, 0xea, 0xb4, 0xc9, 0x5e, 0x75, 0x7d),
 321             LL(0x54, 0x54, 0x4d, 0x54, 0x9a, 0x19, 0xa8, 0xce),
 322             LL(0x93, 0x93, 0x76, 0x93, 0xec, 0xe5, 0x3b, 0x7f),
 323             LL(0x22, 0x22, 0x88, 0x22, 0x0d, 0xaa, 0x44, 0x2f),
 324             LL(0x64, 0x64, 0x8d, 0x64, 0x07, 0xe9, 0xc8, 0x63),
 325             LL(0xf1, 0xf1, 0xe3, 0xf1, 0xdb, 0x12, 0xff, 0x2a),
 326             LL(0x73, 0x73, 0xd1, 0x73, 0xbf, 0xa2, 0xe6, 0xcc),
 327             LL(0x12, 0x12, 0x48, 0x12, 0x90, 0x5a, 0x24, 0x82),
 328             LL(0x40, 0x40, 0x1d, 0x40, 0x3a, 0x5d, 0x80, 0x7a),
 329             LL(0x08, 0x08, 0x20, 0x08, 0x40, 0x28, 0x10, 0x48),
 330             LL(0xc3, 0xc3, 0x2b, 0xc3, 0x56, 0xe8, 0x9b, 0x95),
 331             LL(0xec, 0xec, 0x97, 0xec, 0x33, 0x7b, 0xc5, 0xdf),
 332             LL(0xdb, 0xdb, 0x4b, 0xdb, 0x96, 0x90, 0xab, 0x4d),
 333             LL(0xa1, 0xa1, 0xbe, 0xa1, 0x61, 0x1f, 0x5f, 0xc0),
 334             LL(0x8d, 0x8d, 0x0e, 0x8d, 0x1c, 0x83, 0x07, 0x91),
 335             LL(0x3d, 0x3d, 0xf4, 0x3d, 0xf5, 0xc9, 0x7a, 0xc8),
 336             LL(0x97, 0x97, 0x66, 0x97, 0xcc, 0xf1, 0x33, 0x5b),
 337             LL(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
 338             LL(0xcf, 0xcf, 0x1b, 0xcf, 0x36, 0xd4, 0x83, 0xf9),
 339             LL(0x2b, 0x2b, 0xac, 0x2b, 0x45, 0x87, 0x56, 0x6e),
 340             LL(0x76, 0x76, 0xc5, 0x76, 0x97, 0xb3, 0xec, 0xe1),
 341             LL(0x82, 0x82, 0x32, 0x82, 0x64, 0xb0, 0x19, 0xe6),
 342             LL(0xd6, 0xd6, 0x7f, 0xd6, 0xfe, 0xa9, 0xb1, 0x28),
 343             LL(0x1b, 0x1b, 0x6c, 0x1b, 0xd8, 0x77, 0x36, 0xc3),
 344             LL(0xb5, 0xb5, 0xee, 0xb5, 0xc1, 0x5b, 0x77, 0x74),
 345             LL(0xaf, 0xaf, 0x86, 0xaf, 0x11, 0x29, 0x43, 0xbe),
 346             LL(0x6a, 0x6a, 0xb5, 0x6a, 0x77, 0xdf, 0xd4, 0x1d),
 347             LL(0x50, 0x50, 0x5d, 0x50, 0xba, 0x0d, 0xa0, 0xea),
 348             LL(0x45, 0x45, 0x09, 0x45, 0x12, 0x4c, 0x8a, 0x57),
 349             LL(0xf3, 0xf3, 0xeb, 0xf3, 0xcb, 0x18, 0xfb, 0x38),
 350             LL(0x30, 0x30, 0xc0, 0x30, 0x9d, 0xf0, 0x60, 0xad),
 351             LL(0xef, 0xef, 0x9b, 0xef, 0x2b, 0x74, 0xc3, 0xc4),
 352             LL(0x3f, 0x3f, 0xfc, 0x3f, 0xe5, 0xc3, 0x7e, 0xda),
 353             LL(0x55, 0x55, 0x49, 0x55, 0x92, 0x1c, 0xaa, 0xc7),
 354             LL(0xa2, 0xa2, 0xb2, 0xa2, 0x79, 0x10, 0x59, 0xdb),
 355             LL(0xea, 0xea, 0x8f, 0xea, 0x03, 0x65, 0xc9, 0xe9),
 356             LL(0x65, 0x65, 0x89, 0x65, 0x0f, 0xec, 0xca, 0x6a),
 357             LL(0xba, 0xba, 0xd2, 0xba, 0xb9, 0x68, 0x69, 0x03),
 358             LL(0x2f, 0x2f, 0xbc, 0x2f, 0x65, 0x93, 0x5e, 0x4a),
 359             LL(0xc0, 0xc0, 0x27, 0xc0, 0x4e, 0xe7, 0x9d, 0x8e),
 360             LL(0xde, 0xde, 0x5f, 0xde, 0xbe, 0x81, 0xa1, 0x60),
 361             LL(0x1c, 0x1c, 0x70, 0x1c, 0xe0, 0x6c, 0x38, 0xfc),
 362             LL(0xfd, 0xfd, 0xd3, 0xfd, 0xbb, 0x2e, 0xe7, 0x46),
 363             LL(0x4d, 0x4d, 0x29, 0x4d, 0x52, 0x64, 0x9a, 0x1f),
 364             LL(0x92, 0x92, 0x72, 0x92, 0xe4, 0xe0, 0x39, 0x76),
 365             LL(0x75, 0x75, 0xc9, 0x75, 0x8f, 0xbc, 0xea, 0xfa),
 366             LL(0x06, 0x06, 0x18, 0x06, 0x30, 0x1e, 0x0c, 0x36),
 367             LL(0x8a, 0x8a, 0x12, 0x8a, 0x24, 0x98, 0x09, 0xae),
 368             LL(0xb2, 0xb2, 0xf2, 0xb2, 0xf9, 0x40, 0x79, 0x4b),
 369             LL(0xe6, 0xe6, 0xbf, 0xe6, 0x63, 0x59, 0xd1, 0x85),
 370             LL(0x0e, 0x0e, 0x38, 0x0e, 0x70, 0x36, 0x1c, 0x7e),
 371             LL(0x1f, 0x1f, 0x7c, 0x1f, 0xf8, 0x63, 0x3e, 0xe7),
 372             LL(0x62, 0x62, 0x95, 0x62, 0x37, 0xf7, 0xc4, 0x55),
 373             LL(0xd4, 0xd4, 0x77, 0xd4, 0xee, 0xa3, 0xb5, 0x3a),
 374             LL(0xa8, 0xa8, 0x9a, 0xa8, 0x29, 0x32, 0x4d, 0x81),
 375             LL(0x96, 0x96, 0x62, 0x96, 0xc4, 0xf4, 0x31, 0x52),
 376             LL(0xf9, 0xf9, 0xc3, 0xf9, 0x9b, 0x3a, 0xef, 0x62),
 377             LL(0xc5, 0xc5, 0x33, 0xc5, 0x66, 0xf6, 0x97, 0xa3),
 378             LL(0x25, 0x25, 0x94, 0x25, 0x35, 0xb1, 0x4a, 0x10),
 379             LL(0x59, 0x59, 0x79, 0x59, 0xf2, 0x20, 0xb2, 0xab),
 380             LL(0x84, 0x84, 0x2a, 0x84, 0x54, 0xae, 0x15, 0xd0),
 381             LL(0x72, 0x72, 0xd5, 0x72, 0xb7, 0xa7, 0xe4, 0xc5),
 382             LL(0x39, 0x39, 0xe4, 0x39, 0xd5, 0xdd, 0x72, 0xec),
 383             LL(0x4c, 0x4c, 0x2d, 0x4c, 0x5a, 0x61, 0x98, 0x16),
 384             LL(0x5e, 0x5e, 0x65, 0x5e, 0xca, 0x3b, 0xbc, 0x94),
 385             LL(0x78, 0x78, 0xfd, 0x78, 0xe7, 0x85, 0xf0, 0x9f),
 386             LL(0x38, 0x38, 0xe0, 0x38, 0xdd, 0xd8, 0x70, 0xe5),
 387             LL(0x8c, 0x8c, 0x0a, 0x8c, 0x14, 0x86, 0x05, 0x98),
 388             LL(0xd1, 0xd1, 0x63, 0xd1, 0xc6, 0xb2, 0xbf, 0x17),
 389             LL(0xa5, 0xa5, 0xae, 0xa5, 0x41, 0x0b, 0x57, 0xe4),
 390             LL(0xe2, 0xe2, 0xaf, 0xe2, 0x43, 0x4d, 0xd9, 0xa1),
 391             LL(0x61, 0x61, 0x99, 0x61, 0x2f, 0xf8, 0xc2, 0x4e),
 392             LL(0xb3, 0xb3, 0xf6, 0xb3, 0xf1, 0x45, 0x7b, 0x42),
 393             LL(0x21, 0x21, 0x84, 0x21, 0x15, 0xa5, 0x42, 0x34),
 394             LL(0x9c, 0x9c, 0x4a, 0x9c, 0x94, 0xd6, 0x25, 0x08),
 395             LL(0x1e, 0x1e, 0x78, 0x1e, 0xf0, 0x66, 0x3c, 0xee),
 396             LL(0x43, 0x43, 0x11, 0x43, 0x22, 0x52, 0x86, 0x61),
 397             LL(0xc7, 0xc7, 0x3b, 0xc7, 0x76, 0xfc, 0x93, 0xb1),
 398             LL(0xfc, 0xfc, 0xd7, 0xfc, 0xb3, 0x2b, 0xe5, 0x4f),
 399             LL(0x04, 0x04, 0x10, 0x04, 0x20, 0x14, 0x08, 0x24),
 400             LL(0x51, 0x51, 0x59, 0x51, 0xb2, 0x08, 0xa2, 0xe3),
 401             LL(0x99, 0x99, 0x5e, 0x99, 0xbc, 0xc7, 0x2f, 0x25),
 402             LL(0x6d, 0x6d, 0xa9, 0x6d, 0x4f, 0xc4, 0xda, 0x22),
 403             LL(0x0d, 0x0d, 0x34, 0x0d, 0x68, 0x39, 0x1a, 0x65),
 404             LL(0xfa, 0xfa, 0xcf, 0xfa, 0x83, 0x35, 0xe9, 0x79),
 405             LL(0xdf, 0xdf, 0x5b, 0xdf, 0xb6, 0x84, 0xa3, 0x69),
 406             LL(0x7e, 0x7e, 0xe5, 0x7e, 0xd7, 0x9b, 0xfc, 0xa9),
 407             LL(0x24, 0x24, 0x90, 0x24, 0x3d, 0xb4, 0x48, 0x19),
 408             LL(0x3b, 0x3b, 0xec, 0x3b, 0xc5, 0xd7, 0x76, 0xfe),
 409             LL(0xab, 0xab, 0x96, 0xab, 0x31, 0x3d, 0x4b, 0x9a),
 410             LL(0xce, 0xce, 0x1f, 0xce, 0x3e, 0xd1, 0x81, 0xf0),
 411             LL(0x11, 0x11, 0x44, 0x11, 0x88, 0x55, 0x22, 0x99),
 412             LL(0x8f, 0x8f, 0x06, 0x8f, 0x0c, 0x89, 0x03, 0x83),
 413             LL(0x4e, 0x4e, 0x25, 0x4e, 0x4a, 0x6b, 0x9c, 0x04),
 414             LL(0xb7, 0xb7, 0xe6, 0xb7, 0xd1, 0x51, 0x73, 0x66),
 415             LL(0xeb, 0xeb, 0x8b, 0xeb, 0x0b, 0x60, 0xcb, 0xe0),
 416             LL(0x3c, 0x3c, 0xf0, 0x3c, 0xfd, 0xcc, 0x78, 0xc1),
 417             LL(0x81, 0x81, 0x3e, 0x81, 0x7c, 0xbf, 0x1f, 0xfd),
 418             LL(0x94, 0x94, 0x6a, 0x94, 0xd4, 0xfe, 0x35, 0x40),
 419             LL(0xf7, 0xf7, 0xfb, 0xf7, 0xeb, 0x0c, 0xf3, 0x1c),
 420             LL(0xb9, 0xb9, 0xde, 0xb9, 0xa1, 0x67, 0x6f, 0x18),
 421             LL(0x13, 0x13, 0x4c, 0x13, 0x98, 0x5f, 0x26, 0x8b),
 422             LL(0x2c, 0x2c, 0xb0, 0x2c, 0x7d, 0x9c, 0x58, 0x51),
 423             LL(0xd3, 0xd3, 0x6b, 0xd3, 0xd6, 0xb8, 0xbb, 0x05),
 424             LL(0xe7, 0xe7, 0xbb, 0xe7, 0x6b, 0x5c, 0xd3, 0x8c),
 425             LL(0x6e, 0x6e, 0xa5, 0x6e, 0x57, 0xcb, 0xdc, 0x39),
 426             LL(0xc4, 0xc4, 0x37, 0xc4, 0x6e, 0xf3, 0x95, 0xaa),
 427             LL(0x03, 0x03, 0x0c, 0x03, 0x18, 0x0f, 0x06, 0x1b),
 428             LL(0x56, 0x56, 0x45, 0x56, 0x8a, 0x13, 0xac, 0xdc),
 429             LL(0x44, 0x44, 0x0d, 0x44, 0x1a, 0x49, 0x88, 0x5e),
 430             LL(0x7f, 0x7f, 0xe1, 0x7f, 0xdf, 0x9e, 0xfe, 0xa0),
 431             LL(0xa9, 0xa9, 0x9e, 0xa9, 0x21, 0x37, 0x4f, 0x88),
 432             LL(0x2a, 0x2a, 0xa8, 0x2a, 0x4d, 0x82, 0x54, 0x67),
 433             LL(0xbb, 0xbb, 0xd6, 0xbb, 0xb1, 0x6d, 0x6b, 0x0a),
 434             LL(0xc1, 0xc1, 0x23, 0xc1, 0x46, 0xe2, 0x9f, 0x87),
 435             LL(0x53, 0x53, 0x51, 0x53, 0xa2, 0x02, 0xa6, 0xf1),
 436             LL(0xdc, 0xdc, 0x57, 0xdc, 0xae, 0x8b, 0xa5, 0x72),
 437             LL(0x0b, 0x0b, 0x2c, 0x0b, 0x58, 0x27, 0x16, 0x53),
 438             LL(0x9d, 0x9d, 0x4e, 0x9d, 0x9c, 0xd3, 0x27, 0x01),
 439             LL(0x6c, 0x6c, 0xad, 0x6c, 0x47, 0xc1, 0xd8, 0x2b),
 440             LL(0x31, 0x31, 0xc4, 0x31, 0x95, 0xf5, 0x62, 0xa4),
 441             LL(0x74, 0x74, 0xcd, 0x74, 0x87, 0xb9, 0xe8, 0xf3),
 442             LL(0xf6, 0xf6, 0xff, 0xf6, 0xe3, 0x09, 0xf1, 0x15),
 443             LL(0x46, 0x46, 0x05, 0x46, 0x0a, 0x43, 0x8c, 0x4c),
 444             LL(0xac, 0xac, 0x8a, 0xac, 0x09, 0x26, 0x45, 0xa5),
 445             LL(0x89, 0x89, 0x1e, 0x89, 0x3c, 0x97, 0x0f, 0xb5),
 446             LL(0x14, 0x14, 0x50, 0x14, 0xa0, 0x44, 0x28, 0xb4),
 447             LL(0xe1, 0xe1, 0xa3, 0xe1, 0x5b, 0x42, 0xdf, 0xba),
 448             LL(0x16, 0x16, 0x58, 0x16, 0xb0, 0x4e, 0x2c, 0xa6),
 449             LL(0x3a, 0x3a, 0xe8, 0x3a, 0xcd, 0xd2, 0x74, 0xf7),
 450             LL(0x69, 0x69, 0xb9, 0x69, 0x6f, 0xd0, 0xd2, 0x06),
 451             LL(0x09, 0x09, 0x24, 0x09, 0x48, 0x2d, 0x12, 0x41),
 452             LL(0x70, 0x70, 0xdd, 0x70, 0xa7, 0xad, 0xe0, 0xd7),
 453             LL(0xb6, 0xb6, 0xe2, 0xb6, 0xd9, 0x54, 0x71, 0x6f),
 454             LL(0xd0, 0xd0, 0x67, 0xd0, 0xce, 0xb7, 0xbd, 0x1e),
 455             LL(0xed, 0xed, 0x93, 0xed, 0x3b, 0x7e, 0xc7, 0xd6),
 456             LL(0xcc, 0xcc, 0x17, 0xcc, 0x2e, 0xdb, 0x85, 0xe2),
 457             LL(0x42, 0x42, 0x15, 0x42, 0x2a, 0x57, 0x84, 0x68),
 458             LL(0x98, 0x98, 0x5a, 0x98, 0xb4, 0xc2, 0x2d, 0x2c),
 459             LL(0xa4, 0xa4, 0xaa, 0xa4, 0x49, 0x0e, 0x55, 0xed),
 460             LL(0x28, 0x28, 0xa0, 0x28, 0x5d, 0x88, 0x50, 0x75),
 461             LL(0x5c, 0x5c, 0x6d, 0x5c, 0xda, 0x31, 0xb8, 0x86),
 462             LL(0xf8, 0xf8, 0xc7, 0xf8, 0x93, 0x3f, 0xed, 0x6b),
 463             LL(0x86, 0x86, 0x22, 0x86, 0x44, 0xa4, 0x11, 0xc2),
 464 #define RC      (&(Cx.q[256*N]))
 465             0x18, 0x23, 0xc6, 0xe8, 0x87, 0xb8, 0x01, 0x4f,
 466             /* rc[ROUNDS] */
 467             0x36, 0xa6, 0xd2, 0xf5, 0x79, 0x6f, 0x91, 0x52, 0x60, 0xbc, 0x9b,
 468             0x8e, 0xa3, 0x0c, 0x7b, 0x35, 0x1d, 0xe0, 0xd7, 0xc2, 0x2e, 0x4b,
 469             0xfe, 0x57, 0x15, 0x77, 0x37, 0xe5, 0x9f, 0xf0, 0x4a, 0xda, 0x58,
 470             0xc9, 0x29, 0x0a, 0xb1, 0xa0, 0x6b, 0x85, 0xbd, 0x5d, 0x10, 0xf4,
 471             0xcb, 0x3e, 0x05, 0x67, 0xe4, 0x27, 0x41, 0x8b, 0xa7, 0x7d, 0x95,
 472             0xd8, 0xfb, 0xee, 0x7c, 0x66, 0xdd, 0x17, 0x47, 0x9e, 0xca, 0x2d,
 473             0xbf, 0x07, 0xad, 0x5a, 0x83, 0x33
 474         }
 475     };
 476
 477 void whirlpool_block(WHIRLPOOL_CTX *ctx, const void *inp, size_t n)
 478 {
 479     int r;
 480     const u8 *p = inp;
 481     union {
 482         u64 q[8];
 483         u8 c[64];
 484     } S, K, *H = (void *)ctx->H.q;
 485
 486 #ifdef GO_FOR_MMX
 487     GO_FOR_MMX(ctx, inp, n);
 488 #endif
 489     do {
 490 #ifdef OPENSSL_SMALL_FOOTPRINT
 491         u64 L[8];
 492         int i;
 493
 494         for (i = 0; i < 64; i++)
 495             S.c[i] = (K.c[i] = H->c[i]) ^ p[i];
 496         for (r = 0; r < ROUNDS; r++) {
 497             for (i = 0; i < 8; i++) {
 498                 L[i] = i ? 0 : RC[r];
 499                 L[i] ^= C0(K, i) ^ C1(K, (i - 1) & 7) ^
 500                     C2(K, (i - 2) & 7) ^ C3(K, (i - 3) & 7) ^
 501                     C4(K, (i - 4) & 7) ^ C5(K, (i - 5) & 7) ^
 502                     C6(K, (i - 6) & 7) ^ C7(K, (i - 7) & 7);
 503             }
 504             memcpy(K.q, L, 64);
 505             for (i = 0; i < 8; i++) {
 506                 L[i] ^= C0(S, i) ^ C1(S, (i - 1) & 7) ^
 507                     C2(S, (i - 2) & 7) ^ C3(S, (i - 3) & 7) ^
 508                     C4(S, (i - 4) & 7) ^ C5(S, (i - 5) & 7) ^
 509                     C6(S, (i - 6) & 7) ^ C7(S, (i - 7) & 7);
 510             }
 511             memcpy(S.q, L, 64);
 512         }
 513         for (i = 0; i < 64; i++)
 514             H->c[i] ^= S.c[i] ^ p[i];
 515 #else
 516         u64 L0, L1, L2, L3, L4, L5, L6, L7;
 517
 518 # ifdef STRICT_ALIGNMENT
 519         if ((size_t)p & 7) {
 520             memcpy(S.c, p, 64);
 521             S.q[0] ^= (K.q[0] = H->q[0]);
 522             S.q[1] ^= (K.q[1] = H->q[1]);
 523             S.q[2] ^= (K.q[2] = H->q[2]);
 524             S.q[3] ^= (K.q[3] = H->q[3]);
 525             S.q[4] ^= (K.q[4] = H->q[4]);
 526             S.q[5] ^= (K.q[5] = H->q[5]);
 527             S.q[6] ^= (K.q[6] = H->q[6]);
 528             S.q[7] ^= (K.q[7] = H->q[7]);
 529         } else
 530 # endif
 531         {
 532             const u64 *pa = (const u64 *)p;
 533             S.q[0] = (K.q[0] = H->q[0]) ^ pa[0];
 534             S.q[1] = (K.q[1] = H->q[1]) ^ pa[1];
 535             S.q[2] = (K.q[2] = H->q[2]) ^ pa[2];
 536             S.q[3] = (K.q[3] = H->q[3]) ^ pa[3];
 537             S.q[4] = (K.q[4] = H->q[4]) ^ pa[4];
 538             S.q[5] = (K.q[5] = H->q[5]) ^ pa[5];
 539             S.q[6] = (K.q[6] = H->q[6]) ^ pa[6];
 540             S.q[7] = (K.q[7] = H->q[7]) ^ pa[7];
 541         }
 542
 543         for (r = 0; r < ROUNDS; r++) {
 544 # ifdef SMALL_REGISTER_BANK
 545             L0 = C0(K, 0) ^ C1(K, 7) ^ C2(K, 6) ^ C3(K, 5) ^
 546                 C4(K, 4) ^ C5(K, 3) ^ C6(K, 2) ^ C7(K, 1) ^ RC[r];
 547             L1 = C0(K, 1) ^ C1(K, 0) ^ C2(K, 7) ^ C3(K, 6) ^
 548                 C4(K, 5) ^ C5(K, 4) ^ C6(K, 3) ^ C7(K, 2);
 549             L2 = C0(K, 2) ^ C1(K, 1) ^ C2(K, 0) ^ C3(K, 7) ^
 550                 C4(K, 6) ^ C5(K, 5) ^ C6(K, 4) ^ C7(K, 3);
 551             L3 = C0(K, 3) ^ C1(K, 2) ^ C2(K, 1) ^ C3(K, 0) ^
 552                 C4(K, 7) ^ C5(K, 6) ^ C6(K, 5) ^ C7(K, 4);
 553             L4 = C0(K, 4) ^ C1(K, 3) ^ C2(K, 2) ^ C3(K, 1) ^
 554                 C4(K, 0) ^ C5(K, 7) ^ C6(K, 6) ^ C7(K, 5);
 555             L5 = C0(K, 5) ^ C1(K, 4) ^ C2(K, 3) ^ C3(K, 2) ^
 556                 C4(K, 1) ^ C5(K, 0) ^ C6(K, 7) ^ C7(K, 6);
 557             L6 = C0(K, 6) ^ C1(K, 5) ^ C2(K, 4) ^ C3(K, 3) ^
 558                 C4(K, 2) ^ C5(K, 1) ^ C6(K, 0) ^ C7(K, 7);
 559             L7 = C0(K, 7) ^ C1(K, 6) ^ C2(K, 5) ^ C3(K, 4) ^
 560                 C4(K, 3) ^ C5(K, 2) ^ C6(K, 1) ^ C7(K, 0);
 561
 562             K.q[0] = L0;
 563             K.q[1] = L1;
 564             K.q[2] = L2;
 565             K.q[3] = L3;
 566             K.q[4] = L4;
 567             K.q[5] = L5;
 568             K.q[6] = L6;
 569             K.q[7] = L7;
 570
 571             L0 ^= C0(S, 0) ^ C1(S, 7) ^ C2(S, 6) ^ C3(S, 5) ^
 572                 C4(S, 4) ^ C5(S, 3) ^ C6(S, 2) ^ C7(S, 1);
 573             L1 ^= C0(S, 1) ^ C1(S, 0) ^ C2(S, 7) ^ C3(S, 6) ^
 574                 C4(S, 5) ^ C5(S, 4) ^ C6(S, 3) ^ C7(S, 2);
 575             L2 ^= C0(S, 2) ^ C1(S, 1) ^ C2(S, 0) ^ C3(S, 7) ^
 576                 C4(S, 6) ^ C5(S, 5) ^ C6(S, 4) ^ C7(S, 3);
 577             L3 ^= C0(S, 3) ^ C1(S, 2) ^ C2(S, 1) ^ C3(S, 0) ^
 578                 C4(S, 7) ^ C5(S, 6) ^ C6(S, 5) ^ C7(S, 4);
 579             L4 ^= C0(S, 4) ^ C1(S, 3) ^ C2(S, 2) ^ C3(S, 1) ^
 580                 C4(S, 0) ^ C5(S, 7) ^ C6(S, 6) ^ C7(S, 5);
 581             L5 ^= C0(S, 5) ^ C1(S, 4) ^ C2(S, 3) ^ C3(S, 2) ^
 582                 C4(S, 1) ^ C5(S, 0) ^ C6(S, 7) ^ C7(S, 6);
 583             L6 ^= C0(S, 6) ^ C1(S, 5) ^ C2(S, 4) ^ C3(S, 3) ^
 584                 C4(S, 2) ^ C5(S, 1) ^ C6(S, 0) ^ C7(S, 7);
 585             L7 ^= C0(S, 7) ^ C1(S, 6) ^ C2(S, 5) ^ C3(S, 4) ^
 586                 C4(S, 3) ^ C5(S, 2) ^ C6(S, 1) ^ C7(S, 0);
 587
 588             S.q[0] = L0;
 589             S.q[1] = L1;
 590             S.q[2] = L2;
 591             S.q[3] = L3;
 592             S.q[4] = L4;
 593             S.q[5] = L5;
 594             S.q[6] = L6;
 595             S.q[7] = L7;
 596 # else
 597             L0 = C0(K, 0);
 598             L1 = C1(K, 0);
 599             L2 = C2(K, 0);
 600             L3 = C3(K, 0);
 601             L4 = C4(K, 0);
 602             L5 = C5(K, 0);
 603             L6 = C6(K, 0);
 604             L7 = C7(K, 0);
 605             L0 ^= RC[r];
 606
 607             L1 ^= C0(K, 1);
 608             L2 ^= C1(K, 1);
 609             L3 ^= C2(K, 1);
 610             L4 ^= C3(K, 1);
 611             L5 ^= C4(K, 1);
 612             L6 ^= C5(K, 1);
 613             L7 ^= C6(K, 1);
 614             L0 ^= C7(K, 1);
 615
 616             L2 ^= C0(K, 2);
 617             L3 ^= C1(K, 2);
 618             L4 ^= C2(K, 2);
 619             L5 ^= C3(K, 2);
 620             L6 ^= C4(K, 2);
 621             L7 ^= C5(K, 2);
 622             L0 ^= C6(K, 2);
 623             L1 ^= C7(K, 2);
 624
 625             L3 ^= C0(K, 3);
 626             L4 ^= C1(K, 3);
 627             L5 ^= C2(K, 3);
 628             L6 ^= C3(K, 3);
 629             L7 ^= C4(K, 3);
 630             L0 ^= C5(K, 3);
 631             L1 ^= C6(K, 3);
 632             L2 ^= C7(K, 3);
 633
 634             L4 ^= C0(K, 4);
 635             L5 ^= C1(K, 4);
 636             L6 ^= C2(K, 4);
 637             L7 ^= C3(K, 4);
 638             L0 ^= C4(K, 4);
 639             L1 ^= C5(K, 4);
 640             L2 ^= C6(K, 4);
 641             L3 ^= C7(K, 4);
 642
 643             L5 ^= C0(K, 5);
 644             L6 ^= C1(K, 5);
 645             L7 ^= C2(K, 5);
 646             L0 ^= C3(K, 5);
 647             L1 ^= C4(K, 5);
 648             L2 ^= C5(K, 5);
 649             L3 ^= C6(K, 5);
 650             L4 ^= C7(K, 5);
 651
 652             L6 ^= C0(K, 6);
 653             L7 ^= C1(K, 6);
 654             L0 ^= C2(K, 6);
 655             L1 ^= C3(K, 6);
 656             L2 ^= C4(K, 6);
 657             L3 ^= C5(K, 6);
 658             L4 ^= C6(K, 6);
 659             L5 ^= C7(K, 6);
 660
 661             L7 ^= C0(K, 7);
 662             L0 ^= C1(K, 7);
 663             L1 ^= C2(K, 7);
 664             L2 ^= C3(K, 7);
 665             L3 ^= C4(K, 7);
 666             L4 ^= C5(K, 7);
 667             L5 ^= C6(K, 7);
 668             L6 ^= C7(K, 7);
 669
 670             K.q[0] = L0;
 671             K.q[1] = L1;
 672             K.q[2] = L2;
 673             K.q[3] = L3;
 674             K.q[4] = L4;
 675             K.q[5] = L5;
 676             K.q[6] = L6;
 677             K.q[7] = L7;
 678
 679             L0 ^= C0(S, 0);
 680             L1 ^= C1(S, 0);
 681             L2 ^= C2(S, 0);
 682             L3 ^= C3(S, 0);
 683             L4 ^= C4(S, 0);
 684             L5 ^= C5(S, 0);
 685             L6 ^= C6(S, 0);
 686             L7 ^= C7(S, 0);
 687
 688             L1 ^= C0(S, 1);
 689             L2 ^= C1(S, 1);
 690             L3 ^= C2(S, 1);
 691             L4 ^= C3(S, 1);
 692             L5 ^= C4(S, 1);
 693             L6 ^= C5(S, 1);
 694             L7 ^= C6(S, 1);
 695             L0 ^= C7(S, 1);
 696
 697             L2 ^= C0(S, 2);
 698             L3 ^= C1(S, 2);
 699             L4 ^= C2(S, 2);
 700             L5 ^= C3(S, 2);
 701             L6 ^= C4(S, 2);
 702             L7 ^= C5(S, 2);
 703             L0 ^= C6(S, 2);
 704             L1 ^= C7(S, 2);
 705
 706             L3 ^= C0(S, 3);
 707             L4 ^= C1(S, 3);
 708             L5 ^= C2(S, 3);
 709             L6 ^= C3(S, 3);
 710             L7 ^= C4(S, 3);
 711             L0 ^= C5(S, 3);
 712             L1 ^= C6(S, 3);
 713             L2 ^= C7(S, 3);
 714
 715             L4 ^= C0(S, 4);
 716             L5 ^= C1(S, 4);
 717             L6 ^= C2(S, 4);
 718             L7 ^= C3(S, 4);
 719             L0 ^= C4(S, 4);
 720             L1 ^= C5(S, 4);
 721             L2 ^= C6(S, 4);
 722             L3 ^= C7(S, 4);
 723
 724             L5 ^= C0(S, 5);
 725             L6 ^= C1(S, 5);
 726             L7 ^= C2(S, 5);
 727             L0 ^= C3(S, 5);
 728             L1 ^= C4(S, 5);
 729             L2 ^= C5(S, 5);
 730             L3 ^= C6(S, 5);
 731             L4 ^= C7(S, 5);
 732
 733             L6 ^= C0(S, 6);
 734             L7 ^= C1(S, 6);
 735             L0 ^= C2(S, 6);
 736             L1 ^= C3(S, 6);
 737             L2 ^= C4(S, 6);
 738             L3 ^= C5(S, 6);
 739             L4 ^= C6(S, 6);
 740             L5 ^= C7(S, 6);
 741
 742             L7 ^= C0(S, 7);
 743             L0 ^= C1(S, 7);
 744             L1 ^= C2(S, 7);
 745             L2 ^= C3(S, 7);
 746             L3 ^= C4(S, 7);
 747             L4 ^= C5(S, 7);
 748             L5 ^= C6(S, 7);
 749             L6 ^= C7(S, 7);
 750
 751             S.q[0] = L0;
 752             S.q[1] = L1;
 753             S.q[2] = L2;
 754             S.q[3] = L3;
 755             S.q[4] = L4;
 756             S.q[5] = L5;
 757             S.q[6] = L6;
 758             S.q[7] = L7;
 759 # endif
 760         }
 761
 762 # ifdef STRICT_ALIGNMENT
 763         if ((size_t)p & 7) {
 764             int i;
 765             for (i = 0; i < 64; i++)
 766                 H->c[i] ^= S.c[i] ^ p[i];
 767         } else
 768 # endif
 769         {
 770             const u64 *pa = (const u64 *)p;
 771             H->q[0] ^= S.q[0] ^ pa[0];
 772             H->q[1] ^= S.q[1] ^ pa[1];
 773             H->q[2] ^= S.q[2] ^ pa[2];
 774             H->q[3] ^= S.q[3] ^ pa[3];
 775             H->q[4] ^= S.q[4] ^ pa[4];
 776             H->q[5] ^= S.q[5] ^ pa[5];
 777             H->q[6] ^= S.q[6] ^ pa[6];
 778             H->q[7] ^= S.q[7] ^ pa[7];
 779         }
 780 #endif
 781         p += 64;
 782     } while (--n);
 783 }