src/ckm/unprivileged/main.cpp

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