EGong

git clone git://xatko.vsos.ethz.ch/EGong.git
Log | Files | Refs

Hash.c (5307B)

      1 /* Crypto/SHA256.c -- SHA-256 Hash function
      2 2008-11-06 : Igor Pavlov : Public domain
      3 This code is based on public domain code from Wei Dai's Crypto++ library. */
      4 
      5 #include <EGong/Util/Hash.h>
      6 #ifdef _MSC_VER
      7 
      8 #include <stdlib.h>
      9 #define rotlFixed(x, n) _rotl((x), (n))
     10 #define rotrFixed(x, n) _rotr((x), (n))
     11 
     12 #else
     13 
     14 #define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
     15 #define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
     16 
     17 #endif
     18 /* define it for speed optimization */
     19 /* #define _SHA256_UNROLL */
     20 /* #define _SHA256_UNROLL2 */
     21 
     22 void SHA256_Init(CSHA256 *p)
     23 {
     24   p->state[0] = 0x6a09e667;
     25   p->state[1] = 0xbb67ae85;
     26   p->state[2] = 0x3c6ef372;
     27   p->state[3] = 0xa54ff53a;
     28   p->state[4] = 0x510e527f;
     29   p->state[5] = 0x9b05688c;
     30   p->state[6] = 0x1f83d9ab;
     31   p->state[7] = 0x5be0cd19;
     32   p->count = 0;
     33 }
     34 
     35 #define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
     36 #define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
     37 #define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
     38 #define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
     39 
     40 #define blk0(i) (W[i] = data[i])
     41 #define blk2(i) (W[i&15] += s1(W[(i-2)&15]) + W[(i-7)&15] + s0(W[(i-15)&15]))
     42 
     43 #define Ch(x,y,z) (z^(x&(y^z)))
     44 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
     45 
     46 #define a(i) T[(0-(i))&7]
     47 #define b(i) T[(1-(i))&7]
     48 #define c(i) T[(2-(i))&7]
     49 #define d(i) T[(3-(i))&7]
     50 #define e(i) T[(4-(i))&7]
     51 #define f(i) T[(5-(i))&7]
     52 #define g(i) T[(6-(i))&7]
     53 #define h(i) T[(7-(i))&7]
     54 
     55 
     56 #ifdef _SHA256_UNROLL2
     57 
     58 #define R(a,b,c,d,e,f,g,h, i) h += S1(e) + Ch(e,f,g) + K[i+j] + (j?blk2(i):blk0(i));\
     59   d += h; h += S0(a) + Maj(a, b, c)
     60 
     61 #define RX_8(i) \
     62   R(a,b,c,d,e,f,g,h, i); \
     63   R(h,a,b,c,d,e,f,g, i+1); \
     64   R(g,h,a,b,c,d,e,f, i+2); \
     65   R(f,g,h,a,b,c,d,e, i+3); \
     66   R(e,f,g,h,a,b,c,d, i+4); \
     67   R(d,e,f,g,h,a,b,c, i+5); \
     68   R(c,d,e,f,g,h,a,b, i+6); \
     69   R(b,c,d,e,f,g,h,a, i+7)
     70 
     71 #else
     72 
     73 #define R(i) h(i) += S1(e(i)) + Ch(e(i),f(i),g(i)) + K[i+j] + (j?blk2(i):blk0(i));\
     74   d(i) += h(i); h(i) += S0(a(i)) + Maj(a(i), b(i), c(i))
     75 
     76 #ifdef _SHA256_UNROLL
     77 
     78 #define RX_8(i) R(i+0); R(i+1); R(i+2); R(i+3); R(i+4); R(i+5); R(i+6); R(i+7);
     79 
     80 #endif
     81 
     82 #endif
     83 
     84 const uint32_t K[64] = {
     85   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
     86   0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     87   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
     88   0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     89   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
     90   0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
     91   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
     92   0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
     93   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
     94   0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
     95   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
     96   0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
     97   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
     98   0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     99   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
    100   0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
    101 };
    102 
    103 static void SHA256_Transform(uint32_t *state, const uint32_t *data)
    104 {
    105   uint32_t W[16];
    106   unsigned j;
    107   #ifdef _SHA256_UNROLL2
    108   uint32_t a,b,c,d,e,f,g,h;
    109   a = state[0];
    110   b = state[1];
    111   c = state[2];
    112   d = state[3];
    113   e = state[4];
    114   f = state[5];
    115   g = state[6];
    116   h = state[7];
    117   #else
    118   uint32_t T[8];
    119   for (j = 0; j < 8; j++)
    120     T[j] = state[j];
    121   #endif
    122 
    123   for (j = 0; j < 64; j += 16)
    124   {
    125     #if defined(_SHA256_UNROLL) || defined(_SHA256_UNROLL2)
    126     RX_8(0); RX_8(8);
    127     #else
    128     unsigned i;
    129     for (i = 0; i < 16; i++) { R(i); }
    130     #endif
    131   }
    132 
    133   #ifdef _SHA256_UNROLL2
    134   state[0] += a;
    135   state[1] += b;
    136   state[2] += c;
    137   state[3] += d;
    138   state[4] += e;
    139   state[5] += f;
    140   state[6] += g;
    141   state[7] += h;
    142   #else
    143   for (j = 0; j < 8; j++)
    144     state[j] += T[j];
    145   #endif
    146  
    147   /* Wipe variables */
    148   /* memset(W, 0, sizeof(W)); */
    149   /* memset(T, 0, sizeof(T)); */
    150 }
    151 
    152 #undef S0
    153 #undef S1
    154 #undef s0
    155 #undef s1
    156 
    157 static void SHA256_WritecharBlock(CSHA256 *p)
    158 {
    159   uint32_t data32[16];
    160   unsigned i;
    161   for (i = 0; i < 16; i++)
    162     data32[i] =
    163       ((uint32_t)(p->buffer[i * 4    ]) << 24) +
    164       ((uint32_t)(p->buffer[i * 4 + 1]) << 16) +
    165       ((uint32_t)(p->buffer[i * 4 + 2]) <<  8) +
    166       ((uint32_t)(p->buffer[i * 4 + 3]));
    167   SHA256_Transform(p->state, data32);
    168 }
    169 
    170 void SHA256_Update(CSHA256 *p, const char *data, size_t size)
    171 {
    172   uint32_t curBufferPos = (uint32_t)p->count & 0x3F;
    173   while (size > 0)
    174   {
    175     p->buffer[curBufferPos++] = *data++;
    176     p->count++;
    177     size--;
    178     if (curBufferPos == 64)
    179     {
    180       curBufferPos = 0;
    181       SHA256_WritecharBlock(p);
    182     }
    183   }
    184 }
    185 
    186 void SHA256_Final(char *digest, CSHA256 *p)
    187 {
    188   uint64_t lenInBits = (p->count << 3);
    189   uint32_t curBufferPos = (uint32_t)p->count & 0x3F;
    190   unsigned i;
    191   p->buffer[curBufferPos++] = 0x80;
    192   while (curBufferPos != (64 - 8))
    193   {
    194     curBufferPos &= 0x3F;
    195     if (curBufferPos == 0)
    196       SHA256_WritecharBlock(p);
    197     p->buffer[curBufferPos++] = 0;
    198   }
    199   for (i = 0; i < 8; i++)
    200   {
    201     p->buffer[curBufferPos++] = (char)(lenInBits >> 56);
    202     lenInBits <<= 8;
    203   }
    204   SHA256_WritecharBlock(p);
    205 
    206   for (i = 0; i < 8; i++)
    207   {
    208     *digest++ = (char)((p->state[i] >> 24) & 0xFF);
    209     *digest++ = (char)((p->state[i] >> 16) & 0xFF);
    210     *digest++ = (char)((p->state[i] >> 8) & 0xFF);
    211     *digest++ = (char)((p->state[i]) & 0xFF);
    212   }
    213   SHA256_Init(p);
    214 }
    215