Change sha256 to sha1, and move parsing to main module

7 files changed, 308 insertions, 252 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f20d8e9..655db6f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,4 +3,4 @@ project(t)
 
 set(CMAKE_CXX_STANDARD 17)
 
-add_executable(t src/main.cpp src/opts/cxxopts.hpp src/functions.hpp src/sha256/sha256.cpp src/sha256/sha256.h src/opts/opts.cpp src/opts/opts.hpp)
\ No newline at end of file
+add_executable(t src/main.cpp src/opts/cxxopts.hpp src/functions.hpp)
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 5df353f..35389b1 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,6 +1,56 @@
-#include "opts/opts.hpp"
+#include <filesystem>
+
+#include "opts/cxxopts.hpp"
+#include "functions.hpp"
+#include "sha1/sha1.hpp"
+
+using namespace std;
 
 int main(int argc, char *argv[]) {
-    execute_commands(argc, argv);
+    cxxopts::Options options("MyProgram", "One line description of MyProgram");
+    options
+            .allow_unrecognised_options()
+            .add_options()
+                    ("positional",
+                     "Positional arguments: these are the arguments that are entered "
+                     "without an option", cxxopts::value<std::vector<std::string >>())
+                    ("e,edit", "edit TASK to contain TEXT", cxxopts::value<std::string>())
+                    ("f,finish", "mark TASK as finished", cxxopts::value<std::string>())
+                    ("r,remove", "Remove TASK from list", cxxopts::value<std::string>())
+                    ("l,list", "work on LIST", cxxopts::value<std::string>())
+                    ("t,taskdir", "work on the lists in DIR", cxxopts::value<std::string>())
+                    ("d,delete-if-empty", "delete the task file if it becomes empty")
+                    ("g,grep", "print only tasks that contain WORD", cxxopts::value<std::string>())
+                    ("v,verbose", "print more detailed output (full task ids, etc)")
+                    ("q,quiet", "print less detailed output (no task ids, etc)")
+                    ("D,done", "list done tasks instead of unfinished ones")
+                    ("h,help", "HELP");
+    options.parse_positional({"positional"});
+    auto result = options.parse(argc, argv);
+    const auto &arguments = result.arguments();
+    if (result.count("help")) {
+        std::cout << options.help() << std::endl;
+        exit(0);
+    }
+    if (result.count("positional")) {
+        std::string str;
+        auto &v = result["positional"].as<std::vector<std::string >>();
+        for (const auto &s : v) {
+            str += s + " ";
+        }
+        str = trim(str);
+        char hex[SHA1_HEX_SIZE];
+        sha1(str.c_str()).finalize().print_hex(hex);
+        cout << "sha1('" << str << "'): " << hex << endl;
+    }
+    std::string taskdir;
+    if (result.count("taskdir")) {
+        taskdir = result["taskdir"].as<std::string>();
+    } else {
+        namespace fs = std::filesystem;
+        taskdir = fs::current_path();
+    }
+
+    std::cout << "Current path is " << taskdir << '\n';
     return 0;
 }
