src/ckm/unprivileged/main.cpp

   1 /*
   2  *  Copyright (c) 2016-2018 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 #include <unistd.h>
  17 #include <sys/types.h>
  18
  19 #include <fstream>
  20 #include <iostream>
  21 #include <string>
  22
  23 #include <netdb.h>
  24
  25 #include <dpl/test/test_runner.h>
  26
  27 #include <tests_common.h>
  28 #include <test-certs.h>
  29
  30 #include <ckm-common.h>
  31 #include <ckm/ckm-manager.h>
  32 #include <ckm/ckm-control.h>
  33 #include <ckm/ckm-password.h>
  34 #include <ckm/ckm-type.h>
  35 #include <ckm/ckm-pkcs12.h>
  36
  37 #include <openssl/x509.h>
  38 #include <openssl/x509v3.h>
  39
  40 #include <tzplatform_config.h>
  41
  42 namespace {
  43 const int USER_APP = 5001;
  44
  45 const int USER_APP_2 = 5020;
  46 const int USER_APP_3 = 5030;
  47
  48 const char * const APP_PASS  = "user-pass";
  49 const int USER_TEST = 5001;
  50
  51 const CKM::CertificateShPtrVector EMPTY_CERT_VECTOR;
  52 const CKM::AliasVector EMPTY_ALIAS_VECTOR;
  53 } // namespace anonymous
  54
  55 /*
  56  *  How to numerate tests:
  57  *  TABCD_NAME
  58  *  T - test case (always T)
  59  *  AB - number of test group (always two digits)
  60  *  C - test number in group (all tests with same TABC must be run in the same time).
  61  *  D - subtest.
  62  */
  63 RUNNER_TEST_GROUP_INIT(T0010_CKM_CONTROL);
  64
  65 RUNNER_TEST(T0011_Control)
  66 {
  67     int temp;
  68     auto control = CKM::Control::create();
  69
  70     control->removeUserData(0);
  71     control->removeUserData(USER_APP_2);
  72     control->removeUserData(USER_APP);
  73
  74     RUNNER_ASSERT_MSG(
  75         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "simple-password")),
  76         "Error=" << CKMErrorToString(temp));
  77 }
  78
  79 RUNNER_TEST(T0012_Control)
  80 {
  81     int temp;
  82     auto control = CKM::Control::create();
  83     RUNNER_ASSERT_MSG(
  84         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "simple-password")),
  85         "Error=" << CKMErrorToString(temp));
  86     RUNNER_ASSERT_MSG(
  87         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
  88         "Error=" << CKMErrorToString(temp));
  89 }
  90
  91 RUNNER_TEST(T0013_Control)
  92 {
  93     int temp;
  94     auto control = CKM::Control::create();
  95     RUNNER_ASSERT_MSG(
  96         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "simple-password")),
  97         "Error=" << CKMErrorToString(temp));
  98 }
  99
 100 RUNNER_TEST(T0014_Control)
 101 {
 102     int temp;
 103     auto control = CKM::Control::create();
 104     RUNNER_ASSERT_MSG(
 105         CKM_API_SUCCESS == (temp = control->removeUserData(USER_APP_3)),
 106         "Error=" << CKMErrorToString(temp));
 107
 108     RUNNER_ASSERT_MSG(
 109         CKM_API_SUCCESS == (temp = control->resetUserPassword(USER_APP_3, "simple-password")),
 110         "Error=" << CKMErrorToString(temp));
 111
 112     RUNNER_ASSERT_MSG(
 113         CKM_API_SUCCESS == (temp = control->resetUserPassword(USER_APP_3, "something")),
 114         "Error=" << CKMErrorToString(temp));
 115
 116     RUNNER_ASSERT_MSG(
 117         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP_3, "test-pass")),
 118         "Error=" << CKMErrorToString(temp));
 119
 120     RUNNER_ASSERT_MSG(
 121         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP_3)),
 122         "Error=" << CKMErrorToString(temp));
 123
 124     RUNNER_ASSERT_MSG(
 125         CKM_API_ERROR_BAD_REQUEST == (temp = control->resetUserPassword(USER_APP_3, "something")),
 126         "Error=" << CKMErrorToString(temp));
 127
 128     RUNNER_ASSERT_MSG(
 129         CKM_API_SUCCESS == (temp = control->removeUserData(USER_APP_3)),
 130         "Error=" << CKMErrorToString(temp));
 131 }
 132
 133 RUNNER_TEST(T0015_Control)
 134 {
 135     int temp;
 136     auto control = CKM::Control::create();
 137     RUNNER_ASSERT_MSG(
 138         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP_2, "test-pass")),
 139         "Error=" << CKMErrorToString(temp));
 140     RUNNER_ASSERT_MSG(
 141         CKM_API_SUCCESS == (temp = control->changeUserPassword(USER_APP_2, "test-pass", "new-pass")),
 142         "Error=" << CKMErrorToString(temp));
 143     RUNNER_ASSERT_MSG(
 144         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP_2)),
 145         "Error=" << CKMErrorToString(temp));
 146     RUNNER_ASSERT_MSG(
 147         CKM_API_SUCCESS == (temp = control->removeUserData(USER_APP_2)),
 148         "Error=" << CKMErrorToString(temp));
 149 }
 150
 151 RUNNER_TEST(T0016_Control_negative_wrong_password)
 152 {
 153     int temp;
 154     auto control = CKM::Control::create();
 155     RUNNER_ASSERT_MSG(
 156         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP_2, "test-pass")),
 157         "Error=" << CKMErrorToString(temp));
 158     RUNNER_ASSERT_MSG(
 159         CKM_API_SUCCESS == (temp = control->changeUserPassword(USER_APP_2, "test-pass", "new-pass")),
 160         "Error=" << CKMErrorToString(temp));
 161     RUNNER_ASSERT_MSG(
 162         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP_2)),
 163         "Error=" << CKMErrorToString(temp));
 164     RUNNER_ASSERT_MSG(
 165         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = control->unlockUserKey(USER_APP_2, "incorrect-password")),
 166         "Error=" << CKMErrorToString(temp));
 167     RUNNER_ASSERT_MSG(
 168         CKM_API_SUCCESS == (temp = control->removeUserData(USER_APP_2)),
 169         "Error=" << CKMErrorToString(temp));
 170 }
 171
 172 RUNNER_TEST_GROUP_INIT(T101_CKM_QUICK_SET_GET_TESTS);
 173
 174 RUNNER_TEST(T1010_init)
 175 {
 176     unlock_user_data(USER_APP, "user-pass");
 177 }
 178
 179 RUNNER_TEST(T1011_key)
 180 {
 181     int temp;
 182     auto manager = CKM::Manager::create();
 183
 184     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 185         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 186         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 187         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 188         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 189         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 190         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 191         "zQIDAQAB\n"
 192         "-----END PUBLIC KEY-----";
 193
 194     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 195     auto key = CKM::Key::create(buffer, CKM::Password());
 196     CKM::KeyShPtr key2;
 197     CKM::Alias alias = "mykey";
 198
 199     RUNNER_ASSERT_MSG(
 200         CKM_API_SUCCESS == (temp = manager->saveKey(alias, key, CKM::Policy())),
 201         "Error=" << CKMErrorToString(temp));
 202     RUNNER_ASSERT_MSG(
 203         CKM_API_SUCCESS == (temp = manager->getKey(alias, CKM::Password(), key2)),
 204         "Error=" << CKMErrorToString(temp));
 205     RUNNER_ASSERT_MSG(
 206         key->getDER() == key2->getDER(),
 207         "Key value has been changed by service");
 208 }
 209
 210 RUNNER_TEST(T1012_certificate)
 211 {
 212     int temp;
 213     auto manager = CKM::Manager::create();
 214
 215     auto cert = TestData::getTestCertificate(TestData::THIRD_PARTY_LEAF);
 216     CKM::CertificateShPtr cert2;
 217     CKM::Alias alias = "myCert";
 218
 219     RUNNER_ASSERT_MSG(
 220         CKM_API_SUCCESS == (temp = manager->saveCertificate(alias, cert, CKM::Policy())),
 221         "Error=" << CKMErrorToString(temp));
 222     RUNNER_ASSERT_MSG(
 223         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, CKM::Password(), cert2)),
 224         "Error=" << CKMErrorToString(temp));
 225     RUNNER_ASSERT_MSG(
 226         cert->getDER() == cert2->getDER(),
 227         "Data has been modified in key manager");
 228 }
 229
 230 RUNNER_TEST(T1014_save_with_label)
 231 {
 232     int temp;
 233     auto manager = CKM::Manager::create();
 234
 235     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 236         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 237         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 238         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 239         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 240         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 241         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 242         "zQIDAQAB\n"
 243         "-----END PUBLIC KEY-----";
 244
 245     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 246     auto key = CKM::Key::create(buffer, CKM::Password());
 247     CKM::KeyShPtr key_name, key_full_addr;
 248     CKM::Alias alias = "mykey-2";
 249     std::string top_label = getOwnerIdFromSelf();
 250     std::string full_address = aliasWithLabel(top_label.c_str(), alias.c_str());
 251
 252     RUNNER_ASSERT_MSG(
 253         CKM_API_SUCCESS == (temp = manager->saveKey(full_address, key, CKM::Policy())),
 254         "Error=" << CKMErrorToString(temp));
 255
 256     // lookup by name
 257     RUNNER_ASSERT_MSG(
 258         CKM_API_SUCCESS == (temp = manager->getKey(alias, CKM::Password(), key_name)),
 259         "Error=" << CKMErrorToString(temp));
 260     RUNNER_ASSERT_MSG(
 261         key->getDER() == key_name->getDER(),
 262         "Key value has been changed by service");
 263
 264     // lookup by full address
 265     RUNNER_ASSERT_MSG(
 266         CKM_API_SUCCESS == (temp = manager->getKey(full_address, CKM::Password(), key_full_addr)),
 267         "Error=" << CKMErrorToString(temp));
 268     RUNNER_ASSERT_MSG(
 269         key->getDER() == key_full_addr->getDER(),
 270         "Key value has been changed by service");
 271 }
 272
 273 RUNNER_TEST(T1015_deinit)
 274 {
 275     remove_user_data(USER_APP);
 276 }
 277
 278 RUNNER_TEST_GROUP_INIT(T102_CKM_QUICK_GET_ALIAS_TESTS);
 279
 280 RUNNER_TEST(T1020_init)
 281 {
 282     int temp;
 283     auto control = CKM::Control::create();
 284     RUNNER_ASSERT_MSG(
 285         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "user-pass")),
 286         "Error=" << CKMErrorToString(temp));
 287 }
 288
 289 RUNNER_TEST(T1021_save_keys_get_alias)
 290 {
 291     int temp;
 292     auto manager = CKM::Manager::create();
 293
 294     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 295         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 296         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 297         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 298         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 299         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 300         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 301         "zQIDAQAB\n"
 302         "-----END PUBLIC KEY-----";
 303
 304     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 305     auto key = CKM::Key::create(buffer, CKM::Password());
 306     CKM::AliasVector labelAliasVector;
 307
 308     size_t current_aliases_num = count_aliases(ALIAS_KEY);
 309     RUNNER_ASSERT_MSG(
 310         CKM_API_SUCCESS == (temp = manager->saveKey("rootkey1", key, CKM::Policy())),
 311         "Error=" << CKMErrorToString(temp));
 312     RUNNER_ASSERT_MSG(
 313         CKM_API_SUCCESS == (temp = manager->saveKey("rootkey2", key, CKM::Policy())),
 314         "Error=" << CKMErrorToString(temp));
 315     RUNNER_ASSERT_MSG(
 316         CKM_API_SUCCESS == (temp = manager->saveKey("rootkey3", key, CKM::Policy(CKM::Password(), false))),
 317         "Error=" << CKMErrorToString(temp));
 318     RUNNER_ASSERT_MSG(
 319         CKM_API_SUCCESS == (temp = manager->getKeyAliasVector(labelAliasVector)),
 320         "Error=" << CKMErrorToString(temp));
 321     RUNNER_ASSERT_MSG(
 322         labelAliasVector.size() == (current_aliases_num+3),
 323         "Wrong size of list: " << labelAliasVector.size() << " Expected: " << (current_aliases_num+3));
 324 }
 325
 326 RUNNER_TEST(T1022_app_user_save_keys_get_alias)
 327 {
 328     int temp;
 329     auto manager = CKM::Manager::create();
 330
 331     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 332         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 333         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 334         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 335         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 336         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 337         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 338         "zQIDAQAB\n"
 339         "-----END PUBLIC KEY-----";
 340
 341     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 342     auto key = CKM::Key::create(buffer, CKM::Password());
 343     CKM::AliasVector labelAliasVector;
 344
 345     size_t current_aliases_num = count_aliases(ALIAS_KEY);
 346     RUNNER_ASSERT_MSG(
 347         CKM_API_SUCCESS == (temp = manager->saveKey("appkey1", key, CKM::Policy())),
 348         "Error=" << CKMErrorToString(temp));
 349     RUNNER_ASSERT_MSG(
 350         CKM_API_SUCCESS == (temp = manager->saveKey("appkey2", key, CKM::Policy())),
 351         "Error=" << CKMErrorToString(temp));
 352     RUNNER_ASSERT_MSG(
 353         CKM_API_SUCCESS == (temp = manager->saveKey("appkey3", key, CKM::Policy(CKM::Password(), false))),
 354         "Error=" << CKMErrorToString(temp));
 355     RUNNER_ASSERT_MSG(
 356         CKM_API_SUCCESS == (temp = manager->getKeyAliasVector(labelAliasVector)),
 357         "Error=" << CKMErrorToString(temp));
 358     RUNNER_ASSERT_MSG(
 359         labelAliasVector.size() == (current_aliases_num+3),
 360         "Wrong size of list: " << labelAliasVector.size() << " Expected: " << (current_aliases_num+3));
 361 }
 362
 363 RUNNER_TEST(T1023_app_user_save_keys_exportable_flag)
 364 {
 365     int temp;
 366     auto manager = CKM::Manager::create();
 367
 368     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 369         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 370         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 371         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 372         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 373         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 374         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 375         "zQIDAQAB\n"
 376         "-----END PUBLIC KEY-----";
 377
 378     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 379     auto key = CKM::Key::create(buffer, CKM::Password());
 380     CKM::AliasVector aliasVector;
 381     CKM::Policy notExportable(CKM::Password(), false);
 382
 383     RUNNER_ASSERT_MSG(
 384         CKM_API_SUCCESS == (temp = manager->saveKey("appkey4", key, notExportable)),
 385         "Error=" << CKMErrorToString(temp));
 386     RUNNER_ASSERT_MSG(
 387         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getKey("appkey4", CKM::Password(), key)),
 388         "Error=" << CKMErrorToString(temp));
 389     RUNNER_ASSERT_MSG(
 390         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveData("data3", buffer, notExportable)),
 391         "Error=" << CKMErrorToString(temp));
 392 }
 393
 394 RUNNER_TEST(T1029_deinit)
 395 {
 396     remove_user_data(USER_APP);
 397 }
 398
 399 RUNNER_TEST_GROUP_INIT(T103_CKM_QUICK_REMOVE_BIN_DATA_TEST);
 400 RUNNER_TEST(T1030_init)
 401 {
 402     reset_user_data(USER_APP, APP_PASS);
 403 }
 404
 405 RUNNER_TEST(T1032_app_user_save_bin_data)
 406 {
 407     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 408
 409     int temp;
 410     auto manager = CKM::Manager::create();
 411
 412     std::string binData = "My bin data";
 413
 414     CKM::RawBuffer buffer(binData.begin(), binData.end());
 415
 416     CKM::AliasVector labelAliasVector;
 417
 418     size_t current_aliases_num = count_aliases(ALIAS_DATA);
 419     RUNNER_ASSERT_MSG(
 420         CKM_API_SUCCESS == (temp = manager->saveData("appdata1", buffer, CKM::Policy())),
 421         "Error=" << CKMErrorToString(temp));
 422     RUNNER_ASSERT_MSG(
 423         CKM_API_SUCCESS == (temp = manager->saveData("appdata2", buffer, CKM::Policy())),
 424         "Error=" << CKMErrorToString(temp));
 425     RUNNER_ASSERT_MSG(
 426         CKM_API_SUCCESS == (temp = manager->saveData("appdata3", buffer, CKM::Policy(CKM::Password(), true))),
 427         "Error=" << CKMErrorToString(temp));
 428     RUNNER_ASSERT_MSG(
 429         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(labelAliasVector)),
 430         "Error=" << CKMErrorToString(temp));
 431     RUNNER_ASSERT_MSG(
 432         labelAliasVector.size() == (current_aliases_num+3),
 433         "Wrong size of list: " << labelAliasVector.size() << " Expected: " << (current_aliases_num+3));
 434 }
 435
 436 RUNNER_TEST(T1034_app_remove_bin_data)
 437 {
 438     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 439
 440     int temp;
 441     auto manager = CKM::Manager::create();
 442
 443     std::string binData2 = "My bin data";
 444     CKM::RawBuffer buffer2(binData2.begin(), binData2.end());
 445
 446     CKM::AliasVector labelAliasVector;
 447
 448     size_t current_aliases_num = count_aliases(ALIAS_DATA);
 449     std::string invalid_address = aliasWithLabel("i-do-not-exist", "appdata1");
 450     RUNNER_ASSERT_MSG(
 451         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->removeAlias(invalid_address.c_str())),
 452         "Error=" << CKMErrorToString(temp));
 453     RUNNER_ASSERT_MSG(
 454         CKM_API_SUCCESS == (temp = manager->removeAlias("appdata1")),
 455         "Error=" << CKMErrorToString(temp));
 456     RUNNER_ASSERT_MSG(
 457         CKM_API_SUCCESS == (temp = manager->removeAlias("appdata3")),
 458         "Error=" << CKMErrorToString(temp));
 459     RUNNER_ASSERT_MSG(
 460         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(labelAliasVector)),
 461         "Error=" << CKMErrorToString(temp));
 462     RUNNER_ASSERT_MSG(
 463         labelAliasVector.size() == (current_aliases_num-2),
 464         "Wrong size of list: " << labelAliasVector.size() << " Expected: " << (current_aliases_num-2));
 465
 466     CKM::RawBuffer buffer;
 467     RUNNER_ASSERT_MSG(
 468         CKM_API_SUCCESS == (temp = manager->getData("appdata2", CKM::Password(), buffer)),
 469         "Error=" << CKMErrorToString(temp));
 470     RUNNER_ASSERT_MSG(
 471         buffer == buffer2,
 472         "Data corrupted");
 473     RUNNER_ASSERT_MSG(
 474         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getData("appdata3", CKM::Password(), buffer)),
 475         "Error=" << CKMErrorToString(temp));
 476 }
 477
 478 RUNNER_TEST(T1035_getData_wrong_password)
 479 {
 480     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 481
 482     int temp;
 483     auto manager = CKM::Manager::create();
 484
 485     std::string binData1 = "My bin data4";
 486
 487     CKM::RawBuffer buffer1(binData1.begin(), binData1.end());
 488
 489     RUNNER_ASSERT_MSG(
 490         CKM_API_SUCCESS == (temp = manager->saveData("data4", buffer1, CKM::Policy("CorrectPassword"))),
 491         "Error=" << CKMErrorToString(temp));
 492
 493     CKM::RawBuffer buffer;
 494     RUNNER_ASSERT_MSG(
 495         CKM_API_SUCCESS == (temp = manager->getData("data4", CKM::Password("CorrectPassword"), buffer)),
 496         "Error=" << CKMErrorToString(temp));
 497     RUNNER_ASSERT_MSG(
 498         buffer == buffer1,
 499         "Data corrupted");
 500
 501     RUNNER_ASSERT_MSG(
 502         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getData("data4", CKM::Password("WrongPassword"), buffer)),
 503         "Error=" << CKMErrorToString(temp));
 504 }
 505
 506 RUNNER_TEST(T1036_deinit)
 507 {
 508     remove_user_data(USER_APP);
 509 }
 510
 511 RUNNER_TEST_GROUP_INIT(T104_CKM_QUICK_CREATE_PAIR);
 512
 513 RUNNER_TEST(T1040_init)
 514 {
 515     int temp;
 516     auto control = CKM::Control::create();
 517
 518     RUNNER_ASSERT_MSG(
 519         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "user-pass")),
 520         "Error=" << CKMErrorToString(temp));
 521 }
 522
 523 RUNNER_TEST(T1041_create_RSA_key)
 524 {
 525     int temp;
 526     auto manager = CKM::Manager::create();
 527     CKM::AliasVector av;
 528
 529     size_t current_aliases_num = count_aliases(ALIAS_KEY);
 530     RUNNER_ASSERT_MSG(
 531         CKM_API_SUCCESS == (temp = manager->createKeyPairRSA(2048, CKM::Alias("PRV_KEY1_RSA"), CKM::Alias("PUB_KEY1_RSA"), CKM::Policy(), CKM::Policy())),
 532         "Error=" << CKMErrorToString(temp));
 533     RUNNER_ASSERT_MSG(
 534         CKM_API_SUCCESS == (temp = manager->getKeyAliasVector(av)),
 535         "Error=" << CKMErrorToString(temp));
 536     RUNNER_ASSERT_MSG(
 537         (current_aliases_num+2) == static_cast<size_t>(temp = av.size()),
 538         "Vector size: " << temp << ". Expected: " << (current_aliases_num+2));
 539 }
 540
 541 RUNNER_TEST(T1042_create_RSA_key_foreign_label)
 542 {
 543     int temp;
 544     auto manager = CKM::Manager::create();
 545     CKM::AliasVector av;
 546
 547     RUNNER_ASSERT_MSG(
 548         CKM_API_ERROR_ACCESS_DENIED == (temp = manager->createKeyPairRSA(2048, CKM::Alias("iamsomebodyelse PRV_KEY2_RSA"), CKM::Alias("PUB_KEY2_RSA"), CKM::Policy(), CKM::Policy())),
 549         "Error=" << CKMErrorToString(temp));
 550     RUNNER_ASSERT_MSG(
 551         CKM_API_ERROR_ACCESS_DENIED == (temp = manager->createKeyPairRSA(2048, CKM::Alias("PRV_KEY2_RSA"), CKM::Alias("iamsomebodyelse PUB_KEY2_RSA"), CKM::Policy(), CKM::Policy())),
 552         "Error=" << CKMErrorToString(temp));
 553 }
 554
 555 RUNNER_TEST(T1043_create_DSA_key)
 556 {
 557     int temp;
 558     auto manager = CKM::Manager::create();
 559     CKM::AliasVector av;
 560
 561     size_t current_aliases_num = count_aliases(ALIAS_KEY);
 562     RUNNER_ASSERT_MSG(
 563         CKM_API_SUCCESS == (temp = manager->createKeyPairDSA(1024, CKM::Alias("PRV_KEY1_DSA"), CKM::Alias("PUB_KEY1_DSA"), CKM::Policy(), CKM::Policy())),
 564         "Error=" << CKMErrorToString(temp));
 565     RUNNER_ASSERT_MSG(
 566         CKM_API_SUCCESS == (temp = manager->getKeyAliasVector(av)),
 567         "Error=" << CKMErrorToString(temp));
 568     RUNNER_ASSERT_MSG(
 569         (current_aliases_num+2) == static_cast<size_t>(temp = av.size()),
 570         "Vector size: " << temp << ". Expected: " << (current_aliases_num+2));
 571 }
 572
 573 RUNNER_TEST(T1044_create_AES_key)
 574 {
 575     int temp;
 576     auto manager = CKM::Manager::create();
 577     CKM::AliasVector av;
 578
 579     int current_aliases_num = count_aliases(ALIAS_KEY);
 580     RUNNER_ASSERT_MSG(
 581         CKM_API_SUCCESS == (temp = manager->createKeyAES(128, CKM::Alias("KEY1_AES"), CKM::Policy())),
 582         "Error=" << CKMErrorToString(temp));
 583     RUNNER_ASSERT_MSG(
 584         CKM_API_SUCCESS == (temp = manager->getKeyAliasVector(av)),
 585         "Error=" << CKMErrorToString(temp));
 586     RUNNER_ASSERT_MSG(
 587         (current_aliases_num+1) == (temp = av.size()),
 588         "Vector size: " << temp << ". Expected: " << (current_aliases_num+1));
 589 }
 590
 591 RUNNER_TEST(T1049_deinit)
 592 {
 593     remove_user_data(USER_APP);
 594 }
 595
 596
 597 RUNNER_TEST_GROUP_INIT(T111_CKM_CreateKeyPair);
 598
 599 RUNNER_TEST(T1110_init)
 600 {
 601     unlock_user_data(USER_APP, "user-pass");
 602 }
 603
 604 RUNNER_TEST(T1111_CreateKeyPairRSA)
 605 {
 606     int temp;
 607     auto manager = CKM::Manager::create();
 608     CKM::Alias a1 = "rsa-test-1";
 609     CKM::Alias a2 = "rsa-test-2";
 610     CKM::Policy p1;
 611     CKM::Policy p2;
 612     RUNNER_ASSERT_MSG(
 613         CKM_API_SUCCESS == (temp = manager->createKeyPairRSA(1024, a1, a2, p1, p2)),
 614         "Error=" << CKMErrorToString(temp));
 615     RUNNER_ASSERT_MSG(
 616         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->createKeyPairRSA(1024, a1, a2, p1, p2)),
 617         "Error=" << CKMErrorToString(temp));
 618 }
 619
 620 RUNNER_TEST(T1112_CreateKeyPairDSA)
 621 {
 622     int temp;
 623     auto manager = CKM::Manager::create();
 624     CKM::Alias a1 = "dsa-test-1";
 625     CKM::Alias a2 = "dsa-test-2";
 626     CKM::Policy p1;
 627     CKM::Policy p2;
 628     RUNNER_ASSERT_MSG(
 629         CKM_API_SUCCESS == (temp = manager->createKeyPairDSA(1024, a1, a2, p1, p2)),
 630         "Error=" << CKMErrorToString(temp));
 631     RUNNER_ASSERT_MSG(
 632         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->createKeyPairDSA(1024, a1, a2, p1, p2)),
 633         "Error=" << CKMErrorToString(temp));
 634 }
 635
 636 RUNNER_TEST(T1113_CreateKeyPairECDSA)
 637 {
 638     int temp;
 639     auto manager = CKM::Manager::create();
 640     CKM::Alias a1 = "ecdsa-test-1";
 641     CKM::Alias a2 = "ecdsa-test-2";
 642     CKM::Policy p1;
 643     CKM::Policy p2;
 644     RUNNER_ASSERT_MSG(
 645         CKM_API_SUCCESS == (temp = manager->createKeyPairECDSA(CKM::ElipticCurve::prime192v1, a1, a2, p1, p2)),
 646         "Error=" << CKMErrorToString(temp));
 647 }
 648
 649 RUNNER_TEST(T1114_deinit)
 650 {
 651     remove_user_data(USER_APP);
 652 }
 653
 654 RUNNER_TEST_GROUP_INIT(T120_NEGATIVE_TESTS);
 655
 656 RUNNER_TEST(T12100_init)
 657 {
 658     reset_user_data(USER_APP, APP_PASS);
 659 }
 660
 661 RUNNER_TEST(T12101_key_exist)
 662 {
 663     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 664
 665     int ret;
 666     auto manager = CKM::Manager::create();
 667
 668     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 669       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 670       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 671       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 672       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 673       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 674       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 675       "zQIDAQAB\n"
 676       "-----END PUBLIC KEY-----";
 677
 678     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 679     auto key = CKM::Key::create(buffer);
 680     CKM::Alias alias = "rsa-alias-duplication";
 681
 682     RUNNER_ASSERT_MSG(
 683         CKM_API_SUCCESS == (ret = manager->saveKey(alias, key, CKM::Policy())),
 684         "Error=" << CKMErrorToString(ret));
 685     RUNNER_ASSERT_MSG(
 686         CKM_API_ERROR_DB_ALIAS_EXISTS == (ret = manager->saveKey(alias, key, CKM::Policy())),
 687         "Error=" << CKMErrorToString(ret));
 688 }
 689
 690 /*
 691  * These test cases tests API when empty parameters are passed to functions
 692  */
 693
 694 RUNNER_TEST(T12102_saveKey_empty_alias)
 695 {
 696     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 697
 698     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 699         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 700         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 701         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLc\n"
 702         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 703         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 704         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 705         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 706         "zQIDAQAB\n"
 707         "-----END PUBLIC KEY-----";
 708
 709     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 710     auto key = CKM::Key::create(buffer);
 711     CKM::Alias alias; //alias is not initialized
 712
 713     int ret;
 714     auto manager = CKM::Manager::create();
 715     RUNNER_ASSERT_MSG(
 716         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 717         "Error=" << CKMErrorToString(ret));
 718 }
 719
 720 RUNNER_TEST(T12103_saveKey_foreign_label)
 721 {
 722     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 723
 724     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 725       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 726       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 727       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 728       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 729       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 730       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 731       "zQIDAQAB\n"
 732       "-----END PUBLIC KEY-----";
 733
 734     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 735     auto key = CKM::Key::create(buffer);
 736     CKM::Alias alias = "iamsomebodyelse alias";
 737
 738     int ret;
 739     auto manager = CKM::Manager::create();
 740     RUNNER_ASSERT_MSG(
 741         CKM_API_ERROR_ACCESS_DENIED == (ret = manager->saveKey(alias, key, CKM::Policy())),
 742         "Error=" << CKMErrorToString(ret));
 743 }
 744
 745 RUNNER_TEST(T12104_saveKey_empty_key)
 746 {
 747     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 748
 749     CKM::KeyShPtr key; //key is not initialized
 750     CKM::Alias alias = "empty-key";
 751
 752     int ret;
 753     auto manager = CKM::Manager::create();
 754     RUNNER_ASSERT_MSG(
 755         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 756         "Error=" << CKMErrorToString(ret));
 757 }
 758
 759 RUNNER_TEST(T12105_saveCertificate_empty_alias)
 760 {
 761     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 762
 763     auto cert = TestData::getTestCertificate(TestData::THIRD_PARTY_LEAF);
 764     CKM::Alias alias; //alias is not initialized
 765
 766     int temp;
 767     auto manager = CKM::Manager::create();
 768     RUNNER_ASSERT_MSG(
 769         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveCertificate(alias, cert, CKM::Policy())),
 770         "Error=" << CKMErrorToString(temp));
 771 }
 772
 773 RUNNER_TEST(T12106_saveCertificate_foreign_label)
 774 {
 775     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 776
 777     auto cert = TestData::getTestCertificate(TestData::THIRD_PARTY_LEAF);
 778     CKM::Alias alias = "iamsomebodyelse alias";
 779
 780     int temp;
 781     auto manager = CKM::Manager::create();
 782     RUNNER_ASSERT_MSG(
 783         CKM_API_ERROR_ACCESS_DENIED == (temp = manager->saveCertificate(alias, cert, CKM::Policy())),
 784         "Error=" << CKMErrorToString(temp));
 785 }
 786
 787 RUNNER_TEST(T12107_saveCertificate_empty_cert)
 788 {
 789     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 790
 791     CKM::CertificateShPtr cert; //cert is not initialized
 792     CKM::Alias alias = "empty-cert";
 793
 794     int temp;
 795     auto manager = CKM::Manager::create();
 796     RUNNER_ASSERT_MSG(
 797         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveCertificate(alias, cert, CKM::Policy())),
 798         "Error=" << CKMErrorToString(temp));
 799 }
 800
 801 RUNNER_TEST(T12108_saveData_empty_alias)
 802 {
 803     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 804
 805     std::string testData = "test data test data test data";
 806     CKM::RawBuffer buffer(testData.begin(), testData.end());
 807     CKM::Alias alias;
 808
 809     int temp;
 810     auto manager = CKM::Manager::create();
 811     RUNNER_ASSERT_MSG(
 812         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveData(alias, buffer, CKM::Policy())),
 813         "Error=" << CKMErrorToString(temp));
 814 }
 815
 816 RUNNER_TEST(T12109_saveData_foreign_label)
 817 {
 818     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 819
 820     std::string testData = "test data test data test data";
 821     CKM::RawBuffer buffer(testData.begin(), testData.end());
 822     CKM::Alias alias = "iamsomebodyelse alias";
 823
 824     int temp;
 825     auto manager = CKM::Manager::create();
 826     RUNNER_ASSERT_MSG(
 827         CKM_API_ERROR_ACCESS_DENIED == (temp = manager->saveData(alias, buffer, CKM::Policy())),
 828         "Error=" << CKMErrorToString(temp));
 829 }
 830
 831 RUNNER_TEST(T12110_saveData_empty_data)
 832 {
 833     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 834
 835     CKM::RawBuffer buffer;
 836     CKM::Alias alias = "empty-data";
 837
 838     int temp;
 839     auto manager = CKM::Manager::create();
 840     RUNNER_ASSERT_MSG(
 841         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveData(alias, buffer, CKM::Policy())),
 842         "Error=" << CKMErrorToString(temp));
 843 }
 844
 845 /*
 846  * These test cases tests API when trying to get data from not existing alias
 847  */
 848
 849 RUNNER_TEST(T12111_getKey_alias_not_exist)
 850 {
 851     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 852
 853     CKM::KeyShPtr key;
 854     CKM::Alias alias = "this-alias-not-exist";
 855
 856     int temp;
 857     auto manager = CKM::Manager::create();
 858     RUNNER_ASSERT_MSG(
 859         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getKey(alias, "", key)),
 860         "Error=" << CKMErrorToString(temp));
 861 }
 862
 863 RUNNER_TEST(T12112_getCertificate_alias_not_exist)
 864 {
 865     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 866
 867     CKM::CertificateShPtr certificate;
 868     CKM::Alias alias = "this-alias-not-exist";
 869
 870     int temp;
 871     auto manager = CKM::Manager::create();
 872     RUNNER_ASSERT_MSG(
 873         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getCertificate(alias, CKM::Password(), certificate)),
 874         "Error=" << CKMErrorToString(temp));
 875 }
 876
 877 RUNNER_TEST(T12113_getData_alias_not_exist)
 878 {
 879     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 880
 881     int temp;
 882     auto manager = CKM::Manager::create();
 883     CKM::RawBuffer buffer;
 884     CKM::Alias alias("some alias");
 885     RUNNER_ASSERT_MSG(
 886         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getData(alias, "", buffer)),
 887         "Error=" << CKMErrorToString(temp));
 888 }
 889
 890 /*
 891  * These test cases tests API when damaged keys are used
 892  */
 893 RUNNER_TEST(T12114_RSA_key_damaged)
 894 {
 895     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 896
 897     int ret;
 898     auto manager = CKM::Manager::create();
 899
 900     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 901         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 902     //    "BROKENBROKENBROKENBROKENBROKENTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT\n"
 903         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 904         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 905     //    "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 906         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 907         "zQIDAQAB\n"
 908         "-----END PUBLIC KEY-----";
 909
 910     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 911     auto key = CKM::Key::create(buffer);
 912     CKM::Alias alias = "damaged-rsa";
 913
 914     RUNNER_ASSERT_MSG(
 915         NULL == key.get(), "Key is broken. It should be empty");
 916
 917     RUNNER_ASSERT_MSG(
 918         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 919         "Error=" << CKMErrorToString(ret));
 920 }
 921
 922 RUNNER_TEST(T12115_RSA_key_too_short)
 923 {
 924     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 925
 926     int ret;
 927     auto manager = CKM::Manager::create();
 928
 929     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 930         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 931         //"T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 932         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 933         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 934         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 935         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 936         "zQIDAQAB\n"
 937         "-----END PUBLIC KEY-----";
 938
 939     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 940     auto key = CKM::Key::create(buffer);
 941     CKM::Alias alias = "short-rsa";
 942
 943     RUNNER_ASSERT_MSG(
 944         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 945         "Error=" << CKMErrorToString(ret));
 946 }
 947
 948 RUNNER_TEST(T12116_DSA_key_too_short)
 949 {
 950     ScopedDBUnlock unlock(USER_APP, APP_PASS);
 951
 952     int ret;
 953     auto manager = CKM::Manager::create();
 954
 955     const std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 956         "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
 957         "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
 958         //"A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
 959         "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
 960         //"AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
 961         "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
 962         "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
 963         "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
 964         "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
 965         "YMYCBhubtrVaLmc=\n"
 966         "-----END PUBLIC KEY-----";
 967
 968     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
 969     auto key = CKM::Key::create(buffer);
 970     CKM::Alias alias = "short-dsa";
 971
 972     RUNNER_ASSERT_MSG(
 973         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 974         "Error=" << CKMErrorToString(ret));
 975 }
 976
 977 RUNNER_TEST(T12117_AES_key_too_short)
 978 {
 979     int ret;
 980     auto manager = CKM::Manager::create();
 981
 982     size_t key_size = (128-1);
 983     CKM::RawBuffer key_AES = createRandomBuffer(key_size/8);
 984
 985     auto key = CKM::Key::create(key_AES);
 986     CKM::Alias alias = "short-AES";
 987
 988     RUNNER_ASSERT_MSG(
 989         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
 990         "Error=" << CKMErrorToString(ret));
 991 }
 992
 993 /*
 994  * These test cases tests CKM service if malicious data is provided over the socket.
 995  */
 996
 997 RUNNER_TEST(T12118_RSA_key_damaged_serviceTest)
 998 {
 999     ScopedDBUnlock unlock(USER_APP, APP_PASS);
1000
1001     int ret;
1002     auto manager = CKM::Manager::create();
1003
1004     // fake the client - let the service detect the problem
1005     class WrongKeyImpl : public CKM::Key
1006     {
1007         public:
1008             WrongKeyImpl(CKM::RawBuffer & dummy_content) : m_dummy(dummy_content) {
1009             }
1010
1011             virtual bool empty() const {
1012                 return false;
1013             }
1014
1015             virtual CKM::KeyType getType() const {
1016                 return CKM::KeyType::KEY_RSA_PUBLIC;
1017             }
1018             virtual int getSize() const {
1019                 return 1024;
1020             }
1021             virtual CKM::ElipticCurve getCurve() const {
1022                 return CKM::ElipticCurve::prime192v1;
1023             }
1024             virtual CKM::RawBuffer getDER() const {
1025                 return m_dummy;
1026             }
1027             virtual ~WrongKeyImpl() {}
1028         private:
1029             CKM::RawBuffer & m_dummy;
1030     };
1031     std::string dummyData = "my_cat_Berta\n";
1032     CKM::RawBuffer buffer(dummyData.begin(), dummyData.end());
1033     auto key = std::make_shared<WrongKeyImpl>(buffer);
1034     CKM::Alias alias = "damaged-rsa";
1035
1036     RUNNER_ASSERT_MSG(
1037         CKM_API_ERROR_INPUT_PARAM == (ret = manager->saveKey(alias, key, CKM::Policy())),
1038         "Error=" << CKMErrorToString(ret));
1039 }
1040
1041 RUNNER_TEST(T12119_saveCertificate_damaged_serviceTest)
1042 {
1043     ScopedDBUnlock unlock(USER_APP, APP_PASS);
1044
1045     // fake the client - let the service detect the problem
1046     class WrongCertImpl : public CKM::Certificate
1047     {
1048         public:
1049             WrongCertImpl(CKM::RawBuffer & dummy_content) : m_dummy(dummy_content) {
1050                 m_x509 = X509_new();
1051             }
1052
1053             bool empty() const {
1054                 return false;
1055             }
1056
1057             virtual X509 *getX509() const {
1058                 return m_x509;
1059             }
1060
1061             virtual CKM::RawBuffer getDER() const {
1062                 return m_dummy;
1063             }
1064
1065             virtual ~WrongCertImpl() {
1066                 X509_free(m_x509);
1067             }
1068         private:
1069             X509* m_x509;
1070             CKM::RawBuffer & m_dummy;
1071     };
1072     std::string dummyData = "my_cat_Stefan\n";
1073     CKM::RawBuffer buffer(dummyData.begin(), dummyData.end());
1074     auto cert = std::make_shared<WrongCertImpl>(buffer);
1075     CKM::Alias alias = "damaged-cert";
1076
1077     int temp;
1078     auto manager = CKM::Manager::create();
1079     RUNNER_ASSERT_MSG(
1080         CKM_API_ERROR_INPUT_PARAM == (temp = manager->saveCertificate(alias, cert, CKM::Policy())),
1081         "Error=" << CKMErrorToString(temp));
1082 }
1083
1084 RUNNER_TEST(T12120_deinit)
1085 {
1086     remove_user_data(USER_APP);
1087 }
1088
1089 RUNNER_TEST_GROUP_INIT(T131_CKM_QUICK_SET_GET_TESTS);
1090
1091 RUNNER_TEST(T1311_init)
1092 {
1093     remove_user_data(USER_APP);
1094     RUNNER_ASSERT_MSG(time(0) > 1405343457,
1095         "Time error. Device date is before 14th of July 2014. You must set proper time on device before run this tests!");
1096
1097     struct hostent* he = gethostbyname("google.com");
1098
1099     RUNNER_ASSERT_MSG(he != NULL, "There is problem with translate domain google.com into ip address. Probably network "
1100         "is not woking on the device. OCSP tests requires network access!");
1101 }
1102
1103 RUNNER_TEST(T13121_get_chain_no_cert)
1104 {
1105     CKM::CertificateShPtrVector certChain;
1106     CKM::CertificateShPtr cert;
1107
1108     auto manager = CKM::Manager::create();
1109
1110     int ret = manager->getCertificateChain(cert,
1111                                        EMPTY_CERT_VECTOR,
1112                                        EMPTY_CERT_VECTOR,
1113                                        true,
1114                                        certChain);
1115     RUNNER_ASSERT_MSG(CKM_API_ERROR_INPUT_PARAM == ret,
1116                          "Function should fail for empty certificate");
1117 }
1118
1119 RUNNER_TEST(T13122_get_chain_empty_cert)
1120 {
1121     CKM::CertificateShPtrVector certChain;
1122     CKM::CertificateShPtr cert = CKM::Certificate::create(CKM::RawBuffer(),
1123                                                           CKM::DataFormat::FORM_PEM);
1124
1125     auto manager = CKM::Manager::create();
1126
1127     int ret = manager->getCertificateChain(cert,
1128                                        EMPTY_CERT_VECTOR,
1129                                        EMPTY_CERT_VECTOR,
1130                                        true,
1131                                        certChain);
1132     RUNNER_ASSERT_MSG(CKM_API_ERROR_INPUT_PARAM == ret,
1133                          "Function should fail for empty certificate");
1134 }
1135
1136 RUNNER_TEST(T13129_get_chain)
1137 {
1138     auto cert = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_LEAF);
1139     auto cert1 = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_IM);
1140
1141     CKM::CertificateShPtrVector certVector = {cert1};
1142     CKM::CertificateShPtrVector certChain;
1143
1144     int tmp;
1145     auto manager = CKM::Manager::create();
1146
1147     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1148     RUNNER_ASSERT_MSG(false != cert1.get(), "Certificate should not be empty");
1149
1150     tmp = manager->getCertificateChain(cert,
1151                                        EMPTY_CERT_VECTOR,
1152                                        EMPTY_CERT_VECTOR,
1153                                        true,
1154                                        certChain);
1155     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1156                          "Error=" << CKMErrorToString(tmp));
1157
1158     RUNNER_ASSERT_MSG(
1159         0 == certChain.size(),
1160         "Wrong size of certificate chain.");
1161
1162     tmp = manager->getCertificateChain(cert, certVector, EMPTY_CERT_VECTOR, true, certChain);
1163     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKMErrorToString(tmp));
1164
1165     RUNNER_ASSERT_MSG(
1166         3 == certChain.size(),
1167         "Wrong size of certificate chain.");
1168 }
1169
1170 RUNNER_TEST(T1313_get_chain_with_alias)
1171 {
1172     auto cert = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_LEAF);
1173     auto cert1 = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_IM);
1174
1175     CKM::CertificateShPtrVector certChain;
1176     CKM::AliasVector aliasVector;
1177     CKM::Alias alias = "imcert";
1178
1179     int tmp;
1180     auto manager = CKM::Manager::create();
1181
1182     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1183     RUNNER_ASSERT_MSG(NULL != cert1.get(), "Certificate should not be empty");
1184
1185     tmp = manager->getCertificateChain(cert, aliasVector, EMPTY_ALIAS_VECTOR, true, certChain);
1186     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1187                          "Error=" << CKMErrorToString(tmp));
1188
1189     RUNNER_ASSERT_MSG(
1190         0 == certChain.size(),
1191         "Wrong size of certificate chain.");
1192
1193     RUNNER_ASSERT_MSG(
1194         CKM_API_SUCCESS == (tmp = manager->saveCertificate(alias, cert1, CKM::Policy())),
1195         "Error=" << CKMErrorToString(tmp));
1196
1197     aliasVector.push_back(alias);
1198
1199     tmp = manager->getCertificateChain(cert, aliasVector, EMPTY_ALIAS_VECTOR, true, certChain);
1200     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKMErrorToString(tmp));
1201
1202     RUNNER_ASSERT_MSG(
1203         3 == certChain.size(),
1204         "Wrong size of certificate chain.");
1205 }
1206
1207 RUNNER_TEST(T13141_ocsp_check_valid_chain)
1208 {
1209     auto cert = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_LEAF);
1210     auto cert1 = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_IM);
1211     CKM::CertificateShPtrVector certVector = {cert1};
1212     CKM::CertificateShPtrVector certChain;
1213
1214     int tmp;
1215     auto manager = CKM::Manager::create();
1216
1217     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1218     RUNNER_ASSERT_MSG(NULL != cert1.get(), "Certificate should not be empty");
1219
1220     tmp = manager->getCertificateChain(cert, EMPTY_CERT_VECTOR, EMPTY_CERT_VECTOR, true, certChain);
1221     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1222                          "Error=" << CKMErrorToString(tmp));
1223
1224     RUNNER_ASSERT_MSG(
1225         0 == certChain.size(),
1226         "Wrong size of certificate chain.");
1227
1228     tmp = manager->getCertificateChain(cert, certVector, EMPTY_CERT_VECTOR, true, certChain);
1229     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKMErrorToString(tmp));
1230
1231     RUNNER_ASSERT_MSG(
1232         3 == certChain.size(),
1233         "Wrong size of certificate chain.");
1234
1235     int status;
1236     RUNNER_ASSERT_MSG(
1237         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certChain, status)),
1238         "Error=" << CKMErrorToString(tmp));
1239
1240     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_GOOD == status, "Verfication failed");
1241 }
1242
1243 RUNNER_TEST(T13142_ocsp_check_empty)
1244 {
1245     CKM::CertificateShPtrVector certVector;
1246
1247     auto manager = CKM::Manager::create();
1248
1249     int tmp;
1250     int status;
1251     RUNNER_ASSERT_MSG(
1252             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1253         "ocspCheck should fail for empty certificate vector");
1254 }
1255
1256 RUNNER_TEST(T13143_ocsp_check_empty_ptrs)
1257 {
1258     CKM::CertificateShPtrVector certVector = {
1259             CKM::CertificateShPtr(),
1260             CKM::CertificateShPtr(),
1261             CKM::CertificateShPtr()};
1262
1263     auto manager = CKM::Manager::create();
1264
1265     int tmp;
1266     int status;
1267     RUNNER_ASSERT_MSG(
1268             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1269         "ocspCheck should fail for empty certificate vector");
1270 }
1271
1272 RUNNER_TEST(T13144_ocsp_check_root)
1273 {
1274     auto root = TestData::getTestCertificate(TestData::THIRD_PARTY_ROOT_CA);
1275     CKM::CertificateShPtrVector certVector = {root};
1276
1277     auto manager = CKM::Manager::create();
1278
1279     RUNNER_ASSERT_MSG(NULL != root.get(), "Certificate should not be empty");
1280
1281     int tmp;
1282     int status;
1283     RUNNER_ASSERT_MSG(
1284             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1285         "Ocsp should fail for single certificate");
1286 }
1287
1288 RUNNER_TEST(T13145_ocsp_check_no_ocsp)
1289 {
1290     auto root = TestData::getTestCertificate(TestData::TEST_ROOT_CA);
1291     auto ca = TestData::getTestCertificate(TestData::TEST_IM_CA);
1292
1293     CKM::CertificateShPtrVector certVector = {ca, root};
1294
1295     auto manager = CKM::Manager::create();
1296
1297     RUNNER_ASSERT_MSG(NULL != root.get(), "Certificate should not be empty");
1298     RUNNER_ASSERT_MSG(NULL != ca.get(), "Certificate should not be empty");
1299
1300     int tmp;
1301     int status;
1302     RUNNER_ASSERT_MSG(
1303         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certVector, status)),
1304         "Error=" << CKMErrorToString(tmp));
1305
1306     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_UNSUPPORTED == status, "Verfication failed");
1307 }
1308
1309 RUNNER_TEST(T1315_deinit)
1310 {
1311     remove_user_data(USER_APP);
1312 }
1313
1314 RUNNER_TEST_GROUP_INIT(T141_CREATE_AND_VERIFY_SIGNATURE);
1315
1316 RUNNER_TEST(T1411_init)
1317 {
1318     remove_user_data(USER_APP);
1319 }
1320
1321 RUNNER_TEST(T1412_RSA_key_create_verify)
1322 {
1323     int temp;
1324     auto manager = CKM::Manager::create();
1325
1326     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1327       "Proc-Type: 4,ENCRYPTED\n"
1328       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1329       "\n"
1330       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1331       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1332       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1333       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1334       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1335       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1336       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1337       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1338       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1339       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1340       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1341       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1342       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1343       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1344       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1345       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1346       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1347       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1348       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1349       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1350       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1351       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1352       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1353       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1354       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1355       "-----END RSA PRIVATE KEY-----\n";
1356
1357     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1358       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1359       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1360       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1361       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1362       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1363       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1364       "zQIDAQAB\n"
1365       "-----END PUBLIC KEY-----\n";
1366
1367     std::string message = "message test";
1368
1369     CKM::Alias aliasPub = "pub1";
1370     CKM::Alias aliasPrv = "prv1";
1371     CKM::Password password = "1234";
1372     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1373     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1374     CKM::RawBuffer signature;
1375
1376     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1377     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
1378
1379     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1380         "Key is empty. Failed to import public key.");
1381     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1382         "Key is empty. Failed to import private key.");
1383
1384     RUNNER_ASSERT_MSG(
1385         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1386         "Error=" << CKMErrorToString(temp));
1387     RUNNER_ASSERT_MSG(
1388         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1389         "Error=" << CKMErrorToString(temp));
1390
1391     RUNNER_ASSERT_MSG(
1392         CKM_API_SUCCESS == (temp = manager->createSignature(
1393                                         aliasPrv,
1394                                         CKM::Password(),
1395                                         CKM::RawBuffer(message.begin(), message.end()),
1396                                         hash,
1397                                         padd,
1398                                         signature)),
1399         "Error=" << CKMErrorToString(temp));
1400
1401     RUNNER_ASSERT_MSG(
1402         CKM_API_SUCCESS == (temp = manager->verifySignature(
1403                                         aliasPub,
1404                                         CKM::Password(),
1405                                         CKM::RawBuffer(message.begin(), message.end()),
1406                                         signature,
1407                                         hash,
1408                                         padd)),
1409         "Error=" << CKMErrorToString(temp));
1410 }
1411
1412 RUNNER_TEST(T1413_DSA_key_create_verify)
1413 {
1414     int temp;
1415     auto manager = CKM::Manager::create();
1416
1417     std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1418             "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1419             "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1420             "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1421             "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1422             "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1423             "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1424             "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1425             "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1426             "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1427             "u1roOuaPY+Hl19BlTE2qdw==\n"
1428             "-----END DSA PRIVATE KEY-----";
1429
1430     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1431             "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1432             "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1433             "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1434             "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1435             "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1436             "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1437             "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1438             "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1439             "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1440             "YMYCBhubtrVaLmc=\n"
1441             "-----END PUBLIC KEY-----";
1442
1443     std::string message = "message test";
1444
1445     CKM::Alias aliasPub = "pub2";
1446     CKM::Alias aliasPrv = "prv2";
1447     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1448     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1449     CKM::RawBuffer signature;
1450
1451     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1452     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
1453
1454     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1455         "Key is empty. Failed to import public key.");
1456     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1457         "Key is empty. Failed to import private key.");
1458
1459     RUNNER_ASSERT_MSG(
1460         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1461         "Error=" << CKMErrorToString(temp));
1462     RUNNER_ASSERT_MSG(
1463         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1464         "Error=" << CKMErrorToString(temp));
1465
1466     RUNNER_ASSERT_MSG(
1467         CKM_API_SUCCESS == (temp = manager->createSignature(
1468                                         aliasPrv,
1469                                         CKM::Password(),
1470                                         CKM::RawBuffer(message.begin(), message.end()),
1471                                         hash,
1472                                         padd,
1473                                         signature)),
1474         "Error=" << CKMErrorToString(temp));
1475
1476     RUNNER_ASSERT_MSG(
1477         CKM_API_SUCCESS == (temp = manager->verifySignature(
1478                                         aliasPub,
1479                                         CKM::Password(),
1480                                         CKM::RawBuffer(message.begin(), message.end()),
1481                                         signature,
1482                                         hash,
1483                                         padd)),
1484         "Error=" << CKMErrorToString(temp));
1485 }
1486
1487
1488 RUNNER_TEST(T1414_ECDSA_key_create_verify)
1489 {
1490     int temp;
1491     auto manager = CKM::Manager::create();
1492
1493     std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1494         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1495         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1496         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1497         "-----END EC PRIVATE KEY-----\n";
1498
1499     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1500         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1501         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1502         "-----END PUBLIC KEY-----\n";
1503
1504     std::string message = "message test";
1505
1506     CKM::Alias aliasPub = "ecpub2";
1507     CKM::Alias aliasPrv = "ecprv2";
1508     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1509     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1510     CKM::RawBuffer signature;
1511
1512     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1513     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1514
1515     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1516         "Key is empty. Failed to import public key.");
1517     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1518         "Key is empty. Failed to import private key.");
1519
1520     RUNNER_ASSERT_MSG(
1521         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1522         "Error=" << CKMErrorToString(temp));
1523     RUNNER_ASSERT_MSG(
1524         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1525         "Error=" << CKMErrorToString(temp));
1526
1527     RUNNER_ASSERT_MSG(
1528         CKM_API_SUCCESS == (temp = manager->createSignature(
1529                                         aliasPrv,
1530                                         CKM::Password(),
1531                                         CKM::RawBuffer(message.begin(), message.end()),
1532                                         hash,
1533                                         padd,
1534                                         signature)),
1535         "Error=" << CKMErrorToString(temp));
1536
1537     RUNNER_ASSERT_MSG(
1538         CKM_API_SUCCESS == (temp = manager->verifySignature(
1539                                         aliasPub,
1540                                         CKM::Password(),
1541                                         CKM::RawBuffer(message.begin(), message.end()),
1542                                         signature,
1543                                         hash,
1544                                         padd)),
1545         "Error=" << CKMErrorToString(temp));
1546
1547     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1548
1549     memcpy((void*)signature.data(), "BROKEN", 6);
1550
1551     RUNNER_ASSERT_MSG(
1552         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1553                                         aliasPub,
1554                                         CKM::Password(),
1555                                         CKM::RawBuffer(message.begin(), message.end()),
1556                                         signature,
1557                                         hash,
1558                                         padd)),
1559         "Error=" << CKMErrorToString(temp));
1560 }
1561
1562 RUNNER_TEST(T1415_RSA_key_create_verify_negative)
1563 {
1564     int temp;
1565     auto manager = CKM::Manager::create();
1566     std::string message = "message asdfaslkdfjlksadjf test";
1567
1568     CKM::Alias aliasPub = "pub1";
1569     CKM::Alias aliasPrv = "prv1";
1570
1571     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1572     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1573     CKM::RawBuffer signature;
1574
1575     RUNNER_ASSERT_MSG(
1576         CKM_API_SUCCESS == (temp = manager->createSignature(
1577                                         aliasPrv,
1578                                         CKM::Password(),
1579                                         CKM::RawBuffer(message.begin(), message.end()),
1580                                         hash,
1581                                         padd,
1582                                         signature)),
1583         "Error=" << CKMErrorToString(temp));
1584
1585     RUNNER_ASSERT_MSG(
1586         CKM_API_SUCCESS == (temp = manager->verifySignature(
1587                                         aliasPub,
1588                                         CKM::Password(),
1589                                         CKM::RawBuffer(message.begin(), message.end()),
1590                                         signature,
1591                                         hash,
1592                                         padd)),
1593         "Error=" << CKMErrorToString(temp));
1594
1595     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1596     memcpy((void*)signature.data(), "BROKEN", 6);
1597
1598     RUNNER_ASSERT_MSG(
1599         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1600                                         aliasPub,
1601                                         CKM::Password(),
1602                                         CKM::RawBuffer(message.begin(), message.end()),
1603                                         signature,
1604                                         hash,
1605                                         padd)),
1606         "Error=" << CKMErrorToString(temp));
1607 }
1608
1609 RUNNER_TEST(T1416_DSA_key_create_verify_negative)
1610 {
1611     int temp;
1612     auto manager = CKM::Manager::create();
1613     std::string message = "message asdfaslkdfjlksadjf test";
1614
1615     CKM::Alias aliasPub = "pub2";
1616     CKM::Alias aliasPrv = "prv2";
1617
1618     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1619     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1620     CKM::RawBuffer signature;
1621
1622     RUNNER_ASSERT_MSG(
1623         CKM_API_SUCCESS == (temp = manager->createSignature(
1624                                         aliasPrv,
1625                                         CKM::Password(),
1626                                         CKM::RawBuffer(message.begin(), message.end()),
1627                                         hash,
1628                                         padd,
1629                                         signature)),
1630         "Error=" << CKMErrorToString(temp));
1631
1632     RUNNER_ASSERT_MSG(
1633         CKM_API_SUCCESS == (temp = manager->verifySignature(
1634                                         aliasPub,
1635                                         CKM::Password(),
1636                                         CKM::RawBuffer(message.begin(), message.end()),
1637                                         signature,
1638                                         hash,
1639                                         padd)),
1640         "Error=" << CKMErrorToString(temp));
1641
1642     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1643     memcpy((void*)signature.data(), "BROKEN", 6);
1644
1645     RUNNER_ASSERT_MSG(
1646         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1647                                         aliasPub,
1648                                         CKM::Password(),
1649                                         CKM::RawBuffer(message.begin(), message.end()),
1650                                         signature,
1651                                         hash,
1652                                         padd)),
1653         "Error=" << CKMErrorToString(temp));
1654 }
1655
1656 RUNNER_TEST(T1417_RSA_cert_create_verify_signature)
1657 {
1658     int temp;
1659     auto manager = CKM::Manager::create();
1660
1661     std::string prv =
1662       "-----BEGIN RSA PRIVATE KEY-----\n"
1663       "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1664       "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1665       "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1666       "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1667       "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1668       "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1669       "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1670       "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1671       "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1672       "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1673       "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1674       "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1675       "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1676       "-----END RSA PRIVATE KEY-----\n";
1677
1678     std::string pub =
1679       "-----BEGIN CERTIFICATE-----\n"
1680       "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1681       "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1682       "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1683       "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1684       "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1685       "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1686       "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1687       "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1688       "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1689       "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1690       "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1691       "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1692       "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1693       "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1694       "-----END CERTIFICATE-----\n";
1695
1696     std::string message = "message test";
1697
1698     CKM::Alias aliasPub = "pub1-cert";
1699     CKM::Alias aliasPrv = "prv1-cert";
1700     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1701     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1702     CKM::RawBuffer signature;
1703
1704     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1705     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1706
1707     RUNNER_ASSERT_MSG(NULL != cert.get(),
1708         "Key is empty. Failed to import public key.");
1709     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1710         "Key is empty. Failed to import private key.");
1711
1712     RUNNER_ASSERT_MSG(
1713         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1714         "Error=" << CKMErrorToString(temp));
1715     RUNNER_ASSERT_MSG(
1716         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1717         "Error=" << CKMErrorToString(temp));
1718
1719     RUNNER_ASSERT_MSG(
1720         CKM_API_SUCCESS == (temp = manager->createSignature(
1721                                         aliasPrv,
1722                                         CKM::Password(),
1723                                         CKM::RawBuffer(message.begin(), message.end()),
1724                                         hash,
1725                                         padd,
1726                                         signature)),
1727         "Error=" << CKMErrorToString(temp));
1728
1729     RUNNER_ASSERT_MSG(
1730         CKM_API_SUCCESS == (temp = manager->verifySignature(
1731                                         aliasPub,
1732                                         CKM::Password(),
1733                                         CKM::RawBuffer(message.begin(), message.end()),
1734                                         signature,
1735                                         hash,
1736                                         padd)),
1737         "Error=" << CKMErrorToString(temp));
1738
1739     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1740
1741     memcpy((void*)signature.data(), "BROKEN", 6);
1742
1743     RUNNER_ASSERT_MSG(
1744         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1745                                         aliasPub,
1746                                         CKM::Password(),
1747                                         CKM::RawBuffer(message.begin(), message.end()),
1748                                         signature,
1749                                         hash,
1750                                         padd)),
1751         "Error=" << CKMErrorToString(temp));
1752 }
1753
1754 RUNNER_TEST(T1418_DSA_cert_create_verify_signature)
1755 {
1756     int temp;
1757     auto manager = CKM::Manager::create();
1758
1759     const std::string pub = "-----BEGIN CERTIFICATE-----\n"
1760         "MIIDUzCCAxECCQCer/fKcXtJgTALBglghkgBZQMEAwIwgYsxCzAJBgNVBAYTAlBM\n"
1761         "MQ8wDQYDVQQIDAZQb2xhbmQxDzANBgNVBAcMBldhcnNhdzEQMA4GA1UECgwHU2Ft\n"
1762         "c3VuZzEMMAoGA1UECwwDS1NGMRMwEQYDVQQDDAptLmthcnBpdWsyMSUwIwYJKoZI\n"
1763         "hvcNAQkBFhZtLmthcnBpdWsyQHNhbXN1bmcuY29tMCAXDTE0MDkyNjEzNTQwN1oY\n"
1764         "DzIxNDAwOTA1MTM1NDA3WjCBizELMAkGA1UEBhMCUEwxDzANBgNVBAgMBlBvbGFu\n"
1765         "ZDEPMA0GA1UEBwwGV2Fyc2F3MRAwDgYDVQQKDAdTYW1zdW5nMQwwCgYDVQQLDANL\n"
1766         "U0YxEzARBgNVBAMMCm0ua2FycGl1azIxJTAjBgkqhkiG9w0BCQEWFm0ua2FycGl1\n"
1767         "azJAc2Ftc3VuZy5jb20wggG3MIIBKwYHKoZIzjgEATCCAR4CgYEA9Bhh7ZA4onkY\n"
1768         "uDNQbYR4EwkJ6RpD505hB0GF6yppUNp2LanvNcQXcyXY88MB6OdP7Rikbu1H2zP4\n"
1769         "gONCtdxKW58Za7h9bFzYjxcObZsS52F9DP7sv3C4sX4xNWApfhUgbfzKaRCJOkOs\n"
1770         "06tV7teu3G/v26PdI8dlykIuQXQZmH8CFQCHsIV0njb2yC3ggfKz+exH+g5jAQKB\n"
1771         "gBVLYfVCMjUz5XJH+xYU3A8W8rpSLqZKIK2d9mbXqhpz8QK1bvNQUlSRZo+o1ZYV\n"
1772         "mJn3Mx2YuiifHZNKdBNweCqe5a+HV2RSl1Yv/TV9famZKlogGslsmPHUOJMlSIdh\n"
1773         "MfMwVny4/rNtjEtEFE1WnaTr1W6MKH1EBbizVo8fmWFrA4GFAAKBgQCaPjrlkAyX\n"
1774         "kBitWo+w0xZN4OSk13SsCzZ/PG+5zOgMRaFm2XbiC04YsGCi4NFOd9kaiP7w1CsP\n"
1775         "iqG6Vwv0T/VcoxBl/hp6jEqTDSrM6z0ungjDO9wGOdI+jZS0UjVahgC4ZLDHhrOa\n"
1776         "CjfxcHruO3e416b/Rm2CjhOzjKdoSFUWVzALBglghkgBZQMEAwIDLwAwLAIUHa+A\n"
1777         "5xo8O/tPuH9gXkr1mee6kRYCFGNycJ1xkc3nIJaEQOtGfDe7S71A\n"
1778         "-----END CERTIFICATE-----\n";
1779
1780     const std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1781         "MIIBuwIBAAKBgQD0GGHtkDiieRi4M1BthHgTCQnpGkPnTmEHQYXrKmlQ2nYtqe81\n"
1782         "xBdzJdjzwwHo50/tGKRu7UfbM/iA40K13EpbnxlruH1sXNiPFw5tmxLnYX0M/uy/\n"
1783         "cLixfjE1YCl+FSBt/MppEIk6Q6zTq1Xu167cb+/bo90jx2XKQi5BdBmYfwIVAIew\n"
1784         "hXSeNvbILeCB8rP57Ef6DmMBAoGAFUth9UIyNTPlckf7FhTcDxbyulIupkogrZ32\n"
1785         "ZteqGnPxArVu81BSVJFmj6jVlhWYmfczHZi6KJ8dk0p0E3B4Kp7lr4dXZFKXVi/9\n"
1786         "NX19qZkqWiAayWyY8dQ4kyVIh2Ex8zBWfLj+s22MS0QUTVadpOvVbowofUQFuLNW\n"
1787         "jx+ZYWsCgYEAmj465ZAMl5AYrVqPsNMWTeDkpNd0rAs2fzxvuczoDEWhZtl24gtO\n"
1788         "GLBgouDRTnfZGoj+8NQrD4qhulcL9E/1XKMQZf4aeoxKkw0qzOs9Lp4IwzvcBjnS\n"
1789         "Po2UtFI1WoYAuGSwx4azmgo38XB67jt3uNem/0Ztgo4Ts4ynaEhVFlcCFGMH+Z9l\n"
1790         "vonbjii3BYe4AIdkzOvp\n"
1791         "-----END DSA PRIVATE KEY-----\n";
1792
1793     std::string message = "message test";
1794
1795     CKM::Alias aliasPub = "pub2-cert";
1796     CKM::Alias aliasPrv = "prv2-cert";
1797     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1798     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1799     CKM::RawBuffer signature;
1800
1801     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1802     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1803
1804     RUNNER_ASSERT_MSG(NULL != cert.get(),
1805         "Key is empty. Failed to import public key.");
1806     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1807         "Key is empty. Failed to import private key.");
1808
1809     RUNNER_ASSERT_MSG(
1810         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1811         "Error=" << CKMErrorToString(temp));
1812     RUNNER_ASSERT_MSG(
1813         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1814         "Error=" << CKMErrorToString(temp));
1815
1816     RUNNER_ASSERT_MSG(
1817         CKM_API_SUCCESS == (temp = manager->createSignature(
1818                                         aliasPrv,
1819                                         CKM::Password(),
1820                                         CKM::RawBuffer(message.begin(), message.end()),
1821                                         hash,
1822                                         padd,
1823                                         signature)),
1824         "Error=" << CKMErrorToString(temp));
1825
1826     RUNNER_ASSERT_MSG(
1827         CKM_API_SUCCESS == (temp = manager->verifySignature(
1828                                         aliasPub,
1829                                         CKM::Password(),
1830                                         CKM::RawBuffer(message.begin(), message.end()),
1831                                         signature,
1832                                         hash,
1833                                         padd)),
1834         "Error=" << CKMErrorToString(temp));
1835
1836     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1837
1838     memcpy((void*)signature.data(), "BROKEN", 6);
1839
1840     RUNNER_ASSERT_MSG(
1841         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1842                                         aliasPub,
1843                                         CKM::Password(),
1844                                         CKM::RawBuffer(message.begin(), message.end()),
1845                                         signature,
1846                                         hash,
1847                                         padd)),
1848         "Error=" << CKMErrorToString(temp));
1849 }
1850
1851 RUNNER_TEST(T1419_ECDSA_cert_create_verify_signature)
1852 {
1853     int temp;
1854     auto manager = CKM::Manager::create();
1855
1856     std::string prv =
1857       "-----BEGIN EC PRIVATE KEY-----\n"
1858       "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1859       "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1860       "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1861       "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1862       "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1863       "ELyhe7yPCAuOoLZlTLgf\n"
1864       "-----END EC PRIVATE KEY-----\n";
1865
1866     std::string pub =
1867       "-----BEGIN CERTIFICATE-----\n"
1868       "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1869       "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1870       "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1871       "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1872       "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1873       "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1874       "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1875       "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1876       "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1877       "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1878       "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1879       "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1880       "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1881       "Q1oBry6NEc+lLFmWMDesAA==\n"
1882       "-----END CERTIFICATE-----\n";
1883
1884     std::string message = "message test";
1885
1886     CKM::Alias aliasPub = "pub3";
1887     CKM::Alias aliasPrv = "prv3";
1888     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1889     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1890     CKM::RawBuffer signature;
1891
1892     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1893     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1894
1895     RUNNER_ASSERT_MSG(NULL != cert.get(),
1896         "Key is empty. Failed to import public key.");
1897     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1898         "Key is empty. Failed to import private key.");
1899
1900     RUNNER_ASSERT_MSG(
1901         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1902         "Error=" << CKMErrorToString(temp));
1903     RUNNER_ASSERT_MSG(
1904         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1905         "Error=" << CKMErrorToString(temp));
1906
1907     RUNNER_ASSERT_MSG(
1908         CKM_API_SUCCESS == (temp = manager->createSignature(
1909                                         aliasPrv,
1910                                         CKM::Password(),
1911                                         CKM::RawBuffer(message.begin(), message.end()),
1912                                         hash,
1913                                         padd,
1914                                         signature)),
1915         "Error=" << CKMErrorToString(temp));
1916
1917     RUNNER_ASSERT_MSG(
1918         CKM_API_SUCCESS == (temp = manager->verifySignature(
1919                                         aliasPub,
1920                                         CKM::Password(),
1921                                         CKM::RawBuffer(message.begin(), message.end()),
1922                                         signature,
1923                                         hash,
1924                                         padd)),
1925         "Error=" << CKMErrorToString(temp));
1926
1927     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1928
1929     memcpy((void*)signature.data(), "BROKEN", 6);
1930
1931     RUNNER_ASSERT_MSG(
1932         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1933                                         aliasPub,
1934                                         CKM::Password(),
1935                                         CKM::RawBuffer(message.begin(), message.end()),
1936                                         signature,
1937                                         hash,
1938                                         padd)),
1939         "Error=" << CKMErrorToString(temp));
1940 }
1941
1942 RUNNER_TEST(T1420_deinit)
1943 {
1944     remove_user_data(USER_APP);
1945 }
1946
1947 RUNNER_TEST_GROUP_INIT(T1418_signature_tests);
1948
1949 RUNNER_TEST(T14180_init)
1950 {
1951     int temp;
1952     remove_user_data(USER_APP);
1953
1954     auto manager = CKM::Manager::create();
1955
1956     // Prepare RSA Key Pair
1957     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1958       "Proc-Type: 4,ENCRYPTED\n"
1959       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1960       "\n"
1961       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1962       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1963       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1964       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1965       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1966       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1967       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1968       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1969       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1970       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1971       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1972       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1973       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1974       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1975       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1976       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1977       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1978       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1979       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1980       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1981       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1982       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1983       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1984       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1985       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1986       "-----END RSA PRIVATE KEY-----\n";
1987
1988     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1989       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1990       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1991       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1992       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1993       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1994       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1995       "zQIDAQAB\n"
1996       "-----END PUBLIC KEY-----\n";
1997
1998     CKM::Alias aliasPub = "pub_nohash1";
1999     CKM::Alias aliasPrv = "prv_nohash1";
2000     CKM::Password password = "1234";
2001
2002     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
2003     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
2004
2005     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
2006         "Key is empty. Failed to import public key.");
2007     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2008         "Key is empty. Failed to import private key.");
2009
2010     RUNNER_ASSERT_MSG(
2011         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
2012         "Error=" << CKMErrorToString(temp));
2013     RUNNER_ASSERT_MSG(
2014         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
2015         "Error=" << CKMErrorToString(temp));
2016
2017     // Prepare ECDSA Key Pair
2018     std::string ecprv = "-----BEGIN EC PRIVATE KEY-----\n"
2019         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
2020         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
2021         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2022         "-----END EC PRIVATE KEY-----\n";
2023
2024     std::string ecpub = "-----BEGIN PUBLIC KEY-----\n"
2025         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
2026         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2027         "-----END PUBLIC KEY-----\n";
2028
2029     CKM::Alias aliasEcPub = "ecpub_nohash1";
2030     CKM::Alias aliasEcPrv = "ecprv_nohash1";
2031
2032     auto ecKeyPub = CKM::Key::create(CKM::RawBuffer(ecpub.begin(), ecpub.end()));
2033     auto ecKeyPrv = CKM::Key::create(CKM::RawBuffer(ecprv.begin(), ecprv.end()));
2034
2035     RUNNER_ASSERT_MSG(NULL != ecKeyPub.get(),
2036         "Key is empty. Failed to import public key.");
2037     RUNNER_ASSERT_MSG(NULL != ecKeyPrv.get(),
2038         "Key is empty. Failed to import private key.");
2039
2040     RUNNER_ASSERT_MSG(
2041         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPub, ecKeyPub, CKM::Policy())),
2042         "Error=" << CKMErrorToString(temp));
2043     RUNNER_ASSERT_MSG(
2044         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPrv, ecKeyPrv, CKM::Policy())),
2045         "Error=" << CKMErrorToString(temp));
2046 }
2047
2048
2049 RUNNER_TEST(T14181_RSA_create_signatue_nohash)
2050 {
2051     int temp;
2052     auto manager = CKM::Manager::create();
2053     std::string message = "message asdfaslkdfjlksadjf test";
2054
2055     CKM::Alias aliasPub = "pub_nohash1";
2056     CKM::Alias aliasPrv = "prv_nohash1";
2057
2058     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2059     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2060     CKM::RawBuffer signature;
2061
2062     RUNNER_ASSERT_MSG(
2063         CKM_API_SUCCESS == (temp = manager->createSignature(
2064                                         aliasPrv,
2065                                         CKM::Password(),
2066                                         CKM::RawBuffer(message.begin(), message.end()),
2067                                         hash,
2068                                         padd,
2069                                         signature)),
2070         "Error=" << CKMErrorToString(temp));
2071
2072     RUNNER_ASSERT_MSG(
2073         CKM_API_SUCCESS == (temp = manager->verifySignature(
2074                                         aliasPub,
2075                                         CKM::Password(),
2076                                         CKM::RawBuffer(message.begin(), message.end()),
2077                                         signature,
2078                                         hash,
2079                                         padd)),
2080         "Error=" << CKMErrorToString(temp));
2081
2082     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2083     memcpy((void*)signature.data(), "BROKEN", 6);
2084
2085     RUNNER_ASSERT_MSG(
2086         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2087                                         aliasPub,
2088                                         CKM::Password(),
2089                                         CKM::RawBuffer(message.begin(), message.end()),
2090                                         signature,
2091                                         hash,
2092                                         padd)),
2093         "Error=" << CKMErrorToString(temp));
2094 }
2095
2096 RUNNER_TEST(T14182_RSA_create_signatue_nohash_nopad)
2097 {
2098     int temp;
2099     auto manager = CKM::Manager::create();
2100     std::string message = "message asdfaslkdfjlksadjf test";
2101
2102     CKM::Alias aliasPub = "pub_nohash1";
2103     CKM::Alias aliasPrv = "prv_nohash1";
2104
2105     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2106     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2107     CKM::RawBuffer signature;
2108
2109     RUNNER_ASSERT_MSG(
2110         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2111                                         aliasPrv,
2112                                         CKM::Password(),
2113                                         CKM::RawBuffer(message.begin(), message.end()),
2114                                         hash,
2115                                         padd,
2116                                         signature)),
2117         "Error=" << CKMErrorToString(temp));
2118 }
2119
2120 RUNNER_TEST(T14183_RSA_create_signatue_nohash_bigmsg)
2121 {
2122     int temp;
2123     auto manager = CKM::Manager::create();
2124     std::string message = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2125                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2126                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2127                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2128                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2129                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2130                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2131                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2132                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2133                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2134                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2135                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2136                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2137                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2138                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2139                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2140                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2141                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2142                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2143                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
2144
2145     CKM::Alias aliasPub = "pub_nohash1";
2146     CKM::Alias aliasPrv = "prv_nohash1";
2147
2148     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2149     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2150     CKM::RawBuffer signature;
2151
2152     RUNNER_ASSERT_MSG(
2153         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2154                                         aliasPrv,
2155                                         CKM::Password(),
2156                                         CKM::RawBuffer(message.begin(), message.end()),
2157                                         hash,
2158                                         padd,
2159                                         signature)),
2160         "Error=" << CKMErrorToString(temp));
2161 }
2162
2163
2164 RUNNER_TEST(T14184_ECDSA_create_signatue_nohash)
2165 {
2166     int temp;
2167     auto manager = CKM::Manager::create();
2168
2169     std::string message = "message test";
2170
2171     CKM::Alias aliasPub = "ecpub_nohash1";
2172     CKM::Alias aliasPrv = "ecprv_nohash1";
2173     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2174     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2175     CKM::RawBuffer signature;
2176
2177     RUNNER_ASSERT_MSG(
2178         CKM_API_SUCCESS == (temp = manager->createSignature(
2179                                         aliasPrv,
2180                                         CKM::Password(),
2181                                         CKM::RawBuffer(message.begin(), message.end()),
2182                                         hash,
2183                                         padd,
2184                                         signature)),
2185         "Error=" << CKMErrorToString(temp));
2186
2187     RUNNER_ASSERT_MSG(
2188         CKM_API_SUCCESS == (temp = manager->verifySignature(
2189                                         aliasPub,
2190                                         CKM::Password(),
2191                                         CKM::RawBuffer(message.begin(), message.end()),
2192                                         signature,
2193                                         hash,
2194                                         padd)),
2195         "Error=" << CKMErrorToString(temp));
2196
2197     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2198
2199     memcpy((void*)signature.data(), "BROKEN", 6);
2200
2201     RUNNER_ASSERT_MSG(
2202         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2203                                         aliasPub,
2204                                         CKM::Password(),
2205                                         CKM::RawBuffer(message.begin(), message.end()),
2206                                         signature,
2207                                         hash,
2208                                         padd)),
2209         "Error=" << CKMErrorToString(temp));
2210 }
2211
2212 RUNNER_TEST(T14185_ECDSA_create_signatue_nohash_bigmsg)
2213 {
2214     int temp;
2215     auto manager = CKM::Manager::create();
2216
2217     int msgSize = 1024*1024;
2218     char big_msg[msgSize];
2219     for(int i =0; i<msgSize-1; i++) {
2220         big_msg[i] = 'a';
2221     }
2222     big_msg[msgSize-1]=0x00;
2223     std::string message(big_msg);
2224
2225     CKM::Alias aliasPub = "ecpub_nohash1";
2226     CKM::Alias aliasPrv = "ecprv_nohash1";
2227     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2228     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2229     CKM::RawBuffer signature;
2230
2231     RUNNER_ASSERT_MSG(
2232             CKM_API_SUCCESS == (temp = manager->createSignature(
2233                                         aliasPrv,
2234                                         CKM::Password(),
2235                                         CKM::RawBuffer(message.begin(), message.end()),
2236                                         hash,
2237                                         padd,
2238                                         signature)),
2239         "Error=" << CKMErrorToString(temp));
2240 }
2241
2242
2243 RUNNER_TEST(T14189_deinit)
2244 {
2245     remove_user_data(USER_APP);
2246 }
2247
2248
2249 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
2250
2251 namespace
2252 {
2253 CKM::Alias alias_PKCS_collision = "test-PKCS-collision";
2254 CKM::Alias alias_PKCS_exportable = "test-PKCS-export";
2255 CKM::Alias alias_PKCS_not_exportable = "test-PKCS-no-export";
2256 CKM::Alias alias_PKCS_priv_key_copy = "test-PKCS-private-key-copy";
2257 CKM::Alias alias_PKCS_priv_key_wrong = "test-PKCS-private-key-wrong";
2258 }
2259
2260 RUNNER_TEST(T1800_init)
2261 {
2262     remove_user_data(USER_APP);
2263 }
2264
2265 RUNNER_TEST(T1801_parse_PKCS12) {
2266     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2267     std::istreambuf_iterator<char> begin(is), end;
2268     std::vector<char> buff(begin, end);
2269
2270     CKM::RawBuffer buffer(buff.size());
2271     memcpy(buffer.data(), buff.data(), buff.size());
2272
2273     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2274     RUNNER_ASSERT_MSG(
2275         NULL != pkcs.get(),
2276         "Error in PKCS12::create()");
2277
2278     auto cert = pkcs->getCertificate();
2279     RUNNER_ASSERT_MSG(
2280         NULL != cert.get(),
2281         "Error in PKCS12::getCertificate()");
2282
2283     auto key = pkcs->getKey();
2284     RUNNER_ASSERT_MSG(
2285         NULL != key.get(),
2286         "Error in PKCS12::getKey()");
2287
2288     auto caVector = pkcs->getCaCertificateShPtrVector();
2289     RUNNER_ASSERT_MSG(
2290         0 == caVector.size(),
2291         "Wrong size of vector");
2292 }
2293
2294 RUNNER_TEST(T1802_negative_wrong_password) {
2295     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2296     std::istreambuf_iterator<char> begin(is), end;
2297     std::vector<char> buff(begin, end);
2298
2299     CKM::RawBuffer buffer(buff.size());
2300     memcpy(buffer.data(), buff.data(), buff.size());
2301
2302     auto pkcs = CKM::PKCS12::create(buffer, "error");
2303     RUNNER_ASSERT_MSG(
2304         NULL == pkcs.get(),
2305         "Expected error in PKCS12::create()");
2306 }
2307
2308 RUNNER_TEST(T1803_negative_broken_buffer) {
2309     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2310     std::istreambuf_iterator<char> begin(is), end;
2311     std::vector<char> buff(begin, end);
2312
2313     CKM::RawBuffer buffer(buff.size());
2314     memcpy(buffer.data(), buff.data(), buff.size());
2315
2316     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
2317     buffer[4]=0;
2318
2319     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2320     RUNNER_ASSERT_MSG(
2321         NULL == pkcs.get(),
2322         "Expected error in PKCS12::create()");
2323 }
2324
2325 RUNNER_TEST(T1804_add_PKCS_collision_with_existing_alias)
2326 {
2327     auto manager = CKM::Manager::create();
2328     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2329     std::istreambuf_iterator<char> begin(is), end;
2330     std::vector<char> buff(begin, end);
2331
2332     CKM::RawBuffer buffer(buff.size());
2333     memcpy(buffer.data(), buff.data(), buff.size());
2334
2335     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2336     RUNNER_ASSERT_MSG(
2337         NULL != pkcs.get(),
2338         "Error in PKCS12::create()");
2339
2340     // save private key
2341     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2342         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2343         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2344         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2345         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2346         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2347         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2348         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2349         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2350         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2351         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2352         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2353         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2354         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2355         "-----END RSA PRIVATE KEY-----\n";
2356
2357     std::string message = "message test";
2358
2359     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2360     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2361         "Key is empty. Failed to import private key.");
2362
2363     int temp;
2364     RUNNER_ASSERT_MSG(
2365         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_collision, keyPrv, CKM::Policy())),
2366         "Error=" << CKMErrorToString(temp));
2367
2368     RUNNER_ASSERT_MSG(
2369         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->savePKCS12(alias_PKCS_collision, pkcs, CKM::Policy(), CKM::Policy())),
2370         "Error=" << CKMErrorToString(temp));
2371 }
2372
2373 RUNNER_TEST(T1805_add_bundle_with_chain_certificates)
2374 {
2375     auto manager = CKM::Manager::create();
2376     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2377     std::istreambuf_iterator<char> begin(is), end;
2378     std::vector<char> buff(begin, end);
2379
2380     CKM::RawBuffer buffer(buff.size());
2381     memcpy(buffer.data(), buff.data(), buff.size());
2382
2383     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2384     RUNNER_ASSERT_MSG(
2385         NULL != pkcs.get(),
2386         "Error in PKCS12::create()");
2387
2388     auto cert = pkcs->getCertificate();
2389     RUNNER_ASSERT_MSG(
2390         NULL != cert.get(),
2391         "Error in PKCS12::getCertificate()");
2392
2393     auto key = pkcs->getKey();
2394     RUNNER_ASSERT_MSG(
2395         NULL != key.get(),
2396         "Error in PKCS12::getKey()");
2397
2398     auto caVector = pkcs->getCaCertificateShPtrVector();
2399     RUNNER_ASSERT_MSG(
2400         2 == caVector.size(),
2401         "Wrong size of vector");
2402
2403     // save to the CKM
2404     int tmp;
2405     CKM::Policy exportable;
2406     CKM::Policy notExportable(CKM::Password(), false);
2407
2408     RUNNER_ASSERT_MSG(
2409         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2410         "Error=" << CKMErrorToString(tmp));
2411     RUNNER_ASSERT_MSG(
2412         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2413         "Error=" << CKMErrorToString(tmp));
2414     RUNNER_ASSERT_MSG(
2415         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2416         "Error=" << CKMErrorToString(tmp));
2417     RUNNER_ASSERT_MSG(
2418         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2419         "Error=" << CKMErrorToString(tmp));
2420
2421     // try to lookup key
2422     CKM::KeyShPtr key_lookup;
2423     RUNNER_ASSERT_MSG(
2424         CKM_API_SUCCESS == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2425         "Error=" << CKMErrorToString(tmp));
2426     RUNNER_ASSERT_MSG(
2427         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2428         "Error=" << CKMErrorToString(tmp));
2429
2430     // try to lookup certificate
2431     CKM::CertificateShPtr cert_lookup;
2432     RUNNER_ASSERT_MSG(
2433         CKM_API_SUCCESS == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2434         "Error=" << CKMErrorToString(tmp));
2435     RUNNER_ASSERT_MSG(
2436         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2437         "Error=" << CKMErrorToString(tmp));
2438 }
2439
2440 RUNNER_TEST(T1806_get_PKCS)
2441 {
2442     int temp;
2443     auto manager = CKM::Manager::create();
2444
2445     CKM::PKCS12ShPtr pkcs;
2446
2447     // fail - no entry
2448     RUNNER_ASSERT_MSG(
2449         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getPKCS12("i-do-not-exist", pkcs)),
2450         "Error=" << CKMErrorToString(temp));
2451
2452     // fail - not exportable
2453     RUNNER_ASSERT_MSG(
2454         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getPKCS12(alias_PKCS_not_exportable, pkcs)),
2455         "Error=" << CKMErrorToString(temp));
2456
2457     // success - exportable
2458     RUNNER_ASSERT_MSG(
2459         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias_PKCS_exportable, pkcs)),
2460         "Error=" << CKMErrorToString(temp));
2461
2462     auto cert = pkcs->getCertificate();
2463     RUNNER_ASSERT_MSG(
2464         NULL != cert.get(),
2465         "Error in PKCS12::getCertificate()");
2466
2467     auto key = pkcs->getKey();
2468     RUNNER_ASSERT_MSG(
2469         NULL != key.get(),
2470         "Error in PKCS12::getKey()");
2471
2472     auto caVector = pkcs->getCaCertificateShPtrVector();
2473     RUNNER_ASSERT_MSG(
2474         2 == caVector.size(),
2475         "Wrong size of vector");
2476 }
2477
2478 RUNNER_TEST(T1807_create_and_verify_signature)
2479 {
2480     int temp;
2481     auto manager = CKM::Manager::create();
2482
2483     std::string message = "message test";
2484
2485     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2486     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2487     CKM::RawBuffer signature;
2488
2489     RUNNER_ASSERT_MSG(
2490         CKM_API_SUCCESS == (temp = manager->createSignature(
2491                                         alias_PKCS_exportable,
2492                                         CKM::Password(),
2493                                         CKM::RawBuffer(message.begin(), message.end()),
2494                                         hash,
2495                                         padd,
2496                                         signature)),
2497         "Error=" << CKMErrorToString(temp));
2498
2499     RUNNER_ASSERT_MSG(
2500         CKM_API_SUCCESS == (temp = manager->verifySignature(
2501                                         alias_PKCS_exportable,
2502                                         CKM::Password(),
2503                                         CKM::RawBuffer(message.begin(), message.end()),
2504                                         signature,
2505                                         hash,
2506                                         padd)),
2507         "Error=" << CKMErrorToString(temp));
2508 }
2509
2510 RUNNER_TEST(T1808_create_signature_on_raw_key_and_verify_on_PKCS)
2511 {
2512     int temp;
2513     auto manager = CKM::Manager::create();
2514
2515     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2516         "MIICXQIBAAKBgQD1W9neUbXL1rnq9SvyzprjhWBKXyYKQirG3V2zyUnUaE24Sq2I\n"
2517         "v7ISrwMN/G6WcjrGmeZDEWwrL4zXh002N8BD1waJPRonxwtVkhFy3emGatSmx7eI\n"
2518         "ely5H+PBNImRvBh2u4GWga6OEXcUNdfaBUcxn+P6548/zpDhyNLzQKk5FwIDAQAB\n"
2519         "AoGAR+4WkBuqTUj1FlGsAbHaLKt0UDlWwJknS0eoacWwFEpDxqx19WolfV67aYVA\n"
2520         "snBolMKXg7/+0yZMhv8Ofr+XaHkPQplVVn9BwT0rmtEovJXwx+poRP9Bm3emglj/\n"
2521         "iYd8EkaXDlIXCtewtQW9JEIctWppntHj3TvA/h7FCXPN6SkCQQD/N7sn5S1gBkVh\n"
2522         "dyXQKoyKsZDb7hMIS1q6cKwYCMf2UrsD1/lnr7xXkvORdL213MfueO8g0WkuKfRY\n"
2523         "bDD6WGX1AkEA9hxiOlsgvermqLJkOlJffbSaM8n/6wtnM0HV+Vd9NfSBOmxFDXPO\n"
2524         "vrvdgiDPENhbqTJSQVDsfzHilTpK7lEvWwJBAJLxHoOg0tg3pBiyxgWtic+M3q+R\n"
2525         "ykl7QViY6KzJ2X98MIrM/Z7yMollZXE4+sVLwZ0O6fdGOr3GkBWc7TImVUUCQQC7\n"
2526         "pf6bQfof9Ce0fnf/I+ldHkPost7nJsWkBlGQkM2OQwP5OK4ZyK/dK76DxmI7FMwm\n"
2527         "oJCo7nuzq6R4ZX7WYJ47AkBavxBDo/e9/0Vk5yrloGKW3f8RQXBJLcCkVUGyyJ3D\n"
2528         "3gu/nafW4hzjSJniTjC1fOj0eb0OSg1JAvqHTYAnUsI7\n"
2529         "-----END RSA PRIVATE KEY-----";
2530     std::string message = "message test";
2531
2532     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2533     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2534         "Key is empty. Failed to import private key.");
2535
2536     RUNNER_ASSERT_MSG(
2537         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_copy, keyPrv, CKM::Policy())),
2538         "Error=" << CKMErrorToString(temp));
2539
2540     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2541     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2542     CKM::RawBuffer signature;
2543
2544     RUNNER_ASSERT_MSG(
2545         CKM_API_SUCCESS == (temp = manager->createSignature(
2546                                         alias_PKCS_priv_key_copy,
2547                                         CKM::Password(),
2548                                         CKM::RawBuffer(message.begin(), message.end()),
2549                                         hash,
2550                                         padd,
2551                                         signature)),
2552         "Error=" << CKMErrorToString(temp));
2553
2554     RUNNER_ASSERT_MSG(
2555         CKM_API_SUCCESS == (temp = manager->verifySignature(
2556                                         alias_PKCS_exportable,
2557                                         CKM::Password(),
2558                                         CKM::RawBuffer(message.begin(), message.end()),
2559                                         signature,
2560                                         hash,
2561                                         padd)),
2562         "Error=" << CKMErrorToString(temp));
2563 }
2564
2565 RUNNER_TEST(T1809_create_signature_on_wrong_key_and_verify_on_PKCS)
2566 {
2567     int temp;
2568     auto manager = CKM::Manager::create();
2569
2570     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2571         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2572         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2573         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2574         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2575         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2576         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2577         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2578         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2579         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2580         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2581         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2582         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2583         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2584         "-----END RSA PRIVATE KEY-----\n";
2585
2586     std::string message = "message test";
2587
2588     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2589     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2590         "Key is empty. Failed to import private key.");
2591
2592     RUNNER_ASSERT_MSG(
2593         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_wrong, keyPrv, CKM::Policy())),
2594         "Error=" << CKMErrorToString(temp));
2595
2596     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2597     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2598     CKM::RawBuffer signature;
2599
2600     RUNNER_ASSERT_MSG(
2601         CKM_API_SUCCESS == (temp = manager->createSignature(
2602                                         alias_PKCS_priv_key_wrong,
2603                                         CKM::Password(),
2604                                         CKM::RawBuffer(message.begin(), message.end()),
2605                                         hash,
2606                                         padd,
2607                                         signature)),
2608         "Error=" << CKMErrorToString(temp));
2609
2610     RUNNER_ASSERT_MSG(
2611         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2612                                         alias_PKCS_exportable,
2613                                         CKM::Password(),
2614                                         CKM::RawBuffer(message.begin(), message.end()),
2615                                         signature,
2616                                         hash,
2617                                         padd)),
2618         "Error=" << CKMErrorToString(temp));
2619 }
2620
2621 RUNNER_TEST(T1810_verify_get_certificate_chain)
2622 {
2623     // this certificate has been signed using PKCS chain
2624     std::string im =
2625         "-----BEGIN CERTIFICATE-----\n"
2626         "MIIBozCCAQwCAQEwDQYJKoZIhvcNAQEFBQAwHDEaMBgGA1UEAwwRc2VydmVyQHRl\n"
2627         "c3RtZS5jb20wHhcNMTUxMjA5MTA0NjU0WhcNMjUxMjA2MTA0NjU0WjAYMRYwFAYD\n"
2628         "VQQDDA1lZUB0ZXN0bWUuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDP\n"
2629         "+fNsZB1Vlmhnk0IwYDs7Pw9E38KQfTt/egqqRFN6IvIt0CCDBXqnPTujuvlO2OyL\n"
2630         "XVuALnIBmTDm5Oz+oz+qiY6/XrVS/CoACNZyMo6ihG9OeocvDbU3jXEaPGL6ib/x\n"
2631         "jlms0aA9d5L9TO2lEzEP7bFKgHCB8FWINcxSP5zl1QIDAQABMA0GCSqGSIb3DQEB\n"
2632         "BQUAA4GBAKBpVJMkdK6/qnAz7d7Bul/BhhSLEYbNPdxRiUj3U2dt0GJgswMu2SNT\n"
2633         "/3NXB8V8mnnXR6cWn5bmjyA7ZpQEKAatS/KEQ9wfLXyCgYDRebX71mVKAI3XcyxB\n"
2634         "p2qsOWWaJhuHmC1GVjx3foL+RDrmRo6BiucNHMIuvrd1W36eKdhj\n"
2635         "-----END CERTIFICATE-----\n";
2636
2637     auto cert = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
2638     CKM::CertificateShPtrVector certChain;
2639     CKM::AliasVector aliasVector;
2640
2641     int tmp;
2642     auto manager = CKM::Manager::create();
2643
2644     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
2645
2646     tmp = manager->getCertificateChain(cert,
2647                                        EMPTY_ALIAS_VECTOR,
2648                                        EMPTY_ALIAS_VECTOR,
2649                                        true,
2650                                        certChain);
2651     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
2652                          "Error=" << CKMErrorToString(tmp));
2653
2654     RUNNER_ASSERT_MSG(
2655         0 == certChain.size(),
2656         "Wrong size of certificate chain.");
2657
2658     aliasVector.push_back(alias_PKCS_exportable);
2659
2660     tmp = manager->getCertificateChain(cert, EMPTY_ALIAS_VECTOR, aliasVector, false, certChain);
2661     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKMErrorToString(tmp));
2662
2663     // 1(cert) + 1(pkcs12 cert) + 2(pkcs12 chain cert) = 4
2664     RUNNER_ASSERT_MSG(
2665         4 == certChain.size(),
2666         "Wrong size of certificate chain: " << certChain.size());
2667 }
2668
2669 RUNNER_TEST(T1811_remove_bundle_with_chain_certificates)
2670 {
2671     auto manager = CKM::Manager::create();
2672     int tmp;
2673
2674
2675     // remove the whole PKCS12 bundles
2676     RUNNER_ASSERT_MSG(
2677         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_exportable)),
2678         "Error=" << CKMErrorToString(tmp));
2679     RUNNER_ASSERT_MSG(
2680         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_not_exportable)),
2681         "Error=" << CKMErrorToString(tmp));
2682
2683     // expect lookup fails due to unknown alias
2684     // try to lookup key
2685     CKM::KeyShPtr key_lookup;
2686     RUNNER_ASSERT_MSG(
2687         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2688         "Error=" << CKMErrorToString(tmp));
2689     RUNNER_ASSERT_MSG(
2690         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2691         "Error=" << CKMErrorToString(tmp));
2692
2693     // try to lookup certificate
2694     CKM::CertificateShPtr cert_lookup;
2695     RUNNER_ASSERT_MSG(
2696         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2697         "Error=" << CKMErrorToString(tmp));
2698     RUNNER_ASSERT_MSG(
2699         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2700         "Error=" << CKMErrorToString(tmp));
2701 }
2702
2703 RUNNER_TEST(T1812_get_pkcs12_password_tests)
2704 {
2705     CKM::Alias alias = "t1812alias1";
2706
2707     auto manager = CKM::Manager::create();
2708     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2709     std::istreambuf_iterator<char> begin(is), end;
2710     std::vector<char> buff(begin, end);
2711
2712     CKM::PKCS12ShPtr pkcs12;
2713     CKM::Password pass1 = "easypass1";
2714     CKM::Password pass2 = "easypass2";
2715
2716     CKM::RawBuffer buffer(buff.size());
2717     memcpy(buffer.data(), buff.data(), buff.size());
2718
2719     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2720     RUNNER_ASSERT_MSG(
2721         NULL != pkcs.get(),
2722         "Error in PKCS12::create()");
2723
2724     int temp;
2725     RUNNER_ASSERT_MSG(
2726         CKM_API_SUCCESS == (temp = manager->savePKCS12(alias, pkcs, CKM::Policy(pass1), CKM::Policy(pass2))),
2727         "Error=" << CKMErrorToString(temp));
2728
2729     RUNNER_ASSERT_MSG(
2730         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pkcs)),
2731         "Error=" << CKMErrorToString(temp));
2732
2733     RUNNER_ASSERT_MSG(
2734         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), CKM::Password(), pkcs)),
2735         "Error=" << CKMErrorToString(temp));
2736
2737     RUNNER_ASSERT_MSG(
2738         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pass1, CKM::Password(), pkcs)),
2739         "Error=" << CKMErrorToString(temp));
2740
2741     RUNNER_ASSERT_MSG(
2742         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), pass2, pkcs)),
2743         "Error=" << CKMErrorToString(temp));
2744
2745     RUNNER_ASSERT_MSG(
2746         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias, pass1, pass2, pkcs)),
2747         "Error=" << CKMErrorToString(temp));
2748
2749     CKM::CertificateShPtr cert;
2750     RUNNER_ASSERT_MSG(
2751         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, pass2, cert)),
2752         "Error=" << CKMErrorToString(temp));
2753
2754     CKM::CertificateShPtrVector certChain;
2755     CKM::AliasVector certVect;
2756     certVect.push_back(alias);
2757
2758     RUNNER_ASSERT_MSG(
2759         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getCertificateChain(cert, certVect, certVect, true, certChain)),
2760         "Error=" << CKMErrorToString(temp));
2761 }
2762
2763 RUNNER_TEST(T1813_deinit)
2764 {
2765     int temp;
2766     auto control = CKM::Control::create();
2767
2768     RUNNER_ASSERT_MSG(
2769         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
2770         "Error=" << CKMErrorToString(temp));
2771 }
2772
2773 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
2774 namespace {
2775 const char * const T190_PASSWD = "t190-special-password";
2776 }
2777 RUNNER_TEST(T1901_init_unlock_key)
2778 {
2779     reset_user_data(USER_APP, T190_PASSWD);
2780 }
2781
2782 RUNNER_TEST(T1902_get_data)
2783 {
2784     ScopedDBUnlock unlock(USER_APP, T190_PASSWD);
2785
2786     auto manager = CKM::Manager::create();
2787     CKM::KeyShPtr ptr;
2788
2789     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2790
2791     RUNNER_ASSERT_MSG(
2792         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
2793         "Could not put certificate in datbase. Error=" << CKMErrorToString(status1));
2794 }
2795
2796 RUNNER_TEST(T1903_lock_database)
2797 {
2798     int tmp;
2799     auto control = CKM::Control::create();
2800     RUNNER_ASSERT_MSG(
2801         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2802         "Error=" << CKMErrorToString(tmp));
2803 }
2804
2805 RUNNER_TEST(T1904_get_data_from_locked_database)
2806 {
2807     auto manager = CKM::Manager::create();
2808     CKM::KeyShPtr ptr;
2809
2810     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2811
2812     RUNNER_ASSERT_MSG(
2813         CKM_API_ERROR_DB_LOCKED == status1,
2814         "Could not get key from locked database. Error=" << CKMErrorToString(status1));
2815 }
2816
2817 RUNNER_TEST(T1905_deinit)
2818 {
2819     remove_user_data(USER_APP);
2820 }
2821
2822 int main(int argc, char *argv[])
2823 {
2824     uid_t expected_uid = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
2825     if (expected_uid != geteuid()) {
2826         std::string userStr("owner");
2827         const char* user = tzplatform_getenv(TZ_SYS_DEFAULT_USER);
2828         if (user)
2829             userStr = user;
2830
2831         std::cerr << argv[0] << " should be executed as " << userStr << ". Aborting" << std::endl;
2832         return -1;
2833     }
2834
2835     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
2836 }