src/yaca/yaca-test-key.cpp

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Dariusz Michaluk (d.michaluk@samsumg.com)
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file
  21  * @author Dariusz Michaluk (d.michaluk@samsumg.com)
  22  */
  23
  24 #include "dpl/test/test_runner.h"
  25
  26 #include <stdint.h>
  27
  28 #include <yaca_key.h>
  29 #include <yaca_types.h>
  30 #include <yaca_error.h>
  31
  32 #include "yaca-test-common.h"
  33
  34 namespace {
  35
  36 void key_gen_test(yaca_key_type_e expected_type, size_t expected_bits)
  37 {
  38     size_t bits;
  39     yaca_key_type_e type;
  40
  41     auto key_ptr = generate_key(expected_type, expected_bits);
  42
  43     YACA_SUCCESS(yaca_key_get_bit_length(key_ptr.get(), &bits));
  44     YACA_ASSERT_MSG(bits == expected_bits,
  45                     "Expected key length: " << expected_bits << " got: " << bits);
  46
  47     YACA_SUCCESS(yaca_key_get_type(key_ptr.get(), &type));
  48     YACA_ASSERT_MSG(type == expected_type,
  49                     "Expected key type: " << expected_type << " got: " << bits);
  50 }
  51
  52 void key_gen_invalid_param(yaca_key_type_e key_type,
  53                            size_t key_bit_len,
  54                            yaca_key_h *key)
  55 {
  56     YACA_INVALID_PARAM(yaca_key_generate(key_type, key_bit_len, key));
  57
  58     YACA_ASSERT_MSG(key == nullptr || *key == YACA_KEY_NULL,
  59                     "Non-empty key returned from a function that failed");
  60 }
  61
  62 } // anonymous namespace
  63
  64 RUNNER_TEST_GROUP_INIT(T4000_YACA_KEY);
  65
  66
  67 RUNNER_TEST(T4006_yaca_key_free)
  68 {
  69 }
  70
  71 RUNNER_TEST(T4007_yaca_key_derive_dh)
  72 {
  73 }
  74
  75 RUNNER_TEST(T4008_yaca_key_derive_kea)
  76 {
  77 }
  78
  79 RUNNER_TEST(T4009_yaca_key_derive_pbkdf2)
  80 {
  81 }
  82
  83 RUNNER_TEST(T4010_yaca_key_generate_wrong_type, YacaTest)
  84 {
  85     yaca_key_h key = YACA_KEY_NULL;
  86
  87     key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &key);
  88 }
  89
  90 RUNNER_TEST(T4020_yaca_key_generate_symmetric_invalid_param, YacaTest)
  91 {
  92     yaca_key_h key = YACA_KEY_NULL;
  93
  94     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, nullptr);
  95     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &key);
  96     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &key);
  97     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &key);
  98 }
  99
 100 RUNNER_TEST(T4030_yaca_key_generate_iv_invalid_param, YacaTest)
 101 {
 102     yaca_key_h key = YACA_KEY_NULL;
 103
 104     key_gen_invalid_param(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_256BIT, nullptr);
 105     key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &key);
 106     key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &key);
 107     key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &key);
 108 }
 109
 110 RUNNER_TEST(T4040_yaca_key_generate_des_invalid_param, YacaTest)
 111 {
 112     yaca_key_h key = YACA_KEY_NULL;
 113
 114     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, nullptr);
 115     key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &key);
 116     key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &key);
 117     key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &key);
 118     key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &key);
 119     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &key);
 120 }
 121
 122 RUNNER_TEST(T4050_yaca_key_generate_rsa_invalid_param, YacaTest)
 123 {
 124     yaca_key_h key = YACA_KEY_NULL;
 125
 126     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 127     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
 128     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 129     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &key);
 130 }
 131
 132 RUNNER_TEST(T4060_yaca_key_generate_dsa_invalid_param, YacaTest)
 133 {
 134     yaca_key_h key = YACA_KEY_NULL;
 135
 136     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 137     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
 138     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 139     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &key);
 140     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &key);
 141     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT , &key);
 142 }
 143
 144 // ECDSA not yet implemented
 145 #if 0
 146 RUNNER_TEST(T4070_yaca_key_generate_ecdsa_invalid_param, YacaTest)
 147 {
 148     RUNNER_IGNORED_MSG("ECDSA is not supported yet");
 149     yaca_key_h key = YACA_KEY_NULL;
 150
 151     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_256BIT, nullptr);
 152     key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_CURVE_P192, &key);
 153     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 154     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &key);
 155     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, 193, &key);
 156 }
 157 #endif
 158
 159 RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
 160 {
 161     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8);
 162     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 72);
 163     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
 164     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 165     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 1016);
 166     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_4096BIT);
 167     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8192);
 168 }
 169
 170 RUNNER_TEST(T4090_yaca_key_generate_iv, YacaTest)
 171 {
 172     key_gen_test(YACA_KEY_TYPE_IV, 8);
 173     key_gen_test(YACA_KEY_TYPE_IV, 72);
 174     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
 175     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_512BIT);
 176     key_gen_test(YACA_KEY_TYPE_IV, 1016);
 177     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_4096BIT);
 178     key_gen_test(YACA_KEY_TYPE_IV, 8192);
 179 }
 180
 181 RUNNER_TEST(T4100_yaca_key_generate_des, YacaTest)
 182 {
 183     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT);
 184     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT);
 185     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT);
 186 }
 187
 188 RUNNER_TEST(T4110_yaca_key_generate_rsa, YacaTest)
 189 {
 190     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_256BIT);
 191     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 192     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 193     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 194     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
 195 }
 196
 197 RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
 198 {
 199     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 200     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 201     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 202     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
 203 }
 204
 205 // ECDSA not yet implemented
 206 #if 0
 207 RUNNER_TEST(T4130_yaca_key_generate_ecdsa, YacaTest)
 208 {
 209     RUNNER_IGNORED_MSG("ECDSA is not supported yet");
 210     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P192);
 211     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P256);
 212     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P384);
 213 }
 214 #endif
 215
 216 RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
 217 {
 218     yaca_key_type_e type;
 219
 220     YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
 221
 222     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 223
 224     YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
 225 }
 226
 227 RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
 228 {
 229     size_t bits;
 230
 231     YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
 232
 233     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 234
 235     YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
 236 }
 237
 238 RUNNER_TEST(T4220_yaca_key_export_invalid_param, YacaTest)
 239 {
 240     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 1024);
 241     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, 1024);
 242     char *data;
 243     size_t data_len;
 244
 245     YACA_INVALID_PARAM(yaca_key_export(nullptr,
 246                                        YACA_KEY_FORMAT_DEFAULT,
 247                                        YACA_KEY_FILE_FORMAT_BASE64,
 248                                        nullptr, &data, &data_len));
 249
 250     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 251                                        YACA_KEY_FORMAT_DEFAULT,
 252                                        YACA_KEY_FILE_FORMAT_BASE64,
 253                                        nullptr, nullptr, &data_len));
 254     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 255                                        YACA_KEY_FORMAT_DEFAULT,
 256                                        YACA_KEY_FILE_FORMAT_BASE64,
 257                                        nullptr, &data, nullptr));
 258
 259     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 260                                        YACA_KEY_FORMAT_DEFAULT,
 261                                        YACA_KEY_FILE_FORMAT_BASE64,
 262                                        "pass", &data, &data_len));
 263     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 264                                        static_cast<yaca_key_format_e>(-1),
 265                                        YACA_KEY_FILE_FORMAT_BASE64,
 266                                        nullptr, &data, &data_len));
 267     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 268                                        YACA_KEY_FORMAT_DEFAULT,
 269                                        static_cast<yaca_key_file_format_e>(-1),
 270                                        nullptr, &data, &data_len));
 271     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 272                                        YACA_KEY_FORMAT_DEFAULT,
 273                                        YACA_KEY_FILE_FORMAT_PEM,
 274                                        nullptr, &data, &data_len));
 275     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 276                                        YACA_KEY_FORMAT_DEFAULT,
 277                                        YACA_KEY_FILE_FORMAT_DER,
 278                                        nullptr, &data, &data_len));
 279     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 280                                        YACA_KEY_FORMAT_PKCS8,
 281                                        YACA_KEY_FILE_FORMAT_PEM,
 282                                        nullptr, &data, &data_len));
 283
 284     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 285                                        static_cast<yaca_key_format_e>(-1),
 286                                        YACA_KEY_FILE_FORMAT_PEM,
 287                                        nullptr, &data, &data_len));
 288     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 289                                        YACA_KEY_FORMAT_DEFAULT,
 290                                        static_cast<yaca_key_file_format_e>(-1),
 291                                        nullptr, &data, &data_len));
 292     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 293                                        YACA_KEY_FORMAT_DEFAULT,
 294                                        YACA_KEY_FILE_FORMAT_BASE64,
 295                                        nullptr, &data, &data_len));
 296     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 297                                        YACA_KEY_FORMAT_DEFAULT,
 298                                        YACA_KEY_FILE_FORMAT_RAW,
 299                                        nullptr, &data, &data_len));
 300 }
 301
 302 RUNNER_TEST(T4220_yaca_key_import_invalid_param, YacaTest)
 303 {
 304     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 305     size_t key_sym_data_len;
 306     BufPtr key_sym_data = export_key(key_sym, YACA_KEY_FORMAT_DEFAULT,
 307                                      YACA_KEY_FILE_FORMAT_BASE64,
 308                                      nullptr, &key_sym_data_len);
 309
 310     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 311     size_t key_rsa_data_len;
 312     BufPtr key_rsa_data = export_key(key_rsa, YACA_KEY_FORMAT_DEFAULT,
 313                                      YACA_KEY_FILE_FORMAT_DER,
 314                                      nullptr, &key_rsa_data_len);
 315
 316     const char *inv_data1 = "qwertyuiopasdfghjklzxcvbnmqwerty";
 317     size_t inv_data1_len = strlen(inv_data1);
 318     const char *inv_data2 = "--------qwertyuiopasdfghjklzxcvbnm";
 319     size_t inv_data2_len = strlen(inv_data2);
 320     yaca_key_h out;
 321
 322     YACA_INVALID_PARAM(yaca_key_import(static_cast<yaca_key_type_e>(-1), nullptr,
 323                                        key_sym_data.get(), key_sym_data_len, &out));
 324     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, "pass",
 325                                        key_sym_data.get(), key_sym_data_len, &out));
 326     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 327                                        nullptr, key_sym_data_len, &out));
 328     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 329                                        key_sym_data.get(), 0, &out));
 330     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DES, nullptr,
 331                                        key_sym_data.get(), key_sym_data_len, &out));
 332     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 333                                        inv_data2, SIZE_MAX / 2, &out));
 334
 335     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, nullptr,
 336                                        key_rsa_data.get(), key_rsa_data_len, &out));
 337     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DSA_PRIV, nullptr,
 338                                        key_rsa_data.get(), key_rsa_data_len, &out));
 339     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 340                                        key_rsa_data.get(), key_rsa_data_len - 1, &out));
 341     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 342                                        inv_data1, inv_data1_len, &out));
 343     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 344                                        inv_data2, inv_data2_len, &out));
 345
 346     /* implementation specific tests, might go away at some point */
 347     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 348                                        key_rsa_data.get(), static_cast<size_t>(INT_MAX) + 1, &out));
 349     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 350                                        key_rsa_data.get(), 3, &out));
 351 }