src/ckm/main.cpp

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