crypt/sha512-block.c

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