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