sha256.cpp

00001 #include <cstring>
00002 #include <fstream>
00003 #include "sha256.h"
00004  
00005 const unsigned int SHA256::sha256_k[64] = //UL = uint32
00006             {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
00007              0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
00008              0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
00009              0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
00010              0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
00011              0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
00012              0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
00013              0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
00014              0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
00015              0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
00016              0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
00017              0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
00018              0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
00019              0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
00020              0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
00021              0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
00022  
00023 void SHA256::transform(const unsigned char *message, unsigned int block_nb)
00024 {
00025     uint32 w[64];
00026     uint32 wv[8];
00027     uint32 t1, t2;
00028     const unsigned char *sub_block;
00029     int i;
00030     int j;
00031     for (i = 0; i < (int) block_nb; i++) {
00032         sub_block = message + (i << 6);
00033         for (j = 0; j < 16; j++) {
00034             SHA2_PACK32(&sub_block[j << 2], &w[j]);
00035         }
00036         for (j = 16; j < 64; j++) {
00037             w[j] =  SHA256_F4(w[j -  2]) + w[j -  7] + SHA256_F3(w[j - 15]) + w[j - 16];
00038         }
00039         for (j = 0; j < 8; j++) {
00040             wv[j] = m_h[j];
00041         }
00042         for (j = 0; j < 64; j++) {
00043             t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
00044                 + sha256_k[j] + w[j];
00045             t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
00046             wv[7] = wv[6];
00047             wv[6] = wv[5];
00048             wv[5] = wv[4];
00049             wv[4] = wv[3] + t1;
00050             wv[3] = wv[2];
00051             wv[2] = wv[1];
00052             wv[1] = wv[0];
00053             wv[0] = t1 + t2;
00054         }
00055         for (j = 0; j < 8; j++) {
00056             m_h[j] += wv[j];
00057         }
00058     }
00059 }
00060  
00061 void SHA256::init()
00062 {
00063     m_h[0] = 0x6a09e667;
00064     m_h[1] = 0xbb67ae85;
00065     m_h[2] = 0x3c6ef372;
00066     m_h[3] = 0xa54ff53a;
00067     m_h[4] = 0x510e527f;
00068     m_h[5] = 0x9b05688c;
00069     m_h[6] = 0x1f83d9ab;
00070     m_h[7] = 0x5be0cd19;
00071     m_len = 0;
00072     m_tot_len = 0;
00073 }
00074  
00075 void SHA256::update(const unsigned char *message, unsigned int len)
00076 {
00077     unsigned int block_nb;
00078     unsigned int new_len, rem_len, tmp_len;
00079     const unsigned char *shifted_message;
00080     tmp_len = SHA224_256_BLOCK_SIZE - m_len;
00081     rem_len = len < tmp_len ? len : tmp_len;
00082     std::memcpy(&m_block[m_len], message, rem_len);
00083     if (m_len + len < SHA224_256_BLOCK_SIZE) {
00084         m_len += len;
00085         return;
00086     }
00087     new_len = len - rem_len;
00088     block_nb = new_len / SHA224_256_BLOCK_SIZE;
00089     shifted_message = message + rem_len;
00090     transform(m_block, 1);
00091     transform(shifted_message, block_nb);
00092     rem_len = new_len % SHA224_256_BLOCK_SIZE;
00093     std::memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
00094     m_len = rem_len;
00095     m_tot_len += (block_nb + 1) << 6;
00096 }
00097  
00098 void SHA256::final(unsigned char *digest)
00099 {
00100     unsigned int block_nb;
00101     unsigned int pm_len;
00102     unsigned int len_b;
00103     int i;
00104     block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9)
00105                      < (m_len % SHA224_256_BLOCK_SIZE)));
00106     len_b = (m_tot_len + m_len) << 3;
00107     pm_len = block_nb << 6;
00108     std::memset(m_block + m_len, 0, pm_len - m_len);
00109     m_block[m_len] = 0x80;
00110     SHA2_UNPACK32(len_b, m_block + pm_len - 4);
00111     transform(m_block, block_nb);
00112     for (i = 0 ; i < 8; i++) {
00113         SHA2_UNPACK32(m_h[i], &digest[i << 2]);
00114     }
00115 }
00116  
00117 std::string sha256(std::string input)
00118 {
00119     unsigned char digest[SHA256::DIGEST_SIZE];
00120     std::memset(digest,0,SHA256::DIGEST_SIZE);
00121  
00122     SHA256 ctx = SHA256();
00123     ctx.init();
00124     ctx.update( (unsigned char*)input.c_str(), input.length());
00125     ctx.final(digest);
00126  
00127     char buf[2*SHA256::DIGEST_SIZE+1];
00128     buf[2*SHA256::DIGEST_SIZE] = 0;
00129     for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
00130         std::sprintf(buf+i*2, "%02x", digest[i]);
00131     return std::string(buf);
00132 }