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