sha512-compress.c

   1 /* sha512-compress.c
   2  *
   3  * The compression function of the sha512 hash function.
   4  */
   5
   6 /* nettle, low-level cryptographics library
   7  *
   8  * Copyright (C) 2001, 2010 Niels Möller
   9  *
  10  * The nettle library is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or (at your
  13  * option) any later version.
  14  *
  15  * The nettle library is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with the nettle library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  23  * MA 02111-1307, USA.
  24  */
  25
  26 #if HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <assert.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #include "sha.h"
  35
  36 #include "macros.h"
  37
  38 /* A block, treated as a sequence of 64-bit words. */
  39 #define SHA512_DATA_LENGTH 16
  40
  41 #define ROTR(n,x) ((x)>>(n) | ((x)<<(64-(n))))
  42 #define SHR(n,x) ((x)>>(n))
  43
  44 /* The SHA512 functions. The Choice function is the same as the SHA1
  45    function f1, and the majority function is the same as the SHA1 f3
  46    function, and the same as for SHA256. */
  47
  48 #define Choice(x,y,z)   ( (z) ^ ( (x) & ( (y) ^ (z) ) ) )
  49 #define Majority(x,y,z) ( ((x) & (y)) ^ ((z) & ((x) ^ (y))) )
  50
  51 #define S0(x) (ROTR(28,(x)) ^ ROTR(34,(x)) ^ ROTR(39,(x)))
  52 #define S1(x) (ROTR(14,(x)) ^ ROTR(18,(x)) ^ ROTR(41,(x)))
  53
  54 #define s0(x) (ROTR(1,(x)) ^ ROTR(8,(x)) ^ SHR(7,(x)))
  55 #define s1(x) (ROTR(19,(x)) ^ ROTR(61,(x)) ^ SHR(6,(x)))
  56
  57 /* The initial expanding function. The hash function is defined over
  58    an 64-word expanded input array W, where the first 16 are copies of
  59    the input data, and the remaining 64 are defined by
  60
  61         W[ t ] = s1(W[t-2]) + W[t-7] + s0(W[i-15]) + W[i-16]
  62
  63    This implementation generates these values on the fly in a circular
  64    buffer.
  65 */
  66
  67 #define EXPAND(W,i) \
  68 ( W[(i) & 15 ] += (s1(W[((i)-2) & 15]) + W[((i)-7) & 15] + s0(W[((i)-15) & 15])) )
  69
  70 /* The prototype SHA sub-round.  The fundamental sub-round is:
  71
  72         T1 = h + S1(e) + Choice(e,f,g) + K[t] + W[t]
  73         T2 = S0(a) + Majority(a,b,c)
  74         a' = T1+T2
  75         b' = a
  76         c' = b
  77         d' = c
  78         e' = d + T1
  79         f' = e
  80         g' = f
  81         h' = g
  82
  83    but this is implemented by unrolling the loop 8 times and renaming
  84    the variables
  85    ( h, a, b, c, d, e, f, g ) = ( a, b, c, d, e, f, g, h ) each
  86    iteration. This code is then replicated 8, using the next 8 values
  87    from the W[] array each time */
  88
  89 /* It's crucial that DATA is only used once, as that argument will
  90  * have side effects. */
  91 #define ROUND(a,b,c,d,e,f,g,h,k,data) do {              \
  92   uint64_t T = h + S1(e) + Choice(e,f,g) + k + data;    \
  93   d += T;                                               \
  94   h = T + S0(a) + Majority(a,b,c);                      \
  95 } while (0)
  96
  97 void
  98 _nettle_sha512_compress(uint64_t *state, const uint8_t *input, const uint64_t *k)
  99 {
 100   uint64_t data[SHA512_DATA_LENGTH];
 101   uint64_t A, B, C, D, E, F, G, H;     /* Local vars */
 102   unsigned i;
 103   uint64_t *d;
 104
 105   for (i = 0; i < SHA512_DATA_LENGTH; i++, input += 8)
 106     {
 107       data[i] = READ_UINT64(input);
 108     }
 109
 110   /* Set up first buffer and local data buffer */
 111   A = state[0];
 112   B = state[1];
 113   C = state[2];
 114   D = state[3];
 115   E = state[4];
 116   F = state[5];
 117   G = state[6];
 118   H = state[7];
 119
 120   /* Heavy mangling */
 121   /* First 16 subrounds that act on the original data */
 122
 123   for (i = 0, d = data; i<16; i+=8, k += 8, d+= 8)
 124     {
 125       ROUND(A, B, C, D, E, F, G, H, k[0], d[0]);
 126       ROUND(H, A, B, C, D, E, F, G, k[1], d[1]);
 127       ROUND(G, H, A, B, C, D, E, F, k[2], d[2]);
 128       ROUND(F, G, H, A, B, C, D, E, k[3], d[3]);
 129       ROUND(E, F, G, H, A, B, C, D, k[4], d[4]);
 130       ROUND(D, E, F, G, H, A, B, C, k[5], d[5]);
 131       ROUND(C, D, E, F, G, H, A, B, k[6], d[6]);
 132       ROUND(B, C, D, E, F, G, H, A, k[7], d[7]);
 133     }
 134
 135   for (; i<80; i += 16, k+= 16)
 136     {
 137       ROUND(A, B, C, D, E, F, G, H, k[ 0], EXPAND(data,  0));
 138       ROUND(H, A, B, C, D, E, F, G, k[ 1], EXPAND(data,  1));
 139       ROUND(G, H, A, B, C, D, E, F, k[ 2], EXPAND(data,  2));
 140       ROUND(F, G, H, A, B, C, D, E, k[ 3], EXPAND(data,  3));
 141       ROUND(E, F, G, H, A, B, C, D, k[ 4], EXPAND(data,  4));
 142       ROUND(D, E, F, G, H, A, B, C, k[ 5], EXPAND(data,  5));
 143       ROUND(C, D, E, F, G, H, A, B, k[ 6], EXPAND(data,  6));
 144       ROUND(B, C, D, E, F, G, H, A, k[ 7], EXPAND(data,  7));
 145       ROUND(A, B, C, D, E, F, G, H, k[ 8], EXPAND(data,  8));
 146       ROUND(H, A, B, C, D, E, F, G, k[ 9], EXPAND(data,  9));
 147       ROUND(G, H, A, B, C, D, E, F, k[10], EXPAND(data, 10));
 148       ROUND(F, G, H, A, B, C, D, E, k[11], EXPAND(data, 11));
 149       ROUND(E, F, G, H, A, B, C, D, k[12], EXPAND(data, 12));
 150       ROUND(D, E, F, G, H, A, B, C, k[13], EXPAND(data, 13));
 151       ROUND(C, D, E, F, G, H, A, B, k[14], EXPAND(data, 14));
 152       ROUND(B, C, D, E, F, G, H, A, k[15], EXPAND(data, 15));
 153     }
 154
 155   /* Update state */
 156   state[0] += A;
 157   state[1] += B;
 158   state[2] += C;
 159   state[3] += D;
 160   state[4] += E;
 161   state[5] += F;
 162   state[6] += G;
 163   state[7] += H;
 164 }