OpenCL/m07400.cl

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