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