From 28008a746a31abb7909dd86cb0cd413ac8943b0b Mon Sep 17 00:00:00 2001 From: jmpoep Date: Thu, 7 Dec 2023 16:51:07 +0800 Subject: first commit --- win_runtime.Tests/core_tests.cc | 419 ++++++++++++++++++++++++++++++ win_runtime.Tests/crypto_tests.cc | 170 ++++++++++++ win_runtime.Tests/lin_runtime.Tests.mak | 16 ++ win_runtime.Tests/lin_runtime32.Tests.mak | 3 + win_runtime.Tests/lin_runtime64.Tests.mak | 3 + win_runtime.Tests/mac_runtime.Tests.mak | 16 ++ win_runtime.Tests/mac_runtime32.Tests.mak | 3 + win_runtime.Tests/mac_runtime64.Tests.mak | 3 + win_runtime.Tests/main.cc | 26 ++ win_runtime.Tests/precompiled.cc | 1 + win_runtime.Tests/precompiled.h | 9 + 11 files changed, 669 insertions(+) create mode 100644 win_runtime.Tests/core_tests.cc create mode 100644 win_runtime.Tests/crypto_tests.cc create mode 100644 win_runtime.Tests/lin_runtime.Tests.mak create mode 100644 win_runtime.Tests/lin_runtime32.Tests.mak create mode 100644 win_runtime.Tests/lin_runtime64.Tests.mak create mode 100644 win_runtime.Tests/mac_runtime.Tests.mak create mode 100644 win_runtime.Tests/mac_runtime32.Tests.mak create mode 100644 win_runtime.Tests/mac_runtime64.Tests.mak create mode 100644 win_runtime.Tests/main.cc create mode 100644 win_runtime.Tests/precompiled.cc create mode 100644 win_runtime.Tests/precompiled.h (limited to 'win_runtime.Tests') diff --git a/win_runtime.Tests/core_tests.cc b/win_runtime.Tests/core_tests.cc new file mode 100644 index 0000000..fb5ec62 --- /dev/null +++ b/win_runtime.Tests/core_tests.cc @@ -0,0 +1,419 @@ +#include "../runtime/common.h" +#include "../runtime/objects.h" +#include "../runtime/crypto.h" +#include "../runtime/licensing_manager.h" +#include "../runtime/string_manager.h" +#include "../runtime/hwid.h" +#include "../runtime/hook_manager.h" +#include "../runtime/core.h" +#ifndef VMP_GNU +#include "../runtime/registry_manager.h" +#include "../runtime/file_manager.h" +#endif + +/** + * LicensingManagerTests + */ + +void Base64ToVector(const char *src, std::vector &dst) +{ + size_t src_len = strlen(src); + uint8_t *data = new uint8_t[src_len]; + size_t size = src_len; + Base64Decode(src, src_len, data, size); + dst.insert(dst.end(), &data[0], &data[size]); + delete [] data; +} + +class Data +{ +public: + void PushByte(uint8_t b){ m_vData.push_back(b); } + void PushDWord(uint32_t d) { PushBuff(&d, sizeof(d)); } + void PushQWord(uint64_t q) { PushBuff(&q, sizeof(q)); } + void PushWord(uint16_t w) { PushBuff(&w, sizeof(w)); } + void PushBuff(const void *pBuff, size_t nCount) + { + m_vData.insert(m_vData.end(), reinterpret_cast(pBuff), reinterpret_cast(pBuff) + nCount); + } + void InsertByte(size_t position, uint8_t value) + { + m_vData.insert(m_vData.begin() + position, value); + } + + uint32_t ReadDWord(size_t nPosition) const + { + return *reinterpret_cast(&m_vData[nPosition]); + } + + void WriteDWord(size_t nPosition, uint32_t dwValue) + { + *reinterpret_cast(&m_vData[nPosition]) = dwValue; + } + + size_t size() const { return m_vData.size(); } + void clear() { m_vData.clear(); } + bool empty() const { return m_vData.empty(); } + void resize(size_t size) { m_vData.resize(size); } + void resize(size_t size, uint8_t value) { m_vData.resize(size, value); } + uint8_t *data() const { return const_cast(m_vData.data()); } + uint8_t &operator[](size_t pos) { return m_vData[pos]; } +private: + std::vector m_vData; +}; + +TEST(LicensingManagerTests, ParseSerial) +{ + uint8_t key[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + + std::vector public_exp; + std::vector private_exp; + std::vector modulus; + Data data, data_crypted; + + Base64ToVector("AAEAAQ==", public_exp); + Base64ToVector("qA/5YwcsKJ63gVXf438aCxF0p45Mmew/CXj9TBg0i+biY7nJQqOFP4BhqiBY+4zrqh2iWrse3pZStEm7jqFh488xP2p7KMQHB+EPWx4ZYA6OFVl1SLG3gK7C0pqDmqQ289NUi5u56N+gNV+YA/mZ/dXBCbXv/HDgSuPEfkygz+CG20uRWoKbF+JKF6dHLbQHnn7l9nu1ht7+6NeL32UV8sEu8E508qF4cEni4RPu4cvnp98t8FF5e10JFpCE5wjkg47GQ+vUB5z+Z2AzuQdW8EHPvWwn+TNvcIh2tHEPWT39IeZ2X2KbfLCqdW4T2wwHHesiNwhqOwpNnxzHmDyaAQ==", private_exp); + Base64ToVector("rnK4CvdHf4d3DTtS7B7Fyu5kzT16BTWlecKTZcjw5Ji9BTLfhjgIxSyY6uqD2wNxd+qTzNY4PHvAf8lwxsLE9ir7sDhrDgzLp5PR5EW5nuZgHC+QKpXoaXH9Q73i6KcfDOUSHquQmRNtDHqyublT9/yv1pLuA+mCC+/gWZhgdAGZbwA0Ek61mGH1YFOUY+qLGyiJwGSMBXDWgEAm36wUHyTjZhN2003JuJwtpT8IWKiR5sy+vNQdtj+QEeyADbTFuYv5RHXUkUVvc0RUXecFLAQuE/1i1AJDAd5s4oDKUizZ10nCsHawSnHn4pgdQFzvhxnNTEVcjhcWMW0+/Zvfhw==", modulus); + + for (size_t i = 0; i < FIELD_COUNT; i++) { + data.PushDWord(0); + } + + data.WriteDWord(FIELD_PUBLIC_EXP_OFFSET * sizeof(uint32_t), static_cast(data.size())); + data.WriteDWord(FIELD_PUBLIC_EXP_SIZE * sizeof(uint32_t), static_cast(public_exp.size())); + data.PushBuff(public_exp.data(), public_exp.size()); + + data.WriteDWord(FIELD_MODULUS_OFFSET * sizeof(uint32_t), static_cast(data.size())); + data.WriteDWord(FIELD_MODULUS_SIZE * sizeof(uint32_t), static_cast(modulus.size())); + data.PushBuff(modulus.data(), modulus.size()); + + while (data.size() % 8) { + data.PushByte(0); + } + size_t crc_pos = data.size(); + data.WriteDWord(FIELD_CRC_OFFSET * sizeof(uint32_t), static_cast(crc_pos)); + + data_crypted.resize(crc_pos + 16); + CryptoContainer cont(data_crypted.data(), data_crypted.size(), key); + for (size_t i = 0; i < crc_pos; i++) { + cont.SetByte(i, data[i]); + } + + SHA1 hash; + hash.Input(data_crypted.data(), crc_pos); + const uint8_t *cp = hash.Result(); + for (size_t i = crc_pos; i < data_crypted.size(); i++) { + cont.SetByte(i, cp[i - crc_pos]); + } + + static GlobalData fake_loader_data; + loader_data = &fake_loader_data; + + LicensingManager licensing_manager(data_crypted.data(), (uint32_t)data_crypted.size(), key); + ASSERT_TRUE(licensing_manager.SetSerialNumber("FgeTRyB93RJeABJN83qKo7mTEvXHGHwYXmZ6pGY5o1X09bc8fmmebq1mryX5yHUWb6F+cauzsLxUyG+uTQBT9zC31EJPQqG9YgaRbOPPS9A7u1HXZA8x491ew0lDKJISy8TYNsjTJ2vB903jW+/A/UVc2+cgDCF3eqztkvYBEas6Y40Hj9A2ylJVYsYWq41RCZyDcXZtlbnuk8W2CDBAk+PGZeUPjEq/oasnTCeKdkO4NY2QVrFzvC/msT+7FWAaBNwe5OQYZLCH875qFVw0H2B9xcnVuIAHAYD00H0Hzk9sf/jAGx4l5CS8FQ4tshZfEllF6CcwVQuRdGz07gQWAQ==") == 0); + //ASSERT_TRUE(licensing_manager.SetSerialNumber("ZQQJD0w10nAco1VOACoCV5OSPFTUFHdYCzCKoERSdPpSCpCbL1qPkHTH5H+97W6k9amdncxcaOqXIhpe8ABCbWawJAk84S/IJAPcr1ki9faWOYfaLB2wxb3BRa2knvK++5Dr9EfrXhmk6VeL4MaJLTtFRSQSJVY6ZgFZnACHyEQYGRapk7vOVFlbQpKBaZ+s2eyipTeYpaF4gV15wWwx4uhBmCUMjJfMgMyx5jN6wRO/OzCG2db0keAHZ0136byI8QTqqgwV0lLjgSNC2+Idmp+uO5G7Q2YJetOQQjTwo3QAnEpzK2TSsgATfX50g17OXOb2sBfNMdPKdupKLtLlRg==") == 0); +} + +#ifndef VMP_GNU +#ifndef WIN_DRIVER +TEST(LicensingManagerTests, VmpLocalTime) +{ + SYSTEMTIME local_time; + uint32_t t1, t2, t3; + t1 = LicensingManager::GetCurrentDate(); + GetLocalTime(&local_time); + t2 = (local_time.wYear << 16) + (static_cast(local_time.wMonth) << 8) + static_cast(local_time.wDay); + t3 = LicensingManager::GetCurrentDate(); + ASSERT_TRUE((t1 == t2) || (t3 = t2)); +} +#endif +#endif + +/** + * StringManagerTests + */ + +class StringNode +{ + std::vector m_vString; + +public: + StringNode(const uint8_t *pBuff, size_t nCount, DWORD dwKey) + { + for (size_t i = 0; i < nCount; i++) + { + uint8_t x = static_cast(_rotl32(dwKey, static_cast(i)) + i); + m_vString.push_back(pBuff[i] ^ x); + } + } + + void WriteHeader(uint32_t id, Data *s, uint32_t offsetToData) + { + STRING_ENTRY sDataEntry = STRING_ENTRY(); + sDataEntry.Size = static_cast(m_vString.size()); + sDataEntry.Id = id; + sDataEntry.OffsetToData = offsetToData; + s->PushBuff(reinterpret_cast(&sDataEntry), sizeof(sDataEntry)); + } + + void WriteData(Data *s) + { + s->PushBuff(&m_vString[0], m_vString.size()); + } + + size_t size() const { return m_vString.size(); } +}; + +class StringInput +{ + std::vector m_vData; + std::vector m_vStrings; + uint32_t m_dwKey; + RC5Key m_bKey; + + void Compile() + { + Data s; + s.PushDWord((uint32_t)m_vStrings.size()); + uint32_t offsetToData = (uint32_t)(s.size() + m_vStrings.size() * sizeof(STRING_ENTRY)); + for (size_t i = 0; i < m_vStrings.size(); i++) + { + m_vStrings[i].WriteHeader((uint32_t)i, &s, offsetToData); + offsetToData += (uint32_t)m_vStrings[i].size(); + } + size_t nTreeSize = s.size(); + for (size_t i = 0; i < nTreeSize; i += sizeof(uint32_t)) { + s.WriteDWord(i, s.ReadDWord(i) ^ m_dwKey); + } + + for (size_t i = 0; i < m_vStrings.size(); i++) + m_vStrings[i].WriteData(&s); + + m_vData.insert(m_vData.end(), s.data(), s.data() + s.size()); + } + + void PushBuff(const uint8_t *pBuff, size_t nCount) + { + StringNode s(pBuff, nCount, m_dwKey); + m_vStrings.push_back(s); + + m_vData.clear(); + } + +public: + StringInput(const uint8_t *pKey) + : m_dwKey(0) + { + memset(&m_bKey, 0, sizeof(m_bKey)); + if (pKey) + { + memcpy(&m_bKey.Value[0], pKey, sizeof(m_bKey.Value)); + memcpy(&m_dwKey, pKey, sizeof(m_dwKey)); + } + } + + void Add(const wchar_t *lpString) + { + PushBuff((uint8_t *)lpString, (wcslen(lpString) + 1)*sizeof(wchar_t)); + } + + void Add(const char *lpString) + { + PushBuff((uint8_t *)lpString, strlen(lpString) + 1); + } + + StringNode &GetItem(size_t nIndex) { return m_vStrings[nIndex]; } + + operator const uint8_t *() + { + if (m_vData.empty()) Compile(); + return &m_vData[0]; + } + + size_t size() + { + return m_vData.size(); + } +}; + +TEST(StringManagerTests, InitDone) +{ + uint8_t key[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + uint8_t data[] = {0, 0, 0, 0}; + + ASSERT_NO_THROW(StringManager(data, 0, key)); +} + +TEST(StringManagerTests, BuildAGoodTree) +{ + StringInput string_input(NULL); + wchar_t s1[] = L"String1"; + char s2[] = "String2"; + string_input.Add(s1); + string_input.Add(s2); + + EXPECT_EQ(sizeof(s1), string_input.GetItem(0).size()); + EXPECT_EQ(sizeof(s2), string_input.GetItem(1).size()); +} + +TEST(StringManagerTests, DecryptStrings) +{ + uint8_t key[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + + StringInput string_input(key); + wchar_t s1[] = L"String1"; + char s2[] = "String2"; + string_input.Add(s1); + string_input.Add(s2); + const uint8_t *p = string_input; + + StringManager string_manager(p, (HMODULE)p, key); + + const void *p3 = string_manager.DecryptString(p + 2); + EXPECT_EQ((const void *)(p + 2), p3); + + const void *p2 = string_manager.DecryptString(p + 1); + EXPECT_STREQ((char *)p2, s2); + + const void *p1 = string_manager.DecryptString(p + 0); // 1st decrypt + EXPECT_STREQ((wchar_t *)p1, s1); + + EXPECT_NE(p1, p2) << "different strings cannot live at the same address"; + EXPECT_EQ(p1, string_manager.DecryptString(p + 0)) << "should not allocate the same string twice"; // 2nd decrypt + + EXPECT_TRUE(string_manager.FreeString(p1)); // rollback 1st decrypt, string alive + EXPECT_STREQ((wchar_t *)p1, s1); + EXPECT_TRUE(string_manager.FreeString(p1)); // rollback 2nd decrypt, string dead + EXPECT_STRNE((wchar_t *)p1, s1); // maybe dangerous (don't know about conditions), delete this line if crashed here + EXPECT_FALSE(string_manager.FreeString(p1)); // there were no 3rd decrypt to rollback + + EXPECT_FALSE(string_manager.FreeString(reinterpret_cast(0x12))); + EXPECT_FALSE(string_manager.FreeString(NULL)); + EXPECT_FALSE(string_manager.FreeString(reinterpret_cast("hello, world!"))); +} + +/** + * HardwareIDTests + */ + +TEST(HardwareIDTests, GetCurrentHWID) +{ + char buff[1024]; + HardwareID hardware_id; + ASSERT_TRUE(hardware_id.GetCurrent(buff, sizeof(buff)) != 0); +} + +TEST(HardwareIDTests, Compare) +{ + uint32_t cur[100], test[100]; + HardwareID hardware_id; + size_t size = 0; + ASSERT_NO_THROW(size = hardware_id.Copy(reinterpret_cast(cur), sizeof(cur)) / sizeof(uint32_t)); + ASSERT_GT(size, 1u); + + // change one id + for (size_t i = 0; i < size; i++) { + test[i] = cur[i]; + switch (test[i] & 3) { + case 3: + test[i] ^= 4; + break; + } + } + EXPECT_TRUE(hardware_id.IsCorrect(reinterpret_cast(test), size * sizeof(uint32_t))); + + // change two ids + for (size_t i = 0; i < size; i++) { + test[i] = cur[i]; + switch (test[i] & 3) { + case 2: + case 3: + test[i] ^= 4; + break; + } + } + EXPECT_FALSE(hardware_id.IsCorrect(reinterpret_cast(test), size * sizeof(uint32_t))); + + // change three ids + for (size_t i = 0; i < size; i++) { + test[i] = cur[i]; + switch (test[i] & 3) { + case 1: + case 2: + case 3: + test[i] ^= 4; + break; + } + } + EXPECT_FALSE(hardware_id.IsCorrect(reinterpret_cast(test), size * sizeof(uint32_t))); + + // change cpu`s id + for (size_t i = 0; i < size; i++) { + test[i] = cur[i]; + switch (test[i] & 3) { + case 0: + test[i] ^= 4; + break; + } + } + EXPECT_FALSE(hardware_id.IsCorrect(reinterpret_cast(test), size * sizeof(uint32_t))); +} + +#ifndef VMP_GNU +/** + * RegistryManagerTests + */ +#include "../runtime/registry_manager.h" + +TEST(RegistryManagerTests, UnicodeString) +{ + UnicodeString str(L"123"); + ASSERT_EQ(str.size(), 3); + ASSERT_NO_THROW(str = str + L'4'); + ASSERT_EQ(str.size(), 4); + ASSERT_NO_THROW(str = str + L"56"); + ASSERT_EQ(str.size(), 6); + ASSERT_EQ(wcscmp(L"123456", str.c_str()), 0); +} + +TEST(RegistryManagerTests, RegistryTree) +{ + RegistryKey root; + RegistryKey *key; + RegistryValue *value; + + EXPECT_TRUE(root.AddKey(L"\\registry\\machine\\classes", true, NULL) != NULL); + EXPECT_TRUE(root.GetKey(L"\\registry\\machine") != NULL); + EXPECT_TRUE(root.GetKey(L"\\registry\\123") == NULL); + EXPECT_TRUE(root.AddKey(L"\\registry\\machine\\objects", false, NULL) != NULL); + EXPECT_TRUE(root.AddKey(L"\\registry\\\\machine", true, NULL) == NULL); + ASSERT_NO_THROW(key = root.GetKey(L"\\registry\\machine")); + EXPECT_TRUE(key->is_real()); + EXPECT_EQ(key->keys_size(), 2); + EXPECT_TRUE(key->key(0)->is_real()); + EXPECT_FALSE(key->key(1)->is_real()); + ASSERT_NO_THROW(key->SetValue(L"Value", REG_SZ, L"123456", 14)); + EXPECT_EQ(key->values_size(), 1); + EXPECT_FALSE(key->GetValue(L"")); + ASSERT_NO_THROW(value = key->GetValue(L"Value")); + EXPECT_TRUE(value != NULL); + EXPECT_EQ(value->size(), 14); + EXPECT_EQ(value->type(), REG_SZ); +} + +/** +* FileManagerTests +*/ + +TEST(FileManagerTests, Path) +{ + Path path(L"1\\2\\3\\4"); + UnicodeString str = path.Combine(L"1.txt"); + ASSERT_EQ(wcscmp(L"1\\2\\3\\4\\1.txt", str.c_str()), 0); + str = path.Combine(L"..\\1.txt"); + ASSERT_EQ(wcscmp(L"1\\2\\3\\1.txt", str.c_str()), 0); + str = path.Combine(L"..\\5\\..\\6\\1.txt"); + ASSERT_EQ(wcscmp(L"1\\2\\3\\6\\1.txt", str.c_str()), 0); +} + +#endif diff --git a/win_runtime.Tests/crypto_tests.cc b/win_runtime.Tests/crypto_tests.cc new file mode 100644 index 0000000..5ddc237 --- /dev/null +++ b/win_runtime.Tests/crypto_tests.cc @@ -0,0 +1,170 @@ +#include "../runtime/common.h" +#include "../runtime/crypto.h" + +TEST(CryptoContainerTests, GetRange) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(1, vKey); + for (size_t i = 1; i < 100; i++) + { + EXPECT_EQ(255, cont.GetByte(i)); + EXPECT_EQ(255, cont.GetByte(-1*i)); + } +} + +TEST(CryptoContainerTests, GetSetByte) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(1, vKey); + ASSERT_NO_THROW(cont.SetByte(0, 123)); + EXPECT_EQ(123, cont.GetByte(0)); +} + +TEST(CryptoContainerTests, GetSetNBytes) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + const int N = 256; + CryptoContainer cont(N, vKey); + for (int i = 0; i < N; i++) + ASSERT_NO_THROW(cont.SetByte(i, i)); + for (int i = 0; i < N; i++) + EXPECT_EQ(i, cont.GetByte(i)); +} + +TEST(CryptoContainerTests, CryptedBuffer) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + + // crypt buffer + uint32_t vData[256]; + { + CryptoContainer cont((uint8_t *)vData, sizeof(vData), vKey); + for (size_t i = 0; i < _countof(vData); i++) cont.SetDWord(i * sizeof(uint32_t), static_cast(123456 * i)); + } + + // read data + { + CryptoContainer cont((uint8_t *)vData, sizeof(vData), vKey); + for (size_t i = 0; i < _countof(vData); i++) + { + EXPECT_EQ(static_cast(123456 * i), cont.GetDWord(i * sizeof(uint32_t))); + + // check there is no uint32_t(0) and uint32(123456) inside the buffer + EXPECT_NE((uint32_t)0, vData[i]); + EXPECT_NE((uint32_t)123456, vData[i]); + } + } + + +} + +TEST(CryptoContainerTests, GetSetWordInSingleBlock) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(8, vKey); + ASSERT_NO_THROW(cont.SetWord(3, 12345)); + EXPECT_EQ(12345, cont.GetWord(3)); +} + +TEST(CryptoContainerTests, GetSetWordInTwoBlocks) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(16, vKey); + ASSERT_NO_THROW(cont.SetWord(7, 0x1234)); + EXPECT_EQ(0x1234, cont.GetWord(7)); +} + +TEST(CryptoContainerTests, GetSetWordOutOfRange) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(8, vKey); + ASSERT_NO_THROW(cont.SetByte(7, 1)); + EXPECT_EQ(65535, cont.GetWord(7)); + + ASSERT_NO_THROW(cont.SetByte(7, 0)); + ASSERT_NO_THROW(cont.SetWord(7, 12345)); + EXPECT_EQ(0, cont.GetByte(7)); +} + +TEST(CryptoContainerTests, GetSetDWordInSingleBlock) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(8, vKey); + ASSERT_NO_THROW(cont.SetDWord(3, 0x12345678)); + EXPECT_EQ((uint32_t)0x12345678, cont.GetDWord(3)); +} + +TEST(CryptoContainerTests, GetSetDWordInTwoBlocks) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(16, vKey); + uint32_t vValues[4] = {0x12345678, 0xA0B0C0D0, 0x01020304, 0x1A2B3C4D}; + for (size_t i = 0; i < 4; i++) + { + ASSERT_NO_THROW(cont.SetDWord(5 + i, vValues[i])); + EXPECT_EQ(vValues[i], cont.GetDWord(5 + i)); + } +} + +TEST(CryptoContainerTests, GetSetDWordOutOfRange) +{ + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(8, vKey); + for (size_t i = 5; i < 8; i++) ASSERT_NO_THROW(cont.SetByte(i, 1)); + for (size_t i = 5; i < 8; i++) EXPECT_EQ(0xFFFFFFFF, cont.GetDWord(i)); + + for (size_t i = 5; i < 8; i++) ASSERT_NO_THROW(cont.SetByte(i, 0)); + for (size_t i = 5; i < 8; i++) ASSERT_NO_THROW(cont.SetDWord(i, 0x12345678)); + for (size_t i = 5; i < 8; i++) EXPECT_EQ(0, cont.GetByte(i)); +} + +TEST(CryptoContainerTests, SHA1) +{ + std::vector vData; + srand((unsigned int)__rdtsc()); + for (size_t i = 0; i < 1111; i++) vData.push_back(rand() % 255); + + SHA1 hash1, hash2; + + hash1.Input(&vData[0], vData.size()); + + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(vData.size(), vKey); + for (size_t i = 0; i < vData.size(); i++) cont.SetByte(i, vData[i]); + hash2.Input(cont, 0, cont.size()); + + const uint8_t *p1 = hash1.Result(); + const uint8_t *p2 = hash2.Result(); + for (int i = 0; i < 20; i++) ASSERT_EQ(p1[i], p2[i]); +} + +TEST(CryptoContainerTests, SHA1_CRC) +{ + std::vector vData; + srand((unsigned int)__rdtsc()); + for (size_t i = 0; i < 1111; i++) vData.push_back(rand() % 255); + + SHA1 hash1, hash2; + + hash1.Input(&vData[0], vData.size() - 4); + memcpy(&vData[vData.size() - 4], hash1.Result(), 4); + + uint8_t vKey[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + CryptoContainer cont(vData.size(), vKey); + for (size_t i = 0; i < vData.size(); i++) cont.SetByte(i, vData[i]); + hash2.Input(cont, 0, cont.size() - 4); + EXPECT_TRUE(hash1 == hash2); +} + +TEST(CryptoContainerTests, GetByte) +{ + uint8_t vKey[] = {1, 2, 3, 4, 5, 6, 7, 8}; + const size_t nMax = 20; + CryptoContainer cont(nMax, vKey); + for (size_t i = 0; i < nMax; i++) cont.SetByte(i, static_cast(i)); + + for(size_t i = 0; i < nMax; i++) + { + EXPECT_EQ(cont.GetByte(i), i); + } +} diff --git a/win_runtime.Tests/lin_runtime.Tests.mak b/win_runtime.Tests/lin_runtime.Tests.mak new file mode 100644 index 0000000..1834c5b --- /dev/null +++ b/win_runtime.Tests/lin_runtime.Tests.mak @@ -0,0 +1,16 @@ +SOURCES := ../runtime/core.cc ../runtime/crypto.cc ../runtime/loader.cc ../runtime/licensing_manager.cc ../runtime/string_manager.cc ../runtime/hwid.cc ../runtime/objects.cc ../runtime/utils.cc core_tests.cc crypto_tests.cc main.cc ../third-party/lzma/LzmaDecode.cc + +PROJECT := runtime.Tests +TARGET := $(PROJECT) +BIN_DIR := ../bin/$(ARCH_DIR)/Release +TMP_DIR := ../tmp/lin/$(PROJECT)/$(ARCH_DIR)/$(PROJECT) +PCH_DIR := $(TMP_DIR)/$(PROJECT).gch +DEFINES := -D TIXML_USE_STL -D _CONSOLE +LFLAGS := +LIBS = $(SDK_LIBS) -lpthread -L../bin -lVMProtectSDK$(ARCH_DIR) ~/curl-7.35.0-$(ARCH_DIR)/lib/libcurl.so -ldl +OBJCOMP := ../bin/$(ARCH_DIR)/Release/gtests.a +DYLIBS := +INCFLAGS := -I ../third-party/gmock/include/ -I ../third-party/gtest/include/ -I ../third-party/gmock/ -I ../third-party/gtest/ -I ~/curl-7.35.0-$(ARCH_DIR)/include + +include ../lin_common.mak +include ../gnu_simple.mak diff --git a/win_runtime.Tests/lin_runtime32.Tests.mak b/win_runtime.Tests/lin_runtime32.Tests.mak new file mode 100644 index 0000000..06e9469 --- /dev/null +++ b/win_runtime.Tests/lin_runtime32.Tests.mak @@ -0,0 +1,3 @@ +ARCH := i386-linux-gnu +ARCH_DIR := 32 +include lin_runtime.Tests.mak diff --git a/win_runtime.Tests/lin_runtime64.Tests.mak b/win_runtime.Tests/lin_runtime64.Tests.mak new file mode 100644 index 0000000..a166ca4 --- /dev/null +++ b/win_runtime.Tests/lin_runtime64.Tests.mak @@ -0,0 +1,3 @@ +ARCH := x86_64-linux-gnu +ARCH_DIR := 64 +include lin_runtime.Tests.mak diff --git a/win_runtime.Tests/mac_runtime.Tests.mak b/win_runtime.Tests/mac_runtime.Tests.mak new file mode 100644 index 0000000..8fa1aa5 --- /dev/null +++ b/win_runtime.Tests/mac_runtime.Tests.mak @@ -0,0 +1,16 @@ +SOURCES := ../runtime/core.cc ../runtime/crypto.cc ../runtime/loader.cc ../runtime/licensing_manager.cc ../runtime/string_manager.cc ../runtime/hwid.cc ../runtime/objects.cc ../runtime/utils.cc core_tests.cc crypto_tests.cc main.cc ../third-party/lzma/LzmaDecode.cc + +PROJECT := runtime.Tests +TARGET := $(PROJECT) +BIN_DIR := ../bin/$(ARCH_DIR)/Release +TMP_DIR := ../tmp/mac/$(PROJECT)/$(ARCH_DIR)/$(PROJECT) +PCH_DIR := $(TMP_DIR)/$(PROJECT).gch +DEFINES := -D TIXML_USE_STL -D _CONSOLE +LFLAGS := +LIBS = $(SDK_LIBS) -framework DiskArbitration +OBJCOMP := ../bin/$(ARCH_DIR)/Release/gtests.a +DYLIBS := ../bin/libVMProtectSDK.dylib +INCFLAGS := -I ../third-party/gmock/include/ -I ../third-party/gtest/include/ -I ../third-party/gmock/ -I ../third-party/gtest/ + +include ../mac_common.mak +include ../gnu_simple.mak diff --git a/win_runtime.Tests/mac_runtime32.Tests.mak b/win_runtime.Tests/mac_runtime32.Tests.mak new file mode 100644 index 0000000..1cba09b --- /dev/null +++ b/win_runtime.Tests/mac_runtime32.Tests.mak @@ -0,0 +1,3 @@ +ARCH := i386 +ARCH_DIR := 32 +include mac_runtime.Tests.mak diff --git a/win_runtime.Tests/mac_runtime64.Tests.mak b/win_runtime.Tests/mac_runtime64.Tests.mak new file mode 100644 index 0000000..5efc868 --- /dev/null +++ b/win_runtime.Tests/mac_runtime64.Tests.mak @@ -0,0 +1,3 @@ +ARCH := x86_64 +ARCH_DIR := 64 +include mac_runtime.Tests.mak diff --git a/win_runtime.Tests/main.cc b/win_runtime.Tests/main.cc new file mode 100644 index 0000000..26100b0 --- /dev/null +++ b/win_runtime.Tests/main.cc @@ -0,0 +1,26 @@ +#ifdef WIN +#include /* Heap verifying */ +#elif MACOSX +#define __ICONS__ +#include +#endif + + +int main(int argc, char **argv) +{ +#ifdef WIN + /* Set up heap verifying. */ + _CrtSetDbgFlag(_CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ) | _CRTDBG_LEAK_CHECK_DF); +#elif MACOSX + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; +#endif + + testing::InitGoogleTest(&argc, argv); + int rc = RUN_ALL_TESTS(); + +#ifdef MACOSX + [pool release]; +#endif + + return rc; +} diff --git a/win_runtime.Tests/precompiled.cc b/win_runtime.Tests/precompiled.cc new file mode 100644 index 0000000..5f656a4 --- /dev/null +++ b/win_runtime.Tests/precompiled.cc @@ -0,0 +1 @@ +#include "precompiled.h" diff --git a/win_runtime.Tests/precompiled.h b/win_runtime.Tests/precompiled.h new file mode 100644 index 0000000..6fed2cf --- /dev/null +++ b/win_runtime.Tests/precompiled.h @@ -0,0 +1,9 @@ +#pragma once +#ifndef WRUT_PCH +#define WRUT_PCH + +#include "../runtime/precompiled.h" + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#endif //WRUT_PCH \ No newline at end of file -- cgit v1.2.3