OpenCL/m07400.cl

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #define _SHA256_
   7
   8 #include "inc_vendor.cl"
   9 #include "inc_hash_constants.h"
  10 #include "inc_hash_functions.cl"
  11 #include "inc_types.cl"
  12 #include "inc_common.cl"
  13
  14 #define COMPARE_S "inc_comp_single.cl"
  15 #define COMPARE_M "inc_comp_multi.cl"
  16
  17 __constant u32 k_sha256[64] =
  18 {
  19   SHA256C00, SHA256C01, SHA256C02, SHA256C03,
  20   SHA256C04, SHA256C05, SHA256C06, SHA256C07,
  21   SHA256C08, SHA256C09, SHA256C0a, SHA256C0b,
  22   SHA256C0c, SHA256C0d, SHA256C0e, SHA256C0f,
  23   SHA256C10, SHA256C11, SHA256C12, SHA256C13,
  24   SHA256C14, SHA256C15, SHA256C16, SHA256C17,
  25   SHA256C18, SHA256C19, SHA256C1a, SHA256C1b,
  26   SHA256C1c, SHA256C1d, SHA256C1e, SHA256C1f,
  27   SHA256C20, SHA256C21, SHA256C22, SHA256C23,
  28   SHA256C24, SHA256C25, SHA256C26, SHA256C27,
  29   SHA256C28, SHA256C29, SHA256C2a, SHA256C2b,
  30   SHA256C2c, SHA256C2d, SHA256C2e, SHA256C2f,
  31   SHA256C30, SHA256C31, SHA256C32, SHA256C33,
  32   SHA256C34, SHA256C35, SHA256C36, SHA256C37,
  33   SHA256C38, SHA256C39, SHA256C3a, SHA256C3b,
  34   SHA256C3c, SHA256C3d, SHA256C3e, SHA256C3f,
  35 };
  36
  37 #if 1
  38
  39 void sha256_transform (const u32 w[16], u32 digest[8])
  40 {
  41   u32 a = digest[0];
  42   u32 b = digest[1];
  43   u32 c = digest[2];
  44   u32 d = digest[3];
  45   u32 e = digest[4];
  46   u32 f = digest[5];
  47   u32 g = digest[6];
  48   u32 h = digest[7];
  49
  50   u32 w0_t = swap32 (w[ 0]);
  51   u32 w1_t = swap32 (w[ 1]);
  52   u32 w2_t = swap32 (w[ 2]);
  53   u32 w3_t = swap32 (w[ 3]);
  54   u32 w4_t = swap32 (w[ 4]);
  55   u32 w5_t = swap32 (w[ 5]);
  56   u32 w6_t = swap32 (w[ 6]);
  57   u32 w7_t = swap32 (w[ 7]);
  58   u32 w8_t = swap32 (w[ 8]);
  59   u32 w9_t = swap32 (w[ 9]);
  60   u32 wa_t = swap32 (w[10]);
  61   u32 wb_t = swap32 (w[11]);
  62   u32 wc_t = swap32 (w[12]);
  63   u32 wd_t = swap32 (w[13]);
  64   u32 we_t = swap32 (w[14]);
  65   u32 wf_t = swap32 (w[15]);
  66
  67   #define ROUND_EXPAND()                            \
  68   {                                                 \
  69     w0_t = SHA256_EXPAND (we_t, w9_t, w1_t, w0_t);  \
  70     w1_t = SHA256_EXPAND (wf_t, wa_t, w2_t, w1_t);  \
  71     w2_t = SHA256_EXPAND (w0_t, wb_t, w3_t, w2_t);  \
  72     w3_t = SHA256_EXPAND (w1_t, wc_t, w4_t, w3_t);  \
  73     w4_t = SHA256_EXPAND (w2_t, wd_t, w5_t, w4_t);  \
  74     w5_t = SHA256_EXPAND (w3_t, we_t, w6_t, w5_t);  \
  75     w6_t = SHA256_EXPAND (w4_t, wf_t, w7_t, w6_t);  \
  76     w7_t = SHA256_EXPAND (w5_t, w0_t, w8_t, w7_t);  \
  77     w8_t = SHA256_EXPAND (w6_t, w1_t, w9_t, w8_t);  \
  78     w9_t = SHA256_EXPAND (w7_t, w2_t, wa_t, w9_t);  \
  79     wa_t = SHA256_EXPAND (w8_t, w3_t, wb_t, wa_t);  \
  80     wb_t = SHA256_EXPAND (w9_t, w4_t, wc_t, wb_t);  \
  81     wc_t = SHA256_EXPAND (wa_t, w5_t, wd_t, wc_t);  \
  82     wd_t = SHA256_EXPAND (wb_t, w6_t, we_t, wd_t);  \
  83     we_t = SHA256_EXPAND (wc_t, w7_t, wf_t, we_t);  \
  84     wf_t = SHA256_EXPAND (wd_t, w8_t, w0_t, wf_t);  \
  85   }
  86
  87   #define ROUND_STEP(i)                                                                   \
  88   {                                                                                       \
  89     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, k_sha256[i +  0]); \
  90     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, k_sha256[i +  1]); \
  91     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, k_sha256[i +  2]); \
  92     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, k_sha256[i +  3]); \
  93     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, k_sha256[i +  4]); \
  94     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, k_sha256[i +  5]); \
  95     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, k_sha256[i +  6]); \
  96     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, k_sha256[i +  7]); \
  97     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, k_sha256[i +  8]); \
  98     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, k_sha256[i +  9]); \
  99     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, k_sha256[i + 10]); \
 100     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, k_sha256[i + 11]); \
 101     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, k_sha256[i + 12]); \
 102     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, k_sha256[i + 13]); \
 103     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, k_sha256[i + 14]); \
 104     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, k_sha256[i + 15]); \
 105   }
 106
 107   ROUND_STEP (0);
 108
 109   #ifdef _unroll
 110   #pragma unroll
 111   #endif
 112   for (int i = 16; i < 64; i += 16)
 113   {
 114     ROUND_EXPAND (); ROUND_STEP (i);
 115   }
 116
 117   digest[0] += a;
 118   digest[1] += b;
 119   digest[2] += c;
 120   digest[3] += d;
 121   digest[4] += e;
 122   digest[5] += f;
 123   digest[6] += g;
 124   digest[7] += h;
 125 }
 126
 127 void sha256_transform_no14 (const u32 w[16], u32 digest[8])
 128 {
 129   u32 w_t[16];
 130
 131   w_t[ 0] = w[ 0];
 132   w_t[ 1] = w[ 1];
 133   w_t[ 2] = w[ 2];
 134   w_t[ 3] = w[ 3];
 135   w_t[ 4] = w[ 4];
 136   w_t[ 5] = w[ 5];
 137   w_t[ 6] = w[ 6];
 138   w_t[ 7] = w[ 7];
 139   w_t[ 8] = w[ 8];
 140   w_t[ 9] = w[ 9];
 141   w_t[10] = w[10];
 142   w_t[11] = w[11];
 143   w_t[12] = w[12];
 144   w_t[13] = w[13];
 145   w_t[14] = 0;
 146   w_t[15] = w[15];
 147
 148   sha256_transform (w_t, digest);
 149 }
 150
 151 void init_ctx (u32 digest[8])
 152 {
 153   digest[0] = SHA256M_A;
 154   digest[1] = SHA256M_B;
 155   digest[2] = SHA256M_C;
 156   digest[3] = SHA256M_D;
 157   digest[4] = SHA256M_E;
 158   digest[5] = SHA256M_F;
 159   digest[6] = SHA256M_G;
 160   digest[7] = SHA256M_H;
 161 }
 162
 163 void bzero16 (u32 block[16])
 164 {
 165   block[ 0] = 0;
 166   block[ 1] = 0;
 167   block[ 2] = 0;
 168   block[ 3] = 0;
 169   block[ 4] = 0;
 170   block[ 5] = 0;
 171   block[ 6] = 0;
 172   block[ 7] = 0;
 173   block[ 8] = 0;
 174   block[ 9] = 0;
 175   block[10] = 0;
 176   block[11] = 0;
 177   block[12] = 0;
 178   block[13] = 0;
 179   block[14] = 0;
 180   block[15] = 0;
 181 }
 182
 183 void bswap8 (u32 block[16])
 184 {
 185   block[ 0] = swap32 (block[ 0]);
 186   block[ 1] = swap32 (block[ 1]);
 187   block[ 2] = swap32 (block[ 2]);
 188   block[ 3] = swap32 (block[ 3]);
 189   block[ 4] = swap32 (block[ 4]);
 190   block[ 5] = swap32 (block[ 5]);
 191   block[ 6] = swap32 (block[ 6]);
 192   block[ 7] = swap32 (block[ 7]);
 193 }
 194
 195 u32 memcat16 (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len)
 196 {
 197   const u32 mod = block_len & 3;
 198   const u32 div = block_len / 4;
 199
 200   u32 tmp0;
 201   u32 tmp1;
 202   u32 tmp2;
 203   u32 tmp3;
 204   u32 tmp4;
 205
 206   #if defined IS_AMD || defined IS_GENERIC
 207   const int offset_minus_4 = 4 - block_len;
 208
 209   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 210   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 211   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 212   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 213   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 214
 215   if (mod == 0)
 216   {
 217     tmp0 = tmp1;
 218     tmp1 = tmp2;
 219     tmp2 = tmp3;
 220     tmp3 = tmp4;
 221     tmp4 = 0;
 222   }
 223   #endif
 224
 225   #ifdef IS_NV
 226   const int offset_minus_4 = 4 - (block_len & 3);
 227
 228   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 229
 230   tmp0 = __byte_perm (        0, append[0], selector);
 231   tmp1 = __byte_perm (append[0], append[1], selector);
 232   tmp2 = __byte_perm (append[1], append[2], selector);
 233   tmp3 = __byte_perm (append[2], append[3], selector);
 234   tmp4 = __byte_perm (append[3],         0, selector);
 235   #endif
 236
 237   switch (div)
 238   {
 239     case  0:  block[ 0] |= tmp0;
 240               block[ 1]  = tmp1;
 241               block[ 2]  = tmp2;
 242               block[ 3]  = tmp3;
 243               block[ 4]  = tmp4;
 244               break;
 245     case  1:  block[ 1] |= tmp0;
 246               block[ 2]  = tmp1;
 247               block[ 3]  = tmp2;
 248               block[ 4]  = tmp3;
 249               block[ 5]  = tmp4;
 250               break;
 251     case  2:  block[ 2] |= tmp0;
 252               block[ 3]  = tmp1;
 253               block[ 4]  = tmp2;
 254               block[ 5]  = tmp3;
 255               block[ 6]  = tmp4;
 256               break;
 257     case  3:  block[ 3] |= tmp0;
 258               block[ 4]  = tmp1;
 259               block[ 5]  = tmp2;
 260               block[ 6]  = tmp3;
 261               block[ 7]  = tmp4;
 262               break;
 263     case  4:  block[ 4] |= tmp0;
 264               block[ 5]  = tmp1;
 265               block[ 6]  = tmp2;
 266               block[ 7]  = tmp3;
 267               block[ 8]  = tmp4;
 268               break;
 269     case  5:  block[ 5] |= tmp0;
 270               block[ 6]  = tmp1;
 271               block[ 7]  = tmp2;
 272               block[ 8]  = tmp3;
 273               block[ 9]  = tmp4;
 274               break;
 275     case  6:  block[ 6] |= tmp0;
 276               block[ 7]  = tmp1;
 277               block[ 8]  = tmp2;
 278               block[ 9]  = tmp3;
 279               block[10]  = tmp4;
 280               break;
 281     case  7:  block[ 7] |= tmp0;
 282               block[ 8]  = tmp1;
 283               block[ 9]  = tmp2;
 284               block[10]  = tmp3;
 285               block[11]  = tmp4;
 286               break;
 287     case  8:  block[ 8] |= tmp0;
 288               block[ 9]  = tmp1;
 289               block[10]  = tmp2;
 290               block[11]  = tmp3;
 291               block[12]  = tmp4;
 292               break;
 293     case  9:  block[ 9] |= tmp0;
 294               block[10]  = tmp1;
 295               block[11]  = tmp2;
 296               block[12]  = tmp3;
 297               block[13]  = tmp4;
 298               break;
 299     case 10:  block[10] |= tmp0;
 300               block[11]  = tmp1;
 301               block[12]  = tmp2;
 302               block[13]  = tmp3;
 303               block[14]  = tmp4;
 304               break;
 305     case 11:  block[11] |= tmp0;
 306               block[12]  = tmp1;
 307               block[13]  = tmp2;
 308               block[14]  = tmp3;
 309               block[15]  = tmp4;
 310               break;
 311     case 12:  block[12] |= tmp0;
 312               block[13]  = tmp1;
 313               block[14]  = tmp2;
 314               block[15]  = tmp3;
 315               break;
 316     case 13:  block[13] |= tmp0;
 317               block[14]  = tmp1;
 318               block[15]  = tmp2;
 319               break;
 320     case 14:  block[14] |= tmp0;
 321               block[15]  = tmp1;
 322               break;
 323     case 15:  block[15] |= tmp0;
 324               break;
 325   }
 326
 327   u32 new_len = block_len + append_len;
 328
 329   return new_len;
 330 }
 331
 332 u32 memcat16c (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len, u32 digest[8])
 333 {
 334   const u32 mod = block_len & 3;
 335   const u32 div = block_len / 4;
 336
 337   u32 tmp0;
 338   u32 tmp1;
 339   u32 tmp2;
 340   u32 tmp3;
 341   u32 tmp4;
 342
 343   #if defined IS_AMD || defined IS_GENERIC
 344   const int offset_minus_4 = 4 - block_len;
 345
 346   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 347   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 348   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 349   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 350   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 351
 352   if (mod == 0)
 353   {
 354     tmp0 = tmp1;
 355     tmp1 = tmp2;
 356     tmp2 = tmp3;
 357     tmp3 = tmp4;
 358     tmp4 = 0;
 359   }
 360   #endif
 361
 362   #ifdef IS_NV
 363   const int offset_minus_4 = 4 - (block_len & 3);
 364
 365   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 366
 367   tmp0 = __byte_perm (        0, append[0], selector);
 368   tmp1 = __byte_perm (append[0], append[1], selector);
 369   tmp2 = __byte_perm (append[1], append[2], selector);
 370   tmp3 = __byte_perm (append[2], append[3], selector);
 371   tmp4 = __byte_perm (append[3],         0, selector);
 372   #endif
 373
 374   u32 carry[4] = { 0, 0, 0, 0 };
 375
 376   switch (div)
 377   {
 378     case  0:  block[ 0] |= tmp0;
 379               block[ 1]  = tmp1;
 380               block[ 2]  = tmp2;
 381               block[ 3]  = tmp3;
 382               block[ 4]  = tmp4;
 383               break;
 384     case  1:  block[ 1] |= tmp0;
 385               block[ 2]  = tmp1;
 386               block[ 3]  = tmp2;
 387               block[ 4]  = tmp3;
 388               block[ 5]  = tmp4;
 389               break;
 390     case  2:  block[ 2] |= tmp0;
 391               block[ 3]  = tmp1;
 392               block[ 4]  = tmp2;
 393               block[ 5]  = tmp3;
 394               block[ 6]  = tmp4;
 395               break;
 396     case  3:  block[ 3] |= tmp0;
 397               block[ 4]  = tmp1;
 398               block[ 5]  = tmp2;
 399               block[ 6]  = tmp3;
 400               block[ 7]  = tmp4;
 401               break;
 402     case  4:  block[ 4] |= tmp0;
 403               block[ 5]  = tmp1;
 404               block[ 6]  = tmp2;
 405               block[ 7]  = tmp3;
 406               block[ 8]  = tmp4;
 407               break;
 408     case  5:  block[ 5] |= tmp0;
 409               block[ 6]  = tmp1;
 410               block[ 7]  = tmp2;
 411               block[ 8]  = tmp3;
 412               block[ 9]  = tmp4;
 413               break;
 414     case  6:  block[ 6] |= tmp0;
 415               block[ 7]  = tmp1;
 416               block[ 8]  = tmp2;
 417               block[ 9]  = tmp3;
 418               block[10]  = tmp4;
 419               break;
 420     case  7:  block[ 7] |= tmp0;
 421               block[ 8]  = tmp1;
 422               block[ 9]  = tmp2;
 423               block[10]  = tmp3;
 424               block[11]  = tmp4;
 425               break;
 426     case  8:  block[ 8] |= tmp0;
 427               block[ 9]  = tmp1;
 428               block[10]  = tmp2;
 429               block[11]  = tmp3;
 430               block[12]  = tmp4;
 431               break;
 432     case  9:  block[ 9] |= tmp0;
 433               block[10]  = tmp1;
 434               block[11]  = tmp2;
 435               block[12]  = tmp3;
 436               block[13]  = tmp4;
 437               break;
 438     case 10:  block[10] |= tmp0;
 439               block[11]  = tmp1;
 440               block[12]  = tmp2;
 441               block[13]  = tmp3;
 442               block[14]  = tmp4;
 443               break;
 444     case 11:  block[11] |= tmp0;
 445               block[12]  = tmp1;
 446               block[13]  = tmp2;
 447               block[14]  = tmp3;
 448               block[15]  = tmp4;
 449               break;
 450     case 12:  block[12] |= tmp0;
 451               block[13]  = tmp1;
 452               block[14]  = tmp2;
 453               block[15]  = tmp3;
 454               carry[ 0]  = tmp4;
 455               break;
 456     case 13:  block[13] |= tmp0;
 457               block[14]  = tmp1;
 458               block[15]  = tmp2;
 459               carry[ 0]  = tmp3;
 460               carry[ 1]  = tmp4;
 461               break;
 462     case 14:  block[14] |= tmp0;
 463               block[15]  = tmp1;
 464               carry[ 0]  = tmp2;
 465               carry[ 1]  = tmp3;
 466               carry[ 2]  = tmp4;
 467               break;
 468     case 15:  block[15] |= tmp0;
 469               carry[ 0]  = tmp1;
 470               carry[ 1]  = tmp2;
 471               carry[ 2]  = tmp3;
 472               carry[ 3]  = tmp4;
 473               break;
 474   }
 475
 476   u32 new_len = block_len + append_len;
 477
 478   if (new_len >= 64)
 479   {
 480     new_len -= 64;
 481
 482     sha256_transform (block, digest);
 483
 484     bzero16 (block);
 485
 486     block[0] = carry[0];
 487     block[1] = carry[1];
 488     block[2] = carry[2];
 489     block[3] = carry[3];
 490   }
 491
 492   return new_len;
 493 }
 494
 495 u32 memcat20 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 496 {
 497   const u32 mod = block_len & 3;
 498   const u32 div = block_len / 4;
 499
 500   u32 tmp0;
 501   u32 tmp1;
 502   u32 tmp2;
 503   u32 tmp3;
 504   u32 tmp4;
 505
 506   #if defined IS_AMD || defined IS_GENERIC
 507   const int offset_minus_4 = 4 - block_len;
 508
 509   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 510   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 511   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 512   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 513   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 514
 515   if (mod == 0)
 516   {
 517     tmp0 = tmp1;
 518     tmp1 = tmp2;
 519     tmp2 = tmp3;
 520     tmp3 = tmp4;
 521     tmp4 = 0;
 522   }
 523   #endif
 524
 525   #ifdef IS_NV
 526   const int offset_minus_4 = 4 - (block_len & 3);
 527
 528   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 529
 530   tmp0 = __byte_perm (        0, append[0], selector);
 531   tmp1 = __byte_perm (append[0], append[1], selector);
 532   tmp2 = __byte_perm (append[1], append[2], selector);
 533   tmp3 = __byte_perm (append[2], append[3], selector);
 534   tmp4 = __byte_perm (append[3],         0, selector);
 535   #endif
 536
 537   switch (div)
 538   {
 539     case  0:  block[ 0] |= tmp0;
 540               block[ 1]  = tmp1;
 541               block[ 2]  = tmp2;
 542               block[ 3]  = tmp3;
 543               block[ 4]  = tmp4;
 544               break;
 545     case  1:  block[ 1] |= tmp0;
 546               block[ 2]  = tmp1;
 547               block[ 3]  = tmp2;
 548               block[ 4]  = tmp3;
 549               block[ 5]  = tmp4;
 550               break;
 551     case  2:  block[ 2] |= tmp0;
 552               block[ 3]  = tmp1;
 553               block[ 4]  = tmp2;
 554               block[ 5]  = tmp3;
 555               block[ 6]  = tmp4;
 556               break;
 557     case  3:  block[ 3] |= tmp0;
 558               block[ 4]  = tmp1;
 559               block[ 5]  = tmp2;
 560               block[ 6]  = tmp3;
 561               block[ 7]  = tmp4;
 562               break;
 563     case  4:  block[ 4] |= tmp0;
 564               block[ 5]  = tmp1;
 565               block[ 6]  = tmp2;
 566               block[ 7]  = tmp3;
 567               block[ 8]  = tmp4;
 568               break;
 569     case  5:  block[ 5] |= tmp0;
 570               block[ 6]  = tmp1;
 571               block[ 7]  = tmp2;
 572               block[ 8]  = tmp3;
 573               block[ 9]  = tmp4;
 574               break;
 575     case  6:  block[ 6] |= tmp0;
 576               block[ 7]  = tmp1;
 577               block[ 8]  = tmp2;
 578               block[ 9]  = tmp3;
 579               block[10]  = tmp4;
 580               break;
 581     case  7:  block[ 7] |= tmp0;
 582               block[ 8]  = tmp1;
 583               block[ 9]  = tmp2;
 584               block[10]  = tmp3;
 585               block[11]  = tmp4;
 586               break;
 587     case  8:  block[ 8] |= tmp0;
 588               block[ 9]  = tmp1;
 589               block[10]  = tmp2;
 590               block[11]  = tmp3;
 591               block[12]  = tmp4;
 592               break;
 593     case  9:  block[ 9] |= tmp0;
 594               block[10]  = tmp1;
 595               block[11]  = tmp2;
 596               block[12]  = tmp3;
 597               block[13]  = tmp4;
 598               break;
 599     case 10:  block[10] |= tmp0;
 600               block[11]  = tmp1;
 601               block[12]  = tmp2;
 602               block[13]  = tmp3;
 603               block[14]  = tmp4;
 604               break;
 605     case 11:  block[11] |= tmp0;
 606               block[12]  = tmp1;
 607               block[13]  = tmp2;
 608               block[14]  = tmp3;
 609               block[15]  = tmp4;
 610               break;
 611     case 12:  block[12] |= tmp0;
 612               block[13]  = tmp1;
 613               block[14]  = tmp2;
 614               block[15]  = tmp3;
 615               block[16]  = tmp4;
 616               break;
 617     case 13:  block[13] |= tmp0;
 618               block[14]  = tmp1;
 619               block[15]  = tmp2;
 620               block[16]  = tmp3;
 621               block[17]  = tmp4;
 622               break;
 623     case 14:  block[14] |= tmp0;
 624               block[15]  = tmp1;
 625               block[16]  = tmp2;
 626               block[17]  = tmp3;
 627               block[18]  = tmp4;
 628               break;
 629     case 15:  block[15] |= tmp0;
 630               block[16]  = tmp1;
 631               block[17]  = tmp2;
 632               block[18]  = tmp3;
 633               block[19]  = tmp4;
 634               break;
 635   }
 636
 637   return block_len + append_len;
 638 }
 639
 640 u32 memcat20_x80 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 641 {
 642   const u32 mod = block_len & 3;
 643   const u32 div = block_len / 4;
 644
 645   u32 tmp0;
 646   u32 tmp1;
 647   u32 tmp2;
 648   u32 tmp3;
 649   u32 tmp4;
 650
 651   #if defined IS_AMD || defined IS_GENERIC
 652   const int offset_minus_4 = 4 - block_len;
 653
 654   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 655   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 656   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 657   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 658   tmp4 = amd_bytealign (     0x80, append[3], offset_minus_4);
 659
 660   if (mod == 0)
 661   {
 662     tmp0 = tmp1;
 663     tmp1 = tmp2;
 664     tmp2 = tmp3;
 665     tmp3 = tmp4;
 666     tmp4 = 0x80;
 667   }
 668   #endif
 669
 670   #ifdef IS_NV
 671   const int offset_minus_4 = 4 - (block_len & 3);
 672
 673   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 674
 675   tmp0 = __byte_perm (        0, append[0], selector);
 676   tmp1 = __byte_perm (append[0], append[1], selector);
 677   tmp2 = __byte_perm (append[1], append[2], selector);
 678   tmp3 = __byte_perm (append[2], append[3], selector);
 679   tmp4 = __byte_perm (append[3],      0x80, selector);
 680   #endif
 681
 682   switch (div)
 683   {
 684     case  0:  block[ 0] |= tmp0;
 685               block[ 1]  = tmp1;
 686               block[ 2]  = tmp2;
 687               block[ 3]  = tmp3;
 688               block[ 4]  = tmp4;
 689               break;
 690     case  1:  block[ 1] |= tmp0;
 691               block[ 2]  = tmp1;
 692               block[ 3]  = tmp2;
 693               block[ 4]  = tmp3;
 694               block[ 5]  = tmp4;
 695               break;
 696     case  2:  block[ 2] |= tmp0;
 697               block[ 3]  = tmp1;
 698               block[ 4]  = tmp2;
 699               block[ 5]  = tmp3;
 700               block[ 6]  = tmp4;
 701               break;
 702     case  3:  block[ 3] |= tmp0;
 703               block[ 4]  = tmp1;
 704               block[ 5]  = tmp2;
 705               block[ 6]  = tmp3;
 706               block[ 7]  = tmp4;
 707               break;
 708     case  4:  block[ 4] |= tmp0;
 709               block[ 5]  = tmp1;
 710               block[ 6]  = tmp2;
 711               block[ 7]  = tmp3;
 712               block[ 8]  = tmp4;
 713               break;
 714     case  5:  block[ 5] |= tmp0;
 715               block[ 6]  = tmp1;
 716               block[ 7]  = tmp2;
 717               block[ 8]  = tmp3;
 718               block[ 9]  = tmp4;
 719               break;
 720     case  6:  block[ 6] |= tmp0;
 721               block[ 7]  = tmp1;
 722               block[ 8]  = tmp2;
 723               block[ 9]  = tmp3;
 724               block[10]  = tmp4;
 725               break;
 726     case  7:  block[ 7] |= tmp0;
 727               block[ 8]  = tmp1;
 728               block[ 9]  = tmp2;
 729               block[10]  = tmp3;
 730               block[11]  = tmp4;
 731               break;
 732     case  8:  block[ 8] |= tmp0;
 733               block[ 9]  = tmp1;
 734               block[10]  = tmp2;
 735               block[11]  = tmp3;
 736               block[12]  = tmp4;
 737               break;
 738     case  9:  block[ 9] |= tmp0;
 739               block[10]  = tmp1;
 740               block[11]  = tmp2;
 741               block[12]  = tmp3;
 742               block[13]  = tmp4;
 743               break;
 744     case 10:  block[10] |= tmp0;
 745               block[11]  = tmp1;
 746               block[12]  = tmp2;
 747               block[13]  = tmp3;
 748               block[14]  = tmp4;
 749               break;
 750     case 11:  block[11] |= tmp0;
 751               block[12]  = tmp1;
 752               block[13]  = tmp2;
 753               block[14]  = tmp3;
 754               block[15]  = tmp4;
 755               break;
 756     case 12:  block[12] |= tmp0;
 757               block[13]  = tmp1;
 758               block[14]  = tmp2;
 759               block[15]  = tmp3;
 760               block[16]  = tmp4;
 761               break;
 762     case 13:  block[13] |= tmp0;
 763               block[14]  = tmp1;
 764               block[15]  = tmp2;
 765               block[16]  = tmp3;
 766               block[17]  = tmp4;
 767               break;
 768     case 14:  block[14] |= tmp0;
 769               block[15]  = tmp1;
 770               block[16]  = tmp2;
 771               block[17]  = tmp3;
 772               block[18]  = tmp4;
 773               break;
 774     case 15:  block[15] |= tmp0;
 775               block[16]  = tmp1;
 776               block[17]  = tmp2;
 777               block[18]  = tmp3;
 778               block[19]  = tmp4;
 779               break;
 780   }
 781
 782   return block_len + append_len;
 783 }
 784
 785 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
 786 {
 787   /**
 788    * base
 789    */
 790
 791   const u32 gid = get_global_id (0);
 792
 793   if (gid >= gid_max) return;
 794
 795   u32 w0[4];
 796
 797   w0[0] = pws[gid].i[0];
 798   w0[1] = pws[gid].i[1];
 799   w0[2] = pws[gid].i[2];
 800   w0[3] = pws[gid].i[3];
 801
 802   const u32 pw_len = pws[gid].pw_len;
 803
 804   /**
 805    * salt
 806    */
 807
 808   u32 salt_buf[4];
 809
 810   salt_buf[0] = salt_bufs[salt_pos].salt_buf[0];
 811   salt_buf[1] = salt_bufs[salt_pos].salt_buf[1];
 812   salt_buf[2] = salt_bufs[salt_pos].salt_buf[2];
 813   salt_buf[3] = salt_bufs[salt_pos].salt_buf[3];
 814
 815   u32 salt_len = salt_bufs[salt_pos].salt_len;
 816
 817   /**
 818    * buffers
 819    */
 820
 821   u32 block_len;     // never reaches > 64
 822   u32 transform_len; // required for w[15] = len * 8
 823
 824   u32 block[16];
 825
 826   u32 alt_result[8];
 827   u32 p_bytes[8];
 828   u32 s_bytes[8];
 829
 830   /* Prepare for the real work.  */
 831
 832   block_len = 0;
 833
 834   bzero16 (block);
 835
 836   /* Add key.  */
 837
 838   block_len = memcat16 (block, block_len, w0, pw_len);
 839
 840   /* Add salt.  */
 841
 842   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 843
 844   /* Add key again.  */
 845
 846   block_len = memcat16 (block, block_len, w0, pw_len);
 847
 848   append_0x80_1x16 (block, block_len);
 849
 850   block[15] = swap32 (block_len * 8);
 851
 852   init_ctx (alt_result);
 853
 854   sha256_transform (block, alt_result);
 855
 856   bswap8 (alt_result);
 857
 858   block_len = 0;
 859
 860   bzero16 (block);
 861
 862   u32 alt_result_tmp[8];
 863
 864   alt_result_tmp[0] = alt_result[0];
 865   alt_result_tmp[1] = alt_result[1];
 866   alt_result_tmp[2] = alt_result[2];
 867   alt_result_tmp[3] = alt_result[3];
 868   alt_result_tmp[4] = 0;
 869   alt_result_tmp[5] = 0;
 870   alt_result_tmp[6] = 0;
 871   alt_result_tmp[7] = 0;
 872
 873   truncate_block (alt_result_tmp, pw_len);
 874
 875   /* Add the key string.  */
 876
 877   block_len = memcat16 (block, block_len, w0, pw_len);
 878
 879   /* The last part is the salt string.  This must be at most 8
 880      characters and it ends at the first `$' character (for
 881      compatibility with existing implementations).  */
 882
 883   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 884
 885   /* Now get result of this (32 bytes) and add it to the other
 886      context.  */
 887
 888   block_len = memcat16 (block, block_len, alt_result_tmp, pw_len);
 889
 890   transform_len = block_len;
 891
 892   /* Take the binary representation of the length of the key and for every
 893      1 add the alternate sum, for every 0 the key.  */
 894
 895   alt_result_tmp[0] = alt_result[0];
 896   alt_result_tmp[1] = alt_result[1];
 897   alt_result_tmp[2] = alt_result[2];
 898   alt_result_tmp[3] = alt_result[3];
 899   alt_result_tmp[4] = alt_result[4];
 900   alt_result_tmp[5] = alt_result[5];
 901   alt_result_tmp[6] = alt_result[6];
 902   alt_result_tmp[7] = alt_result[7];
 903
 904   init_ctx (alt_result);
 905
 906   for (u32 j = pw_len; j; j >>= 1)
 907   {
 908     if (j & 1)
 909     {
 910       block_len = memcat16c (block, block_len, &alt_result_tmp[0], 16, alt_result);
 911       block_len = memcat16c (block, block_len, &alt_result_tmp[4], 16, alt_result);
 912
 913       transform_len += 32;
 914     }
 915     else
 916     {
 917       block_len = memcat16c (block, block_len, w0, pw_len, alt_result);
 918
 919       transform_len += pw_len;
 920     }
 921   }
 922
 923   append_0x80_1x16 (block, block_len);
 924
 925   if (block_len >= 56)
 926   {
 927     sha256_transform (block, alt_result);
 928
 929     bzero16 (block);
 930   }
 931
 932   block[15] = swap32 (transform_len * 8);
 933
 934   sha256_transform (block, alt_result);
 935
 936   bswap8 (alt_result);
 937
 938   tmps[gid].alt_result[0] = alt_result[0];
 939   tmps[gid].alt_result[1] = alt_result[1];
 940   tmps[gid].alt_result[2] = alt_result[2];
 941   tmps[gid].alt_result[3] = alt_result[3];
 942   tmps[gid].alt_result[4] = alt_result[4];
 943   tmps[gid].alt_result[5] = alt_result[5];
 944   tmps[gid].alt_result[6] = alt_result[6];
 945   tmps[gid].alt_result[7] = alt_result[7];
 946
 947   /* Start computation of P byte sequence.  */
 948
 949   block_len = 0;
 950
 951   transform_len = 0;
 952
 953   bzero16 (block);
 954
 955   /* For every character in the password add the entire password.  */
 956
 957   init_ctx (p_bytes);
 958
 959   for (u32 j = 0; j < pw_len; j++)
 960   {
 961     block_len = memcat16c (block, block_len, w0, pw_len, p_bytes);
 962
 963     transform_len += pw_len;
 964   }
 965
 966   /* Finish the digest.  */
 967
 968   append_0x80_1x16 (block, block_len);
 969
 970   if (block_len >= 56)
 971   {
 972     sha256_transform (block, p_bytes);
 973
 974     bzero16 (block);
 975   }
 976
 977   block[15] = swap32 (transform_len * 8);
 978
 979   sha256_transform (block, p_bytes);
 980
 981   bswap8 (p_bytes);
 982
 983   truncate_block (p_bytes, pw_len);
 984
 985   tmps[gid].p_bytes[0] = p_bytes[0];
 986   tmps[gid].p_bytes[1] = p_bytes[1];
 987   tmps[gid].p_bytes[2] = p_bytes[2];
 988   tmps[gid].p_bytes[3] = p_bytes[3];
 989
 990   /* Start computation of S byte sequence.  */
 991
 992   block_len = 0;
 993
 994   transform_len = 0;
 995
 996   bzero16 (block);
 997
 998   /* For every character in the password add the entire password.  */
 999
1000   init_ctx (s_bytes);
1001
1002   for (u32 j = 0; j < 16 + (alt_result[0] & 0xff); j++)
1003   {
1004     block_len = memcat16c (block, block_len, salt_buf, salt_len, s_bytes);
1005
1006     transform_len += salt_len;
1007   }
1008
1009   /* Finish the digest.  */
1010
1011   append_0x80_1x16 (block, block_len);
1012
1013   if (block_len >= 56)
1014   {
1015     sha256_transform (block, s_bytes);
1016
1017     bzero16 (block);
1018   }
1019
1020   block[15] = swap32 (transform_len * 8);
1021
1022   sha256_transform (block, s_bytes);
1023
1024   bswap8 (s_bytes);
1025
1026   truncate_block (s_bytes, salt_len);
1027
1028   tmps[gid].s_bytes[0] = s_bytes[0];
1029   tmps[gid].s_bytes[1] = s_bytes[1];
1030   tmps[gid].s_bytes[2] = s_bytes[2];
1031   tmps[gid].s_bytes[3] = s_bytes[3];
1032 }
1033
1034 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
1035 {
1036   /**
1037    * base
1038    */
1039
1040   const u32 gid = get_global_id (0);
1041
1042   if (gid >= gid_max) return;
1043
1044   const u32 pw_len = pws[gid].pw_len;
1045
1046   /**
1047    * base
1048    */
1049
1050   u32 p_bytes[4];
1051
1052   p_bytes[0] = tmps[gid].p_bytes[0];
1053   p_bytes[1] = tmps[gid].p_bytes[1];
1054   p_bytes[2] = tmps[gid].p_bytes[2];
1055   p_bytes[3] = tmps[gid].p_bytes[3];
1056
1057   u32 p_bytes_x80[4];
1058
1059   p_bytes_x80[0] = tmps[gid].p_bytes[0];
1060   p_bytes_x80[1] = tmps[gid].p_bytes[1];
1061   p_bytes_x80[2] = tmps[gid].p_bytes[2];
1062   p_bytes_x80[3] = tmps[gid].p_bytes[3];
1063
1064   append_0x80_1x4 (p_bytes_x80, pw_len);
1065
1066   u32 s_bytes[4];
1067
1068   s_bytes[0] = tmps[gid].s_bytes[0];
1069   s_bytes[1] = tmps[gid].s_bytes[1];
1070   s_bytes[2] = tmps[gid].s_bytes[2];
1071   s_bytes[3] = tmps[gid].s_bytes[3];
1072
1073   u32 alt_result[8];
1074
1075   alt_result[0] = tmps[gid].alt_result[0];
1076   alt_result[1] = tmps[gid].alt_result[1];
1077   alt_result[2] = tmps[gid].alt_result[2];
1078   alt_result[3] = tmps[gid].alt_result[3];
1079   alt_result[4] = tmps[gid].alt_result[4];
1080   alt_result[5] = tmps[gid].alt_result[5];
1081   alt_result[6] = tmps[gid].alt_result[6];
1082   alt_result[7] = tmps[gid].alt_result[7];
1083
1084   u32 salt_len = salt_bufs[salt_pos].salt_len;
1085
1086   /* Repeatedly run the collected hash value through SHA256 to burn
1087      CPU cycles.  */
1088
1089   for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
1090   {
1091     u32 tmp[8];
1092
1093     init_ctx (tmp);
1094
1095     u32 block[32];
1096
1097     bzero16 (&block[ 0]);
1098     bzero16 (&block[16]);
1099
1100     u32 block_len = 0;
1101
1102     const u32 j1 = (j & 1) ? 1 : 0;
1103     const u32 j3 = (j % 3) ? 1 : 0;
1104     const u32 j7 = (j % 7) ? 1 : 0;
1105
1106     if (j1)
1107     {
1108       block[0] = p_bytes[0];
1109       block[1] = p_bytes[1];
1110       block[2] = p_bytes[2];
1111       block[3] = p_bytes[3];
1112
1113       block_len = pw_len;
1114     }
1115     else
1116     {
1117       block[0] = alt_result[0];
1118       block[1] = alt_result[1];
1119       block[2] = alt_result[2];
1120       block[3] = alt_result[3];
1121       block[4] = alt_result[4];
1122       block[5] = alt_result[5];
1123       block[6] = alt_result[6];
1124       block[7] = alt_result[7];
1125
1126       block_len = 32;
1127     }
1128
1129     if (j3)
1130     {
1131       block_len = memcat20 (block, block_len, s_bytes, salt_len);
1132     }
1133
1134     if (j7)
1135     {
1136       block_len = memcat20 (block, block_len, p_bytes, pw_len);
1137     }
1138
1139     if (j1)
1140     {
1141       block_len = memcat20     (block, block_len, &alt_result[0], 16);
1142       block_len = memcat20_x80 (block, block_len, &alt_result[4], 16);
1143     }
1144     else
1145     {
1146       block_len = memcat20 (block, block_len, p_bytes_x80, pw_len);
1147     }
1148
1149     if (block_len >= 56)
1150     {
1151       sha256_transform (block, tmp);
1152
1153       block[ 0] = block[16];
1154       block[ 1] = block[17];
1155       block[ 2] = block[18];
1156       block[ 3] = block[19];
1157       block[ 4] = 0;
1158       block[ 5] = 0;
1159       block[ 6] = 0;
1160       block[ 7] = 0;
1161       block[ 8] = 0;
1162       block[ 9] = 0;
1163       block[10] = 0;
1164       block[11] = 0;
1165       block[12] = 0;
1166       block[13] = 0;
1167       block[14] = 0;
1168       block[15] = 0;
1169     }
1170
1171     block[15] = swap32 (block_len * 8);
1172
1173     sha256_transform_no14 (block, tmp);
1174
1175     bswap8 (tmp);
1176
1177     alt_result[0] = tmp[0];
1178     alt_result[1] = tmp[1];
1179     alt_result[2] = tmp[2];
1180     alt_result[3] = tmp[3];
1181     alt_result[4] = tmp[4];
1182     alt_result[5] = tmp[5];
1183     alt_result[6] = tmp[6];
1184     alt_result[7] = tmp[7];
1185   }
1186
1187   tmps[gid].alt_result[0] = alt_result[0];
1188   tmps[gid].alt_result[1] = alt_result[1];
1189   tmps[gid].alt_result[2] = alt_result[2];
1190   tmps[gid].alt_result[3] = alt_result[3];
1191   tmps[gid].alt_result[4] = alt_result[4];
1192   tmps[gid].alt_result[5] = alt_result[5];
1193   tmps[gid].alt_result[6] = alt_result[6];
1194   tmps[gid].alt_result[7] = alt_result[7];
1195 }
1196
1197 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
1198 {
1199   /**
1200    * base
1201    */
1202
1203   const u32 gid = get_global_id (0);
1204
1205   if (gid >= gid_max) return;
1206
1207   const u32 lid = get_local_id (0);
1208
1209   const u32 r0 = tmps[gid].alt_result[0];
1210   const u32 r1 = tmps[gid].alt_result[1];
1211   const u32 r2 = tmps[gid].alt_result[2];
1212   const u32 r3 = tmps[gid].alt_result[3];
1213
1214   #define il_pos 0
1215
1216   #include COMPARE_M
1217 }
1218
1219 #else
1220
1221 // this is basically a much cleaner version, but apparently drops speeds by over 100% :(
1222
1223 #define PUTCHAR32_BE(a,p,c) ((u8 *)(a))[(p) ^ 3] = (u8) (c)
1224 #define GETCHAR32_BE(a,p)   ((u8 *)(a))[(p) ^ 3]
1225
1226 typedef struct
1227 {
1228   u32 state[8];
1229   u32 buf[32];
1230   int len;
1231
1232 } sha256_ctx_t;
1233
1234 void sha256_transform (const u32 w[16], u32 digest[8])
1235 {
1236   u32 a = digest[0];
1237   u32 b = digest[1];
1238   u32 c = digest[2];
1239   u32 d = digest[3];
1240   u32 e = digest[4];
1241   u32 f = digest[5];
1242   u32 g = digest[6];
1243   u32 h = digest[7];
1244
1245   u32 w0_t = w[ 0];
1246   u32 w1_t = w[ 1];
1247   u32 w2_t = w[ 2];
1248   u32 w3_t = w[ 3];
1249   u32 w4_t = w[ 4];
1250   u32 w5_t = w[ 5];
1251   u32 w6_t = w[ 6];
1252   u32 w7_t = w[ 7];
1253   u32 w8_t = w[ 8];
1254   u32 w9_t = w[ 9];
1255   u32 wa_t = w[10];
1256   u32 wb_t = w[11];
1257   u32 wc_t = w[12];
1258   u32 wd_t = w[13];
1259   u32 we_t = w[14];
1260   u32 wf_t = w[15];
1261
1262   #define ROUND_EXPAND()                            \
1263   {                                                 \
1264     w0_t = SHA256_EXPAND (we_t, w9_t, w1_t, w0_t);  \
1265     w1_t = SHA256_EXPAND (wf_t, wa_t, w2_t, w1_t);  \
1266     w2_t = SHA256_EXPAND (w0_t, wb_t, w3_t, w2_t);  \
1267     w3_t = SHA256_EXPAND (w1_t, wc_t, w4_t, w3_t);  \
1268     w4_t = SHA256_EXPAND (w2_t, wd_t, w5_t, w4_t);  \
1269     w5_t = SHA256_EXPAND (w3_t, we_t, w6_t, w5_t);  \
1270     w6_t = SHA256_EXPAND (w4_t, wf_t, w7_t, w6_t);  \
1271     w7_t = SHA256_EXPAND (w5_t, w0_t, w8_t, w7_t);  \
1272     w8_t = SHA256_EXPAND (w6_t, w1_t, w9_t, w8_t);  \
1273     w9_t = SHA256_EXPAND (w7_t, w2_t, wa_t, w9_t);  \
1274     wa_t = SHA256_EXPAND (w8_t, w3_t, wb_t, wa_t);  \
1275     wb_t = SHA256_EXPAND (w9_t, w4_t, wc_t, wb_t);  \
1276     wc_t = SHA256_EXPAND (wa_t, w5_t, wd_t, wc_t);  \
1277     wd_t = SHA256_EXPAND (wb_t, w6_t, we_t, wd_t);  \
1278     we_t = SHA256_EXPAND (wc_t, w7_t, wf_t, we_t);  \
1279     wf_t = SHA256_EXPAND (wd_t, w8_t, w0_t, wf_t);  \
1280   }
1281
1282   #define ROUND_STEP(i)                                                                   \
1283   {                                                                                       \
1284     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, k_sha256[i +  0]); \
1285     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, k_sha256[i +  1]); \
1286     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, k_sha256[i +  2]); \
1287     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, k_sha256[i +  3]); \
1288     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, k_sha256[i +  4]); \
1289     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, k_sha256[i +  5]); \
1290     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, k_sha256[i +  6]); \
1291     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, k_sha256[i +  7]); \
1292     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, k_sha256[i +  8]); \
1293     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, k_sha256[i +  9]); \
1294     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, k_sha256[i + 10]); \
1295     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, k_sha256[i + 11]); \
1296     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, k_sha256[i + 12]); \
1297     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, k_sha256[i + 13]); \
1298     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, k_sha256[i + 14]); \
1299     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, k_sha256[i + 15]); \
1300   }
1301
1302   ROUND_STEP (0);
1303
1304   #ifdef _unroll
1305   #pragma unroll
1306   #endif
1307   for (int i = 16; i < 64; i += 16)
1308   {
1309     ROUND_EXPAND (); ROUND_STEP (i);
1310   }
1311
1312   digest[0] += a;
1313   digest[1] += b;
1314   digest[2] += c;
1315   digest[3] += d;
1316   digest[4] += e;
1317   digest[5] += f;
1318   digest[6] += g;
1319   digest[7] += h;
1320 }
1321
1322 void sha256_init (sha256_ctx_t *sha256_ctx)
1323 {
1324   sha256_ctx->state[0] = SHA256M_A;
1325   sha256_ctx->state[1] = SHA256M_B;
1326   sha256_ctx->state[2] = SHA256M_C;
1327   sha256_ctx->state[3] = SHA256M_D;
1328   sha256_ctx->state[4] = SHA256M_E;
1329   sha256_ctx->state[5] = SHA256M_F;
1330   sha256_ctx->state[6] = SHA256M_G;
1331   sha256_ctx->state[7] = SHA256M_H;
1332
1333   sha256_ctx->len = 0;
1334 }
1335
1336 void sha256_update (sha256_ctx_t *sha256_ctx, const u32 *buf, int len)
1337 {
1338   int pos = sha256_ctx->len & 0x3f;
1339
1340   sha256_ctx->len += len;
1341
1342   if ((pos + len) < 64)
1343   {
1344     for (int i = 0; i < len; i++)
1345     {
1346       PUTCHAR32_BE (sha256_ctx->buf, pos++, GETCHAR32_BE (buf, i));
1347     }
1348
1349     return;
1350   }
1351
1352   int cnt = 64 - pos;
1353
1354   for (int i = 0; i < cnt; i++)
1355   {
1356     PUTCHAR32_BE (sha256_ctx->buf, pos++, GETCHAR32_BE (buf, i));
1357   }
1358
1359   sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1360
1361   len -= cnt;
1362
1363   for (int i = 0; i < len; i++)
1364   {
1365     PUTCHAR32_BE (sha256_ctx->buf, i, GETCHAR32_BE (buf, cnt + i));
1366   }
1367 }
1368
1369 void sha256_final (sha256_ctx_t *sha256_ctx)
1370 {
1371   int pos = sha256_ctx->len & 0x3f;
1372
1373   for (int i = pos; i < 64; i++)
1374   {
1375     PUTCHAR32_BE (sha256_ctx->buf, i, 0);
1376   }
1377
1378   PUTCHAR32_BE (sha256_ctx->buf, pos, 0x80);
1379
1380   if (pos >= 56)
1381   {
1382     sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1383
1384     sha256_ctx->buf[ 0] = 0;
1385     sha256_ctx->buf[ 1] = 0;
1386     sha256_ctx->buf[ 2] = 0;
1387     sha256_ctx->buf[ 3] = 0;
1388     sha256_ctx->buf[ 4] = 0;
1389     sha256_ctx->buf[ 5] = 0;
1390     sha256_ctx->buf[ 6] = 0;
1391     sha256_ctx->buf[ 7] = 0;
1392     sha256_ctx->buf[ 8] = 0;
1393     sha256_ctx->buf[ 9] = 0;
1394     sha256_ctx->buf[10] = 0;
1395     sha256_ctx->buf[11] = 0;
1396     sha256_ctx->buf[12] = 0;
1397     sha256_ctx->buf[13] = 0;
1398     sha256_ctx->buf[14] = 0;
1399     sha256_ctx->buf[15] = 0;
1400   }
1401
1402   sha256_ctx->buf[15] = sha256_ctx->len * 8;
1403
1404   sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1405 }
1406
1407 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
1408 {
1409   /**
1410    * base
1411    */
1412
1413   const u32 gid = get_global_id (0);
1414
1415   if (gid >= gid_max) return;
1416
1417   u32 pw[4];
1418
1419   pw[0] = swap32 (pws[gid].i[0]);
1420   pw[1] = swap32 (pws[gid].i[1]);
1421   pw[2] = swap32 (pws[gid].i[2]);
1422   pw[3] = swap32 (pws[gid].i[3]);
1423
1424   const u32 pw_len = pws[gid].pw_len;
1425
1426   /**
1427    * salt
1428    */
1429
1430   u32 salt[4];
1431
1432   salt[0] = swap32 (salt_bufs[salt_pos].salt_buf[0]);
1433   salt[1] = swap32 (salt_bufs[salt_pos].salt_buf[1]);
1434   salt[2] = swap32 (salt_bufs[salt_pos].salt_buf[2]);
1435   salt[3] = swap32 (salt_bufs[salt_pos].salt_buf[3]);
1436
1437   u32 salt_len = salt_bufs[salt_pos].salt_len;
1438
1439   /**
1440    * begin
1441    */
1442
1443   sha256_ctx_t sha256_ctx;
1444
1445   sha256_init (&sha256_ctx);
1446
1447   sha256_update (&sha256_ctx, pw, pw_len);
1448   sha256_update (&sha256_ctx, salt, salt_len);
1449   sha256_update (&sha256_ctx, pw, pw_len);
1450
1451   sha256_final (&sha256_ctx);
1452
1453   u32 tmp[8];
1454
1455   tmp[0] = sha256_ctx.state[0];
1456   tmp[1] = sha256_ctx.state[1];
1457   tmp[2] = sha256_ctx.state[2];
1458   tmp[3] = sha256_ctx.state[3];
1459   tmp[4] = sha256_ctx.state[4];
1460   tmp[5] = sha256_ctx.state[5];
1461   tmp[6] = sha256_ctx.state[6];
1462   tmp[7] = sha256_ctx.state[7];
1463
1464   sha256_init (&sha256_ctx);
1465
1466   sha256_update (&sha256_ctx, pw, pw_len);
1467   sha256_update (&sha256_ctx, salt, salt_len);
1468   sha256_update (&sha256_ctx, tmp, pw_len);
1469
1470   for (u32 j = pw_len; j; j >>= 1)
1471   {
1472     if (j & 1)
1473     {
1474       sha256_update (&sha256_ctx, tmp, 32);
1475     }
1476     else
1477     {
1478       sha256_update (&sha256_ctx, pw, pw_len);
1479     }
1480   }
1481
1482   sha256_final (&sha256_ctx);
1483
1484   tmps[gid].alt_result[0] = sha256_ctx.state[0];
1485   tmps[gid].alt_result[1] = sha256_ctx.state[1];
1486   tmps[gid].alt_result[2] = sha256_ctx.state[2];
1487   tmps[gid].alt_result[3] = sha256_ctx.state[3];
1488   tmps[gid].alt_result[4] = sha256_ctx.state[4];
1489   tmps[gid].alt_result[5] = sha256_ctx.state[5];
1490   tmps[gid].alt_result[6] = sha256_ctx.state[6];
1491   tmps[gid].alt_result[7] = sha256_ctx.state[7];
1492
1493   // p_bytes
1494
1495   sha256_init (&sha256_ctx);
1496
1497   for (u32 j = 0; j < pw_len; j++)
1498   {
1499     sha256_update (&sha256_ctx, pw, pw_len);
1500   }
1501
1502   sha256_final (&sha256_ctx);
1503
1504   tmps[gid].p_bytes[0] = sha256_ctx.state[0];
1505   tmps[gid].p_bytes[1] = sha256_ctx.state[1];
1506   tmps[gid].p_bytes[2] = sha256_ctx.state[2];
1507   tmps[gid].p_bytes[3] = sha256_ctx.state[3];
1508
1509   // s_bytes
1510
1511   sha256_init (&sha256_ctx);
1512
1513   for (u32 j = 0; j < 16 + ((tmps[gid].alt_result[0] >> 24) & 0xff); j++)
1514   {
1515     sha256_update (&sha256_ctx, salt, salt_len);
1516   }
1517
1518   sha256_final (&sha256_ctx);
1519
1520   tmps[gid].s_bytes[0] = sha256_ctx.state[0];
1521   tmps[gid].s_bytes[1] = sha256_ctx.state[1];
1522   tmps[gid].s_bytes[2] = sha256_ctx.state[2];
1523   tmps[gid].s_bytes[3] = sha256_ctx.state[3];
1524 }
1525
1526 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
1527 {
1528   /**
1529    * base
1530    */
1531
1532   const u32 gid = get_global_id (0);
1533
1534   if (gid >= gid_max) return;
1535
1536   u32 p_bytes0[4];
1537
1538   p_bytes0[0] = tmps[gid].p_bytes[0];
1539   p_bytes0[1] = tmps[gid].p_bytes[1];
1540   p_bytes0[2] = tmps[gid].p_bytes[2];
1541   p_bytes0[3] = tmps[gid].p_bytes[3];
1542
1543   const u32 pw_len = pws[gid].pw_len;
1544
1545   u32 s_bytes0[4];
1546
1547   s_bytes0[0] = tmps[gid].s_bytes[0];
1548   s_bytes0[1] = tmps[gid].s_bytes[1];
1549   s_bytes0[2] = tmps[gid].s_bytes[2];
1550   s_bytes0[3] = tmps[gid].s_bytes[3];
1551
1552   const u32 salt_len = salt_bufs[salt_pos].salt_len;
1553
1554   u32 wpc_len[8];
1555
1556   wpc_len[0] = 32     +        0 +      0 + pw_len;
1557   wpc_len[1] = pw_len +        0 +      0 + 32;
1558   wpc_len[2] = 32     + salt_len +      0 + pw_len;
1559   wpc_len[3] = pw_len + salt_len +      0 + 32;
1560   wpc_len[4] = 32     +        0 + pw_len + pw_len;
1561   wpc_len[5] = pw_len +        0 + pw_len + 32;
1562   wpc_len[6] = 32     + salt_len + pw_len + pw_len;
1563   wpc_len[7] = pw_len + salt_len + pw_len + 32;
1564
1565   u32 wpc[8][32] = { { 0 } };
1566
1567   for (u32 i = 0; i < 8; i++)
1568   {
1569     u32 block_len = 0;
1570
1571     if (i & 1)
1572     {
1573       for (u32 j = 0; j < pw_len; j++)
1574       {
1575         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1576       }
1577     }
1578     else
1579     {
1580       block_len += 32;
1581     }
1582
1583     if (i & 2)
1584     {
1585       for (u32 j = 0; j < salt_len; j++)
1586       {
1587         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (s_bytes0, j));
1588       }
1589     }
1590
1591     if (i & 4)
1592     {
1593       for (u32 j = 0; j < pw_len; j++)
1594       {
1595         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1596       }
1597     }
1598
1599     if (i & 1)
1600     {
1601       block_len += 32;
1602     }
1603     else
1604     {
1605       for (u32 j = 0; j < pw_len; j++)
1606       {
1607         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1608       }
1609     }
1610
1611     PUTCHAR32_BE (wpc[i], block_len, 0x80);
1612
1613     if (block_len < 56)
1614     {
1615       wpc[i][15] = block_len * 8;
1616     }
1617     else
1618     {
1619       wpc[i][31] = block_len * 8;
1620     }
1621   }
1622
1623   /**
1624    * base
1625    */
1626
1627   u32 alt_result[8];
1628
1629   alt_result[0] = tmps[gid].alt_result[0];
1630   alt_result[1] = tmps[gid].alt_result[1];
1631   alt_result[2] = tmps[gid].alt_result[2];
1632   alt_result[3] = tmps[gid].alt_result[3];
1633   alt_result[4] = tmps[gid].alt_result[4];
1634   alt_result[5] = tmps[gid].alt_result[5];
1635   alt_result[6] = tmps[gid].alt_result[6];
1636   alt_result[7] = tmps[gid].alt_result[7];
1637
1638
1639   /* Repeatedly run the collected hash value through SHA256 to burn
1640      CPU cycles.  */
1641
1642   for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
1643   {
1644     const u32 j1 = (j & 1) ? 1 : 0;
1645     const u32 j3 = (j % 3) ? 2 : 0;
1646     const u32 j7 = (j % 7) ? 4 : 0;
1647
1648     const u32 pc = j1 + j3 + j7;
1649
1650     u32 block[32];
1651
1652     block[ 0] = wpc[pc][ 0];
1653     block[ 1] = wpc[pc][ 1];
1654     block[ 2] = wpc[pc][ 2];
1655     block[ 3] = wpc[pc][ 3];
1656     block[ 4] = wpc[pc][ 4];
1657     block[ 5] = wpc[pc][ 5];
1658     block[ 6] = wpc[pc][ 6];
1659     block[ 7] = wpc[pc][ 7];
1660     block[ 8] = wpc[pc][ 8];
1661     block[ 9] = wpc[pc][ 9];
1662     block[10] = wpc[pc][10];
1663     block[11] = wpc[pc][11];
1664     block[12] = wpc[pc][12];
1665     block[13] = wpc[pc][13];
1666     block[14] = wpc[pc][14];
1667     block[15] = wpc[pc][15];
1668     block[16] = wpc[pc][16];
1669     block[17] = wpc[pc][17];
1670     block[18] = wpc[pc][18];
1671     block[19] = wpc[pc][19];
1672     block[20] = wpc[pc][20];
1673     block[21] = wpc[pc][21];
1674     block[22] = wpc[pc][22];
1675     block[23] = wpc[pc][23];
1676     block[24] = wpc[pc][24];
1677     block[25] = wpc[pc][25];
1678     block[26] = wpc[pc][26];
1679     block[27] = wpc[pc][27];
1680     block[28] = wpc[pc][28];
1681     block[29] = wpc[pc][29];
1682     block[30] = wpc[pc][30];
1683     block[31] = wpc[pc][31];
1684
1685     const u32 block_len = wpc_len[pc];
1686
1687     if (j1)
1688     {
1689       #ifdef _unroll
1690       #pragma unroll
1691       #endif
1692       for (u32 k = 0, p = block_len - 32; k < 32; k++, p++)
1693       {
1694         PUTCHAR32_BE (block, p, GETCHAR32_BE (alt_result, k));
1695       }
1696     }
1697     else
1698     {
1699       block[0] = alt_result[0];
1700       block[1] = alt_result[1];
1701       block[2] = alt_result[2];
1702       block[3] = alt_result[3];
1703       block[4] = alt_result[4];
1704       block[5] = alt_result[5];
1705       block[6] = alt_result[6];
1706       block[7] = alt_result[7];
1707     }
1708
1709     alt_result[0] = SHA256M_A;
1710     alt_result[1] = SHA256M_B;
1711     alt_result[2] = SHA256M_C;
1712     alt_result[3] = SHA256M_D;
1713     alt_result[4] = SHA256M_E;
1714     alt_result[5] = SHA256M_F;
1715     alt_result[6] = SHA256M_G;
1716     alt_result[7] = SHA256M_H;
1717
1718     sha256_transform (block, alt_result);
1719
1720     if (block_len >= 56)
1721     {
1722       sha256_transform (block + 16, alt_result);
1723     }
1724   }
1725
1726   tmps[gid].alt_result[0] = alt_result[0];
1727   tmps[gid].alt_result[1] = alt_result[1];
1728   tmps[gid].alt_result[2] = alt_result[2];
1729   tmps[gid].alt_result[3] = alt_result[3];
1730   tmps[gid].alt_result[4] = alt_result[4];
1731   tmps[gid].alt_result[5] = alt_result[5];
1732   tmps[gid].alt_result[6] = alt_result[6];
1733   tmps[gid].alt_result[7] = alt_result[7];
1734 }
1735
1736 __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_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_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)
1737 {
1738   /**
1739    * base
1740    */
1741
1742   const u32 gid = get_global_id (0);
1743
1744   if (gid >= gid_max) return;
1745
1746   const u32 lid = get_local_id (0);
1747
1748   const u32 r0 = swap32 (tmps[gid].alt_result[0]);
1749   const u32 r1 = swap32 (tmps[gid].alt_result[1]);
1750   const u32 r2 = swap32 (tmps[gid].alt_result[2]);
1751   const u32 r3 = swap32 (tmps[gid].alt_result[3]);
1752
1753   #define il_pos 0
1754
1755   #include COMPARE_M
1756 }
1757
1758 #endif