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