YACA: Add helpers for digest, hmac, random buffers

Change-Id: I61c4d545adbcf39c2ecdca588cc1feb29f6c0e99

diff --git a/src/yaca/yaca-test-common.cpp b/src/yaca/yaca-test-common.cpp
index e2c6ffb..e1b96f5 100644 (file)
--- a/src/yaca/yaca-test-common.cpp
+++ b/src/yaca/yaca-test-common.cpp
@@ -21,8 +21,12 @@
 
 #include <vector>
 #include <string>
+#include <fstream>
+#include <sstream>
 
 #include <yaca_seal.h>
+#include <yaca_sign.h>
+#include <yaca_digest.h>
 
 #include "yaca-test-common.h"
 
@@ -52,6 +56,11 @@ const char *yaca_error(int error)
     return yaca_debug_translate_error(static_cast<yaca_error_e>(error));
 }
 
+BufPtr wrap_ptr(char* buffer)
+{
+    return BufPtr(buffer, yaca_free);
+}
+
 KeyPtr wrap_ptr(yaca_key_h key)
 {
     return KeyPtr(key, yaca_key_destroy);
@@ -62,9 +71,11 @@ CtxPtr wrap_ptr(yaca_context_h ctx)
     return CtxPtr(ctx, yaca_context_destroy);
 }
 
-BufPtr wrap_ptr(char* buffer)
+BufPtr create_yaca_buffer(size_t size)
 {
-    return BufPtr(buffer, yaca_free);
+    char *buffer;
+    YACA_SUCCESS(yaca_malloc(size, (void**)&buffer));
+    return wrap_ptr(buffer);
 }
 
 KeyPtr null_key()
@@ -106,9 +117,60 @@ CtxPtr seal_init(const KeyPtr& key_pub,
     return wrap_ptr(ctx);
 }
 
-BufPtr create_buffer(size_t size)
+CtxPtr hmac_init(yaca_digest_algorithm_e algo, const KeyPtr& key)
 {
-    char *buffer;
-    YACA_SUCCESS(yaca_malloc(size, (void**)&buffer));
-    return wrap_ptr(buffer);
+    yaca_context_h ctx = YACA_CONTEXT_NULL;
+
+    YACA_SUCCESS(yaca_sign_initialize_hmac(&ctx, algo, key.get()));
+
+    return wrap_ptr(ctx);
+}
+
+CtxPtr digest_init(yaca_digest_algorithm_e algo)
+{
+    yaca_context_h ctx = YACA_CONTEXT_NULL;
+
+    YACA_SUCCESS(yaca_digest_initialize(&ctx, algo));
+
+    return wrap_ptr(ctx);
+}
+
+std::vector<char> random_buffer(size_t length)
+{
+    RUNNER_ASSERT(length > 0);
+
+    std::vector<char> buffer(length);
+    std::ifstream is("/dev/urandom", std::ifstream::binary);
+    RUNNER_ASSERT_MSG(is, "Failed to open /dev/urandom");
+    is.read(buffer.data(), length);
+    if(static_cast<std::streamsize>(length) != is.gcount()) {
+        RUNNER_ASSERT_MSG(false,
+                          "Not enough bytes read from /dev/urandom: " << length << "!=" <<
+                          is.gcount());
+    }
+
+    return buffer;
+}
+
+#define DIGEST_DESCRIBE(algo) case (algo): return #algo;
+const char* digest2str(yaca_digest_algorithm_e algo)
+{
+    switch (algo) {
+    DIGEST_DESCRIBE(YACA_DIGEST_MD5);
+    DIGEST_DESCRIBE(YACA_DIGEST_SHA1);
+    DIGEST_DESCRIBE(YACA_DIGEST_SHA224);
+    DIGEST_DESCRIBE(YACA_DIGEST_SHA256);
+    DIGEST_DESCRIBE(YACA_DIGEST_SHA384);
+    DIGEST_DESCRIBE(YACA_DIGEST_SHA512);
+    default: return "Unknown digest algorithm";
+    }
+}
+#undef DIGEST_DESCRIBE
+
+std::string truncate_str(const std::string& input, size_t len)
+{
+    if (len >= input.size())
+        return input;
+
+    return input.substr(0, len).append("...");
 }

diff --git a/src/yaca/yaca-test-common.h b/src/yaca/yaca-test-common.h
index ff62a58..e8008d1 100644 (file)
--- a/src/yaca/yaca-test-common.h
+++ b/src/yaca/yaca-test-common.h
@@ -97,13 +97,15 @@ do {                                                                           \
 
 #define YACA_INVALID_PARAM(func) YACA_RESULT(YACA_ERROR_INVALID_PARAMETER, func);
 
+typedef std::unique_ptr<char, int (*)(void*)> BufPtr;
 typedef std::unique_ptr<yaca_key_s, int (*)(yaca_key_h)> KeyPtr;
 typedef std::unique_ptr<yaca_context_s, int (*)(yaca_context_h)> CtxPtr;
-typedef std::unique_ptr<char, int (*)(void*)> BufPtr;
 
+BufPtr wrap_ptr(char* buffer);
 KeyPtr wrap_ptr(yaca_key_h key);
 CtxPtr wrap_ptr(yaca_context_h ctx);
-BufPtr wrap_ptr(char* buffer);
+
+BufPtr create_yaca_buffer(size_t size);
 
 KeyPtr null_key();
 
@@ -118,4 +120,17 @@ CtxPtr seal_init(const KeyPtr& key_pub,
                  KeyPtr& sym_key_ptr,
                  KeyPtr& iv_ptr);
 
-BufPtr create_buffer(size_t size);
+CtxPtr hmac_init(yaca_digest_algorithm_e algo, const KeyPtr& key);
+
+CtxPtr digest_init(yaca_digest_algorithm_e algo);
+
+std::vector<char> random_buffer(size_t length);
+
+/* Converts string representing hex to array of bytes, for example: "d41d" -> { 0xd4, 0x1d } */
+std::vector<char> str2data(const std::string& hex_str);
+
+const char* digest2str(yaca_digest_algorithm_e algo);
+
+/* If input is longer than len it is truncated and an ellipsis is appended.
+ * Otherwise the original string is returned. */
+std::string truncate_str(const std::string& input, size_t len);

diff --git a/src/yaca/yaca-test-stress.cpp b/src/yaca/yaca-test-stress.cpp
index 5ef0a6e..f974414 100644 (file)
--- a/src/yaca/yaca-test-stress.cpp
+++ b/src/yaca/yaca-test-stress.cpp
@@ -57,7 +57,7 @@ void thread_fn()
 
         enc_size = output_len + block_len;
 
-        auto enc = create_buffer(enc_size);
+        auto enc = create_yaca_buffer(enc_size);
 
         out_size = enc_size;
         YACA_SUCCESS(yaca_seal_update(ctx.get(), lorem4096, LOREM4096_SIZE, enc.get(), &out_size));