v1.4.4

source/core/StarSha256.cpp

@@ -0,0 +1,260 @@
+#include "StarSha256.hpp"
+#include "StarFormat.hpp"
+#include "StarEncode.hpp"
+
+namespace Star {
+
+// An implementation of the SHA-256 hash function, this is endian neutral
+// so should work just about anywhere.
+//
+// This code works much like the MD5 code provided by RSA. You sha_init()
+// a "sha_state" then sha_process() the bytes you want and sha_done() to get
+// the output.
+//
+// Revised Code:  Complies to SHA-256 standard now.
+//
+// Tom St Denis
+
+// the K array
+static const uint32_t K[64] = {0x428a2f98U,
+    0x71374491U,
+    0xb5c0fbcfU,
+    0xe9b5dba5U,
+    0x3956c25bU,
+    0x59f111f1U,
+    0x923f82a4U,
+    0xab1c5ed5U,
+    0xd807aa98U,
+    0x12835b01U,
+    0x243185beU,
+    0x550c7dc3U,
+    0x72be5d74U,
+    0x80deb1feU,
+    0x9bdc06a7U,
+    0xc19bf174U,
+    0xe49b69c1U,
+    0xefbe4786U,
+    0x0fc19dc6U,
+    0x240ca1ccU,
+    0x2de92c6fU,
+    0x4a7484aaU,
+    0x5cb0a9dcU,
+    0x76f988daU,
+    0x983e5152U,
+    0xa831c66dU,
+    0xb00327c8U,
+    0xbf597fc7U,
+    0xc6e00bf3U,
+    0xd5a79147U,
+    0x06ca6351U,
+    0x14292967U,
+    0x27b70a85U,
+    0x2e1b2138U,
+    0x4d2c6dfcU,
+    0x53380d13U,
+    0x650a7354U,
+    0x766a0abbU,
+    0x81c2c92eU,
+    0x92722c85U,
+    0xa2bfe8a1U,
+    0xa81a664bU,
+    0xc24b8b70U,
+    0xc76c51a3U,
+    0xd192e819U,
+    0xd6990624U,
+    0xf40e3585U,
+    0x106aa070U,
+    0x19a4c116U,
+    0x1e376c08U,
+    0x2748774cU,
+    0x34b0bcb5U,
+    0x391c0cb3U,
+    0x4ed8aa4aU,
+    0x5b9cca4fU,
+    0x682e6ff3U,
+    0x748f82eeU,
+    0x78a5636fU,
+    0x84c87814U,
+    0x8cc70208U,
+    0x90befffaU,
+    0xa4506cebU,
+    0xbef9a3f7U,
+    0xc67178f2UL};
+
+// Various logical functions
+#define Ch(x, y, z) ((x & y) ^ (~x & z))
+#define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
+#define S(x, n) (((x) >> ((n)&31)) | ((x) << (32 - ((n)&31))))
+#define R(x, n) ((x) >> (n))
+#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
+#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
+#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
+#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
+
+// compress 512-bits
+static void sha_compress(sha_state* md) {
+  uint32_t S[8], W[64], t0, t1;
+  int i;
+
+  /* copy state into S */
+  for (i = 0; i < 8; i++)
+    S[i] = md->state[i];
+
+  /* copy the state into 512-bits into W[0..15] */
+  for (i = 0; i < 16; i++)
+    W[i] = (((uint32_t)md->buf[(4 * i) + 0]) << 24) | (((uint32_t)md->buf[(4 * i) + 1]) << 16)
+        | (((uint32_t)md->buf[(4 * i) + 2]) << 8) | (((uint32_t)md->buf[(4 * i) + 3]));
+
+  /* fill W[16..63] */
+  for (i = 16; i < 64; i++)
+    W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
+
+  /* Compress */
+  for (i = 0; i < 64; i++) {
+    t0 = S[7] + Sigma1(S[4]) + Ch(S[4], S[5], S[6]) + K[i] + W[i];
+    t1 = Sigma0(S[0]) + Maj(S[0], S[1], S[2]);
+    S[7] = S[6];
+    S[6] = S[5];
+    S[5] = S[4];
+    S[4] = S[3] + t0;
+    S[3] = S[2];
+    S[2] = S[1];
+    S[1] = S[0];
+    S[0] = t0 + t1;
+  }
+
+  /* feedback */
+  for (i = 0; i < 8; i++)
+    md->state[i] += S[i];
+}
+
+// init the SHA state
+static void sha_init(sha_state* md) {
+  md->curlen = md->length = 0;
+  md->state[0] = 0x6A09E667U;
+  md->state[1] = 0xBB67AE85U;
+  md->state[2] = 0x3C6EF372U;
+  md->state[3] = 0xA54FF53AU;
+  md->state[4] = 0x510E527FU;
+  md->state[5] = 0x9B05688CU;
+  md->state[6] = 0x1F83D9ABU;
+  md->state[7] = 0x5BE0CD19U;
+}
+
+static void sha_process(sha_state* md, uint8_t* buf, int len) {
+  while (len--) {
+    /* copy byte */
+    md->buf[md->curlen++] = *buf++;
+
+    /* is 64 bytes full? */
+    if (md->curlen == 64) {
+      sha_compress(md);
+      md->length += 512;
+      md->curlen = 0;
+    }
+  }
+}
+
+static void sha_done(sha_state* md, uint8_t* hash) {
+  int i;
+
+  /* increase the length of the message */
+  md->length += md->curlen * 8;
+
+  /* append the '1' bit */
+  md->buf[md->curlen++] = 0x80;
+
+  /* if the length is currently above 56 bytes we append zeros then compress.
+    Then we can fall back to padding zeros and length encoding like normal. */
+
+  if (md->curlen > 56) {
+    for (; md->curlen < 64;)
+      md->buf[md->curlen++] = 0;
+    sha_compress(md);
+    md->curlen = 0;
+  }
+
+  /* pad upto 56 bytes of zeroes */
+  for (; md->curlen < 56;)
+    md->buf[md->curlen++] = 0;
+
+  /* since all messages are under 2^32 bits we mark the top bits zero */
+  for (i = 56; i < 60; i++)
+    md->buf[i] = 0;
+
+  /* append length */
+  for (i = 60; i < 64; i++)
+    md->buf[i] = (md->length >> ((63 - i) * 8)) & 255;
+  sha_compress(md);
+
+  /* copy output */
+  for (i = 0; i < 32; i++)
+    hash[i] = (md->state[i >> 2] >> (((3 - i) & 3) << 3)) & 255;
+}
+
+Sha256Hasher::Sha256Hasher() {
+  m_finished = false;
+  sha_init(&m_state);
+}
+
+void Sha256Hasher::push(char const* data, size_t length) {
+  if (m_finished) {
+    sha_init(&m_state);
+    m_finished = false;
+  }
+
+  sha_process(&m_state, (uint8_t*)data, length);
+}
+
+void Sha256Hasher::push(String const& data) {
+  push(data.utf8Ptr(), data.utf8Size());
+}
+
+void Sha256Hasher::push(ByteArray const& data) {
+  push(data.ptr(), data.size());
+}
+
+ByteArray Sha256Hasher::compute() {
+  ByteArray dest(32, 0);
+  sha_done(&m_state, (uint8_t*)dest.ptr());
+  m_finished = true;
+  return dest;
+}
+
+void Sha256Hasher::compute(char* hashDestination) {
+  sha_done(&m_state, (uint8_t*)hashDestination);
+  m_finished = true;
+}
+
+void sha256(char const* source, size_t length, char* hashDestination) {
+  sha_state state;
+  sha_init(&state);
+  sha_process(&state, (uint8_t*)source, length);
+  sha_done(&state, (uint8_t*)hashDestination);
+}
+
+ByteArray sha256(char const* source, size_t length) {
+  ByteArray dest(32, 0);
+  sha256(source, length, dest.ptr());
+  return dest;
+}
+
+void sha256(ByteArray const& in, ByteArray& out) {
+  out.resize(32, 0);
+  sha256(in.ptr(), in.size(), out.ptr());
+}
+
+void sha256(String const& in, ByteArray& out) {
+  out.resize(32, 0);
+  sha256(in.utf8Ptr(), in.utf8Size(), out.ptr());
+}
+
+ByteArray sha256(ByteArray const& in) {
+  return sha256(in.ptr(), in.size());
+}
+
+ByteArray sha256(String const& in) {
+  return sha256(in.utf8Ptr(), in.utf8Size());
+}
+
+}