tests/mock_test_key.cpp

   1 /*
   2  *  Copyright (c) 2020-2022 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Lukasz Pawelczyk <l.pawelczyk@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file    test_key.cpp
  21  * @author  Lukasz Pawelczyk <l.pawelczyk@samsung.com>
  22  * @brief   Key API unit tests.
  23  */
  24
  25 #include <boost/test/unit_test.hpp>
  26 #include <vector>
  27
  28 #include <yaca_crypto.h>
  29 #include <yaca_encrypt.h>
  30 #include <yaca_key.h>
  31 #include <yaca_simple.h>
  32 #include <yaca_error.h>
  33
  34 #include "common.h"
  35
  36
  37 namespace {
  38
  39 int import_export(yaca_key_h key, yaca_key_type_e type, const char *password,
  40                                   yaca_key_format_e format, yaca_key_file_format_e file_format)
  41 {
  42         int ret;
  43         yaca_key_h imported = YACA_KEY_NULL;
  44
  45         char *data = NULL;
  46         size_t data_len = 0;
  47         yaca_key_type_e key_type;
  48         size_t key_length;
  49
  50         ret = yaca_key_export(key, format, file_format,
  51                                                   password, &data, &data_len);
  52         if (ret != YACA_ERROR_NONE) goto exit;
  53
  54         ret = yaca_key_import(type, password, data, data_len, &imported);
  55         if (ret != YACA_ERROR_NONE) goto exit;
  56
  57         ret = yaca_key_get_type(imported, &key_type);
  58         if (ret != YACA_ERROR_NONE) goto exit;
  59         ret = yaca_key_get_bit_length(imported, &key_length);
  60         if (ret != YACA_ERROR_NONE) goto exit;
  61
  62 exit:
  63         yaca_key_destroy(imported);
  64         yaca_free(data);
  65         return ret;
  66 }
  67
  68 } // namespace
  69
  70
  71 BOOST_AUTO_TEST_SUITE(MOCK_TESTS_KEY)
  72
  73 BOOST_FIXTURE_TEST_CASE(T1201__mock__negative__key_symmetric_all, InitFixture)
  74 {
  75         struct key_args {
  76                 yaca_key_type_e type;
  77                 yaca_key_bit_length_e len;
  78         };
  79
  80         const std::vector<struct key_args> kargs = {
  81                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT},
  82                 {YACA_KEY_TYPE_DES,       YACA_KEY_LENGTH_192BIT},
  83                 {YACA_KEY_TYPE_IV,        YACA_KEY_LENGTH_IV_64BIT}
  84         };
  85
  86         for (const auto &ka: kargs) {
  87                 auto test_code = [&ka]()
  88                         {
  89                                 int ret;
  90                                 yaca_key_h key = YACA_KEY_NULL;
  91
  92                                 ret = yaca_key_generate(ka.type, ka.len, &key);
  93                                 if (ret != YACA_ERROR_NONE) goto exit;
  94
  95                                 ret = import_export(key, ka.type, "",
  96                                                                         YACA_KEY_FORMAT_DEFAULT,
  97                                                                         YACA_KEY_FILE_FORMAT_RAW);
  98                                 if (ret != YACA_ERROR_NONE) goto exit;
  99
 100                                 ret = import_export(key, ka.type, "",
 101                                                                         YACA_KEY_FORMAT_DEFAULT,
 102                                                                         YACA_KEY_FILE_FORMAT_BASE64);
 103                                 if (ret != YACA_ERROR_NONE) goto exit;
 104
 105                         exit:
 106                                 yaca_key_destroy(key);
 107                                 return ret;
 108                         };
 109
 110                 call_mock_test(test_code);
 111         }
 112 }
 113
 114 BOOST_FIXTURE_TEST_CASE(T1202__mock__negative__key_asymmetric_generate_all, InitFixture)
 115 {
 116         struct key_args {
 117                 yaca_key_type_e type_priv;
 118                 yaca_key_type_e type_pub;
 119                 yaca_key_type_e type_params;
 120                 yaca_key_bit_length_e len;
 121         };
 122
 123         const std::vector<struct key_args> kargs = {
 124                 {YACA_KEY_TYPE_RSA_PRIV,
 125                  YACA_KEY_TYPE_RSA_PUB,
 126                  YACA_INVALID_KEY_TYPE,
 127                  YACA_KEY_LENGTH_512BIT},
 128                 {YACA_KEY_TYPE_DSA_PRIV,
 129                  YACA_KEY_TYPE_DSA_PUB,
 130                  YACA_KEY_TYPE_DSA_PARAMS,
 131                  YACA_KEY_LENGTH_512BIT},
 132                 {YACA_KEY_TYPE_DH_PRIV,
 133                  YACA_KEY_TYPE_DH_PUB,
 134                  YACA_KEY_TYPE_DH_PARAMS,
 135                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_DH_RFC_1024_160},
 136                 {YACA_KEY_TYPE_EC_PRIV,
 137                  YACA_KEY_TYPE_EC_PUB,
 138                  YACA_KEY_TYPE_EC_PARAMS,
 139                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_PRIME192V1}
 140         };
 141
 142         for (const auto &ka: kargs) {
 143                 auto test_code = [&ka]()
 144                         {
 145                                 int ret;
 146                                 yaca_key_h priv = YACA_KEY_NULL;
 147                                 yaca_key_h priv2 = YACA_KEY_NULL;
 148                                 yaca_key_h pub = YACA_KEY_NULL;
 149                                 yaca_key_h params = YACA_KEY_NULL;
 150                                 yaca_key_h params2 = YACA_KEY_NULL;
 151
 152                                 ret = yaca_key_generate(ka.type_priv, ka.len, &priv);
 153                                 if (ret != YACA_ERROR_NONE) goto exit;
 154
 155                                 ret = yaca_key_extract_public(priv, &pub);
 156                                 if (ret != YACA_ERROR_NONE) goto exit;
 157
 158                                 if (ka.type_params != YACA_INVALID_KEY_TYPE) {
 159                                         ret = yaca_key_generate(ka.type_params, ka.len, &params);
 160                                         if (ret != YACA_ERROR_NONE) goto exit;
 161
 162                                         ret = yaca_key_generate_from_parameters(params, &priv2);
 163                                         if (ret != YACA_ERROR_NONE) goto exit;
 164
 165                                         ret = yaca_key_extract_parameters(pub, &params2);
 166                                         if (ret != YACA_ERROR_NONE) goto exit;
 167                                 }
 168
 169                         exit:
 170                                 yaca_key_destroy(params);
 171                                 yaca_key_destroy(params2);
 172                                 yaca_key_destroy(priv);
 173                                 yaca_key_destroy(priv2);
 174                                 yaca_key_destroy(pub);
 175                                 return ret;
 176                         };
 177
 178                 call_mock_test(test_code);
 179         }
 180 }
 181
 182 BOOST_FIXTURE_TEST_CASE(T1204__mock__negative__key_asymmetric_import_export, InitFixture)
 183 {
 184         struct key_args {
 185                 yaca_key_type_e type_priv;
 186                 yaca_key_type_e type_pub;
 187                 yaca_key_type_e type_params;
 188                 yaca_key_bit_length_e len;
 189         };
 190
 191         const std::vector<struct key_args> kargs = {
 192                 {YACA_KEY_TYPE_RSA_PRIV,
 193                  YACA_KEY_TYPE_RSA_PUB,
 194                  YACA_INVALID_KEY_TYPE,
 195                  YACA_KEY_LENGTH_512BIT},
 196                 {YACA_KEY_TYPE_DSA_PRIV,
 197                  YACA_KEY_TYPE_DSA_PUB,
 198                  YACA_KEY_TYPE_DSA_PARAMS,
 199                  YACA_KEY_LENGTH_512BIT},
 200                 {YACA_KEY_TYPE_EC_PRIV,
 201                  YACA_KEY_TYPE_EC_PUB,
 202                  YACA_KEY_TYPE_EC_PARAMS,
 203                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_PRIME192V1},
 204                 {YACA_KEY_TYPE_DH_PRIV,
 205                  YACA_KEY_TYPE_DH_PUB,
 206                  YACA_KEY_TYPE_DH_PARAMS,
 207                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_DH_RFC_1024_160},
 208         };
 209
 210         for (const auto &ka: kargs) {
 211                 auto test_code = [&ka]()
 212                         {
 213                                 int ret;
 214                                 yaca_key_h key_priv = YACA_KEY_NULL;
 215                                 yaca_key_h key_pub = YACA_KEY_NULL;
 216                                 yaca_key_h key_params = YACA_KEY_NULL;
 217
 218                                 ret = yaca_key_generate(ka.type_priv, ka.len, &key_priv);
 219                                 if (ret != YACA_ERROR_NONE) goto exit;
 220
 221                                 ret = import_export(key_priv, ka.type_priv, NULL,
 222                                                                         YACA_KEY_FORMAT_DEFAULT,
 223                                                                         YACA_KEY_FILE_FORMAT_DER);
 224                                 if (ret != YACA_ERROR_NONE) goto exit;
 225
 226                                 ret = import_export(key_priv, ka.type_priv, NULL,
 227                                                                         YACA_KEY_FORMAT_DEFAULT,
 228                                                                         YACA_KEY_FILE_FORMAT_PEM);
 229                                 if (ret != YACA_ERROR_NONE) goto exit;
 230
 231                                 ret = yaca_key_extract_public(key_priv, &key_pub);
 232                                 if (ret != YACA_ERROR_NONE) goto exit;
 233
 234                                 ret = import_export(key_pub, ka.type_pub, "",
 235                                                                         YACA_KEY_FORMAT_DEFAULT,
 236                                                                         YACA_KEY_FILE_FORMAT_DER);
 237                                 if (ret != YACA_ERROR_NONE) goto exit;
 238
 239                                 ret = import_export(key_pub, ka.type_pub, "",
 240                                                                         YACA_KEY_FORMAT_DEFAULT,
 241                                                                         YACA_KEY_FILE_FORMAT_PEM);
 242                                 if (ret != YACA_ERROR_NONE) goto exit;
 243
 244                                 if (ka.type_params != YACA_INVALID_KEY_TYPE) {
 245                                         ret = yaca_key_extract_parameters(key_priv, &key_params);
 246                                         if (ret != YACA_ERROR_NONE) goto exit;
 247
 248                                         ret = import_export(key_params, ka.type_params, NULL,
 249                                                                                 YACA_KEY_FORMAT_DEFAULT,
 250                                                                                 YACA_KEY_FILE_FORMAT_DER);
 251                                         if (ret != YACA_ERROR_NONE) goto exit;
 252
 253                                         ret = import_export(key_params, ka.type_params, NULL,
 254                                                                                 YACA_KEY_FORMAT_DEFAULT,
 255                                                                                 YACA_KEY_FILE_FORMAT_PEM);
 256                                         if (ret != YACA_ERROR_NONE) goto exit;
 257                                 }
 258
 259                         exit:
 260                                 yaca_key_destroy(key_params);
 261                                 yaca_key_destroy(key_priv);
 262                                 yaca_key_destroy(key_pub);
 263                                 return ret;
 264                         };
 265
 266                 call_mock_test(test_code);
 267         }
 268 }
 269
 270 BOOST_FIXTURE_TEST_CASE(T1205__mock__negative__key_encrypted_import_export, InitFixture)
 271 {
 272         static const char *PASSWORD = "ExamplE_PassworD";
 273
 274         struct default_args {
 275                 yaca_key_type_e type;
 276                 yaca_key_bit_length_e len;
 277         };
 278
 279         const std::vector<struct default_args> dargs = {
 280                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT},
 281                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT}
 282         };
 283
 284         for (const auto &da: dargs) {
 285                 auto test_code = [&da]()
 286                         {
 287                                 int ret;
 288                                 yaca_key_h key = YACA_KEY_NULL;
 289
 290                                 ret = yaca_key_generate(da.type, da.len, &key);
 291                                 if (ret != YACA_ERROR_NONE) goto exit;
 292
 293                                 ret = import_export(key, da.type, PASSWORD,
 294                                                                         YACA_KEY_FORMAT_DEFAULT,
 295                                                                         YACA_KEY_FILE_FORMAT_PEM);
 296                                 if (ret != YACA_ERROR_NONE) goto exit;
 297
 298                         exit:
 299                                 yaca_key_destroy(key);
 300                                 return ret;
 301                         };
 302
 303                 call_mock_test(test_code);
 304         }
 305
 306         struct pkcs8_args {
 307                 yaca_key_type_e type;
 308                 yaca_key_bit_length_e len;
 309         };
 310
 311         const std::vector<struct pkcs8_args> pargs {
 312                 {YACA_KEY_TYPE_RSA_PRIV,
 313                  YACA_KEY_LENGTH_512BIT},
 314                 {YACA_KEY_TYPE_DSA_PRIV,
 315                  YACA_KEY_LENGTH_512BIT},
 316                 {YACA_KEY_TYPE_EC_PRIV,
 317                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_PRIME256V1},
 318                 {YACA_KEY_TYPE_DH_PRIV,
 319                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_DH_RFC_1024_160},
 320         };
 321
 322         for (const auto &pa: pargs) {
 323                 auto test_code2 = [&pa]()
 324                         {
 325                                 int ret;
 326                                 yaca_key_h key = YACA_KEY_NULL;
 327
 328                                 ret = yaca_key_generate(pa.type, pa.len, &key);
 329                                 if (ret != YACA_ERROR_NONE) goto exit;
 330
 331                                 ret = import_export(key, pa.type, PASSWORD,
 332                                                                         YACA_KEY_FORMAT_PKCS8,
 333                                                                         YACA_KEY_FILE_FORMAT_DER);
 334                                 if (ret != YACA_ERROR_NONE) goto exit;
 335
 336                                 ret = import_export(key, pa.type, PASSWORD,
 337                                                                         YACA_KEY_FORMAT_PKCS8,
 338                                                                         YACA_KEY_FILE_FORMAT_PEM);
 339                                 if (ret != YACA_ERROR_NONE) goto exit;
 340
 341                         exit:
 342                                 yaca_key_destroy(key);
 343                                 return ret;
 344                         };
 345
 346                 call_mock_test(test_code2);
 347         }
 348 }
 349
 350 BOOST_FIXTURE_TEST_CASE(T1206__mock__negative__key_derive_dh, InitFixture)
 351 {
 352         struct key_args {
 353                 yaca_key_type_e type;
 354                 yaca_key_bit_length_e len;
 355         };
 356
 357         const std::vector<struct key_args> kargs = {
 358                 {YACA_KEY_TYPE_DH_PRIV,
 359                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_DH_RFC_1024_160},
 360                 {YACA_KEY_TYPE_EC_PRIV,
 361                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_SECP256K1}
 362         };
 363
 364         for (const auto &ka: kargs) {
 365                 auto test_code = [&ka]()
 366                         {
 367                                 int ret;
 368                                 yaca_key_h priv1 = YACA_KEY_NULL, pub1 = YACA_KEY_NULL;
 369                                 yaca_key_h priv2 = YACA_KEY_NULL, pub2 = YACA_KEY_NULL;
 370                                 char *secret1 = NULL, *secret2 = NULL;
 371                                 size_t secret1_len, secret2_len;
 372
 373                                 ret = yaca_key_generate(ka.type, ka.len, &priv1);
 374                                 if (ret != YACA_ERROR_NONE) goto exit;
 375                                 ret = yaca_key_generate(ka.type, ka.len, &priv2);
 376                                 if (ret != YACA_ERROR_NONE) goto exit;
 377                                 ret = yaca_key_extract_public(priv1, &pub1);
 378                                 if (ret != YACA_ERROR_NONE) goto exit;
 379                                 ret = yaca_key_extract_public(priv2, &pub2);
 380                                 if (ret != YACA_ERROR_NONE) goto exit;
 381
 382                                 ret = yaca_key_derive_dh(priv1, pub2, &secret1, &secret1_len);
 383                                 if (ret != YACA_ERROR_NONE) goto exit;
 384                                 ret = yaca_key_derive_dh(priv2, pub1, &secret2, &secret2_len);
 385                                 if (ret != YACA_ERROR_NONE) goto exit;
 386
 387                         exit:
 388                                 yaca_key_destroy(priv1);
 389                                 yaca_key_destroy(priv2);
 390                                 yaca_key_destroy(pub1);
 391                                 yaca_key_destroy(pub2);
 392                                 yaca_free(secret1);
 393                                 yaca_free(secret2);
 394                                 return ret;
 395                         };
 396
 397                 call_mock_test(test_code);
 398         }
 399 }
 400
 401 BOOST_FIXTURE_TEST_CASE(T1207__mock__negative__key_derive_kdf, InitFixture)
 402 {
 403         static const size_t SECRET_LEN = 128;
 404         static const size_t MATERIAL_LEN = 256;
 405
 406         struct kdf_args {
 407                 yaca_kdf_e kdf;
 408                 yaca_digest_algorithm_e digest;
 409         };
 410
 411         const std::vector<struct kdf_args> kargs = {
 412                 {YACA_KDF_X942, YACA_DIGEST_SHA1},
 413                 {YACA_KDF_X962, YACA_DIGEST_MD5}
 414         };
 415
 416         int ret;
 417         char secret[SECRET_LEN];
 418
 419         ret = yaca_randomize_bytes(secret, SECRET_LEN);
 420         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 421
 422         for (const auto &ka: kargs) {
 423                 auto test_code = [&ka, &secret]()
 424                         {
 425                                 int ret_derive;
 426                                 char *key_material = NULL;;
 427
 428                                 ret_derive = yaca_key_derive_kdf(ka.kdf, ka.digest, secret, SECRET_LEN,
 429                                                                                                  NULL, 0, MATERIAL_LEN, &key_material);
 430
 431                                 yaca_free(key_material);
 432                                 return ret_derive;
 433                         };
 434
 435                 call_mock_test(test_code);
 436         }
 437 }
 438
 439 BOOST_FIXTURE_TEST_CASE(T1208__mock__negative__key_derive_pbkdf2, InitFixture)
 440 {
 441         static const char *PASSWORD = "Password_ExamplE";
 442         static const size_t SALT_LEN = 64;
 443
 444         struct pbkdf2_args {
 445                 yaca_digest_algorithm_e digest;
 446                 size_t iter;
 447                 size_t bit_len;
 448         };
 449
 450         const std::vector<struct pbkdf2_args> pargs = {
 451                 {YACA_DIGEST_MD5,     1, 256},
 452                 {YACA_DIGEST_SHA512, 50, 512}
 453         };
 454
 455         int ret;
 456         char salt[SALT_LEN];
 457
 458         ret = yaca_randomize_bytes(salt, SALT_LEN);
 459         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 460
 461         for (const auto &pa: pargs) {
 462                 auto test_code = [&pa, &salt]()
 463                         {
 464                                 int ret_derive;
 465                                 yaca_key_h key = YACA_KEY_NULL;
 466
 467                                 ret_derive = yaca_key_derive_pbkdf2(PASSWORD, salt, SALT_LEN, pa.iter,
 468                                                                                                         pa.digest, pa.bit_len, &key);
 469
 470                                 yaca_key_destroy(key);
 471                                 return ret_derive;
 472                         };
 473
 474                 call_mock_test(test_code);
 475         }
 476 }
 477
 478 BOOST_FIXTURE_TEST_CASE(T1209__mock__negative__import_x509_cert, InitFixture)
 479 {
 480         static const char data_pem[] = "-----BEGIN CERTIFICATE-----\n\
 481 MIIC9jCCAl+gAwIBAgIUaWM7DVy/evvsrKz8gkz3qWZKw7EwDQYJKoZIhvcNAQEL\n\
 482 BQAwgYwxCzAJBgNVBAYTAlBMMRQwEgYDVQQIDAtNYXpvd2llY2tpZTERMA8GA1UE\n\
 483 BwwIV2Fyc3phd2ExEDAOBgNVBAoMB1NhbXN1bmcxCzAJBgNVBAsMAklUMRQwEgYD\n\
 484 VQQDDAtzYW1zdW5nLmNvbTEfMB0GCSqGSIb3DQEJARYQbm9uZUBzYW1zdW5nLmNv\n\
 485 bTAeFw0yMDA0MDkxNzUzMDlaFw0yNTA0MDgxNzUzMDlaMIGMMQswCQYDVQQGEwJQ\n\
 486 TDEUMBIGA1UECAwLTWF6b3dpZWNraWUxETAPBgNVBAcMCFdhcnN6YXdhMRAwDgYD\n\
 487 VQQKDAdTYW1zdW5nMQswCQYDVQQLDAJJVDEUMBIGA1UEAwwLc2Ftc3VuZy5jb20x\n\
 488 HzAdBgkqhkiG9w0BCQEWEG5vbmVAc2Ftc3VuZy5jb20wgZ8wDQYJKoZIhvcNAQEB\n\
 489 BQADgY0AMIGJAoGBAMrx4VdcBEWSXdOa7nJr6Vh53TDfnqhgOGRUC8c+kGUu45Cp\n\
 490 hcGU7q44zfqvEdgkVBK+Y6GBMrbB0TALo2zK4RVDIgTc8UskbiBjiP4cHB+Zl460\n\
 491 kU/0vKZPWt7yWq9g87lppEr/f0RTGrKkkcVadCxmKILr4ZtS9563xXH+kKAlAgMB\n\
 492 AAGjUzBRMB0GA1UdDgQWBBQBroKxSi+l6RqOD5jQGRYyoM0I1jAfBgNVHSMEGDAW\n\
 493 gBQBroKxSi+l6RqOD5jQGRYyoM0I1jAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3\n\
 494 DQEBCwUAA4GBAC1f+n4ly876nTXMjdINH8qmxrHOH55vt7v1KYWqCVFSJbqtQMlT\n\
 495 E9+bqRGN2LpzMBkDdNkGSrCesI1l/FUStjqdpBGMi1fqFDNDyBXkLJDH5HAMR3ei\n\
 496 hajHIasdGWcAfj+Cyuk1KcTIEkBfdYR6a8C4g04Vbg6M0qEjFl5UTMwm\n\
 497 -----END CERTIFICATE-----";
 498
 499         /* THIS CHUNK OF BYTES IS AUTOMATICALLY GENERATED */
 500         static const unsigned char data_der[] = {
 501                 0x30, 0x82, 0x02, 0xf2, 0x30, 0x82, 0x02, 0x5b, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x3e,
 502                 0x03, 0xd9, 0x79, 0x86, 0xae, 0xa4, 0x85, 0x59, 0xd6, 0x2b, 0x53, 0x29, 0xee, 0xfd, 0x2c, 0x26,
 503                 0xe8, 0x72, 0x57, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
 504                 0x05, 0x00, 0x30, 0x81, 0x8a, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02,
 505                 0x50, 0x4c, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0b, 0x4d, 0x61, 0x7a,
 506                 0x6f, 0x77, 0x69, 0x65, 0x63, 0x6b, 0x69, 0x65, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04,
 507                 0x07, 0x0c, 0x06, 0x57, 0x61, 0x72, 0x73, 0x61, 0x77, 0x31, 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55,
 508                 0x04, 0x0a, 0x0c, 0x07, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x31, 0x0b, 0x30, 0x09, 0x06,
 509                 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x02, 0x49, 0x54, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04,
 510                 0x03, 0x0c, 0x0b, 0x73, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x1f,
 511                 0x30, 0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x10, 0x6e,
 512                 0x6f, 0x6e, 0x65, 0x40, 0x73, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x2e, 0x63, 0x6f, 0x6d, 0x30,
 513                 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x30, 0x34, 0x31, 0x34, 0x31, 0x35, 0x32, 0x33, 0x30, 0x37, 0x5a,
 514                 0x17, 0x0d, 0x32, 0x31, 0x30, 0x34, 0x31, 0x34, 0x31, 0x35, 0x32, 0x33, 0x30, 0x37, 0x5a, 0x30,
 515                 0x81, 0x8a, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x50, 0x4c, 0x31,
 516                 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0b, 0x4d, 0x61, 0x7a, 0x6f, 0x77, 0x69,
 517                 0x65, 0x63, 0x6b, 0x69, 0x65, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x06,
 518                 0x57, 0x61, 0x72, 0x73, 0x61, 0x77, 0x31, 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c,
 519                 0x07, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 520                 0x0b, 0x0c, 0x02, 0x49, 0x54, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0b,
 521                 0x73, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x1f, 0x30, 0x1d, 0x06,
 522                 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x10, 0x6e, 0x6f, 0x6e, 0x65,
 523                 0x40, 0x73, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x81, 0x9f, 0x30,
 524                 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81,
 525                 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xc9, 0x73, 0x11, 0x8f, 0x63, 0x4d, 0xaa,
 526                 0x8e, 0xc5, 0xb5, 0x6d, 0x9c, 0xea, 0x30, 0x43, 0xb5, 0x5d, 0xd3, 0xb2, 0x9c, 0x59, 0x23, 0xdf,
 527                 0xa8, 0x69, 0xe6, 0x0d, 0xfe, 0x0a, 0xdb, 0xce, 0x22, 0x64, 0x15, 0x02, 0xf6, 0xa4, 0xe9, 0x22,
 528                 0x04, 0xce, 0x73, 0x9e, 0x89, 0x1e, 0x87, 0x93, 0x31, 0x07, 0x91, 0x0e, 0xbd, 0x98, 0x45, 0x3d,
 529                 0x66, 0xe9, 0x59, 0x02, 0xfc, 0x2f, 0xd9, 0x11, 0x71, 0xc4, 0x11, 0x3f, 0x20, 0xf3, 0x49, 0xb6,
 530                 0x59, 0x26, 0xb2, 0x8c, 0x9f, 0x74, 0xe0, 0x09, 0x3b, 0x4f, 0xdd, 0xf4, 0x13, 0x8b, 0x91, 0x48,
 531                 0x1e, 0x1b, 0xf5, 0x86, 0xca, 0xe6, 0xd6, 0x1d, 0x29, 0x74, 0x1d, 0xb6, 0x84, 0x0b, 0x48, 0xe7,
 532                 0x40, 0x14, 0x60, 0x65, 0xb2, 0x35, 0xf0, 0x48, 0xe9, 0x93, 0xea, 0x77, 0x63, 0x77, 0x53, 0x77,
 533                 0xaf, 0xbb, 0xac, 0xc2, 0x86, 0x40, 0xc7, 0xb0, 0x0b, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53,
 534                 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xd0, 0xb1, 0x78,
 535                 0xed, 0xee, 0xb4, 0x57, 0x7b, 0x4f, 0xed, 0x45, 0xba, 0x0b, 0x5a, 0x32, 0xe5, 0xe1, 0x32, 0xee,
 536                 0x83, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xd0, 0xb1,
 537                 0x78, 0xed, 0xee, 0xb4, 0x57, 0x7b, 0x4f, 0xed, 0x45, 0xba, 0x0b, 0x5a, 0x32, 0xe5, 0xe1, 0x32,
 538                 0xee, 0x83, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03,
 539                 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
 540                 0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x2e, 0xf4, 0x42, 0x8b, 0xde, 0xfe, 0x36, 0x79, 0x6d, 0xaa,
 541                 0x51, 0x85, 0x65, 0xe3, 0x0f, 0x89, 0x1f, 0x84, 0xce, 0x5c, 0x34, 0x03, 0x0d, 0x59, 0x2a, 0xad,
 542                 0xfb, 0x09, 0xd2, 0xcd, 0xbc, 0xac, 0x51, 0x4a, 0xe3, 0xcb, 0x9e, 0xe5, 0x75, 0x26, 0x36, 0x5e,
 543                 0xe7, 0xc6, 0x86, 0x6b, 0xf8, 0xc4, 0x96, 0x99, 0x43, 0xb6, 0x53, 0xcc, 0x6a, 0x14, 0x57, 0xcd,
 544                 0x08, 0xad, 0x53, 0x11, 0x5f, 0x17, 0x97, 0xb3, 0x2f, 0x36, 0xbe, 0xd6, 0x5c, 0x03, 0x32, 0xe3,
 545                 0x2a, 0x4f, 0x69, 0x85, 0xf6, 0xf0, 0x14, 0x13, 0x2b, 0xfc, 0xa6, 0x64, 0x67, 0x4d, 0x7b, 0xab,
 546                 0xb9, 0xd0, 0x06, 0x00, 0xce, 0xc6, 0x85, 0x08, 0x45, 0xfb, 0xca, 0x70, 0x1b, 0xb4, 0x8f, 0x4e,
 547                 0x49, 0x2e, 0xfe, 0x94, 0xd7, 0x7b, 0xf1, 0xc6, 0x60, 0x24, 0xa6, 0x79, 0x5a, 0xeb, 0x92, 0xed,
 548                 0xd7, 0x07, 0x42, 0x65, 0xd3, 0x31
 549         };
 550
 551         auto test_code = []()
 552                 {
 553                         int ret;
 554                         yaca_key_h key_pem = YACA_KEY_NULL, key_der = YACA_KEY_NULL;
 555
 556                         ret = yaca_key_import(YACA_KEY_TYPE_RSA_PUB, NULL, data_pem,
 557                                                                   sizeof(data_pem), &key_pem);
 558                         if (ret != YACA_ERROR_NONE) goto exit;
 559
 560                         ret = yaca_key_import(YACA_KEY_TYPE_RSA_PUB, NULL, (char*)data_der,
 561                                                                   sizeof(data_der), &key_der);
 562                         if (ret != YACA_ERROR_NONE) goto exit;
 563
 564                 exit:
 565                         yaca_key_destroy(key_pem);
 566                         yaca_key_destroy(key_der);
 567                         return ret;
 568                 };
 569
 570         call_mock_test(test_code);
 571 }
 572
 573 BOOST_AUTO_TEST_SUITE_END()