E2EE bundle API test

Change-Id: I84751e9ea417aedc06520af66c1208d76c4e091d

diff --git a/src/dcm-client/device_certificate_manager.cpp b/src/dcm-client/device_certificate_manager.cpp
index 18b429d..62ba34f 100644 (file)
--- a/src/dcm-client/device_certificate_manager.cpp
+++ b/src/dcm-client/device_certificate_manager.cpp
@@ -273,14 +273,18 @@ int dcm_e2ee_get_bundle_payload(const dcm_e2ee_bundle_h bundle,
 }
 
 API_DEVICE_CERTIFICATE_MANAGER_EXPORT
-int dcm_e2ee_create_signed_bundle(const void */*key_ctx*/,
+int dcm_e2ee_create_signed_bundle(const void *key_ctx,
        dcm_digest_algorithm_e /*md*/,
-       const unsigned char */*payload*/,
+       const unsigned char *payload,
        size_t /*payload_len*/,
-       dcm_e2ee_bundle_h */*bundle*/,
-       unsigned char **/*signature*/,
-       size_t */*signature_len*/)
+       dcm_e2ee_bundle_h *bundle,
+       char **signature,
+       size_t *signature_len)
 {
+       if (key_ctx == NULL || payload == NULL || bundle == NULL || signature == NULL ||
+               signature_len == NULL)
+               return DCM_ERROR_INVALID_PARAMETER;
+
        /* TODO:
         * 1. Get client pkg_id from socket
         * 2. Construct a message (platform="Tizen" + pkg_id + payload) and put it into bundle

diff --git a/tests/api_test.cpp b/tests/api_test.cpp
index abcda69..5cfb254 100644 (file)
--- a/tests/api_test.cpp
+++ b/tests/api_test.cpp
@@ -18,6 +18,7 @@
 
 #include <boost/algorithm/hex.hpp>
 #include <cstring>
+#include <memory>
 #include <iomanip>
 #include <iostream>
 #include <sys/smack.h> // SMACK_LABEL_LEN
@@ -96,6 +97,61 @@ public:
     }
 };
 
+template <typename F, typename... Args>
+void assert_result(int expected, F&& func, Args... args)
+{
+    BOOST_REQUIRE_EQUAL(func(args...), expected);
+}
+
+template <typename F, typename... Args>
+void assert_positive(F&& func, Args... args)
+{
+    assert_result(DCM_ERROR_NONE, std::move(func), args...);
+}
+
+template <typename F, typename... Args>
+void assert_invalid_param(F&& func, Args... args)
+{
+    assert_result(DCM_ERROR_INVALID_PARAMETER, std::move(func), args...);
+}
+
+template <size_t N>
+std::pair<unsigned char*, size_t> makeMessage(const char* platform,
+                                              const char* pkgId,
+                                              const unsigned char (&payload)[N])
+{
+    const size_t platformSize = strlen(platform) + 1;
+    const size_t pkgIdSize = strlen(pkgId) + 1;
+    const size_t size = platformSize + pkgIdSize + N;
+    unsigned char* message = static_cast<unsigned char*>(malloc(size));
+    memcpy(message, platform, platformSize);
+    memcpy(message + platformSize, pkgId, pkgIdSize);
+    memcpy(message + platformSize + pkgIdSize, payload, N);
+    return std::make_pair(message, size);
+}
+
+template <typename T, void (*Fn)(T*)>
+struct Free {
+    explicit Free(T* ptr) : ptr(ptr) {}
+    ~Free() {
+        Fn(ptr);
+    }
+    Free(const Free&) = delete;
+    Free& operator=(const Free&) = delete;
+    T* operator*() { return ptr; }
+private:
+    T* ptr;
+};
+
+void freeKey(void* ptr)
+{
+    dcm_free_key_context(ptr);
+}
+
+typedef Free<dcm_e2ee_bundle_s, dcm_e2ee_free_bundle> FreeBundle;
+typedef Free<void, freeKey> FreeKey;
+typedef std::unique_ptr<unsigned char, decltype(&free)> BytesPtr;
+
 } // namespace
 
 BOOST_AUTO_TEST_SUITE(API_TEST)
@@ -410,4 +466,133 @@ NEGATIVE_TEST_CASE(test19_dcm_api_no_mem) {
             nullptr, nullptr, nullptr, &ctx) == DCM_ERROR_UNKNOWN);
 }
 
+POSITIVE_TEST_CASE(test20_dcm_api_bundle) {
+    BOOST_REQUIRE_NO_THROW(dcm_e2ee_free_bundle(NULL));
+
+    unsigned char payload[] = {1,2,3,4};
+    auto [msg, size] = makeMessage("Tizen", "User::Pkg::test", payload);
+
+    dcm_e2ee_bundle_h bundle;
+    assert_positive(dcm_e2ee_create_bundle, msg, size, &bundle);
+    FreeBundle freeBundle(bundle);
+
+    const unsigned char* cMsg;
+    size_t cMsgSize;
+    assert_positive(dcm_e2ee_get_bundle_message, bundle, &cMsg, &cMsgSize);
+    BOOST_REQUIRE_EQUAL(cMsgSize, size);
+    BOOST_REQUIRE_EQUAL(memcmp(msg, cMsg, cMsgSize), 0);
+
+    const char* cPlatform;
+    assert_positive(dcm_e2ee_get_bundle_platform, bundle, &cPlatform);
+    BOOST_REQUIRE_EQUAL(strcmp(cPlatform, "Tizen"), 0);
+
+    const char* cPkgId;
+    assert_positive(dcm_e2ee_get_bundle_pkg_id, bundle, &cPkgId);
+    BOOST_REQUIRE_EQUAL(strcmp(cPkgId, "User::Pkg::test"), 0);
+
+    const unsigned char* cPayload;
+    size_t cPayloadSize;
+    assert_positive(dcm_e2ee_get_bundle_payload, bundle, &cPayload, &cPayloadSize);
+    BOOST_REQUIRE_EQUAL(cPayloadSize, sizeof(payload));
+    BOOST_REQUIRE_EQUAL(memcmp(payload, cPayload, cPayloadSize), 0);
+
+    // TODO create signed bundle
+}
+
+NEGATIVE_TEST_CASE(test21_dcm_api_bundle) {
+    unsigned char payload[] = {1,2,3,4};
+    unsigned char payload2[] = {'T', 'i', 'z', 'e', 'n', 0, 1, 2, 3, 4};
+    auto [msg, size] = makeMessage("Tizen", "User::Pkg::test", payload);
+    auto [msg2, size2] = makeMessage("Tauzen", "User::Pkg::test", payload);
+    BytesPtr msgPtr(msg, free);
+    BytesPtr msg2Ptr(msg2, free);
+
+    dcm_e2ee_bundle_h bundle;
+
+    assert_invalid_param(dcm_e2ee_create_bundle, nullptr,  size,             &bundle);
+    assert_invalid_param(dcm_e2ee_create_bundle, msg,      size,             nullptr);
+    assert_invalid_param(dcm_e2ee_create_bundle, payload,  sizeof(payload),  &bundle);
+    assert_invalid_param(dcm_e2ee_create_bundle, payload2, sizeof(payload2), &bundle);
+
+    BOOST_REQUIRE_EQUAL(dcm_e2ee_create_bundle(msg2, size2, &bundle), DCM_ERROR_NOT_SUPPORTED);
+
+    assert_positive(dcm_e2ee_create_bundle, msg, size, &bundle);
+    msgPtr.release();
+    {
+        FreeBundle freeBundle(bundle);
+
+        const unsigned char* cMsg;
+        size_t cMsgSize;
+        assert_invalid_param(dcm_e2ee_get_bundle_message, nullptr, &cMsg,   &cMsgSize);
+        assert_invalid_param(dcm_e2ee_get_bundle_message, bundle,  nullptr, &cMsgSize);
+        assert_invalid_param(dcm_e2ee_get_bundle_message, bundle,  &cMsg,   nullptr);
+
+        const char* cPlatform;
+        assert_invalid_param(dcm_e2ee_get_bundle_platform, nullptr, &cPlatform);
+        assert_invalid_param(dcm_e2ee_get_bundle_platform, bundle,  nullptr);
+
+        const char* cPkgId;
+        assert_invalid_param(dcm_e2ee_get_bundle_pkg_id, nullptr, &cPkgId);
+        assert_invalid_param(dcm_e2ee_get_bundle_pkg_id, bundle,  nullptr);
+
+        const unsigned char* cPayload;
+        size_t cPayloadSize;
+        assert_invalid_param(dcm_e2ee_get_bundle_payload, nullptr, &cPayload, &cPayloadSize);
+        assert_invalid_param(dcm_e2ee_get_bundle_payload, bundle,  nullptr,   &cPayloadSize);
+        assert_invalid_param(dcm_e2ee_get_bundle_payload, bundle,  &cPayload, nullptr);
+    }
+    bundle = nullptr;
+
+    void* ocfCtx = nullptr;
+    assert_positive(dcm_create_key_context, nullptr, nullptr, "ECDSA", &ocfCtx);
+    FreeKey freeOcfCtx(ocfCtx);
+
+    char* signature;
+    size_t signatureSize;
+    assert_invalid_param(dcm_e2ee_create_signed_bundle,
+                         nullptr,
+                         DCM_DIGEST_SHA256,
+                         payload,
+                         sizeof(payload),
+                         &bundle,
+                         &signature,
+                         &signatureSize);
+
+    assert_invalid_param(dcm_e2ee_create_signed_bundle,
+                         ocfCtx,
+                         DCM_DIGEST_SHA256,
+                         nullptr,
+                         sizeof(payload),
+                         &bundle,
+                         &signature,
+                         &signatureSize);
+
+    assert_invalid_param(dcm_e2ee_create_signed_bundle,
+                         ocfCtx,
+                         DCM_DIGEST_SHA256,
+                         payload,
+                         sizeof(payload),
+                         nullptr,
+                         &signature,
+                         &signatureSize);
+
+    assert_invalid_param(dcm_e2ee_create_signed_bundle,
+                         ocfCtx,
+                         DCM_DIGEST_SHA256,
+                         payload,
+                         sizeof(payload),
+                         &bundle,
+                         nullptr,
+                         &signatureSize);
+
+    assert_invalid_param(dcm_e2ee_create_signed_bundle,
+                         ocfCtx,
+                         DCM_DIGEST_SHA256,
+                         payload,
+                         sizeof(payload),
+                         &bundle,
+                         &signature,
+                         nullptr);
+}
+
 BOOST_AUTO_TEST_SUITE_END()