src/ckm/unprivileged/main.cpp

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