feat: implement MD5 algorithm

.gitignore

@@ -1,6 +1,10 @@
 .DS_Store
-.idea
+.vs
 .vscode
+.idea
 
 /build
 /cmake-build-*
+/out
+
+/CMakeSettings.json

common/MD5.cpp

@@ -1,13 +1,246 @@
 #include "common/MD5.hpp"
 
-void MD5Init(MD5_CTX* context) {
-    // TODO
+#include <cstring>
+
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+static void MD5Transform(uint32_t[4], const uint8_t[64]);
+static void Encode(uint8_t*, const uint32_t*, unsigned int);
+static void Decode(uint32_t*, const uint8_t*, unsigned int);
+
+static uint8_t PADDING[64] = {
+    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* F, G, H and I are basic MD5 functions.
+ */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~z)))
+
+/* ROTATE_LEFT rotates x left n bits.
+ */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+Rotation is separate from addition to prevent recomputation.
+ */
+#define FF(a, b, c, d, x, s, ac)                        \
+    {                                                   \
+        (a) += F((b), (c), (d)) + (x) + (uint32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                    \
+        (a) += (b);                                     \
+    }
+#define GG(a, b, c, d, x, s, ac)                        \
+    {                                                   \
+        (a) += G((b), (c), (d)) + (x) + (uint32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                    \
+        (a) += (b);                                     \
+    }
+#define HH(a, b, c, d, x, s, ac)                        \
+    {                                                   \
+        (a) += H((b), (c), (d)) + (x) + (uint32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                    \
+        (a) += (b);                                     \
+    }
+#define II(a, b, c, d, x, s, ac)                        \
+    {                                                   \
+        (a) += I((b), (c), (d)) + (x) + (uint32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                    \
+        (a) += (b);                                     \
     }
 
-void MD5Update(MD5_CTX* context, uint8_t* input, uint32_t inputLen) {
-    // TODO
+
+void MD5Init(MD5_CTX* context) {
+    context->count[0] = 0;
+    context->count[1] = 0;
+
+    context->state[0] = 0x67452301;
+    context->state[1] = 0XEFCDAB89;
+    context->state[2] = 0X98BADCFE;
+    context->state[3] = 0x10325476;
+}
+
+void MD5Update(MD5_CTX* context, const void* input, size_t inputLen) {
+    auto inputBuffer = reinterpret_cast<const uint8_t*>(input);
+
+    uint32_t i, index, partLen;
+
+    /* Compute number of bytes mod 64 */
+    index = (uint32_t)((context->count[0] >> 3) & 0x3F);
+
+    /* Update number of bits */
+    if ((context->count[0] += ((uint32_t)inputLen << 3)) < ((uint32_t)inputLen << 3))
+        context->count[1]++;
+    context->count[1] += ((uint32_t)inputLen >> 29);
+    partLen = 64 - index;
+
+    /* Transform as many times as possible. */
+    if (inputLen >= partLen) {
+        memcpy(&context->buffer[index], inputBuffer, partLen);
+        MD5Transform(context->state, context->buffer);
+
+        for (i = partLen; i + 63 < inputLen; i += 64) {
+            MD5Transform(context->state, &inputBuffer[i]);
+        }
+
+        index = 0;
+    } else {
+        i = 0;
+    }
+
+    /* Buffer remaining input */
+    memcpy(&context->buffer[index], &inputBuffer[i], inputLen - i);
 }
 
 void MD5Final(uint8_t digest[16], MD5_CTX* context) {
-    // TODO
+    uint8_t bits[8];
+    uint32_t index, padLen;
+
+    /* Save number of bits */
+    Encode(bits, context->count, 8);
+
+    /* Pad out to 56 mod 64. */
+    index = (uint32_t)((context->count[0] >> 3) & 0x3f);
+    padLen = (index < 56) ? (56 - index) : (120 - index);
+    MD5Update(context, PADDING, padLen);
+
+    /* Append length (before padding) */
+    MD5Update(context, bits, 8);
+
+    /* Store state in digest */
+    Encode(digest, context->state, 16);
+
+    /* Zeroize sensitive information. */
+    memset(context, 0, sizeof(*context));
+}
+
+static void MD5Transform(uint32_t state[4], const uint8_t block[64]) {
+    uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+    Decode(x, block, 64);
+
+    /* Round 1 */
+    FF(a, b, c, d, x[0], S11, 0xd76aa478);  /* 1 */
+    FF(d, a, b, c, x[1], S12, 0xe8c7b756);  /* 2 */
+    FF(c, d, a, b, x[2], S13, 0x242070db);  /* 3 */
+    FF(b, c, d, a, x[3], S14, 0xc1bdceee);  /* 4 */
+    FF(a, b, c, d, x[4], S11, 0xf57c0faf);  /* 5 */
+    FF(d, a, b, c, x[5], S12, 0x4787c62a);  /* 6 */
+    FF(c, d, a, b, x[6], S13, 0xa8304613);  /* 7 */
+    FF(b, c, d, a, x[7], S14, 0xfd469501);  /* 8 */
+    FF(a, b, c, d, x[8], S11, 0x698098d8);  /* 9 */
+    FF(d, a, b, c, x[9], S12, 0x8b44f7af);  /* 10 */
+    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+    /* Round 2 */
+    GG(a, b, c, d, x[1], S21, 0xf61e2562);  /* 17 */
+    GG(d, a, b, c, x[6], S22, 0xc040b340);  /* 18 */
+    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);  /* 20 */
+    GG(a, b, c, d, x[5], S21, 0xd62f105d);  /* 21 */
+    GG(d, a, b, c, x[10], S22, 0x2441453);  /* 22 */
+    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);  /* 24 */
+    GG(a, b, c, d, x[9], S21, 0x21e1cde6);  /* 25 */
+    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+    GG(c, d, a, b, x[3], S23, 0xf4d50d87);  /* 27 */
+    GG(b, c, d, a, x[8], S24, 0x455a14ed);  /* 28 */
+    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+    GG(d, a, b, c, x[2], S22, 0xfcefa3f8);  /* 30 */
+    GG(c, d, a, b, x[7], S23, 0x676f02d9);  /* 31 */
+    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+    /* Round 3 */
+    HH(a, b, c, d, x[5], S31, 0xfffa3942);  /* 33 */
+    HH(d, a, b, c, x[8], S32, 0x8771f681);  /* 34 */
+    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+    HH(a, b, c, d, x[1], S31, 0xa4beea44);  /* 37 */
+    HH(d, a, b, c, x[4], S32, 0x4bdecfa9);  /* 38 */
+    HH(c, d, a, b, x[7], S33, 0xf6bb4b60);  /* 39 */
+    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+    HH(d, a, b, c, x[0], S32, 0xeaa127fa);  /* 42 */
+    HH(c, d, a, b, x[3], S33, 0xd4ef3085);  /* 43 */
+    HH(b, c, d, a, x[6], S34, 0x4881d05);   /* 44 */
+    HH(a, b, c, d, x[9], S31, 0xd9d4d039);  /* 45 */
+    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+    HH(b, c, d, a, x[2], S34, 0xc4ac5665);  /* 48 */
+
+    /* Round 4 */
+    II(a, b, c, d, x[0], S41, 0xf4292244);  /* 49 */
+    II(d, a, b, c, x[7], S42, 0x432aff97);  /* 50 */
+    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+    II(b, c, d, a, x[5], S44, 0xfc93a039);  /* 52 */
+    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+    II(d, a, b, c, x[3], S42, 0x8f0ccc92);  /* 54 */
+    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+    II(b, c, d, a, x[1], S44, 0x85845dd1);  /* 56 */
+    II(a, b, c, d, x[8], S41, 0x6fa87e4f);  /* 57 */
+    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+    II(c, d, a, b, x[6], S43, 0xa3014314);  /* 59 */
+    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+    II(a, b, c, d, x[4], S41, 0xf7537e82);  /* 61 */
+    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+    II(c, d, a, b, x[2], S43, 0x2ad7d2bb);  /* 63 */
+    II(b, c, d, a, x[9], S44, 0xeb86d391);  /* 64 */
+
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+
+    /* Zeroize sensitive information. */
+    memset(x, 0, sizeof(x));
+}
+
+/* Encodes input (uint32_t) into output (uint8_t). Assumes len is
+  a multiple of 4.
+ */
+static void Encode(uint8_t* output, const uint32_t* input, unsigned int len) {
+    unsigned int i, j;
+
+    for (i = 0, j = 0; j < len; i++, j += 4) {
+        output[j] = (uint8_t)(input[i] & 0xff);
+        output[j + 1] = (uint8_t)((input[i] >> 8) & 0xff);
+        output[j + 2] = (uint8_t)((input[i] >> 16) & 0xff);
+        output[j + 3] = (uint8_t)((input[i] >> 24) & 0xff);
+    }
+}
+
+/* Decodes input (uint8_t) into output (uint32_t). Assumes len is
+  a multiple of 4.
+ */
+static void Decode(uint32_t* output, const uint8_t* input, unsigned int len) {
+    unsigned int i, j;
+
+    for (i = 0, j = 0; j < len; i++, j += 4) {
+        output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j + 1]) << 8) |
+                    (((uint32_t)input[j + 2]) << 16) | (((uint32_t)input[j + 3]) << 24);
+    }
 }

