From: Krzysztof Jackiewicz Date: Wed, 20 May 2015 11:47:51 +0000 (+0200) Subject: CKM: Add tests for algorithm parameters CAPI X-Git-Tag: security-manager_5.5_testing~9^2~78 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=35813b4d809f0158dd508d7fd1b575aba3f32b43;p=platform%2Fcore%2Ftest%2Fsecurity-tests.git 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 fc11723a..554749cf 100644 --- 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 index 00000000..9b130ad7 --- /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 +#include + +#include + +#include +#include +#include +#include + +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 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 RawBufferPtr; +ckmc_raw_buffer_s* createRandomBuffer(size_t len) +{ + ckmc_raw_buffer_s* buffer = NULL; + char* data = static_cast(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(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(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(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(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(-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(-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(-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(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 e9993734..281c378f 100644 --- 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 7a5ccd79..8b9090a3 100644 --- a/src/ckm/ckm-common.h +++ b/src/ckm/ckm-common.h @@ -28,7 +28,6 @@ #include #include #include -#include // RUNNER_ASSERT wrappers template @@ -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);