CKM: Add tests for algorithm parameters CAPI

[Cause] No tests for algorithm params
[Solution] Tests added

[Verification] Run ckm-tests --group=CKM_ALGO_PARAMS

Change-Id: I609b62f035fdf89d2691e299b8d92c3580869f01

diff --git a/src/ckm/CMakeLists.txt b/src/ckm/CMakeLists.txt
index fc11723ae9476764b6f0184ab6bc0828b03f61f6..554749cfbcf6956a1d2bf70bdb6581166c904921 100644 (file)
--- a/src/ckm/CMakeLists.txt
+++ b/src/ckm/CMakeLists.txt
@@ -51,6 +51,7 @@ SET(CKM_SOURCES
     ${PROJECT_SOURCE_DIR}/src/ckm/initial-values.cpp
     ${PROJECT_SOURCE_DIR}/src/ckm/clean-env.cpp
     ${PROJECT_SOURCE_DIR}/src/ckm/test-certs.cpp
+    ${PROJECT_SOURCE_DIR}/src/ckm/algo-params.cpp
 )
 
 INCLUDE_DIRECTORIES(SYSTEM ${CKM_DEP_INCLUDE_DIRS})

diff --git a/src/ckm/algo-params.cpp b/src/ckm/algo-params.cpp
new file mode 100644 (file)
index 0000000..9b130ad
--- /dev/null
+++ b/src/ckm/algo-params.cpp
@@ -0,0 +1,213 @@
+/*
+ *  Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License
+ */
+/*
+ * @file       algo-params.cpp
+ * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version    1.0
+ */
+
+#include <memory>
+#include <fstream>
+
+#include <string.h>
+
+#include <dpl/test/test_runner.h>
+#include <ckm-common.h>
+#include <ckmc/ckmc-type.h>
+#include <ckm/ckm-type.h>
+
+namespace {
+
+struct CryptoAlgorithmWrapper : public CKM::CryptoAlgorithm
+{
+    bool empty() const { return m_params.empty(); }
+    size_t count() const { return m_params.size(); }
+};
+
+ckmc_param_list_s** EMPTY_PLIST = NULL;
+ckmc_param_list_s* EMPTY_LIST = NULL;
+
+const size_t DEFAULT_IV_LEN = 16;
+const size_t DEFAULT_IV_LEN_BITS = 8*DEFAULT_IV_LEN;
+
+typedef std::unique_ptr<ckmc_param_list_s, void(*)(ckmc_param_list_s*)> ParamListPtr;
+ParamListPtr createParamListPtr()
+{
+    ckmc_param_list_s* list = NULL;
+    assert_positive(ckmc_param_list_new, &list);
+    return ParamListPtr(list, ckmc_param_list_free);
+}
+
+typedef std::unique_ptr<ckmc_raw_buffer_s, void(*)(ckmc_raw_buffer_s*)> RawBufferPtr;
+ckmc_raw_buffer_s* createRandomBuffer(size_t len)
+{
+    ckmc_raw_buffer_s* buffer = NULL;
+    char* data = static_cast<char*>(malloc(len*sizeof(char)));
+    std::ifstream is("/dev/urandom", std::ifstream::binary);
+    RUNNER_ASSERT_MSG(is, "Failed to read /dev/urandom");
+    is.read(data, len);
+    if(static_cast<std::streamsize>(len) != is.gcount()) {
+        free(data);
+        RUNNER_ASSERT_MSG(false,
+                          "Not enough bytes read from /dev/urandom: " << len << "!=" <<
+                          is.gcount());
+    }
+    int ret = ckmc_buffer_new(reinterpret_cast<unsigned char*>(data), len, &buffer);
+    RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "Buffer creation failed: " << CKMCErrorToString(ret));
+    return buffer;
+}
+RawBufferPtr IV(createRandomBuffer(DEFAULT_IV_LEN), ckmc_buffer_free);
+
+void assert_list_empty(const ckmc_param_list_s* list)
+{
+    const CryptoAlgorithmWrapper* caw = reinterpret_cast<const CryptoAlgorithmWrapper*>(list);
+    RUNNER_ASSERT_MSG(caw->empty(), "Parameter list is not empty");
+}
+
+void check_int_param(const ckmc_param_list_s* list,
+                     ckmc_param_name_e name,
+                     uint64_t expected)
+{
+    RUNNER_ASSERT_MSG(list, "List is NULL");
+    uint64_t got;
+    int ret = ckmc_param_list_get_integer(list, name, &got);
+    RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "No such integer param: " << name);
+    RUNNER_ASSERT_MSG(expected == got,
+                      "Param " << name << " expected value: " << expected << " got: " << got);
+}
+
+void check_buffer_param(const ckmc_param_list_s* list,
+                        ckmc_param_name_e name,
+                        const ckmc_raw_buffer_s& expected)
+{
+    RUNNER_ASSERT_MSG(list, "List is NULL");
+    ckmc_raw_buffer_s* got = NULL;
+    int ret = ckmc_param_list_get_buffer(list, name, &got);
+    RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "No such buffer param: " << name);
+    assert_buffers_equal(expected, *got);
+}
+
+void assert_param_count(const ckmc_param_list_s* list, size_t expected)
+{
+    RUNNER_ASSERT_MSG(list, "List is NULL");
+    const CryptoAlgorithmWrapper* caw = reinterpret_cast<const CryptoAlgorithmWrapper*>(list);
+    size_t count = caw->count();
+    RUNNER_ASSERT_MSG(count == expected, "Expected param count: " << expected << " got: " << count);
+}
+
+} // anonymous namespace
+
+RUNNER_TEST_GROUP_INIT(CKM_ALGO_PARAMS);
+
+RUNNER_TEST(TAP_0010_new_invalid_param)
+{
+    assert_invalid_param(ckmc_param_list_new, EMPTY_PLIST);
+}
+
+RUNNER_TEST(TAP_0020_free_invalid_param)
+{
+    ckmc_param_list_free(EMPTY_LIST); // should not throw/segfault
+}
+
+RUNNER_TEST(TAP_0030_new_free)
+{
+    ParamListPtr list = createParamListPtr();
+    assert_list_empty(list.get());
+}
+
+RUNNER_TEST(TAP_0040_add_integer_invalid_param)
+{
+    assert_invalid_param(ckmc_param_list_add_integer,
+                         EMPTY_LIST,
+                         CKMC_PARAM_ALGO_TYPE,
+                         CKMC_ALGO_AES_CTR);
+
+    ParamListPtr list = createParamListPtr();
+    assert_invalid_param(ckmc_param_list_add_integer,
+                         list.get(),
+                         static_cast<ckmc_param_name_e>(-1),
+                         CKMC_ALGO_AES_CTR);
+    assert_list_empty(list.get());
+}
+
+RUNNER_TEST(TAP_0050_add_buffer_invalid_param)
+{
+    assert_invalid_param(ckmc_param_list_add_buffer,
+                         EMPTY_LIST,
+                         CKMC_PARAM_ED_IV,
+                         IV.get());
+
+    ParamListPtr list = createParamListPtr();
+    assert_invalid_param(ckmc_param_list_add_buffer,
+                         list.get(),
+                         CKMC_PARAM_ED_IV,
+                         nullptr);
+    assert_list_empty(list.get());
+
+    ckmc_raw_buffer_s buffer;
+    buffer.data = nullptr;
+    buffer.size = 0;
+    assert_invalid_param(ckmc_param_list_add_buffer,
+                         list.get(),
+                         CKMC_PARAM_ED_IV,
+                         &buffer);
+    assert_list_empty(list.get());
+
+    assert_invalid_param(ckmc_param_list_add_buffer,
+                         list.get(),
+                         static_cast<ckmc_param_name_e>(-1),
+                         IV.get());
+    assert_list_empty(list.get());
+}
+
+RUNNER_TEST(TAP_0060_add_param)
+{
+    ParamListPtr list = createParamListPtr();
+    assert_positive(ckmc_param_list_add_integer,
+                    list.get(),
+                    CKMC_PARAM_ALGO_TYPE,
+                    CKMC_ALGO_AES_GCM);
+    check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_GCM);
+    assert_param_count(list.get(),1);
+
+    RawBufferPtr buffer(createRandomBuffer(DEFAULT_IV_LEN), ckmc_buffer_free);
+    assert_positive(ckmc_param_list_add_buffer,
+                    list.get(),
+                    CKMC_PARAM_ED_IV,
+                    buffer.get());
+    check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_GCM);
+    check_buffer_param(list.get(), CKMC_PARAM_ED_IV, *buffer.get());
+    assert_param_count(list.get(),2);
+}
+
+RUNNER_TEST(TAP_0070_generate_invalid_param)
+{
+    assert_invalid_param(ckmc_generate_params, static_cast<ckmc_algo_type_e>(-1), EMPTY_LIST);
+}
+
+RUNNER_TEST(TAP_0080_generate)
+{
+    ParamListPtr list = createParamListPtr();
+    assert_positive(ckmc_generate_params, CKMC_ALGO_AES_CTR, list.get());
+    check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_CTR);
+    check_int_param(list.get(), CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
+
+    CKM::CryptoAlgorithm* ca = reinterpret_cast<CKM::CryptoAlgorithm*>(list.get());
+    CKM::RawBuffer iv;
+    bool ret = ca->getParam(CKM::ParamName::ED_IV, iv);
+    RUNNER_ASSERT_MSG(!ret, "ED_IV param should not be present");
+    assert_param_count(list.get(),2);
+}

