libmultihash/sha2.c

   1 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   2 //  WjCryptLib_Sha256
   3 //
   4 //  Implementation of SHA256 hash function.
   5 //  Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org
   6 //  Modified by WaterJuice retaining Public Domain license.
   7 //
   8 //  This is free and unencumbered software released into the public domain - June 2013 waterjuice.org
   9 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  10
  11 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  12 //  IMPORTS
  13 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  14
  15 #include "sha2.h"
  16 #include <memory.h>
  17
  18 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  19 //  MACROS
  20 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  21
  22 #define ror(value, bits) (((value) >> (bits)) | ((value) << (32 - (bits))))
  23
  24 #define MIN(x, y) ( ((x)<(y))?(x):(y) )
  25
  26 #define STORE32H(x, y)                                                                     \
  27      { (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255);   \
  28        (y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); }
  29
  30 #define LOAD32H(x, y)                            \
  31      { x = ((uint32_t)((y)[0] & 255)<<24) | \
  32            ((uint32_t)((y)[1] & 255)<<16) | \
  33            ((uint32_t)((y)[2] & 255)<<8)  | \
  34            ((uint32_t)((y)[3] & 255)); }
  35
  36 #define STORE64H(x, y)                                                                     \
  37    { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255);     \
  38      (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255);     \
  39      (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255);     \
  40      (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); }
  41
  42 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  43 //  CONSTANTS
  44 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  45
  46 // The K array
  47 static const uint32_t K[64] = {
  48     0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
  49     0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
  50     0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
  51     0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
  52     0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
  53     0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
  54     0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
  55     0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
  56     0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
  57     0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
  58     0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
  59     0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
  60     0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
  61 };
  62
  63 #define BLOCK_SIZE          64
  64
  65 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  66 //  INTERNAL FUNCTIONS
  67 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  68
  69 // Various logical functions
  70 #define Ch( x, y, z )     (z ^ (x & (y ^ z)))
  71 #define Maj( x, y, z )    (((x | y) & z) | (x & y))
  72 #define S( x, n )         ror((x),(n))
  73 #define R( x, n )         (((x)&0xFFFFFFFFUL)>>(n))
  74 #define Sigma0( x )       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
  75 #define Sigma1( x )       (S(x, 6) ^ S(x, 11) ^ S(x, 25))
  76 #define Gamma0( x )       (S(x, 7) ^ S(x, 18) ^ R(x, 3))
  77 #define Gamma1( x )       (S(x, 17) ^ S(x, 19) ^ R(x, 10))
  78
  79 #define Sha256Round( a, b, c, d, e, f, g, h, i )       \
  80      t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i];   \
  81      t1 = Sigma0(a) + Maj(a, b, c);                    \
  82      d += t0;                                          \
  83      h  = t0 + t1;
  84
  85 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  86 //  TransformFunction
  87 //
  88 //  Compress 512-bits
  89 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  90 static
  91 void
  92     TransformFunction
  93     (
  94         Sha256Context*      Context,
  95         uint8_t const*      Buffer
  96     )
  97 {
  98     uint32_t    S[8];
  99     uint32_t    W[64];
 100     uint32_t    t0;
 101     uint32_t    t1;
 102     uint32_t    t;
 103     int         i;
 104
 105     // Copy state into S
 106     for( i=0; i<8; i++ )
 107     {
 108         S[i] = Context->state[i];
 109     }
 110
 111     // Copy the state into 512-bits into W[0..15]
 112     for( i=0; i<16; i++ )
 113     {
 114         LOAD32H( W[i], Buffer + (4*i) );
 115     }
 116
 117     // Fill W[16..63]
 118     for( i=16; i<64; i++ )
 119     {
 120         W[i] = Gamma1( W[i-2]) + W[i-7] + Gamma0( W[i-15] ) + W[i-16];
 121     }
 122
 123     // Compress
 124     for( i=0; i<64; i++ )
 125     {
 126         Sha256Round( S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i );
 127         t = S[7];
 128         S[7] = S[6];
 129         S[6] = S[5];
 130         S[5] = S[4];
 131         S[4] = S[3];
 132         S[3] = S[2];
 133         S[2] = S[1];
 134         S[1] = S[0];
 135         S[0] = t;
 136     }
 137
 138     // Feedback
 139     for( i=0; i<8; i++ )
 140     {
 141         Context->state[i] = Context->state[i] + S[i];
 142     }
 143 }
 144
 145 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 146 //  PUBLIC FUNCTIONS
 147 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 148
 149 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 150 //  Sha256Initialise
 151 //
 152 //  Initialises a SHA256 Context. Use this to initialise/reset a context.
 153 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 154 void
 155     Sha256Initialise
 156     (
 157         Sha256Context*      Context         // [out]
 158     )
 159 {
 160     Context->curlen = 0;
 161     Context->length = 0;
 162     Context->state[0] = 0x6A09E667UL;
 163     Context->state[1] = 0xBB67AE85UL;
 164     Context->state[2] = 0x3C6EF372UL;
 165     Context->state[3] = 0xA54FF53AUL;
 166     Context->state[4] = 0x510E527FUL;
 167     Context->state[5] = 0x9B05688CUL;
 168     Context->state[6] = 0x1F83D9ABUL;
 169     Context->state[7] = 0x5BE0CD19UL;
 170 }
 171
 172 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 173 //  Sha256Update
 174 //
 175 //  Adds data to the SHA256 context. This will process the data and update the internal state of the context. Keep on
 176 //  calling this function until all the data has been added. Then call Sha256Finalise to calculate the hash.
 177 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 178 void
 179     Sha256Update
 180     (
 181         Sha256Context*      Context,        // [in out]
 182         void const*         Buffer,         // [in]
 183         uint32_t            BufferSize      // [in]
 184     )
 185 {
 186     uint32_t n;
 187
 188     if( Context->curlen > sizeof(Context->buf) )
 189     {
 190        return;
 191     }
 192
 193     while( BufferSize > 0 )
 194     {
 195         if( Context->curlen == 0 && BufferSize >= BLOCK_SIZE )
 196         {
 197            TransformFunction( Context, (uint8_t*)Buffer );
 198            Context->length += BLOCK_SIZE * 8;
 199            Buffer = (uint8_t*)Buffer + BLOCK_SIZE;
 200            BufferSize -= BLOCK_SIZE;
 201         }
 202         else
 203         {
 204            n = MIN( BufferSize, (BLOCK_SIZE - Context->curlen) );
 205            memcpy( Context->buf + Context->curlen, Buffer, (size_t)n );
 206            Context->curlen += n;
 207            Buffer = (uint8_t*)Buffer + n;
 208            BufferSize -= n;
 209            if( Context->curlen == BLOCK_SIZE )
 210            {
 211               TransformFunction( Context, Context->buf );
 212               Context->length += 8*BLOCK_SIZE;
 213               Context->curlen = 0;
 214            }
 215        }
 216     }
 217 }
 218
 219 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 220 //  Sha256Finalise
 221 //
 222 //  Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). After
 223 //  calling this, Sha256Initialised must be used to reuse the context.
 224 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 225 void
 226     Sha256Finalise
 227     (
 228         Sha256Context*      Context,        // [in out]
 229         SHA256_HASH*        Digest          // [out]
 230     )
 231 {
 232     int i;
 233
 234     if( Context->curlen >= sizeof(Context->buf) )
 235     {
 236        return;
 237     }
 238
 239     // Increase the length of the message
 240     Context->length += Context->curlen * 8;
 241
 242     // Append the '1' bit
 243     Context->buf[Context->curlen++] = (uint8_t)0x80;
 244
 245     // if the length is currently above 56 bytes we append zeros
 246     // then compress.  Then we can fall back to padding zeros and length
 247     // encoding like normal.
 248     if( Context->curlen > 56 )
 249     {
 250         while( Context->curlen < 64 )
 251         {
 252             Context->buf[Context->curlen++] = (uint8_t)0;
 253         }
 254         TransformFunction(Context, Context->buf);
 255         Context->curlen = 0;
 256     }
 257
 258     // Pad up to 56 bytes of zeroes
 259     while( Context->curlen < 56 )
 260     {
 261         Context->buf[Context->curlen++] = (uint8_t)0;
 262     }
 263
 264     // Store length
 265     STORE64H( Context->length, Context->buf+56 );
 266     TransformFunction( Context, Context->buf );
 267
 268     // Copy output
 269     for( i=0; i<8; i++ )
 270     {
 271         STORE32H( Context->state[i], Digest->bytes+(4*i) );
 272     }
 273 }
 274
 275 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 276 //  Sha256Calculate
 277 //
 278 //  Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one function. Calculates the SHA256 hash of the
 279 //  buffer.
 280 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 281 void
 282     Sha256Calculate
 283     (
 284         void  const*        Buffer,         // [in]
 285         uint32_t            BufferSize,     // [in]
 286         SHA256_HASH*        Digest          // [in]
 287     )
 288 {
 289     Sha256Context context;
 290
 291     Sha256Initialise( &context );
 292     Sha256Update( &context, Buffer, BufferSize );
 293     Sha256Finalise( &context, Digest );
 294 }
 295