OpenCL/m07400.cl

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #define _SHA256_
   7
   8 #include "include/constants.h"
   9 #include "include/kernel_vendor.h"
  10
  11 #define DGST_R0 0
  12 #define DGST_R1 1
  13 #define DGST_R2 2
  14 #define DGST_R3 3
  15
  16 #include "include/kernel_functions.c"
  17 #include "OpenCL/types_ocl.c"
  18 #include "OpenCL/common.c"
  19
  20 #define COMPARE_S "OpenCL/check_single_comp4.c"
  21 #define COMPARE_M "OpenCL/check_multi_comp4.c"
  22
  23 __constant u32 k_sha256[64] =
  24 {
  25   SHA256C00, SHA256C01, SHA256C02, SHA256C03,
  26   SHA256C04, SHA256C05, SHA256C06, SHA256C07,
  27   SHA256C08, SHA256C09, SHA256C0a, SHA256C0b,
  28   SHA256C0c, SHA256C0d, SHA256C0e, SHA256C0f,
  29   SHA256C10, SHA256C11, SHA256C12, SHA256C13,
  30   SHA256C14, SHA256C15, SHA256C16, SHA256C17,
  31   SHA256C18, SHA256C19, SHA256C1a, SHA256C1b,
  32   SHA256C1c, SHA256C1d, SHA256C1e, SHA256C1f,
  33   SHA256C20, SHA256C21, SHA256C22, SHA256C23,
  34   SHA256C24, SHA256C25, SHA256C26, SHA256C27,
  35   SHA256C28, SHA256C29, SHA256C2a, SHA256C2b,
  36   SHA256C2c, SHA256C2d, SHA256C2e, SHA256C2f,
  37   SHA256C30, SHA256C31, SHA256C32, SHA256C33,
  38   SHA256C34, SHA256C35, SHA256C36, SHA256C37,
  39   SHA256C38, SHA256C39, SHA256C3a, SHA256C3b,
  40   SHA256C3c, SHA256C3d, SHA256C3e, SHA256C3f,
  41 };
  42
  43 void sha256_transform (const u32 w[16], u32 digest[8])
  44 {
  45   u32 a = digest[0];
  46   u32 b = digest[1];
  47   u32 c = digest[2];
  48   u32 d = digest[3];
  49   u32 e = digest[4];
  50   u32 f = digest[5];
  51   u32 g = digest[6];
  52   u32 h = digest[7];
  53
  54   u32 w0_t = swap32 (w[ 0]);
  55   u32 w1_t = swap32 (w[ 1]);
  56   u32 w2_t = swap32 (w[ 2]);
  57   u32 w3_t = swap32 (w[ 3]);
  58   u32 w4_t = swap32 (w[ 4]);
  59   u32 w5_t = swap32 (w[ 5]);
  60   u32 w6_t = swap32 (w[ 6]);
  61   u32 w7_t = swap32 (w[ 7]);
  62   u32 w8_t = swap32 (w[ 8]);
  63   u32 w9_t = swap32 (w[ 9]);
  64   u32 wa_t = swap32 (w[10]);
  65   u32 wb_t = swap32 (w[11]);
  66   u32 wc_t = swap32 (w[12]);
  67   u32 wd_t = swap32 (w[13]);
  68   u32 we_t = swap32 (w[14]);
  69   u32 wf_t = swap32 (w[15]);
  70
  71   #define ROUND_EXPAND()                            \
  72   {                                                 \
  73     w0_t = SHA256_EXPAND (we_t, w9_t, w1_t, w0_t);  \
  74     w1_t = SHA256_EXPAND (wf_t, wa_t, w2_t, w1_t);  \
  75     w2_t = SHA256_EXPAND (w0_t, wb_t, w3_t, w2_t);  \
  76     w3_t = SHA256_EXPAND (w1_t, wc_t, w4_t, w3_t);  \
  77     w4_t = SHA256_EXPAND (w2_t, wd_t, w5_t, w4_t);  \
  78     w5_t = SHA256_EXPAND (w3_t, we_t, w6_t, w5_t);  \
  79     w6_t = SHA256_EXPAND (w4_t, wf_t, w7_t, w6_t);  \
  80     w7_t = SHA256_EXPAND (w5_t, w0_t, w8_t, w7_t);  \
  81     w8_t = SHA256_EXPAND (w6_t, w1_t, w9_t, w8_t);  \
  82     w9_t = SHA256_EXPAND (w7_t, w2_t, wa_t, w9_t);  \
  83     wa_t = SHA256_EXPAND (w8_t, w3_t, wb_t, wa_t);  \
  84     wb_t = SHA256_EXPAND (w9_t, w4_t, wc_t, wb_t);  \
  85     wc_t = SHA256_EXPAND (wa_t, w5_t, wd_t, wc_t);  \
  86     wd_t = SHA256_EXPAND (wb_t, w6_t, we_t, wd_t);  \
  87     we_t = SHA256_EXPAND (wc_t, w7_t, wf_t, we_t);  \
  88     wf_t = SHA256_EXPAND (wd_t, w8_t, w0_t, wf_t);  \
  89   }
  90
  91   #define ROUND_STEP(i)                                                                   \
  92   {                                                                                       \
  93     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, k_sha256[i +  0]); \
  94     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, k_sha256[i +  1]); \
  95     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, k_sha256[i +  2]); \
  96     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, k_sha256[i +  3]); \
  97     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, k_sha256[i +  4]); \
  98     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, k_sha256[i +  5]); \
  99     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, k_sha256[i +  6]); \
 100     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, k_sha256[i +  7]); \
 101     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, k_sha256[i +  8]); \
 102     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, k_sha256[i +  9]); \
 103     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, k_sha256[i + 10]); \
 104     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, k_sha256[i + 11]); \
 105     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, k_sha256[i + 12]); \
 106     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, k_sha256[i + 13]); \
 107     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, k_sha256[i + 14]); \
 108     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, k_sha256[i + 15]); \
 109   }
 110
 111   ROUND_STEP (0);
 112
 113   //#pragma unroll
 114   for (int i = 16; i < 64; i += 16)
 115   {
 116     ROUND_EXPAND (); ROUND_STEP (i);
 117   }
 118
 119   digest[0] += a;
 120   digest[1] += b;
 121   digest[2] += c;
 122   digest[3] += d;
 123   digest[4] += e;
 124   digest[5] += f;
 125   digest[6] += g;
 126   digest[7] += h;
 127 }
 128
 129 void sha256_transform_no14 (const u32 w[16], u32 digest[8])
 130 {
 131   u32 w_t[16];
 132
 133   w_t[ 0] = w[ 0];
 134   w_t[ 1] = w[ 1];
 135   w_t[ 2] = w[ 2];
 136   w_t[ 3] = w[ 3];
 137   w_t[ 4] = w[ 4];
 138   w_t[ 5] = w[ 5];
 139   w_t[ 6] = w[ 6];
 140   w_t[ 7] = w[ 7];
 141   w_t[ 8] = w[ 8];
 142   w_t[ 9] = w[ 9];
 143   w_t[10] = w[10];
 144   w_t[11] = w[11];
 145   w_t[12] = w[12];
 146   w_t[13] = w[13];
 147   w_t[14] = 0;
 148   w_t[15] = w[15];
 149
 150   sha256_transform (w_t, digest);
 151 }
 152
 153 void init_ctx (u32 digest[8])
 154 {
 155   digest[0] = SHA256M_A;
 156   digest[1] = SHA256M_B;
 157   digest[2] = SHA256M_C;
 158   digest[3] = SHA256M_D;
 159   digest[4] = SHA256M_E;
 160   digest[5] = SHA256M_F;
 161   digest[6] = SHA256M_G;
 162   digest[7] = SHA256M_H;
 163 }
 164
 165 void bzero16 (u32 block[16])
 166 {
 167   block[ 0] = 0;
 168   block[ 1] = 0;
 169   block[ 2] = 0;
 170   block[ 3] = 0;
 171   block[ 4] = 0;
 172   block[ 5] = 0;
 173   block[ 6] = 0;
 174   block[ 7] = 0;
 175   block[ 8] = 0;
 176   block[ 9] = 0;
 177   block[10] = 0;
 178   block[11] = 0;
 179   block[12] = 0;
 180   block[13] = 0;
 181   block[14] = 0;
 182   block[15] = 0;
 183 }
 184
 185 void bswap8 (u32 block[16])
 186 {
 187   block[ 0] = swap32 (block[ 0]);
 188   block[ 1] = swap32 (block[ 1]);
 189   block[ 2] = swap32 (block[ 2]);
 190   block[ 3] = swap32 (block[ 3]);
 191   block[ 4] = swap32 (block[ 4]);
 192   block[ 5] = swap32 (block[ 5]);
 193   block[ 6] = swap32 (block[ 6]);
 194   block[ 7] = swap32 (block[ 7]);
 195 }
 196
 197 u32 memcat16 (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len)
 198 {
 199   const u32 mod = block_len & 3;
 200   const u32 div = block_len / 4;
 201
 202   u32 tmp0;
 203   u32 tmp1;
 204   u32 tmp2;
 205   u32 tmp3;
 206   u32 tmp4;
 207
 208   #if defined IS_AMD || defined IS_GENERIC
 209   const int offset_minus_4 = 4 - block_len;
 210
 211   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 212   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 213   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 214   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 215   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 216
 217   if (mod == 0)
 218   {
 219     tmp0 = tmp1;
 220     tmp1 = tmp2;
 221     tmp2 = tmp3;
 222     tmp3 = tmp4;
 223     tmp4 = 0;
 224   }
 225   #endif
 226
 227   #ifdef IS_NV
 228   const int offset_minus_4 = 4 - (block_len & 3);
 229
 230   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 231
 232   tmp0 = __byte_perm (        0, append[0], selector);
 233   tmp1 = __byte_perm (append[0], append[1], selector);
 234   tmp2 = __byte_perm (append[1], append[2], selector);
 235   tmp3 = __byte_perm (append[2], append[3], selector);
 236   tmp4 = __byte_perm (append[3],         0, selector);
 237   #endif
 238
 239   switch (div)
 240   {
 241     case  0:  block[ 0] |= tmp0;
 242               block[ 1]  = tmp1;
 243               block[ 2]  = tmp2;
 244               block[ 3]  = tmp3;
 245               block[ 4]  = tmp4;
 246               break;
 247     case  1:  block[ 1] |= tmp0;
 248               block[ 2]  = tmp1;
 249               block[ 3]  = tmp2;
 250               block[ 4]  = tmp3;
 251               block[ 5]  = tmp4;
 252               break;
 253     case  2:  block[ 2] |= tmp0;
 254               block[ 3]  = tmp1;
 255               block[ 4]  = tmp2;
 256               block[ 5]  = tmp3;
 257               block[ 6]  = tmp4;
 258               break;
 259     case  3:  block[ 3] |= tmp0;
 260               block[ 4]  = tmp1;
 261               block[ 5]  = tmp2;
 262               block[ 6]  = tmp3;
 263               block[ 7]  = tmp4;
 264               break;
 265     case  4:  block[ 4] |= tmp0;
 266               block[ 5]  = tmp1;
 267               block[ 6]  = tmp2;
 268               block[ 7]  = tmp3;
 269               block[ 8]  = tmp4;
 270               break;
 271     case  5:  block[ 5] |= tmp0;
 272               block[ 6]  = tmp1;
 273               block[ 7]  = tmp2;
 274               block[ 8]  = tmp3;
 275               block[ 9]  = tmp4;
 276               break;
 277     case  6:  block[ 6] |= tmp0;
 278               block[ 7]  = tmp1;
 279               block[ 8]  = tmp2;
 280               block[ 9]  = tmp3;
 281               block[10]  = tmp4;
 282               break;
 283     case  7:  block[ 7] |= tmp0;
 284               block[ 8]  = tmp1;
 285               block[ 9]  = tmp2;
 286               block[10]  = tmp3;
 287               block[11]  = tmp4;
 288               break;
 289     case  8:  block[ 8] |= tmp0;
 290               block[ 9]  = tmp1;
 291               block[10]  = tmp2;
 292               block[11]  = tmp3;
 293               block[12]  = tmp4;
 294               break;
 295     case  9:  block[ 9] |= tmp0;
 296               block[10]  = tmp1;
 297               block[11]  = tmp2;
 298               block[12]  = tmp3;
 299               block[13]  = tmp4;
 300               break;
 301     case 10:  block[10] |= tmp0;
 302               block[11]  = tmp1;
 303               block[12]  = tmp2;
 304               block[13]  = tmp3;
 305               block[14]  = tmp4;
 306               break;
 307     case 11:  block[11] |= tmp0;
 308               block[12]  = tmp1;
 309               block[13]  = tmp2;
 310               block[14]  = tmp3;
 311               block[15]  = tmp4;
 312               break;
 313     case 12:  block[12] |= tmp0;
 314               block[13]  = tmp1;
 315               block[14]  = tmp2;
 316               block[15]  = tmp3;
 317               break;
 318     case 13:  block[13] |= tmp0;
 319               block[14]  = tmp1;
 320               block[15]  = tmp2;
 321               break;
 322     case 14:  block[14] |= tmp0;
 323               block[15]  = tmp1;
 324               break;
 325     case 15:  block[15] |= tmp0;
 326               break;
 327   }
 328
 329   u32 new_len = block_len + append_len;
 330
 331   return new_len;
 332 }
 333
 334 u32 memcat16c (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len, u32 digest[8])
 335 {
 336   const u32 mod = block_len & 3;
 337   const u32 div = block_len / 4;
 338
 339   u32 tmp0;
 340   u32 tmp1;
 341   u32 tmp2;
 342   u32 tmp3;
 343   u32 tmp4;
 344
 345   #if defined IS_AMD || defined IS_GENERIC
 346   const int offset_minus_4 = 4 - block_len;
 347
 348   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 349   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 350   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 351   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 352   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 353
 354   if (mod == 0)
 355   {
 356     tmp0 = tmp1;
 357     tmp1 = tmp2;
 358     tmp2 = tmp3;
 359     tmp3 = tmp4;
 360     tmp4 = 0;
 361   }
 362   #endif
 363
 364   #ifdef IS_NV
 365   const int offset_minus_4 = 4 - (block_len & 3);
 366
 367   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 368
 369   tmp0 = __byte_perm (        0, append[0], selector);
 370   tmp1 = __byte_perm (append[0], append[1], selector);
 371   tmp2 = __byte_perm (append[1], append[2], selector);
 372   tmp3 = __byte_perm (append[2], append[3], selector);
 373   tmp4 = __byte_perm (append[3],         0, selector);
 374   #endif
 375
 376   u32 carry[4] = { 0, 0, 0, 0 };
 377
 378   switch (div)
 379   {
 380     case  0:  block[ 0] |= tmp0;
 381               block[ 1]  = tmp1;
 382               block[ 2]  = tmp2;
 383               block[ 3]  = tmp3;
 384               block[ 4]  = tmp4;
 385               break;
 386     case  1:  block[ 1] |= tmp0;
 387               block[ 2]  = tmp1;
 388               block[ 3]  = tmp2;
 389               block[ 4]  = tmp3;
 390               block[ 5]  = tmp4;
 391               break;
 392     case  2:  block[ 2] |= tmp0;
 393               block[ 3]  = tmp1;
 394               block[ 4]  = tmp2;
 395               block[ 5]  = tmp3;
 396               block[ 6]  = tmp4;
 397               break;
 398     case  3:  block[ 3] |= tmp0;
 399               block[ 4]  = tmp1;
 400               block[ 5]  = tmp2;
 401               block[ 6]  = tmp3;
 402               block[ 7]  = tmp4;
 403               break;
 404     case  4:  block[ 4] |= tmp0;
 405               block[ 5]  = tmp1;
 406               block[ 6]  = tmp2;
 407               block[ 7]  = tmp3;
 408               block[ 8]  = tmp4;
 409               break;
 410     case  5:  block[ 5] |= tmp0;
 411               block[ 6]  = tmp1;
 412               block[ 7]  = tmp2;
 413               block[ 8]  = tmp3;
 414               block[ 9]  = tmp4;
 415               break;
 416     case  6:  block[ 6] |= tmp0;
 417               block[ 7]  = tmp1;
 418               block[ 8]  = tmp2;
 419               block[ 9]  = tmp3;
 420               block[10]  = tmp4;
 421               break;
 422     case  7:  block[ 7] |= tmp0;
 423               block[ 8]  = tmp1;
 424               block[ 9]  = tmp2;
 425               block[10]  = tmp3;
 426               block[11]  = tmp4;
 427               break;
 428     case  8:  block[ 8] |= tmp0;
 429               block[ 9]  = tmp1;
 430               block[10]  = tmp2;
 431               block[11]  = tmp3;
 432               block[12]  = tmp4;
 433               break;
 434     case  9:  block[ 9] |= tmp0;
 435               block[10]  = tmp1;
 436               block[11]  = tmp2;
 437               block[12]  = tmp3;
 438               block[13]  = tmp4;
 439               break;
 440     case 10:  block[10] |= tmp0;
 441               block[11]  = tmp1;
 442               block[12]  = tmp2;
 443               block[13]  = tmp3;
 444               block[14]  = tmp4;
 445               break;
 446     case 11:  block[11] |= tmp0;
 447               block[12]  = tmp1;
 448               block[13]  = tmp2;
 449               block[14]  = tmp3;
 450               block[15]  = tmp4;
 451               break;
 452     case 12:  block[12] |= tmp0;
 453               block[13]  = tmp1;
 454               block[14]  = tmp2;
 455               block[15]  = tmp3;
 456               carry[ 0]  = tmp4;
 457               break;
 458     case 13:  block[13] |= tmp0;
 459               block[14]  = tmp1;
 460               block[15]  = tmp2;
 461               carry[ 0]  = tmp3;
 462               carry[ 1]  = tmp4;
 463               break;
 464     case 14:  block[14] |= tmp0;
 465               block[15]  = tmp1;
 466               carry[ 0]  = tmp2;
 467               carry[ 1]  = tmp3;
 468               carry[ 2]  = tmp4;
 469               break;
 470     case 15:  block[15] |= tmp0;
 471               carry[ 0]  = tmp1;
 472               carry[ 1]  = tmp2;
 473               carry[ 2]  = tmp3;
 474               carry[ 3]  = tmp4;
 475               break;
 476   }
 477
 478   u32 new_len = block_len + append_len;
 479
 480   if (new_len >= 64)
 481   {
 482     new_len -= 64;
 483
 484     sha256_transform (block, digest);
 485
 486     bzero16 (block);
 487
 488     block[0] = carry[0];
 489     block[1] = carry[1];
 490     block[2] = carry[2];
 491     block[3] = carry[3];
 492   }
 493
 494   return new_len;
 495 }
 496
 497 u32 memcat20 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 498 {
 499   const u32 mod = block_len & 3;
 500   const u32 div = block_len / 4;
 501
 502   u32 tmp0;
 503   u32 tmp1;
 504   u32 tmp2;
 505   u32 tmp3;
 506   u32 tmp4;
 507
 508   #if defined IS_AMD || defined IS_GENERIC
 509   const int offset_minus_4 = 4 - block_len;
 510
 511   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 512   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 513   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 514   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 515   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 516
 517   if (mod == 0)
 518   {
 519     tmp0 = tmp1;
 520     tmp1 = tmp2;
 521     tmp2 = tmp3;
 522     tmp3 = tmp4;
 523     tmp4 = 0;
 524   }
 525   #endif
 526
 527   #ifdef IS_NV
 528   const int offset_minus_4 = 4 - (block_len & 3);
 529
 530   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 531
 532   tmp0 = __byte_perm (        0, append[0], selector);
 533   tmp1 = __byte_perm (append[0], append[1], selector);
 534   tmp2 = __byte_perm (append[1], append[2], selector);
 535   tmp3 = __byte_perm (append[2], append[3], selector);
 536   tmp4 = __byte_perm (append[3],         0, selector);
 537   #endif
 538
 539   switch (div)
 540   {
 541     case  0:  block[ 0] |= tmp0;
 542               block[ 1]  = tmp1;
 543               block[ 2]  = tmp2;
 544               block[ 3]  = tmp3;
 545               block[ 4]  = tmp4;
 546               break;
 547     case  1:  block[ 1] |= tmp0;
 548               block[ 2]  = tmp1;
 549               block[ 3]  = tmp2;
 550               block[ 4]  = tmp3;
 551               block[ 5]  = tmp4;
 552               break;
 553     case  2:  block[ 2] |= tmp0;
 554               block[ 3]  = tmp1;
 555               block[ 4]  = tmp2;
 556               block[ 5]  = tmp3;
 557               block[ 6]  = tmp4;
 558               break;
 559     case  3:  block[ 3] |= tmp0;
 560               block[ 4]  = tmp1;
 561               block[ 5]  = tmp2;
 562               block[ 6]  = tmp3;
 563               block[ 7]  = tmp4;
 564               break;
 565     case  4:  block[ 4] |= tmp0;
 566               block[ 5]  = tmp1;
 567               block[ 6]  = tmp2;
 568               block[ 7]  = tmp3;
 569               block[ 8]  = tmp4;
 570               break;
 571     case  5:  block[ 5] |= tmp0;
 572               block[ 6]  = tmp1;
 573               block[ 7]  = tmp2;
 574               block[ 8]  = tmp3;
 575               block[ 9]  = tmp4;
 576               break;
 577     case  6:  block[ 6] |= tmp0;
 578               block[ 7]  = tmp1;
 579               block[ 8]  = tmp2;
 580               block[ 9]  = tmp3;
 581               block[10]  = tmp4;
 582               break;
 583     case  7:  block[ 7] |= tmp0;
 584               block[ 8]  = tmp1;
 585               block[ 9]  = tmp2;
 586               block[10]  = tmp3;
 587               block[11]  = tmp4;
 588               break;
 589     case  8:  block[ 8] |= tmp0;
 590               block[ 9]  = tmp1;
 591               block[10]  = tmp2;
 592               block[11]  = tmp3;
 593               block[12]  = tmp4;
 594               break;
 595     case  9:  block[ 9] |= tmp0;
 596               block[10]  = tmp1;
 597               block[11]  = tmp2;
 598               block[12]  = tmp3;
 599               block[13]  = tmp4;
 600               break;
 601     case 10:  block[10] |= tmp0;
 602               block[11]  = tmp1;
 603               block[12]  = tmp2;
 604               block[13]  = tmp3;
 605               block[14]  = tmp4;
 606               break;
 607     case 11:  block[11] |= tmp0;
 608               block[12]  = tmp1;
 609               block[13]  = tmp2;
 610               block[14]  = tmp3;
 611               block[15]  = tmp4;
 612               break;
 613     case 12:  block[12] |= tmp0;
 614               block[13]  = tmp1;
 615               block[14]  = tmp2;
 616               block[15]  = tmp3;
 617               block[16]  = tmp4;
 618               break;
 619     case 13:  block[13] |= tmp0;
 620               block[14]  = tmp1;
 621               block[15]  = tmp2;
 622               block[16]  = tmp3;
 623               block[17]  = tmp4;
 624               break;
 625     case 14:  block[14] |= tmp0;
 626               block[15]  = tmp1;
 627               block[16]  = tmp2;
 628               block[17]  = tmp3;
 629               block[18]  = tmp4;
 630               break;
 631     case 15:  block[15] |= tmp0;
 632               block[16]  = tmp1;
 633               block[17]  = tmp2;
 634               block[18]  = tmp3;
 635               block[19]  = tmp4;
 636               break;
 637   }
 638
 639   return block_len + append_len;
 640 }
 641
 642 u32 memcat20_x80 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 643 {
 644   const u32 mod = block_len & 3;
 645   const u32 div = block_len / 4;
 646
 647   u32 tmp0;
 648   u32 tmp1;
 649   u32 tmp2;
 650   u32 tmp3;
 651   u32 tmp4;
 652
 653   #if defined IS_AMD || defined IS_GENERIC
 654   const int offset_minus_4 = 4 - block_len;
 655
 656   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 657   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 658   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 659   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 660   tmp4 = amd_bytealign (     0x80, append[3], offset_minus_4);
 661
 662   if (mod == 0)
 663   {
 664     tmp0 = tmp1;
 665     tmp1 = tmp2;
 666     tmp2 = tmp3;
 667     tmp3 = tmp4;
 668     tmp4 = 0x80;
 669   }
 670   #endif
 671
 672   #ifdef IS_NV
 673   const int offset_minus_4 = 4 - (block_len & 3);
 674
 675   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 676
 677   tmp0 = __byte_perm (        0, append[0], selector);
 678   tmp1 = __byte_perm (append[0], append[1], selector);
 679   tmp2 = __byte_perm (append[1], append[2], selector);
 680   tmp3 = __byte_perm (append[2], append[3], selector);
 681   tmp4 = __byte_perm (append[3],      0x80, selector);
 682   #endif
 683
 684   switch (div)
 685   {
 686     case  0:  block[ 0] |= tmp0;
 687               block[ 1]  = tmp1;
 688               block[ 2]  = tmp2;
 689               block[ 3]  = tmp3;
 690               block[ 4]  = tmp4;
 691               break;
 692     case  1:  block[ 1] |= tmp0;
 693               block[ 2]  = tmp1;
 694               block[ 3]  = tmp2;
 695               block[ 4]  = tmp3;
 696               block[ 5]  = tmp4;
 697               break;
 698     case  2:  block[ 2] |= tmp0;
 699               block[ 3]  = tmp1;
 700               block[ 4]  = tmp2;
 701               block[ 5]  = tmp3;
 702               block[ 6]  = tmp4;
 703               break;
 704     case  3:  block[ 3] |= tmp0;
 705               block[ 4]  = tmp1;
 706               block[ 5]  = tmp2;
 707               block[ 6]  = tmp3;
 708               block[ 7]  = tmp4;
 709               break;
 710     case  4:  block[ 4] |= tmp0;
 711               block[ 5]  = tmp1;
 712               block[ 6]  = tmp2;
 713               block[ 7]  = tmp3;
 714               block[ 8]  = tmp4;
 715               break;
 716     case  5:  block[ 5] |= tmp0;
 717               block[ 6]  = tmp1;
 718               block[ 7]  = tmp2;
 719               block[ 8]  = tmp3;
 720               block[ 9]  = tmp4;
 721               break;
 722     case  6:  block[ 6] |= tmp0;
 723               block[ 7]  = tmp1;
 724               block[ 8]  = tmp2;
 725               block[ 9]  = tmp3;
 726               block[10]  = tmp4;
 727               break;
 728     case  7:  block[ 7] |= tmp0;
 729               block[ 8]  = tmp1;
 730               block[ 9]  = tmp2;
 731               block[10]  = tmp3;
 732               block[11]  = tmp4;
 733               break;
 734     case  8:  block[ 8] |= tmp0;
 735               block[ 9]  = tmp1;
 736               block[10]  = tmp2;
 737               block[11]  = tmp3;
 738               block[12]  = tmp4;
 739               break;
 740     case  9:  block[ 9] |= tmp0;
 741               block[10]  = tmp1;
 742               block[11]  = tmp2;
 743               block[12]  = tmp3;
 744               block[13]  = tmp4;
 745               break;
 746     case 10:  block[10] |= tmp0;
 747               block[11]  = tmp1;
 748               block[12]  = tmp2;
 749               block[13]  = tmp3;
 750               block[14]  = tmp4;
 751               break;
 752     case 11:  block[11] |= tmp0;
 753               block[12]  = tmp1;
 754               block[13]  = tmp2;
 755               block[14]  = tmp3;
 756               block[15]  = tmp4;
 757               break;
 758     case 12:  block[12] |= tmp0;
 759               block[13]  = tmp1;
 760               block[14]  = tmp2;
 761               block[15]  = tmp3;
 762               block[16]  = tmp4;
 763               break;
 764     case 13:  block[13] |= tmp0;
 765               block[14]  = tmp1;
 766               block[15]  = tmp2;
 767               block[16]  = tmp3;
 768               block[17]  = tmp4;
 769               break;
 770     case 14:  block[14] |= tmp0;
 771               block[15]  = tmp1;
 772               block[16]  = tmp2;
 773               block[17]  = tmp3;
 774               block[18]  = tmp4;
 775               break;
 776     case 15:  block[15] |= tmp0;
 777               block[16]  = tmp1;
 778               block[17]  = tmp2;
 779               block[18]  = tmp3;
 780               block[19]  = tmp4;
 781               break;
 782   }
 783
 784   return block_len + append_len;
 785 }
 786
 787 __kernel void m07400_init (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
 788 {
 789   /**
 790    * base
 791    */
 792
 793   const u32 gid = get_global_id (0);
 794
 795   if (gid >= gid_max) return;
 796
 797   u32 w0[4];
 798
 799   w0[0] = pws[gid].i[0];
 800   w0[1] = pws[gid].i[1];
 801   w0[2] = pws[gid].i[2];
 802   w0[3] = pws[gid].i[3];
 803
 804   const u32 pw_len = pws[gid].pw_len;
 805
 806   /**
 807    * salt
 808    */
 809
 810   u32 salt_buf[4];
 811
 812   salt_buf[0] = salt_bufs[salt_pos].salt_buf[0];
 813   salt_buf[1] = salt_bufs[salt_pos].salt_buf[1];
 814   salt_buf[2] = salt_bufs[salt_pos].salt_buf[2];
 815   salt_buf[3] = salt_bufs[salt_pos].salt_buf[3];
 816
 817   u32 salt_len = salt_bufs[salt_pos].salt_len;
 818
 819   /**
 820    * buffers
 821    */
 822
 823   u32 block_len;     // never reaches > 64
 824   u32 transform_len; // required for w[15] = len * 8
 825
 826   u32 block[16];
 827
 828   u32 alt_result[8];
 829   u32 p_bytes[8];
 830   u32 s_bytes[8];
 831
 832   /* Prepare for the real work.  */
 833
 834   block_len = 0;
 835
 836   bzero16 (block);
 837
 838   /* Add key.  */
 839
 840   block_len = memcat16 (block, block_len, w0, pw_len);
 841
 842   /* Add salt.  */
 843
 844   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 845
 846   /* Add key again.  */
 847
 848   block_len = memcat16 (block, block_len, w0, pw_len);
 849
 850   append_0x80_1x16 (block, block_len);
 851
 852   block[15] = swap32 (block_len * 8);
 853
 854   init_ctx (alt_result);
 855
 856   sha256_transform (block, alt_result);
 857
 858   bswap8 (alt_result);
 859
 860   block_len = 0;
 861
 862   bzero16 (block);
 863
 864   u32 alt_result_tmp[8];
 865
 866   alt_result_tmp[0] = alt_result[0];
 867   alt_result_tmp[1] = alt_result[1];
 868   alt_result_tmp[2] = alt_result[2];
 869   alt_result_tmp[3] = alt_result[3];
 870   alt_result_tmp[4] = 0;
 871   alt_result_tmp[5] = 0;
 872   alt_result_tmp[6] = 0;
 873   alt_result_tmp[7] = 0;
 874
 875   truncate_block (alt_result_tmp, pw_len);
 876
 877   /* Add the key string.  */
 878
 879   block_len = memcat16 (block, block_len, w0, pw_len);
 880
 881   /* The last part is the salt string.  This must be at most 8
 882      characters and it ends at the first `$' character (for
 883      compatibility with existing implementations).  */
 884
 885   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 886
 887   /* Now get result of this (32 bytes) and add it to the other
 888      context.  */
 889
 890   block_len = memcat16 (block, block_len, alt_result_tmp, pw_len);
 891
 892   transform_len = block_len;
 893
 894   /* Take the binary representation of the length of the key and for every
 895      1 add the alternate sum, for every 0 the key.  */
 896
 897   alt_result_tmp[0] = alt_result[0];
 898   alt_result_tmp[1] = alt_result[1];
 899   alt_result_tmp[2] = alt_result[2];
 900   alt_result_tmp[3] = alt_result[3];
 901   alt_result_tmp[4] = alt_result[4];
 902   alt_result_tmp[5] = alt_result[5];
 903   alt_result_tmp[6] = alt_result[6];
 904   alt_result_tmp[7] = alt_result[7];
 905
 906   init_ctx (alt_result);
 907
 908   for (u32 j = pw_len; j; j >>= 1)
 909   {
 910     if (j & 1)
 911     {
 912       block_len = memcat16c (block, block_len, &alt_result_tmp[0], 16, alt_result);
 913       block_len = memcat16c (block, block_len, &alt_result_tmp[4], 16, alt_result);
 914
 915       transform_len += 32;
 916     }
 917     else
 918     {
 919       block_len = memcat16c (block, block_len, w0, pw_len, alt_result);
 920
 921       transform_len += pw_len;
 922     }
 923   }
 924
 925   append_0x80_1x16 (block, block_len);
 926
 927   if (block_len >= 56)
 928   {
 929     sha256_transform (block, alt_result);
 930
 931     bzero16 (block);
 932   }
 933
 934   block[15] = swap32 (transform_len * 8);
 935
 936   sha256_transform (block, alt_result);
 937
 938   bswap8 (alt_result);
 939
 940   tmps[gid].alt_result[0] = alt_result[0];
 941   tmps[gid].alt_result[1] = alt_result[1];
 942   tmps[gid].alt_result[2] = alt_result[2];
 943   tmps[gid].alt_result[3] = alt_result[3];
 944   tmps[gid].alt_result[4] = alt_result[4];
 945   tmps[gid].alt_result[5] = alt_result[5];
 946   tmps[gid].alt_result[6] = alt_result[6];
 947   tmps[gid].alt_result[7] = alt_result[7];
 948
 949   /* Start computation of P byte sequence.  */
 950
 951   block_len = 0;
 952
 953   transform_len = 0;
 954
 955   bzero16 (block);
 956
 957   /* For every character in the password add the entire password.  */
 958
 959   init_ctx (p_bytes);
 960
 961   for (u32 j = 0; j < pw_len; j++)
 962   {
 963     block_len = memcat16c (block, block_len, w0, pw_len, p_bytes);
 964
 965     transform_len += pw_len;
 966   }
 967
 968   /* Finish the digest.  */
 969
 970   append_0x80_1x16 (block, block_len);
 971
 972   if (block_len >= 56)
 973   {
 974     sha256_transform (block, p_bytes);
 975
 976     bzero16 (block);
 977   }
 978
 979   block[15] = swap32 (transform_len * 8);
 980
 981   sha256_transform (block, p_bytes);
 982
 983   bswap8 (p_bytes);
 984
 985   truncate_block (p_bytes, pw_len);
 986
 987   tmps[gid].p_bytes[0] = p_bytes[0];
 988   tmps[gid].p_bytes[1] = p_bytes[1];
 989   tmps[gid].p_bytes[2] = p_bytes[2];
 990   tmps[gid].p_bytes[3] = p_bytes[3];
 991
 992   /* Start computation of S byte sequence.  */
 993
 994   block_len = 0;
 995
 996   transform_len = 0;
 997
 998   bzero16 (block);
 999
1000   /* For every character in the password add the entire password.  */
1001
1002   init_ctx (s_bytes);
1003
1004   for (u32 j = 0; j < 16 + (alt_result[0] & 0xff); j++)
1005   {
1006     block_len = memcat16c (block, block_len, salt_buf, salt_len, s_bytes);
1007
1008     transform_len += salt_len;
1009   }
1010
1011   /* Finish the digest.  */
1012
1013   append_0x80_1x16 (block, block_len);
1014
1015   if (block_len >= 56)
1016   {
1017     sha256_transform (block, s_bytes);
1018
1019     bzero16 (block);
1020   }
1021
1022   block[15] = swap32 (transform_len * 8);
1023
1024   sha256_transform (block, s_bytes);
1025
1026   bswap8 (s_bytes);
1027
1028   truncate_block (s_bytes, salt_len);
1029
1030   tmps[gid].s_bytes[0] = s_bytes[0];
1031   tmps[gid].s_bytes[1] = s_bytes[1];
1032   tmps[gid].s_bytes[2] = s_bytes[2];
1033   tmps[gid].s_bytes[3] = s_bytes[3];
1034 }
1035
1036 __kernel void m07400_loop (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1037 {
1038   /**
1039    * base
1040    */
1041
1042   const u32 gid = get_global_id (0);
1043
1044   if (gid >= gid_max) return;
1045
1046   const u32 pw_len = pws[gid].pw_len;
1047
1048   /**
1049    * base
1050    */
1051
1052   u32 p_bytes[4];
1053
1054   p_bytes[0] = tmps[gid].p_bytes[0];
1055   p_bytes[1] = tmps[gid].p_bytes[1];
1056   p_bytes[2] = tmps[gid].p_bytes[2];
1057   p_bytes[3] = tmps[gid].p_bytes[3];
1058
1059   u32 p_bytes_x80[4];
1060
1061   p_bytes_x80[0] = tmps[gid].p_bytes[0];
1062   p_bytes_x80[1] = tmps[gid].p_bytes[1];
1063   p_bytes_x80[2] = tmps[gid].p_bytes[2];
1064   p_bytes_x80[3] = tmps[gid].p_bytes[3];
1065
1066   append_0x80_1x4 (p_bytes_x80, pw_len);
1067
1068   u32 s_bytes[4];
1069
1070   s_bytes[0] = tmps[gid].s_bytes[0];
1071   s_bytes[1] = tmps[gid].s_bytes[1];
1072   s_bytes[2] = tmps[gid].s_bytes[2];
1073   s_bytes[3] = tmps[gid].s_bytes[3];
1074
1075   u32 alt_result[8];
1076
1077   alt_result[0] = tmps[gid].alt_result[0];
1078   alt_result[1] = tmps[gid].alt_result[1];
1079   alt_result[2] = tmps[gid].alt_result[2];
1080   alt_result[3] = tmps[gid].alt_result[3];
1081   alt_result[4] = tmps[gid].alt_result[4];
1082   alt_result[5] = tmps[gid].alt_result[5];
1083   alt_result[6] = tmps[gid].alt_result[6];
1084   alt_result[7] = tmps[gid].alt_result[7];
1085
1086   u32 salt_len = salt_bufs[salt_pos].salt_len;
1087
1088   /* Repeatedly run the collected hash value through SHA256 to burn
1089      CPU cycles.  */
1090
1091   for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
1092   {
1093     u32 tmp[8];
1094
1095     init_ctx (tmp);
1096
1097     u32 block[32];
1098
1099     bzero16 (&block[ 0]);
1100     bzero16 (&block[16]);
1101
1102     u32 block_len = 0;
1103
1104     const u32 j1 = (j & 1) ? 1 : 0;
1105     const u32 j3 = (j % 3) ? 1 : 0;
1106     const u32 j7 = (j % 7) ? 1 : 0;
1107
1108     if (j1)
1109     {
1110       block[0] = p_bytes[0];
1111       block[1] = p_bytes[1];
1112       block[2] = p_bytes[2];
1113       block[3] = p_bytes[3];
1114
1115       block_len = pw_len;
1116     }
1117     else
1118     {
1119       block[0] = alt_result[0];
1120       block[1] = alt_result[1];
1121       block[2] = alt_result[2];
1122       block[3] = alt_result[3];
1123       block[4] = alt_result[4];
1124       block[5] = alt_result[5];
1125       block[6] = alt_result[6];
1126       block[7] = alt_result[7];
1127
1128       block_len = 32;
1129     }
1130
1131     if (j3)
1132     {
1133       block_len = memcat20 (block, block_len, s_bytes, salt_len);
1134     }
1135
1136     if (j7)
1137     {
1138       block_len = memcat20 (block, block_len, p_bytes, pw_len);
1139     }
1140
1141     if (j1)
1142     {
1143       block_len = memcat20     (block, block_len, &alt_result[0], 16);
1144       block_len = memcat20_x80 (block, block_len, &alt_result[4], 16);
1145     }
1146     else
1147     {
1148       block_len = memcat20 (block, block_len, p_bytes_x80, pw_len);
1149     }
1150
1151     if (block_len >= 56)
1152     {
1153       sha256_transform (block, tmp);
1154
1155       block[ 0] = block[16];
1156       block[ 1] = block[17];
1157       block[ 2] = block[18];
1158       block[ 3] = block[19];
1159       block[ 4] = 0;
1160       block[ 5] = 0;
1161       block[ 6] = 0;
1162       block[ 7] = 0;
1163       block[ 8] = 0;
1164       block[ 9] = 0;
1165       block[10] = 0;
1166       block[11] = 0;
1167       block[12] = 0;
1168       block[13] = 0;
1169       block[14] = 0;
1170       block[15] = 0;
1171     }
1172
1173     block[15] = swap32 (block_len * 8);
1174
1175     sha256_transform_no14 (block, tmp);
1176
1177     bswap8 (tmp);
1178
1179     alt_result[0] = tmp[0];
1180     alt_result[1] = tmp[1];
1181     alt_result[2] = tmp[2];
1182     alt_result[3] = tmp[3];
1183     alt_result[4] = tmp[4];
1184     alt_result[5] = tmp[5];
1185     alt_result[6] = tmp[6];
1186     alt_result[7] = tmp[7];
1187   }
1188
1189   tmps[gid].alt_result[0] = alt_result[0];
1190   tmps[gid].alt_result[1] = alt_result[1];
1191   tmps[gid].alt_result[2] = alt_result[2];
1192   tmps[gid].alt_result[3] = alt_result[3];
1193   tmps[gid].alt_result[4] = alt_result[4];
1194   tmps[gid].alt_result[5] = alt_result[5];
1195   tmps[gid].alt_result[6] = alt_result[6];
1196   tmps[gid].alt_result[7] = alt_result[7];
1197 }
1198
1199 __kernel void m07400_comp (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1200 {
1201   /**
1202    * base
1203    */
1204
1205   const u32 gid = get_global_id (0);
1206
1207   if (gid >= gid_max) return;
1208
1209   const u32 lid = get_local_id (0);
1210
1211   const u32 r0 = tmps[gid].alt_result[0];
1212   const u32 r1 = tmps[gid].alt_result[1];
1213   const u32 r2 = tmps[gid].alt_result[2];
1214   const u32 r3 = tmps[gid].alt_result[3];
1215
1216   #define il_pos 0
1217
1218   #include COMPARE_M
1219 }