skein_block.c

   1 /***********************************************************************\r
   2 **\r
   3 ** Implementation of the Skein block functions.\r
   4 **\r
   5 ** Source code author: Doug Whiting, 2008.\r
   6 **\r
   7 ** This algorithm and source code is released to the public domain.\r
   8 **\r
   9 ** Compile-time switches:\r
  10 **\r
  11 **  SKEIN_USE_ASM             -- set bits (256/512/1024) to select which\r
  12 **                               versions use ASM code for block processing\r
  13 **                               [default: use C for all block sizes]\r
  14 **\r
  15 ************************************************************************/\r
  16 \r
  17 #include <string.h>\r
  18 #include "skein.h"\r
  19 \r
  20 /* 64-bit rotate left */\r
  21 u64b_t RotL_64(u64b_t x,uint_t N)\r
  22     {\r
  23     return (x << (N & 63)) | (x >> ((64-N) & 63));\r
  24     }\r
  25 \r
  26 #define BLK_BITS    (WCNT*64)\r
  27 \r
  28 /* macro to perform a key injection (same for all block sizes) */\r
  29 #define InjectKey(r)                                                \\r
  30     for (i=0;i < WCNT;i++)                                          \\r
  31          X[i] += ks[((r)+i) % (WCNT+1)];                            \\r
  32     X[WCNT-3] += ts[((r)+0) % 3];                                   \\r
  33     X[WCNT-2] += ts[((r)+1) % 3];                                   \\r
  34     X[WCNT-1] += (r);                    /* avoid slide attacks */  \\r
  35     Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,X);\r
  36 \r
  37 void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd)\r
  38     { /* do it in C */\r
  39     enum\r
  40         {\r
  41         WCNT     = SKEIN_256_STATE_WORDS\r
  42         };\r
  43     size_t  i,r;\r
  44     u64b_t  ts[3];                            /* key schedule: tweak */\r
  45     u64b_t  ks[WCNT+1];                       /* key schedule: chaining vars */\r
  46     u64b_t  X [WCNT];                         /* local copy of context vars */\r
  47     u64b_t  w [WCNT];                         /* local copy of input block */\r
  48 \r
  49     Skein_assert(blkCnt != 0);                /* never call with blkCnt == 0! */\r
  50     do  {\r
  51         /* this implementation only supports 2**64 input bytes (no carry out here) */\r
  52         ctx->h.T[0] += byteCntAdd;            /* update processed length */\r
  53 \r
  54         /* precompute the key schedule for this block */\r
  55         ks[WCNT] = SKEIN_KS_PARITY;\r
  56         for (i=0;i < WCNT; i++)\r
  57             {\r
  58             ks[i]     = ctx->X[i];\r
  59             ks[WCNT] ^= ctx->X[i];            /* compute overall parity */\r
  60             }\r
  61         ts[0] = ctx->h.T[0];\r
  62         ts[1] = ctx->h.T[1];\r
  63         ts[2] = ts[0] ^ ts[1];\r
  64 \r
  65         Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */\r
  66         Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts);\r
  67         for (i=0;i < WCNT; i++)               /* do the first full key injection */\r
  68             {\r
  69             X[i]  = w[i] + ks[i];\r
  70             }\r
  71         X[WCNT-3] += ts[0];\r
  72         X[WCNT-2] += ts[1];\r
  73 \r
  74         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X);     /* show starting state values */\r
  75 \r
  76         for (r=1;r <= SKEIN_256_ROUNDS_TOTAL/8; r++)\r
  77             { /* unroll 8 rounds */\r
  78             X[0] += X[1]; X[1] = RotL_64(X[1],R_256_0_0); X[1] ^= X[0];\r
  79             X[2] += X[3]; X[3] = RotL_64(X[3],R_256_0_1); X[3] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X);\r
  80 \r
  81             X[0] += X[3]; X[3] = RotL_64(X[3],R_256_1_0); X[3] ^= X[0];\r
  82             X[2] += X[1]; X[1] = RotL_64(X[1],R_256_1_1); X[1] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X);\r
  83 \r
  84             X[0] += X[1]; X[1] = RotL_64(X[1],R_256_2_0); X[1] ^= X[0];\r
  85             X[2] += X[3]; X[3] = RotL_64(X[3],R_256_2_1); X[3] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X);\r
  86 \r
  87             X[0] += X[3]; X[3] = RotL_64(X[3],R_256_3_0); X[3] ^= X[0];\r
  88             X[2] += X[1]; X[1] = RotL_64(X[1],R_256_3_1); X[1] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X);\r
  89             InjectKey(2*r-1);\r
  90 \r
  91             X[0] += X[1]; X[1] = RotL_64(X[1],R_256_4_0); X[1] ^= X[0];\r
  92             X[2] += X[3]; X[3] = RotL_64(X[3],R_256_4_1); X[3] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X);\r
  93 \r
  94             X[0] += X[3]; X[3] = RotL_64(X[3],R_256_5_0); X[3] ^= X[0];\r
  95             X[2] += X[1]; X[1] = RotL_64(X[1],R_256_5_1); X[1] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X);\r
  96 \r
  97             X[0] += X[1]; X[1] = RotL_64(X[1],R_256_6_0); X[1] ^= X[0];\r
  98             X[2] += X[3]; X[3] = RotL_64(X[3],R_256_6_1); X[3] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X);\r
  99 \r
 100             X[0] += X[3]; X[3] = RotL_64(X[3],R_256_7_0); X[3] ^= X[0];\r
 101             X[2] += X[1]; X[1] = RotL_64(X[1],R_256_7_1); X[1] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r  ,X);\r
 102             InjectKey(2*r);\r
 103             }\r
 104         /* do the final "feedforward" xor, update context chaining vars */\r
 105         for (i=0;i < WCNT;i++)\r
 106             ctx->X[i] = X[i] ^ w[i];\r
 107         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X);\r
 108 \r
 109                 Skein_Clear_First_Flag(ctx->h);         /* clear the start bit */\r
 110         blkPtr += SKEIN_256_BLOCK_BYTES;\r
 111         }\r
 112     while (--blkCnt);\r
 113     }\r
 114 \r
 115 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)\r
 116 size_t Skein_256_Process_Block_CodeSize(void)\r
 117     {\r
 118     return ((u08b_t *) Skein_256_Process_Block_CodeSize) -\r
 119            ((u08b_t *) Skein_256_Process_Block);\r
 120     }\r
 121 uint_t Skein_256_Unroll_Cnt(void)\r
 122     {\r
 123     return 1;\r
 124     }\r
 125 #endif\r
 126 \r
 127 void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd)\r
 128     { /* do it in C */\r
 129     enum\r
 130         {\r
 131         WCNT = SKEIN_512_STATE_WORDS\r
 132         };\r
 133 \r
 134     size_t  i,r;\r
 135     u64b_t  ts[3];                            /* key schedule: tweak */\r
 136     u64b_t  ks[WCNT+1];                       /* key schedule: chaining vars */\r
 137     u64b_t  X [WCNT];                         /* local copy of vars */\r
 138     u64b_t  w [WCNT];                         /* local copy of input block */\r
 139 \r
 140     Skein_assert(blkCnt != 0);                /* never call with blkCnt == 0! */\r
 141     do  {\r
 142         /* this implementation only supports 2**64 input bytes (no carry out here) */\r
 143         ctx->h.T[0] += byteCntAdd;            /* update processed length */\r
 144 \r
 145         /* precompute the key schedule for this block */\r
 146         ks[WCNT] = SKEIN_KS_PARITY;\r
 147         for (i=0;i < WCNT; i++)\r
 148             {\r
 149             ks[i]     = ctx->X[i];\r
 150             ks[WCNT] ^= ctx->X[i];            /* compute overall parity */\r
 151             }\r
 152         ts[0] = ctx->h.T[0];\r
 153         ts[1] = ctx->h.T[1];\r
 154         ts[2] = ts[0] ^ ts[1];\r
 155 \r
 156         Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */\r
 157         Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts);\r
 158         for (i=0;i < WCNT; i++)               /* do the first full key injection */\r
 159             {\r
 160             X[i]  = w[i] + ks[i];\r
 161             }\r
 162         X[WCNT-3] += ts[0];\r
 163         X[WCNT-2] += ts[1];\r
 164 \r
 165         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X);\r
 166         for (r=1;r <= SKEIN_512_ROUNDS_TOTAL/8; r++)\r
 167             { /* unroll 8 rounds */\r
 168             X[0] += X[1]; X[1] = RotL_64(X[1],R_512_0_0); X[1] ^= X[0];\r
 169             X[2] += X[3]; X[3] = RotL_64(X[3],R_512_0_1); X[3] ^= X[2];\r
 170             X[4] += X[5]; X[5] = RotL_64(X[5],R_512_0_2); X[5] ^= X[4];\r
 171             X[6] += X[7]; X[7] = RotL_64(X[7],R_512_0_3); X[7] ^= X[6];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X);\r
 172 \r
 173             X[2] += X[1]; X[1] = RotL_64(X[1],R_512_1_0); X[1] ^= X[2];\r
 174             X[4] += X[7]; X[7] = RotL_64(X[7],R_512_1_1); X[7] ^= X[4];\r
 175             X[6] += X[5]; X[5] = RotL_64(X[5],R_512_1_2); X[5] ^= X[6];\r
 176             X[0] += X[3]; X[3] = RotL_64(X[3],R_512_1_3); X[3] ^= X[0];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X);\r
 177 \r
 178             X[4] += X[1]; X[1] = RotL_64(X[1],R_512_2_0); X[1] ^= X[4];\r
 179             X[6] += X[3]; X[3] = RotL_64(X[3],R_512_2_1); X[3] ^= X[6];\r
 180             X[0] += X[5]; X[5] = RotL_64(X[5],R_512_2_2); X[5] ^= X[0];\r
 181             X[2] += X[7]; X[7] = RotL_64(X[7],R_512_2_3); X[7] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X);\r
 182 \r
 183             X[6] += X[1]; X[1] = RotL_64(X[1],R_512_3_0); X[1] ^= X[6];\r
 184             X[0] += X[7]; X[7] = RotL_64(X[7],R_512_3_1); X[7] ^= X[0];\r
 185             X[2] += X[5]; X[5] = RotL_64(X[5],R_512_3_2); X[5] ^= X[2];\r
 186             X[4] += X[3]; X[3] = RotL_64(X[3],R_512_3_3); X[3] ^= X[4];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X);\r
 187             InjectKey(2*r-1);\r
 188 \r
 189             X[0] += X[1]; X[1] = RotL_64(X[1],R_512_4_0); X[1] ^= X[0];\r
 190             X[2] += X[3]; X[3] = RotL_64(X[3],R_512_4_1); X[3] ^= X[2];\r
 191             X[4] += X[5]; X[5] = RotL_64(X[5],R_512_4_2); X[5] ^= X[4];\r
 192             X[6] += X[7]; X[7] = RotL_64(X[7],R_512_4_3); X[7] ^= X[6];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X);\r
 193 \r
 194             X[2] += X[1]; X[1] = RotL_64(X[1],R_512_5_0); X[1] ^= X[2];\r
 195             X[4] += X[7]; X[7] = RotL_64(X[7],R_512_5_1); X[7] ^= X[4];\r
 196             X[6] += X[5]; X[5] = RotL_64(X[5],R_512_5_2); X[5] ^= X[6];\r
 197             X[0] += X[3]; X[3] = RotL_64(X[3],R_512_5_3); X[3] ^= X[0];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X);\r
 198 \r
 199             X[4] += X[1]; X[1] = RotL_64(X[1],R_512_6_0); X[1] ^= X[4];\r
 200             X[6] += X[3]; X[3] = RotL_64(X[3],R_512_6_1); X[3] ^= X[6];\r
 201             X[0] += X[5]; X[5] = RotL_64(X[5],R_512_6_2); X[5] ^= X[0];\r
 202             X[2] += X[7]; X[7] = RotL_64(X[7],R_512_6_3); X[7] ^= X[2];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X);\r
 203 \r
 204             X[6] += X[1]; X[1] = RotL_64(X[1],R_512_7_0); X[1] ^= X[6];\r
 205             X[0] += X[7]; X[7] = RotL_64(X[7],R_512_7_1); X[7] ^= X[0];\r
 206             X[2] += X[5]; X[5] = RotL_64(X[5],R_512_7_2); X[5] ^= X[2];\r
 207             X[4] += X[3]; X[3] = RotL_64(X[3],R_512_7_3); X[3] ^= X[4];  Skein_Show_Round(BLK_BITS,&ctx->h,8*r  ,X);\r
 208             InjectKey(2*r);\r
 209             }\r
 210         /* do the final "feedforward" xor, update context chaining vars */\r
 211         for (i=0;i < WCNT;i++)\r
 212             ctx->X[i] = X[i] ^ w[i];\r
 213         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X);\r
 214 \r
 215                 Skein_Clear_First_Flag(ctx->h);         /* clear the start bit */\r
 216         blkPtr += SKEIN_512_BLOCK_BYTES;\r
 217         }\r
 218     while (--blkCnt);\r
 219     }\r
 220 \r
 221 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)\r
 222 size_t Skein_512_Process_Block_CodeSize(void)\r
 223     {\r
 224     return ((u08b_t *) Skein_512_Process_Block_CodeSize) -\r
 225            ((u08b_t *) Skein_512_Process_Block);\r
 226     }\r
 227 uint_t Skein_512_Unroll_Cnt(void)\r
 228     {\r
 229     return 1;\r
 230     }\r
 231 #endif\r
 232 \r
 233 void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd)\r
 234     { /* do it in C */\r
 235     enum\r
 236         {\r
 237         WCNT = SKEIN1024_STATE_WORDS\r
 238         };\r
 239 \r
 240     size_t  i,r;\r
 241     u64b_t  ts[3];                            /* key schedule: tweak */\r
 242     u64b_t  ks[WCNT+1];                       /* key schedule: chaining vars */\r
 243     u64b_t  X [WCNT];                         /* local copy of vars */\r
 244     u64b_t  w [WCNT];                         /* local copy of input block */\r
 245 \r
 246     Skein_assert(blkCnt != 0);                /* never call with blkCnt == 0! */\r
 247     do  {\r
 248         /* this implementation only supports 2**64 input bytes (no carry out here) */\r
 249         ctx->h.T[0] += byteCntAdd;            /* update processed length */\r
 250 \r
 251         /* precompute the key schedule for this block */\r
 252         ks[WCNT] = SKEIN_KS_PARITY;\r
 253         for (i=0;i < WCNT; i++)\r
 254             {\r
 255             ks[i]     = ctx->X[i];\r
 256             ks[WCNT] ^= ctx->X[i];            /* compute overall parity */\r
 257             }\r
 258         ts[0] = ctx->h.T[0];\r
 259         ts[1] = ctx->h.T[1];\r
 260         ts[2] = ts[0] ^ ts[1];\r
 261 \r
 262         Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */\r
 263         Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts);\r
 264         for (i=0;i < WCNT; i++)               /* do the first full key injection */\r
 265             {\r
 266             X[i]  = w[i] + ks[i];\r
 267             }\r
 268         X[WCNT-3] += ts[0];\r
 269         X[WCNT-2] += ts[1];\r
 270 \r
 271         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X);   /* show starting state values */\r
 272         for (r=1;r <= SKEIN1024_ROUNDS_TOTAL/8; r++)\r
 273             { /* unroll 8 rounds */\r
 274             X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_0_0); X[ 1] ^= X[ 0];\r
 275             X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_0_1); X[ 3] ^= X[ 2];\r
 276             X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_0_2); X[ 5] ^= X[ 4];\r
 277             X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_0_3); X[ 7] ^= X[ 6];\r
 278             X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_0_4); X[ 9] ^= X[ 8];\r
 279             X[10] += X[11]; X[11] = RotL_64(X[11],R1024_0_5); X[11] ^= X[10];\r
 280             X[12] += X[13]; X[13] = RotL_64(X[13],R1024_0_6); X[13] ^= X[12];\r
 281             X[14] += X[15]; X[15] = RotL_64(X[15],R1024_0_7); X[15] ^= X[14];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X);\r
 282 \r
 283             X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_1_0); X[ 9] ^= X[ 0];\r
 284             X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_1_1); X[13] ^= X[ 2];\r
 285             X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_1_2); X[11] ^= X[ 6];\r
 286             X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_1_3); X[15] ^= X[ 4];\r
 287             X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_1_4); X[ 7] ^= X[10];\r
 288             X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_1_5); X[ 3] ^= X[12];\r
 289             X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_1_6); X[ 5] ^= X[14];\r
 290             X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_1_7); X[ 1] ^= X[ 8];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X);\r
 291 \r
 292             X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_2_0); X[ 7] ^= X[ 0];\r
 293             X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_2_1); X[ 5] ^= X[ 2];\r
 294             X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_2_2); X[ 3] ^= X[ 4];\r
 295             X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_2_3); X[ 1] ^= X[ 6];\r
 296             X[12] += X[15]; X[15] = RotL_64(X[15],R1024_2_4); X[15] ^= X[12];\r
 297             X[14] += X[13]; X[13] = RotL_64(X[13],R1024_2_5); X[13] ^= X[14];\r
 298             X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_2_6); X[11] ^= X[ 8];\r
 299             X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_2_7); X[ 9] ^= X[10];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X);\r
 300                                                                             \r
 301             X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_3_0); X[15] ^= X[ 0];\r
 302             X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_3_1); X[11] ^= X[ 2];\r
 303             X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_3_2); X[13] ^= X[ 6];\r
 304             X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_3_3); X[ 9] ^= X[ 4];\r
 305             X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_3_4); X[ 1] ^= X[14];\r
 306             X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_3_5); X[ 5] ^= X[ 8];\r
 307             X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_3_6); X[ 3] ^= X[10];\r
 308             X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_3_7); X[ 7] ^= X[12];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X);\r
 309             InjectKey(2*r-1);\r
 310 \r
 311             X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_4_0); X[ 1] ^= X[ 0];\r
 312             X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_4_1); X[ 3] ^= X[ 2];\r
 313             X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_4_2); X[ 5] ^= X[ 4];\r
 314             X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_4_3); X[ 7] ^= X[ 6];\r
 315             X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_4_4); X[ 9] ^= X[ 8];\r
 316             X[10] += X[11]; X[11] = RotL_64(X[11],R1024_4_5); X[11] ^= X[10];\r
 317             X[12] += X[13]; X[13] = RotL_64(X[13],R1024_4_6); X[13] ^= X[12];\r
 318             X[14] += X[15]; X[15] = RotL_64(X[15],R1024_4_7); X[15] ^= X[14];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X);\r
 319 \r
 320             X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_5_0); X[ 9] ^= X[ 0];\r
 321             X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_5_1); X[13] ^= X[ 2];\r
 322             X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_5_2); X[11] ^= X[ 6];\r
 323             X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_5_3); X[15] ^= X[ 4];\r
 324             X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_5_4); X[ 7] ^= X[10];\r
 325             X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_5_5); X[ 3] ^= X[12];\r
 326             X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_5_6); X[ 5] ^= X[14];\r
 327             X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_5_7); X[ 1] ^= X[ 8];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X);\r
 328 \r
 329             X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_6_0); X[ 7] ^= X[ 0];\r
 330             X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_6_1); X[ 5] ^= X[ 2];\r
 331             X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_6_2); X[ 3] ^= X[ 4];\r
 332             X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_6_3); X[ 1] ^= X[ 6];\r
 333             X[12] += X[15]; X[15] = RotL_64(X[15],R1024_6_4); X[15] ^= X[12];\r
 334             X[14] += X[13]; X[13] = RotL_64(X[13],R1024_6_5); X[13] ^= X[14];\r
 335             X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_6_6); X[11] ^= X[ 8];\r
 336             X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_6_7); X[ 9] ^= X[10];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X);\r
 337                                                                             \r
 338             X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_7_0); X[15] ^= X[ 0];\r
 339             X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_7_1); X[11] ^= X[ 2];\r
 340             X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_7_2); X[13] ^= X[ 6];\r
 341             X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_7_3); X[ 9] ^= X[ 4];\r
 342             X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_7_4); X[ 1] ^= X[14];\r
 343             X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_7_5); X[ 5] ^= X[ 8];\r
 344             X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_7_6); X[ 3] ^= X[10];\r
 345             X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_7_7); X[ 7] ^= X[12];    Skein_Show_Round(BLK_BITS,&ctx->h,8*r  ,X);\r
 346             InjectKey(2*r);\r
 347             }\r
 348         /* do the final "feedforward" xor, update context chaining vars */\r
 349         for (i=0;i<WCNT;i++)\r
 350             ctx->X[i] = X[i] ^ w[i];\r
 351         Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X);\r
 352         \r
 353                 Skein_Clear_First_Flag(ctx->h);         /* clear the start bit */\r
 354         blkPtr += SKEIN1024_BLOCK_BYTES;\r
 355         }\r
 356     while (--blkCnt);\r
 357     }\r
 358 \r
 359 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)\r
 360 size_t Skein1024_Process_Block_CodeSize(void)\r
 361     {\r
 362     return ((u08b_t *) Skein1024_Process_Block_CodeSize) -\r
 363            ((u08b_t *) Skein1024_Process_Block);\r
 364     }\r
 365 uint_t Skein1024_Unroll_Cnt(void)\r
 366     {\r
 367     return 1;\r
 368     }\r
 369 #endif\r