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@samsung.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@samsung.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 #include "yaca-test-vector.h"
  34
  35 namespace {
  36
  37 bool is_key_private(yaca_key_type_e key_type)
  38 {
  39     switch (key_type) {
  40     case YACA_KEY_TYPE_RSA_PRIV:
  41     case YACA_KEY_TYPE_DSA_PRIV:
  42     case YACA_KEY_TYPE_DH_PRIV:
  43     case YACA_KEY_TYPE_EC_PRIV:
  44         return true;
  45     default:
  46         return false;
  47     }
  48 }
  49
  50 void key_gen_test(yaca_key_type_e expected_type, size_t expected_bits)
  51 {
  52     size_t bits;
  53     yaca_key_type_e type;
  54     size_t mask = 0xFFFFFFFF;
  55
  56     if (expected_type == YACA_KEY_TYPE_DH_PRIV)
  57         mask = YACA_KEYLEN_COMPONENT_DH_PRIME_MASK;
  58
  59     auto key_ptr = generate_key(expected_type, expected_bits);
  60
  61     YACA_SUCCESS(yaca_key_get_bit_length(key_ptr.get(), &bits));
  62     YACA_ASSERT_MSG(bits == (expected_bits & mask),
  63                     "Expected key length: " << expected_bits << " got: " << bits);
  64
  65     YACA_SUCCESS(yaca_key_get_type(key_ptr.get(), &type));
  66     YACA_ASSERT_MSG(type == expected_type,
  67                     "Expected key type: " << expected_type << " got: " << type);
  68
  69     bool do_params_test = false;
  70     yaca_key_type_e params_type;
  71
  72     switch (expected_type) {
  73     case YACA_KEY_TYPE_DSA_PRIV:
  74         do_params_test = true;
  75         params_type = YACA_KEY_TYPE_DSA_PARAMS;
  76         break;
  77     case YACA_KEY_TYPE_DH_PRIV:
  78         do_params_test = true;
  79         params_type = YACA_KEY_TYPE_DH_PARAMS;
  80         break;
  81     case YACA_KEY_TYPE_EC_PRIV:
  82         do_params_test = true;
  83         params_type = YACA_KEY_TYPE_EC_PARAMS;
  84         break;
  85     default:
  86         break;
  87     }
  88
  89     if (do_params_test) {
  90         auto key_params = generate_key(params_type, expected_bits);
  91
  92         YACA_SUCCESS(yaca_key_get_bit_length(key_params.get(), &bits));
  93         YACA_ASSERT_MSG(bits == (expected_bits & mask),
  94                         "Expected key length: " << expected_bits << " got: " << bits);
  95
  96         YACA_SUCCESS(yaca_key_get_type(key_params.get(), &type));
  97         YACA_ASSERT_MSG(type == params_type,
  98                         "Expected key type: " << params_type << " got: " << type);
  99
 100         auto key_prv = generate_key_from_parameters(key_params);
 101
 102         YACA_SUCCESS(yaca_key_get_bit_length(key_ptr.get(), &bits));
 103         YACA_ASSERT_MSG(bits == (expected_bits & mask),
 104                         "Expected key length: " << expected_bits << " got: " << bits);
 105
 106         YACA_SUCCESS(yaca_key_get_type(key_ptr.get(), &type));
 107         YACA_ASSERT_MSG(type == expected_type,
 108                         "Expected key type: " << expected_type << " got: " << type);
 109     }
 110 }
 111
 112 void key_gen_invalid_param(yaca_key_type_e key_type,
 113                            size_t key_bit_len,
 114                            yaca_key_h *key)
 115 {
 116     YACA_INVALID_PARAM(yaca_key_generate(key_type, key_bit_len, key));
 117
 118     YACA_ASSERT_MSG(key == nullptr || *key == YACA_KEY_NULL,
 119                     "Non-empty key returned from a function that failed");
 120 }
 121
 122 void key_gen_from_params_invalid_param(yaca_key_h params,
 123                                        yaca_key_h *key)
 124 {
 125     YACA_INVALID_PARAM(yaca_key_generate_from_parameters(params, key));
 126
 127     YACA_ASSERT_MSG(key == nullptr || *key == YACA_KEY_NULL,
 128                     "Non-empty key returned from a function that failed");
 129 }
 130
 131 void key_extract_public_invalid_param(yaca_key_h key,
 132                                       yaca_key_h *pub)
 133 {
 134     YACA_INVALID_PARAM(yaca_key_extract_public(key, pub));
 135
 136     YACA_ASSERT_MSG(pub == nullptr || *pub == YACA_KEY_NULL,
 137                     "Non-empty key returned from a function that failed");
 138 }
 139
 140 void key_extract_params_invalid_param(yaca_key_h key,
 141                                       yaca_key_h *params)
 142 {
 143     YACA_INVALID_PARAM(yaca_key_extract_parameters(key, params));
 144
 145     YACA_ASSERT_MSG(params == nullptr || *params == YACA_KEY_NULL,
 146                     "Non-empty key returned from a function that failed");
 147 }
 148
 149 void import_key_wrong_password(yaca_key_type_e key_type,
 150                                const std::string &password,
 151                                const char *data,
 152                                size_t data_len)
 153 {
 154     yaca_key_h key = YACA_KEY_NULL;
 155     std::string password_wrong = password + "!";
 156
 157     if (password.size() > 0) {
 158         YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
 159                     yaca_key_import(key_type, "", data, data_len, &key));
 160
 161         YACA_ASSERT_MSG(key == YACA_KEY_NULL,
 162                         "Non-empty key returned from a function that failed");
 163
 164         YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
 165                     yaca_key_import(key_type, nullptr, data, data_len, &key));
 166
 167         YACA_ASSERT_MSG(key == YACA_KEY_NULL,
 168                         "Non-empty key returned from a function that failed");
 169     }
 170
 171     YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
 172                 yaca_key_import(key_type, password_wrong.c_str(), data, data_len, &key));
 173
 174     YACA_ASSERT_MSG(key == YACA_KEY_NULL,
 175                     "Non-empty key returned from a function that failed");
 176 }
 177
 178 void assert_keys_equal(const KeyPtr &key1,
 179                        const KeyPtr &key2)
 180 {
 181     yaca_key_format_e key_fmt = YACA_KEY_FORMAT_DEFAULT;
 182     yaca_key_file_format_e key_file_fmt = static_cast<yaca_key_file_format_e>(-1); // fix clang
 183     yaca_key_type_e key1_type;
 184     yaca_key_type_e key2_type;
 185
 186     YACA_SUCCESS(yaca_key_get_type(key1.get(), &key1_type));
 187     YACA_SUCCESS(yaca_key_get_type(key2.get(), &key2_type));
 188
 189     YACA_ASSERT_MSG(key1_type == key2_type, "Key types are not equal");
 190
 191     switch(key1_type) {
 192     case YACA_KEY_TYPE_SYMMETRIC:
 193     case YACA_KEY_TYPE_DES:
 194     case YACA_KEY_TYPE_IV:
 195         key_file_fmt = YACA_KEY_FILE_FORMAT_RAW;
 196         break;
 197     case YACA_KEY_TYPE_RSA_PUB:
 198     case YACA_KEY_TYPE_RSA_PRIV:
 199     case YACA_KEY_TYPE_DSA_PUB:
 200     case YACA_KEY_TYPE_DSA_PRIV:
 201     case YACA_KEY_TYPE_DSA_PARAMS:
 202     case YACA_KEY_TYPE_DH_PUB:
 203     case YACA_KEY_TYPE_DH_PRIV:
 204     case YACA_KEY_TYPE_DH_PARAMS:
 205     case YACA_KEY_TYPE_EC_PUB:
 206     case YACA_KEY_TYPE_EC_PRIV:
 207     case YACA_KEY_TYPE_EC_PARAMS:
 208         key_file_fmt = YACA_KEY_FILE_FORMAT_DER;
 209         break;
 210     default:
 211         RUNNER_FAIL_MSG("Wrong key_type passed");
 212     }
 213
 214     size_t key1_len;
 215     ChrPtr key1_data = export_key(key1, key_fmt, key_file_fmt, nullptr, &key1_len);
 216
 217     size_t key2_len;
 218     ChrPtr key2_data = export_key(key2, key_fmt, key_file_fmt, nullptr, &key2_len);
 219
 220     YACA_ASSERT_MSG(key1_len == key2_len, "Compared keys are not of equal length");
 221     YACA_SUCCESS(yaca_memcmp(key1_data.get(), key2_data.get(), key1_len));
 222 }
 223
 224 } // anonymous namespace
 225
 226 RUNNER_TEST_GROUP_INIT(T4000_YACA_KEY);
 227
 228
 229 RUNNER_TEST(T4006_yaca_key_destroy, YacaTest)
 230 {
 231     yaca_key_destroy(YACA_KEY_NULL);
 232
 233     yaca_key_h key;
 234     YACA_SUCCESS(yaca_key_generate(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, &key));
 235
 236     yaca_key_destroy(key);
 237 }
 238
 239 RUNNER_TEST(T4010_yaca_key_invalid_param, YacaTest)
 240 {
 241     yaca_key_h out = YACA_KEY_NULL;
 242
 243     key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &out);
 244     key_gen_from_params_invalid_param(nullptr, &out);
 245     key_extract_public_invalid_param(nullptr, &out);
 246     key_extract_params_invalid_param(nullptr, &out);
 247 }
 248
 249 RUNNER_TEST(T4020_yaca_key_symmetric_invalid_param, YacaTest)
 250 {
 251     yaca_key_h out = YACA_KEY_NULL;
 252
 253     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, nullptr);
 254     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &out);
 255     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &out);
 256     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &out);
 257 }
 258
 259 RUNNER_TEST(T4030_yaca_key_iv_invalid_param, YacaTest)
 260 {
 261     yaca_key_h out = YACA_KEY_NULL;
 262
 263     key_gen_invalid_param(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_256BIT, nullptr);
 264     key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &out);
 265     key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &out);
 266     key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &out);
 267 }
 268
 269 RUNNER_TEST(T4040_yaca_key_des_invalid_param, YacaTest)
 270 {
 271     yaca_key_h out = YACA_KEY_NULL;
 272
 273     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, nullptr);
 274     key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &out);
 275     key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &out);
 276     key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &out);
 277     key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &out);
 278     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &out);
 279 }
 280
 281 RUNNER_TEST(T4050_yaca_key_rsa_invalid_param, YacaTest)
 282 {
 283     yaca_key_h out = YACA_KEY_NULL;
 284     KeyPtr priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 285     KeyPtr pub = extract_public_key(priv);
 286
 287     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
 288     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 289     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 290     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &out);
 291     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 292     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 293
 294     key_gen_from_params_invalid_param(priv.get(), &out);
 295     key_gen_from_params_invalid_param(pub.get(), &out);
 296
 297     key_extract_public_invalid_param(priv.get(), nullptr);
 298     key_extract_public_invalid_param(pub.get(), &out);
 299
 300     key_extract_params_invalid_param(priv.get(), &out);
 301     key_extract_params_invalid_param(pub.get(), &out);
 302 }
 303
 304 RUNNER_TEST(T4060_yaca_key_dsa_invalid_param, YacaTest)
 305 {
 306     yaca_key_h out = YACA_KEY_NULL;
 307     KeyPtr priv = generate_key(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 308     KeyPtr pub = extract_public_key(priv);
 309     KeyPtr params = extract_parameters(priv);
 310
 311     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
 312     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 313     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_1024BIT, nullptr);
 314     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 315     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 316     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &out);
 317     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1016, &out);
 318     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &out);
 319     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1023, &out);
 320     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT, &out);
 321     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_256BIT, &out);
 322     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 323     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 324     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 325     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 326
 327     key_gen_from_params_invalid_param(params.get(), nullptr);
 328     key_gen_from_params_invalid_param(priv.get(), &out);
 329     key_gen_from_params_invalid_param(pub.get(), &out);
 330
 331     key_extract_public_invalid_param(priv.get(), nullptr);
 332     key_extract_public_invalid_param(pub.get(), &out);
 333
 334     key_extract_params_invalid_param(priv.get(), nullptr);
 335     key_extract_params_invalid_param(params.get(), &out);
 336 }
 337
 338 RUNNER_TEST(T4065_yaca_key_dh_invalid_param, YacaTest)
 339 {
 340     yaca_key_h out = YACA_KEY_NULL;
 341     KeyPtr priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 342     KeyPtr pub = extract_public_key(priv);
 343     KeyPtr params = extract_parameters(priv);
 344
 345     key_gen_invalid_param(YACA_KEY_TYPE_DH_PUB, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 346     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
 347     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
 348     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_512BIT, &out);
 349     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
 350     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 351     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 352
 353     key_gen_from_params_invalid_param(params.get(), nullptr);
 354     key_gen_from_params_invalid_param(priv.get(), &out);
 355     key_gen_from_params_invalid_param(pub.get(), &out);
 356
 357     key_extract_public_invalid_param(priv.get(), nullptr);
 358     key_extract_public_invalid_param(pub.get(), &out);
 359
 360     key_extract_params_invalid_param(priv.get(), nullptr);
 361     key_extract_params_invalid_param(params.get(), &out);
 362 }
 363
 364 RUNNER_TEST(T4070_yaca_key_ec_invalid_param, YacaTest)
 365 {
 366     yaca_key_h out = YACA_KEY_NULL;
 367     KeyPtr priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 368     KeyPtr pub = extract_public_key(priv);
 369     KeyPtr params = extract_parameters(priv);
 370
 371     key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 372     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
 373     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
 374     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &out);
 375     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
 376     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 377     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 378
 379     key_gen_from_params_invalid_param(params.get(), nullptr);
 380     key_gen_from_params_invalid_param(priv.get(), &out);
 381     key_gen_from_params_invalid_param(pub.get(), &out);
 382
 383     key_extract_public_invalid_param(priv.get(), nullptr);
 384     key_extract_public_invalid_param(pub.get(), &out);
 385
 386     key_extract_params_invalid_param(priv.get(), nullptr);
 387     key_extract_params_invalid_param(params.get(), &out);
 388 }
 389
 390 RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
 391 {
 392     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8);
 393     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 72);
 394     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 24);
 395     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 396     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 1016);
 397     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_4096BIT);
 398     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8192);
 399 }
 400
 401 RUNNER_TEST(T4090_yaca_key_generate_iv, YacaTest)
 402 {
 403     key_gen_test(YACA_KEY_TYPE_IV, 8);
 404     key_gen_test(YACA_KEY_TYPE_IV, 72);
 405     key_gen_test(YACA_KEY_TYPE_IV, 24);
 406     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_512BIT);
 407     key_gen_test(YACA_KEY_TYPE_IV, 1016);
 408     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_4096BIT);
 409     key_gen_test(YACA_KEY_TYPE_IV, 8192);
 410 }
 411
 412 RUNNER_TEST(T4100_yaca_key_generate_des, YacaTest)
 413 {
 414     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT);
 415     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT);
 416     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT);
 417 }
 418
 419 RUNNER_TEST(T4110_yaca_key_generate_rsa, YacaTest)
 420 {
 421     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 422     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 423     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 424     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
 425 }
 426
 427 RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
 428 {
 429     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 430     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 431     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 432     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
 433 }
 434
 435 RUNNER_TEST(T4130_yaca_key_generate_dh, YacaTest)
 436 {
 437     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_2 | 333);
 438     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_5 | 512);
 439     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_1024_160);
 440     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 441     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 442 }
 443
 444 RUNNER_TEST(T4140_yaca_key_generate_ec, YacaTest)
 445 {
 446     // This curve doesn't work on fedora:
 447     //key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME192V1);
 448     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 449     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP256K1);
 450     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP384R1);
 451     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 452 }
 453
 454 RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
 455 {
 456     yaca_key_type_e type;
 457
 458     YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
 459
 460     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 461
 462     YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
 463 }
 464
 465 RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
 466 {
 467     size_t bits;
 468
 469     YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
 470
 471     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 472
 473     YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
 474 }
 475
 476 RUNNER_TEST(T4220_yaca_key_export_invalid_param, YacaTest)
 477 {
 478     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 1024);
 479     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, 1024);
 480     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 481     char *data;
 482     size_t data_len;
 483
 484     YACA_INVALID_PARAM(yaca_key_export(nullptr,
 485                                        YACA_KEY_FORMAT_DEFAULT,
 486                                        YACA_KEY_FILE_FORMAT_BASE64,
 487                                        nullptr, &data, &data_len));
 488
 489     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 490                                        YACA_KEY_FORMAT_DEFAULT,
 491                                        YACA_KEY_FILE_FORMAT_BASE64,
 492                                        nullptr, nullptr, &data_len));
 493     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 494                                        YACA_KEY_FORMAT_DEFAULT,
 495                                        YACA_KEY_FILE_FORMAT_BASE64,
 496                                        nullptr, &data, nullptr));
 497
 498     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 499                                        YACA_KEY_FORMAT_DEFAULT,
 500                                        YACA_KEY_FILE_FORMAT_BASE64,
 501                                        "pass", &data, &data_len));
 502     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 503                                        static_cast<yaca_key_format_e>(-1),
 504                                        YACA_KEY_FILE_FORMAT_BASE64,
 505                                        nullptr, &data, &data_len));
 506     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 507                                        YACA_KEY_FORMAT_DEFAULT,
 508                                        static_cast<yaca_key_file_format_e>(-1),
 509                                        nullptr, &data, &data_len));
 510     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 511                                        YACA_KEY_FORMAT_DEFAULT,
 512                                        YACA_KEY_FILE_FORMAT_PEM,
 513                                        nullptr, &data, &data_len));
 514     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 515                                        YACA_KEY_FORMAT_DEFAULT,
 516                                        YACA_KEY_FILE_FORMAT_DER,
 517                                        nullptr, &data, &data_len));
 518     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 519                                        YACA_KEY_FORMAT_PKCS8,
 520                                        YACA_KEY_FILE_FORMAT_PEM,
 521                                        nullptr, &data, &data_len));
 522
 523     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 524                                        static_cast<yaca_key_format_e>(-1),
 525                                        YACA_KEY_FILE_FORMAT_PEM,
 526                                        nullptr, &data, &data_len));
 527     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 528                                        YACA_KEY_FORMAT_DEFAULT,
 529                                        static_cast<yaca_key_file_format_e>(-1),
 530                                        nullptr, &data, &data_len));
 531     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 532                                        YACA_KEY_FORMAT_DEFAULT,
 533                                        YACA_KEY_FILE_FORMAT_BASE64,
 534                                        nullptr, &data, &data_len));
 535     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 536                                        YACA_KEY_FORMAT_DEFAULT,
 537                                        YACA_KEY_FILE_FORMAT_RAW,
 538                                        nullptr, &data, &data_len));
 539
 540     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 541                                        YACA_KEY_FORMAT_PKCS8,
 542                                        YACA_KEY_FILE_FORMAT_PEM,
 543                                        nullptr, &data, &data_len));
 544
 545     /* passing password with a key/format that doesn't support it */
 546     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 547                                        YACA_KEY_FORMAT_DEFAULT,
 548                                        YACA_KEY_FILE_FORMAT_DER,
 549                                        "pass", &data, &data_len));
 550     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 551                                        YACA_KEY_FORMAT_DEFAULT,
 552                                        YACA_KEY_FILE_FORMAT_PEM,
 553                                        "pass", &data, &data_len));
 554
 555     /* not passing a password with a format that requires it */
 556     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 557                                        YACA_KEY_FORMAT_PKCS8,
 558                                        YACA_KEY_FILE_FORMAT_PEM,
 559                                        nullptr, &data, &data_len));
 560     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 561                                        YACA_KEY_FORMAT_PKCS8,
 562                                        YACA_KEY_FILE_FORMAT_PEM,
 563                                        "", &data, &data_len));
 564 }
 565
 566 RUNNER_TEST(T4230_yaca_key_import_invalid_param, YacaTest)
 567 {
 568     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 569     size_t key_sym_data_len;
 570     ChrPtr key_sym_data = export_key(key_sym, YACA_KEY_FORMAT_DEFAULT,
 571                                      YACA_KEY_FILE_FORMAT_BASE64,
 572                                      nullptr, &key_sym_data_len);
 573
 574     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 575     size_t key_rsa_data_len;
 576     ChrPtr key_rsa_data = export_key(key_rsa, YACA_KEY_FORMAT_DEFAULT,
 577                                      YACA_KEY_FILE_FORMAT_DER,
 578                                      nullptr, &key_rsa_data_len);
 579
 580     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 581     size_t key_rsa_pub_data_len;
 582     ChrPtr key_rsa_pub_data = export_key(key_rsa_pub, YACA_KEY_FORMAT_DEFAULT,
 583                                          YACA_KEY_FILE_FORMAT_PEM,
 584                                          nullptr, &key_rsa_pub_data_len);
 585
 586     const char *inv_data1 = "qwertyuiopasdfghjklzxcvbnmqwerty";
 587     size_t inv_data1_len = strlen(inv_data1);
 588     const char *inv_data2 = "--------qwertyuiopasdfghjklzxcvbnm";
 589     size_t inv_data2_len = strlen(inv_data2);
 590     yaca_key_h out;
 591
 592     YACA_INVALID_PARAM(yaca_key_import(static_cast<yaca_key_type_e>(-1), nullptr,
 593                                        key_sym_data.get(), key_sym_data_len, &out));
 594     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, "pass",
 595                                        key_sym_data.get(), key_sym_data_len, &out));
 596     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 597                                        nullptr, key_sym_data_len, &out));
 598     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 599                                        key_sym_data.get(), 0, &out));
 600     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DES, nullptr,
 601                                        key_sym_data.get(), key_sym_data_len, &out));
 602     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 603                                        inv_data2, SIZE_MAX / 2, &out));
 604
 605     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, nullptr,
 606                                        key_rsa_data.get(), key_rsa_data_len, &out));
 607     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DSA_PRIV, nullptr,
 608                                        key_rsa_data.get(), key_rsa_data_len, &out));
 609     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 610                                        key_rsa_data.get(), key_rsa_data_len - 1, &out));
 611     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 612                                        inv_data1, inv_data1_len, &out));
 613     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 614                                        inv_data2, inv_data2_len, &out));
 615
 616     /* implementation specific tests, might go away at some point */
 617     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 618                                        key_rsa_data.get(), static_cast<size_t>(INT_MAX) + 1, &out));
 619     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 620                                        key_rsa_data.get(), 3, &out));
 621
 622     /* passing password with a key/format that doesn't support it */
 623     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, "pass",
 624                                        key_rsa_data.get(), key_rsa_data_len, &out));
 625     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, "pass",
 626                                        key_rsa_pub_data.get(), key_rsa_pub_data_len, &out));
 627 }
 628
 629 RUNNER_TEST(T4233_yaca_key_derive_dh_invalid_param, YacaTest)
 630 {
 631     char *secret;
 632     size_t secret_len;
 633
 634     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 635     KeyPtr key_dh_pub = extract_public_key(key_dh_priv);
 636
 637     KeyPtr key_dh_priv_2048_224 = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 638     KeyPtr key_dh_pub_2048_224 = extract_public_key(key_dh_priv_2048_224);
 639
 640     KeyPtr key_ecdh_priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 641     KeyPtr key_ecdh_pub = extract_public_key(key_ecdh_priv);
 642
 643     KeyPtr key_ecdh_priv_256V1 = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 644     KeyPtr key_ecdh_pub_256V1 = extract_public_key(key_ecdh_priv_256V1);
 645
 646     KeyPtr key_rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 647     KeyPtr key_rsa_pub = extract_public_key(key_rsa_priv);
 648
 649     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
 650
 651     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_dh_pub.get(), &secret, &secret_len));
 652     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 653     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 654     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 655     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 656     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 657     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_dh_pub.get(), &secret, &secret_len));
 658
 659     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_ecdh_pub.get(), &secret, &secret_len));
 660     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 661     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 662     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 663     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 664     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 665     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_ecdh_pub.get(), &secret, &secret_len));
 666
 667     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), null_key().get(), &secret, &secret_len));
 668     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 669     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 670     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 671     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 672     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_sym.get(), &secret, &secret_len));
 673
 674     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), null_key().get(), &secret, &secret_len));
 675     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 676     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 677     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 678     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 679     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_sym.get(), &secret, &secret_len));
 680
 681     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 682
 683     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), nullptr, &secret_len));
 684     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), nullptr, &secret_len));
 685
 686     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), &secret, nullptr));
 687     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub.get(), &secret, nullptr));
 688
 689     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub_2048_224.get(), &secret, &secret_len));
 690     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv_2048_224.get(), key_dh_pub.get(), &secret, &secret_len));
 691
 692     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub_256V1.get(), &secret, &secret_len));
 693     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv_256V1.get(), key_ecdh_pub.get(), &secret, &secret_len));
 694 }
 695
 696 RUNNER_TEST(T4236_yaca_key_derive_kdf_invalid_param, YacaTest)
 697 {
 698     yaca_kdf_e kdf = YACA_KDF_X942;
 699     yaca_digest_algorithm_e digest = YACA_DIGEST_SHA512;
 700     size_t secret_len;
 701     char *info = NULL;
 702     size_t info_len = 0;
 703     char *key_material;
 704
 705     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 706     KeyPtr peer_key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 707     KeyPtr peer_key_dh_pub = extract_public_key(peer_key_dh_priv);
 708
 709     ChrPtr secret = key_derive_dh(key_dh_priv, peer_key_dh_pub, &secret_len);
 710
 711     YACA_INVALID_PARAM(yaca_key_derive_kdf(static_cast<yaca_kdf_e>(-1),
 712                                            digest, secret.get(), secret_len, info, info_len, 512, &key_material));
 713     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, static_cast<yaca_digest_algorithm_e>(-1),
 714                                            secret.get(), secret_len, info, info_len, 512, &key_material));
 715     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, nullptr, secret_len, info, info_len, 512, &key_material));
 716     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret.get(), 0, info, info_len, 512, &key_material));
 717     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret.get(), secret_len, info, info_len, 0, &key_material));
 718     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret.get(), secret_len, info, info_len, 512, nullptr));
 719 }
 720
 721 RUNNER_TEST(T4240_yaca_key_derive_pbkdf2_invalid_param, YacaTest)
 722 {
 723     yaca_key_h key;
 724
 725     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2(nullptr, "salt", 4, 1, YACA_DIGEST_MD5, 128, &key));
 726     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 4, 1, YACA_DIGEST_MD5, 128, &key));
 727     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 1, 1, YACA_DIGEST_MD5, 128, &key));
 728     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 0, 1, YACA_DIGEST_MD5, 128, &key));
 729     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 0, YACA_DIGEST_MD5, 128, &key));
 730     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1,
 731                                               static_cast<yaca_digest_algorithm_e>(-1),128, &key));
 732     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 0, &key));
 733     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 127, &key));
 734     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 128, nullptr));
 735
 736     /* implementation specific tests, might go away at some point */
 737     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, static_cast<size_t>(INT_MAX) + 1,
 738                                               YACA_DIGEST_MD5, 128, &key));
 739 }
 740
 741 RUNNER_TEST(T4250_yaca_key_export_import, YacaTest)
 742 {
 743     auto tvv = loadTestVector("key.txt");
 744
 745     for (const auto& tv : tvv) {
 746         yaca_key_type_e key_type;
 747         size_t key_len_bits;
 748         yaca_key_format_e key_format;
 749         yaca_key_file_format_e key_file_format;
 750         std::string password;
 751
 752         tv.get("key_type", key_type);
 753         tv.get("key_len_bits", key_len_bits);
 754         tv.get("key_format", key_format);
 755         tv.get("key_file_format", key_file_format);
 756         tv.get("password", password);
 757
 758         KeyPtr key = generate_key(key_type, key_len_bits);
 759
 760         size_t key_data_len;
 761         ChrPtr key_data = export_key(key, key_format, key_file_format, password.c_str(), &key_data_len);
 762         KeyPtr key_imp = import_key(key_type, password.c_str(), key_data.get(), key_data_len);
 763
 764         assert_keys_equal(key, key_imp);
 765
 766         /* password test for asymmetric DEFAULT PEM */
 767         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type) &&
 768             key_file_format == YACA_KEY_FILE_FORMAT_PEM)
 769             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 770
 771         /* password test for asymmetric PKCS8 PEM and DER */
 772         if (key_format == YACA_KEY_FORMAT_PKCS8 && is_key_private(key_type))
 773             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 774
 775         /* public key and params test for asymmetric DEFAULT PEM and DER */
 776         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type)) {
 777             yaca_key_type_e key_pub_type = static_cast<yaca_key_type_e>(-1);
 778             yaca_key_type_e key_params_type = static_cast<yaca_key_type_e>(-1);
 779
 780             switch (key_type) {
 781             case YACA_KEY_TYPE_RSA_PRIV:
 782                 key_pub_type = YACA_KEY_TYPE_RSA_PUB;
 783                 break;
 784             case YACA_KEY_TYPE_DSA_PRIV:
 785                 key_pub_type = YACA_KEY_TYPE_DSA_PUB;
 786                 key_params_type = YACA_KEY_TYPE_DSA_PARAMS;
 787                 break;
 788             case YACA_KEY_TYPE_DH_PRIV:
 789                 key_pub_type = YACA_KEY_TYPE_DH_PUB;
 790                 key_params_type = YACA_KEY_TYPE_DH_PARAMS;
 791                 break;
 792             case YACA_KEY_TYPE_EC_PRIV:
 793                 key_pub_type = YACA_KEY_TYPE_EC_PUB;
 794                 key_params_type = YACA_KEY_TYPE_EC_PARAMS;
 795                 break;
 796             default:
 797                 RUNNER_FAIL_MSG("Wrong key_type passed");
 798             }
 799
 800             if (key_pub_type != static_cast<yaca_key_type_e>(-1)) {
 801                 KeyPtr key_pub = extract_public_key(key);
 802                 size_t key_pub_data_len;
 803                 ChrPtr key_pub_data = export_key(key_pub, key_format, key_file_format, nullptr, &key_pub_data_len);
 804                 KeyPtr key_pub_imp = import_key(key_pub_type, nullptr, key_pub_data.get(), key_pub_data_len);
 805
 806                 assert_keys_equal(key_pub, key_pub_imp);
 807             }
 808
 809             if (key_params_type != static_cast<yaca_key_type_e>(-1)) {
 810                 KeyPtr key_params = extract_parameters(key);
 811                 size_t key_params_data_len;
 812                 ChrPtr key_params_data = export_key(key_params, key_format, key_file_format, nullptr, &key_params_data_len);
 813                 KeyPtr key_params_imp = import_key(key_params_type, nullptr, key_params_data.get(), key_params_data_len);
 814
 815                 assert_keys_equal(key_params, key_params_imp);
 816             }
 817         }
 818     }
 819 }
 820
 821 RUNNER_TEST(T4260_yaca_key_import_x509, YacaTest)
 822 {
 823     auto tvv = loadTestVector("key_x509.txt");
 824
 825     for (const auto& tv : tvv) {
 826         yaca_key_type_e key_type;
 827         Buffer cert_data;
 828         Buffer pub_key_data;
 829
 830         tv.get("key_type", key_type);
 831         tv.get("cert", cert_data);
 832         tv.get("pub_key", pub_key_data);
 833
 834         KeyPtr cert_key = import_key(key_type, nullptr, cert_data.data(), cert_data.size());
 835         KeyPtr pub_key = import_key(key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 836
 837         assert_keys_equal(cert_key, pub_key);
 838     }
 839 }
 840
 841 RUNNER_TEST(T4263_yaca_key_derive_dh, YacaTest)
 842 {
 843     auto tvv = loadTestVector("key_derive_dh.txt");
 844
 845     for (const auto& tv : tvv) {
 846         yaca_key_type_e prv_key_type;
 847         Buffer prv_key_data;
 848         yaca_key_type_e pub_key_type;
 849         Buffer pub_key_data;
 850         Buffer secret_data;
 851
 852         tv.get("prv_key_type", prv_key_type);
 853         tv.get("prv_key", prv_key_data);
 854         tv.get("pub_key_type", pub_key_type);
 855         tv.get("pub_key", pub_key_data);
 856         tv.get("secret", secret_data);
 857
 858         KeyPtr prv_key = import_key(prv_key_type, nullptr, prv_key_data.data(), prv_key_data.size());
 859         KeyPtr pub_key = import_key(pub_key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 860
 861         size_t secret_len;
 862         ChrPtr derived_secret = key_derive_dh(prv_key, pub_key, &secret_len);
 863
 864         YACA_ASSERT_MSG(secret_data.size() == secret_len, "Compared secrets are not of equal length");
 865         YACA_SUCCESS(yaca_memcmp(secret_data.data(), derived_secret.get(), secret_data.size()));
 866     }
 867 }
 868
 869 RUNNER_TEST(T4266_yaca_key_derive_kdf, YacaTest)
 870 {
 871     auto tvv = loadTestVector("key_derive_kdf.txt");
 872
 873     for (const auto& tv : tvv) {
 874         yaca_kdf_e kdf;
 875         yaca_digest_algorithm_e algo;
 876         Buffer secret;
 877         Buffer info;
 878         Buffer key_material;
 879
 880         tv.get("kdf", kdf);
 881         tv.get("algo", algo);
 882         tv.get("secret", secret);
 883         tv.get("info", info);
 884         tv.get("key_material", key_material);
 885
 886         ChrPtr derived_key_material = key_derive_kdf(kdf, algo, secret.data(), secret.size(),
 887                                                      info.data(), info.size(), key_material.size());
 888
 889         YACA_SUCCESS(yaca_memcmp(key_material.data(), derived_key_material.get(), key_material.size()));
 890     }
 891 }
 892
 893 RUNNER_TEST(T4270_yaca_key_derive_pbkdf2, YacaTest)
 894 {
 895     auto tvv = loadTestVector("key_pbkdf2.txt");
 896
 897     for (const auto& tv : tvv) {
 898         std::string password;
 899         Buffer salt;
 900         size_t iter;
 901         yaca_digest_algorithm_e algo;
 902         size_t key_bit_len;
 903         Buffer key_data;
 904
 905         tv.get("password", password);
 906         tv.get("salt", salt);
 907         tv.get("iter", iter);
 908         tv.get("algo", algo);
 909         tv.get("key_bit_len", key_bit_len);
 910         tv.get("key", key_data);
 911
 912         KeyPtr key_expected = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 913         KeyPtr key_derived = key_derive_pbkdf2(password.c_str(), salt.data(), salt.size(), iter, algo, key_bit_len);
 914
 915         assert_keys_equal(key_expected, key_derived);
 916     }
 917 }