OpenCL/m07400.cl

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