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