views: Add simple pattern, library and magics store

plugins/libimhex/include/hex/helpers/crypto.hpp

@@ -24,8 +24,17 @@ namespace hex::crypt {
     std::array<u8, 48> sha384(prv::Provider* &data, u64 offset, size_t size);
     std::array<u8, 64> sha512(prv::Provider* &data, u64 offset, size_t size);
 
+    std::array<u8, 16> md5(const std::vector<u8> &data);
+    std::array<u8, 20> sha1(const std::vector<u8> &data);
+    std::array<u8, 28> sha224(const std::vector<u8> &data);
+    std::array<u8, 32> sha256(const std::vector<u8> &data);
+    std::array<u8, 48> sha384(const std::vector<u8> &data);
+    std::array<u8, 64> sha512(const std::vector<u8> &data);
+
     std::vector<u8> decode64(const std::vector<u8> &input);
     std::vector<u8> encode64(const std::vector<u8> &input);
+    std::vector<u8> decode16(const std::string &input);
+    std::string encode16(const std::vector<u8> &input);
 
     enum class AESMode : u8 {
         ECB     = 0,

plugins/libimhex/include/hex/helpers/net.hpp

@@ -21,6 +21,11 @@ namespace hex {
         T body;
     };
 
+    template<>
+    struct Response<void> {
+        s32 code;
+    };
+
     class Net {
     public:
         Net();
@@ -30,6 +35,7 @@ namespace hex {
         std::future<Response<nlohmann::json>> getJson(const std::string &url);
 
         std::future<Response<std::string>> uploadFile(const std::string &url, const std::filesystem::path &filePath);
+        std::future<Response<void>> downloadFile(const std::string &url, const std::filesystem::path &filePath);
 
         [[nodiscard]]
         std::string encode(const std::string &input) {

plugins/libimhex/source/helpers/crypto.cpp

@@ -1,9 +1,11 @@
 #include <hex/helpers/crypto.hpp>
 
 #include <hex/providers/provider.hpp>
+#include <hex/helpers/utils.hpp>
 
 #include <mbedtls/version.h>
 #include <mbedtls/base64.h>
+#include <mbedtls/bignum.h>
 #include <mbedtls/md5.h>
 #include <mbedtls/sha1.h>
 #include <mbedtls/sha256.h>
@@ -131,6 +133,21 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 16> md5(const std::vector<u8> &data) {
+        std::array<u8, 16> result = { 0 };
+
+        mbedtls_md5_context ctx;
+        mbedtls_md5_init(&ctx);
+
+        mbedtls_md5_starts(&ctx);
+        mbedtls_md5_update(&ctx, data.data(), data.size());
+        mbedtls_md5_finish(&ctx, result.data());
+
+        mbedtls_md5_free(&ctx);
+
+        return result;
+    }
+
     std::array<u8, 20> sha1(prv::Provider* &data, u64 offset, size_t size) {
         std::array<u8, 20> result = { 0 };
 
@@ -153,6 +170,21 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 20> sha1(const std::vector<u8> &data) {
+        std::array<u8, 20> result = { 0 };
+
+        mbedtls_sha1_context ctx;
+        mbedtls_sha1_init(&ctx);
+
+        mbedtls_sha1_starts(&ctx);
+        mbedtls_sha1_update(&ctx, data.data(), data.size());
+        mbedtls_sha1_finish(&ctx, result.data());
+
+        mbedtls_sha1_free(&ctx);
+
+        return result;
+    }
+
     std::array<u8, 28> sha224(prv::Provider* &data, u64 offset, size_t size) {
         std::array<u8, 28> result = { 0 };
 
@@ -175,6 +207,21 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 28> sha224(const std::vector<u8> &data) {
+        std::array<u8, 28> result = { 0 };
+
+        mbedtls_sha256_context ctx;
+        mbedtls_sha256_init(&ctx);
+
+        mbedtls_sha256_starts(&ctx, true);
+        mbedtls_sha256_update(&ctx, data.data(), data.size());
+        mbedtls_sha256_finish(&ctx, result.data());
+
+        mbedtls_sha256_free(&ctx);
+
+        return result;
+    }
+
     std::array<u8, 32> sha256(prv::Provider* &data, u64 offset, size_t size) {
         std::array<u8, 32> result = { 0 };
 
@@ -197,6 +244,21 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 32> sha256(const std::vector<u8> &data) {
+        std::array<u8, 32> result = { 0 };
+
+        mbedtls_sha256_context ctx;
+        mbedtls_sha256_init(&ctx);
+
+        mbedtls_sha256_starts(&ctx, false);
+        mbedtls_sha256_update(&ctx, data.data(), data.size());
+        mbedtls_sha256_finish(&ctx, result.data());
+
+        mbedtls_sha256_free(&ctx);
+
+        return result;
+    }
+
     std::array<u8, 48> sha384(prv::Provider* &data, u64 offset, size_t size) {
         std::array<u8, 48> result = { 0 };
 
@@ -219,6 +281,21 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 48> sha384(const std::vector<u8> &data) {
+        std::array<u8, 48> result = { 0 };
+
+        mbedtls_sha512_context ctx;
+        mbedtls_sha512_init(&ctx);
+
+        mbedtls_sha512_starts(&ctx, true);
+        mbedtls_sha512_update(&ctx, data.data(), data.size());
+        mbedtls_sha512_finish(&ctx, result.data());
+
+        mbedtls_sha512_free(&ctx);
+
+        return result;
+    }
+
     std::array<u8, 64> sha512(prv::Provider* &data, u64 offset, size_t size) {
         std::array<u8, 64> result = { 0 };
 
@@ -241,6 +318,22 @@ namespace hex::crypt {
         return result;
     }
 
+    std::array<u8, 64> sha512(const std::vector<u8> &data) {
+        std::array<u8, 64> result = { 0 };
+
+        mbedtls_sha512_context ctx;
+        mbedtls_sha512_init(&ctx);
+
+        mbedtls_sha512_starts(&ctx, false);
+        mbedtls_sha512_update(&ctx, data.data(), data.size());
+        mbedtls_sha512_finish(&ctx, result.data());
+
+        mbedtls_sha512_free(&ctx);
+
+        return result;
+    }
+
+
     std::vector<u8> decode64(const std::vector<u8> &input) {
         size_t outputSize = (3 * input.size()) / 4;
         std::vector<u8> output(outputSize + 1, 0x00);
@@ -263,6 +356,41 @@ namespace hex::crypt {
         return output;
     }
 
+    std::vector<u8> decode16(const std::string &input) {
+        std::vector<u8> output(input.length() / 2, 0x00);
+
+        mbedtls_mpi ctx;
+        mbedtls_mpi_init(&ctx);
+
+        ON_SCOPE_EXIT { mbedtls_mpi_free(&ctx); };
+
+        if (mbedtls_mpi_read_string(&ctx, 16, input.c_str()))
+            return { };
+
+        if (mbedtls_mpi_write_binary(&ctx, output.data(), output.size()))
+            return { };
+
+        return output;
+    }
+
+    std::string encode16(const std::vector<u8> &input) {
+        std::string output(input.size() * 2 + 1, 0x00);
+
+        mbedtls_mpi ctx;
+        mbedtls_mpi_init(&ctx);
+
+        ON_SCOPE_EXIT { mbedtls_mpi_free(&ctx); };
+
+        if (mbedtls_mpi_read_binary(&ctx, input.data(), input.size()))
+            return { };
+
+        size_t written = 0;
+        if (mbedtls_mpi_write_string(&ctx, 16, output.data(), output.size(), &written))
+            return { };
+
+        return output;
+    }
+
     static std::vector<u8> aes(mbedtls_cipher_type_t type, mbedtls_operation_t operation, const std::vector<u8> &key, std::array<u8, 8> nonce, std::array<u8, 8> iv, const std::vector<u8> &input) {
         std::vector<u8> output;
 

plugins/libimhex/source/helpers/net.cpp

@@ -42,6 +42,12 @@ namespace hex {
         return fread(contents, size, nmemb, file);
     }
 
+    static size_t writeToFile(void *contents, size_t size, size_t nmemb, void *userdata) {
+        FILE *file = static_cast<FILE*>(userdata);
+
+        return fwrite(contents, size, nmemb, file);
+    }
+
     static CURLcode sslCtxFunction(CURL *ctx, void *sslctx, void *userdata) {
         auto* cfg = static_cast<mbedtls_ssl_config*>(sslctx);
 
@@ -203,4 +209,28 @@ namespace hex {
         });
     }
 
+    std::future<Response<void>> Net::downloadFile(const std::string &url, const std::filesystem::path &filePath) {
+        this->m_transmissionActive.lock();
+
+        return std::async(std::launch::async, [=, this]{
+            std::string response;
+
+            ON_SCOPE_EXIT { this->m_transmissionActive.unlock(); };
+
+            FILE *file = fopen(filePath.string().c_str(), "wb");
+            if (file == nullptr)
+                return Response<void> { 400 };
+
+            ON_SCOPE_EXIT { fclose(file); };
+
+            setCommonSettings(response, url, {});
+            curl_easy_setopt(this->m_ctx, CURLOPT_CUSTOMREQUEST, "GET");
+            curl_easy_setopt(this->m_ctx, CURLOPT_WRITEFUNCTION, writeToFile);
+            curl_easy_setopt(this->m_ctx, CURLOPT_WRITEDATA, file);
+            auto responseCode = execute();
+
+            return Response<void> { responseCode.value_or(0) };
+        });
+    }
+
 }