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