SHARE
TWEET

Untitled

a guest Aug 24th, 2019 97 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <string>
  2. #include <cstring>
  3. #include <fstream>
  4. #include <iostream>
  5. #include <vector>
  6. #include <cassert>
  7. using namespace std;
  8.  
  9. class SHA256
  10. {
  11. protected:
  12.     typedef unsigned char uint8;
  13.     typedef unsigned int uint32;
  14.     typedef unsigned long long uint64;
  15.  
  16.     const static uint32 sha256_k[];
  17.     static const unsigned int SHA224_256_BLOCK_SIZE = (512 / 8);
  18.  
  19. public:
  20.     void init();
  21.     void update(const unsigned char *message, unsigned int len);
  22.     void final(unsigned char *digest);
  23.     static const unsigned int DIGEST_SIZE = (256 / 8);
  24.  
  25. protected:
  26.     void transform(const unsigned char *message, unsigned int block_nb);
  27.     unsigned int m_tot_len;
  28.     unsigned int m_len;
  29.     unsigned char m_block[2 * SHA224_256_BLOCK_SIZE];
  30.     uint32 m_h[8];
  31. };
  32.  
  33. std::string sha256(std::string input);
  34.  
  35. #define SHA2_SHFR(x, n) (x >> n)
  36. #define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
  37. #define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))
  38. #define SHA2_CH(x, y, z) ((x & y) ^ (~x & z))
  39. #define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
  40. #define SHA256_F1(x) (SHA2_ROTR(x, 2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22))
  41. #define SHA256_F2(x) (SHA2_ROTR(x, 6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25))
  42. #define SHA256_F3(x) (SHA2_ROTR(x, 7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x, 3))
  43. #define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10))
  44. #define SHA2_UNPACK32(x, str)              \
  45.     {                                      \
  46.         *((str) + 3) = (uint8)((x));       \
  47.         *((str) + 2) = (uint8)((x) >> 8);  \
  48.         *((str) + 1) = (uint8)((x) >> 16); \
  49.         *((str) + 0) = (uint8)((x) >> 24); \
  50.     }
  51. #define SHA2_PACK32(str, x)                                                                                                                \
  52.     {                                                                                                                                      \
  53.         *(x) = ((uint32) * ((str) + 3)) | ((uint32) * ((str) + 2) << 8) | ((uint32) * ((str) + 1) << 16) | ((uint32) * ((str) + 0) << 24); \
  54.     }
  55.  
  56. const unsigned int SHA256::sha256_k[64] = //UL = uint32
  57.     {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
  58.      0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
  59.      0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
  60.      0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
  61.      0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
  62.      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
  63.      0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
  64.      0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
  65.      0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
  66.      0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
  67.      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
  68.      0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
  69.      0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
  70.      0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
  71.      0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
  72.      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
  73.  
  74. void SHA256::transform(const unsigned char *message, unsigned int block_nb)
  75. {
  76.     uint32 w[64];
  77.     uint32 wv[8];
  78.     uint32 t1, t2;
  79.     const unsigned char *sub_block;
  80.     int i;
  81.     int j;
  82.     for (i = 0; i < (int)block_nb; i++)
  83.     {
  84.         sub_block = message + (i << 6);
  85.         for (j = 0; j < 16; j++)
  86.         {
  87.             SHA2_PACK32(&sub_block[j << 2], &w[j]);
  88.         }
  89.         for (j = 16; j < 64; j++)
  90.         {
  91.             w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16];
  92.         }
  93.         for (j = 0; j < 8; j++)
  94.         {
  95.             wv[j] = m_h[j];
  96.         }
  97.         for (j = 0; j < 64; j++)
  98.         {
  99.             t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j];
  100.             t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
  101.             wv[7] = wv[6];
  102.             wv[6] = wv[5];
  103.             wv[5] = wv[4];
  104.             wv[4] = wv[3] + t1;
  105.             wv[3] = wv[2];
  106.             wv[2] = wv[1];
  107.             wv[1] = wv[0];
  108.             wv[0] = t1 + t2;
  109.         }
  110.         for (j = 0; j < 8; j++)
  111.         {
  112.             m_h[j] += wv[j];
  113.         }
  114.     }
  115. }
  116.  
  117. void SHA256::init()
  118. {
  119.     m_h[0] = 0x6a09e667;
  120.     m_h[1] = 0xbb67ae85;
  121.     m_h[2] = 0x3c6ef372;
  122.     m_h[3] = 0xa54ff53a;
  123.     m_h[4] = 0x510e527f;
  124.     m_h[5] = 0x9b05688c;
  125.     m_h[6] = 0x1f83d9ab;
  126.     m_h[7] = 0x5be0cd19;
  127.     m_len = 0;
  128.     m_tot_len = 0;
  129. }
  130.  
  131. void SHA256::update(const unsigned char *message, unsigned int len)
  132. {
  133.     unsigned int block_nb;
  134.     unsigned int new_len, rem_len, tmp_len;
  135.     const unsigned char *shifted_message;
  136.     tmp_len = SHA224_256_BLOCK_SIZE - m_len;
  137.     rem_len = len < tmp_len ? len : tmp_len;
  138.     memcpy(&m_block[m_len], message, rem_len);
  139.     if (m_len + len < SHA224_256_BLOCK_SIZE)
  140.     {
  141.         m_len += len;
  142.         return;
  143.     }
  144.     new_len = len - rem_len;
  145.     block_nb = new_len / SHA224_256_BLOCK_SIZE;
  146.     shifted_message = message + rem_len;
  147.     transform(m_block, 1);
  148.     transform(shifted_message, block_nb);
  149.     rem_len = new_len % SHA224_256_BLOCK_SIZE;
  150.     memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
  151.     m_len = rem_len;
  152.     m_tot_len += (block_nb + 1) << 6;
  153. }
  154.  
  155. void SHA256::final(unsigned char *digest)
  156. {
  157.     unsigned int block_nb;
  158.     unsigned int pm_len;
  159.     unsigned int len_b;
  160.     int i;
  161.     block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9) < (m_len % SHA224_256_BLOCK_SIZE)));
  162.     len_b = (m_tot_len + m_len) << 3;
  163.     pm_len = block_nb << 6;
  164.     memset(m_block + m_len, 0, pm_len - m_len);
  165.     m_block[m_len] = 0x80;
  166.     SHA2_UNPACK32(len_b, m_block + pm_len - 4);
  167.     transform(m_block, block_nb);
  168.     for (i = 0; i < 8; i++)
  169.     {
  170.         SHA2_UNPACK32(m_h[i], &digest[i << 2]);
  171.     }
  172. }
  173.  
  174. std::string sha256(std::string input)
  175. {
  176.     unsigned char digest[SHA256::DIGEST_SIZE];
  177.     memset(digest, 0, SHA256::DIGEST_SIZE);
  178.  
  179.     SHA256 ctx = SHA256();
  180.     ctx.init();
  181.     ctx.update((unsigned char *)input.c_str(), input.length());
  182.     ctx.final(digest);
  183.  
  184.     char buf[2 * SHA256::DIGEST_SIZE + 1];
  185.     buf[2 * SHA256::DIGEST_SIZE] = 0;
  186.     for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
  187.         sprintf(buf + i * 2, "%02x", digest[i]);
  188.     return std::string(buf);
  189. }
  190.  
  191. std::string sha256_vector(vector<std::string> inputs)
  192. {
  193.     unsigned char digest[SHA256::DIGEST_SIZE];
  194.     memset(digest, 0, SHA256::DIGEST_SIZE);
  195.  
  196.     SHA256 ctx = SHA256();
  197.     ctx.init();
  198.     for (string &input : inputs)
  199.     {
  200.         ctx.update((unsigned char *)input.c_str(), input.length());
  201.     }
  202.     ctx.final(digest);
  203.  
  204.     char buf[2 * SHA256::DIGEST_SIZE + 1];
  205.     buf[2 * SHA256::DIGEST_SIZE] = 0;
  206.     for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
  207.         sprintf(buf + i * 2, "%02x", digest[i]);
  208.     return std::string(buf);
  209. }
  210. typedef vector<string> Words;
  211. typedef vector<string> Hashes;
  212.  
  213. Hashes compute_hash(Words words)
  214. {
  215.     Hashes h;
  216.     for (auto &a : words)
  217.     {
  218.         auto hash = sha256(a);
  219.         h.push_back(hash);
  220.     }
  221.     return h;
  222. }
  223. void show_hash(Hashes h)
  224. {
  225.     for (auto &a : h)
  226.     {
  227.         cout << a << endl;
  228.     }
  229. }
  230.  
  231. string compute_merkle(Hashes src)
  232. {
  233.     ............
  234. }
  235. int main()
  236. {
  237.     string input = "grape";
  238.     string output1 = sha256(input);
  239.     cout << output1 << endl;
  240.  
  241.     Words w;
  242.     w.push_back("apple");
  243.     w.push_back("pear");
  244.     w.push_back("strawberry");
  245.     w.push_back("banana");
  246.     auto hashes = compute_hash(w);
  247.     show_hash(hashes);
  248.     auto final = compute_merkle(hashes);
  249.     cout << "final hash =" << final << endl;
  250.     return 0;
  251. }
  252.  
  253.  
  254. final hash =f763dd68d4be72ce37b7f55356e24f958eab69eae59e7ed6d932bacd21d23835
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top