dcp.cpp

Go to the documentation of this file.

 
#include <array>
#include <cstdint>
#include <cstring>
 
namespace utils {
 
// SHA-256 constants
constexpr std::array<uint32_t, 64> K = {
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
 
// SHA-1 constants
constexpr std::array<uint32_t, 4> H1 = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476};
 
// Helper functions
inline uint32_t rotr(uint32_t x, uint32_t n) { return (x >> n) | (x << (32 - n)); }
 
inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (~x & z); }
 
inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (x & z) ^ (y & z); }
 
inline uint32_t sigma0(uint32_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); }
 
inline uint32_t sigma1(uint32_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); }
 
void hash_sha256(const uint8_t *msg, size_t msg_len, uint8_t *out_hash) {
  // Initialize hash values
  uint32_t h0 = 0x6a09e667;
  uint32_t h1 = 0xbb67ae85;
  uint32_t h2 = 0x3c6ef372;
  uint32_t h3 = 0xa54ff53a;
  uint32_t h4 = 0x510e527f;
  uint32_t h5 = 0x9b05688c;
  uint32_t h6 = 0x1f83d9ab;
  uint32_t h7 = 0x5be0cd19;
 
  // Pre-processing: Padding the message
  size_t new_len = ((((msg_len + 8) / 64) + 1) * 64) - 8;
  uint8_t *padded = new uint8_t[new_len + 64];
  memcpy(padded, msg, msg_len);
  padded[msg_len] = 0x80;
 
  for (size_t i = msg_len + 1; i < new_len; i++) {
    padded[i] = 0;
  }
 
  // Append length in bits
  uint64_t bits_len = msg_len * 8;
  for (int i = 0; i < 8; i++) {
    padded[new_len + i] = (bits_len >> (56 - i * 8)) & 0xFF;
  }
 
  // Process the message in 512-bit chunks
  for (size_t chunk = 0; chunk < new_len + 64; chunk += 64) {
    uint32_t w[64];
 
    // Create message schedule
    for (int i = 0; i < 16; i++) {
      w[i] = (padded[chunk + i * 4] << 24) | (padded[chunk + i * 4 + 1] << 16) |
             (padded[chunk + i * 4 + 2] << 8) | padded[chunk + i * 4 + 3];
    }
 
    for (int i = 16; i < 64; i++) {
      uint32_t s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3);
      uint32_t s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10);
      w[i] = w[i - 16] + s0 + w[i - 7] + s1;
    }
 
    // Initialize working variables
    uint32_t a = h0;
    uint32_t b = h1;
    uint32_t c = h2;
    uint32_t d = h3;
    uint32_t e = h4;
    uint32_t f = h5;
    uint32_t g = h6;
    uint32_t h = h7;
 
    // Main loop
    for (int i = 0; i < 64; i++) {
      uint32_t S1 = sigma1(e);
      uint32_t ch_val = ch(e, f, g);
      uint32_t temp1 = h + S1 + ch_val + K[i] + w[i];
      uint32_t S0 = sigma0(a);
      uint32_t maj_val = maj(a, b, c);
      uint32_t temp2 = S0 + maj_val;
 
      h = g;
      g = f;
      f = e;
      e = d + temp1;
      d = c;
      c = b;
      b = a;
      a = temp1 + temp2;
    }
 
    // Update hash values
    h0 += a;
    h1 += b;
    h2 += c;
    h3 += d;
    h4 += e;
    h5 += f;
    h6 += g;
    h7 += h;
  }
 
  delete[] padded;
 
  // Produce the final hash value
  uint32_t hash[8] = {h0, h1, h2, h3, h4, h5, h6, h7};
  memcpy(out_hash, hash, 32);
}
 
void hash_sha1(const uint8_t *msg, size_t msg_len, uint8_t *out_hash) {
  // Initialize variables
  uint32_t h0 = 0x67452301;
  uint32_t h1 = 0xEFCDAB89;
  uint32_t h2 = 0x98BADCFE;
  uint32_t h3 = 0x10325476;
  uint32_t h4 = 0xC3D2E1F0;
 
  // Pre-processing
  size_t new_len = ((((msg_len + 8) / 64) + 1) * 64) - 8;
  uint8_t *padded = new uint8_t[new_len + 64];
  memcpy(padded, msg, msg_len);
  padded[msg_len] = 0x80;
 
  for (size_t i = msg_len + 1; i < new_len; i++) {
    padded[i] = 0;
  }
 
  // Append length in bits
  uint64_t bits_len = msg_len * 8;
  for (int i = 0; i < 8; i++) {
    padded[new_len + i] = (bits_len >> (56 - i * 8)) & 0xFF;
  }
 
  // Process the message in 512-bit chunks
  for (size_t chunk = 0; chunk < new_len + 64; chunk += 64) {
    uint32_t w[80];
 
    // Break chunk into sixteen 32-bit big-endian words
    for (int i = 0; i < 16; i++) {
      w[i] = (padded[chunk + i * 4] << 24) | (padded[chunk + i * 4 + 1] << 16) |
             (padded[chunk + i * 4 + 2] << 8) | padded[chunk + i * 4 + 3];
    }
 
    // Extend the sixteen 32-bit words into eighty 32-bit words
    for (int i = 16; i < 80; i++) {
      w[i] = rotr((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 31);
    }
 
    // Initialize hash value for this chunk
    uint32_t a = h0;
    uint32_t b = h1;
    uint32_t c = h2;
    uint32_t d = h3;
    uint32_t e = h4;
 
    // Main loop
    for (int i = 0; i < 80; i++) {
      uint32_t f, k;
 
      if (i < 20) {
        f = (b & c) | ((~b) & d);
        k = 0x5A827999;
      } else if (i < 40) {
        f = b ^ c ^ d;
        k = 0x6ED9EBA1;
      } else if (i < 60) {
        f = (b & c) | (b & d) | (c & d);
        k = 0x8F1BBCDC;
      } else {
        f = b ^ c ^ d;
        k = 0xCA62C1D6;
      }
 
      uint32_t temp = rotr(a, 27) + f + e + k + w[i];
      e = d;
      d = c;
      c = rotr(b, 2);
      b = a;
      a = temp;
    }
 
    // Add this chunk's hash to result so far
    h0 += a;
    h1 += b;
    h2 += c;
    h3 += d;
    h4 += e;
  }
 
  delete[] padded;
 
  // Produce the final hash value
  uint32_t hash[5] = {h0, h1, h2, h3, h4};
  memcpy(out_hash, hash, 20);
}
 
} // namespace utils