common/MD5.hpp

@@ -11,7 +11,7 @@ typedef struct {
 
 void MD5Init(MD5_CTX* context);
 
-void MD5Update(MD5_CTX* context, uint8_t* input, uint32_t inputLen);
+void MD5Update(MD5_CTX* context, const void* input, size_t inputLen);
 
 void MD5Final(uint8_t digest[16], MD5_CTX* context);
 

common/memory/CDataAllocator.cpp

@@ -11,9 +11,13 @@ CDataAllocator::CDataAllocator(uint32_t bytesPerData, uint32_t dataPerBlock) {
 }
 
 CDataAllocator::~CDataAllocator() {
+    if (this->m_blockList) {
+        Clear(__FILE__, __LINE__);
+    }
 }
 
 void CDataAllocator::Clear(const char* fileName, int32_t lineNumber) {
+#if defined(WHOA_BUILD_ASSERTIONS)
     if (this->m_dataUsed) {
         if (!fileName) {
             fileName == __FILE__;
@@ -21,7 +25,7 @@ void CDataAllocator::Clear(const char* fileName, int32_t lineNumber) {
         }
 
         SErrDisplayErrorFmt(
-            0x8510007E,
+            STORM_ERROR(0x7E),
             fileName,
             lineNumber,
             1,
@@ -34,6 +38,7 @@ void CDataAllocator::Clear(const char* fileName, int32_t lineNumber) {
             this->m_dataPerBlock,
             this->m_bytesPerData);
     }
+#endif
 
     while (this->m_blockList) {
         auto block = this->m_blockList;
@@ -63,7 +68,7 @@ CDataAllocator::Data* CDataAllocator::GetData(int32_t zero, const char* fileName
             lineNumber,
             0));
         Block* block = reinterpret_cast<Block*>(memory);
-        Data* data = reinterpret_cast<Data*>(memory + sizeof(Block*));
+        Data* data = reinterpret_cast<Data*>(memory + sizeof(Block));
 
         this->m_dataList = data;
         for (uint32_t i = 0; i < this->m_dataPerBlock - 1; ++i) {
@@ -71,7 +76,7 @@ CDataAllocator::Data* CDataAllocator::GetData(int32_t zero, const char* fileName
             data->m_next = reinterpret_cast<Data*>(next);
             data = data->m_next;
         }
-        data->m_next = 0;
+        data->m_next = nullptr;
         block->m_next = this->m_blockList;
         this->m_blockList = block;
     }

common/memory/CDataAllocator.hpp

@@ -2,6 +2,25 @@
 #define COMMON_MEMORY_C_DATA_ALLOCATOR_HPP
 
 #include <cstdint>
+#include <cstdlib>
+#include <new>
+#include <type_traits>
+
+#define ALLOCATOR_GET(allocator) allocator.GetData(0, __FILE__, __LINE__)
+#define ALLOCATOR_GET_ZERO(allocator) allocator.GetData(1, __FILE__, __LINE__)
+#define ALLOCATOR_NEW(allocator, T, ...) (new (allocator.GetData(0, __FILE__, __LINE__)) T(__VA_ARGS__))
+#define ALLOCATOR_NEW_ZERO(allocator, T, ...) (new (allocator.GetData(1, __FILE__, __LINE__)) T(__VA_ARGS__))
+
+#define ALLOCATOR_PUT(allocator, ptr) allocator.PutData(ptr, __FILE__, __LINE__)
+#define ALLOCATOR_DEL(allocator, ptr)                                                          \
+    do {                                                                                       \
+        if (ptr) {                                                                             \
+            using __data_object = std::remove_pointer<std::decay<decltype(ptr)>::type>::type;  \
+            (ptr)->~__data_object();                                                           \
+            allocator.PutData(ptr, __FILE__, __LINE__);                                        \
+        }                                                                                      \
+    } while (0)
+
 
 class CDataAllocator {
     public:
@@ -21,6 +40,11 @@ class CDataAllocator {
     Data* GetData(int32_t zero, const char* fileName, int32_t lineNumber);
     void PutData(void* data, const char* fileName, int32_t lineNumber);
 
+    inline uint32_t BytesPerData() const { return this->m_bytesPerData; }
+    inline uint32_t DataPerBlock() const { return this->m_dataPerBlock; }
+    inline uint32_t DataUsed() const { return this->m_dataUsed; }
+
+    private:
     // Member variables
     uint32_t m_bytesPerData = sizeof(Data);
     uint32_t m_dataPerBlock = 1;

test/DataAllocator.cpp

@@ -0,0 +1,75 @@
+#include "common/DataAllocator.hpp"
+#include "test/Test.hpp"
+
+struct TestContainer
+{
+    uint32_t value[10];
+};
+
+class TestClass
+{
+    public:
+    uint32_t* m_value = nullptr;
+
+    TestClass(uint32_t* value) {
+        this->m_value = value;
+        if (this->m_value) {
+            *this->m_value = 1;
+        }
+    }
+    ~TestClass() {
+        if (this->m_value) {
+            *this->m_value = 2;
+        }
+    }
+};
+
+TEST_CASE("CDataAllocator::CDataAllocator", "[dataallocator]") {
+    SECTION("constructs new data allocator") {
+        CDataAllocator allocator(sizeof(TestContainer), 2);
+        SUCCEED();
+    }
+}
+
+TEST_CASE("CDataAllocator::GetData", "[dataallocator]") {
+    SECTION("get allocated objects") {
+        CDataAllocator allocator(sizeof(TestContainer), 2);
+        auto container = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        auto container2 = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        auto container3 = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        REQUIRE(container);
+        REQUIRE(container2);
+        REQUIRE(container3);
+        REQUIRE(allocator.DataUsed() == 3);
+        allocator.PutData(container, __FILE__, __LINE__);
+        allocator.PutData(container2, __FILE__, __LINE__);
+        allocator.PutData(container3, __FILE__, __LINE__);
+    }
+}
+
+TEST_CASE("CDataAllocator::PutData", "[dataallocator]") {
+    SECTION("return allocated objects") {
+        CDataAllocator allocator(sizeof(TestContainer), 2);
+        auto container = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        auto container2 = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        auto container3 = (TestContainer*)allocator.GetData(0, __FILE__, __LINE__);
+        allocator.PutData(container, __FILE__, __LINE__);
+        allocator.PutData(container3, __FILE__, __LINE__);
+        REQUIRE(allocator.DataUsed() == 1);
+        allocator.PutData(container2, __FILE__, __LINE__);
+    }
+}
+
+TEST_CASE("CDataAllocator Class Handling", "[dataallocator]") {
+    SECTION("test class creation/destruction") {
+        CDataAllocator allocator(sizeof(TestClass), 2);
+        uint32_t value = 0;
+
+        auto testClass = ALLOCATOR_NEW(allocator, TestClass, &value);
+        REQUIRE(testClass->m_value == &value);
+        REQUIRE(value == 1);
+
+        ALLOCATOR_DEL(allocator, testClass);
+        REQUIRE(value == 2);
+    }
+}

test/MD5.cpp

@@ -0,0 +1,55 @@
+#include "common/MD5.hpp"
+#include "test/Test.hpp"
+
+#include <cstdio>
+#include <cstring>
+
+static bool test_hash(const char* data, const char* expected, int length = -1) {
+    const size_t digestLength = 16;
+
+    uint8_t digest[digestLength] = {};
+    char hex[(2 * digestLength) + 1];
+
+    if (length < 0) {
+        length = strlen(data);
+    }
+
+    /* calculate hash */
+    MD5_CTX context;
+    MD5Init(&context);
+    MD5Update(&context, data, static_cast<size_t>(length));
+    MD5Final(digest, &context);
+
+    /* copy hash to string */
+    for (size_t i = 0; i < digestLength; i++) {
+        sprintf(&(hex[i * 2]), "%02x", digest[i]);
+    }
+    hex[digestLength * 2] = '\0';
+
+    /* compare with result string */
+    return strcmp(hex, expected) == 0;
+}
+
+TEST_CASE("MD5", "[md5]") {
+    SECTION("zero data") {
+        REQUIRE(test_hash("", "d41d8cd98f00b204e9800998ecf8427e"));
+    }
+    SECTION("test 1") {
+        REQUIRE(test_hash("a", "0cc175b9c0f1b6a831c399e269772661"));
+    }
+    SECTION("test 2") {
+        REQUIRE(test_hash("abc", "900150983cd24fb0d6963f7d28e17f72"));
+    }
+    SECTION("test 3") {
+        REQUIRE(test_hash(
+            "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
+            "57edf4a22be3c955ac49da2e2107b67a"));
+    }
+    SECTION("binary array test") {
+        char data[8192];
+        for (size_t i = 0; i < sizeof(data); ++i) {
+            data[i] = static_cast<char>(i % 256);
+        }
+        test_hash(data, "6556112372898c69e1de0bf689d8db26", sizeof(data));
+    }
+}