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_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_256BIT);
 422     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 423     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 424     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 425     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
 426 }
 427
 428 RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
 429 {
 430     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 431     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 432     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 433     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
 434 }
 435
 436 RUNNER_TEST(T4130_yaca_key_generate_dh, YacaTest)
 437 {
 438     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_2 | 333);
 439     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_GENERATOR_5 | 512);
 440     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_1024_160);
 441     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 442     key_gen_test(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 443 }
 444
 445 RUNNER_TEST(T4140_yaca_key_generate_ec, YacaTest)
 446 {
 447     // This curve doesn't work on fedora:
 448     //key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME192V1);
 449     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 450     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP256K1);
 451     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP384R1);
 452     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 453 }
 454
 455 RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
 456 {
 457     yaca_key_type_e type;
 458
 459     YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
 460
 461     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 462
 463     YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
 464 }
 465
 466 RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
 467 {
 468     size_t bits;
 469
 470     YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
 471
 472     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 473
 474     YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
 475 }
 476
 477 RUNNER_TEST(T4220_yaca_key_export_invalid_param, YacaTest)
 478 {
 479     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 1024);
 480     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, 1024);
 481     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 482     char *data;
 483     size_t data_len;
 484
 485     YACA_INVALID_PARAM(yaca_key_export(nullptr,
 486                                        YACA_KEY_FORMAT_DEFAULT,
 487                                        YACA_KEY_FILE_FORMAT_BASE64,
 488                                        nullptr, &data, &data_len));
 489
 490     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 491                                        YACA_KEY_FORMAT_DEFAULT,
 492                                        YACA_KEY_FILE_FORMAT_BASE64,
 493                                        nullptr, nullptr, &data_len));
 494     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 495                                        YACA_KEY_FORMAT_DEFAULT,
 496                                        YACA_KEY_FILE_FORMAT_BASE64,
 497                                        nullptr, &data, nullptr));
 498
 499     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 500                                        YACA_KEY_FORMAT_DEFAULT,
 501                                        YACA_KEY_FILE_FORMAT_BASE64,
 502                                        "pass", &data, &data_len));
 503     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 504                                        static_cast<yaca_key_format_e>(-1),
 505                                        YACA_KEY_FILE_FORMAT_BASE64,
 506                                        nullptr, &data, &data_len));
 507     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 508                                        YACA_KEY_FORMAT_DEFAULT,
 509                                        static_cast<yaca_key_file_format_e>(-1),
 510                                        nullptr, &data, &data_len));
 511     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 512                                        YACA_KEY_FORMAT_DEFAULT,
 513                                        YACA_KEY_FILE_FORMAT_PEM,
 514                                        nullptr, &data, &data_len));
 515     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 516                                        YACA_KEY_FORMAT_DEFAULT,
 517                                        YACA_KEY_FILE_FORMAT_DER,
 518                                        nullptr, &data, &data_len));
 519     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 520                                        YACA_KEY_FORMAT_PKCS8,
 521                                        YACA_KEY_FILE_FORMAT_PEM,
 522                                        nullptr, &data, &data_len));
 523
 524     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 525                                        static_cast<yaca_key_format_e>(-1),
 526                                        YACA_KEY_FILE_FORMAT_PEM,
 527                                        nullptr, &data, &data_len));
 528     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 529                                        YACA_KEY_FORMAT_DEFAULT,
 530                                        static_cast<yaca_key_file_format_e>(-1),
 531                                        nullptr, &data, &data_len));
 532     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 533                                        YACA_KEY_FORMAT_DEFAULT,
 534                                        YACA_KEY_FILE_FORMAT_BASE64,
 535                                        nullptr, &data, &data_len));
 536     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 537                                        YACA_KEY_FORMAT_DEFAULT,
 538                                        YACA_KEY_FILE_FORMAT_RAW,
 539                                        nullptr, &data, &data_len));
 540
 541     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 542                                        YACA_KEY_FORMAT_PKCS8,
 543                                        YACA_KEY_FILE_FORMAT_PEM,
 544                                        nullptr, &data, &data_len));
 545
 546     /* passing password with a key/format that doesn't support it */
 547     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 548                                        YACA_KEY_FORMAT_DEFAULT,
 549                                        YACA_KEY_FILE_FORMAT_DER,
 550                                        "pass", &data, &data_len));
 551     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 552                                        YACA_KEY_FORMAT_DEFAULT,
 553                                        YACA_KEY_FILE_FORMAT_PEM,
 554                                        "pass", &data, &data_len));
 555
 556     /* not passing a password with a format that requires it */
 557     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 558                                        YACA_KEY_FORMAT_PKCS8,
 559                                        YACA_KEY_FILE_FORMAT_PEM,
 560                                        nullptr, &data, &data_len));
 561     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 562                                        YACA_KEY_FORMAT_PKCS8,
 563                                        YACA_KEY_FILE_FORMAT_PEM,
 564                                        "", &data, &data_len));
 565 }
 566
 567 RUNNER_TEST(T4230_yaca_key_import_invalid_param, YacaTest)
 568 {
 569     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 570     size_t key_sym_data_len;
 571     ChrPtr key_sym_data = export_key(key_sym, YACA_KEY_FORMAT_DEFAULT,
 572                                      YACA_KEY_FILE_FORMAT_BASE64,
 573                                      nullptr, &key_sym_data_len);
 574
 575     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 576     size_t key_rsa_data_len;
 577     ChrPtr key_rsa_data = export_key(key_rsa, YACA_KEY_FORMAT_DEFAULT,
 578                                      YACA_KEY_FILE_FORMAT_DER,
 579                                      nullptr, &key_rsa_data_len);
 580
 581     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 582     size_t key_rsa_pub_data_len;
 583     ChrPtr key_rsa_pub_data = export_key(key_rsa_pub, YACA_KEY_FORMAT_DEFAULT,
 584                                          YACA_KEY_FILE_FORMAT_PEM,
 585                                          nullptr, &key_rsa_pub_data_len);
 586
 587     const char *inv_data1 = "qwertyuiopasdfghjklzxcvbnmqwerty";
 588     size_t inv_data1_len = strlen(inv_data1);
 589     const char *inv_data2 = "--------qwertyuiopasdfghjklzxcvbnm";
 590     size_t inv_data2_len = strlen(inv_data2);
 591     yaca_key_h out;
 592
 593     YACA_INVALID_PARAM(yaca_key_import(static_cast<yaca_key_type_e>(-1), nullptr,
 594                                        key_sym_data.get(), key_sym_data_len, &out));
 595     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, "pass",
 596                                        key_sym_data.get(), key_sym_data_len, &out));
 597     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 598                                        nullptr, key_sym_data_len, &out));
 599     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 600                                        key_sym_data.get(), 0, &out));
 601     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DES, nullptr,
 602                                        key_sym_data.get(), key_sym_data_len, &out));
 603     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 604                                        inv_data2, SIZE_MAX / 2, &out));
 605
 606     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, nullptr,
 607                                        key_rsa_data.get(), key_rsa_data_len, &out));
 608     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DSA_PRIV, nullptr,
 609                                        key_rsa_data.get(), key_rsa_data_len, &out));
 610     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 611                                        key_rsa_data.get(), key_rsa_data_len - 1, &out));
 612     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 613                                        inv_data1, inv_data1_len, &out));
 614     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 615                                        inv_data2, inv_data2_len, &out));
 616
 617     /* implementation specific tests, might go away at some point */
 618     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 619                                        key_rsa_data.get(), static_cast<size_t>(INT_MAX) + 1, &out));
 620     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 621                                        key_rsa_data.get(), 3, &out));
 622
 623     /* passing password with a key/format that doesn't support it */
 624     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, "pass",
 625                                        key_rsa_data.get(), key_rsa_data_len, &out));
 626     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, "pass",
 627                                        key_rsa_pub_data.get(), key_rsa_pub_data_len, &out));
 628 }
 629
 630 RUNNER_TEST(T4233_yaca_key_derive_dh_invalid_param, YacaTest)
 631 {
 632     char *secret;
 633     size_t secret_len;
 634
 635     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 636     KeyPtr key_dh_pub = extract_public_key(key_dh_priv);
 637
 638     KeyPtr key_dh_priv_2048_224 = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_224);
 639     KeyPtr key_dh_pub_2048_224 = extract_public_key(key_dh_priv_2048_224);
 640
 641     KeyPtr key_ecdh_priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP521R1);
 642     KeyPtr key_ecdh_pub = extract_public_key(key_ecdh_priv);
 643
 644     KeyPtr key_ecdh_priv_256V1 = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
 645     KeyPtr key_ecdh_pub_256V1 = extract_public_key(key_ecdh_priv_256V1);
 646
 647     KeyPtr key_rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 648     KeyPtr key_rsa_pub = extract_public_key(key_rsa_priv);
 649
 650     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
 651
 652     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_dh_pub.get(), &secret, &secret_len));
 653     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 654     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 655     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 656     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_dh_pub.get(), &secret, &secret_len));
 657     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_dh_pub.get(), &secret, &secret_len));
 658     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_dh_pub.get(), &secret, &secret_len));
 659
 660     YACA_INVALID_PARAM(yaca_key_derive_dh(null_key().get(), key_ecdh_pub.get(), &secret, &secret_len));
 661     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 662     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 663     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 664     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_ecdh_pub.get(), &secret, &secret_len));
 665     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_pub.get(), key_ecdh_pub.get(), &secret, &secret_len));
 666     YACA_INVALID_PARAM(yaca_key_derive_dh(key_sym.get(), key_ecdh_pub.get(), &secret, &secret_len));
 667
 668     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), null_key().get(), &secret, &secret_len));
 669     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 670     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 671     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 672     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 673     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_sym.get(), &secret, &secret_len));
 674
 675     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), null_key().get(), &secret, &secret_len));
 676     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_dh_priv.get(), &secret, &secret_len));
 677     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), &secret, &secret_len));
 678     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_priv.get(), &secret, &secret_len));
 679     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 680     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_sym.get(), &secret, &secret_len));
 681
 682     YACA_INVALID_PARAM(yaca_key_derive_dh(key_rsa_priv.get(), key_rsa_pub.get(), &secret, &secret_len));
 683
 684     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), nullptr, &secret_len));
 685     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_priv.get(), nullptr, &secret_len));
 686
 687     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub.get(), &secret, nullptr));
 688     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub.get(), &secret, nullptr));
 689
 690     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv.get(), key_dh_pub_2048_224.get(), &secret, &secret_len));
 691     YACA_INVALID_PARAM(yaca_key_derive_dh(key_dh_priv_2048_224.get(), key_dh_pub.get(), &secret, &secret_len));
 692
 693     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv.get(), key_ecdh_pub_256V1.get(), &secret, &secret_len));
 694     YACA_INVALID_PARAM(yaca_key_derive_dh(key_ecdh_priv_256V1.get(), key_ecdh_pub.get(), &secret, &secret_len));
 695 }
 696
 697 RUNNER_TEST(T4236_yaca_key_derive_kdf_invalid_param, YacaTest)
 698 {
 699     yaca_kdf_e kdf = YACA_KDF_X942;
 700     yaca_digest_algorithm_e digest = YACA_DIGEST_SHA512;
 701     char *secret;
 702     size_t secret_len;
 703     char *info = NULL;
 704     size_t info_len = 0;
 705     char *key_material;
 706
 707     KeyPtr key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 708     KeyPtr peer_key_dh_priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
 709     KeyPtr peer_key_dh_pub = extract_public_key(peer_key_dh_priv);
 710
 711     YACA_SUCCESS(yaca_key_derive_dh(key_dh_priv.get(), peer_key_dh_pub.get(), &secret, &secret_len));
 712
 713     YACA_INVALID_PARAM(yaca_key_derive_kdf(static_cast<yaca_kdf_e>(-1),
 714                                            digest, secret, secret_len, info, info_len, 512, &key_material));
 715     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, static_cast<yaca_digest_algorithm_e>(-1),
 716                                            secret, secret_len, info, info_len, 512, &key_material));
 717     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, nullptr, secret_len, info, info_len, 512, &key_material));
 718     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, 0, info, info_len, 512, &key_material));
 719     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, secret_len, info, info_len, 0, &key_material));
 720     YACA_INVALID_PARAM(yaca_key_derive_kdf(kdf, digest, secret, secret_len, info, info_len, 512, nullptr));
 721 }
 722
 723 RUNNER_TEST(T4240_yaca_key_derive_pbkdf2_invalid_param, YacaTest)
 724 {
 725     yaca_key_h key;
 726
 727     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2(nullptr, "salt", 4, 1, YACA_DIGEST_MD5, 128, &key));
 728     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 4, 1, YACA_DIGEST_MD5, 128, &key));
 729     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 1, 1, YACA_DIGEST_MD5, 128, &key));
 730     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 0, 1, YACA_DIGEST_MD5, 128, &key));
 731     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 0, YACA_DIGEST_MD5, 128, &key));
 732     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1,
 733                                               static_cast<yaca_digest_algorithm_e>(-1),128, &key));
 734     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 0, &key));
 735     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 127, &key));
 736     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 128, nullptr));
 737
 738     /* implementation specific tests, might go away at some point */
 739     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, static_cast<size_t>(INT_MAX) + 1,
 740                                               YACA_DIGEST_MD5, 128, &key));
 741 }
 742
 743 RUNNER_TEST(T4250_yaca_key_export_import, YacaTest)
 744 {
 745     auto tvv = loadTestVector("key.txt");
 746
 747     for (const auto& tv : tvv) {
 748         yaca_key_type_e key_type;
 749         size_t key_len_bits;
 750         yaca_key_format_e key_format;
 751         yaca_key_file_format_e key_file_format;
 752         std::string password;
 753
 754         tv.get("key_type", key_type);
 755         tv.get("key_len_bits", key_len_bits);
 756         tv.get("key_format", key_format);
 757         tv.get("key_file_format", key_file_format);
 758         tv.get("password", password);
 759
 760         KeyPtr key = generate_key(key_type, key_len_bits);
 761
 762         size_t key_data_len;
 763         ChrPtr key_data = export_key(key, key_format, key_file_format, password.c_str(), &key_data_len);
 764         KeyPtr key_imp = import_key(key_type, password.c_str(), key_data.get(), key_data_len);
 765
 766         assert_keys_equal(key, key_imp);
 767
 768         /* password test for asymmetric DEFAULT PEM */
 769         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type) &&
 770             key_file_format == YACA_KEY_FILE_FORMAT_PEM)
 771             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 772
 773         /* password test for asymmetric PKCS8 PEM and DER */
 774         if (key_format == YACA_KEY_FORMAT_PKCS8 && is_key_private(key_type))
 775             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 776
 777         /* public key and params test for asymmetric DEFAULT PEM and DER */
 778         if (key_format == YACA_KEY_FORMAT_DEFAULT && is_key_private(key_type)) {
 779             yaca_key_type_e key_pub_type = static_cast<yaca_key_type_e>(-1);
 780             yaca_key_type_e key_params_type = static_cast<yaca_key_type_e>(-1);
 781
 782             switch (key_type) {
 783             case YACA_KEY_TYPE_RSA_PRIV:
 784                 key_pub_type = YACA_KEY_TYPE_RSA_PUB;
 785                 break;
 786             case YACA_KEY_TYPE_DSA_PRIV:
 787                 key_pub_type = YACA_KEY_TYPE_DSA_PUB;
 788                 key_params_type = YACA_KEY_TYPE_DSA_PARAMS;
 789                 break;
 790             case YACA_KEY_TYPE_DH_PRIV:
 791                 key_pub_type = YACA_KEY_TYPE_DH_PUB;
 792                 key_params_type = YACA_KEY_TYPE_DH_PARAMS;
 793                 break;
 794             case YACA_KEY_TYPE_EC_PRIV:
 795                 key_pub_type = YACA_KEY_TYPE_EC_PUB;
 796                 key_params_type = YACA_KEY_TYPE_EC_PARAMS;
 797                 break;
 798             default:
 799                 RUNNER_FAIL_MSG("Wrong key_type passed");
 800             }
 801
 802             if (key_pub_type != static_cast<yaca_key_type_e>(-1)) {
 803                 KeyPtr key_pub = extract_public_key(key);
 804                 size_t key_pub_data_len;
 805                 ChrPtr key_pub_data = export_key(key_pub, key_format, key_file_format, nullptr, &key_pub_data_len);
 806                 KeyPtr key_pub_imp = import_key(key_pub_type, nullptr, key_pub_data.get(), key_pub_data_len);
 807
 808                 assert_keys_equal(key_pub, key_pub_imp);
 809             }
 810
 811             if (key_params_type != static_cast<yaca_key_type_e>(-1)) {
 812                 KeyPtr key_params = extract_parameters(key);
 813                 size_t key_params_data_len;
 814                 ChrPtr key_params_data = export_key(key_params, key_format, key_file_format, nullptr, &key_params_data_len);
 815                 KeyPtr key_params_imp = import_key(key_params_type, nullptr, key_params_data.get(), key_params_data_len);
 816
 817                 assert_keys_equal(key_params, key_params_imp);
 818             }
 819         }
 820     }
 821 }
 822
 823 RUNNER_TEST(T4260_yaca_key_import_x509, YacaTest)
 824 {
 825     auto tvv = loadTestVector("key_x509.txt");
 826
 827     for (const auto& tv : tvv) {
 828         yaca_key_type_e key_type;
 829         Buffer cert_data;
 830         Buffer pub_key_data;
 831
 832         tv.get("key_type", key_type);
 833         tv.get("cert", cert_data);
 834         tv.get("pub_key", pub_key_data);
 835
 836         KeyPtr cert_key = import_key(key_type, nullptr, cert_data.data(), cert_data.size());
 837         KeyPtr pub_key = import_key(key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 838
 839         assert_keys_equal(cert_key, pub_key);
 840     }
 841 }
 842
 843 RUNNER_TEST(T4263_yaca_key_derive_dh, YacaTest)
 844 {
 845     auto tvv = loadTestVector("key_derive_dh.txt");
 846
 847     for (const auto& tv : tvv) {
 848         yaca_key_type_e prv_key_type;
 849         Buffer prv_key_data;
 850         yaca_key_type_e pub_key_type;
 851         Buffer pub_key_data;
 852         Buffer secret_data;
 853
 854         tv.get("prv_key_type", prv_key_type);
 855         tv.get("prv_key", prv_key_data);
 856         tv.get("pub_key_type", pub_key_type);
 857         tv.get("pub_key", pub_key_data);
 858         tv.get("secret", secret_data);
 859
 860         KeyPtr prv_key = import_key(prv_key_type, nullptr, prv_key_data.data(), prv_key_data.size());
 861         KeyPtr pub_key = import_key(pub_key_type, nullptr, pub_key_data.data(), pub_key_data.size());
 862
 863         size_t secret_len;
 864         ChrPtr derived_secret = key_derive_dh(prv_key, pub_key, &secret_len);
 865
 866         YACA_ASSERT_MSG(secret_data.size() == secret_len, "Compared secrets are not of equal length");
 867         YACA_SUCCESS(yaca_memcmp(secret_data.data(), derived_secret.get(), secret_data.size()));
 868     }
 869 }
 870
 871 RUNNER_TEST(T4266_yaca_key_derive_kdf, YacaTest)
 872 {
 873     auto tvv = loadTestVector("key_derive_kdf.txt");
 874
 875     for (const auto& tv : tvv) {
 876         yaca_kdf_e kdf;
 877         yaca_digest_algorithm_e algo;
 878         Buffer secret;
 879         Buffer info;
 880         Buffer key_material;
 881
 882         tv.get("kdf", kdf);
 883         tv.get("algo", algo);
 884         tv.get("secret", secret);
 885         tv.get("info", info);
 886         tv.get("key_material", key_material);
 887
 888         ChrPtr derived_key_material = key_derive_kdf(kdf, algo, secret.data(), secret.size(),
 889                                                      info.data(), info.size(), key_material.size());
 890
 891         YACA_SUCCESS(yaca_memcmp(key_material.data(), derived_key_material.get(), key_material.size()));
 892     }
 893 }
 894
 895 RUNNER_TEST(T4270_yaca_key_derive_pbkdf2, YacaTest)
 896 {
 897     auto tvv = loadTestVector("key_pbkdf2.txt");
 898
 899     for (const auto& tv : tvv) {
 900         std::string password;
 901         Buffer salt;
 902         size_t iter;
 903         yaca_digest_algorithm_e algo;
 904         size_t key_bit_len;
 905         Buffer key_data;
 906
 907         tv.get("password", password);
 908         tv.get("salt", salt);
 909         tv.get("iter", iter);
 910         tv.get("algo", algo);
 911         tv.get("key_bit_len", key_bit_len);
 912         tv.get("key", key_data);
 913
 914         KeyPtr key_expected = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 915         KeyPtr key_derived = key_derive_pbkdf2(password.c_str(), salt.data(), salt.size(), iter, algo, key_bit_len);
 916
 917         assert_keys_equal(key_expected, key_derived);
 918     }
 919 }