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 #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_INTERNAL_KEYLEN_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_free)
 230 {
 231 }
 232
 233 RUNNER_TEST(T4010_yaca_key_invalid_param, YacaTest)
 234 {
 235     yaca_key_h out = YACA_KEY_NULL;
 236
 237     key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &out);
 238     key_gen_from_params_invalid_param(nullptr, &out);
 239     key_extract_public_invalid_param(nullptr, &out);
 240     key_extract_params_invalid_param(nullptr, &out);
 241 }
 242
 243 RUNNER_TEST(T4020_yaca_key_symmetric_invalid_param, YacaTest)
 244 {
 245     yaca_key_h out = YACA_KEY_NULL;
 246
 247     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, nullptr);
 248     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &out);
 249     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &out);
 250     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &out);
 251 }
 252
 253 RUNNER_TEST(T4030_yaca_key_iv_invalid_param, YacaTest)
 254 {
 255     yaca_key_h out = YACA_KEY_NULL;
 256
 257     key_gen_invalid_param(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_256BIT, nullptr);
 258     key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &out);
 259     key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &out);
 260     key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &out);
 261 }
 262
 263 RUNNER_TEST(T4040_yaca_key_des_invalid_param, YacaTest)
 264 {
 265     yaca_key_h out = YACA_KEY_NULL;
 266
 267     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, nullptr);
 268     key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &out);
 269     key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &out);
 270     key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &out);
 271     key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &out);
 272     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &out);
 273 }
 274
 275 RUNNER_TEST(T4050_yaca_key_rsa_invalid_param, YacaTest)
 276 {
 277     yaca_key_h out = YACA_KEY_NULL;
 278     KeyPtr priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 279     KeyPtr pub = extract_public_key(priv);
 280
 281     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
 282     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 283     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 284     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &out);
 285     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 286     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 287
 288     key_gen_from_params_invalid_param(priv.get(), &out);
 289     key_gen_from_params_invalid_param(pub.get(), &out);
 290
 291     key_extract_public_invalid_param(priv.get(), nullptr);
 292     key_extract_public_invalid_param(pub.get(), &out);
 293
 294     key_extract_params_invalid_param(priv.get(), &out);
 295     key_extract_params_invalid_param(pub.get(), &out);
 296 }
 297
 298 RUNNER_TEST(T4060_yaca_key_dsa_invalid_param, YacaTest)
 299 {
 300     yaca_key_h out = YACA_KEY_NULL;
 301     KeyPtr priv = generate_key(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 302     KeyPtr pub = extract_public_key(priv);
 303     KeyPtr params = extract_parameters(priv);
 304
 305     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
 306     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 307     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_1024BIT, nullptr);
 308     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 309     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
 310     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &out);
 311     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1016, &out);
 312     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &out);
 313     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1023, &out);
 314     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT, &out);
 315     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_256BIT, &out);
 316     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 317     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 318     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 319     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 320
 321     key_gen_from_params_invalid_param(params.get(), nullptr);
 322     key_gen_from_params_invalid_param(priv.get(), &out);
 323     key_gen_from_params_invalid_param(pub.get(), &out);
 324
 325     key_extract_public_invalid_param(priv.get(), nullptr);
 326     key_extract_public_invalid_param(pub.get(), &out);
 327
 328     key_extract_params_invalid_param(priv.get(), nullptr);
 329     key_extract_params_invalid_param(params.get(), &out);
 330 }
 331
 332 RUNNER_TEST(T4065_yaca_key_dh_invalid_param, YacaTest)
 333 {
 334     yaca_key_h out = YACA_KEY_NULL;
 335     KeyPtr priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 336     KeyPtr pub = extract_public_key(priv);
 337     KeyPtr params = extract_parameters(priv);
 338
 339     key_gen_invalid_param(YACA_KEY_TYPE_DH_PUB, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 340     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
 341     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
 342     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_512BIT, &out);
 343     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
 344     key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 345     key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 346
 347     key_gen_from_params_invalid_param(params.get(), nullptr);
 348     key_gen_from_params_invalid_param(priv.get(), &out);
 349     key_gen_from_params_invalid_param(pub.get(), &out);
 350
 351     key_extract_public_invalid_param(priv.get(), nullptr);
 352     key_extract_public_invalid_param(pub.get(), &out);
 353
 354     key_extract_params_invalid_param(priv.get(), nullptr);
 355     key_extract_params_invalid_param(params.get(), &out);
 356 }
 357
 358 RUNNER_TEST(T4070_yaca_key_ec_invalid_param, YacaTest)
 359 {
 360     yaca_key_h out = YACA_KEY_NULL;
 361     KeyPtr priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 362     KeyPtr pub = extract_public_key(priv);
 363     KeyPtr params = extract_parameters(priv);
 364
 365     key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
 366     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
 367     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
 368     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &out);
 369     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
 370     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 371     key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
 372
 373     key_gen_from_params_invalid_param(params.get(), nullptr);
 374     key_gen_from_params_invalid_param(priv.get(), &out);
 375     key_gen_from_params_invalid_param(pub.get(), &out);
 376
 377     key_extract_public_invalid_param(priv.get(), nullptr);
 378     key_extract_public_invalid_param(pub.get(), &out);
 379
 380     key_extract_params_invalid_param(priv.get(), nullptr);
 381     key_extract_params_invalid_param(params.get(), &out);
 382 }
 383
 384 RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
 385 {
 386     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8);
 387     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 72);
 388     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 24);
 389     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 390     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 1016);
 391     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_4096BIT);
 392     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8192);
 393 }
 394
 395 RUNNER_TEST(T4090_yaca_key_generate_iv, YacaTest)
 396 {
 397     key_gen_test(YACA_KEY_TYPE_IV, 8);
 398     key_gen_test(YACA_KEY_TYPE_IV, 72);
 399     key_gen_test(YACA_KEY_TYPE_IV, 24);
 400     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_512BIT);
 401     key_gen_test(YACA_KEY_TYPE_IV, 1016);
 402     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_4096BIT);
 403     key_gen_test(YACA_KEY_TYPE_IV, 8192);
 404 }
 405
 406 RUNNER_TEST(T4100_yaca_key_generate_des, YacaTest)
 407 {
 408     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT);
 409     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT);
 410     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT);
 411 }
 412
 413 RUNNER_TEST(T4110_yaca_key_generate_rsa, YacaTest)
 414 {
 415     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_256BIT);
 416     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 417     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 418     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 419     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
 420 }
 421
 422 RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
 423 {
 424     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 425     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 426     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 427     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
 428 }
 429
 430 RUNNER_TEST(T4130_yaca_key_generate_dh, YacaTest)
 431 {
 432     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_2 | 333);
 433     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_5 | 512);
 434     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_1024_160);
 435     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 436     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 437 }
 438
 439 RUNNER_TEST(T4140_yaca_key_generate_ec, YacaTest)
 440 {
 441     // This curve doesn't work on fedora:
 442     //key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME192V1);
 443     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 444     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP256K1);
 445     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP384R1);
 446     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 447 }
 448
 449 RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
 450 {
 451     yaca_key_type_e type;
 452
 453     YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
 454
 455     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 456
 457     YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
 458 }
 459
 460 RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
 461 {
 462     size_t bits;
 463
 464     YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
 465
 466     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 467
 468     YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
 469 }
 470
 471 RUNNER_TEST(T4220_yaca_key_export_invalid_param, YacaTest)
 472 {
 473     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 1024);
 474     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, 1024);
 475     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 476     char *data;
 477     size_t data_len;
 478
 479     YACA_INVALID_PARAM(yaca_key_export(nullptr,
 480                                        YACA_KEY_FORMAT_DEFAULT,
 481                                        YACA_KEY_FILE_FORMAT_BASE64,
 482                                        nullptr, &data, &data_len));
 483
 484     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 485                                        YACA_KEY_FORMAT_DEFAULT,
 486                                        YACA_KEY_FILE_FORMAT_BASE64,
 487                                        nullptr, nullptr, &data_len));
 488     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 489                                        YACA_KEY_FORMAT_DEFAULT,
 490                                        YACA_KEY_FILE_FORMAT_BASE64,
 491                                        nullptr, &data, nullptr));
 492
 493     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 494                                        YACA_KEY_FORMAT_DEFAULT,
 495                                        YACA_KEY_FILE_FORMAT_BASE64,
 496                                        "pass", &data, &data_len));
 497     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 498                                        static_cast<yaca_key_format_e>(-1),
 499                                        YACA_KEY_FILE_FORMAT_BASE64,
 500                                        nullptr, &data, &data_len));
 501     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 502                                        YACA_KEY_FORMAT_DEFAULT,
 503                                        static_cast<yaca_key_file_format_e>(-1),
 504                                        nullptr, &data, &data_len));
 505     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 506                                        YACA_KEY_FORMAT_DEFAULT,
 507                                        YACA_KEY_FILE_FORMAT_PEM,
 508                                        nullptr, &data, &data_len));
 509     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 510                                        YACA_KEY_FORMAT_DEFAULT,
 511                                        YACA_KEY_FILE_FORMAT_DER,
 512                                        nullptr, &data, &data_len));
 513     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 514                                        YACA_KEY_FORMAT_PKCS8,
 515                                        YACA_KEY_FILE_FORMAT_PEM,
 516                                        nullptr, &data, &data_len));
 517
 518     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 519                                        static_cast<yaca_key_format_e>(-1),
 520                                        YACA_KEY_FILE_FORMAT_PEM,
 521                                        nullptr, &data, &data_len));
 522     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 523                                        YACA_KEY_FORMAT_DEFAULT,
 524                                        static_cast<yaca_key_file_format_e>(-1),
 525                                        nullptr, &data, &data_len));
 526     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 527                                        YACA_KEY_FORMAT_DEFAULT,
 528                                        YACA_KEY_FILE_FORMAT_BASE64,
 529                                        nullptr, &data, &data_len));
 530     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 531                                        YACA_KEY_FORMAT_DEFAULT,
 532                                        YACA_KEY_FILE_FORMAT_RAW,
 533                                        nullptr, &data, &data_len));
 534
 535     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 536                                        YACA_KEY_FORMAT_PKCS8,
 537                                        YACA_KEY_FILE_FORMAT_PEM,
 538                                        nullptr, &data, &data_len));
 539
 540     /* passing password with a key/format that doesn't support it */
 541     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 542                                        YACA_KEY_FORMAT_DEFAULT,
 543                                        YACA_KEY_FILE_FORMAT_DER,
 544                                        "pass", &data, &data_len));
 545     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 546                                        YACA_KEY_FORMAT_DEFAULT,
 547                                        YACA_KEY_FILE_FORMAT_PEM,
 548                                        "pass", &data, &data_len));
 549
 550     /* not passing a password with a format that requires it */
 551     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 552                                        YACA_KEY_FORMAT_PKCS8,
 553                                        YACA_KEY_FILE_FORMAT_PEM,
 554                                        nullptr, &data, &data_len));
 555     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 556                                        YACA_KEY_FORMAT_PKCS8,
 557                                        YACA_KEY_FILE_FORMAT_PEM,
 558                                        "", &data, &data_len));
 559 }
 560
 561 RUNNER_TEST(T4230_yaca_key_import_invalid_param, YacaTest)
 562 {
 563     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 564     size_t key_sym_data_len;
 565     ChrPtr key_sym_data = export_key(key_sym, YACA_KEY_FORMAT_DEFAULT,
 566                                      YACA_KEY_FILE_FORMAT_BASE64,
 567                                      nullptr, &key_sym_data_len);
 568
 569     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 570     size_t key_rsa_data_len;
 571     ChrPtr key_rsa_data = export_key(key_rsa, YACA_KEY_FORMAT_DEFAULT,
 572                                      YACA_KEY_FILE_FORMAT_DER,
 573                                      nullptr, &key_rsa_data_len);
 574
 575     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 576     size_t key_rsa_pub_data_len;
 577     ChrPtr key_rsa_pub_data = export_key(key_rsa_pub, YACA_KEY_FORMAT_DEFAULT,
 578                                          YACA_KEY_FILE_FORMAT_PEM,
 579                                          nullptr, &key_rsa_pub_data_len);
 580
 581     const char *inv_data1 = "qwertyuiopasdfghjklzxcvbnmqwerty";
 582     size_t inv_data1_len = strlen(inv_data1);
 583     const char *inv_data2 = "--------qwertyuiopasdfghjklzxcvbnm";
 584     size_t inv_data2_len = strlen(inv_data2);
 585     yaca_key_h out;
 586
 587     YACA_INVALID_PARAM(yaca_key_import(static_cast<yaca_key_type_e>(-1), nullptr,
 588                                        key_sym_data.get(), key_sym_data_len, &out));
 589     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, "pass",
 590                                        key_sym_data.get(), key_sym_data_len, &out));
 591     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 592                                        nullptr, key_sym_data_len, &out));
 593     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 594                                        key_sym_data.get(), 0, &out));
 595     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DES, nullptr,
 596                                        key_sym_data.get(), key_sym_data_len, &out));
 597     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 598                                        inv_data2, SIZE_MAX / 2, &out));
 599
 600     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, nullptr,
 601                                        key_rsa_data.get(), key_rsa_data_len, &out));
 602     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DSA_PRIV, nullptr,
 603                                        key_rsa_data.get(), key_rsa_data_len, &out));
 604     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 605                                        key_rsa_data.get(), key_rsa_data_len - 1, &out));
 606     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 607                                        inv_data1, inv_data1_len, &out));
 608     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 609                                        inv_data2, inv_data2_len, &out));
 610
 611     /* implementation specific tests, might go away at some point */
 612     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 613                                        key_rsa_data.get(), static_cast<size_t>(INT_MAX) + 1, &out));
 614     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 615                                        key_rsa_data.get(), 3, &out));
 616
 617     /* passing password with a key/format that doesn't support it */
 618     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, "pass",
 619                                        key_rsa_data.get(), key_rsa_data_len, &out));
 620     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, "pass",
 621                                        key_rsa_pub_data.get(), key_rsa_pub_data_len, &out));
 622 }
 623
 624 RUNNER_TEST(T4233_yaca_key_derive_dh_invalid_param, YacaTest)
 625 {
 626     char *secret;
 627     size_t secret_len;
 628
 629     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 630     KeyPtr key_dh_pub = extract_public_key(key_dh_priv);
 631
 632     KeyPtr key_dh_priv_2048_224 = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 633     KeyPtr key_dh_pub_2048_224 = extract_public_key(key_dh_priv_2048_224);
 634
 635     KeyPtr key_ecdh_priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 636     KeyPtr key_ecdh_pub = extract_public_key(key_ecdh_priv);
 637
 638     KeyPtr key_ecdh_priv_256V1 = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 639     KeyPtr key_ecdh_pub_256V1 = extract_public_key(key_ecdh_priv_256V1);
 640
 641     KeyPtr key_rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 642     KeyPtr key_rsa_pub = extract_public_key(key_rsa_priv);
 643
 644     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
 645
 646     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_dh_pub.get(), &secret, &secret_len));
 647     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 648     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 649     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 650     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 651     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 652     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_dh_pub.get(), &secret, &secret_len));
 653
 654     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_ecdh_pub.get(), &secret, &secret_len));
 655     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 656     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 657     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 658     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 659     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 660     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_ecdh_pub.get(), &secret, &secret_len));
 661
 662     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), null_key().get(), &secret, &secret_len));
 663     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 664     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 665     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 666     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 667     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_sym.get(), &secret, &secret_len));
 668
 669     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), null_key().get(), &secret, &secret_len));
 670     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 671     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 672     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 673     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 674     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_sym.get(), &secret, &secret_len));
 675
 676     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 677
 678     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), nullptr, &secret_len));
 679     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), nullptr, &secret_len));
 680
 681     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), &secret, nullptr));
 682     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub.get(), &secret, nullptr));
 683
 684     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub_2048_224.get(), &secret, &secret_len));
 685     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv_2048_224.get(), key_dh_pub.get(), &secret, &secret_len));
 686
 687     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub_256V1.get(), &secret, &secret_len));
 688     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv_256V1.get(), key_ecdh_pub.get(), &secret, &secret_len));
 689 }
 690
 691 RUNNER_TEST(T4236_yaca_key_derive_kdf_invalid_param, YacaTest)
 692 {
 693     yaca_kdf_e kdf = YACA_KDF_X942;
 694     yaca_digest_algorithm_e digest = YACA_DIGEST_SHA512;
 695     char *secret;
 696     size_t secret_len;
 697     char *info = NULL;
 698     size_t info_len = 0;
 699     char *key_material;
 700
 701     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 702     KeyPtr peer_key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 703     KeyPtr peer_key_dh_pub = extract_public_key(peer_key_dh_priv);
 704
 705     YACA_SUCCESS(yaca_key_derive_dh(key_dh_priv.get(), peer_key_dh_pub.get(), &secret, &secret_len));
 706
 707     YACA_INVALID_PARAM(yaca_key_derive_kdf(static_cast<yaca_kdf_e>(-1),
 708                                            digest, secret, secret_len, info, info_len, 512, &key_material));
 709     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, static_cast<yaca_digest_algorithm_e>(-1),
 710                                            secret, secret_len, info, info_len, 512, &key_material));
 711     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, nullptr, secret_len, info, info_len, 512, &key_material));
 712     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, 0, info, info_len, 512, &key_material));
 713     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, secret_len, info, info_len, 0, &key_material));
 714     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, secret_len, info, info_len, 512, nullptr));
 715 }
 716
 717 RUNNER_TEST(T4240_yaca_key_derive_pbkdf2_invalid_param, YacaTest)
 718 {
 719     yaca_key_h key;
 720
 721     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2(nullptr, "salt", 4, 1, YACA_DIGEST_MD5, 128, &key));
 722     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 4, 1, YACA_DIGEST_MD5, 128, &key));
 723     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 1, 1, YACA_DIGEST_MD5, 128, &key));
 724     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 0, 1, YACA_DIGEST_MD5, 128, &key));
 725     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 0, YACA_DIGEST_MD5, 128, &key));
 726     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1,
 727                                               static_cast<yaca_digest_algorithm_e>(-1),128, &key));
 728     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 0, &key));
 729     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 127, &key));
 730     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 128, nullptr));
 731
 732     /* implementation specific tests, might go away at some point */
 733     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, static_cast<size_t>(INT_MAX) + 1,
 734                                               YACA_DIGEST_MD5, 128, &key));
 735 }
 736
 737 RUNNER_TEST(T4250_yaca_key_export_import, YacaTest)
 738 {
 739     auto tvv = loadTestVector("key.txt");
 740
 741     for (const auto& tv : tvv) {
 742         yaca_key_type_e key_type;
 743         size_t key_len_bits;
 744         yaca_key_format_e key_format;
 745         yaca_key_file_format_e key_file_format;
 746         std::string password;
 747
 748         tv.get("key_type", key_type);
 749         tv.get("key_len_bits", key_len_bits);
 750         tv.get("key_format", key_format);
 751         tv.get("key_file_format", key_file_format);
 752         tv.get("password", password);
 753
 754         KeyPtr key = generate_key(key_type, key_len_bits);
 755
 756         size_t key_data_len;
 757         ChrPtr key_data = export_key(key, key_format, key_file_format, password.c_str(), &key_data_len);
 758         KeyPtr key_imp = import_key(key_type, password.c_str(), key_data.get(), key_data_len);
 759
 760         assert_keys_equal(key, key_imp);
 761
 762         /* password test for asymmetric DEFAULT PEM */
 763         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type) &&
 764             key_file_format == YACA_KEY_FILE_FORMAT_PEM)
 765             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 766
 767         /* password test for asymmetric PKCS8 PEM and DER */
 768         if (key_format == YACA_KEY_FORMAT_PKCS8 && is_key_private(key_type))
 769             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 770
 771         /* public key and params test for asymmetric DEFAULT PEM and DER */
 772         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type)) {
 773             yaca_key_type_e key_pub_type = static_cast<yaca_key_type_e>(-1);
 774             yaca_key_type_e key_params_type = static_cast<yaca_key_type_e>(-1);
 775
 776             switch (key_type) {
 777             case YACA_KEY_TYPE_RSA_PRIV:
 778                 key_pub_type = YACA_KEY_TYPE_RSA_PUB;
 779                 break;
 780             case YACA_KEY_TYPE_DSA_PRIV:
 781                 key_pub_type = YACA_KEY_TYPE_DSA_PUB;
 782                 key_params_type = YACA_KEY_TYPE_DSA_PARAMS;
 783                 break;
 784             case YACA_KEY_TYPE_DH_PRIV:
 785                 key_pub_type = YACA_KEY_TYPE_DH_PUB;
 786                 key_params_type = YACA_KEY_TYPE_DH_PARAMS;
 787                 break;
 788             case YACA_KEY_TYPE_EC_PRIV:
 789                 key_pub_type = YACA_KEY_TYPE_EC_PUB;
 790                 key_params_type = YACA_KEY_TYPE_EC_PARAMS;
 791                 break;
 792             default:
 793                 RUNNER_FAIL_MSG("Wrong key_type passed");
 794             }
 795
 796             if (key_pub_type != static_cast<yaca_key_type_e>(-1)) {
 797                 KeyPtr key_pub = extract_public_key(key);
 798                 size_t key_pub_data_len;
 799                 ChrPtr key_pub_data = export_key(key_pub, key_format, key_file_format, nullptr, &key_pub_data_len);
 800                 KeyPtr key_pub_imp = import_key(key_pub_type, nullptr, key_pub_data.get(), key_pub_data_len);
 801
 802                 assert_keys_equal(key_pub, key_pub_imp);
 803             }
 804
 805             if (key_params_type != static_cast<yaca_key_type_e>(-1)) {
 806                 KeyPtr key_params = extract_parameters(key);
 807                 size_t key_params_data_len;
 808                 ChrPtr key_params_data = export_key(key_params, key_format, key_file_format, nullptr, &key_params_data_len);
 809                 KeyPtr key_params_imp = import_key(key_params_type, nullptr, key_params_data.get(), key_params_data_len);
 810
 811                 assert_keys_equal(key_params, key_params_imp);
 812             }
 813         }
 814     }
 815 }
 816
 817 RUNNER_TEST(T4260_yaca_key_import_x509, YacaTest)
 818 {
 819     auto tvv = loadTestVector("key_x509.txt");
 820
 821     for (const auto& tv : tvv) {
 822         yaca_key_type_e key_type;
 823         Buffer cert_data;
 824         Buffer pub_key_data;
 825
 826         tv.get("key_type", key_type);
 827         tv.get("cert", cert_data);
 828         tv.get("pub_key", pub_key_data);
 829
 830         KeyPtr cert_key = import_key(key_type, nullptr, cert_data.data(), cert_data.size());
 831         KeyPtr pub_key = import_key(key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 832
 833         assert_keys_equal(cert_key, pub_key);
 834     }
 835 }
 836
 837 RUNNER_TEST(T4263_yaca_key_derive_dh, YacaTest)
 838 {
 839     auto tvv = loadTestVector("key_derive_dh.txt");
 840
 841     for (const auto& tv : tvv) {
 842         yaca_key_type_e prv_key_type;
 843         Buffer prv_key_data;
 844         yaca_key_type_e pub_key_type;
 845         Buffer pub_key_data;
 846         Buffer secret_data;
 847
 848         tv.get("prv_key_type", prv_key_type);
 849         tv.get("prv_key", prv_key_data);
 850         tv.get("pub_key_type", pub_key_type);
 851         tv.get("pub_key", pub_key_data);
 852         tv.get("secret", secret_data);
 853
 854         KeyPtr prv_key = import_key(prv_key_type, nullptr, prv_key_data.data(), prv_key_data.size());
 855         KeyPtr pub_key = import_key(pub_key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 856
 857         size_t secret_len;
 858         ChrPtr derived_secret = key_derive_dh(prv_key, pub_key, &secret_len);
 859
 860         YACA_ASSERT_MSG(secret_data.size() == secret_len, "Compared secrets are not of equal length");
 861         YACA_SUCCESS(yaca_memcmp(secret_data.data(), derived_secret.get(), secret_data.size()));
 862     }
 863 }
 864
 865 RUNNER_TEST(T4266_yaca_key_derive_kdf, YacaTest)
 866 {
 867     auto tvv = loadTestVector("key_derive_kdf.txt");
 868
 869     for (const auto& tv : tvv) {
 870         yaca_kdf_e kdf;
 871         yaca_digest_algorithm_e algo;
 872         Buffer secret;
 873         Buffer info;
 874         Buffer key_material;
 875
 876         tv.get("kdf", kdf);
 877         tv.get("algo", algo);
 878         tv.get("secret", secret);
 879         tv.get("info", info);
 880         tv.get("key_material", key_material);
 881
 882         ChrPtr derived_key_material = key_derive_kdf(kdf, algo, secret.data(), secret.size(),
 883                                                      info.data(), info.size(), key_material.size());
 884
 885         YACA_SUCCESS(yaca_memcmp(key_material.data(), derived_key_material.get(), key_material.size()));
 886     }
 887 }
 888
 889 RUNNER_TEST(T4270_yaca_key_derive_pbkdf2, YacaTest)
 890 {
 891     auto tvv = loadTestVector("key_pbkdf2.txt");
 892
 893     for (const auto& tv : tvv) {
 894         std::string password;
 895         Buffer salt;
 896         size_t iter;
 897         yaca_digest_algorithm_e algo;
 898         size_t key_bit_len;
 899         Buffer key_data;
 900
 901         tv.get("password", password);
 902         tv.get("salt", salt);
 903         tv.get("iter", iter);
 904         tv.get("algo", algo);
 905         tv.get("key_bit_len", key_bit_len);
 906         tv.get("key", key_data);
 907
 908         KeyPtr key_expected = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 909         KeyPtr key_derived = key_derive_pbkdf2(password.c_str(), salt.data(), salt.size(), iter, algo, key_bit_len);
 910
 911         assert_keys_equal(key_expected, key_derived);
 912     }
 913 }