YACA: Digest ASCII test vectors

[platform/core/test/security-tests.git] / src / yaca / yaca-test-digest.cpp

diff --git a/src/yaca/yaca-test-digest.cpp b/src/yaca/yaca-test-digest.cpp
index ff7e6a9..3856977 100644 (file)
--- a/src/yaca/yaca-test-digest.cpp
+++ b/src/yaca/yaca-test-digest.cpp
@@ -21,21 +21,150 @@
  * @author Dariusz Michaluk (d.michaluk@samsumg.com)
  */
 
+#include <map>
+#include <vector>
+
 #include "dpl/test/test_runner.h"
+#include "yaca-test-common.h"
+#include "yaca-test-vector.h"
 
 #include <yaca_digest.h>
 
+using namespace std;
+
+namespace {
+const vector<char> DATA = random_buffer(1024);
+
+void digest_length_test(yaca_digest_algorithm_e algo, size_t expected_bit_len)
+{
+    auto ctx_ptr = digest_init(algo);
+    size_t output_len;
+
+    YACA_SUCCESS(yaca_context_get_output_length(ctx_ptr.get(), 0, &output_len));
+
+    YACA_ASSERT_MSG(output_len == expected_bit_len / 8,
+                    "Digest " << digest2str(algo) << " produces " << output_len * 8 <<
+                    " bit digest. Expected " << expected_bit_len << " bits.");
+}
+
+} // anonymous namespace
 
 RUNNER_TEST_GROUP_INIT(T2000_YACA_DIGEST);
 
-RUNNER_TEST(T2001_yaca_digest_init)
+RUNNER_TEST(T2010_yaca_digest_initialize_invalid_param, YacaTest)
 {
+    YACA_INVALID_PARAM(yaca_digest_initialize(nullptr, YACA_DIGEST_MD5));
+
+    yaca_context_h ctx;
+    YACA_INVALID_PARAM(yaca_digest_initialize(
+            &ctx,
+            static_cast<yaca_digest_algorithm_e>(YACA_DIGEST_MD5-1)));
+
+    YACA_INVALID_PARAM(yaca_digest_initialize(
+            &ctx,
+            static_cast<yaca_digest_algorithm_e>(YACA_DIGEST_SHA512+1)));
 }
 
-RUNNER_TEST(T2002_yaca_digest_update)
+RUNNER_TEST(T2020_yaca_digest_update_invalid_param, YacaTest)
 {
+    YACA_INVALID_PARAM(yaca_digest_update(YACA_CONTEXT_NULL, DATA.data(), DATA.size()));
+
+    {
+        auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+        auto ctx_ptr = hmac_init(YACA_DIGEST_MD5, key_ptr);
+
+        YACA_INVALID_PARAM(yaca_digest_update(ctx_ptr.get(), DATA.data(), DATA.size()));
+    }
+
+    auto ctx_ptr = digest_init(YACA_DIGEST_MD5);
+
+    YACA_INVALID_PARAM(yaca_digest_update(ctx_ptr.get(), NULL, 42));
+    YACA_INVALID_PARAM(yaca_digest_update(ctx_ptr.get(), DATA.data(), 0));
 }
 
-RUNNER_TEST(T2003_yaca_digest_final)
+RUNNER_TEST(T2030_yaca_digest_finalize_invalid_param, YacaTest)
 {
+    char output[256];
+    size_t out_len;
+    YACA_INVALID_PARAM(yaca_digest_finalize(YACA_CONTEXT_NULL, output, &out_len));
+
+    {
+        auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+        auto ctx_ptr = hmac_init(YACA_DIGEST_MD5, key_ptr);
+
+        YACA_INVALID_PARAM(yaca_digest_finalize(ctx_ptr.get(), output, &out_len));
+    }
+
+    auto ctx_ptr = digest_init(YACA_DIGEST_MD5);
+    YACA_SUCCESS(yaca_digest_update(ctx_ptr.get(), DATA.data(), DATA.size()));
+
+    YACA_INVALID_PARAM(yaca_digest_finalize(ctx_ptr.get(), nullptr, &out_len));
+    YACA_INVALID_PARAM(yaca_digest_finalize(ctx_ptr.get(), output, nullptr));
+}
+
+RUNNER_TEST(T2040_yaca_digest_get_output_length_invalid_param, YacaTest)
+{
+    auto ctx_ptr = digest_init(YACA_DIGEST_MD5);
+
+    YACA_INVALID_PARAM(yaca_context_get_output_length(ctx_ptr.get(), 0, nullptr));
+
+    size_t out_len;
+    YACA_INVALID_PARAM(yaca_context_get_output_length(ctx_ptr.get(), 42, &out_len));
+}
+
+RUNNER_TEST(T2050_yaca_digest_get_output_length, YacaTest)
+{
+    digest_length_test(YACA_DIGEST_MD5,    128);
+    digest_length_test(YACA_DIGEST_SHA1,   160);
+    digest_length_test(YACA_DIGEST_SHA224, 224);
+    digest_length_test(YACA_DIGEST_SHA256, 256);
+    digest_length_test(YACA_DIGEST_SHA384, 384);
+    digest_length_test(YACA_DIGEST_SHA512, 512);
+}
+
+RUNNER_TEST(T2060_yaca_digest_test_vectors, YacaTest)
+{
+    auto tvv = loadTestVector("digest_ascii.txt");
+
+    for (const auto& tv : tvv) {
+        yaca_digest_algorithm_e algo;
+        size_t repeats;
+        std::string input;
+        Buffer expected;
+
+        tv.get("algo", algo);
+        tv.get("repeats", repeats);
+        tv.get("input", input);
+        tv.get("output", expected);
+
+        auto ctx_ptr = digest_init(algo);
+        size_t out_len;
+
+        out_len = get_output_length(ctx_ptr);
+
+        if (input.size() > 0) {
+            for (size_t i = 0; i < repeats; i++)
+                YACA_SUCCESS(yaca_digest_update(ctx_ptr.get(),
+                                                input.c_str(),
+                                                input.size()));
+        }
+
+        Buffer output(out_len);
+        YACA_SUCCESS(yaca_digest_finalize(ctx_ptr.get(), output.data(), &out_len));
+        RUNNER_ASSERT_MSG(output.size() >= out_len,
+                          "Length returned from yaca_digest_finalize() (" << out_len <<
+                          ") is greater than the one returned from yaca_context_get_output_length() ("
+                          << output.size() << ")");
+        output.resize(out_len);
+
+        YACA_ASSERT_MSG(output.size() == expected.size(),
+                        " Digest calculated for \""  << truncate_str(input, 16) << "\" with "
+                        << digest2str(algo) << " is " << output.size() * 8
+                        <<" bits long. Expected " << expected.size() * 8 << " bits");
+
+        int ret = yaca_memcmp(output.data(), expected.data(), output.size());
+        YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
+                        "Digest calculated for \"" << truncate_str(input, 16) << "\" with "
+                        << digest2str(algo) << " is different than expected");
+    }
 }