1  #include <stdint.h>
       2  
       3  /* Process LEN bytes of BUFFER, accumulating context into CTX.
       4     It is assumed that LEN % 64 == 0.  */
       5  void
       6  __sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
       7  {
       8    const uint32_t *words = buffer;
       9    size_t nwords = len / sizeof (uint32_t);
      10    uint32_t a = ctx->H[0];
      11    uint32_t b = ctx->H[1];
      12    uint32_t c = ctx->H[2];
      13    uint32_t d = ctx->H[3];
      14    uint32_t e = ctx->H[4];
      15    uint32_t f = ctx->H[5];
      16    uint32_t g = ctx->H[6];
      17    uint32_t h = ctx->H[7];
      18  
      19    /* First increment the byte count.  FIPS 180-2 specifies the possible
      20       length of the file up to 2^64 bits.  Here we only compute the
      21       number of bytes.  */
      22    ctx->total64 += len;
      23  
      24    /* Process all bytes in the buffer with 64 bytes in each round of
      25       the loop.  */
      26    while (nwords > 0)
      27      {
      28        uint32_t W[64];
      29        uint32_t a_save = a;
      30        uint32_t b_save = b;
      31        uint32_t c_save = c;
      32        uint32_t d_save = d;
      33        uint32_t e_save = e;
      34        uint32_t f_save = f;
      35        uint32_t g_save = g;
      36        uint32_t h_save = h;
      37  
      38        /* Operators defined in FIPS 180-2:4.1.2.  */
      39  #define Ch(x, y, z) ((x & y) ^ (~x & z))
      40  #define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
      41  #define S0(x) (CYCLIC (x, 2) ^ CYCLIC (x, 13) ^ CYCLIC (x, 22))
      42  #define S1(x) (CYCLIC (x, 6) ^ CYCLIC (x, 11) ^ CYCLIC (x, 25))
      43  #define R0(x) (CYCLIC (x, 7) ^ CYCLIC (x, 18) ^ (x >> 3))
      44  #define R1(x) (CYCLIC (x, 17) ^ CYCLIC (x, 19) ^ (x >> 10))
      45  
      46        /* It is unfortunate that C does not provide an operator for
      47  	 cyclic rotation.  Hope the C compiler is smart enough.  */
      48  #define CYCLIC(w, s) ((w >> s) | (w << (32 - s)))
      49  
      50        /* Compute the message schedule according to FIPS 180-2:6.2.2 step 2.  */
      51        for (unsigned int t = 0; t < 16; ++t)
      52  	{
      53  	  W[t] = SWAP (*words);
      54  	  ++words;
      55  	}
      56        for (unsigned int t = 16; t < 64; ++t)
      57  	W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
      58  
      59        /* The actual computation according to FIPS 180-2:6.2.2 step 3.  */
      60        for (unsigned int t = 0; t < 64; ++t)
      61  	{
      62  	  uint32_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
      63  	  uint32_t T2 = S0 (a) + Maj (a, b, c);
      64  	  h = g;
      65  	  g = f;
      66  	  f = e;
      67  	  e = d + T1;
      68  	  d = c;
      69  	  c = b;
      70  	  b = a;
      71  	  a = T1 + T2;
      72  	}
      73  
      74        /* Add the starting values of the context according to FIPS 180-2:6.2.2
      75  	 step 4.  */
      76        a += a_save;
      77        b += b_save;
      78        c += c_save;
      79        d += d_save;
      80        e += e_save;
      81        f += f_save;
      82        g += g_save;
      83        h += h_save;
      84  
      85        /* Prepare for the next round.  */
      86        nwords -= 16;
      87      }
      88  
      89    /* Put checksum in context given as argument.  */
      90    ctx->H[0] = a;
      91    ctx->H[1] = b;
      92    ctx->H[2] = c;
      93    ctx->H[3] = d;
      94    ctx->H[4] = e;
      95    ctx->H[5] = f;
      96    ctx->H[6] = g;
      97    ctx->H[7] = h;
      98  }