src/ckm/algo-params.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  */
  16 /*
  17  * @file       algo-params.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #include <memory>
  23 #include <fstream>
  24
  25 #include <string.h>
  26
  27 #include <dpl/test/test_runner.h>
  28 #include <ckm-common.h>
  29 #include <ckmc/ckmc-type.h>
  30 #include <ckm/ckm-type.h>
  31
  32 namespace {
  33
  34 struct CryptoAlgorithmWrapper : public CKM::CryptoAlgorithm
  35 {
  36     bool empty() const { return m_params.empty(); }
  37     size_t count() const { return m_params.size(); }
  38 };
  39
  40 ckmc_param_list_h* EMPTY_PLIST = NULL;
  41 ckmc_param_list_h EMPTY_LIST = NULL;
  42
  43 const size_t DEFAULT_IV_LEN = 16;
  44 const size_t DEFAULT_IV_LEN_BITS = 8*DEFAULT_IV_LEN;
  45
  46 RawBufferPtr IV(createRandomBufferCAPI(DEFAULT_IV_LEN), ckmc_buffer_free);
  47
  48 void assert_list_empty(ckmc_param_list_h list)
  49 {
  50     const CryptoAlgorithmWrapper* caw = reinterpret_cast<const CryptoAlgorithmWrapper*>(list);
  51     RUNNER_ASSERT_MSG(caw->empty(), "Parameter list is not empty");
  52 }
  53
  54 void check_int_param(ckmc_param_list_h list,
  55                      ckmc_param_name_e name,
  56                      uint64_t expected)
  57 {
  58     RUNNER_ASSERT_MSG(list, "List is NULL");
  59     uint64_t got;
  60     int ret = ckmc_param_list_get_integer(list, name, &got);
  61     RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "No such integer param: " << name);
  62     RUNNER_ASSERT_MSG(expected == got,
  63                       "Param " << name << " expected value: " << expected << " got: " << got);
  64 }
  65
  66 void check_buffer_param(ckmc_param_list_h list,
  67                         ckmc_param_name_e name,
  68                         const ckmc_raw_buffer_s& expected)
  69 {
  70     RUNNER_ASSERT_MSG(list, "List is NULL");
  71     ckmc_raw_buffer_s* got = NULL;
  72     int ret = ckmc_param_list_get_buffer(list, name, &got);
  73     RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "No such buffer param: " << name);
  74     assert_buffers_equal(expected, *got);
  75 }
  76
  77 void assert_param_count(ckmc_param_list_h list, size_t expected)
  78 {
  79     RUNNER_ASSERT_MSG(list, "List is NULL");
  80     const CryptoAlgorithmWrapper* caw = reinterpret_cast<const CryptoAlgorithmWrapper*>(list);
  81     size_t count = caw->count();
  82     RUNNER_ASSERT_MSG(count == expected, "Expected param count: " << expected << " got: " << count);
  83 }
  84
  85 } // anonymous namespace
  86
  87 RUNNER_TEST_GROUP_INIT(CKM_ALGO_PARAMS);
  88
  89 RUNNER_TEST(TAP_0010_new_invalid_param)
  90 {
  91     assert_invalid_param(ckmc_param_list_new, EMPTY_PLIST);
  92 }
  93
  94 RUNNER_TEST(TAP_0020_free_invalid_param)
  95 {
  96     ckmc_param_list_free(EMPTY_LIST); // should not throw/segfault
  97 }
  98
  99 RUNNER_TEST(TAP_0030_new_free)
 100 {
 101     ParamListPtr list = createParamListPtr();
 102     assert_list_empty(list.get());
 103 }
 104
 105 RUNNER_TEST(TAP_0040_add_integer_invalid_param)
 106 {
 107     assert_invalid_param(ckmc_param_list_set_integer,
 108                          EMPTY_LIST,
 109                          CKMC_PARAM_ALGO_TYPE,
 110                          CKMC_ALGO_AES_CTR);
 111
 112     ParamListPtr list = createParamListPtr();
 113     assert_invalid_param(ckmc_param_list_set_integer,
 114                          list.get(),
 115                          static_cast<ckmc_param_name_e>(-1),
 116                          CKMC_ALGO_AES_CTR);
 117     assert_list_empty(list.get());
 118 }
 119
 120 RUNNER_TEST(TAP_0050_add_buffer_invalid_param)
 121 {
 122     assert_invalid_param(ckmc_param_list_set_buffer,
 123                          EMPTY_LIST,
 124                          CKMC_PARAM_ED_IV,
 125                          IV.get());
 126
 127     ParamListPtr list = createParamListPtr();
 128     assert_invalid_param(ckmc_param_list_set_buffer,
 129                          list.get(),
 130                          CKMC_PARAM_ED_IV,
 131                          nullptr);
 132     assert_list_empty(list.get());
 133
 134     ckmc_raw_buffer_s buffer;
 135     buffer.data = nullptr;
 136     buffer.size = 0;
 137     assert_invalid_param(ckmc_param_list_set_buffer,
 138                          list.get(),
 139                          CKMC_PARAM_ED_IV,
 140                          &buffer);
 141     assert_list_empty(list.get());
 142
 143     assert_invalid_param(ckmc_param_list_set_buffer,
 144                          list.get(),
 145                          static_cast<ckmc_param_name_e>(-1),
 146                          IV.get());
 147     assert_list_empty(list.get());
 148 }
 149
 150 RUNNER_TEST(TAP_0060_add_param)
 151 {
 152     ParamListPtr list = createParamListPtr();
 153     assert_positive(ckmc_param_list_set_integer,
 154                     list.get(),
 155                     CKMC_PARAM_ALGO_TYPE,
 156                     CKMC_ALGO_AES_GCM);
 157     check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_GCM);
 158     assert_param_count(list.get(),1);
 159
 160     RawBufferPtr buffer(createRandomBufferCAPI(DEFAULT_IV_LEN), ckmc_buffer_free);
 161     assert_positive(ckmc_param_list_set_buffer,
 162                     list.get(),
 163                     CKMC_PARAM_ED_IV,
 164                     buffer.get());
 165     check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_GCM);
 166     check_buffer_param(list.get(), CKMC_PARAM_ED_IV, *buffer.get());
 167     assert_param_count(list.get(),2);
 168 }
 169
 170 RUNNER_TEST(TAP_0070_generate_invalid_param)
 171 {
 172     assert_invalid_param(ckmc_generate_new_params, static_cast<ckmc_algo_type_e>(-1), EMPTY_PLIST);
 173 }
 174
 175 RUNNER_TEST(TAP_0080_generate)
 176 {
 177     ckmc_param_list_h handle = NULL;
 178     assert_positive(ckmc_generate_new_params, CKMC_ALGO_AES_CTR, &handle);
 179     ParamListPtr list = ParamListPtr(handle, ckmc_param_list_free);
 180     check_int_param(list.get(), CKMC_PARAM_ALGO_TYPE, CKMC_ALGO_AES_CTR);
 181     check_int_param(list.get(), CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
 182
 183     CKM::CryptoAlgorithm* ca = reinterpret_cast<CKM::CryptoAlgorithm*>(list.get());
 184     CKM::RawBuffer iv;
 185     bool ret = ca->getParam(CKM::ParamName::ED_IV, iv);
 186     RUNNER_ASSERT_MSG(!ret, "ED_IV param should not be present");
 187     assert_param_count(list.get(),2);
 188 }