1 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2 // WjCryptLib_Sha256 3 // 4 // Implementation of SHA256 hash function. 5 // Original author: Tom St Denis, [email protected], 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 "sha256.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 TransformFunction(Sha256Context * Context,uint8_t const * Buffer)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 Sha256Initialise(Sha256Context * Context)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 Sha256Update(Sha256Context * Context,void const * Buffer,uint32_t BufferSize)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 Sha256Finalise(Sha256Context * Context,SHA256_HASH * Digest)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 Sha256Calculate(void const * Buffer,uint32_t BufferSize,SHA256_HASH * Digest)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