Tests for the CRC and hash algorithms (#335)

* Update TEST_ASSERT to do nothing if condition is true

The TEST_ASSERT should not return if the condition is true, because:
- it prevents the usage of multiple TEST_ASSERT in a single test case,
- that behavior differs from how the assert in the standard library
works, and thus may give unexpected results.

Make the TEST_ASSERT to print an error message (with an formatted
optional user part) when it fails to make debugging easier.

* Fix some bugs in TestProvider, add unit tests

Use pointer-to-vector in TestProvider so writes can be tested, too.

* Add test EncodeDecode16, fix some encode16 bugs

The function mbedtls_mpi_write_string needs a bit longer buffer than the
resulting string actually will be.

Known bug: mbedtls_mpi_read_binary ingores initial null bytes

* Add test EncodeDecode64, fix some bugs

The functions mbedtls_base64_encode and mbedtls_base64_decode needs a
bit longer buffer than the resulting string actually will be.

* Remove check for empty data from TestProvider

It can be valid to get the hash of empty string.

* Add tests for CRC calculation

Two type of thests:
- compare the result of the CRC calculation to a known to be good
results,
- generate random data as message, calculate of it's CRC and append that
to the message, the CRC of this new data should be 0.

* Add test for hash algorithms

* Add includes in tests

* Remove the use of C++20 ranges

It seems that Apple Clang does not support range-based constrained
algorithms at this time.

* Replace encode16 implementation

To encode the zero bytes at the begining of the input vector, too.

plugins/libimhex/source/helpers/crypto.cpp

@@ -372,24 +372,29 @@ namespace hex::crypt {
 
 
     std::vector<u8> decode64(const std::vector<u8> &input) {
-        size_t outputSize = (3 * input.size()) / 4;
-        std::vector<u8> output(outputSize + 1, 0x00);
 
         size_t written = 0;
+        mbedtls_base64_decode(nullptr, 0, &written, reinterpret_cast<const unsigned char *>(input.data()), input.size());
+        std::vector<u8> output(written, 0x00);
         if (mbedtls_base64_decode(output.data(), output.size(), &written, reinterpret_cast<const unsigned char *>(input.data()), input.size()))
             return { };
 
+        output.resize(written);
+
         return output;
     }
 
     std::vector<u8> encode64(const std::vector<u8> &input) {
-        size_t outputSize = 4 * ((input.size() + 2) / 3);
-        std::vector<u8> output(outputSize + 1, 0x00);
 
         size_t written = 0;
+        mbedtls_base64_encode(nullptr, 0, &written, reinterpret_cast<const unsigned char *>(input.data()), input.size());
+
+        std::vector<u8> output(written, 0x00);
         if (mbedtls_base64_encode(output.data(), output.size(), &written, reinterpret_cast<const unsigned char *>(input.data()), input.size()))
             return { };
 
+        output.resize(written);
+
         return output;
     }
 
@@ -411,19 +416,16 @@ namespace hex::crypt {
     }
 
     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()))
+        if (input.empty())
             return { };
 
-        size_t written = 0;
-        if (mbedtls_mpi_write_string(&ctx, 16, output.data(), output.size(), &written))
-            return { };
+        std::string output(input.size() * 2, '\0');
+
+        for(int i = 0; i < input.size(); i++) {
+            output[2*i+0] = "0123456789ABCDEF"[input[i] / 16];
+            output[2*i+1] = "0123456789ABCDEF"[input[i] % 16];
+        }
 
         return output;
     }