\ No newline at end of file
diff --git a/src/opts/opts.cpp b/src/opts/opts.cpp
deleted file mode 100644
index fac0356..0000000
--- a/src/opts/opts.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <filesystem>
-
-#include "cxxopts.hpp"
-#include "../functions.hpp"
-#include "../sha256/sha256.h"
-
-using namespace std;
-
-void execute_commands(int argc, char **argv) {
-    cxxopts::Options options("MyProgram", "One line description of MyProgram");
-    options
-            .allow_unrecognised_options()
-            .add_options()
-                    ("positional",
-                     "Positional arguments: these are the arguments that are entered "
-                     "without an option", cxxopts::value<std::vector<std::string >>())
-                    ("e,edit", "edit TASK to contain TEXT", cxxopts::value<std::string>())
-                    ("f,finish", "mark TASK as finished", cxxopts::value<std::string>())
-                    ("r,remove", "Remove TASK from list", cxxopts::value<std::string>())
-                    ("l,list", "work on LIST", cxxopts::value<std::string>())
-                    ("t,taskdir", "work on the lists in DIR", cxxopts::value<std::string>())
-                    ("d,delete-if-empty", "delete the task file if it becomes empty")
-                    ("g,grep", "print only tasks that contain WORD", cxxopts::value<std::string>())
-                    ("v,verbose", "print more detailed output (full task ids, etc)")
-                    ("q,quiet", "print less detailed output (no task ids, etc)")
-                    ("D,done", "list done tasks instead of unfinished ones")
-                    ("h,help", "HELP");
-    options.parse_positional({"positional"});
-    auto result = options.parse(argc, argv);
-    const auto &arguments = result.arguments();
-    if (result.count("help")) {
-        std::cout << options.help() << std::endl;
-        exit(0);
-    }
-    if (result.count("positional")) {
-        std::string str;
-        auto &v = result["positional"].as<std::vector<std::string >>();
-        for (const auto &s : v) {
-            str += s + " ";
-        }
-        str = trim(str);
-
-        cout << "sha256('" << str << "'): " << sha256(str) << endl;
-    }
-    std::string taskdir;
-    if (result.count("taskdir")) {
-        taskdir = result["taskdir"].as<std::string>();
-    } else {
-        namespace fs = std::filesystem;
-        taskdir = fs::current_path();
-    }
-
-    std::cout << "Current path is " << taskdir << '\n';
-    std::cout << "Saw " << arguments.size() << " arguments" << std::endl;
-}
\ No newline at end of file
diff --git a/src/opts/opts.hpp b/src/opts/opts.hpp
deleted file mode 100644
index 0f38abf..0000000
--- a/src/opts/opts.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-//
-// Created by d.evsyukov on 09.01.2020.
-//
-
-#ifndef T_OPTS_HPP
-#define T_OPTS_HPP
-
-void execute_commands(int argc, char **argv);
-
-#endif //T_OPTS_HPP
diff --git a/src/sha1/sha1.hpp b/src/sha1/sha1.hpp
new file mode 100644
index 0000000..3baeec4
--- /dev/null
+++ b/src/sha1/sha1.hpp
@@ -0,0 +1,255 @@
+#include <stdint.h>
+#include <string.h>
+
+#define SHA1_HEX_SIZE (40 + 1)
+#define SHA1_BASE64_SIZE (28 + 1)
+
+class sha1 {
+private:
+
+    void add_byte_dont_count_bits(uint8_t x) {
+        buf[i++] = x;
+
+        if (i >= sizeof(buf)) {
+            i = 0;
+            process_block(buf);
+        }
+    }
+
+    static uint32_t rol32(uint32_t x, uint32_t n) {
+        return (x << n) | (x >> (32 - n));
+    }
+
+    static uint32_t make_word(const uint8_t *p) {
+        return
+                ((uint32_t) p[0] << 3 * 8) |
+                ((uint32_t) p[1] << 2 * 8) |
+                ((uint32_t) p[2] << 1 * 8) |
+                ((uint32_t) p[3] << 0 * 8);
+    }
+
+    void process_block(const uint8_t *ptr) {
+        const uint32_t c0 = 0x5a827999;
+        const uint32_t c1 = 0x6ed9eba1;
+        const uint32_t c2 = 0x8f1bbcdc;
+        const uint32_t c3 = 0xca62c1d6;
+
+        uint32_t a = state[0];
+        uint32_t b = state[1];
+        uint32_t c = state[2];
+        uint32_t d = state[3];
+        uint32_t e = state[4];
+
+        uint32_t w[16];
+
+        for (int i = 0; i < 16; i++) w[i] = make_word(ptr + i * 4);
+
+#define SHA1_LOAD(i) w[i&15] = rol32(w[(i+13)&15] ^ w[(i+8)&15] ^ w[(i+2)&15] ^ w[i&15], 1);
+#define SHA1_ROUND_0(v, u, x, y, z, i)              z += ((u & (x ^ y)) ^ y) + w[i&15] + c0 + rol32(v, 5); u = rol32(u, 30);
+#define SHA1_ROUND_1(v, u, x, y, z, i) SHA1_LOAD(i) z += ((u & (x ^ y)) ^ y) + w[i&15] + c0 + rol32(v, 5); u = rol32(u, 30);
+#define SHA1_ROUND_2(v, u, x, y, z, i) SHA1_LOAD(i) z += (u ^ x ^ y) + w[i&15] + c1 + rol32(v, 5); u = rol32(u, 30);
+#define SHA1_ROUND_3(v, u, x, y, z, i) SHA1_LOAD(i) z += (((u | x) & y) | (u & x)) + w[i&15] + c2 + rol32(v, 5); u = rol32(u, 30);
+#define SHA1_ROUND_4(v, u, x, y, z, i) SHA1_LOAD(i) z += (u ^ x ^ y) + w[i&15] + c3 + rol32(v, 5); u = rol32(u, 30);
+
+        SHA1_ROUND_0(a, b, c, d, e, 0);
+        SHA1_ROUND_0(e, a, b, c, d, 1);
+        SHA1_ROUND_0(d, e, a, b, c, 2);
+        SHA1_ROUND_0(c, d, e, a, b, 3);
+        SHA1_ROUND_0(b, c, d, e, a, 4);
+        SHA1_ROUND_0(a, b, c, d, e, 5);
+        SHA1_ROUND_0(e, a, b, c, d, 6);
+        SHA1_ROUND_0(d, e, a, b, c, 7);
+        SHA1_ROUND_0(c, d, e, a, b, 8);
+        SHA1_ROUND_0(b, c, d, e, a, 9);
+        SHA1_ROUND_0(a, b, c, d, e, 10);
+        SHA1_ROUND_0(e, a, b, c, d, 11);
+        SHA1_ROUND_0(d, e, a, b, c, 12);
+        SHA1_ROUND_0(c, d, e, a, b, 13);
+        SHA1_ROUND_0(b, c, d, e, a, 14);
+        SHA1_ROUND_0(a, b, c, d, e, 15);
+        SHA1_ROUND_1(e, a, b, c, d, 16);
+        SHA1_ROUND_1(d, e, a, b, c, 17);
+        SHA1_ROUND_1(c, d, e, a, b, 18);
+        SHA1_ROUND_1(b, c, d, e, a, 19);
+        SHA1_ROUND_2(a, b, c, d, e, 20);
+        SHA1_ROUND_2(e, a, b, c, d, 21);
+        SHA1_ROUND_2(d, e, a, b, c, 22);
+        SHA1_ROUND_2(c, d, e, a, b, 23);
+        SHA1_ROUND_2(b, c, d, e, a, 24);
+        SHA1_ROUND_2(a, b, c, d, e, 25);
+        SHA1_ROUND_2(e, a, b, c, d, 26);
+        SHA1_ROUND_2(d, e, a, b, c, 27);
+        SHA1_ROUND_2(c, d, e, a, b, 28);
+        SHA1_ROUND_2(b, c, d, e, a, 29);
+        SHA1_ROUND_2(a, b, c, d, e, 30);
+        SHA1_ROUND_2(e, a, b, c, d, 31);
+        SHA1_ROUND_2(d, e, a, b, c, 32);
+        SHA1_ROUND_2(c, d, e, a, b, 33);
+        SHA1_ROUND_2(b, c, d, e, a, 34);
+        SHA1_ROUND_2(a, b, c, d, e, 35);
+        SHA1_ROUND_2(e, a, b, c, d, 36);
+        SHA1_ROUND_2(d, e, a, b, c, 37);
+        SHA1_ROUND_2(c, d, e, a, b, 38);
+        SHA1_ROUND_2(b, c, d, e, a, 39);
+        SHA1_ROUND_3(a, b, c, d, e, 40);
+        SHA1_ROUND_3(e, a, b, c, d, 41);
+        SHA1_ROUND_3(d, e, a, b, c, 42);
+        SHA1_ROUND_3(c, d, e, a, b, 43);
+        SHA1_ROUND_3(b, c, d, e, a, 44);
+        SHA1_ROUND_3(a, b, c, d, e, 45);
+        SHA1_ROUND_3(e, a, b, c, d, 46);
+        SHA1_ROUND_3(d, e, a, b, c, 47);
+        SHA1_ROUND_3(c, d, e, a, b, 48);
+        SHA1_ROUND_3(b, c, d, e, a, 49);
+        SHA1_ROUND_3(a, b, c, d, e, 50);
+        SHA1_ROUND_3(e, a, b, c, d, 51);
+        SHA1_ROUND_3(d, e, a, b, c, 52);
+        SHA1_ROUND_3(c, d, e, a, b, 53);
+        SHA1_ROUND_3(b, c, d, e, a, 54);
+        SHA1_ROUND_3(a, b, c, d, e, 55);
+        SHA1_ROUND_3(e, a, b, c, d, 56);
+        SHA1_ROUND_3(d, e, a, b, c, 57);
+        SHA1_ROUND_3(c, d, e, a, b, 58);
+        SHA1_ROUND_3(b, c, d, e, a, 59);
+        SHA1_ROUND_4(a, b, c, d, e, 60);
+        SHA1_ROUND_4(e, a, b, c, d, 61);
+        SHA1_ROUND_4(d, e, a, b, c, 62);
+        SHA1_ROUND_4(c, d, e, a, b, 63);
+        SHA1_ROUND_4(b, c, d, e, a, 64);
+        SHA1_ROUND_4(a, b, c, d, e, 65);
+        SHA1_ROUND_4(e, a, b, c, d, 66);
+        SHA1_ROUND_4(d, e, a, b, c, 67);
+        SHA1_ROUND_4(c, d, e, a, b, 68);
+        SHA1_ROUND_4(b, c, d, e, a, 69);
+        SHA1_ROUND_4(a, b, c, d, e, 70);
+        SHA1_ROUND_4(e, a, b, c, d, 71);
+        SHA1_ROUND_4(d, e, a, b, c, 72);
+        SHA1_ROUND_4(c, d, e, a, b, 73);
+        SHA1_ROUND_4(b, c, d, e, a, 74);
+        SHA1_ROUND_4(a, b, c, d, e, 75);
+        SHA1_ROUND_4(e, a, b, c, d, 76);
+        SHA1_ROUND_4(d, e, a, b, c, 77);
+        SHA1_ROUND_4(c, d, e, a, b, 78);
+        SHA1_ROUND_4(b, c, d, e, a, 79);
+
+#undef SHA1_LOAD
+#undef SHA1_ROUND_0
+#undef SHA1_ROUND_1
+#undef SHA1_ROUND_2
+#undef SHA1_ROUND_3
+#undef SHA1_ROUND_4
+
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+        state[4] += e;
+    }
+
+public:
+
+    uint32_t state[5];
+    uint8_t buf[64];
+    uint32_t i;
+    uint64_t n_bits;
+
+    sha1(const char *text = NULL) : i(0), n_bits(0) {
+        state[0] = 0x67452301;
+        state[1] = 0xEFCDAB89;
+        state[2] = 0x98BADCFE;
+        state[3] = 0x10325476;
+        state[4] = 0xC3D2E1F0;
+        if (text) add(text);
+    }
+
+    sha1 &add(uint8_t x) {
+        add_byte_dont_count_bits(x);
+        n_bits += 8;
+        return *this;
+    }
+
+    sha1 &add(char c) {
+        return add(*(uint8_t *) &c);
+    }
+
+    sha1 &add(const void *data, uint32_t n) {
+        if (!data) return *this;
+
+        const uint8_t *ptr = (const uint8_t *) data;
+
+        // fill up block if not full
+        for (; n && i % sizeof(buf); n--) add(*ptr++);
+
+        // process full blocks
+        for (; n >= sizeof(buf); n -= sizeof(buf)) {
+            process_block(ptr);
+            ptr += sizeof(buf);
+            n_bits += sizeof(buf) * 8;
+        }
+
+        // process remaining part of block
+        for (; n; n--) add(*ptr++);
+
+        return *this;
+    }
+
+    sha1 &add(const char *text) {
+        if (!text) return *this;
+        return add(text, strlen(text));
+    }
+
+    sha1 &finalize() {
+        // hashed text ends with 0x80, some padding 0x00 and the length in bits
+        add_byte_dont_count_bits(0x80);
+        while (i % 64 != 56) add_byte_dont_count_bits(0x00);
+        for (int j = 7; j >= 0; j--) add_byte_dont_count_bits(n_bits >> j * 8);
+
+        return *this;
+    }
+
+    const sha1 &print_hex(
+            char *hex,
+            bool zero_terminate = true,
+            const char *alphabet = "0123456789abcdef"
+    ) const {
+        // print hex
+        int k = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 7; j >= 0; j--) {
+                hex[k++] = alphabet[(state[i] >> j * 4) & 0xf];
+            }
+        }
+        if (zero_terminate) hex[k] = '\0';
+        return *this;
+    }
+
+    const sha1 &print_base64(char *base64, bool zero_terminate = true) const {
+        static const uint8_t *table = (const uint8_t *)
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                "abcdefghijklmnopqrstuvwxyz"
+                "0123456789"
+                "+/";
+
+        uint32_t triples[7] = {
+                ((state[0] & 0xffffff00) >> 1 * 8),
+                ((state[0] & 0x000000ff) << 2 * 8) | ((state[1] & 0xffff0000) >> 2 * 8),
+                ((state[1] & 0x0000ffff) << 1 * 8) | ((state[2] & 0xff000000) >> 3 * 8),
+                ((state[2] & 0x00ffffff) << 0 * 8),
+                ((state[3] & 0xffffff00) >> 1 * 8),
+                ((state[3] & 0x000000ff) << 2 * 8) | ((state[4] & 0xffff0000) >> 2 * 8),
+                ((state[4] & 0x0000ffff) << 1 * 8),
+        };
+
+        for (int i = 0; i < 7; i++) {
+            uint32_t x = triples[i];
+            base64[i * 4 + 0] = table[(x >> 3 * 6) % 64];
+            base64[i * 4 + 1] = table[(x >> 2 * 6) % 64];
+            base64[i * 4 + 2] = table[(x >> 1 * 6) % 64];
+            base64[i * 4 + 3] = table[(x >> 0 * 6) % 64];
+        }
+
+        base64[SHA1_BASE64_SIZE - 2] = '=';
+        if (zero_terminate) base64[SHA1_BASE64_SIZE - 1] = '\0';
+        return *this;
+    }
+};
diff --git a/src/sha256/sha256.cpp b/src/sha256/sha256.cpp
deleted file mode 100644
index 3feded9..0000000
--- a/src/sha256/sha256.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <cstring>
-#include <fstream>
-#include "sha256.h"
-
-const unsigned int SHA256::sha256_k[64] = //UL = uint32
-        {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};
-
-void SHA256::transform(const unsigned char *message, unsigned int block_nb) {
-    uint32 w[64];
-    uint32 wv[8];
-    uint32 t1, t2;
-    const unsigned char *sub_block;
-    int i;
-    int j;
-    for (i = 0; i < (int) block_nb; i++) {
-        sub_block = message + (i << 6);
-        for (j = 0; j < 16; j++) {
-            SHA2_PACK32(&sub_block[j << 2], &w[j]);
-        }
-        for (j = 16; j < 64; j++) {
-            w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16];
-        }
-        for (j = 0; j < 8; j++) {
-            wv[j] = m_h[j];
-        }
-        for (j = 0; j < 64; j++) {
-            t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
-                 + sha256_k[j] + w[j];
-            t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
-            wv[7] = wv[6];
-            wv[6] = wv[5];
-            wv[5] = wv[4];
-            wv[4] = wv[3] + t1;
-            wv[3] = wv[2];
-            wv[2] = wv[1];
-            wv[1] = wv[0];
-            wv[0] = t1 + t2;
-        }
-        for (j = 0; j < 8; j++) {
-            m_h[j] += wv[j];
-        }
-    }
-}
-
-void SHA256::init() {
-    m_h[0] = 0x6a09e667;
-    m_h[1] = 0xbb67ae85;
-    m_h[2] = 0x3c6ef372;
-    m_h[3] = 0xa54ff53a;
-    m_h[4] = 0x510e527f;
-    m_h[5] = 0x9b05688c;
-    m_h[6] = 0x1f83d9ab;
-    m_h[7] = 0x5be0cd19;
-    m_len = 0;
-    m_tot_len = 0;
-}
-
-void SHA256::update(const unsigned char *message, unsigned int len) {
-    unsigned int block_nb;
-    unsigned int new_len, rem_len, tmp_len;
-    const unsigned char *shifted_message;
-    tmp_len = SHA224_256_BLOCK_SIZE - m_len;
-    rem_len = len < tmp_len ? len : tmp_len;
-    memcpy(&m_block[m_len], message, rem_len);
-    if (m_len + len < SHA224_256_BLOCK_SIZE) {
-        m_len += len;
-        return;
-    }
-    new_len = len - rem_len;
-    block_nb = new_len / SHA224_256_BLOCK_SIZE;
-    shifted_message = message + rem_len;
-    transform(m_block, 1);
-    transform(shifted_message, block_nb);
-    rem_len = new_len % SHA224_256_BLOCK_SIZE;
-    memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
-    m_len = rem_len;
-    m_tot_len += (block_nb + 1) << 6;
-}
-
-void SHA256::final(unsigned char *digest) {
-    unsigned int block_nb;
-    unsigned int pm_len;
-    unsigned int len_b;
-    int i;
-    block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9)
-                     < (m_len % SHA224_256_BLOCK_SIZE)));
-    len_b = (m_tot_len + m_len) << 3;
-    pm_len = block_nb << 6;
-    memset(m_block + m_len, 0, pm_len - m_len);
-    m_block[m_len] = 0x80;
-    SHA2_UNPACK32(len_b, m_block + pm_len - 4);
-    transform(m_block, block_nb);
-    for (i = 0; i < 8; i++) {
-        SHA2_UNPACK32(m_h[i], &digest[i << 2]);
-    }
-}
-
-std::string sha256(std::string input) {
-    unsigned char digest[SHA256::DIGEST_SIZE];
-    memset(digest, 0, SHA256::DIGEST_SIZE);
-
-    SHA256 ctx = SHA256();
-    ctx.init();
-    ctx.update((unsigned char *) input.c_str(), input.length());
-    ctx.final(digest);
-
-    char buf[2 * SHA256::DIGEST_SIZE + 1];
-    buf[2 * SHA256::DIGEST_SIZE] = 0;
-    for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
-        sprintf(buf + i * 2, "%02x", digest[i]);
-    return std::string(buf);
-}
\ No newline at end of file
diff --git a/src/sha256/sha256.h b/src/sha256/sha256.h
deleted file mode 100644
index 03355a9..0000000
--- a/src/sha256/sha256.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef SHA256_H
-#define SHA256_H
-
-#include <string>
-
-class SHA256 {
-protected:
-    typedef unsigned char uint8;
-    typedef unsigned int uint32;
-    typedef unsigned long long uint64;
-
-    const static uint32 sha256_k[];
-    static const unsigned int SHA224_256_BLOCK_SIZE = (512 / 8);
-public:
-    void init();
-
-    void update(const unsigned char *message, unsigned int len);
-
-    void final(unsigned char *digest);
-
-    static const unsigned int DIGEST_SIZE = (256 / 8);
-
-protected:
-    void transform(const unsigned char *message, unsigned int block_nb);
-
-    unsigned int m_tot_len;
-    unsigned int m_len;
-    unsigned char m_block[2 * SHA224_256_BLOCK_SIZE];
-    uint32 m_h[8];
-};
-
-std::string sha256(std::string input);
-
-#define SHA2_SHFR(x, n)    (x >> n)
-#define SHA2_ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
-#define SHA2_ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
-#define SHA2_CH(x, y, z)  ((x & y) ^ (~x & z))
-#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
-#define SHA256_F1(x) (SHA2_ROTR(x,  2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22))
-#define SHA256_F2(x) (SHA2_ROTR(x,  6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25))
-#define SHA256_F3(x) (SHA2_ROTR(x,  7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x,  3))
-#define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10))
-#define SHA2_UNPACK32(x, str)                 \
-{                                             \
-    *((str) + 3) = (uint8) ((x)      );       \
-    *((str) + 2) = (uint8) ((x) >>  8);       \
-    *((str) + 1) = (uint8) ((x) >> 16);       \
-    *((str) + 0) = (uint8) ((x) >> 24);       \
-}
-#define SHA2_PACK32(str, x)                   \
-{                                             \
-    *(x) =   ((uint32) *((str) + 3)      )    \
-           | ((uint32) *((str) + 2) <<  8)    \
-           | ((uint32) *((str) + 1) << 16)    \
-           | ((uint32) *((str) + 0) << 24);   \
-}
-#endif
\ No newline at end of file