sha256-compress.c

   1 /* sha256-compress.c
   2  *
   3  * The compression function of the sha256 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 32-bit words. */
  39 #define SHA256_DATA_LENGTH 16
  40
  41 #define ROTR(n,x) ((x)>>(n) | ((x)<<(32-(n))))
  42 #define SHR(n,x) ((x)>>(n))
  43
  44 /* The SHA256 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. They can be optimized to save one boolean operation each
  47    - thanks to Rich Schroeppel, rcs@cs.arizona.edu for discovering
  48    this */
  49
  50 /* #define Choice(x,y,z) ( ( (x) & (y) ) | ( ~(x) & (z) ) ) */
  51 #define Choice(x,y,z)   ( (z) ^ ( (x) & ( (y) ^ (z) ) ) )
  52 /* #define Majority(x,y,z) ( ((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)) ) */
  53 #define Majority(x,y,z) ( ((x) & (y)) ^ ((z) & ((x) ^ (y))) )
  54
  55 #define S0(x) (ROTR(2,(x)) ^ ROTR(13,(x)) ^ ROTR(22,(x)))
  56 #define S1(x) (ROTR(6,(x)) ^ ROTR(11,(x)) ^ ROTR(25,(x)))
  57
  58 #define s0(x) (ROTR(7,(x)) ^ ROTR(18,(x)) ^ SHR(3,(x)))
  59 #define s1(x) (ROTR(17,(x)) ^ ROTR(19,(x)) ^ SHR(10,(x)))
  60
  61 /* The initial expanding function.  The hash function is defined over an
  62    64-word expanded input array W, where the first 16 are copies of the input
  63    data, and the remaining 64 are defined by
  64
  65         W[ t ] = s1(W[t-2]) + W[t-7] + s0(W[i-15]) + W[i-16]
  66
  67    This implementation generates these values on the fly in a circular
  68    buffer - thanks to Colin Plumb, colin@nyx10.cs.du.edu for this
  69    optimization.
  70 */
  71
  72 #define EXPAND(W,i) \
  73 ( W[(i) & 15 ] += (s1(W[((i)-2) & 15]) + W[((i)-7) & 15] + s0(W[((i)-15) & 15])) )
  74
  75 /* The prototype SHA sub-round.  The fundamental sub-round is:
  76
  77         T1 = h + S1(e) + Choice(e,f,g) + K[t] + W[t]
  78         T2 = S0(a) + Majority(a,b,c)
  79         a' = T1+T2
  80         b' = a
  81         c' = b
  82         d' = c
  83         e' = d + T1
  84         f' = e
  85         g' = f
  86         h' = g
  87
  88    but this is implemented by unrolling the loop 8 times and renaming
  89    the variables
  90    ( h, a, b, c, d, e, f, g ) = ( a, b, c, d, e, f, g, h ) each
  91    iteration. */
  92
  93 /* It's crucial that DATA is only used once, as that argument will
  94  * have side effects. */
  95 #define ROUND(a,b,c,d,e,f,g,h,k,data) do {              \
  96   uint32_t T = h + S1(e) + Choice(e,f,g) + k + data;    \
  97   d += T;                                               \
  98   h = T + S0(a) + Majority(a,b,c);                      \
  99 } while (0)
 100
 101 void
 102 _nettle_sha256_compress(uint32_t *state, const uint8_t *input, const uint32_t *k)
 103 {
 104   uint32_t data[SHA256_DATA_LENGTH];
 105   uint32_t A, B, C, D, E, F, G, H;     /* Local vars */
 106   unsigned i;
 107   uint32_t *d;
 108
 109   for (i = 0; i < SHA256_DATA_LENGTH; i++, input+= 4)
 110     {
 111       data[i] = READ_UINT32(input);
 112     }
 113
 114   /* Set up first buffer and local data buffer */
 115   A = state[0];
 116   B = state[1];
 117   C = state[2];
 118   D = state[3];
 119   E = state[4];
 120   F = state[5];
 121   G = state[6];
 122   H = state[7];
 123
 124   /* Heavy mangling */
 125   /* First 16 subrounds that act on the original data */
 126
 127   for (i = 0, d = data; i<16; i+=8, k += 8, d+= 8)
 128     {
 129       ROUND(A, B, C, D, E, F, G, H, k[0], d[0]);
 130       ROUND(H, A, B, C, D, E, F, G, k[1], d[1]);
 131       ROUND(G, H, A, B, C, D, E, F, k[2], d[2]);
 132       ROUND(F, G, H, A, B, C, D, E, k[3], d[3]);
 133       ROUND(E, F, G, H, A, B, C, D, k[4], d[4]);
 134       ROUND(D, E, F, G, H, A, B, C, k[5], d[5]);
 135       ROUND(C, D, E, F, G, H, A, B, k[6], d[6]);
 136       ROUND(B, C, D, E, F, G, H, A, k[7], d[7]);
 137     }
 138
 139   for (; i<64; i += 16, k+= 16)
 140     {
 141       ROUND(A, B, C, D, E, F, G, H, k[ 0], EXPAND(data,  0));
 142       ROUND(H, A, B, C, D, E, F, G, k[ 1], EXPAND(data,  1));
 143       ROUND(G, H, A, B, C, D, E, F, k[ 2], EXPAND(data,  2));
 144       ROUND(F, G, H, A, B, C, D, E, k[ 3], EXPAND(data,  3));
 145       ROUND(E, F, G, H, A, B, C, D, k[ 4], EXPAND(data,  4));
 146       ROUND(D, E, F, G, H, A, B, C, k[ 5], EXPAND(data,  5));
 147       ROUND(C, D, E, F, G, H, A, B, k[ 6], EXPAND(data,  6));
 148       ROUND(B, C, D, E, F, G, H, A, k[ 7], EXPAND(data,  7));
 149       ROUND(A, B, C, D, E, F, G, H, k[ 8], EXPAND(data,  8));
 150       ROUND(H, A, B, C, D, E, F, G, k[ 9], EXPAND(data,  9));
 151       ROUND(G, H, A, B, C, D, E, F, k[10], EXPAND(data, 10));
 152       ROUND(F, G, H, A, B, C, D, E, k[11], EXPAND(data, 11));
 153       ROUND(E, F, G, H, A, B, C, D, k[12], EXPAND(data, 12));
 154       ROUND(D, E, F, G, H, A, B, C, k[13], EXPAND(data, 13));
 155       ROUND(C, D, E, F, G, H, A, B, k[14], EXPAND(data, 14));
 156       ROUND(B, C, D, E, F, G, H, A, k[15], EXPAND(data, 15));
 157     }
 158
 159   /* Update state */
 160   state[0] += A;
 161   state[1] += B;
 162   state[2] += C;
 163   state[3] += D;
 164   state[4] += E;
 165   state[5] += F;
 166   state[6] += G;
 167   state[7] += H;
 168 }