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 void key_gen_test(yaca_key_type_e expected_type, size_t expected_bits)
  38 {
  39     size_t bits;
  40     yaca_key_type_e type;
  41
  42     auto key_ptr = generate_key(expected_type, expected_bits);
  43
  44     YACA_SUCCESS(yaca_key_get_bit_length(key_ptr.get(), &bits));
  45     YACA_ASSERT_MSG(bits == expected_bits,
  46                     "Expected key length: " << expected_bits << " got: " << bits);
  47
  48     YACA_SUCCESS(yaca_key_get_type(key_ptr.get(), &type));
  49     YACA_ASSERT_MSG(type == expected_type,
  50                     "Expected key type: " << expected_type << " got: " << bits);
  51 }
  52
  53 void key_gen_invalid_param(yaca_key_type_e key_type,
  54                            size_t key_bit_len,
  55                            yaca_key_h *key)
  56 {
  57     YACA_INVALID_PARAM(yaca_key_generate(key_type, key_bit_len, key));
  58
  59     YACA_ASSERT_MSG(key == nullptr || *key == YACA_KEY_NULL,
  60                     "Non-empty key returned from a function that failed");
  61 }
  62
  63 void import_key_wrong_password(yaca_key_type_e key_type,
  64                                const std::string &password,
  65                                const char *data,
  66                                size_t data_len)
  67 {
  68     yaca_key_h key = YACA_KEY_NULL;
  69     std::string password_wrong = password + "!";
  70
  71     if (password.size() > 0) {
  72         YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
  73                     yaca_key_import(key_type, "", data, data_len, &key));
  74
  75         YACA_ASSERT_MSG(key == YACA_KEY_NULL,
  76                         "Non-empty key returned from a function that failed");
  77
  78         YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
  79                     yaca_key_import(key_type, nullptr, data, data_len, &key));
  80
  81         YACA_ASSERT_MSG(key == YACA_KEY_NULL,
  82                         "Non-empty key returned from a function that failed");
  83     }
  84
  85     YACA_RESULT(YACA_ERROR_INVALID_PASSWORD,
  86                 yaca_key_import(key_type, password_wrong.c_str(), data, data_len, &key));
  87
  88     YACA_ASSERT_MSG(key == YACA_KEY_NULL,
  89                     "Non-empty key returned from a function that failed");
  90 }
  91
  92 void assert_keys_equal(const KeyPtr &key1,
  93                        const KeyPtr &key2)
  94 {
  95     yaca_key_format_e key_fmt = YACA_KEY_FORMAT_DEFAULT;
  96     yaca_key_file_format_e key_file_fmt;
  97     yaca_key_type_e key1_type;
  98     yaca_key_type_e key2_type;
  99
 100     YACA_SUCCESS(yaca_key_get_type(key1.get(), &key1_type));
 101     YACA_SUCCESS(yaca_key_get_type(key2.get(), &key2_type));
 102
 103     YACA_ASSERT_MSG(key1_type == key2_type, "Key types are not equal");
 104
 105     switch(key1_type) {
 106     case YACA_KEY_TYPE_SYMMETRIC:
 107     case YACA_KEY_TYPE_DES:
 108     case YACA_KEY_TYPE_IV:
 109         key_file_fmt = YACA_KEY_FILE_FORMAT_RAW;
 110         break;
 111     case YACA_KEY_TYPE_RSA_PUB:
 112     case YACA_KEY_TYPE_RSA_PRIV:
 113     case YACA_KEY_TYPE_DSA_PUB:
 114     case YACA_KEY_TYPE_DSA_PRIV:
 115         key_file_fmt = YACA_KEY_FILE_FORMAT_DER;
 116         break;
 117     default:
 118         RUNNER_FAIL_MSG("Wrong key_type passed");
 119     }
 120
 121     size_t key1_len;
 122     ChrPtr key1_data = export_key(key1, key_fmt, key_file_fmt, nullptr, &key1_len);
 123
 124     size_t key2_len;
 125     ChrPtr key2_data = export_key(key2, key_fmt, key_file_fmt, nullptr, &key2_len);
 126
 127     YACA_ASSERT_MSG(key1_len == key2_len, "Compared keys are not of equal length");
 128     YACA_SUCCESS(yaca_memcmp(key1_data.get(), key2_data.get(), key1_len));
 129 }
 130
 131 } // anonymous namespace
 132
 133 RUNNER_TEST_GROUP_INIT(T4000_YACA_KEY);
 134
 135
 136 RUNNER_TEST(T4006_yaca_key_free)
 137 {
 138 }
 139
 140 RUNNER_TEST(T4007_yaca_key_derive_dh)
 141 {
 142 }
 143
 144 RUNNER_TEST(T4008_yaca_key_derive_kea)
 145 {
 146 }
 147
 148 RUNNER_TEST(T4009_yaca_key_derive_pbkdf2)
 149 {
 150 }
 151
 152 RUNNER_TEST(T4010_yaca_key_generate_wrong_type, YacaTest)
 153 {
 154     yaca_key_h key = YACA_KEY_NULL;
 155
 156     key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &key);
 157 }
 158
 159 RUNNER_TEST(T4020_yaca_key_generate_symmetric_invalid_param, YacaTest)
 160 {
 161     yaca_key_h key = YACA_KEY_NULL;
 162
 163     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, nullptr);
 164     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &key);
 165     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &key);
 166     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &key);
 167 }
 168
 169 RUNNER_TEST(T4030_yaca_key_generate_iv_invalid_param, YacaTest)
 170 {
 171     yaca_key_h key = YACA_KEY_NULL;
 172
 173     key_gen_invalid_param(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_256BIT, nullptr);
 174     key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &key);
 175     key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &key);
 176     key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &key);
 177 }
 178
 179 RUNNER_TEST(T4040_yaca_key_generate_des_invalid_param, YacaTest)
 180 {
 181     yaca_key_h key = YACA_KEY_NULL;
 182
 183     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, nullptr);
 184     key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &key);
 185     key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &key);
 186     key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &key);
 187     key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &key);
 188     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &key);
 189 }
 190
 191 RUNNER_TEST(T4050_yaca_key_generate_rsa_invalid_param, YacaTest)
 192 {
 193     yaca_key_h key = YACA_KEY_NULL;
 194
 195     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 196     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
 197     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 198     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &key);
 199 }
 200
 201 RUNNER_TEST(T4060_yaca_key_generate_dsa_invalid_param, YacaTest)
 202 {
 203     yaca_key_h key = YACA_KEY_NULL;
 204
 205     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
 206     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
 207     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 208     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &key);
 209     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &key);
 210     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT , &key);
 211 }
 212
 213 // ECDSA not yet implemented
 214 #if 0
 215 RUNNER_TEST(T4070_yaca_key_generate_ecdsa_invalid_param, YacaTest)
 216 {
 217     RUNNER_IGNORED_MSG("ECDSA is not supported yet");
 218     yaca_key_h key = YACA_KEY_NULL;
 219
 220     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_256BIT, nullptr);
 221     key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_CURVE_P192, &key);
 222     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
 223     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &key);
 224     key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, 193, &key);
 225 }
 226 #endif
 227
 228 RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
 229 {
 230     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8);
 231     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 72);
 232     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
 233     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 234     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 1016);
 235     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_4096BIT);
 236     key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8192);
 237 }
 238
 239 RUNNER_TEST(T4090_yaca_key_generate_iv, YacaTest)
 240 {
 241     key_gen_test(YACA_KEY_TYPE_IV, 8);
 242     key_gen_test(YACA_KEY_TYPE_IV, 72);
 243     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
 244     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_512BIT);
 245     key_gen_test(YACA_KEY_TYPE_IV, 1016);
 246     key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_4096BIT);
 247     key_gen_test(YACA_KEY_TYPE_IV, 8192);
 248 }
 249
 250 RUNNER_TEST(T4100_yaca_key_generate_des, YacaTest)
 251 {
 252     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT);
 253     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT);
 254     key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT);
 255 }
 256
 257 RUNNER_TEST(T4110_yaca_key_generate_rsa, YacaTest)
 258 {
 259     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_256BIT);
 260     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
 261     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 262     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 263     key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
 264 }
 265
 266 RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
 267 {
 268     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
 269     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 270     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
 271     key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
 272 }
 273
 274 // ECDSA not yet implemented
 275 #if 0
 276 RUNNER_TEST(T4130_yaca_key_generate_ecdsa, YacaTest)
 277 {
 278     RUNNER_IGNORED_MSG("ECDSA is not supported yet");
 279     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P192);
 280     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P256);
 281     key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P384);
 282 }
 283 #endif
 284
 285 RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
 286 {
 287     yaca_key_type_e type;
 288
 289     YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
 290
 291     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 292
 293     YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
 294 }
 295
 296 RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
 297 {
 298     size_t bits;
 299
 300     YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
 301
 302     auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
 303
 304     YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
 305 }
 306
 307 RUNNER_TEST(T4220_yaca_key_export_invalid_param, YacaTest)
 308 {
 309     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 1024);
 310     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, 1024);
 311     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 312     char *data;
 313     size_t data_len;
 314
 315     YACA_INVALID_PARAM(yaca_key_export(nullptr,
 316                                        YACA_KEY_FORMAT_DEFAULT,
 317                                        YACA_KEY_FILE_FORMAT_BASE64,
 318                                        nullptr, &data, &data_len));
 319
 320     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 321                                        YACA_KEY_FORMAT_DEFAULT,
 322                                        YACA_KEY_FILE_FORMAT_BASE64,
 323                                        nullptr, nullptr, &data_len));
 324     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 325                                        YACA_KEY_FORMAT_DEFAULT,
 326                                        YACA_KEY_FILE_FORMAT_BASE64,
 327                                        nullptr, &data, nullptr));
 328
 329     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 330                                        YACA_KEY_FORMAT_DEFAULT,
 331                                        YACA_KEY_FILE_FORMAT_BASE64,
 332                                        "pass", &data, &data_len));
 333     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 334                                        static_cast<yaca_key_format_e>(-1),
 335                                        YACA_KEY_FILE_FORMAT_BASE64,
 336                                        nullptr, &data, &data_len));
 337     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 338                                        YACA_KEY_FORMAT_DEFAULT,
 339                                        static_cast<yaca_key_file_format_e>(-1),
 340                                        nullptr, &data, &data_len));
 341     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 342                                        YACA_KEY_FORMAT_DEFAULT,
 343                                        YACA_KEY_FILE_FORMAT_PEM,
 344                                        nullptr, &data, &data_len));
 345     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 346                                        YACA_KEY_FORMAT_DEFAULT,
 347                                        YACA_KEY_FILE_FORMAT_DER,
 348                                        nullptr, &data, &data_len));
 349     YACA_INVALID_PARAM(yaca_key_export(key_sym.get(),
 350                                        YACA_KEY_FORMAT_PKCS8,
 351                                        YACA_KEY_FILE_FORMAT_PEM,
 352                                        nullptr, &data, &data_len));
 353
 354     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 355                                        static_cast<yaca_key_format_e>(-1),
 356                                        YACA_KEY_FILE_FORMAT_PEM,
 357                                        nullptr, &data, &data_len));
 358     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 359                                        YACA_KEY_FORMAT_DEFAULT,
 360                                        static_cast<yaca_key_file_format_e>(-1),
 361                                        nullptr, &data, &data_len));
 362     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 363                                        YACA_KEY_FORMAT_DEFAULT,
 364                                        YACA_KEY_FILE_FORMAT_BASE64,
 365                                        nullptr, &data, &data_len));
 366     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 367                                        YACA_KEY_FORMAT_DEFAULT,
 368                                        YACA_KEY_FILE_FORMAT_RAW,
 369                                        nullptr, &data, &data_len));
 370
 371     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 372                                        YACA_KEY_FORMAT_PKCS8,
 373                                        YACA_KEY_FILE_FORMAT_PEM,
 374                                        nullptr, &data, &data_len));
 375
 376     /* passing password with a key/format that doesn't support it */
 377     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 378                                        YACA_KEY_FORMAT_DEFAULT,
 379                                        YACA_KEY_FILE_FORMAT_DER,
 380                                        "pass", &data, &data_len));
 381     YACA_INVALID_PARAM(yaca_key_export(key_rsa_pub.get(),
 382                                        YACA_KEY_FORMAT_DEFAULT,
 383                                        YACA_KEY_FILE_FORMAT_PEM,
 384                                        "pass", &data, &data_len));
 385
 386     /* not passing a password with a format that requires it */
 387     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 388                                        YACA_KEY_FORMAT_PKCS8,
 389                                        YACA_KEY_FILE_FORMAT_PEM,
 390                                        nullptr, &data, &data_len));
 391     YACA_INVALID_PARAM(yaca_key_export(key_rsa.get(),
 392                                        YACA_KEY_FORMAT_PKCS8,
 393                                        YACA_KEY_FILE_FORMAT_PEM,
 394                                        "", &data, &data_len));
 395 }
 396
 397 RUNNER_TEST(T4230_yaca_key_import_invalid_param, YacaTest)
 398 {
 399     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 400     size_t key_sym_data_len;
 401     ChrPtr key_sym_data = export_key(key_sym, YACA_KEY_FORMAT_DEFAULT,
 402                                      YACA_KEY_FILE_FORMAT_BASE64,
 403                                      nullptr, &key_sym_data_len);
 404
 405     KeyPtr key_rsa = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 406     size_t key_rsa_data_len;
 407     ChrPtr key_rsa_data = export_key(key_rsa, YACA_KEY_FORMAT_DEFAULT,
 408                                      YACA_KEY_FILE_FORMAT_DER,
 409                                      nullptr, &key_rsa_data_len);
 410
 411     KeyPtr key_rsa_pub = extract_public_key(key_rsa);
 412     size_t key_rsa_pub_data_len;
 413     ChrPtr key_rsa_pub_data = export_key(key_rsa_pub, YACA_KEY_FORMAT_DEFAULT,
 414                                          YACA_KEY_FILE_FORMAT_PEM,
 415                                          nullptr, &key_rsa_pub_data_len);
 416
 417     const char *inv_data1 = "qwertyuiopasdfghjklzxcvbnmqwerty";
 418     size_t inv_data1_len = strlen(inv_data1);
 419     const char *inv_data2 = "--------qwertyuiopasdfghjklzxcvbnm";
 420     size_t inv_data2_len = strlen(inv_data2);
 421     yaca_key_h out;
 422
 423     YACA_INVALID_PARAM(yaca_key_import(static_cast<yaca_key_type_e>(-1), nullptr,
 424                                        key_sym_data.get(), key_sym_data_len, &out));
 425     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, "pass",
 426                                        key_sym_data.get(), key_sym_data_len, &out));
 427     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 428                                        nullptr, key_sym_data_len, &out));
 429     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 430                                        key_sym_data.get(), 0, &out));
 431     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DES, nullptr,
 432                                        key_sym_data.get(), key_sym_data_len, &out));
 433     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_SYMMETRIC, nullptr,
 434                                        inv_data2, SIZE_MAX / 2, &out));
 435
 436     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, nullptr,
 437                                        key_rsa_data.get(), key_rsa_data_len, &out));
 438     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_DSA_PRIV, nullptr,
 439                                        key_rsa_data.get(), key_rsa_data_len, &out));
 440     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 441                                        key_rsa_data.get(), key_rsa_data_len - 1, &out));
 442     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 443                                        inv_data1, inv_data1_len, &out));
 444     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 445                                        inv_data2, inv_data2_len, &out));
 446
 447     /* implementation specific tests, might go away at some point */
 448     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 449                                        key_rsa_data.get(), static_cast<size_t>(INT_MAX) + 1, &out));
 450     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, nullptr,
 451                                        key_rsa_data.get(), 3, &out));
 452
 453     /* passing password with a key/format that doesn't support it */
 454     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PRIV, "pass",
 455                                        key_rsa_data.get(), key_rsa_data_len, &out));
 456     YACA_INVALID_PARAM(yaca_key_import(YACA_KEY_TYPE_RSA_PUB, "pass",
 457                                        key_rsa_pub_data.get(), key_rsa_pub_data_len, &out));
 458 }
 459
 460 RUNNER_TEST(T4240_yaca_key_derive_pbkdf2_invalid_param, YacaTest)
 461 {
 462     yaca_key_h key;
 463
 464     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2(nullptr, "salt", 4, 1, YACA_DIGEST_MD5, 128, &key));
 465     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 4, 1, YACA_DIGEST_MD5, 128, &key));
 466     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", nullptr, 1, 1, YACA_DIGEST_MD5, 128, &key));
 467     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 0, 1, YACA_DIGEST_MD5, 128, &key));
 468     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 0, YACA_DIGEST_MD5, 128, &key));
 469     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1,
 470                                               static_cast<yaca_digest_algorithm_e>(-1),128, &key));
 471     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 0, &key));
 472     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 127, &key));
 473     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, 1, YACA_DIGEST_MD5, 128, nullptr));
 474
 475     /* implementation specific tests, might go away at some point */
 476     YACA_INVALID_PARAM(yaca_key_derive_pbkdf2("pass", "salt", 4, static_cast<size_t>(INT_MAX) + 1,
 477                                               YACA_DIGEST_MD5, 128, &key));
 478 }
 479
 480 RUNNER_TEST(T4250_yaca_key_export_import, YacaTest)
 481 {
 482     auto tvv = loadTestVector("key.txt");
 483
 484     for (const auto& tv : tvv) {
 485         yaca_key_type_e key_type;
 486         size_t key_len_bits;
 487         yaca_key_format_e key_format;
 488         yaca_key_file_format_e key_file_format;
 489         std::string password;
 490
 491         tv.get("key_type", key_type);
 492         tv.get("key_len_bits", key_len_bits);
 493         tv.get("key_format", key_format);
 494         tv.get("key_file_format", key_file_format);
 495         tv.get("password", password);
 496
 497         KeyPtr key = generate_key(key_type, key_len_bits);
 498
 499         size_t key_data_len;
 500         ChrPtr key_data = export_key(key, key_format, key_file_format, password.c_str(), &key_data_len);
 501         KeyPtr key_imp = import_key(key_type, password.c_str(), key_data.get(), key_data_len);
 502
 503         assert_keys_equal(key, key_imp);
 504
 505         /* password test for asymmetric DEFAULT PEM */
 506         if (key_format == YACA_KEY_FORMAT_DEFAULT &&
 507             (key_type == YACA_KEY_TYPE_RSA_PRIV || key_type == YACA_KEY_TYPE_DSA_PRIV) &&
 508             key_file_format == YACA_KEY_FILE_FORMAT_PEM)
 509             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 510
 511         /* password test for asymmetric PKCS8 PEM and DER */
 512         if (key_format == YACA_KEY_FORMAT_PKCS8 &&
 513             (key_type == YACA_KEY_TYPE_RSA_PRIV || key_type == YACA_KEY_TYPE_DSA_PRIV))
 514             import_key_wrong_password(key_type, password, key_data.get(), key_data_len);
 515
 516         /* public key test for asymmetric DEFAULT PEM and DER */
 517         if (key_format == YACA_KEY_FORMAT_DEFAULT &&
 518             (key_type == YACA_KEY_TYPE_RSA_PRIV || key_type == YACA_KEY_TYPE_DSA_PRIV)) {
 519             KeyPtr key_pub = extract_public_key(key);
 520             yaca_key_type_e key_pub_type = static_cast<yaca_key_type_e>(-1); // fix clang
 521
 522             switch (key_type) {
 523             case YACA_KEY_TYPE_RSA_PRIV:
 524                 key_pub_type = YACA_KEY_TYPE_RSA_PUB;
 525                 break;
 526             case YACA_KEY_TYPE_DSA_PRIV:
 527                 key_pub_type = YACA_KEY_TYPE_DSA_PUB;
 528                 break;
 529             default:
 530                 RUNNER_FAIL_MSG("Wrong key_type passed");
 531             }
 532
 533             size_t key_pub_data_len;
 534             ChrPtr key_pub_data = export_key(key_pub, key_format, key_file_format, nullptr, &key_pub_data_len);
 535             KeyPtr key_pub_imp = import_key(key_pub_type, nullptr, key_pub_data.get(), key_pub_data_len);
 536
 537             assert_keys_equal(key_pub, key_pub_imp);
 538         }
 539     }
 540 }
 541
 542 RUNNER_TEST(T4260_yaca_key_import_x509, YacaTest)
 543 {
 544     auto tvv = loadTestVector("key_x509.txt");
 545
 546     for (const auto& tv : tvv) {
 547         Buffer cert_data;
 548         Buffer pub_key_data;
 549
 550         tv.get("cert", cert_data);
 551         tv.get("pub_key", pub_key_data);
 552
 553         KeyPtr cert_key = import_key(YACA_KEY_TYPE_RSA_PUB, nullptr, cert_data.data(), cert_data.size());
 554         KeyPtr pub_key = import_key(YACA_KEY_TYPE_RSA_PUB, nullptr, pub_key_data.data(), pub_key_data.size());
 555
 556         assert_keys_equal(cert_key, pub_key);
 557     }
 558 }
 559
 560 RUNNER_TEST(T4270_yaca_key_derive_pbkdf2, YacaTest)
 561 {
 562     auto tvv = loadTestVector("key_pbkdf2.txt");
 563
 564     for (const auto& tv : tvv) {
 565         std::string password;
 566         Buffer salt;
 567         size_t iter;
 568         yaca_digest_algorithm_e algo;
 569         size_t key_bit_len;
 570         Buffer key_data;
 571
 572         tv.get("password", password);
 573         tv.get("salt", salt);
 574         tv.get("iter", iter);
 575         tv.get("algo", algo);
 576         tv.get("key_bit_len", key_bit_len);
 577         tv.get("key", key_data);
 578
 579         KeyPtr key_expected = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 580         KeyPtr key_derived = key_derive_pbkdf2(password.c_str(), salt.data(), salt.size(), iter, algo, key_bit_len);
 581
 582         assert_keys_equal(key_expected, key_derived);
 583     }
 584 }