tests/test_cases.cpp

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  *
  16  *
  17  * @file        test_cases.cpp
  18  * @author      Dongsun Lee (ds73.lee@samsung.com)
  19  * @version     1.0
  20  * @brief       tests for SE Backend
  21  */
  22 #include <boost/test/unit_test.hpp>
  23 #include <stdio.h>
  24 #include <string>
  25 #include <key-manager-se-backend.h>
  26
  27 BOOST_AUTO_TEST_SUITE(USER)
  28
  29 BOOST_AUTO_TEST_SUITE(SE_EMUL);
  30
  31 void _print_bin(char *bin, uint32_t len) {
  32     for(uint32_t i=0; i<len; i++) {
  33         printf("%02X, ", 0x00FF & bin[i]);
  34     }
  35     printf("\n");
  36 }
  37
  38 bool _dbp_key_exist()
  39 {
  40     bool key_exist = true;
  41     kmsb_error_e ret = KMSB_ERROR_NONE;
  42
  43     unsigned char input[32] = {0x01};
  44     unsigned char iv[16] = {0x02};
  45     unsigned char *output = NULL;
  46     unsigned int output_len = 0;
  47
  48     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
  49                                     input, sizeof(input),
  50                                     iv, sizeof(iv),
  51                                     &output, &output_len);
  52     if (ret == KMSB_ERROR_NO_KEY)
  53         key_exist = false;
  54
  55     BOOST_TEST_MESSAGE( "Check Existence of DB Protection Key : Exist=" << std::boolalpha << key_exist );
  56     return key_exist;
  57 }
  58
  59 struct dbp_key_checker
  60 {
  61     dbp_key_checker() {}
  62
  63     boost::test_tools::assertion_result operator()(boost::unit_test::test_unit_id)
  64     {
  65         return _dbp_key_exist();
  66     }
  67 };
  68
  69 struct no_dbp_key_checker
  70 {
  71     no_dbp_key_checker() {}
  72
  73     boost::test_tools::assertion_result operator()(boost::unit_test::test_unit_id)
  74     {
  75         return !_dbp_key_exist();
  76     }
  77 };
  78
  79 BOOST_AUTO_TEST_CASE(kmsb_generate_dbp_key_p,
  80   * boost::unit_test::precondition(no_dbp_key_checker()))
  81 {
  82     kmsb_error_e ret = KMSB_ERROR_NONE;
  83
  84     unsigned char input[32] = {0x01};
  85     unsigned char iv[16] = {0x02};
  86     unsigned char *output = NULL;
  87     unsigned int output_len = 0;
  88
  89     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
  90                                     input, sizeof(input),
  91                                     iv, sizeof(iv),
  92                                     &output, &output_len);
  93     BOOST_REQUIRE(ret == KMSB_ERROR_NO_KEY);
  94
  95     ret = kmsb_generate_dbp_key(false);
  96     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
  97
  98     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
  99                                     input, sizeof(input),
 100                                     iv, sizeof(iv),
 101                                     &output, &output_len);
 102     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 103     if (output) free(output);
 104 }
 105
 106 BOOST_AUTO_TEST_CASE(kmsb_generate_dbp_key_regenerate_p,
 107   * boost::unit_test::precondition(dbp_key_checker()))
 108 {
 109     kmsb_error_e ret = kmsb_generate_dbp_key(true);
 110     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 111 }
 112
 113 BOOST_AUTO_TEST_CASE(kmsb_generate_dbp_key_not_permitted_n,
 114   * boost::unit_test::precondition(dbp_key_checker()))
 115 {
 116     kmsb_error_e ret = kmsb_generate_dbp_key(false);
 117     BOOST_REQUIRE(ret == KMSB_ERROR_NOT_PERMITTED);
 118 }
 119
 120 BOOST_AUTO_TEST_CASE(kmsb_encrypt_with_dbp_key_p,
 121   * boost::unit_test::precondition(dbp_key_checker()))
 122 {
 123     kmsb_error_e ret = KMSB_ERROR_NONE;
 124
 125     unsigned char input[32] = {0x01};
 126     unsigned char iv[16] = {0x02};
 127     unsigned char *output1 = NULL;
 128     unsigned char *output2 = NULL;
 129     unsigned int output_len = 0;
 130
 131     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 132                                     input, sizeof(input),
 133                                     iv, sizeof(iv),
 134                                     &output1, &output_len);
 135     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 136     BOOST_REQUIRE(output_len == sizeof(input));
 137
 138     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 139                                     input, sizeof(input),
 140                                     iv, sizeof(iv),
 141                                     &output2, &output_len);
 142     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 143     BOOST_REQUIRE(output_len == sizeof(input));
 144
 145     BOOST_REQUIRE(std::memcmp(output1, output2, output_len) == 0);
 146
 147     if (output1) free(output1);
 148     if (output2) free(output2);
 149 }
 150
 151 BOOST_AUTO_TEST_CASE(kmsb_encrypt_with_dbp_key_invalid_parameter_n)
 152 {
 153     kmsb_error_e ret = KMSB_ERROR_NONE;
 154
 155     unsigned char input[32] = {0x01};
 156     unsigned char iv[16] = {0x02};
 157     unsigned char *output = NULL;
 158     unsigned int output_len = 0;
 159
 160     ret = kmsb_encrypt_with_dbp_key(0,
 161                                     input, sizeof(input),
 162                                     iv, sizeof(iv),
 163                                     &output, &output_len);
 164     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 165
 166     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 167                                     NULL, sizeof(input),
 168                                     iv, sizeof(iv),
 169                                     &output, &output_len);
 170     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 171
 172     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 173                                     input, 0,
 174                                     iv, sizeof(iv),
 175                                     &output, &output_len);
 176     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 177
 178     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 179                                     input, sizeof(input),
 180                                     NULL, sizeof(iv),
 181                                     &output, &output_len);
 182     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 183
 184     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 185                                     input, sizeof(input),
 186                                     iv, 0,
 187                                     &output, &output_len);
 188     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 189
 190     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 191                                     input, sizeof(input),
 192                                     iv, sizeof(iv),
 193                                     NULL, &output_len);
 194     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 195
 196     ret = kmsb_encrypt_with_dbp_key(SE_BACKEND_DBP_SCHEME_VERSION,
 197                                     input, sizeof(input),
 198                                     iv, sizeof(iv),
 199                                     &output, NULL);
 200     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 201 }
 202
 203 ///////////////////////////
 204 const int TEST_AES_KEY_IDX = 1;
 205 const int TEST_ECDSA_P192_KEY_IDX = 2;
 206 const int TEST_ECDSA_P256_KEY_IDX = 3;
 207 const int TEST_ECDSA_S384_KEY_IDX = 4;
 208 const int TEST_CERT_IDX = 0;
 209 const int TEST_DATA_IDX = 0;
 210
 211 BOOST_AUTO_TEST_CASE(kmsb_aes_cbc_encrypt_p)
 212 {
 213     kmsb_error_e ret = KMSB_ERROR_NONE;
 214
 215     unsigned char input[32] = {0x01};
 216     unsigned char iv[16] = {0x02};
 217     unsigned char *output1 = NULL;
 218     unsigned char *output2 = NULL;
 219     unsigned int output_len = 0;
 220
 221     kmsb_aes_param_s param;
 222     param.mode = KMSB_ALGO_AES_CBC;
 223     param.iv = iv;
 224     param.iv_len = 16;
 225
 226     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 227                             input, sizeof(input),
 228                             &output1, &output_len);
 229     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 230
 231     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 232                             input, sizeof(input),
 233                             &output2, &output_len);
 234     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 235     BOOST_REQUIRE(std::memcmp(output1, output2, output_len) == 0);
 236
 237     if (output1) free(output1);
 238     if (output2) free(output2);
 239 }
 240
 241 BOOST_AUTO_TEST_CASE(kmsb_aes_cbc_decrypt_p)
 242 {
 243     kmsb_error_e ret = KMSB_ERROR_NONE;
 244
 245     unsigned char input[32] = {0x01};
 246     unsigned char iv[16] = {0x02};
 247     unsigned char *output1 = NULL;
 248     unsigned char *output2 = NULL;
 249     unsigned int output_len = 0;
 250
 251     kmsb_aes_param_s param;
 252     param.mode = KMSB_ALGO_AES_CBC;
 253     param.iv = iv;
 254     param.iv_len = 16;
 255
 256     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 257                             input, sizeof(input),
 258                             &output1, &output_len);
 259     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 260
 261     ret = kmsb_aes_decrypt(TEST_AES_KEY_IDX, &param,
 262                             output1, output_len,
 263                             &output2, &output_len);
 264     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 265     BOOST_REQUIRE(output_len == sizeof(input));
 266     BOOST_REQUIRE(std::memcmp(input, output2, output_len) == 0);
 267
 268     if (output1) free(output1);
 269     if (output2) free(output2);
 270 }
 271
 272 BOOST_AUTO_TEST_CASE(kmsb_aes_ctr_encrypt_p)
 273 {
 274     kmsb_error_e ret = KMSB_ERROR_NONE;
 275
 276     unsigned char input[32] = {0x01};
 277     unsigned char iv[16] = {0x02};
 278     unsigned char *output1 = NULL;
 279     unsigned char *output2 = NULL;
 280     unsigned int output_len = 0;
 281
 282     kmsb_aes_param_s param;
 283     param.mode = KMSB_ALGO_AES_CTR;
 284     param.iv = iv;
 285     param.iv_len = 16;
 286     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 287                             input, sizeof(input),
 288                             &output1, &output_len);
 289     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 290     BOOST_REQUIRE(output_len == sizeof(input));
 291
 292     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 293                             input, sizeof(input),
 294                             &output2, &output_len);
 295     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 296     BOOST_REQUIRE(output_len == sizeof(input));
 297
 298     BOOST_REQUIRE(std::memcmp(output1, output2, output_len) == 0);
 299
 300     if (output1) free(output1);
 301     if (output2) free(output2);
 302 }
 303
 304 BOOST_AUTO_TEST_CASE(kmsb_aes_ctr_decrypt_p)
 305 {
 306     kmsb_error_e ret = KMSB_ERROR_NONE;
 307
 308     unsigned char input[32] = {0x01};
 309     unsigned char iv[16] = {0x02};
 310     unsigned char *output1 = NULL;
 311     unsigned char *output2 = NULL;
 312     unsigned int output_len = 0;
 313
 314     kmsb_aes_param_s param;
 315     param.mode = KMSB_ALGO_AES_CTR;
 316     param.iv = iv;
 317     param.iv_len = 16;
 318
 319     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 320                             input, sizeof(input),
 321                             &output1, &output_len);
 322     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 323     BOOST_REQUIRE(output_len == sizeof(input));
 324
 325     ret = kmsb_aes_decrypt(TEST_AES_KEY_IDX, &param,
 326                             output1, output_len,
 327                             &output2, &output_len);
 328     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 329     BOOST_REQUIRE(output_len == sizeof(input));
 330     BOOST_REQUIRE(std::memcmp(input, output2, output_len) == 0);
 331
 332     if (output1) free(output1);
 333     if (output2) free(output2);
 334 }
 335
 336 BOOST_AUTO_TEST_CASE(kmsb_aes_cfb_encrypt_p)
 337 {
 338     kmsb_error_e ret = KMSB_ERROR_NONE;
 339
 340     unsigned char input[32] = {0x01};
 341     unsigned char iv[16] = {0x02};
 342     unsigned char *output1 = NULL;
 343     unsigned char *output2 = NULL;
 344     unsigned int output_len = 0;
 345
 346     kmsb_aes_param_s param;
 347     param.mode = KMSB_ALGO_AES_CFB;
 348     param.iv = iv;
 349     param.iv_len = 16;
 350     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 351                             input, sizeof(input),
 352                             &output1, &output_len);
 353     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 354     BOOST_REQUIRE(output_len == sizeof(input));
 355
 356     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 357                             input, sizeof(input),
 358                             &output2, &output_len);
 359     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 360     BOOST_REQUIRE(output_len == sizeof(input));
 361
 362     BOOST_REQUIRE(std::memcmp(output1, output2, output_len) == 0);
 363
 364     if (output1) free(output1);
 365     if (output2) free(output2);
 366 }
 367
 368 BOOST_AUTO_TEST_CASE(kmsb_aes_cfb_decrypt_p)
 369 {
 370     kmsb_error_e ret = KMSB_ERROR_NONE;
 371
 372     unsigned char input[32] = {0x01};
 373     unsigned char iv[16] = {0x02};
 374     unsigned char *output1 = NULL;
 375     unsigned char *output2 = NULL;
 376     unsigned int output_len = 0;
 377
 378     kmsb_aes_param_s param;
 379     param.mode = KMSB_ALGO_AES_CFB;
 380     param.iv = iv;
 381     param.iv_len = 16;
 382
 383     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 384                             input, sizeof(input),
 385                             &output1, &output_len);
 386     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 387     BOOST_REQUIRE(output_len == sizeof(input));
 388
 389     ret = kmsb_aes_decrypt(TEST_AES_KEY_IDX, &param,
 390                             output1, output_len,
 391                             &output2, &output_len);
 392     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 393     BOOST_REQUIRE(output_len == sizeof(input));
 394     BOOST_REQUIRE(std::memcmp(input, output2, output_len) == 0);
 395
 396     if (output1) free(output1);
 397     if (output2) free(output2);
 398 }
 399
 400 BOOST_AUTO_TEST_CASE(kmsb_aes_gcm_encrypt_p)
 401 {
 402     kmsb_error_e ret = KMSB_ERROR_NONE;
 403
 404     unsigned char input[32] = {0x01};
 405     unsigned char iv[16] = {0x02};
 406     unsigned char aad[16] = {0x03};
 407     unsigned char tag[16];
 408     unsigned char *output1 = NULL;
 409     unsigned char *output2 = NULL;
 410     unsigned int output_len = 0;
 411
 412     kmsb_aes_param_s param;
 413     param.mode = KMSB_ALGO_AES_GCM;
 414     param.iv = iv;
 415     param.iv_len = 16;
 416     param.aad = aad;
 417     param.aad_len = sizeof(aad),
 418     param.tag = tag;
 419     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 420                             input, sizeof(input),
 421                             &output1, &output_len);
 422     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 423     BOOST_REQUIRE(output_len == sizeof(input));
 424
 425     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 426                             input, sizeof(input),
 427                             &output2, &output_len);
 428     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 429     BOOST_REQUIRE(output_len == sizeof(input));
 430
 431     BOOST_REQUIRE(std::memcmp(output1, output2, output_len) == 0);
 432
 433     if (output1) free(output1);
 434     if (output2) free(output2);
 435 }
 436
 437 BOOST_AUTO_TEST_CASE(kmsb_aes_gcm_decrypt_p)
 438 {
 439     kmsb_error_e ret = KMSB_ERROR_NONE;
 440
 441     unsigned char input[32] = {0x01};
 442     unsigned char iv[16] = {0x02};
 443     unsigned char aad[16] = {0x03};
 444     unsigned char tag[16];
 445     unsigned char *output1 = NULL;
 446     unsigned char *output2 = NULL;
 447     unsigned int output_len = 0;
 448
 449     kmsb_aes_param_s param;
 450     param.mode = KMSB_ALGO_AES_GCM;
 451     param.iv = iv;
 452     param.iv_len = 16;
 453     param.aad = aad;
 454     param.aad_len = sizeof(aad);
 455     param.tag = tag;
 456
 457     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 458                             input, sizeof(input),
 459                             &output1, &output_len);
 460     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 461     BOOST_REQUIRE(output_len == sizeof(input));
 462
 463     ret = kmsb_aes_decrypt(TEST_AES_KEY_IDX, &param,
 464                             output1, output_len,
 465                             &output2, &output_len);
 466     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 467     BOOST_REQUIRE(output_len == sizeof(input));
 468     BOOST_REQUIRE(std::memcmp(input, output2, output_len) == 0);
 469
 470     if (output1) free(output1);
 471     if (output2) free(output2);
 472 }
 473
 474 void test_kmsb_create_signature(int key_idx,
 475                                 kmsb_hash_algo_e alg, kmsb_ec_type_e ec,
 476                                 unsigned char *input, unsigned int input_len,
 477                                 unsigned char **output, unsigned int *output_len)
 478 {
 479     kmsb_error_e ret = KMSB_ERROR_NONE;
 480     kmsb_sign_param_s param;
 481     param.ec_type = ec;
 482     param.hash_algo = alg;
 483
 484     ret = kmsb_create_signature(key_idx, &param,
 485                             input, input_len,
 486                             output, output_len);
 487     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 488 }
 489
 490 void test_kmsb_verify_signature(int key_idx,
 491                                 kmsb_hash_algo_e alg, kmsb_ec_type_e ec,
 492                                 unsigned char *input, unsigned int input_len,
 493                                 unsigned char **output, unsigned int *output_len)
 494 {
 495     kmsb_error_e ret = KMSB_ERROR_NONE;
 496     kmsb_sign_param_s param;
 497     param.ec_type = ec;
 498     param.hash_algo = alg;
 499
 500     ret = kmsb_create_signature(key_idx, &param,
 501                             input, input_len,
 502                             output, output_len);
 503     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 504
 505     ret = kmsb_verify_signature(key_idx, &param,
 506                             input, input_len,
 507                             *output, *output_len);
 508     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 509 }
 510
 511 BOOST_AUTO_TEST_CASE(kmsb_create_signature_sha1_p)
 512 {
 513     unsigned char input[32] = {0x01};
 514     unsigned char *signature = NULL;
 515     unsigned int signature_len = 0;
 516
 517     kmsb_hash_algo_e alg = KMSB_HASH_SHA1;
 518     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 519     test_kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 520                             input, sizeof(input),
 521                             &signature, &signature_len);
 522
 523     if (signature) free(signature);
 524 }
 525
 526 BOOST_AUTO_TEST_CASE(kmsb_create_signature_sha256_p)
 527 {
 528     unsigned char input[32] = {0x01};
 529     unsigned char *signature = NULL;
 530     unsigned int signature_len = 0;
 531
 532     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 533     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 534     test_kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 535                             input, sizeof(input),
 536                             &signature, &signature_len);
 537
 538     if (signature) free(signature);
 539 }
 540
 541 BOOST_AUTO_TEST_CASE(kmsb_create_signature_sha384_p)
 542 {
 543     unsigned char input[32] = {0x01};
 544     unsigned char *signature = NULL;
 545     unsigned int signature_len = 0;
 546
 547     kmsb_hash_algo_e alg = KMSB_HASH_SHA384;
 548     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 549     test_kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 550                             input, sizeof(input),
 551                             &signature, &signature_len);
 552
 553     if (signature) free(signature);
 554 }
 555
 556 BOOST_AUTO_TEST_CASE(kmsb_create_signature_sha512_p)
 557 {
 558     unsigned char input[32] = {0x01};
 559     unsigned char *signature = NULL;
 560     unsigned int signature_len = 0;
 561
 562     kmsb_hash_algo_e alg = KMSB_HASH_SHA512;
 563     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 564     test_kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 565                             input, sizeof(input),
 566                             &signature, &signature_len);
 567
 568     if (signature) free(signature);
 569 }
 570
 571 BOOST_AUTO_TEST_CASE(kmsb_create_signature_p192v1_p)
 572 {
 573     unsigned char input[32] = {0x01};
 574     unsigned char *signature = NULL;
 575     unsigned int signature_len = 0;
 576
 577     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 578     kmsb_ec_type_e ec = KMSB_EC_PRIME192V1;
 579     test_kmsb_create_signature(TEST_ECDSA_P192_KEY_IDX, alg, ec,
 580                             input, sizeof(input),
 581                             &signature, &signature_len);
 582
 583     if (signature) free(signature);
 584 }
 585
 586 BOOST_AUTO_TEST_CASE(kmsb_create_signature_secp384r1_p)
 587 {
 588     unsigned char input[32] = {0x01};
 589     unsigned char *signature = NULL;
 590     unsigned int signature_len = 0;
 591
 592     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 593     kmsb_ec_type_e ec = KMSB_EC_SECP384R1;
 594     test_kmsb_create_signature(TEST_ECDSA_S384_KEY_IDX, alg, ec,
 595                             input, sizeof(input),
 596                             &signature, &signature_len);
 597
 598     if (signature) free(signature);
 599 }
 600
 601 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_sha1_p)
 602 {
 603     unsigned char input[32] = {0x01};
 604     unsigned char *signature = NULL;
 605     unsigned int signature_len = 0;
 606
 607     kmsb_hash_algo_e alg = KMSB_HASH_SHA1;
 608     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 609     test_kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 610                             input, sizeof(input),
 611                             &signature, &signature_len);
 612
 613     if (signature) free(signature);
 614 }
 615
 616 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_sha256_p)
 617 {
 618     unsigned char input[32] = {0x01};
 619     unsigned char *signature = NULL;
 620     unsigned int signature_len = 0;
 621
 622     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 623     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 624     test_kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 625                             input, sizeof(input),
 626                             &signature, &signature_len);
 627
 628     if (signature) free(signature);
 629 }
 630
 631 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_sha384_p)
 632 {
 633     unsigned char input[32] = {0x01};
 634     unsigned char *signature = NULL;
 635     unsigned int signature_len = 0;
 636
 637     kmsb_hash_algo_e alg = KMSB_HASH_SHA384;
 638     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 639     test_kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 640                             input, sizeof(input),
 641                             &signature, &signature_len);
 642
 643     if (signature) free(signature);
 644 }
 645
 646 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_sha512_p)
 647 {
 648     unsigned char input[32] = {0x01};
 649     unsigned char *signature = NULL;
 650     unsigned int signature_len = 0;
 651
 652     kmsb_hash_algo_e alg = KMSB_HASH_SHA512;
 653     kmsb_ec_type_e ec = KMSB_EC_PRIME256V1;
 654     test_kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 655                             input, sizeof(input),
 656                             &signature, &signature_len);
 657
 658     if (signature) free(signature);
 659 }
 660
 661 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_p192v1_p)
 662 {
 663     unsigned char input[32] = {0x01};
 664     unsigned char *signature = NULL;
 665     unsigned int signature_len = 0;
 666
 667     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 668     kmsb_ec_type_e ec = KMSB_EC_PRIME192V1;
 669     test_kmsb_verify_signature(TEST_ECDSA_P192_KEY_IDX, alg, ec,
 670                             input, sizeof(input),
 671                             &signature, &signature_len);
 672
 673     if (signature) free(signature);
 674 }
 675
 676 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_secp384r1_p)
 677 {
 678     unsigned char input[32] = {0x01};
 679     unsigned char *signature = NULL;
 680     unsigned int signature_len = 0;
 681
 682     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 683     kmsb_ec_type_e ec = KMSB_EC_SECP384R1;
 684     test_kmsb_verify_signature(TEST_ECDSA_S384_KEY_IDX, alg, ec,
 685                             input, sizeof(input),
 686                             &signature, &signature_len);
 687
 688     if (signature) free(signature);
 689 }
 690
 691 BOOST_AUTO_TEST_CASE(kmsb_aes_decrypt_fail_n)
 692 {
 693     kmsb_error_e ret = KMSB_ERROR_NONE;
 694
 695     unsigned char input[32] = {0x01};
 696     unsigned char iv[16] = {0x02};
 697     unsigned char *output1 = NULL;
 698     unsigned char *output2 = NULL;
 699     unsigned int output_len = 0;
 700
 701     kmsb_aes_param_s param;
 702     param.mode = KMSB_ALGO_AES_CBC;
 703     param.iv = iv;
 704     param.iv_len = 16;
 705
 706     ret = kmsb_aes_encrypt(TEST_AES_KEY_IDX, &param,
 707                             input, sizeof(input),
 708                             &output1, &output_len);
 709     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 710
 711     output_len--;
 712     ret = kmsb_aes_decrypt(TEST_AES_KEY_IDX, &param,
 713                             output1, output_len,
 714                             &output2, &output_len);
 715     BOOST_REQUIRE(ret == KMSB_ERROR_OPERATION_FAILED);
 716
 717     if (output1) free(output1);
 718     if (output2) free(output2);
 719 }
 720
 721 BOOST_AUTO_TEST_CASE(kmsb_aes_encrypt_invalid_parameters_n)
 722 {
 723     kmsb_error_e ret = KMSB_ERROR_NONE;
 724
 725     unsigned char input[32] = {0x01};
 726     unsigned char iv[16] = {0x02};
 727     unsigned char *output = NULL;
 728     unsigned int output_len = 0;
 729     unsigned int key_idx = TEST_AES_KEY_IDX;
 730
 731     kmsb_aes_param_s param;
 732     param.mode = KMSB_ALGO_AES_CBC;
 733     param.iv = iv;
 734     param.iv_len = 16;
 735
 736     ret = kmsb_aes_encrypt(key_idx, &param,
 737                             NULL, sizeof(input),
 738                             &output, &output_len);
 739     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 740
 741     ret = kmsb_aes_encrypt(key_idx, &param,
 742                             input, 0,
 743                             &output, &output_len);
 744     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 745
 746     param.iv = NULL;
 747     ret = kmsb_aes_encrypt(key_idx, &param,
 748                             input, sizeof(input),
 749                             &output, &output_len);
 750     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 751
 752     param.iv = iv;
 753     param.iv_len = 0;
 754     ret = kmsb_aes_encrypt(key_idx, &param,
 755                             input, sizeof(input),
 756                             &output, &output_len);
 757     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 758 }
 759
 760 BOOST_AUTO_TEST_CASE(kmsb_aes_decrypt_invalid_parameters_n)
 761 {
 762     kmsb_error_e ret = KMSB_ERROR_NONE;
 763
 764     unsigned char input[32] = {0x01};
 765     unsigned char iv[16] = {0x02};
 766     unsigned char *output = NULL;
 767     unsigned int output_len = 0;
 768     unsigned int key_idx = TEST_AES_KEY_IDX;
 769
 770     kmsb_aes_param_s param;
 771     param.mode = KMSB_ALGO_AES_CBC;
 772     param.iv = iv;
 773     param.iv_len = 16;
 774
 775     ret = kmsb_aes_encrypt(key_idx, &param,
 776                             input, sizeof(input),
 777                             &output, &output_len);
 778     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 779
 780     ret = kmsb_aes_decrypt(key_idx, &param,
 781                             NULL, sizeof(input),
 782                             &output, &output_len);
 783     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 784
 785     ret = kmsb_aes_decrypt(key_idx, &param,
 786                             input, 0,
 787                             &output, &output_len);
 788     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 789
 790     ret = kmsb_aes_decrypt(key_idx, &param,
 791                             input, sizeof(input),
 792                             NULL, &output_len);
 793     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 794
 795     ret = kmsb_aes_decrypt(key_idx, &param,
 796                             input, sizeof(input),
 797                             &output, NULL);
 798     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 799
 800     param.iv = NULL;
 801     ret = kmsb_aes_decrypt(key_idx, &param,
 802                             input, sizeof(input),
 803                             &output, &output_len);
 804     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 805
 806     param.iv = iv;
 807     param.iv_len = 0;
 808     ret = kmsb_aes_encrypt(key_idx, &param,
 809                             input, sizeof(input),
 810                             &output, &output_len);
 811     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 812
 813     if (output) free(output);
 814 }
 815
 816 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_fail_n)
 817 {
 818     kmsb_error_e ret = KMSB_ERROR_NONE;
 819     unsigned char input[32] = {0x01};
 820     unsigned char *signature = NULL;
 821     unsigned int signature_len = 0;
 822
 823     kmsb_sign_param_s param;
 824     param.ec_type = KMSB_EC_PRIME256V1;
 825     param.hash_algo = KMSB_HASH_SHA256;
 826
 827     ret = kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, &param,
 828                             input, sizeof(input),
 829                             &signature, &signature_len);
 830     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 831
 832     signature_len--;
 833     ret = kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, &param,
 834                             input, sizeof(input),
 835                             signature, signature_len);
 836     BOOST_REQUIRE(ret == KMSB_ERROR_VERIFICATION_FAILED);
 837
 838     if (signature) free(signature);
 839 }
 840
 841 BOOST_AUTO_TEST_CASE(kmsb_create_signature_wrong_key_idx_n)
 842 {
 843     unsigned char input[32] = {0x01};
 844     unsigned char *signature = NULL;
 845     unsigned int signature_len = 0;
 846
 847     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 848     kmsb_ec_type_e ec = KMSB_EC_SECP384R1;
 849     test_kmsb_create_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 850                             input, sizeof(input),
 851                             &signature, &signature_len);
 852
 853     if (signature) free(signature);
 854 }
 855
 856 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_wrong_key_idx_n)
 857 {
 858     unsigned char input[32] = {0x01};
 859     unsigned char *signature = NULL;
 860     unsigned int signature_len = 0;
 861
 862     kmsb_hash_algo_e alg = KMSB_HASH_SHA256;
 863     kmsb_ec_type_e ec = KMSB_EC_SECP384R1;
 864     test_kmsb_verify_signature(TEST_ECDSA_P256_KEY_IDX, alg, ec,
 865                             input, sizeof(input),
 866                             &signature, &signature_len);
 867
 868     if (signature) free(signature);
 869 }
 870
 871 BOOST_AUTO_TEST_CASE(kmsb_create_signature_invalid_parameters_n)
 872 {
 873     kmsb_error_e ret = KMSB_ERROR_NONE;
 874     unsigned char input[32] = {0x01};
 875     unsigned char *signature = NULL;
 876     unsigned int signature_len = 0;
 877     unsigned int key_idx = TEST_ECDSA_P256_KEY_IDX;
 878
 879     kmsb_sign_param_s param;
 880     param.ec_type = KMSB_EC_PRIME256V1;
 881     param.hash_algo = KMSB_HASH_NONE;
 882     ret = kmsb_create_signature(key_idx, &param,
 883                             input, sizeof(input),
 884                             &signature, &signature_len);
 885     BOOST_REQUIRE(ret == KMSB_ERROR_NOT_SUPPORTED);
 886
 887     param.hash_algo = KMSB_HASH_SHA256;
 888     ret = kmsb_create_signature(key_idx, &param,
 889                             NULL, sizeof(input),
 890                             &signature, &signature_len);
 891     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 892
 893     ret = kmsb_create_signature(key_idx, &param,
 894                             input, 0,
 895                             &signature, &signature_len);
 896     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 897
 898     ret = kmsb_create_signature(key_idx, &param,
 899                             input, sizeof(input),
 900                             NULL, &signature_len);
 901     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 902
 903     ret = kmsb_create_signature(key_idx, &param,
 904                             input, sizeof(input),
 905                             &signature, NULL);
 906     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 907
 908 }
 909
 910 BOOST_AUTO_TEST_CASE(kmsb_verify_signature_invalid_parameters_n)
 911 {
 912     kmsb_error_e ret = KMSB_ERROR_NONE;
 913     unsigned char input[32] = {0x01};
 914     unsigned char *signature = NULL;
 915     unsigned int signature_len = 0;
 916     unsigned int key_idx = TEST_ECDSA_P256_KEY_IDX;
 917
 918     kmsb_sign_param_s param;
 919     param.ec_type = KMSB_EC_PRIME256V1;
 920     param.hash_algo = KMSB_HASH_SHA256;
 921
 922     ret = kmsb_create_signature(key_idx, &param,
 923                             input, sizeof(input),
 924                             &signature, &signature_len);
 925     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 926
 927     param.hash_algo = KMSB_HASH_NONE;
 928     ret = kmsb_verify_signature(key_idx, &param,
 929                             input, sizeof(input),
 930                             signature, signature_len);
 931     BOOST_REQUIRE(ret == KMSB_ERROR_NOT_SUPPORTED);
 932
 933     param.hash_algo = KMSB_HASH_SHA256;
 934     ret = kmsb_verify_signature(key_idx, &param,
 935                             NULL, sizeof(input),
 936                             signature, signature_len);
 937     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 938
 939     ret = kmsb_verify_signature(key_idx, &param,
 940                             input, 0,
 941                             signature, signature_len);
 942     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 943
 944     ret = kmsb_verify_signature(key_idx, &param,
 945                             input, sizeof(input),
 946                             NULL, signature_len);
 947     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 948
 949     ret = kmsb_verify_signature(key_idx, &param,
 950                             input, sizeof(input),
 951                             signature, 0);
 952     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 953
 954     if (signature) free(signature);
 955 }
 956
 957 BOOST_AUTO_TEST_CASE(kmsb_get_key_invalid_parameters_n)
 958 {
 959     kmsb_error_e ret = KMSB_ERROR_NONE;
 960     unsigned char *public_key = NULL;
 961     unsigned int key_len = 0;
 962     unsigned int key_idx = TEST_ECDSA_P256_KEY_IDX;
 963
 964     ret = kmsb_get_key(100, &public_key, &key_len);
 965     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 966
 967     ret = kmsb_get_key(key_idx, NULL, &key_len);
 968     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 969
 970     ret = kmsb_get_key(key_idx, &public_key, NULL);
 971     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
 972
 973     if (public_key) free(public_key);
 974 }
 975
 976 BOOST_AUTO_TEST_CASE(kmsb_get_key_p192_p)
 977 {
 978     kmsb_error_e ret = KMSB_ERROR_NONE;
 979     unsigned char *public_key = NULL;
 980     unsigned int key_len = 0;
 981     unsigned int key_idx = TEST_ECDSA_P192_KEY_IDX;
 982
 983     ret = kmsb_get_key(key_idx, &public_key, &key_len);
 984     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 985
 986     if (public_key) free(public_key);
 987 }
 988
 989 BOOST_AUTO_TEST_CASE(kmsb_get_key_p256_n)
 990 {
 991     kmsb_error_e ret = KMSB_ERROR_NONE;
 992     unsigned char *public_key = NULL;
 993     unsigned int key_len = 0;
 994     unsigned int key_idx = TEST_ECDSA_P256_KEY_IDX;
 995
 996     ret = kmsb_get_key(key_idx, &public_key, &key_len);
 997     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
 998
 999     if (public_key) free(public_key);
1000 }
1001
1002 BOOST_AUTO_TEST_CASE(kmsb_get_key_secp384r1_n)
1003 {
1004     kmsb_error_e ret = KMSB_ERROR_NONE;
1005     unsigned char *public_key = NULL;
1006     unsigned int key_len = 0;
1007     unsigned int key_idx = TEST_ECDSA_S384_KEY_IDX;
1008
1009     ret = kmsb_get_key(key_idx, &public_key, &key_len);
1010     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
1011
1012     if (public_key) free(public_key);
1013 }
1014
1015 BOOST_AUTO_TEST_CASE(kmsb_get_certificate_invalid_parameters_n)
1016 {
1017     kmsb_error_e ret = KMSB_ERROR_NONE;
1018     unsigned char *certificate = NULL;
1019     unsigned int cert_len = 0;
1020     unsigned int cert_idx = TEST_CERT_IDX;
1021
1022     ret = kmsb_get_certificate(100, &certificate, &cert_len);
1023     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1024
1025     ret = kmsb_get_certificate(cert_idx, NULL, &cert_len);
1026     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1027
1028     ret = kmsb_get_certificate(cert_idx, &certificate, NULL);
1029     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1030
1031     if (certificate) free(certificate);
1032 }
1033
1034 BOOST_AUTO_TEST_CASE(kmsb_get_certificate_p)
1035 {
1036     kmsb_error_e ret = KMSB_ERROR_NONE;
1037     unsigned char *certificate = NULL;
1038     unsigned int cert_len = 0;
1039     unsigned int cert_idx = TEST_CERT_IDX;
1040
1041     ret = kmsb_get_certificate(cert_idx, &certificate, &cert_len);
1042     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
1043
1044     if (certificate) free(certificate);
1045 }
1046
1047 BOOST_AUTO_TEST_CASE(kmsb_get_data_invalid_parameters_n)
1048 {
1049     kmsb_error_e ret = KMSB_ERROR_NONE;
1050     unsigned char *data = NULL;
1051     unsigned int data_len = 0;
1052     unsigned int data_idx = TEST_DATA_IDX;
1053
1054     ret = kmsb_get_data(100, &data, &data_len);
1055     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1056
1057     ret = kmsb_get_data(data_idx, NULL, &data_len);
1058     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1059
1060     ret = kmsb_get_data(data_idx, &data, NULL);
1061     BOOST_REQUIRE(ret == KMSB_ERROR_INVALID_PARAMETER);
1062
1063     if (data) free(data);
1064 }
1065
1066 BOOST_AUTO_TEST_CASE(kmsb_get_data_p)
1067 {
1068     kmsb_error_e ret = KMSB_ERROR_NONE;
1069     unsigned char *data = NULL;
1070     unsigned int data_len = 0;
1071     unsigned int data_idx = TEST_DATA_IDX;
1072
1073     ret = kmsb_get_data(data_idx, &data, &data_len);
1074     BOOST_REQUIRE(ret == KMSB_ERROR_NONE);
1075
1076     if (data) free(data);
1077 }
1078
1079 BOOST_AUTO_TEST_SUITE_END() // SE_EMUL
1080
1081 BOOST_AUTO_TEST_SUITE_END() // USER