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 namespace {
2316 CKM::Alias certeeAlias("CertEE");
2317 CKM::Alias certimAlias("CertIM");
2318 }
2319 RUNNER_CHILD_TEST(T1510_init_unlock_key)
2320 {
2321     reset_user_data(USER_TEST, "strong-password");
2322
2323     // initial DB feed
2324     AccessProvider ap("my-label");
2325     ap.allowAPI("key-manager::api-storage", "rw");
2326     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2327
2328     auto manager = CKM::Manager::create();
2329     auto certee = TestData::getTestCertificate(TestData::MBANK);
2330     auto certim = TestData::getTestCertificate(TestData::SYMANTEC);
2331     RUNNER_ASSERT(CKM_API_SUCCESS == manager->saveCertificate(certeeAlias, certee, CKM::Policy()));
2332     RUNNER_ASSERT(CKM_API_SUCCESS == manager->saveCertificate(certimAlias, certim, CKM::Policy()));
2333 }
2334
2335 RUNNER_TEST(T1511_restart_CKM)
2336 {
2337     // restart CKM
2338     stop_service(MANAGER);
2339     start_service(MANAGER);
2340     unlock_user_data(USER_TEST, "strong-password");
2341 }
2342
2343 RUNNER_CHILD_TEST(T1512_check_data_exists)
2344 {
2345     // actual test
2346     AccessProvider ap("my-label");
2347     ap.allowAPI("key-manager::api-storage", "rw");
2348     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2349
2350     auto manager = CKM::Manager::create();
2351     auto certee = TestData::getTestCertificate(TestData::MBANK);
2352     auto certim = TestData::getTestCertificate(TestData::SYMANTEC);
2353     int status1 = manager->saveCertificate(certeeAlias, certee, CKM::Policy());
2354     int status2 = manager->saveCertificate(certimAlias, certim, CKM::Policy());
2355     RUNNER_ASSERT_MSG(
2356         CKM_API_ERROR_DB_ALIAS_EXISTS == status1,
2357         "Certificate should be in database already. Error=" << CKM::ErrorToString(status1));
2358     RUNNER_ASSERT_MSG(
2359         CKM_API_ERROR_DB_ALIAS_EXISTS == status2,
2360         "Certificate should be in database already. Error=" << CKM::ErrorToString(status2));
2361 }
2362
2363 RUNNER_TEST(T1519_deinit)
2364 {
2365     remove_user_data(USER_TEST);
2366 }
2367
2368
2369 RUNNER_TEST_GROUP_INIT(T170_CKM_STORAGE_PERNAMENT_TESTS);
2370
2371 RUNNER_TEST(T1701_init_unlock_key)
2372 {
2373     int tmp;
2374     auto control = CKM::Control::create();
2375     RUNNER_ASSERT_MSG(
2376         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+1, "t170-special-password")),
2377         "Error=" << CKM::ErrorToString(tmp));
2378 }
2379
2380 RUNNER_CHILD_TEST(T1702_insert_data)
2381 {
2382     int temp;
2383     AccessProvider ap("t170-special-label");
2384     ap.allowAPI("key-manager::api-storage", "rw");
2385     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2386
2387     auto certee = TestData::getTestCertificate(TestData::MBANK);
2388
2389     auto manager = CKM::Manager::create();
2390     int status1 = manager->saveCertificate(CKM::Alias("CertEEE"), certee, CKM::Policy());
2391
2392     RUNNER_ASSERT_MSG(
2393         CKM_API_SUCCESS == status1,
2394         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
2395
2396     CKM::AliasVector av;
2397     RUNNER_ASSERT_MSG(
2398         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2399         "Error=" << CKM::ErrorToString(temp));
2400     RUNNER_ASSERT_MSG(
2401         1 == (temp = av.size()),
2402         "Vector size: " << temp << ". Expected: 1");
2403 }
2404
2405 RUNNER_TEST(T1703_removeApplicationData)
2406 {
2407     int tmp;
2408     auto control = CKM::Control::create();
2409     RUNNER_ASSERT_MSG(
2410         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t170-special-label")),
2411         "Error=" << CKM::ErrorToString(tmp));
2412 }
2413
2414 RUNNER_CHILD_TEST(T1704_data_test)
2415 {
2416     int temp;
2417     AccessProvider ap("t170-special-label");
2418     ap.allowAPI("key-manager::api-storage", "rw");
2419     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2420
2421     CKM::AliasVector av;
2422     auto manager = CKM::Manager::create();
2423
2424     RUNNER_ASSERT_MSG(
2425         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2426         "Error=" << CKM::ErrorToString(temp));
2427     RUNNER_ASSERT_MSG(
2428         0 == (temp = av.size()),
2429         "Vector size: " << temp << ". Expected: 0");
2430 }
2431
2432 RUNNER_TEST(T1705_deinit)
2433 {
2434     int tmp;
2435
2436     auto control = CKM::Control::create();
2437     RUNNER_ASSERT_MSG(
2438         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+1)),
2439         "Error=" << CKM::ErrorToString(tmp));
2440     RUNNER_ASSERT_MSG(
2441         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+1)),
2442         "Error=" << CKM::ErrorToString(tmp));
2443 }
2444
2445 RUNNER_TEST(T17101_init)
2446 {
2447     int tmp;
2448
2449     auto control = CKM::Control::create();
2450     RUNNER_ASSERT_MSG(
2451         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
2452         "Error=" << CKM::ErrorToString(tmp));
2453     RUNNER_ASSERT_MSG(
2454         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
2455         "Error=" << CKM::ErrorToString(tmp));
2456     RUNNER_ASSERT_MSG(
2457         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+2, "t1706-special-password")),
2458         "Error=" << CKM::ErrorToString(tmp));
2459
2460     RUNNER_ASSERT_MSG(
2461         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2462         "Error=" << CKM::ErrorToString(tmp));
2463     RUNNER_ASSERT_MSG(
2464         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
2465         "Error=" << CKM::ErrorToString(tmp));
2466     RUNNER_ASSERT_MSG(
2467          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
2468          "Error=" << CKM::ErrorToString(tmp));
2469 }
2470
2471 RUNNER_CHILD_TEST(T17102_prep_data_01)
2472 {
2473     int temp;
2474     AccessProvider ap("t1706-special-label");
2475     ap.allowAPI("key-manager::api-storage", "rw");
2476     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2477
2478     CKM::AliasVector av;
2479     auto manager = CKM::Manager::create();
2480
2481     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2482
2483     CKM::RawBuffer buffer(data.begin(), data.end());
2484     CKM::Policy exportable(CKM::Password(), true);
2485
2486     RUNNER_ASSERT_MSG(
2487         CKM_API_SUCCESS == (temp = manager->saveData("data1", buffer, exportable)),
2488         "Error=" << CKM::ErrorToString(temp));
2489 }
2490
2491 RUNNER_CHILD_TEST(T17103_prep_data_02)
2492 {
2493     int temp;
2494     AccessProvider ap("t1706-special-label2");
2495     ap.allowAPI("key-manager::api-storage", "rw");
2496     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2497
2498     CKM::AliasVector av;
2499     auto manager = CKM::Manager::create();
2500
2501     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2502
2503     CKM::RawBuffer buffer(data.begin(), data.end());
2504     CKM::Policy exportable(CKM::Password(), true);
2505
2506     RUNNER_ASSERT_MSG(
2507         CKM_API_SUCCESS == (temp = manager->saveData("data2", buffer, exportable)),
2508         "Error=" << CKM::ErrorToString(temp));
2509 }
2510
2511 RUNNER_CHILD_TEST(T17104_prep_data_03)
2512 {
2513     int temp;
2514     AccessProvider ap("t1706-special-label");
2515     ap.allowAPI("key-manager::api-storage", "rw");
2516     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2517
2518     CKM::AliasVector av;
2519     auto manager = CKM::Manager::create();
2520
2521     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2522
2523     CKM::RawBuffer buffer(data.begin(), data.end());
2524     CKM::Policy exportable(CKM::Password(), true);
2525
2526     RUNNER_ASSERT_MSG(
2527         CKM_API_SUCCESS == (temp = manager->saveData("data3", buffer, exportable)),
2528         "Error=" << CKM::ErrorToString(temp));
2529 }
2530
2531 RUNNER_CHILD_TEST(T17105_prep_data_04)
2532 {
2533     int temp;
2534     AccessProvider ap("t1706-special-label2");
2535     ap.allowAPI("key-manager::api-storage", "rw");
2536     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2537
2538     CKM::AliasVector av;
2539     auto manager = CKM::Manager::create();
2540
2541     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2542
2543     CKM::RawBuffer buffer(data.begin(), data.end());
2544     CKM::Policy exportable(CKM::Password(), true);
2545
2546     RUNNER_ASSERT_MSG(
2547         CKM_API_SUCCESS == (temp = manager->saveData("data4", buffer, exportable)),
2548         "Error=" << CKM::ErrorToString(temp));
2549 }
2550
2551 RUNNER_TEST(T17106_remove_application)
2552 {
2553     int tmp;
2554
2555     auto control = CKM::Control::create();
2556     RUNNER_ASSERT_MSG(
2557         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2558         "Error=" << CKM::ErrorToString(tmp));
2559     RUNNER_ASSERT_MSG(
2560         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t1706-special-label")),
2561         "Error=" << CKM::ErrorToString(tmp));
2562 }
2563
2564 RUNNER_CHILD_TEST(T17107_check_data_01)
2565 {
2566     int temp;
2567     AccessProvider ap("t1706-special-label");
2568     ap.allowAPI("key-manager::api-storage", "rw");
2569     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2570
2571     CKM::AliasVector av;
2572     auto manager = CKM::Manager::create();
2573
2574     RUNNER_ASSERT_MSG(
2575         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2576         "Error=" << CKM::ErrorToString(temp));
2577     RUNNER_ASSERT_MSG(
2578         0 == (temp = av.size()),
2579         "Vector size: " << temp << ". Expected: 0");
2580 }
2581
2582 RUNNER_CHILD_TEST(T17108_check_data_02)
2583 {
2584     int temp;
2585     AccessProvider ap("t1706-special-label2");
2586     ap.allowAPI("key-manager::api-storage", "rw");
2587     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2588
2589     CKM::AliasVector av;
2590     auto manager = CKM::Manager::create();
2591
2592     RUNNER_ASSERT_MSG(
2593         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2594         "Error=" << CKM::ErrorToString(temp));
2595     RUNNER_ASSERT_MSG(
2596         1 == (temp = av.size()),
2597         "Vector size: " << temp << ". Expected: 1");
2598 }
2599
2600 RUNNER_TEST(T17109_unlock_user2)
2601 {
2602     int tmp;
2603
2604     auto control = CKM::Control::create();
2605     RUNNER_ASSERT_MSG(
2606          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
2607          "Error=" << CKM::ErrorToString(tmp));
2608 }
2609
2610 RUNNER_CHILD_TEST(T17110_check_data_03)
2611 {
2612     int temp;
2613     AccessProvider ap("t1706-special-label");
2614     ap.allowAPI("key-manager::api-storage", "rw");
2615     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2616
2617     CKM::AliasVector av;
2618     auto manager = CKM::Manager::create();
2619
2620     RUNNER_ASSERT_MSG(
2621         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2622         "Error=" << CKM::ErrorToString(temp));
2623     RUNNER_ASSERT_MSG(
2624         0 == (temp = av.size()),
2625         "Vector size: " << temp << ". Expected: 0");
2626 }
2627
2628 RUNNER_CHILD_TEST(T17111_check_data_04)
2629 {
2630     int temp;
2631     AccessProvider ap("t1706-special-label2");
2632     ap.allowAPI("key-manager::api-storage", "rw");
2633     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2634
2635     CKM::AliasVector av;
2636     auto manager = CKM::Manager::create();
2637
2638     RUNNER_ASSERT_MSG(
2639         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2640         "Error=" << CKM::ErrorToString(temp));
2641     RUNNER_ASSERT_MSG(
2642         1 == (temp = av.size()),
2643         "Vector size: " << temp << ". Expected: 1");
2644 }
2645
2646 RUNNER_TEST(T17112_deinit)
2647 {
2648     int tmp;
2649
2650     auto control = CKM::Control::create();
2651     RUNNER_ASSERT_MSG(
2652         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
2653         "Error=" << CKM::ErrorToString(tmp));
2654     RUNNER_ASSERT_MSG(
2655         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
2656         "Error=" << CKM::ErrorToString(tmp));
2657
2658     RUNNER_ASSERT_MSG(
2659         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2660         "Error=" << CKM::ErrorToString(tmp));
2661     RUNNER_ASSERT_MSG(
2662         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
2663         "Error=" << CKM::ErrorToString(tmp));
2664 }
2665
2666 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
2667
2668 namespace
2669 {
2670 CKM::Alias alias_PKCS_collision = "test-PKCS-collision";
2671 CKM::Alias alias_PKCS_exportable = "test-PKCS-export";
2672 CKM::Alias alias_PKCS_not_exportable = "test-PKCS-no-export";
2673 CKM::Alias alias_PKCS_priv_key_copy = "test-PKCS-private-key-copy";
2674 CKM::Alias alias_PKCS_priv_key_wrong = "test-PKCS-private-key-wrong";
2675 const char *PKCS_PASSWD = "PKCS-pass";
2676 }
2677
2678 RUNNER_TEST(T1800_init)
2679 {
2680     reset_user_data(0, PKCS_PASSWD);
2681 }
2682
2683 RUNNER_TEST(T1801_parse_PKCS12) {
2684     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2685     std::istreambuf_iterator<char> begin(is), end;
2686     std::vector<char> buff(begin, end);
2687
2688     CKM::RawBuffer buffer(buff.size());
2689     memcpy(buffer.data(), buff.data(), buff.size());
2690
2691     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2692     RUNNER_ASSERT_MSG(
2693         NULL != pkcs.get(),
2694         "Error in PKCS12::create()");
2695
2696     auto cert = pkcs->getCertificate();
2697     RUNNER_ASSERT_MSG(
2698         NULL != cert.get(),
2699         "Error in PKCS12::getCertificate()");
2700
2701     auto key = pkcs->getKey();
2702     RUNNER_ASSERT_MSG(
2703         NULL != key.get(),
2704         "Error in PKCS12::getKey()");
2705
2706     auto caVector = pkcs->getCaCertificateShPtrVector();
2707     RUNNER_ASSERT_MSG(
2708         0 == caVector.size(),
2709         "Wrong size of vector");
2710 }
2711
2712 RUNNER_TEST(T1802_negative_wrong_password) {
2713     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2714     std::istreambuf_iterator<char> begin(is), end;
2715     std::vector<char> buff(begin, end);
2716
2717     CKM::RawBuffer buffer(buff.size());
2718     memcpy(buffer.data(), buff.data(), buff.size());
2719
2720     auto pkcs = CKM::PKCS12::create(buffer, "error");
2721     RUNNER_ASSERT_MSG(
2722         NULL == pkcs.get(),
2723         "Expected error in PKCS12::create()");
2724 }
2725
2726 RUNNER_TEST(T1803_negative_broken_buffer) {
2727     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2728     std::istreambuf_iterator<char> begin(is), end;
2729     std::vector<char> buff(begin, end);
2730
2731     CKM::RawBuffer buffer(buff.size());
2732     memcpy(buffer.data(), buff.data(), buff.size());
2733
2734     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
2735     buffer[4]=0;
2736
2737     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2738     RUNNER_ASSERT_MSG(
2739         NULL == pkcs.get(),
2740         "Expected error in PKCS12::create()");
2741 }
2742
2743 RUNNER_TEST(T1804_add_PKCS_collision_with_existing_alias)
2744 {
2745     auto manager = CKM::Manager::create();
2746     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
2747     std::istreambuf_iterator<char> begin(is), end;
2748     std::vector<char> buff(begin, end);
2749
2750     CKM::RawBuffer buffer(buff.size());
2751     memcpy(buffer.data(), buff.data(), buff.size());
2752
2753     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2754     RUNNER_ASSERT_MSG(
2755         NULL != pkcs.get(),
2756         "Error in PKCS12::create()");
2757
2758     // save private key
2759     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2760         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2761         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2762         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2763         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2764         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2765         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2766         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2767         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2768         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2769         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2770         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2771         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2772         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2773         "-----END RSA PRIVATE KEY-----\n";
2774
2775     std::string message = "message test";
2776
2777     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2778     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2779         "Key is empty. Failed to import private key.");
2780
2781     int temp;
2782     RUNNER_ASSERT_MSG(
2783         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_collision, keyPrv, CKM::Policy())),
2784         "Error=" << CKM::ErrorToString(temp));
2785
2786     RUNNER_ASSERT_MSG(
2787         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->savePKCS12(alias_PKCS_collision, pkcs, CKM::Policy(), CKM::Policy())),
2788         "Error=" << CKM::ErrorToString(temp));
2789 }
2790
2791 RUNNER_TEST(T1805_add_bundle_with_chain_certificates)
2792 {
2793     auto manager = CKM::Manager::create();
2794     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
2795     std::istreambuf_iterator<char> begin(is), end;
2796     std::vector<char> buff(begin, end);
2797
2798     CKM::RawBuffer buffer(buff.size());
2799     memcpy(buffer.data(), buff.data(), buff.size());
2800
2801     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2802     RUNNER_ASSERT_MSG(
2803         NULL != pkcs.get(),
2804         "Error in PKCS12::create()");
2805
2806     auto cert = pkcs->getCertificate();
2807     RUNNER_ASSERT_MSG(
2808         NULL != cert.get(),
2809         "Error in PKCS12::getCertificate()");
2810
2811     auto key = pkcs->getKey();
2812     RUNNER_ASSERT_MSG(
2813         NULL != key.get(),
2814         "Error in PKCS12::getKey()");
2815
2816     auto caVector = pkcs->getCaCertificateShPtrVector();
2817     RUNNER_ASSERT_MSG(
2818         2 == caVector.size(),
2819         "Wrong size of vector");
2820
2821     // save to the CKM
2822     int tmp;
2823     CKM::Policy exportable;
2824     CKM::Policy notExportable(CKM::Password(), false);
2825
2826     RUNNER_ASSERT_MSG(
2827         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2828         "Error=" << CKM::ErrorToString(tmp));
2829     RUNNER_ASSERT_MSG(
2830         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2831         "Error=" << CKM::ErrorToString(tmp));
2832     RUNNER_ASSERT_MSG(
2833         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2834         "Error=" << CKM::ErrorToString(tmp));
2835     RUNNER_ASSERT_MSG(
2836         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2837         "Error=" << CKM::ErrorToString(tmp));
2838
2839     // try to lookup key
2840     CKM::KeyShPtr key_lookup;
2841     RUNNER_ASSERT_MSG(
2842         CKM_API_SUCCESS == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2843         "Error=" << CKM::ErrorToString(tmp));
2844     RUNNER_ASSERT_MSG(
2845         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2846         "Error=" << CKM::ErrorToString(tmp));
2847
2848     // try to lookup certificate
2849     CKM::CertificateShPtr cert_lookup;
2850     RUNNER_ASSERT_MSG(
2851         CKM_API_SUCCESS == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2852         "Error=" << CKM::ErrorToString(tmp));
2853     RUNNER_ASSERT_MSG(
2854         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2855         "Error=" << CKM::ErrorToString(tmp));
2856 }
2857
2858 RUNNER_TEST(T1806_get_PKCS)
2859 {
2860     int temp;
2861     auto manager = CKM::Manager::create();
2862
2863     CKM::PKCS12ShPtr pkcs;
2864
2865     // fail - no entry
2866     RUNNER_ASSERT_MSG(
2867         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getPKCS12("i-do-not-exist", pkcs)),
2868         "Error=" << CKM::ErrorToString(temp));
2869
2870     // fail - not exportable
2871     RUNNER_ASSERT_MSG(
2872         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getPKCS12(alias_PKCS_not_exportable, pkcs)),
2873         "Error=" << CKM::ErrorToString(temp));
2874
2875     // success - exportable
2876     RUNNER_ASSERT_MSG(
2877         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias_PKCS_exportable, pkcs)),
2878         "Error=" << CKM::ErrorToString(temp));
2879
2880     auto cert = pkcs->getCertificate();
2881     RUNNER_ASSERT_MSG(
2882         NULL != cert.get(),
2883         "Error in PKCS12::getCertificate()");
2884
2885     auto key = pkcs->getKey();
2886     RUNNER_ASSERT_MSG(
2887         NULL != key.get(),
2888         "Error in PKCS12::getKey()");
2889
2890     auto caVector = pkcs->getCaCertificateShPtrVector();
2891     RUNNER_ASSERT_MSG(
2892         2 == caVector.size(),
2893         "Wrong size of vector");
2894 }
2895
2896 RUNNER_TEST(T1807_create_and_verify_signature)
2897 {
2898     int temp;
2899     auto manager = CKM::Manager::create();
2900
2901     std::string message = "message test";
2902
2903     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2904     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2905     CKM::RawBuffer signature;
2906
2907     RUNNER_ASSERT_MSG(
2908         CKM_API_SUCCESS == (temp = manager->createSignature(
2909                                         alias_PKCS_exportable,
2910                                         CKM::Password(),
2911                                         CKM::RawBuffer(message.begin(), message.end()),
2912                                         hash,
2913                                         padd,
2914                                         signature)),
2915         "Error=" << CKM::ErrorToString(temp));
2916
2917     RUNNER_ASSERT_MSG(
2918         CKM_API_SUCCESS == (temp = manager->verifySignature(
2919                                         alias_PKCS_exportable,
2920                                         CKM::Password(),
2921                                         CKM::RawBuffer(message.begin(), message.end()),
2922                                         signature,
2923                                         hash,
2924                                         padd)),
2925         "Error=" << CKM::ErrorToString(temp));
2926 }
2927
2928 RUNNER_TEST(T1808_create_signature_on_raw_key_and_verify_on_PKCS)
2929 {
2930     int temp;
2931     auto manager = CKM::Manager::create();
2932
2933     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2934         "MIICXQIBAAKBgQD1W9neUbXL1rnq9SvyzprjhWBKXyYKQirG3V2zyUnUaE24Sq2I\n"
2935         "v7ISrwMN/G6WcjrGmeZDEWwrL4zXh002N8BD1waJPRonxwtVkhFy3emGatSmx7eI\n"
2936         "ely5H+PBNImRvBh2u4GWga6OEXcUNdfaBUcxn+P6548/zpDhyNLzQKk5FwIDAQAB\n"
2937         "AoGAR+4WkBuqTUj1FlGsAbHaLKt0UDlWwJknS0eoacWwFEpDxqx19WolfV67aYVA\n"
2938         "snBolMKXg7/+0yZMhv8Ofr+XaHkPQplVVn9BwT0rmtEovJXwx+poRP9Bm3emglj/\n"
2939         "iYd8EkaXDlIXCtewtQW9JEIctWppntHj3TvA/h7FCXPN6SkCQQD/N7sn5S1gBkVh\n"
2940         "dyXQKoyKsZDb7hMIS1q6cKwYCMf2UrsD1/lnr7xXkvORdL213MfueO8g0WkuKfRY\n"
2941         "bDD6WGX1AkEA9hxiOlsgvermqLJkOlJffbSaM8n/6wtnM0HV+Vd9NfSBOmxFDXPO\n"
2942         "vrvdgiDPENhbqTJSQVDsfzHilTpK7lEvWwJBAJLxHoOg0tg3pBiyxgWtic+M3q+R\n"
2943         "ykl7QViY6KzJ2X98MIrM/Z7yMollZXE4+sVLwZ0O6fdGOr3GkBWc7TImVUUCQQC7\n"
2944         "pf6bQfof9Ce0fnf/I+ldHkPost7nJsWkBlGQkM2OQwP5OK4ZyK/dK76DxmI7FMwm\n"
2945         "oJCo7nuzq6R4ZX7WYJ47AkBavxBDo/e9/0Vk5yrloGKW3f8RQXBJLcCkVUGyyJ3D\n"
2946         "3gu/nafW4hzjSJniTjC1fOj0eb0OSg1JAvqHTYAnUsI7\n"
2947         "-----END RSA PRIVATE KEY-----";
2948     std::string message = "message test";
2949
2950     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2951     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2952         "Key is empty. Failed to import private key.");
2953
2954     RUNNER_ASSERT_MSG(
2955         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_copy, keyPrv, CKM::Policy())),
2956         "Error=" << CKM::ErrorToString(temp));
2957
2958     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2959     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2960     CKM::RawBuffer signature;
2961
2962     RUNNER_ASSERT_MSG(
2963         CKM_API_SUCCESS == (temp = manager->createSignature(
2964                                         alias_PKCS_priv_key_copy,
2965                                         CKM::Password(),
2966                                         CKM::RawBuffer(message.begin(), message.end()),
2967                                         hash,
2968                                         padd,
2969                                         signature)),
2970         "Error=" << CKM::ErrorToString(temp));
2971
2972     RUNNER_ASSERT_MSG(
2973         CKM_API_SUCCESS == (temp = manager->verifySignature(
2974                                         alias_PKCS_exportable,
2975                                         CKM::Password(),
2976                                         CKM::RawBuffer(message.begin(), message.end()),
2977                                         signature,
2978                                         hash,
2979                                         padd)),
2980         "Error=" << CKM::ErrorToString(temp));
2981 }
2982
2983 RUNNER_TEST(T1809_create_signature_on_wrong_key_and_verify_on_PKCS)
2984 {
2985     int temp;
2986     auto manager = CKM::Manager::create();
2987
2988     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2989         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2990         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2991         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2992         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2993         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2994         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2995         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2996         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2997         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2998         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2999         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
3000         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
3001         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
3002         "-----END RSA PRIVATE KEY-----\n";
3003
3004     std::string message = "message test";
3005
3006     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
3007     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
3008         "Key is empty. Failed to import private key.");
3009
3010     RUNNER_ASSERT_MSG(
3011         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_wrong, keyPrv, CKM::Policy())),
3012         "Error=" << CKM::ErrorToString(temp));
3013
3014     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
3015     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
3016     CKM::RawBuffer signature;
3017
3018     RUNNER_ASSERT_MSG(
3019         CKM_API_SUCCESS == (temp = manager->createSignature(
3020                                         alias_PKCS_priv_key_wrong,
3021                                         CKM::Password(),
3022                                         CKM::RawBuffer(message.begin(), message.end()),
3023                                         hash,
3024                                         padd,
3025                                         signature)),
3026         "Error=" << CKM::ErrorToString(temp));
3027
3028     RUNNER_ASSERT_MSG(
3029         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
3030                                         alias_PKCS_exportable,
3031                                         CKM::Password(),
3032                                         CKM::RawBuffer(message.begin(), message.end()),
3033                                         signature,
3034                                         hash,
3035                                         padd)),
3036         "Error=" << CKM::ErrorToString(temp));
3037 }
3038
3039 RUNNER_TEST(T1810_verify_get_certificate_chain)
3040 {
3041     // this certificate has been signed using PKCS chain
3042     std::string im = "-----BEGIN CERTIFICATE-----\n"
3043         "MIIBrTCCARYCAQEwDQYJKoZIhvcNAQELBQAwHDEaMBgGA1UEAwwRc2VydmVyQHRl\n"
3044         "c3RtZS5jb20wHhcNMTQxMjAyMTMxNTQzWhcNMTUxMjAyMTMxNTQzWjAiMSAwHgYD\n"
3045         "VQQDDBdlbmQtb24tY2hhaW5AdGVzdG1lLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOB\n"
3046         "jQAwgYkCgYEAsJS/jky4Cnxnlj6m2Eam3E3ARfR1PTaQV3Om09z3Ax15ca3kfHSb\n"
3047         "n6UlDk9vjP3iE7Nbju5Nzw9Tu/Pe32g/54quUBgbTFWbztR/Q9Dxbt3evWZ98ADS\n"
3048         "qAtH9OU23xS/5jGpmJSP0l22JItx8E8nEbEPj7GTWfVuYb3HXMHqzY8CAwEAATAN\n"
3049         "BgkqhkiG9w0BAQsFAAOBgQCPJqjMH24kAngd0EunIPsVNSpWJMlMocFM5xHJsvgi\n"
3050         "5DZ7swo0O/Jfqvo/vKDVqR/wiPeAxrwirECGC1O2hC7HcOt7kW4taHSVGGd4dHMn\n"
3051         "oK70cUKQeVy3cYY6QUaonjuNVvYQHE3OSLDe56n6c7Mnek28qNtezeSWLUy8L8fA\n"
3052         "Qw==\n"
3053         "-----END CERTIFICATE-----\n";
3054
3055     auto cert = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
3056     CKM::CertificateShPtrVector certChain;
3057     CKM::AliasVector aliasVector;
3058
3059     int tmp;
3060     auto manager = CKM::Manager::create();
3061
3062     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
3063
3064     tmp = manager->getCertificateChain(cert,
3065                                        EMPTY_ALIAS_VECTOR,
3066                                        EMPTY_ALIAS_VECTOR,
3067                                        true,
3068                                        certChain);
3069     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
3070                          "Error=" << CKM::ErrorToString(tmp));
3071
3072     RUNNER_ASSERT_MSG(
3073         0 == certChain.size(),
3074         "Wrong size of certificate chain.");
3075
3076     aliasVector.push_back(alias_PKCS_exportable);
3077
3078     tmp = manager->getCertificateChain(cert, EMPTY_ALIAS_VECTOR, aliasVector, false, certChain);
3079     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKM::ErrorToString(tmp));
3080
3081     // 1(cert) + 1(pkcs12 cert) + 2(pkcs12 chain cert) = 4
3082     RUNNER_ASSERT_MSG(
3083         4 == certChain.size(),
3084         "Wrong size of certificate chain: " << certChain.size());
3085 }
3086
3087 RUNNER_TEST(T1811_remove_bundle_with_chain_certificates)
3088 {
3089     auto manager = CKM::Manager::create();
3090     int tmp;
3091
3092
3093     // remove the whole PKCS12 bundles
3094     RUNNER_ASSERT_MSG(
3095         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_exportable)),
3096         "Error=" << CKM::ErrorToString(tmp));
3097     RUNNER_ASSERT_MSG(
3098         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_not_exportable)),
3099         "Error=" << CKM::ErrorToString(tmp));
3100
3101     // expect lookup fails due to unknown alias
3102     // try to lookup key
3103     CKM::KeyShPtr key_lookup;
3104     RUNNER_ASSERT_MSG(
3105         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
3106         "Error=" << CKM::ErrorToString(tmp));
3107     RUNNER_ASSERT_MSG(
3108         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
3109         "Error=" << CKM::ErrorToString(tmp));
3110
3111     // try to lookup certificate
3112     CKM::CertificateShPtr cert_lookup;
3113     RUNNER_ASSERT_MSG(
3114         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
3115         "Error=" << CKM::ErrorToString(tmp));
3116     RUNNER_ASSERT_MSG(
3117         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
3118         "Error=" << CKM::ErrorToString(tmp));
3119 }
3120
3121 RUNNER_TEST(T1812_get_pkcs12_password_tests)
3122 {
3123     CKM::Alias alias = "t1812alias1";
3124
3125     auto manager = CKM::Manager::create();
3126     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
3127     std::istreambuf_iterator<char> begin(is), end;
3128     std::vector<char> buff(begin, end);
3129
3130     CKM::PKCS12ShPtr pkcs12;
3131     CKM::Password pass1 = "easypass1";
3132     CKM::Password pass2 = "easypass2";
3133
3134     CKM::RawBuffer buffer(buff.size());
3135     memcpy(buffer.data(), buff.data(), buff.size());
3136
3137     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
3138     RUNNER_ASSERT_MSG(
3139         NULL != pkcs.get(),
3140         "Error in PKCS12::create()");
3141
3142     int temp;
3143     RUNNER_ASSERT_MSG(
3144         CKM_API_SUCCESS == (temp = manager->savePKCS12(alias, pkcs, CKM::Policy(pass1), CKM::Policy(pass2))),
3145         "Error=" << CKM::ErrorToString(temp));
3146
3147     RUNNER_ASSERT_MSG(
3148         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pkcs)),
3149         "Error=" << CKM::ErrorToString(temp));
3150
3151     RUNNER_ASSERT_MSG(
3152         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), CKM::Password(), pkcs)),
3153         "Error=" << CKM::ErrorToString(temp));
3154
3155     RUNNER_ASSERT_MSG(
3156         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pass1, CKM::Password(), pkcs)),
3157         "Error=" << CKM::ErrorToString(temp));
3158
3159     RUNNER_ASSERT_MSG(
3160         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), pass2, pkcs)),
3161         "Error=" << CKM::ErrorToString(temp));
3162
3163     RUNNER_ASSERT_MSG(
3164         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias, pass1, pass2, pkcs)),
3165         "Error=" << CKM::ErrorToString(temp));
3166
3167     CKM::CertificateShPtr cert;
3168     RUNNER_ASSERT_MSG(
3169         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, pass2, cert)),
3170         "Error=" << CKM::ErrorToString(temp));
3171
3172     CKM::CertificateShPtrVector certChain;
3173     CKM::AliasVector certVect;
3174     certVect.push_back(alias);
3175
3176     RUNNER_ASSERT_MSG(
3177         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getCertificateChain(cert, certVect, certVect, true, certChain)),
3178         "Error=" << CKM::ErrorToString(temp));
3179 }
3180
3181 RUNNER_TEST(T1813_deinit)
3182 {
3183     int temp;
3184     auto control = CKM::Control::create();
3185
3186     RUNNER_ASSERT_MSG(
3187         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
3188         "Error=" << CKM::ErrorToString(temp));
3189 }
3190
3191 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
3192
3193 RUNNER_TEST(T1901_init_unlock_key)
3194 {
3195     int tmp;
3196     auto control = CKM::Control::create();
3197     RUNNER_ASSERT_MSG(
3198         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
3199         "Error=" << CKM::ErrorToString(tmp));
3200     RUNNER_ASSERT_MSG(
3201         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
3202         "Error=" << CKM::ErrorToString(tmp));
3203     RUNNER_ASSERT_MSG(
3204         CKM_API_SUCCESS == (tmp = control->unlockUserKey(0, "t190-special-password")),
3205         "Error=" << CKM::ErrorToString(tmp));
3206 }
3207
3208 RUNNER_TEST(T1902_get_data)
3209 {
3210     auto manager = CKM::Manager::create();
3211     CKM::KeyShPtr ptr;
3212
3213     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
3214
3215     RUNNER_ASSERT_MSG(
3216         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
3217         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
3218 }
3219
3220 RUNNER_TEST(T1903_lock_database)
3221 {
3222     int tmp;
3223     auto control = CKM::Control::create();
3224     RUNNER_ASSERT_MSG(
3225         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
3226         "Error=" << CKM::ErrorToString(tmp));
3227 }
3228
3229 RUNNER_TEST(T1904_get_data_from_locked_database)
3230 {
3231     auto manager = CKM::Manager::create();
3232     CKM::KeyShPtr ptr;
3233
3234     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
3235
3236     RUNNER_ASSERT_MSG(
3237         CKM_API_ERROR_DB_LOCKED == status1,
3238         "Could not get key from locked database. Error=" << CKM::ErrorToString(status1));
3239 }
3240
3241 RUNNER_TEST(T1905_deinit)
3242 {
3243     int tmp;
3244     auto control = CKM::Control::create();
3245     RUNNER_ASSERT_MSG(
3246         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
3247         "Error=" << CKM::ErrorToString(tmp));
3248 }
3249
3250 int main(int argc, char *argv[])
3251 {
3252     DPL::Log::LogSystemSingleton::Instance().SetTag("CKM_TESTS");
3253     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
3254 }