src/ckm/unprivileged/main.cpp

   1 /*
   2  *  Copyright (c) 2016 - 2019 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     RUNNER_ASSERT_MSG(false != cert1.get(), "Certificate should not be empty");
1307
1308     tmp = manager->getCertificateChain(cert,
1309                                        EMPTY_CERT_VECTOR,
1310                                        EMPTY_CERT_VECTOR,
1311                                        true,
1312                                        certChain);
1313     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1314                          "Error=" << CKM::APICodeToString(tmp));
1315
1316     RUNNER_ASSERT_MSG(
1317         0 == certChain.size(),
1318         "Wrong size of certificate chain.");
1319
1320     tmp = manager->getCertificateChain(cert, certVector, EMPTY_CERT_VECTOR, true, certChain);
1321     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKM::APICodeToString(tmp));
1322
1323     RUNNER_ASSERT_MSG(
1324         3 == certChain.size(),
1325         "Wrong size of certificate chain.");
1326 }
1327
1328 RUNNER_TEST(T1313_get_chain_with_alias)
1329 {
1330     auto cert = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_LEAF);
1331     auto cert1 = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_IM);
1332
1333     CKM::CertificateShPtrVector certChain;
1334     CKM::AliasVector aliasVector;
1335     CKM::Alias alias = "imcert";
1336
1337     int tmp;
1338     auto manager = CKM::Manager::create();
1339
1340     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1341     RUNNER_ASSERT_MSG(NULL != cert1.get(), "Certificate should not be empty");
1342
1343     tmp = manager->getCertificateChain(cert, aliasVector, EMPTY_ALIAS_VECTOR, true, certChain);
1344     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1345                          "Error=" << CKM::APICodeToString(tmp));
1346
1347     RUNNER_ASSERT_MSG(
1348         0 == certChain.size(),
1349         "Wrong size of certificate chain.");
1350
1351     RUNNER_ASSERT_MSG(
1352         CKM_API_SUCCESS == (tmp = manager->saveCertificate(alias, cert1, CKM::Policy())),
1353         "Error=" << CKM::APICodeToString(tmp));
1354
1355     aliasVector.push_back(alias);
1356
1357     tmp = manager->getCertificateChain(cert, aliasVector, EMPTY_ALIAS_VECTOR, true, certChain);
1358     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKM::APICodeToString(tmp));
1359
1360     RUNNER_ASSERT_MSG(
1361         3 == certChain.size(),
1362         "Wrong size of certificate chain.");
1363 }
1364
1365 RUNNER_TEST(T13141_ocsp_check_valid_chain)
1366 {
1367     auto cert = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_LEAF);
1368     auto cert1 = TestData::getTestCertificate(TestData::OCSP_AVAILABLE_IM);
1369     CKM::CertificateShPtrVector certVector = {cert1};
1370     CKM::CertificateShPtrVector certChain;
1371
1372     int tmp;
1373     auto manager = CKM::Manager::create();
1374
1375     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1376     RUNNER_ASSERT_MSG(NULL != cert1.get(), "Certificate should not be empty");
1377
1378     tmp = manager->getCertificateChain(cert, EMPTY_CERT_VECTOR, EMPTY_CERT_VECTOR, true, certChain);
1379     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
1380                          "Error=" << CKM::APICodeToString(tmp));
1381
1382     RUNNER_ASSERT_MSG(
1383         0 == certChain.size(),
1384         "Wrong size of certificate chain.");
1385
1386     tmp = manager->getCertificateChain(cert, certVector, EMPTY_CERT_VECTOR, true, certChain);
1387     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKM::APICodeToString(tmp));
1388
1389     RUNNER_ASSERT_MSG(
1390         3 == certChain.size(),
1391         "Wrong size of certificate chain.");
1392
1393     int status;
1394     RUNNER_ASSERT_MSG(
1395         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certChain, status)),
1396         "Error=" << CKM::APICodeToString(tmp));
1397
1398     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_GOOD == status, "Verfication failed");
1399 }
1400
1401 RUNNER_TEST(T13142_ocsp_check_empty)
1402 {
1403     CKM::CertificateShPtrVector certVector;
1404
1405     auto manager = CKM::Manager::create();
1406
1407     int tmp;
1408     int status;
1409     RUNNER_ASSERT_MSG(
1410             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1411         "ocspCheck should fail for empty certificate vector");
1412 }
1413
1414 RUNNER_TEST(T13143_ocsp_check_empty_ptrs)
1415 {
1416     CKM::CertificateShPtrVector certVector = {
1417             CKM::CertificateShPtr(),
1418             CKM::CertificateShPtr(),
1419             CKM::CertificateShPtr()};
1420
1421     auto manager = CKM::Manager::create();
1422
1423     int tmp;
1424     int status;
1425     RUNNER_ASSERT_MSG(
1426             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1427         "ocspCheck should fail for empty certificate vector");
1428 }
1429
1430 RUNNER_TEST(T13144_ocsp_check_root)
1431 {
1432     auto root = TestData::getTestCertificate(TestData::THIRD_PARTY_ROOT_CA);
1433     CKM::CertificateShPtrVector certVector = {root};
1434
1435     auto manager = CKM::Manager::create();
1436
1437     RUNNER_ASSERT_MSG(NULL != root.get(), "Certificate should not be empty");
1438
1439     int tmp;
1440     int status;
1441     RUNNER_ASSERT_MSG(
1442             CKM_API_ERROR_INPUT_PARAM == (tmp = manager->ocspCheck(certVector, status)),
1443         "Ocsp should fail for single certificate");
1444 }
1445
1446 RUNNER_TEST(T13145_ocsp_check_no_ocsp)
1447 {
1448     auto root = TestData::getTestCertificate(TestData::TEST_ROOT_CA);
1449     auto ca = TestData::getTestCertificate(TestData::TEST_IM_CA);
1450
1451     CKM::CertificateShPtrVector certVector = {ca, root};
1452
1453     auto manager = CKM::Manager::create();
1454
1455     RUNNER_ASSERT_MSG(NULL != root.get(), "Certificate should not be empty");
1456     RUNNER_ASSERT_MSG(NULL != ca.get(), "Certificate should not be empty");
1457
1458     int tmp;
1459     int status;
1460     RUNNER_ASSERT_MSG(
1461         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certVector, status)),
1462         "Error=" << CKM::APICodeToString(tmp));
1463
1464     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_UNSUPPORTED == status, "Verfication failed");
1465 }
1466
1467 RUNNER_TEST(T1315_deinit)
1468 {
1469     remove_user_data(USER_APP);
1470 }
1471
1472 RUNNER_TEST_GROUP_INIT(T141_CREATE_AND_VERIFY_SIGNATURE);
1473
1474 RUNNER_TEST(T1411_init)
1475 {
1476     remove_user_data(USER_APP);
1477 }
1478
1479 RUNNER_TEST(T1412_RSA_key_create_verify)
1480 {
1481     int temp;
1482     auto manager = CKM::Manager::create();
1483
1484     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1485       "Proc-Type: 4,ENCRYPTED\n"
1486       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1487       "\n"
1488       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1489       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1490       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1491       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1492       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1493       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1494       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1495       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1496       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1497       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1498       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1499       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1500       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1501       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1502       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1503       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1504       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1505       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1506       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1507       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1508       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1509       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1510       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1511       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1512       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1513       "-----END RSA PRIVATE KEY-----\n";
1514
1515     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1516       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1517       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1518       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1519       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1520       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1521       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1522       "zQIDAQAB\n"
1523       "-----END PUBLIC KEY-----\n";
1524
1525     std::string message = "message test";
1526
1527     CKM::Alias aliasPub = "pub1";
1528     CKM::Alias aliasPrv = "prv1";
1529     CKM::Password password = "1234";
1530     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1531     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1532     CKM::RawBuffer signature;
1533
1534     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1535     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
1536
1537     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1538         "Key is empty. Failed to import public key.");
1539     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1540         "Key is empty. Failed to import private key.");
1541
1542     RUNNER_ASSERT_MSG(
1543         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1544         "Error=" << CKM::APICodeToString(temp));
1545     RUNNER_ASSERT_MSG(
1546         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1547         "Error=" << CKM::APICodeToString(temp));
1548
1549     RUNNER_ASSERT_MSG(
1550         CKM_API_SUCCESS == (temp = manager->createSignature(
1551                                         aliasPrv,
1552                                         CKM::Password(),
1553                                         CKM::RawBuffer(message.begin(), message.end()),
1554                                         hash,
1555                                         padd,
1556                                         signature)),
1557         "Error=" << CKM::APICodeToString(temp));
1558
1559     RUNNER_ASSERT_MSG(
1560         CKM_API_SUCCESS == (temp = manager->verifySignature(
1561                                         aliasPub,
1562                                         CKM::Password(),
1563                                         CKM::RawBuffer(message.begin(), message.end()),
1564                                         signature,
1565                                         hash,
1566                                         padd)),
1567         "Error=" << CKM::APICodeToString(temp));
1568 }
1569
1570 RUNNER_TEST(T1413_DSA_key_create_verify)
1571 {
1572     int temp;
1573     auto manager = CKM::Manager::create();
1574
1575     std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1576             "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1577             "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1578             "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1579             "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1580             "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1581             "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1582             "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1583             "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1584             "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1585             "u1roOuaPY+Hl19BlTE2qdw==\n"
1586             "-----END DSA PRIVATE KEY-----";
1587
1588     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1589             "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1590             "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1591             "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1592             "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1593             "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1594             "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1595             "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1596             "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1597             "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1598             "YMYCBhubtrVaLmc=\n"
1599             "-----END PUBLIC KEY-----";
1600
1601     std::string message = "message test";
1602
1603     CKM::Alias aliasPub = "pub2";
1604     CKM::Alias aliasPrv = "prv2";
1605     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1606     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1607     CKM::RawBuffer signature;
1608
1609     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1610     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
1611
1612     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1613         "Key is empty. Failed to import public key.");
1614     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1615         "Key is empty. Failed to import private key.");
1616
1617     RUNNER_ASSERT_MSG(
1618         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1619         "Error=" << CKM::APICodeToString(temp));
1620     RUNNER_ASSERT_MSG(
1621         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1622         "Error=" << CKM::APICodeToString(temp));
1623
1624     RUNNER_ASSERT_MSG(
1625         CKM_API_SUCCESS == (temp = manager->createSignature(
1626                                         aliasPrv,
1627                                         CKM::Password(),
1628                                         CKM::RawBuffer(message.begin(), message.end()),
1629                                         hash,
1630                                         padd,
1631                                         signature)),
1632         "Error=" << CKM::APICodeToString(temp));
1633
1634     RUNNER_ASSERT_MSG(
1635         CKM_API_SUCCESS == (temp = manager->verifySignature(
1636                                         aliasPub,
1637                                         CKM::Password(),
1638                                         CKM::RawBuffer(message.begin(), message.end()),
1639                                         signature,
1640                                         hash,
1641                                         padd)),
1642         "Error=" << CKM::APICodeToString(temp));
1643 }
1644
1645
1646 RUNNER_TEST(T1414_ECDSA_key_create_verify)
1647 {
1648     int temp;
1649     auto manager = CKM::Manager::create();
1650
1651     std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1652         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1653         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1654         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1655         "-----END EC PRIVATE KEY-----\n";
1656
1657     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1658         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1659         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1660         "-----END PUBLIC KEY-----\n";
1661
1662     std::string message = "message test";
1663
1664     CKM::Alias aliasPub = "ecpub2";
1665     CKM::Alias aliasPrv = "ecprv2";
1666     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1667     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1668     CKM::RawBuffer signature;
1669
1670     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1671     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1672
1673     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1674         "Key is empty. Failed to import public key.");
1675     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1676         "Key is empty. Failed to import private key.");
1677
1678     RUNNER_ASSERT_MSG(
1679         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1680         "Error=" << CKM::APICodeToString(temp));
1681     RUNNER_ASSERT_MSG(
1682         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1683         "Error=" << CKM::APICodeToString(temp));
1684
1685     RUNNER_ASSERT_MSG(
1686         CKM_API_SUCCESS == (temp = manager->createSignature(
1687                                         aliasPrv,
1688                                         CKM::Password(),
1689                                         CKM::RawBuffer(message.begin(), message.end()),
1690                                         hash,
1691                                         padd,
1692                                         signature)),
1693         "Error=" << CKM::APICodeToString(temp));
1694
1695     RUNNER_ASSERT_MSG(
1696         CKM_API_SUCCESS == (temp = manager->verifySignature(
1697                                         aliasPub,
1698                                         CKM::Password(),
1699                                         CKM::RawBuffer(message.begin(), message.end()),
1700                                         signature,
1701                                         hash,
1702                                         padd)),
1703         "Error=" << CKM::APICodeToString(temp));
1704
1705     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1706
1707     memcpy((void*)signature.data(), "BROKEN", 6);
1708
1709     RUNNER_ASSERT_MSG(
1710         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1711                                         aliasPub,
1712                                         CKM::Password(),
1713                                         CKM::RawBuffer(message.begin(), message.end()),
1714                                         signature,
1715                                         hash,
1716                                         padd)),
1717         "Error=" << CKM::APICodeToString(temp));
1718 }
1719
1720 RUNNER_TEST(T1415_RSA_key_create_verify_negative)
1721 {
1722     int temp;
1723     auto manager = CKM::Manager::create();
1724     std::string message = "message asdfaslkdfjlksadjf test";
1725
1726     CKM::Alias aliasPub = "pub1";
1727     CKM::Alias aliasPrv = "prv1";
1728
1729     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1730     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1731     CKM::RawBuffer signature;
1732
1733     RUNNER_ASSERT_MSG(
1734         CKM_API_SUCCESS == (temp = manager->createSignature(
1735                                         aliasPrv,
1736                                         CKM::Password(),
1737                                         CKM::RawBuffer(message.begin(), message.end()),
1738                                         hash,
1739                                         padd,
1740                                         signature)),
1741         "Error=" << CKM::APICodeToString(temp));
1742
1743     RUNNER_ASSERT_MSG(
1744         CKM_API_SUCCESS == (temp = manager->verifySignature(
1745                                         aliasPub,
1746                                         CKM::Password(),
1747                                         CKM::RawBuffer(message.begin(), message.end()),
1748                                         signature,
1749                                         hash,
1750                                         padd)),
1751         "Error=" << CKM::APICodeToString(temp));
1752
1753     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1754     memcpy((void*)signature.data(), "BROKEN", 6);
1755
1756     RUNNER_ASSERT_MSG(
1757         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1758                                         aliasPub,
1759                                         CKM::Password(),
1760                                         CKM::RawBuffer(message.begin(), message.end()),
1761                                         signature,
1762                                         hash,
1763                                         padd)),
1764         "Error=" << CKM::APICodeToString(temp));
1765 }
1766
1767 RUNNER_TEST(T1416_DSA_key_create_verify_negative)
1768 {
1769     int temp;
1770     auto manager = CKM::Manager::create();
1771     std::string message = "message asdfaslkdfjlksadjf test";
1772
1773     CKM::Alias aliasPub = "pub2";
1774     CKM::Alias aliasPrv = "prv2";
1775
1776     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1777     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1778     CKM::RawBuffer signature;
1779
1780     RUNNER_ASSERT_MSG(
1781         CKM_API_SUCCESS == (temp = manager->createSignature(
1782                                         aliasPrv,
1783                                         CKM::Password(),
1784                                         CKM::RawBuffer(message.begin(), message.end()),
1785                                         hash,
1786                                         padd,
1787                                         signature)),
1788         "Error=" << CKM::APICodeToString(temp));
1789
1790     RUNNER_ASSERT_MSG(
1791         CKM_API_SUCCESS == (temp = manager->verifySignature(
1792                                         aliasPub,
1793                                         CKM::Password(),
1794                                         CKM::RawBuffer(message.begin(), message.end()),
1795                                         signature,
1796                                         hash,
1797                                         padd)),
1798         "Error=" << CKM::APICodeToString(temp));
1799
1800     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1801     memcpy((void*)signature.data(), "BROKEN", 6);
1802
1803     RUNNER_ASSERT_MSG(
1804         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1805                                         aliasPub,
1806                                         CKM::Password(),
1807                                         CKM::RawBuffer(message.begin(), message.end()),
1808                                         signature,
1809                                         hash,
1810                                         padd)),
1811         "Error=" << CKM::APICodeToString(temp));
1812 }
1813
1814 RUNNER_TEST(T1417_RSA_cert_create_verify_signature)
1815 {
1816     int temp;
1817     auto manager = CKM::Manager::create();
1818
1819     std::string prv =
1820       "-----BEGIN RSA PRIVATE KEY-----\n"
1821       "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1822       "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1823       "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1824       "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1825       "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1826       "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1827       "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1828       "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1829       "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1830       "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1831       "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1832       "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1833       "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1834       "-----END RSA PRIVATE KEY-----\n";
1835
1836     std::string pub =
1837       "-----BEGIN CERTIFICATE-----\n"
1838       "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1839       "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1840       "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1841       "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1842       "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1843       "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1844       "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1845       "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1846       "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1847       "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1848       "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1849       "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1850       "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1851       "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1852       "-----END CERTIFICATE-----\n";
1853
1854     std::string message = "message test";
1855
1856     CKM::Alias aliasPub = "pub1-cert";
1857     CKM::Alias aliasPrv = "prv1-cert";
1858     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1859     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1860     CKM::RawBuffer signature;
1861
1862     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1863     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1864
1865     RUNNER_ASSERT_MSG(NULL != cert.get(),
1866         "Key is empty. Failed to import public key.");
1867     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1868         "Key is empty. Failed to import private key.");
1869
1870     RUNNER_ASSERT_MSG(
1871         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1872         "Error=" << CKM::APICodeToString(temp));
1873     RUNNER_ASSERT_MSG(
1874         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1875         "Error=" << CKM::APICodeToString(temp));
1876
1877     RUNNER_ASSERT_MSG(
1878         CKM_API_SUCCESS == (temp = manager->createSignature(
1879                                         aliasPrv,
1880                                         CKM::Password(),
1881                                         CKM::RawBuffer(message.begin(), message.end()),
1882                                         hash,
1883                                         padd,
1884                                         signature)),
1885         "Error=" << CKM::APICodeToString(temp));
1886
1887     RUNNER_ASSERT_MSG(
1888         CKM_API_SUCCESS == (temp = manager->verifySignature(
1889                                         aliasPub,
1890                                         CKM::Password(),
1891                                         CKM::RawBuffer(message.begin(), message.end()),
1892                                         signature,
1893                                         hash,
1894                                         padd)),
1895         "Error=" << CKM::APICodeToString(temp));
1896
1897     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1898
1899     memcpy((void*)signature.data(), "BROKEN", 6);
1900
1901     RUNNER_ASSERT_MSG(
1902         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1903                                         aliasPub,
1904                                         CKM::Password(),
1905                                         CKM::RawBuffer(message.begin(), message.end()),
1906                                         signature,
1907                                         hash,
1908                                         padd)),
1909         "Error=" << CKM::APICodeToString(temp));
1910 }
1911
1912 RUNNER_TEST(T1418_DSA_cert_create_verify_signature)
1913 {
1914     int temp;
1915     auto manager = CKM::Manager::create();
1916
1917     const std::string pub = "-----BEGIN CERTIFICATE-----\n"
1918         "MIIDUzCCAxECCQCer/fKcXtJgTALBglghkgBZQMEAwIwgYsxCzAJBgNVBAYTAlBM\n"
1919         "MQ8wDQYDVQQIDAZQb2xhbmQxDzANBgNVBAcMBldhcnNhdzEQMA4GA1UECgwHU2Ft\n"
1920         "c3VuZzEMMAoGA1UECwwDS1NGMRMwEQYDVQQDDAptLmthcnBpdWsyMSUwIwYJKoZI\n"
1921         "hvcNAQkBFhZtLmthcnBpdWsyQHNhbXN1bmcuY29tMCAXDTE0MDkyNjEzNTQwN1oY\n"
1922         "DzIxNDAwOTA1MTM1NDA3WjCBizELMAkGA1UEBhMCUEwxDzANBgNVBAgMBlBvbGFu\n"
1923         "ZDEPMA0GA1UEBwwGV2Fyc2F3MRAwDgYDVQQKDAdTYW1zdW5nMQwwCgYDVQQLDANL\n"
1924         "U0YxEzARBgNVBAMMCm0ua2FycGl1azIxJTAjBgkqhkiG9w0BCQEWFm0ua2FycGl1\n"
1925         "azJAc2Ftc3VuZy5jb20wggG3MIIBKwYHKoZIzjgEATCCAR4CgYEA9Bhh7ZA4onkY\n"
1926         "uDNQbYR4EwkJ6RpD505hB0GF6yppUNp2LanvNcQXcyXY88MB6OdP7Rikbu1H2zP4\n"
1927         "gONCtdxKW58Za7h9bFzYjxcObZsS52F9DP7sv3C4sX4xNWApfhUgbfzKaRCJOkOs\n"
1928         "06tV7teu3G/v26PdI8dlykIuQXQZmH8CFQCHsIV0njb2yC3ggfKz+exH+g5jAQKB\n"
1929         "gBVLYfVCMjUz5XJH+xYU3A8W8rpSLqZKIK2d9mbXqhpz8QK1bvNQUlSRZo+o1ZYV\n"
1930         "mJn3Mx2YuiifHZNKdBNweCqe5a+HV2RSl1Yv/TV9famZKlogGslsmPHUOJMlSIdh\n"
1931         "MfMwVny4/rNtjEtEFE1WnaTr1W6MKH1EBbizVo8fmWFrA4GFAAKBgQCaPjrlkAyX\n"
1932         "kBitWo+w0xZN4OSk13SsCzZ/PG+5zOgMRaFm2XbiC04YsGCi4NFOd9kaiP7w1CsP\n"
1933         "iqG6Vwv0T/VcoxBl/hp6jEqTDSrM6z0ungjDO9wGOdI+jZS0UjVahgC4ZLDHhrOa\n"
1934         "CjfxcHruO3e416b/Rm2CjhOzjKdoSFUWVzALBglghkgBZQMEAwIDLwAwLAIUHa+A\n"
1935         "5xo8O/tPuH9gXkr1mee6kRYCFGNycJ1xkc3nIJaEQOtGfDe7S71A\n"
1936         "-----END CERTIFICATE-----\n";
1937
1938     const std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1939         "MIIBuwIBAAKBgQD0GGHtkDiieRi4M1BthHgTCQnpGkPnTmEHQYXrKmlQ2nYtqe81\n"
1940         "xBdzJdjzwwHo50/tGKRu7UfbM/iA40K13EpbnxlruH1sXNiPFw5tmxLnYX0M/uy/\n"
1941         "cLixfjE1YCl+FSBt/MppEIk6Q6zTq1Xu167cb+/bo90jx2XKQi5BdBmYfwIVAIew\n"
1942         "hXSeNvbILeCB8rP57Ef6DmMBAoGAFUth9UIyNTPlckf7FhTcDxbyulIupkogrZ32\n"
1943         "ZteqGnPxArVu81BSVJFmj6jVlhWYmfczHZi6KJ8dk0p0E3B4Kp7lr4dXZFKXVi/9\n"
1944         "NX19qZkqWiAayWyY8dQ4kyVIh2Ex8zBWfLj+s22MS0QUTVadpOvVbowofUQFuLNW\n"
1945         "jx+ZYWsCgYEAmj465ZAMl5AYrVqPsNMWTeDkpNd0rAs2fzxvuczoDEWhZtl24gtO\n"
1946         "GLBgouDRTnfZGoj+8NQrD4qhulcL9E/1XKMQZf4aeoxKkw0qzOs9Lp4IwzvcBjnS\n"
1947         "Po2UtFI1WoYAuGSwx4azmgo38XB67jt3uNem/0Ztgo4Ts4ynaEhVFlcCFGMH+Z9l\n"
1948         "vonbjii3BYe4AIdkzOvp\n"
1949         "-----END DSA PRIVATE KEY-----\n";
1950
1951     std::string message = "message test";
1952
1953     CKM::Alias aliasPub = "pub2-cert";
1954     CKM::Alias aliasPrv = "prv2-cert";
1955     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1956     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1957     CKM::RawBuffer signature;
1958
1959     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1960     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1961
1962     RUNNER_ASSERT_MSG(NULL != cert.get(),
1963         "Key is empty. Failed to import public key.");
1964     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1965         "Key is empty. Failed to import private key.");
1966
1967     RUNNER_ASSERT_MSG(
1968         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1969         "Error=" << CKM::APICodeToString(temp));
1970     RUNNER_ASSERT_MSG(
1971         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1972         "Error=" << CKM::APICodeToString(temp));
1973
1974     RUNNER_ASSERT_MSG(
1975         CKM_API_SUCCESS == (temp = manager->createSignature(
1976                                         aliasPrv,
1977                                         CKM::Password(),
1978                                         CKM::RawBuffer(message.begin(), message.end()),
1979                                         hash,
1980                                         padd,
1981                                         signature)),
1982         "Error=" << CKM::APICodeToString(temp));
1983
1984     RUNNER_ASSERT_MSG(
1985         CKM_API_SUCCESS == (temp = manager->verifySignature(
1986                                         aliasPub,
1987                                         CKM::Password(),
1988                                         CKM::RawBuffer(message.begin(), message.end()),
1989                                         signature,
1990                                         hash,
1991                                         padd)),
1992         "Error=" << CKM::APICodeToString(temp));
1993
1994     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1995
1996     memcpy((void*)signature.data(), "BROKEN", 6);
1997
1998     RUNNER_ASSERT_MSG(
1999         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2000                                         aliasPub,
2001                                         CKM::Password(),
2002                                         CKM::RawBuffer(message.begin(), message.end()),
2003                                         signature,
2004                                         hash,
2005                                         padd)),
2006         "Error=" << CKM::APICodeToString(temp));
2007 }
2008
2009 RUNNER_TEST(T1419_ECDSA_cert_create_verify_signature)
2010 {
2011     int temp;
2012     auto manager = CKM::Manager::create();
2013
2014     std::string prv =
2015       "-----BEGIN EC PRIVATE KEY-----\n"
2016       "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
2017       "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
2018       "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
2019       "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
2020       "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
2021       "ELyhe7yPCAuOoLZlTLgf\n"
2022       "-----END EC PRIVATE KEY-----\n";
2023
2024     std::string pub =
2025       "-----BEGIN CERTIFICATE-----\n"
2026       "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
2027       "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
2028       "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
2029       "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
2030       "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
2031       "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
2032       "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
2033       "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
2034       "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
2035       "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
2036       "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
2037       "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
2038       "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
2039       "Q1oBry6NEc+lLFmWMDesAA==\n"
2040       "-----END CERTIFICATE-----\n";
2041
2042     std::string message = "message test";
2043
2044     CKM::Alias aliasPub = "pub3";
2045     CKM::Alias aliasPrv = "prv3";
2046     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2047     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2048     CKM::RawBuffer signature;
2049
2050     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
2051     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
2052
2053     RUNNER_ASSERT_MSG(NULL != cert.get(),
2054         "Key is empty. Failed to import public key.");
2055     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2056         "Key is empty. Failed to import private key.");
2057
2058     RUNNER_ASSERT_MSG(
2059         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
2060         "Error=" << CKM::APICodeToString(temp));
2061     RUNNER_ASSERT_MSG(
2062         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
2063         "Error=" << CKM::APICodeToString(temp));
2064
2065     RUNNER_ASSERT_MSG(
2066         CKM_API_SUCCESS == (temp = manager->createSignature(
2067                                         aliasPrv,
2068                                         CKM::Password(),
2069                                         CKM::RawBuffer(message.begin(), message.end()),
2070                                         hash,
2071                                         padd,
2072                                         signature)),
2073         "Error=" << CKM::APICodeToString(temp));
2074
2075     RUNNER_ASSERT_MSG(
2076         CKM_API_SUCCESS == (temp = manager->verifySignature(
2077                                         aliasPub,
2078                                         CKM::Password(),
2079                                         CKM::RawBuffer(message.begin(), message.end()),
2080                                         signature,
2081                                         hash,
2082                                         padd)),
2083         "Error=" << CKM::APICodeToString(temp));
2084
2085     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2086
2087     memcpy((void*)signature.data(), "BROKEN", 6);
2088
2089     RUNNER_ASSERT_MSG(
2090         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2091                                         aliasPub,
2092                                         CKM::Password(),
2093                                         CKM::RawBuffer(message.begin(), message.end()),
2094                                         signature,
2095                                         hash,
2096                                         padd)),
2097         "Error=" << CKM::APICodeToString(temp));
2098 }
2099
2100 RUNNER_TEST(T1420_deinit)
2101 {
2102     remove_user_data(USER_APP);
2103 }
2104
2105 RUNNER_TEST_GROUP_INIT(T1418_signature_tests);
2106
2107 RUNNER_TEST(T14180_init)
2108 {
2109     int temp;
2110     remove_user_data(USER_APP);
2111
2112     auto manager = CKM::Manager::create();
2113
2114     // Prepare RSA Key Pair
2115     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2116       "Proc-Type: 4,ENCRYPTED\n"
2117       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
2118       "\n"
2119       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
2120       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
2121       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
2122       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
2123       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
2124       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
2125       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
2126       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
2127       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
2128       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
2129       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
2130       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
2131       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
2132       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
2133       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
2134       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
2135       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
2136       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
2137       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
2138       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
2139       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
2140       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
2141       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
2142       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
2143       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
2144       "-----END RSA PRIVATE KEY-----\n";
2145
2146     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
2147       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2148       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2149       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2150       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2151       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2152       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2153       "zQIDAQAB\n"
2154       "-----END PUBLIC KEY-----\n";
2155
2156     CKM::Alias aliasPub = "pub_nohash1";
2157     CKM::Alias aliasPrv = "prv_nohash1";
2158     CKM::Password password = "1234";
2159
2160     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
2161     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
2162
2163     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
2164         "Key is empty. Failed to import public key.");
2165     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2166         "Key is empty. Failed to import private key.");
2167
2168     RUNNER_ASSERT_MSG(
2169         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
2170         "Error=" << CKM::APICodeToString(temp));
2171     RUNNER_ASSERT_MSG(
2172         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
2173         "Error=" << CKM::APICodeToString(temp));
2174
2175     // Prepare ECDSA Key Pair
2176     std::string ecprv = "-----BEGIN EC PRIVATE KEY-----\n"
2177         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
2178         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
2179         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2180         "-----END EC PRIVATE KEY-----\n";
2181
2182     std::string ecpub = "-----BEGIN PUBLIC KEY-----\n"
2183         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
2184         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2185         "-----END PUBLIC KEY-----\n";
2186
2187     CKM::Alias aliasEcPub = "ecpub_nohash1";
2188     CKM::Alias aliasEcPrv = "ecprv_nohash1";
2189
2190     auto ecKeyPub = CKM::Key::create(CKM::RawBuffer(ecpub.begin(), ecpub.end()));
2191     auto ecKeyPrv = CKM::Key::create(CKM::RawBuffer(ecprv.begin(), ecprv.end()));
2192
2193     RUNNER_ASSERT_MSG(NULL != ecKeyPub.get(),
2194         "Key is empty. Failed to import public key.");
2195     RUNNER_ASSERT_MSG(NULL != ecKeyPrv.get(),
2196         "Key is empty. Failed to import private key.");
2197
2198     RUNNER_ASSERT_MSG(
2199         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPub, ecKeyPub, CKM::Policy())),
2200         "Error=" << CKM::APICodeToString(temp));
2201     RUNNER_ASSERT_MSG(
2202         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPrv, ecKeyPrv, CKM::Policy())),
2203         "Error=" << CKM::APICodeToString(temp));
2204 }
2205
2206
2207 RUNNER_TEST(T14181_RSA_create_signatue_nohash)
2208 {
2209     int temp;
2210     auto manager = CKM::Manager::create();
2211     std::string message = "message asdfaslkdfjlksadjf test";
2212
2213     CKM::Alias aliasPub = "pub_nohash1";
2214     CKM::Alias aliasPrv = "prv_nohash1";
2215
2216     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2217     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2218     CKM::RawBuffer signature;
2219
2220     RUNNER_ASSERT_MSG(
2221         CKM_API_SUCCESS == (temp = manager->createSignature(
2222                                         aliasPrv,
2223                                         CKM::Password(),
2224                                         CKM::RawBuffer(message.begin(), message.end()),
2225                                         hash,
2226                                         padd,
2227                                         signature)),
2228         "Error=" << CKM::APICodeToString(temp));
2229
2230     RUNNER_ASSERT_MSG(
2231         CKM_API_SUCCESS == (temp = manager->verifySignature(
2232                                         aliasPub,
2233                                         CKM::Password(),
2234                                         CKM::RawBuffer(message.begin(), message.end()),
2235                                         signature,
2236                                         hash,
2237                                         padd)),
2238         "Error=" << CKM::APICodeToString(temp));
2239
2240     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2241     memcpy((void*)signature.data(), "BROKEN", 6);
2242
2243     RUNNER_ASSERT_MSG(
2244         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2245                                         aliasPub,
2246                                         CKM::Password(),
2247                                         CKM::RawBuffer(message.begin(), message.end()),
2248                                         signature,
2249                                         hash,
2250                                         padd)),
2251         "Error=" << CKM::APICodeToString(temp));
2252 }
2253
2254 RUNNER_TEST(T14182_RSA_create_signatue_nohash_nopad)
2255 {
2256     int temp;
2257     auto manager = CKM::Manager::create();
2258     std::string message = "message asdfaslkdfjlksadjf test";
2259
2260     CKM::Alias aliasPub = "pub_nohash1";
2261     CKM::Alias aliasPrv = "prv_nohash1";
2262
2263     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2264     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2265     CKM::RawBuffer signature;
2266
2267     RUNNER_ASSERT_MSG(
2268         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2269                                         aliasPrv,
2270                                         CKM::Password(),
2271                                         CKM::RawBuffer(message.begin(), message.end()),
2272                                         hash,
2273                                         padd,
2274                                         signature)),
2275         "Error=" << CKM::APICodeToString(temp));
2276 }
2277
2278 RUNNER_TEST(T14183_RSA_create_signatue_nohash_bigmsg)
2279 {
2280     int temp;
2281     auto manager = CKM::Manager::create();
2282     std::string message = "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                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
2302
2303     CKM::Alias aliasPub = "pub_nohash1";
2304     CKM::Alias aliasPrv = "prv_nohash1";
2305
2306     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2307     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2308     CKM::RawBuffer signature;
2309
2310     RUNNER_ASSERT_MSG(
2311         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2312                                         aliasPrv,
2313                                         CKM::Password(),
2314                                         CKM::RawBuffer(message.begin(), message.end()),
2315                                         hash,
2316                                         padd,
2317                                         signature)),
2318         "Error=" << CKM::APICodeToString(temp));
2319 }
2320
2321
2322 RUNNER_TEST(T14184_ECDSA_create_signatue_nohash)
2323 {
2324     int temp;
2325     auto manager = CKM::Manager::create();
2326
2327     std::string message = "message test";
2328
2329     CKM::Alias aliasPub = "ecpub_nohash1";
2330     CKM::Alias aliasPrv = "ecprv_nohash1";
2331     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2332     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2333     CKM::RawBuffer signature;
2334
2335     RUNNER_ASSERT_MSG(
2336         CKM_API_SUCCESS == (temp = manager->createSignature(
2337                                         aliasPrv,
2338                                         CKM::Password(),
2339                                         CKM::RawBuffer(message.begin(), message.end()),
2340                                         hash,
2341                                         padd,
2342                                         signature)),
2343         "Error=" << CKM::APICodeToString(temp));
2344
2345     RUNNER_ASSERT_MSG(
2346         CKM_API_SUCCESS == (temp = manager->verifySignature(
2347                                         aliasPub,
2348                                         CKM::Password(),
2349                                         CKM::RawBuffer(message.begin(), message.end()),
2350                                         signature,
2351                                         hash,
2352                                         padd)),
2353         "Error=" << CKM::APICodeToString(temp));
2354
2355     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2356
2357     memcpy((void*)signature.data(), "BROKEN", 6);
2358
2359     RUNNER_ASSERT_MSG(
2360         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2361                                         aliasPub,
2362                                         CKM::Password(),
2363                                         CKM::RawBuffer(message.begin(), message.end()),
2364                                         signature,
2365                                         hash,
2366                                         padd)),
2367         "Error=" << CKM::APICodeToString(temp));
2368 }
2369
2370 RUNNER_TEST(T14185_ECDSA_create_signatue_nohash_bigmsg)
2371 {
2372     int temp;
2373     auto manager = CKM::Manager::create();
2374
2375     int msgSize = 1024*1024;
2376     char big_msg[msgSize];
2377     for(int i =0; i<msgSize-1; i++) {
2378         big_msg[i] = 'a';
2379     }
2380     big_msg[msgSize-1]=0x00;
2381     std::string message(big_msg);
2382
2383     CKM::Alias aliasPub = "ecpub_nohash1";
2384     CKM::Alias aliasPrv = "ecprv_nohash1";
2385     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2386     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2387     CKM::RawBuffer signature;
2388
2389     RUNNER_ASSERT_MSG(
2390             CKM_API_SUCCESS == (temp = manager->createSignature(
2391                                         aliasPrv,
2392                                         CKM::Password(),
2393                                         CKM::RawBuffer(message.begin(), message.end()),
2394                                         hash,
2395                                         padd,
2396                                         signature)),
2397         "Error=" << CKM::APICodeToString(temp));
2398 }
2399
2400
2401 RUNNER_TEST(T14189_deinit)
2402 {
2403     remove_user_data(USER_APP);
2404 }
2405
2406
2407 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
2408
2409 namespace
2410 {
2411 CKM::Alias alias_PKCS_collision = "test-PKCS-collision";
2412 CKM::Alias alias_PKCS_exportable = "test-PKCS-export";
2413 CKM::Alias alias_PKCS_not_exportable = "test-PKCS-no-export";
2414 CKM::Alias alias_PKCS_priv_key_copy = "test-PKCS-private-key-copy";
2415 CKM::Alias alias_PKCS_priv_key_wrong = "test-PKCS-private-key-wrong";
2416 }
2417
2418 RUNNER_TEST(T1800_init)
2419 {
2420     remove_user_data(USER_APP);
2421 }
2422
2423 RUNNER_TEST(T1801_parse_PKCS12) {
2424     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2425     std::istreambuf_iterator<char> begin(is), end;
2426     std::vector<char> buff(begin, end);
2427
2428     CKM::RawBuffer buffer(buff.size());
2429     memcpy(buffer.data(), buff.data(), buff.size());
2430
2431     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2432     RUNNER_ASSERT_MSG(
2433         NULL != pkcs.get(),
2434         "Error in PKCS12::create()");
2435
2436     auto cert = pkcs->getCertificate();
2437     RUNNER_ASSERT_MSG(
2438         NULL != cert.get(),
2439         "Error in PKCS12::getCertificate()");
2440
2441     auto key = pkcs->getKey();
2442     RUNNER_ASSERT_MSG(
2443         NULL != key.get(),
2444         "Error in PKCS12::getKey()");
2445
2446     auto caVector = pkcs->getCaCertificateShPtrVector();
2447     RUNNER_ASSERT_MSG(
2448         0 == caVector.size(),
2449         "Wrong size of vector");
2450 }
2451
2452 RUNNER_TEST(T1802_negative_wrong_password) {
2453     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2454     std::istreambuf_iterator<char> begin(is), end;
2455     std::vector<char> buff(begin, end);
2456
2457     CKM::RawBuffer buffer(buff.size());
2458     memcpy(buffer.data(), buff.data(), buff.size());
2459
2460     auto pkcs = CKM::PKCS12::create(buffer, "error");
2461     RUNNER_ASSERT_MSG(
2462         NULL == pkcs.get(),
2463         "Expected error in PKCS12::create()");
2464 }
2465
2466 RUNNER_TEST(T1803_negative_broken_buffer) {
2467     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2468     std::istreambuf_iterator<char> begin(is), end;
2469     std::vector<char> buff(begin, end);
2470
2471     CKM::RawBuffer buffer(buff.size());
2472     memcpy(buffer.data(), buff.data(), buff.size());
2473
2474     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
2475     buffer[4]=0;
2476
2477     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2478     RUNNER_ASSERT_MSG(
2479         NULL == pkcs.get(),
2480         "Expected error in PKCS12::create()");
2481 }
2482
2483 RUNNER_TEST(T1804_add_PKCS_collision_with_existing_alias)
2484 {
2485     auto manager = CKM::Manager::create();
2486     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2487     std::istreambuf_iterator<char> begin(is), end;
2488     std::vector<char> buff(begin, end);
2489
2490     CKM::RawBuffer buffer(buff.size());
2491     memcpy(buffer.data(), buff.data(), buff.size());
2492
2493     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2494     RUNNER_ASSERT_MSG(
2495         NULL != pkcs.get(),
2496         "Error in PKCS12::create()");
2497
2498     // save private key
2499     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2500         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2501         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2502         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2503         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2504         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2505         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2506         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2507         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2508         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2509         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2510         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2511         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2512         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2513         "-----END RSA PRIVATE KEY-----\n";
2514
2515     std::string message = "message test";
2516
2517     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2518     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2519         "Key is empty. Failed to import private key.");
2520
2521     int temp;
2522     RUNNER_ASSERT_MSG(
2523         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_collision, keyPrv, CKM::Policy())),
2524         "Error=" << CKM::APICodeToString(temp));
2525
2526     RUNNER_ASSERT_MSG(
2527         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->savePKCS12(alias_PKCS_collision, pkcs, CKM::Policy(), CKM::Policy())),
2528         "Error=" << CKM::APICodeToString(temp));
2529 }
2530
2531 RUNNER_TEST(T1805_add_bundle_with_chain_certificates)
2532 {
2533     auto manager = CKM::Manager::create();
2534     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2535     std::istreambuf_iterator<char> begin(is), end;
2536     std::vector<char> buff(begin, end);
2537
2538     CKM::RawBuffer buffer(buff.size());
2539     memcpy(buffer.data(), buff.data(), buff.size());
2540
2541     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2542     RUNNER_ASSERT_MSG(
2543         NULL != pkcs.get(),
2544         "Error in PKCS12::create()");
2545
2546     auto cert = pkcs->getCertificate();
2547     RUNNER_ASSERT_MSG(
2548         NULL != cert.get(),
2549         "Error in PKCS12::getCertificate()");
2550
2551     auto key = pkcs->getKey();
2552     RUNNER_ASSERT_MSG(
2553         NULL != key.get(),
2554         "Error in PKCS12::getKey()");
2555
2556     auto caVector = pkcs->getCaCertificateShPtrVector();
2557     RUNNER_ASSERT_MSG(
2558         2 == caVector.size(),
2559         "Wrong size of vector");
2560
2561     // save to the CKM
2562     int tmp;
2563     CKM::Policy exportable;
2564     CKM::Policy notExportable(CKM::Password(), false);
2565
2566     RUNNER_ASSERT_MSG(
2567         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2568         "Error=" << CKM::APICodeToString(tmp));
2569     RUNNER_ASSERT_MSG(
2570         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2571         "Error=" << CKM::APICodeToString(tmp));
2572     RUNNER_ASSERT_MSG(
2573         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2574         "Error=" << CKM::APICodeToString(tmp));
2575     RUNNER_ASSERT_MSG(
2576         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2577         "Error=" << CKM::APICodeToString(tmp));
2578
2579     // try to lookup key
2580     CKM::KeyShPtr key_lookup;
2581     RUNNER_ASSERT_MSG(
2582         CKM_API_SUCCESS == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2583         "Error=" << CKM::APICodeToString(tmp));
2584     RUNNER_ASSERT_MSG(
2585         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2586         "Error=" << CKM::APICodeToString(tmp));
2587
2588     // try to lookup certificate
2589     CKM::CertificateShPtr cert_lookup;
2590     RUNNER_ASSERT_MSG(
2591         CKM_API_SUCCESS == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2592         "Error=" << CKM::APICodeToString(tmp));
2593     RUNNER_ASSERT_MSG(
2594         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2595         "Error=" << CKM::APICodeToString(tmp));
2596 }
2597
2598 RUNNER_TEST(T1806_get_PKCS)
2599 {
2600     int temp;
2601     auto manager = CKM::Manager::create();
2602
2603     CKM::PKCS12ShPtr pkcs;
2604
2605     // fail - no entry
2606     RUNNER_ASSERT_MSG(
2607         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getPKCS12("i-do-not-exist", pkcs)),
2608         "Error=" << CKM::APICodeToString(temp));
2609
2610     // fail - not exportable
2611     RUNNER_ASSERT_MSG(
2612         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getPKCS12(alias_PKCS_not_exportable, pkcs)),
2613         "Error=" << CKM::APICodeToString(temp));
2614
2615     // success - exportable
2616     RUNNER_ASSERT_MSG(
2617         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias_PKCS_exportable, pkcs)),
2618         "Error=" << CKM::APICodeToString(temp));
2619
2620     auto cert = pkcs->getCertificate();
2621     RUNNER_ASSERT_MSG(
2622         NULL != cert.get(),
2623         "Error in PKCS12::getCertificate()");
2624
2625     auto key = pkcs->getKey();
2626     RUNNER_ASSERT_MSG(
2627         NULL != key.get(),
2628         "Error in PKCS12::getKey()");
2629
2630     auto caVector = pkcs->getCaCertificateShPtrVector();
2631     RUNNER_ASSERT_MSG(
2632         2 == caVector.size(),
2633         "Wrong size of vector");
2634 }
2635
2636 RUNNER_TEST(T1807_create_and_verify_signature)
2637 {
2638     int temp;
2639     auto manager = CKM::Manager::create();
2640
2641     std::string message = "message test";
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_exportable,
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(T1808_create_signature_on_raw_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         "MIICXQIBAAKBgQD1W9neUbXL1rnq9SvyzprjhWBKXyYKQirG3V2zyUnUaE24Sq2I\n"
2675         "v7ISrwMN/G6WcjrGmeZDEWwrL4zXh002N8BD1waJPRonxwtVkhFy3emGatSmx7eI\n"
2676         "ely5H+PBNImRvBh2u4GWga6OEXcUNdfaBUcxn+P6548/zpDhyNLzQKk5FwIDAQAB\n"
2677         "AoGAR+4WkBuqTUj1FlGsAbHaLKt0UDlWwJknS0eoacWwFEpDxqx19WolfV67aYVA\n"
2678         "snBolMKXg7/+0yZMhv8Ofr+XaHkPQplVVn9BwT0rmtEovJXwx+poRP9Bm3emglj/\n"
2679         "iYd8EkaXDlIXCtewtQW9JEIctWppntHj3TvA/h7FCXPN6SkCQQD/N7sn5S1gBkVh\n"
2680         "dyXQKoyKsZDb7hMIS1q6cKwYCMf2UrsD1/lnr7xXkvORdL213MfueO8g0WkuKfRY\n"
2681         "bDD6WGX1AkEA9hxiOlsgvermqLJkOlJffbSaM8n/6wtnM0HV+Vd9NfSBOmxFDXPO\n"
2682         "vrvdgiDPENhbqTJSQVDsfzHilTpK7lEvWwJBAJLxHoOg0tg3pBiyxgWtic+M3q+R\n"
2683         "ykl7QViY6KzJ2X98MIrM/Z7yMollZXE4+sVLwZ0O6fdGOr3GkBWc7TImVUUCQQC7\n"
2684         "pf6bQfof9Ce0fnf/I+ldHkPost7nJsWkBlGQkM2OQwP5OK4ZyK/dK76DxmI7FMwm\n"
2685         "oJCo7nuzq6R4ZX7WYJ47AkBavxBDo/e9/0Vk5yrloGKW3f8RQXBJLcCkVUGyyJ3D\n"
2686         "3gu/nafW4hzjSJniTjC1fOj0eb0OSg1JAvqHTYAnUsI7\n"
2687         "-----END RSA PRIVATE KEY-----";
2688     std::string message = "message test";
2689
2690     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2691     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2692         "Key is empty. Failed to import private key.");
2693
2694     RUNNER_ASSERT_MSG(
2695         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_copy, keyPrv, CKM::Policy())),
2696         "Error=" << CKM::APICodeToString(temp));
2697
2698     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2699     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2700     CKM::RawBuffer signature;
2701
2702     RUNNER_ASSERT_MSG(
2703         CKM_API_SUCCESS == (temp = manager->createSignature(
2704                                         alias_PKCS_priv_key_copy,
2705                                         CKM::Password(),
2706                                         CKM::RawBuffer(message.begin(), message.end()),
2707                                         hash,
2708                                         padd,
2709                                         signature)),
2710         "Error=" << CKM::APICodeToString(temp));
2711
2712     RUNNER_ASSERT_MSG(
2713         CKM_API_SUCCESS == (temp = manager->verifySignature(
2714                                         alias_PKCS_exportable,
2715                                         CKM::Password(),
2716                                         CKM::RawBuffer(message.begin(), message.end()),
2717                                         signature,
2718                                         hash,
2719                                         padd)),
2720         "Error=" << CKM::APICodeToString(temp));
2721 }
2722
2723 RUNNER_TEST(T1809_create_signature_on_wrong_key_and_verify_on_PKCS)
2724 {
2725     int temp;
2726     auto manager = CKM::Manager::create();
2727
2728     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2729         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2730         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2731         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2732         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2733         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2734         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2735         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2736         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2737         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2738         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2739         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2740         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2741         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2742         "-----END RSA PRIVATE KEY-----\n";
2743
2744     std::string message = "message test";
2745
2746     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2747     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2748         "Key is empty. Failed to import private key.");
2749
2750     RUNNER_ASSERT_MSG(
2751         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_wrong, keyPrv, CKM::Policy())),
2752         "Error=" << CKM::APICodeToString(temp));
2753
2754     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2755     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2756     CKM::RawBuffer signature;
2757
2758     RUNNER_ASSERT_MSG(
2759         CKM_API_SUCCESS == (temp = manager->createSignature(
2760                                         alias_PKCS_priv_key_wrong,
2761                                         CKM::Password(),
2762                                         CKM::RawBuffer(message.begin(), message.end()),
2763                                         hash,
2764                                         padd,
2765                                         signature)),
2766         "Error=" << CKM::APICodeToString(temp));
2767
2768     RUNNER_ASSERT_MSG(
2769         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2770                                         alias_PKCS_exportable,
2771                                         CKM::Password(),
2772                                         CKM::RawBuffer(message.begin(), message.end()),
2773                                         signature,
2774                                         hash,
2775                                         padd)),
2776         "Error=" << CKM::APICodeToString(temp));
2777 }
2778
2779 RUNNER_TEST(T1810_verify_get_certificate_chain)
2780 {
2781     // this certificate has been signed using PKCS chain
2782     std::string im =
2783         "-----BEGIN CERTIFICATE-----\n"
2784         "MIIBozCCAQwCAQEwDQYJKoZIhvcNAQEFBQAwHDEaMBgGA1UEAwwRc2VydmVyQHRl\n"
2785         "c3RtZS5jb20wHhcNMTUxMjA5MTA0NjU0WhcNMjUxMjA2MTA0NjU0WjAYMRYwFAYD\n"
2786         "VQQDDA1lZUB0ZXN0bWUuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDP\n"
2787         "+fNsZB1Vlmhnk0IwYDs7Pw9E38KQfTt/egqqRFN6IvIt0CCDBXqnPTujuvlO2OyL\n"
2788         "XVuALnIBmTDm5Oz+oz+qiY6/XrVS/CoACNZyMo6ihG9OeocvDbU3jXEaPGL6ib/x\n"
2789         "jlms0aA9d5L9TO2lEzEP7bFKgHCB8FWINcxSP5zl1QIDAQABMA0GCSqGSIb3DQEB\n"
2790         "BQUAA4GBAKBpVJMkdK6/qnAz7d7Bul/BhhSLEYbNPdxRiUj3U2dt0GJgswMu2SNT\n"
2791         "/3NXB8V8mnnXR6cWn5bmjyA7ZpQEKAatS/KEQ9wfLXyCgYDRebX71mVKAI3XcyxB\n"
2792         "p2qsOWWaJhuHmC1GVjx3foL+RDrmRo6BiucNHMIuvrd1W36eKdhj\n"
2793         "-----END CERTIFICATE-----\n";
2794
2795     auto cert = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
2796     CKM::CertificateShPtrVector certChain;
2797     CKM::AliasVector aliasVector;
2798
2799     int tmp;
2800     auto manager = CKM::Manager::create();
2801
2802     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
2803
2804     tmp = manager->getCertificateChain(cert,
2805                                        EMPTY_ALIAS_VECTOR,
2806                                        EMPTY_ALIAS_VECTOR,
2807                                        true,
2808                                        certChain);
2809     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
2810                          "Error=" << CKM::APICodeToString(tmp));
2811
2812     RUNNER_ASSERT_MSG(
2813         0 == certChain.size(),
2814         "Wrong size of certificate chain.");
2815
2816     aliasVector.push_back(alias_PKCS_exportable);
2817
2818     tmp = manager->getCertificateChain(cert, EMPTY_ALIAS_VECTOR, aliasVector, false, certChain);
2819     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKM::APICodeToString(tmp));
2820
2821     // 1(cert) + 1(pkcs12 cert) + 2(pkcs12 chain cert) = 4
2822     RUNNER_ASSERT_MSG(
2823         4 == certChain.size(),
2824         "Wrong size of certificate chain: " << certChain.size());
2825 }
2826
2827 RUNNER_TEST(T1811_remove_bundle_with_chain_certificates)
2828 {
2829     auto manager = CKM::Manager::create();
2830     int tmp;
2831
2832
2833     // remove the whole PKCS12 bundles
2834     RUNNER_ASSERT_MSG(
2835         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_exportable)),
2836         "Error=" << CKM::APICodeToString(tmp));
2837     RUNNER_ASSERT_MSG(
2838         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_not_exportable)),
2839         "Error=" << CKM::APICodeToString(tmp));
2840
2841     // expect lookup fails due to unknown alias
2842     // try to lookup key
2843     CKM::KeyShPtr key_lookup;
2844     RUNNER_ASSERT_MSG(
2845         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2846         "Error=" << CKM::APICodeToString(tmp));
2847     RUNNER_ASSERT_MSG(
2848         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2849         "Error=" << CKM::APICodeToString(tmp));
2850
2851     // try to lookup certificate
2852     CKM::CertificateShPtr cert_lookup;
2853     RUNNER_ASSERT_MSG(
2854         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2855         "Error=" << CKM::APICodeToString(tmp));
2856     RUNNER_ASSERT_MSG(
2857         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2858         "Error=" << CKM::APICodeToString(tmp));
2859 }
2860
2861 RUNNER_TEST(T1812_get_pkcs12_password_tests)
2862 {
2863     CKM::Alias alias = "t1812alias1";
2864
2865     auto manager = CKM::Manager::create();
2866     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2867     std::istreambuf_iterator<char> begin(is), end;
2868     std::vector<char> buff(begin, end);
2869
2870     CKM::PKCS12ShPtr pkcs12;
2871     CKM::Password pass1 = "easypass1";
2872     CKM::Password pass2 = "easypass2";
2873
2874     CKM::RawBuffer buffer(buff.size());
2875     memcpy(buffer.data(), buff.data(), buff.size());
2876
2877     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2878     RUNNER_ASSERT_MSG(
2879         NULL != pkcs.get(),
2880         "Error in PKCS12::create()");
2881
2882     int temp;
2883     RUNNER_ASSERT_MSG(
2884         CKM_API_SUCCESS == (temp = manager->savePKCS12(alias, pkcs, CKM::Policy(pass1), CKM::Policy(pass2))),
2885         "Error=" << CKM::APICodeToString(temp));
2886
2887     RUNNER_ASSERT_MSG(
2888         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pkcs)),
2889         "Error=" << CKM::APICodeToString(temp));
2890
2891     RUNNER_ASSERT_MSG(
2892         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), CKM::Password(), pkcs)),
2893         "Error=" << CKM::APICodeToString(temp));
2894
2895     RUNNER_ASSERT_MSG(
2896         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pass1, CKM::Password(), pkcs)),
2897         "Error=" << CKM::APICodeToString(temp));
2898
2899     RUNNER_ASSERT_MSG(
2900         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), pass2, pkcs)),
2901         "Error=" << CKM::APICodeToString(temp));
2902
2903     RUNNER_ASSERT_MSG(
2904         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias, pass1, pass2, pkcs)),
2905         "Error=" << CKM::APICodeToString(temp));
2906
2907     CKM::CertificateShPtr cert;
2908     RUNNER_ASSERT_MSG(
2909         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, pass2, cert)),
2910         "Error=" << CKM::APICodeToString(temp));
2911
2912     CKM::CertificateShPtrVector certChain;
2913     CKM::AliasVector certVect;
2914     certVect.push_back(alias);
2915
2916     RUNNER_ASSERT_MSG(
2917         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getCertificateChain(cert, certVect, certVect, true, certChain)),
2918         "Error=" << CKM::APICodeToString(temp));
2919 }
2920
2921 RUNNER_TEST(T1813_deinit)
2922 {
2923     int temp;
2924     auto control = CKM::Control::create();
2925
2926     RUNNER_ASSERT_MSG(
2927         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
2928         "Error=" << CKM::APICodeToString(temp));
2929 }
2930
2931 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
2932 namespace {
2933 const char * const T190_PASSWD = "t190-special-password";
2934 }
2935 RUNNER_TEST(T1901_init_unlock_key)
2936 {
2937     reset_user_data(USER_APP, T190_PASSWD);
2938 }
2939
2940 RUNNER_TEST(T1902_get_data)
2941 {
2942     ScopedDBUnlock unlock(USER_APP, T190_PASSWD);
2943
2944     auto manager = CKM::Manager::create();
2945     CKM::KeyShPtr ptr;
2946
2947     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2948
2949     RUNNER_ASSERT_MSG(
2950         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
2951         "Could not put certificate in datbase. Error=" << CKM::APICodeToString(status1));
2952 }
2953
2954 RUNNER_TEST(T1903_lock_database)
2955 {
2956     int tmp;
2957     auto control = CKM::Control::create();
2958     RUNNER_ASSERT_MSG(
2959         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2960         "Error=" << CKM::APICodeToString(tmp));
2961 }
2962
2963 RUNNER_TEST(T1904_get_data_from_locked_database)
2964 {
2965     auto manager = CKM::Manager::create();
2966     CKM::KeyShPtr ptr;
2967
2968     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2969
2970     RUNNER_ASSERT_MSG(
2971         CKM_API_ERROR_DB_LOCKED == status1,
2972         "Could not get key from locked database. Error=" << CKM::APICodeToString(status1));
2973 }
2974
2975 RUNNER_TEST(T1905_deinit)
2976 {
2977     remove_user_data(USER_APP);
2978 }
2979
2980 int main(int argc, char *argv[])
2981 {
2982     uid_t expected_uid = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
2983     if (expected_uid != geteuid()) {
2984         std::string userStr("owner");
2985         const char* user = tzplatform_getenv(TZ_SYS_DEFAULT_USER);
2986         if (user)
2987             userStr = user;
2988
2989         std::cerr << argv[0] << " should be executed as " << userStr << ". Aborting" << std::endl;
2990         return -1;
2991     }
2992
2993     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
2994 }