diff --git a/src/ckm/ckm-common.cpp b/src/ckm/ckm-common.cpp
index e9993734cadcf4e1afe7f056771cc67e4b55e954..281c378f4d0fab4ac08d7b440cf9b320905266fb 100644 (file)
--- a/src/ckm/ckm-common.cpp
+++ b/src/ckm/ckm-common.cpp
@@ -456,3 +456,14 @@ std::string sharedDatabase(const CKM::Alias & alias)
 {
     return aliasWithLabel(ckmc_label_shared_owner, alias.c_str());
 }
+
+void assert_buffers_equal(const ckmc_raw_buffer_s b1, const ckmc_raw_buffer_s b2, bool equal)
+{
+    if(equal) {
+        RUNNER_ASSERT_MSG(b1.size == b2.size, "Buffer size differs: " << b1.size << "!=" << b2.size);
+        RUNNER_ASSERT_MSG(0 == memcmp(b1.data, b2.data, b1.size), "Buffer contents differ");
+    } else {
+        RUNNER_ASSERT_MSG(b1.size != b2.size, "Buffer sizes equal: " << b1.size << "==" << b2.size);
+        RUNNER_ASSERT_MSG(0 != memcmp(b1.data, b2.data, b1.size), "Buffer contents are identical");
+    }
+}

diff --git a/src/ckm/ckm-common.h b/src/ckm/ckm-common.h
index 7a5ccd79cfbe9c486708da3c68629b8e779dbde4..8b9090a31276665b3986269aaa7759483edca859 100644 (file)
--- a/src/ckm/ckm-common.h
+++ b/src/ckm/ckm-common.h
@@ -28,7 +28,6 @@
 #include <ckmc/ckmc-error.h>
 #include <tests_common.h>
 #include <sys/types.h>
-#include <access_provider2.h>
 
 // RUNNER_ASSERT wrappers
 template <typename F, typename... Args>
@@ -206,3 +205,5 @@ public:
         remove_user_data(UID);
     }
 };
+
+void assert_buffers_equal(const ckmc_raw_buffer_s b1, const ckmc_raw_buffer_s b2, bool equal=true);