src/ckm/unprivileged/main.cpp

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