Want to implement SHA3-256 with Iterations

[magooie]

Hello!

I try to implement sha3-256 with multiple iterations on the basis of m05000_a0.cl. The kernel code is quite difficult to understand. Perhaps someone might be interested in it and would like to help. I tried something like this. Any idea? Im am guessing around about the details. It is quite simple. First iteration: make sha3-256 of password, next make sha3-256 of the last hash. I am struggeling with the details and do not fully understand the implementation

Code:

__
kernel void m05000_m04 (...)
{
 /**
  * modifier
  */

 const u32 lid = get_local_id (0);

 /**
  * base
  */

 const u32 gid = get_global_id (0);

 if (gid >= gid_max) return;

 u32 pw_buf0[4];
 u32 pw_buf1[4];

 pw_buf0[0] = pws[gid].i[0];
 pw_buf0[1] = pws[gid].i[1];
 pw_buf0[2] = pws[gid].i[2];
 pw_buf0[3] = pws[gid].i[3];
 pw_buf1[0] = pws[gid].i[4];
 pw_buf1[1] = pws[gid].i[5];
 pw_buf1[2] = pws[gid].i[6];
 pw_buf1[3] = pws[gid].i[7];

 const u32 pw_len = pws[gid].pw_len;

 /**
  * constants
  */

 const u8 keccakf_rotc[24] =
 {
    1,  3,  6, 10, 15, 21, 28, 36, 45, 55,  2, 14,
   27, 41, 56,  8, 25, 43, 62, 18, 39, 61, 20, 44
 };

 const u8 keccakf_piln[24] =
 {
   10,  7, 11, 17, 18,  3,  5, 16,  8, 21, 24,  4,
   15, 23, 19, 13, 12,  2, 20, 14, 22,  9,  6,  1
 };

 /**
  * 0x80 keccak, very special
  */

 const u32 mdlen = salt_bufs[salt_pos].keccak_mdlen;
/* ###################### NEW */
 /*
  * All the SHA-3 functions share code structure.  They
  * differ only in the size of the chunks they split the message into:
  * for digest size d, they are split into chunks of 200 - mdlen bytes.
  * So for several rounds mdlen = 32 (this is 256bit). For add80w we get 16
  */
 const u32 rsiz = 200 - (2 * mdlen);

 const u32 add80w = (rsiz - 1) / 8;
 const u32 add80w_256bit_input = 16; /* ###################### NEW */

 /**
  * loop
  */

 for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
 {
   u32x w0[4] = { 0 };
   u32x w1[4] = { 0 };
   u32x w2[4] = { 0 };
   u32x w3[4] = { 0 };
   
   u64x st_roundResult[4] = {0};
   
   const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);

   append_0x01_2x4_VV (w0, w1, out_len);

   /**
    * Keccak
    */

   u64x st[25];

   int round;
   int hashIter; /* ###################### NEW */
   for (hashIter = 0; hashIter < HASHITER_NUM; hashIter++)
   {
       if(hashIter == 0)
       {
           st[ 0] = hl32_to_64 (w0[1], w0[0]);
           st[ 1] = hl32_to_64 (w0[3], w0[2]);
           st[ 2] = hl32_to_64 (w1[1], w1[0]);
           st[ 3] = hl32_to_64 (w1[3], w1[2]);
           st[ 4] = 0;
           st[ 5] = 0;
           st[ 6] = 0;
           st[ 7] = 0;
           st[ 8] = 0;
           st[ 9] = 0;
           st[10] = 0;
           st[11] = 0;
           st[12] = 0;
           st[13] = 0;
           st[14] = 0;
           st[15] = 0;
           st[16] = 0;
           st[17] = 0;
           st[18] = 0;
           st[19] = 0;
           st[20] = 0;
           st[21] = 0;
           st[22] = 0;
           st[23] = 0;
           st[24] = 0;

           st[add80w] |= 0x8000000000000000;
       }
       /* ###################### NEW, take the result from last iteration*/
       else{
           st[ 0] = st_roundResult[0];
           st[ 1] = st_roundResult[1];
           st[ 2] = st_roundResult[2];
           st[ 3] = st_roundResult[3];
           st[ 4] = 0;
           st[ 5] = 0;
           st[ 6] = 0;
           st[ 7] = 0;
           st[ 8] = 0;
           st[ 9] = 0;
           st[10] = 0;
           st[11] = 0;
           st[12] = 0;
           st[13] = 0;
           st[14] = 0;
           st[15] = 0;
           st[16] = 0;
           st[17] = 0;
           st[18] = 0;
           st[19] = 0;
           st[20] = 0;
           st[21] = 0;
           st[22] = 0;
           st[23] = 0;
           st[24] = 0;

           st[add80w_256bit_input] |= 0x8000000000000000;                
       }

       for (round = 0; round < KECCAK_ROUNDS; round++)
       {
         // Theta

         u64x bc0 = Theta1 (0);
         u64x bc1 = Theta1 (1);
         u64x bc2 = Theta1 (2);
         u64x bc3 = Theta1 (3);
         u64x bc4 = Theta1 (4);

         u64x t;

         t = bc4 ^ rotl64 (bc1, 1); Theta2 (0);
         t = bc0 ^ rotl64 (bc2, 1); Theta2 (1);
         t = bc1 ^ rotl64 (bc3, 1); Theta2 (2);
         t = bc2 ^ rotl64 (bc4, 1); Theta2 (3);
         t = bc3 ^ rotl64 (bc0, 1); Theta2 (4);

         // Rho Pi

         t = st[1];

         Rho_Pi (0);
         Rho_Pi (1);
         Rho_Pi (2);
         Rho_Pi (3);
         Rho_Pi (4);
         Rho_Pi (5);
         Rho_Pi (6);
         Rho_Pi (7);
         Rho_Pi (8);
         Rho_Pi (9);
         Rho_Pi (10);
         Rho_Pi (11);
         Rho_Pi (12);
         Rho_Pi (13);
         Rho_Pi (14);
         Rho_Pi (15);
         Rho_Pi (16);
         Rho_Pi (17);
         Rho_Pi (18);
         Rho_Pi (19);
         Rho_Pi (20);
         Rho_Pi (21);
         Rho_Pi (22);
         Rho_Pi (23);

         //  Chi

         Chi (0);
         Chi (5);
         Chi (10);
         Chi (15);
         Chi (20);

         //  Iota

         st[0] ^= keccakf_rndc[round];
       }
       /* ###################### NEW, remember for next round */
       st_roundResult[0] = st[ 0];
       st_roundResult[1] = st[ 1];
       st_roundResult[2] = st[ 2];
       st_roundResult[3] = st[ 3];
   }
   const u32x r0 = l32_from_64 (st[1]);
   const u32x r1 = h32_from_64 (st[1]);
   const u32x r2 = l32_from_64 (st[2]);
   const u32x r3 = h32_from_64 (st[2]);

   COMPARE_M_SIMD (r0, r1, r2, r3);
 }
}