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_BT(
 106         CKM_API_SUCCESS == (temp = control->removeUserData(14)),
 107         "Error=" << CKM::ErrorToString(temp));
 108
 109     RUNNER_ASSERT_MSG_BT(
 110         CKM_API_SUCCESS == (temp = control->resetUserPassword(14, "simple-password")),
 111         "Error=" << CKM::ErrorToString(temp));
 112
 113     RUNNER_ASSERT_MSG_BT(
 114         CKM_API_SUCCESS == (temp = control->resetUserPassword(14, "something")),
 115         "Error=" << CKM::ErrorToString(temp));
 116
 117     RUNNER_ASSERT_MSG_BT(
 118         CKM_API_SUCCESS == (temp = control->unlockUserKey(14, "test-pass")),
 119         "Error=" << CKM::ErrorToString(temp));
 120
 121     RUNNER_ASSERT_MSG_BT(
 122         CKM_API_SUCCESS == (temp = control->lockUserKey(14)),
 123         "Error=" << CKM::ErrorToString(temp));
 124
 125     RUNNER_ASSERT_MSG_BT(
 126         CKM_API_ERROR_BAD_REQUEST == (temp = control->resetUserPassword(14, "something")),
 127         "Error=" << CKM::ErrorToString(temp));
 128
 129     RUNNER_ASSERT_MSG_BT(
 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_BT(
 157         CKM_API_SUCCESS == (temp = control->unlockUserKey(20, "test-pass")),
 158         "Error=" << CKM::ErrorToString(temp));
 159     RUNNER_ASSERT_MSG_BT(
 160         CKM_API_SUCCESS == (temp = control->changeUserPassword(20, "test-pass", "new-pass")),
 161         "Error=" << CKM::ErrorToString(temp));
 162     RUNNER_ASSERT_MSG_BT(
 163         CKM_API_SUCCESS == (temp = control->lockUserKey(20)),
 164         "Error=" << CKM::ErrorToString(temp));
 165     RUNNER_ASSERT_MSG_BT(
 166         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = control->unlockUserKey(20, "incorrect-password")),
 167         "Error=" << CKM::ErrorToString(temp));
 168     RUNNER_ASSERT_MSG_BT(
 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_BT(
 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_BT(
 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_BT(
 654         CKM_API_SUCCESS == (temp = manager->getData("data4", CKM::Password("CorrectPassword"), buffer)),
 655         "Error=" << CKM::ErrorToString(temp));
 656     RUNNER_ASSERT_MSG_BT(
 657         buffer == buffer1,
 658         "Data corrupted");
 659
 660     RUNNER_ASSERT_MSG_BT(
 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_BT(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_BT(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_BT(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_BT(CKM_API_SUCCESS == tmp, "Error=" << CKM::ErrorToString(tmp));
1526
1527     RUNNER_ASSERT_MSG_BT(
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_BT(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_BT(CKM_API_SUCCESS == tmp, "Error=" << CKM::ErrorToString(tmp));
1628
1629     RUNNER_ASSERT_MSG_BT(
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(T14180_init)
2300 {
2301     int temp;
2302     auto control = CKM::Control::create();
2303     RUNNER_ASSERT_MSG(
2304         CKM_API_SUCCESS == (temp = control->unlockUserKey(0, "test-pass")),
2305         "Error=" << CKM::ErrorToString(temp));
2306
2307     auto manager = CKM::Manager::create();
2308
2309     // Prepare RSA Key Pair
2310     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2311       "Proc-Type: 4,ENCRYPTED\n"
2312       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
2313       "\n"
2314       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
2315       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
2316       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
2317       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
2318       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
2319       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
2320       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
2321       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
2322       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
2323       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
2324       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
2325       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
2326       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
2327       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
2328       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
2329       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
2330       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
2331       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
2332       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
2333       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
2334       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
2335       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
2336       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
2337       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
2338       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
2339       "-----END RSA PRIVATE KEY-----\n";
2340
2341     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
2342       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2343       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2344       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2345       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2346       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2347       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2348       "zQIDAQAB\n"
2349       "-----END PUBLIC KEY-----\n";
2350
2351     CKM::Alias aliasPub = "pub_nohash1";
2352     CKM::Alias aliasPrv = "prv_nohash1";
2353     CKM::Password password = "1234";
2354
2355     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
2356     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
2357
2358     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
2359         "Key is empty. Failed to import public key.");
2360     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2361         "Key is empty. Failed to import private key.");
2362
2363     RUNNER_ASSERT_MSG(
2364         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
2365         "Error=" << CKM::ErrorToString(temp));
2366     RUNNER_ASSERT_MSG(
2367         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
2368         "Error=" << CKM::ErrorToString(temp));
2369
2370     // Prepare ECDSA Key Pair
2371     std::string ecprv = "-----BEGIN EC PRIVATE KEY-----\n"
2372         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
2373         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
2374         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2375         "-----END EC PRIVATE KEY-----\n";
2376
2377     std::string ecpub = "-----BEGIN PUBLIC KEY-----\n"
2378         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
2379         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2380         "-----END PUBLIC KEY-----\n";
2381
2382     CKM::Alias aliasEcPub = "ecpub_nohash1";
2383     CKM::Alias aliasEcPrv = "ecprv_nohash1";
2384
2385     auto ecKeyPub = CKM::Key::create(CKM::RawBuffer(ecpub.begin(), ecpub.end()));
2386     auto ecKeyPrv = CKM::Key::create(CKM::RawBuffer(ecprv.begin(), ecprv.end()));
2387
2388     RUNNER_ASSERT_MSG(NULL != ecKeyPub.get(),
2389         "Key is empty. Failed to import public key.");
2390     RUNNER_ASSERT_MSG(NULL != ecKeyPrv.get(),
2391         "Key is empty. Failed to import private key.");
2392
2393     RUNNER_ASSERT_MSG(
2394         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPub, ecKeyPub, CKM::Policy())),
2395         "Error=" << CKM::ErrorToString(temp));
2396     RUNNER_ASSERT_MSG(
2397         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPrv, ecKeyPrv, CKM::Policy())),
2398         "Error=" << CKM::ErrorToString(temp));
2399 }
2400
2401
2402 RUNNER_TEST(T14181_rsa_create_signatue_nohash)
2403 {
2404     int temp;
2405     auto manager = CKM::Manager::create();
2406     std::string message = "message asdfaslkdfjlksadjf test";
2407
2408     CKM::Alias aliasPub = "pub_nohash1";
2409     CKM::Alias aliasPrv = "prv_nohash1";
2410
2411     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2412     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2413     CKM::RawBuffer signature;
2414
2415     RUNNER_ASSERT_MSG(
2416         CKM_API_SUCCESS == (temp = manager->createSignature(
2417                                         aliasPrv,
2418                                         CKM::Password(),
2419                                         CKM::RawBuffer(message.begin(), message.end()),
2420                                         hash,
2421                                         padd,
2422                                         signature)),
2423         "Error=" << CKM::ErrorToString(temp));
2424
2425     RUNNER_ASSERT_MSG(
2426         CKM_API_SUCCESS == (temp = manager->verifySignature(
2427                                         aliasPub,
2428                                         CKM::Password(),
2429                                         CKM::RawBuffer(message.begin(), message.end()),
2430                                         signature,
2431                                         hash,
2432                                         padd)),
2433         "Error=" << CKM::ErrorToString(temp));
2434
2435     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2436     memcpy((void*)signature.data(), "BROKEN", 6);
2437
2438     RUNNER_ASSERT_MSG(
2439         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2440                                         aliasPub,
2441                                         CKM::Password(),
2442                                         CKM::RawBuffer(message.begin(), message.end()),
2443                                         signature,
2444                                         hash,
2445                                         padd)),
2446         "Error=" << CKM::ErrorToString(temp));
2447 }
2448
2449 RUNNER_TEST(T14182_rsa_create_signatue_nohash_nopad)
2450 {
2451     int temp;
2452     auto manager = CKM::Manager::create();
2453     std::string message = "message asdfaslkdfjlksadjf test";
2454
2455     CKM::Alias aliasPub = "pub_nohash1";
2456     CKM::Alias aliasPrv = "prv_nohash1";
2457
2458     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2459     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2460     CKM::RawBuffer signature;
2461
2462     RUNNER_ASSERT_MSG(
2463         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2464                                         aliasPrv,
2465                                         CKM::Password(),
2466                                         CKM::RawBuffer(message.begin(), message.end()),
2467                                         hash,
2468                                         padd,
2469                                         signature)),
2470         "Error=" << CKM::ErrorToString(temp));
2471 }
2472
2473 RUNNER_TEST(T14183_rsa_create_signatue_nohash_bigmsg)
2474 {
2475     int temp;
2476     auto manager = CKM::Manager::create();
2477     std::string message = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2478                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2479                           "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
2498     CKM::Alias aliasPub = "pub_nohash1";
2499     CKM::Alias aliasPrv = "prv_nohash1";
2500
2501     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2502     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2503     CKM::RawBuffer signature;
2504
2505     RUNNER_ASSERT_MSG(
2506         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2507                                         aliasPrv,
2508                                         CKM::Password(),
2509                                         CKM::RawBuffer(message.begin(), message.end()),
2510                                         hash,
2511                                         padd,
2512                                         signature)),
2513         "Error=" << CKM::ErrorToString(temp));
2514 }
2515
2516
2517 RUNNER_TEST(T14184_ec_create_signatue_nohash)
2518 {
2519     int temp;
2520     auto manager = CKM::Manager::create();
2521
2522     std::string message = "message test";
2523
2524     CKM::Alias aliasPub = "ecpub_nohash1";
2525     CKM::Alias aliasPrv = "ecprv_nohash1";
2526     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2527     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2528     CKM::RawBuffer signature;
2529
2530     RUNNER_ASSERT_MSG(
2531         CKM_API_SUCCESS == (temp = manager->createSignature(
2532                                         aliasPrv,
2533                                         CKM::Password(),
2534                                         CKM::RawBuffer(message.begin(), message.end()),
2535                                         hash,
2536                                         padd,
2537                                         signature)),
2538         "Error=" << CKM::ErrorToString(temp));
2539
2540     RUNNER_ASSERT_MSG(
2541         CKM_API_SUCCESS == (temp = manager->verifySignature(
2542                                         aliasPub,
2543                                         CKM::Password(),
2544                                         CKM::RawBuffer(message.begin(), message.end()),
2545                                         signature,
2546                                         hash,
2547                                         padd)),
2548         "Error=" << CKM::ErrorToString(temp));
2549
2550     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2551
2552     memcpy((void*)signature.data(), "BROKEN", 6);
2553
2554     RUNNER_ASSERT_MSG(
2555         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2556                                         aliasPub,
2557                                         CKM::Password(),
2558                                         CKM::RawBuffer(message.begin(), message.end()),
2559                                         signature,
2560                                         hash,
2561                                         padd)),
2562         "Error=" << CKM::ErrorToString(temp));
2563 }
2564
2565 RUNNER_TEST(T14185_ec_create_signatue_nohash_bigmsg)
2566 {
2567     int temp;
2568     auto manager = CKM::Manager::create();
2569
2570     int msgSize = 1024*1024;
2571     char big_msg[msgSize];
2572     for(int i =0; i<msgSize-1; i++) {
2573         big_msg[i] = 'a';
2574     }
2575     big_msg[msgSize-1]=0x00;
2576     std::string message(big_msg);
2577
2578     CKM::Alias aliasPub = "ecpub_nohash1";
2579     CKM::Alias aliasPrv = "ecprv_nohash1";
2580     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2581     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2582     CKM::RawBuffer signature;
2583
2584     RUNNER_ASSERT_MSG(
2585             CKM_API_SUCCESS == (temp = manager->createSignature(
2586                                         aliasPrv,
2587                                         CKM::Password(),
2588                                         CKM::RawBuffer(message.begin(), message.end()),
2589                                         hash,
2590                                         padd,
2591                                         signature)),
2592         "Error=" << CKM::ErrorToString(temp));
2593 }
2594
2595
2596 RUNNER_TEST(T14189_deinit)
2597 {
2598     int temp;
2599     auto control = CKM::Control::create();
2600
2601     RUNNER_ASSERT_MSG(
2602         CKM_API_SUCCESS == (temp = control->lockUserKey(0)),
2603         "Error=" << CKM::ErrorToString(temp));
2604     RUNNER_ASSERT_MSG(
2605         CKM_API_SUCCESS == (temp = control->removeUserData(0)),
2606         "Error=" << CKM::ErrorToString(temp));
2607 }
2608
2609
2610 RUNNER_TEST_GROUP_INIT(T151_CKM_STORAGE_PERNAMENT_TESTS);
2611
2612 RUNNER_CHILD_TEST(T1510_init_unlock_key)
2613 {
2614     int tmp;
2615     AccessProvider ap("my-label");
2616     ap.allowAPI("key-manager::api-control", "rw");
2617     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2618
2619     auto control = CKM::Control::create();
2620     RUNNER_ASSERT_MSG(
2621         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST, "strong-password")),
2622         "Error=" << CKM::ErrorToString(tmp));
2623 }
2624
2625 RUNNER_CHILD_TEST(T1511_insert_data)
2626 {
2627     AccessProvider ap("my-label");
2628     ap.allowAPI("key-manager::api-storage", "rw");
2629     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2630
2631     std::string ee = "-----BEGIN CERTIFICATE-----\n"
2632       "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2633       "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2634       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2635       "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2636       "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2637       "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2638       "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2639       "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2640       "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2641       "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2642       "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2643       "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2644       "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2645       "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2646       "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2647       "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2648       "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2649       "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2650       "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2651       "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2652       "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2653       "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2654       "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2655       "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2656       "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2657       "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2658       "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2659       "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2660       "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2661       "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2662       "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2663       "oFXtrg0=\n"
2664       "-----END CERTIFICATE-----\n";
2665
2666     std::string im =
2667       "-----BEGIN CERTIFICATE-----\n"
2668       "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
2669       "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2670       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
2671       "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
2672       "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
2673       "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
2674       "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
2675       "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
2676       "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
2677       "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
2678       "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
2679       "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
2680       "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
2681       "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
2682       "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
2683       "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
2684       "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
2685       "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
2686       "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
2687       "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
2688       "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
2689       "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
2690       "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
2691       "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
2692       "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
2693       "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
2694       "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
2695       "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
2696       "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
2697       "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
2698       "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
2699       "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
2700       "-----END CERTIFICATE-----\n";
2701
2702     auto manager = CKM::Manager::create();
2703     auto certee = CKM::Certificate::create(CKM::RawBuffer(ee.begin(), ee.end()), CKM::DataFormat::FORM_PEM);
2704     auto certim = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
2705
2706     int status1 = manager->saveCertificate(CKM::Alias("CertEE"), certee, CKM::Policy());
2707     int status2 = manager->saveCertificate(CKM::Alias("CertIM"), certim, CKM::Policy());
2708
2709     RUNNER_ASSERT_MSG(
2710         CKM_API_ERROR_DB_ALIAS_EXISTS == status1,
2711         "Certificate should be in database already. Error=" << CKM::ErrorToString(status1));
2712
2713     RUNNER_ASSERT_MSG(
2714         CKM_API_ERROR_DB_ALIAS_EXISTS == status2,
2715         "Certificate should be in database already. Error=" << CKM::ErrorToString(status2));
2716 }
2717
2718 RUNNER_CHILD_TEST(T1519_deinit)
2719 {
2720     int tmp;
2721     AccessProvider ap("my-label");
2722     ap.allowAPI("key-manager::api-control", "rw");
2723     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2724
2725     auto control = CKM::Control::create();
2726     RUNNER_ASSERT_MSG(
2727         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST)),
2728         "Error=" << CKM::ErrorToString(tmp));
2729 }
2730
2731
2732 RUNNER_TEST_GROUP_INIT(T161_CKM_LOCKTYPE_TESTS);
2733
2734 RUNNER_CHILD_TEST(T1610_init_lock_key)
2735 {
2736     int tmp;
2737     AccessProvider ap("my-label");
2738     ap.allowAPI("key-manager::api-control", "rw");
2739     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2740
2741     auto control = CKM::Control::create();
2742     RUNNER_ASSERT_MSG(
2743         CKM_API_SUCCESS == (tmp = control->changeUserPassword(USER_APP,"user-pass","")),
2744         "Error=" << CKM::ErrorToString(tmp));
2745     RUNNER_ASSERT_MSG(
2746         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2747         "Error=" << CKM::ErrorToString(tmp));
2748 }
2749
2750 RUNNER_CHILD_TEST(T1611_unlock_default_passwd)
2751 {
2752     AccessProvider ap("my-label");
2753     ap.allowAPI("key-manager::api-storage", "rw");
2754     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2755
2756     int temp;
2757     auto manager = CKM::Manager::create();
2758
2759     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2760         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2761         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2762         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2763         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2764         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2765         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2766         "zQIDAQAB\n"
2767         "-----END PUBLIC KEY-----";
2768
2769     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
2770     auto key = CKM::Key::create(buffer, CKM::Password());
2771     CKM::KeyShPtr key2;
2772     CKM::Alias alias = "mykey_defpasswd";
2773
2774     RUNNER_ASSERT_MSG(
2775         CKM_API_SUCCESS == (temp = manager->saveKey(alias, key, CKM::Policy())),
2776         "Error=" << CKM::ErrorToString(temp));
2777     RUNNER_ASSERT_MSG(
2778         CKM_API_SUCCESS == (temp = manager->getKey(alias, CKM::Password(), key2)),
2779         "Error=" << CKM::ErrorToString(temp));
2780     RUNNER_ASSERT_MSG(
2781         key->getDER() == key2->getDER(),
2782         "Key value has been changed by service");
2783
2784     std::string invalid_address = aliasWithLabel("i-do-not-exist", alias.c_str());
2785     RUNNER_ASSERT_MSG(
2786             CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->removeAlias(invalid_address.c_str())),
2787             "Error=" << CKM::ErrorToString(temp));
2788     RUNNER_ASSERT_MSG(
2789             CKM_API_SUCCESS == (temp = manager->removeAlias(alias)),
2790             "Error=" << CKM::ErrorToString(temp));
2791 }
2792
2793 RUNNER_CHILD_TEST(T1612_init_change_user_password)
2794 {
2795     int tmp;
2796     AccessProvider ap("my-label");
2797     ap.allowAPI("key-manager::api-control", "rw");
2798     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2799
2800     auto control = CKM::Control::create();
2801     RUNNER_ASSERT_MSG(
2802         CKM_API_SUCCESS == (tmp = control->changeUserPassword(USER_APP,"","user-pass")),
2803         "Error=" << CKM::ErrorToString(tmp));
2804     // confirm changed password
2805     RUNNER_ASSERT_MSG(
2806         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_APP,"user-pass")),
2807         CKM::ErrorToString(tmp));
2808     RUNNER_ASSERT_MSG(
2809         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2810         CKM::ErrorToString(tmp));
2811 }
2812
2813 RUNNER_CHILD_TEST(T1613_unlock_default_passwd_negative)
2814 {
2815     AccessProvider ap("my-label");
2816     ap.allowAPI("key-manager::api-storage", "rw");
2817     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2818
2819     int temp;
2820     auto manager = CKM::Manager::create();
2821
2822     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2823         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2824         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2825         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2826         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2827         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2828         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2829         "zQIDAQAB\n"
2830         "-----END PUBLIC KEY-----";
2831
2832     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
2833     auto key = CKM::Key::create(buffer, CKM::Password());
2834     CKM::KeyShPtr key2;
2835     CKM::Alias alias = "mykey_defpasswd";
2836
2837     RUNNER_ASSERT_MSG(
2838         CKM_API_ERROR_DB_LOCKED == (temp = manager->saveKey(alias, key, CKM::Policy())),
2839         "Error=" << CKM::ErrorToString(temp));
2840     RUNNER_ASSERT_MSG(
2841         CKM_API_ERROR_DB_LOCKED == (temp = manager->getKey(alias, CKM::Password(), key2)),
2842         "Error=" << CKM::ErrorToString(temp));
2843     RUNNER_ASSERT_MSG(
2844         CKM_API_ERROR_DB_LOCKED == (temp = manager->removeAlias(alias)),
2845         "Error=" << CKM::ErrorToString(temp));
2846 }
2847
2848 RUNNER_CHILD_TEST(T1619_deinit)
2849 {
2850     AccessProvider ap("my-label");
2851     ap.allowAPI("key-manager::api-control", "rw");
2852     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2853 }
2854
2855 RUNNER_TEST_GROUP_INIT(T170_CKM_STORAGE_PERNAMENT_TESTS);
2856
2857 RUNNER_TEST(T1701_init_unlock_key)
2858 {
2859     int tmp;
2860     auto control = CKM::Control::create();
2861     RUNNER_ASSERT_MSG(
2862         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+1, "t170-special-password")),
2863         "Error=" << CKM::ErrorToString(tmp));
2864 }
2865
2866 RUNNER_CHILD_TEST(T1702_insert_data)
2867 {
2868     int temp;
2869     AccessProvider ap("t170-special-label");
2870     ap.allowAPI("key-manager::api-storage", "rw");
2871     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2872
2873     std::string ee = "-----BEGIN CERTIFICATE-----\n"
2874       "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2875       "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2876       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2877       "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2878       "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2879       "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2880       "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2881       "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2882       "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2883       "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2884       "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2885       "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2886       "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2887       "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2888       "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2889       "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2890       "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2891       "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2892       "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2893       "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2894       "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2895       "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2896       "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2897       "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2898       "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2899       "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2900       "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2901       "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2902       "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2903       "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2904       "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2905       "oFXtrg0=\n"
2906       "-----END CERTIFICATE-----\n";
2907
2908     auto manager = CKM::Manager::create();
2909     auto certee = CKM::Certificate::create(CKM::RawBuffer(ee.begin(), ee.end()), CKM::DataFormat::FORM_PEM);
2910
2911     int status1 = manager->saveCertificate(CKM::Alias("CertEEE"), certee, CKM::Policy());
2912
2913     RUNNER_ASSERT_MSG(
2914         CKM_API_SUCCESS == status1,
2915         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
2916
2917     CKM::AliasVector av;
2918     RUNNER_ASSERT_MSG(
2919         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2920         "Error=" << CKM::ErrorToString(temp));
2921     RUNNER_ASSERT_MSG(
2922         1 == (temp = av.size()),
2923         "Vector size: " << temp << ". Expected: 1");
2924 }
2925
2926 RUNNER_TEST(T1703_removeApplicationData)
2927 {
2928     int tmp;
2929     auto control = CKM::Control::create();
2930     RUNNER_ASSERT_MSG(
2931         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t170-special-label")),
2932         "Error=" << CKM::ErrorToString(tmp));
2933 }
2934
2935 RUNNER_CHILD_TEST(T1704_data_test)
2936 {
2937     int temp;
2938     AccessProvider ap("t170-special-label");
2939     ap.allowAPI("key-manager::api-storage", "rw");
2940     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2941
2942     CKM::AliasVector av;
2943     auto manager = CKM::Manager::create();
2944
2945     RUNNER_ASSERT_MSG(
2946         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2947         "Error=" << CKM::ErrorToString(temp));
2948     RUNNER_ASSERT_MSG(
2949         0 == (temp = av.size()),
2950         "Vector size: " << temp << ". Expected: 0");
2951 }
2952
2953 RUNNER_TEST(T1705_deinit)
2954 {
2955     int tmp;
2956
2957     auto control = CKM::Control::create();
2958     RUNNER_ASSERT_MSG(
2959         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+1)),
2960         "Error=" << CKM::ErrorToString(tmp));
2961     RUNNER_ASSERT_MSG(
2962         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+1)),
2963         "Error=" << CKM::ErrorToString(tmp));
2964 }
2965
2966 RUNNER_TEST(T17101_init)
2967 {
2968     int tmp;
2969
2970     auto control = CKM::Control::create();
2971     RUNNER_ASSERT_MSG(
2972         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
2973         "Error=" << CKM::ErrorToString(tmp));
2974     RUNNER_ASSERT_MSG(
2975         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
2976         "Error=" << CKM::ErrorToString(tmp));
2977     RUNNER_ASSERT_MSG(
2978         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+2, "t1706-special-password")),
2979         "Error=" << CKM::ErrorToString(tmp));
2980
2981     RUNNER_ASSERT_MSG(
2982         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2983         "Error=" << CKM::ErrorToString(tmp));
2984     RUNNER_ASSERT_MSG(
2985         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
2986         "Error=" << CKM::ErrorToString(tmp));
2987     RUNNER_ASSERT_MSG(
2988          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
2989          "Error=" << CKM::ErrorToString(tmp));
2990 }
2991
2992 RUNNER_CHILD_TEST(T17102_prep_data_01)
2993 {
2994     int temp;
2995     AccessProvider ap("t1706-special-label");
2996     ap.allowAPI("key-manager::api-storage", "rw");
2997     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2998
2999     CKM::AliasVector av;
3000     auto manager = CKM::Manager::create();
3001
3002     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
3003
3004     CKM::RawBuffer buffer(data.begin(), data.end());
3005     CKM::Policy exportable(CKM::Password(), true);
3006
3007     RUNNER_ASSERT_MSG(
3008         CKM_API_SUCCESS == (temp = manager->saveData("data1", buffer, exportable)),
3009         "Error=" << CKM::ErrorToString(temp));
3010 }
3011
3012 RUNNER_CHILD_TEST(T17103_prep_data_02)
3013 {
3014     int temp;
3015     AccessProvider ap("t1706-special-label2");
3016     ap.allowAPI("key-manager::api-storage", "rw");
3017     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
3018
3019     CKM::AliasVector av;
3020     auto manager = CKM::Manager::create();
3021
3022     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
3023
3024     CKM::RawBuffer buffer(data.begin(), data.end());
3025     CKM::Policy exportable(CKM::Password(), true);
3026
3027     RUNNER_ASSERT_MSG(
3028         CKM_API_SUCCESS == (temp = manager->saveData("data2", buffer, exportable)),
3029         "Error=" << CKM::ErrorToString(temp));
3030 }
3031
3032 RUNNER_CHILD_TEST(T17104_prep_data_03)
3033 {
3034     int temp;
3035     AccessProvider ap("t1706-special-label");
3036     ap.allowAPI("key-manager::api-storage", "rw");
3037     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
3038
3039     CKM::AliasVector av;
3040     auto manager = CKM::Manager::create();
3041
3042     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
3043
3044     CKM::RawBuffer buffer(data.begin(), data.end());
3045     CKM::Policy exportable(CKM::Password(), true);
3046
3047     RUNNER_ASSERT_MSG(
3048         CKM_API_SUCCESS == (temp = manager->saveData("data3", buffer, exportable)),
3049         "Error=" << CKM::ErrorToString(temp));
3050 }
3051
3052 RUNNER_CHILD_TEST(T17105_prep_data_04)
3053 {
3054     int temp;
3055     AccessProvider ap("t1706-special-label2");
3056     ap.allowAPI("key-manager::api-storage", "rw");
3057     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
3058
3059     CKM::AliasVector av;
3060     auto manager = CKM::Manager::create();
3061
3062     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
3063
3064     CKM::RawBuffer buffer(data.begin(), data.end());
3065     CKM::Policy exportable(CKM::Password(), true);
3066
3067     RUNNER_ASSERT_MSG(
3068         CKM_API_SUCCESS == (temp = manager->saveData("data4", buffer, exportable)),
3069         "Error=" << CKM::ErrorToString(temp));
3070 }
3071
3072 RUNNER_TEST(T17106_remove_application)
3073 {
3074     int tmp;
3075
3076     auto control = CKM::Control::create();
3077     RUNNER_ASSERT_MSG(
3078         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
3079         "Error=" << CKM::ErrorToString(tmp));
3080     RUNNER_ASSERT_MSG(
3081         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t1706-special-label")),
3082         "Error=" << CKM::ErrorToString(tmp));
3083 }
3084
3085 RUNNER_CHILD_TEST(T17107_check_data_01)
3086 {
3087     int temp;
3088     AccessProvider ap("t1706-special-label");
3089     ap.allowAPI("key-manager::api-storage", "rw");
3090     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
3091
3092     CKM::AliasVector av;
3093     auto manager = CKM::Manager::create();
3094
3095     RUNNER_ASSERT_MSG(
3096         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
3097         "Error=" << CKM::ErrorToString(temp));
3098     RUNNER_ASSERT_MSG(
3099         0 == (temp = av.size()),
3100         "Vector size: " << temp << ". Expected: 0");
3101 }
3102
3103 RUNNER_CHILD_TEST(T17108_check_data_02)
3104 {
3105     int temp;
3106     AccessProvider ap("t1706-special-label2");
3107     ap.allowAPI("key-manager::api-storage", "rw");
3108     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
3109
3110     CKM::AliasVector av;
3111     auto manager = CKM::Manager::create();
3112
3113     RUNNER_ASSERT_MSG(
3114         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
3115         "Error=" << CKM::ErrorToString(temp));
3116     RUNNER_ASSERT_MSG(
3117         1 == (temp = av.size()),
3118         "Vector size: " << temp << ". Expected: 1");
3119 }
3120
3121 RUNNER_TEST(T17109_unlock_user2)
3122 {
3123     int tmp;
3124
3125     auto control = CKM::Control::create();
3126     RUNNER_ASSERT_MSG(
3127          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
3128          "Error=" << CKM::ErrorToString(tmp));
3129 }
3130
3131 RUNNER_CHILD_TEST(T17110_check_data_03)
3132 {
3133     int temp;
3134     AccessProvider ap("t1706-special-label");
3135     ap.allowAPI("key-manager::api-storage", "rw");
3136     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
3137
3138     CKM::AliasVector av;
3139     auto manager = CKM::Manager::create();
3140
3141     RUNNER_ASSERT_MSG(
3142         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
3143         "Error=" << CKM::ErrorToString(temp));
3144     RUNNER_ASSERT_MSG(
3145         0 == (temp = av.size()),
3146         "Vector size: " << temp << ". Expected: 0");
3147 }
3148
3149 RUNNER_CHILD_TEST(T17111_check_data_04)
3150 {
3151     int temp;
3152     AccessProvider ap("t1706-special-label2");
3153     ap.allowAPI("key-manager::api-storage", "rw");
3154     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
3155
3156     CKM::AliasVector av;
3157     auto manager = CKM::Manager::create();
3158
3159     RUNNER_ASSERT_MSG(
3160         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
3161         "Error=" << CKM::ErrorToString(temp));
3162     RUNNER_ASSERT_MSG(
3163         1 == (temp = av.size()),
3164         "Vector size: " << temp << ". Expected: 1");
3165 }
3166
3167 RUNNER_TEST(T17112_deinit)
3168 {
3169     int tmp;
3170
3171     auto control = CKM::Control::create();
3172     RUNNER_ASSERT_MSG(
3173         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
3174         "Error=" << CKM::ErrorToString(tmp));
3175     RUNNER_ASSERT_MSG(
3176         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
3177         "Error=" << CKM::ErrorToString(tmp));
3178
3179     RUNNER_ASSERT_MSG(
3180         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
3181         "Error=" << CKM::ErrorToString(tmp));
3182     RUNNER_ASSERT_MSG(
3183         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
3184         "Error=" << CKM::ErrorToString(tmp));
3185 }
3186
3187 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
3188
3189 namespace
3190 {
3191 CKM::Alias alias_PKCS_collision = "test-PKCS-collision";
3192 CKM::Alias alias_PKCS_exportable = "test-PKCS-export";
3193 CKM::Alias alias_PKCS_not_exportable = "test-PKCS-no-export";
3194 CKM::Alias alias_PKCS_priv_key_copy = "test-PKCS-private-key-copy";
3195 CKM::Alias alias_PKCS_priv_key_wrong = "test-PKCS-private-key-wrong";
3196 }
3197
3198 RUNNER_TEST(T1800_init) {
3199     int temp;
3200     auto control = CKM::Control::create();
3201     RUNNER_ASSERT_MSG(
3202         CKM_API_SUCCESS == (temp = control->unlockUserKey(USER_APP, "user-pass")),
3203         "Error=" << CKM::ErrorToString(temp));
3204
3205     auto manager = CKM::Manager::create();
3206     manager->removeAlias(alias_PKCS_collision);
3207     manager->removeAlias(alias_PKCS_exportable);
3208     manager->removeAlias(alias_PKCS_not_exportable);
3209     manager->removeAlias(alias_PKCS_priv_key_copy);
3210     manager->removeAlias(alias_PKCS_priv_key_wrong);
3211 }
3212
3213 RUNNER_TEST(T1801_parse_PKCS12) {
3214     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
3215     std::istreambuf_iterator<char> begin(is), end;
3216     std::vector<char> buff(begin, end);
3217
3218     CKM::RawBuffer buffer(buff.size());
3219     memcpy(buffer.data(), buff.data(), buff.size());
3220
3221     auto pkcs = CKM::PKCS12::create(buffer, "secret");
3222     RUNNER_ASSERT_MSG(
3223         NULL != pkcs.get(),
3224         "Error in PKCS12::create()");
3225
3226     auto cert = pkcs->getCertificate();
3227     RUNNER_ASSERT_MSG(
3228         NULL != cert.get(),
3229         "Error in PKCS12::getCertificate()");
3230
3231     auto key = pkcs->getKey();
3232     RUNNER_ASSERT_MSG(
3233         NULL != key.get(),
3234         "Error in PKCS12::getKey()");
3235
3236     auto caVector = pkcs->getCaCertificateShPtrVector();
3237     RUNNER_ASSERT_MSG(
3238         0 == caVector.size(),
3239         "Wrong size of vector");
3240 }
3241
3242 RUNNER_TEST(T1802_negative_wrong_password) {
3243     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
3244     std::istreambuf_iterator<char> begin(is), end;
3245     std::vector<char> buff(begin, end);
3246
3247     CKM::RawBuffer buffer(buff.size());
3248     memcpy(buffer.data(), buff.data(), buff.size());
3249
3250     auto pkcs = CKM::PKCS12::create(buffer, "error");
3251     RUNNER_ASSERT_MSG(
3252         NULL == pkcs.get(),
3253         "Expected error in PKCS12::create()");
3254 }
3255
3256 RUNNER_TEST(T1803_negative_broken_buffer) {
3257     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
3258     std::istreambuf_iterator<char> begin(is), end;
3259     std::vector<char> buff(begin, end);
3260
3261     CKM::RawBuffer buffer(buff.size());
3262     memcpy(buffer.data(), buff.data(), buff.size());
3263
3264     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
3265     buffer[4]=0;
3266
3267     auto pkcs = CKM::PKCS12::create(buffer, "secret");
3268     RUNNER_ASSERT_MSG(
3269         NULL == pkcs.get(),
3270         "Expected error in PKCS12::create()");
3271 }
3272
3273 RUNNER_TEST(T1804_add_PKCS_collision_with_existing_alias)
3274 {
3275     auto manager = CKM::Manager::create();
3276     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
3277     std::istreambuf_iterator<char> begin(is), end;
3278     std::vector<char> buff(begin, end);
3279
3280     CKM::RawBuffer buffer(buff.size());
3281     memcpy(buffer.data(), buff.data(), buff.size());
3282
3283     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
3284     RUNNER_ASSERT_MSG(
3285         NULL != pkcs.get(),
3286         "Error in PKCS12::create()");
3287
3288     // save private key
3289     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
3290         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
3291         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
3292         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
3293         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
3294         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
3295         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
3296         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
3297         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
3298         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
3299         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
3300         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
3301         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
3302         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
3303         "-----END RSA PRIVATE KEY-----\n";
3304
3305     std::string message = "message test";
3306
3307     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
3308     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
3309         "Key is empty. Failed to import private key.");
3310
3311     int temp;
3312     RUNNER_ASSERT_MSG(
3313         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_collision, keyPrv, CKM::Policy())),
3314         "Error=" << CKM::ErrorToString(temp));
3315
3316     RUNNER_ASSERT_MSG(
3317         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->savePKCS12(alias_PKCS_collision, pkcs, CKM::Policy(), CKM::Policy())),
3318         "Error=" << CKM::ErrorToString(temp));
3319 }
3320
3321 RUNNER_TEST(T1805_add_bundle_with_chain_certificates)
3322 {
3323     auto manager = CKM::Manager::create();
3324     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
3325     std::istreambuf_iterator<char> begin(is), end;
3326     std::vector<char> buff(begin, end);
3327
3328     CKM::RawBuffer buffer(buff.size());
3329     memcpy(buffer.data(), buff.data(), buff.size());
3330
3331     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
3332     RUNNER_ASSERT_MSG(
3333         NULL != pkcs.get(),
3334         "Error in PKCS12::create()");
3335
3336     auto cert = pkcs->getCertificate();
3337     RUNNER_ASSERT_MSG(
3338         NULL != cert.get(),
3339         "Error in PKCS12::getCertificate()");
3340
3341     auto key = pkcs->getKey();
3342     RUNNER_ASSERT_MSG(
3343         NULL != key.get(),
3344         "Error in PKCS12::getKey()");
3345
3346     auto caVector = pkcs->getCaCertificateShPtrVector();
3347     RUNNER_ASSERT_MSG(
3348         2 == caVector.size(),
3349         "Wrong size of vector");
3350
3351     // save to the CKM
3352     int tmp;
3353     CKM::Policy exportable;
3354     CKM::Policy notExportable(CKM::Password(), false);
3355
3356     RUNNER_ASSERT_MSG(
3357         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
3358         "Error=" << CKM::ErrorToString(tmp));
3359     RUNNER_ASSERT_MSG(
3360         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
3361         "Error=" << CKM::ErrorToString(tmp));
3362     RUNNER_ASSERT_MSG(
3363         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
3364         "Error=" << CKM::ErrorToString(tmp));
3365     RUNNER_ASSERT_MSG(
3366         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
3367         "Error=" << CKM::ErrorToString(tmp));
3368
3369     // try to lookup key
3370     CKM::KeyShPtr key_lookup;
3371     RUNNER_ASSERT_MSG(
3372         CKM_API_SUCCESS == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
3373         "Error=" << CKM::ErrorToString(tmp));
3374     RUNNER_ASSERT_MSG(
3375         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
3376         "Error=" << CKM::ErrorToString(tmp));
3377
3378     // try to lookup certificate
3379     CKM::CertificateShPtr cert_lookup;
3380     RUNNER_ASSERT_MSG(
3381         CKM_API_SUCCESS == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
3382         "Error=" << CKM::ErrorToString(tmp));
3383     RUNNER_ASSERT_MSG(
3384         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
3385         "Error=" << CKM::ErrorToString(tmp));
3386 }
3387
3388 RUNNER_TEST(T1806_get_PKCS)
3389 {
3390     int temp;
3391     auto manager = CKM::Manager::create();
3392
3393     CKM::PKCS12ShPtr pkcs;
3394
3395     // fail - no entry
3396     RUNNER_ASSERT_MSG(
3397         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getPKCS12("i-do-not-exist", pkcs)),
3398         "Error=" << CKM::ErrorToString(temp));
3399
3400     // fail - not exportable
3401     RUNNER_ASSERT_MSG(
3402         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getPKCS12(alias_PKCS_not_exportable, pkcs)),
3403         "Error=" << CKM::ErrorToString(temp));
3404
3405     // success - exportable
3406     RUNNER_ASSERT_MSG(
3407         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias_PKCS_exportable, pkcs)),
3408         "Error=" << CKM::ErrorToString(temp));
3409
3410     auto cert = pkcs->getCertificate();
3411     RUNNER_ASSERT_MSG(
3412         NULL != cert.get(),
3413         "Error in PKCS12::getCertificate()");
3414
3415     auto key = pkcs->getKey();
3416     RUNNER_ASSERT_MSG(
3417         NULL != key.get(),
3418         "Error in PKCS12::getKey()");
3419
3420     auto caVector = pkcs->getCaCertificateShPtrVector();
3421     RUNNER_ASSERT_MSG(
3422         2 == caVector.size(),
3423         "Wrong size of vector");
3424 }
3425
3426 RUNNER_TEST(T1807_create_and_verify_signature)
3427 {
3428     int temp;
3429     auto manager = CKM::Manager::create();
3430
3431     std::string message = "message test";
3432
3433     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
3434     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
3435     CKM::RawBuffer signature;
3436
3437     RUNNER_ASSERT_MSG(
3438         CKM_API_SUCCESS == (temp = manager->createSignature(
3439                                         alias_PKCS_exportable,
3440                                         CKM::Password(),
3441                                         CKM::RawBuffer(message.begin(), message.end()),
3442                                         hash,
3443                                         padd,
3444                                         signature)),
3445         "Error=" << CKM::ErrorToString(temp));
3446
3447     RUNNER_ASSERT_MSG(
3448         CKM_API_SUCCESS == (temp = manager->verifySignature(
3449                                         alias_PKCS_exportable,
3450                                         CKM::Password(),
3451                                         CKM::RawBuffer(message.begin(), message.end()),
3452                                         signature,
3453                                         hash,
3454                                         padd)),
3455         "Error=" << CKM::ErrorToString(temp));
3456 }
3457
3458 RUNNER_TEST(T1808_create_signature_on_raw_key_and_verify_on_PKCS)
3459 {
3460     int temp;
3461     auto manager = CKM::Manager::create();
3462
3463     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
3464         "MIICXQIBAAKBgQD1W9neUbXL1rnq9SvyzprjhWBKXyYKQirG3V2zyUnUaE24Sq2I\n"
3465         "v7ISrwMN/G6WcjrGmeZDEWwrL4zXh002N8BD1waJPRonxwtVkhFy3emGatSmx7eI\n"
3466         "ely5H+PBNImRvBh2u4GWga6OEXcUNdfaBUcxn+P6548/zpDhyNLzQKk5FwIDAQAB\n"
3467         "AoGAR+4WkBuqTUj1FlGsAbHaLKt0UDlWwJknS0eoacWwFEpDxqx19WolfV67aYVA\n"
3468         "snBolMKXg7/+0yZMhv8Ofr+XaHkPQplVVn9BwT0rmtEovJXwx+poRP9Bm3emglj/\n"
3469         "iYd8EkaXDlIXCtewtQW9JEIctWppntHj3TvA/h7FCXPN6SkCQQD/N7sn5S1gBkVh\n"
3470         "dyXQKoyKsZDb7hMIS1q6cKwYCMf2UrsD1/lnr7xXkvORdL213MfueO8g0WkuKfRY\n"
3471         "bDD6WGX1AkEA9hxiOlsgvermqLJkOlJffbSaM8n/6wtnM0HV+Vd9NfSBOmxFDXPO\n"
3472         "vrvdgiDPENhbqTJSQVDsfzHilTpK7lEvWwJBAJLxHoOg0tg3pBiyxgWtic+M3q+R\n"
3473         "ykl7QViY6KzJ2X98MIrM/Z7yMollZXE4+sVLwZ0O6fdGOr3GkBWc7TImVUUCQQC7\n"
3474         "pf6bQfof9Ce0fnf/I+ldHkPost7nJsWkBlGQkM2OQwP5OK4ZyK/dK76DxmI7FMwm\n"
3475         "oJCo7nuzq6R4ZX7WYJ47AkBavxBDo/e9/0Vk5yrloGKW3f8RQXBJLcCkVUGyyJ3D\n"
3476         "3gu/nafW4hzjSJniTjC1fOj0eb0OSg1JAvqHTYAnUsI7\n"
3477         "-----END RSA PRIVATE KEY-----";
3478     std::string message = "message test";
3479
3480     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
3481     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
3482         "Key is empty. Failed to import private key.");
3483
3484     RUNNER_ASSERT_MSG(
3485         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_copy, keyPrv, CKM::Policy())),
3486         "Error=" << CKM::ErrorToString(temp));
3487
3488     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
3489     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
3490     CKM::RawBuffer signature;
3491
3492     RUNNER_ASSERT_MSG(
3493         CKM_API_SUCCESS == (temp = manager->createSignature(
3494                                         alias_PKCS_priv_key_copy,
3495                                         CKM::Password(),
3496                                         CKM::RawBuffer(message.begin(), message.end()),
3497                                         hash,
3498                                         padd,
3499                                         signature)),
3500         "Error=" << CKM::ErrorToString(temp));
3501
3502     RUNNER_ASSERT_MSG(
3503         CKM_API_SUCCESS == (temp = manager->verifySignature(
3504                                         alias_PKCS_exportable,
3505                                         CKM::Password(),
3506                                         CKM::RawBuffer(message.begin(), message.end()),
3507                                         signature,
3508                                         hash,
3509                                         padd)),
3510         "Error=" << CKM::ErrorToString(temp));
3511 }
3512
3513 RUNNER_TEST(T1809_create_signature_on_wrong_key_and_verify_on_PKCS)
3514 {
3515     int temp;
3516     auto manager = CKM::Manager::create();
3517
3518     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
3519         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
3520         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
3521         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
3522         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
3523         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
3524         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
3525         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
3526         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
3527         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
3528         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
3529         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
3530         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
3531         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
3532         "-----END RSA PRIVATE KEY-----\n";
3533
3534     std::string message = "message test";
3535
3536     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
3537     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
3538         "Key is empty. Failed to import private key.");
3539
3540     RUNNER_ASSERT_MSG(
3541         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_wrong, keyPrv, CKM::Policy())),
3542         "Error=" << CKM::ErrorToString(temp));
3543
3544     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
3545     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
3546     CKM::RawBuffer signature;
3547
3548     RUNNER_ASSERT_MSG(
3549         CKM_API_SUCCESS == (temp = manager->createSignature(
3550                                         alias_PKCS_priv_key_wrong,
3551                                         CKM::Password(),
3552                                         CKM::RawBuffer(message.begin(), message.end()),
3553                                         hash,
3554                                         padd,
3555                                         signature)),
3556         "Error=" << CKM::ErrorToString(temp));
3557
3558     RUNNER_ASSERT_MSG(
3559         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
3560                                         alias_PKCS_exportable,
3561                                         CKM::Password(),
3562                                         CKM::RawBuffer(message.begin(), message.end()),
3563                                         signature,
3564                                         hash,
3565                                         padd)),
3566         "Error=" << CKM::ErrorToString(temp));
3567 }
3568
3569 RUNNER_TEST(T1810_verify_get_certificate_chain)
3570 {
3571     // this certificate has been signed using PKCS chain
3572     std::string im = "-----BEGIN CERTIFICATE-----\n"
3573         "MIIBrTCCARYCAQEwDQYJKoZIhvcNAQELBQAwHDEaMBgGA1UEAwwRc2VydmVyQHRl\n"
3574         "c3RtZS5jb20wHhcNMTQxMjAyMTMxNTQzWhcNMTUxMjAyMTMxNTQzWjAiMSAwHgYD\n"
3575         "VQQDDBdlbmQtb24tY2hhaW5AdGVzdG1lLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOB\n"
3576         "jQAwgYkCgYEAsJS/jky4Cnxnlj6m2Eam3E3ARfR1PTaQV3Om09z3Ax15ca3kfHSb\n"
3577         "n6UlDk9vjP3iE7Nbju5Nzw9Tu/Pe32g/54quUBgbTFWbztR/Q9Dxbt3evWZ98ADS\n"
3578         "qAtH9OU23xS/5jGpmJSP0l22JItx8E8nEbEPj7GTWfVuYb3HXMHqzY8CAwEAATAN\n"
3579         "BgkqhkiG9w0BAQsFAAOBgQCPJqjMH24kAngd0EunIPsVNSpWJMlMocFM5xHJsvgi\n"
3580         "5DZ7swo0O/Jfqvo/vKDVqR/wiPeAxrwirECGC1O2hC7HcOt7kW4taHSVGGd4dHMn\n"
3581         "oK70cUKQeVy3cYY6QUaonjuNVvYQHE3OSLDe56n6c7Mnek28qNtezeSWLUy8L8fA\n"
3582         "Qw==\n"
3583         "-----END CERTIFICATE-----\n";
3584
3585     auto cert = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
3586     CKM::CertificateShPtrVector certChain;
3587     CKM::AliasVector aliasVector;
3588
3589     int tmp;
3590     auto manager = CKM::Manager::create();
3591
3592     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
3593
3594     tmp = manager->getCertificateChain(cert,
3595                                        EMPTY_ALIAS_VECTOR,
3596                                        EMPTY_ALIAS_VECTOR,
3597                                        true,
3598                                        certChain);
3599     RUNNER_ASSERT_MSG_BT(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
3600                          "Error=" << CKM::ErrorToString(tmp));
3601
3602     RUNNER_ASSERT_MSG(
3603         0 == certChain.size(),
3604         "Wrong size of certificate chain.");
3605
3606     aliasVector.push_back(alias_PKCS_exportable);
3607
3608     tmp = manager->getCertificateChain(cert, EMPTY_ALIAS_VECTOR, aliasVector, false, certChain);
3609     RUNNER_ASSERT_MSG_BT(CKM_API_SUCCESS == tmp, "Error=" << CKM::ErrorToString(tmp));
3610
3611     // 1(cert) + 1(pkcs12 cert) + 2(pkcs12 chain cert) = 4
3612     RUNNER_ASSERT_MSG_BT(
3613         4 == certChain.size(),
3614         "Wrong size of certificate chain: " << certChain.size());
3615 }
3616
3617 RUNNER_TEST(T1811_remove_bundle_with_chain_certificates)
3618 {
3619     auto manager = CKM::Manager::create();
3620     int tmp;
3621
3622
3623     // remove the whole PKCS12 bundles
3624     RUNNER_ASSERT_MSG(
3625         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_exportable)),
3626         "Error=" << CKM::ErrorToString(tmp));
3627     RUNNER_ASSERT_MSG(
3628         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_not_exportable)),
3629         "Error=" << CKM::ErrorToString(tmp));
3630
3631     // expect lookup fails due to unknown alias
3632     // try to lookup key
3633     CKM::KeyShPtr key_lookup;
3634     RUNNER_ASSERT_MSG(
3635         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
3636         "Error=" << CKM::ErrorToString(tmp));
3637     RUNNER_ASSERT_MSG(
3638         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
3639         "Error=" << CKM::ErrorToString(tmp));
3640
3641     // try to lookup certificate
3642     CKM::CertificateShPtr cert_lookup;
3643     RUNNER_ASSERT_MSG(
3644         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
3645         "Error=" << CKM::ErrorToString(tmp));
3646     RUNNER_ASSERT_MSG(
3647         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
3648         "Error=" << CKM::ErrorToString(tmp));
3649 }
3650
3651 RUNNER_TEST(T1812_get_pkcs12_password_tests)
3652 {
3653     CKM::Alias alias = "t1812alias1";
3654
3655     auto manager = CKM::Manager::create();
3656     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
3657     std::istreambuf_iterator<char> begin(is), end;
3658     std::vector<char> buff(begin, end);
3659
3660     CKM::PKCS12ShPtr pkcs12;
3661     CKM::Password pass1 = "easypass1";
3662     CKM::Password pass2 = "easypass2";
3663
3664     CKM::RawBuffer buffer(buff.size());
3665     memcpy(buffer.data(), buff.data(), buff.size());
3666
3667     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
3668     RUNNER_ASSERT_MSG_BT(
3669         NULL != pkcs.get(),
3670         "Error in PKCS12::create()");
3671
3672     int temp;
3673     RUNNER_ASSERT_MSG_BT(
3674         CKM_API_SUCCESS == (temp = manager->savePKCS12(alias, pkcs, CKM::Policy(pass1), CKM::Policy(pass2))),
3675         "Error=" << CKM::ErrorToString(temp));
3676
3677     RUNNER_ASSERT_MSG_BT(
3678         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pkcs)),
3679         "Error=" << CKM::ErrorToString(temp));
3680
3681     RUNNER_ASSERT_MSG_BT(
3682         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), CKM::Password(), pkcs)),
3683         "Error=" << CKM::ErrorToString(temp));
3684
3685     RUNNER_ASSERT_MSG_BT(
3686         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pass1, CKM::Password(), pkcs)),
3687         "Error=" << CKM::ErrorToString(temp));
3688
3689     RUNNER_ASSERT_MSG_BT(
3690         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), pass2, pkcs)),
3691         "Error=" << CKM::ErrorToString(temp));
3692
3693     RUNNER_ASSERT_MSG_BT(
3694         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias, pass1, pass2, pkcs)),
3695         "Error=" << CKM::ErrorToString(temp));
3696
3697     CKM::CertificateShPtr cert;
3698     RUNNER_ASSERT_MSG_BT(
3699         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, pass2, cert)),
3700         "Error=" << CKM::ErrorToString(temp));
3701
3702     CKM::CertificateShPtrVector certChain;
3703     CKM::AliasVector certVect;
3704     certVect.push_back(alias);
3705
3706     RUNNER_ASSERT_MSG_BT(
3707         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getCertificateChain(cert, certVect, certVect, true, certChain)),
3708         "Error=" << CKM::ErrorToString(temp));
3709 }
3710
3711 RUNNER_TEST(T1813_deinit)
3712 {
3713     int temp;
3714     auto control = CKM::Control::create();
3715
3716     RUNNER_ASSERT_MSG(
3717         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
3718         "Error=" << CKM::ErrorToString(temp));
3719 }
3720
3721 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
3722
3723 RUNNER_TEST(T1901_init_unlock_key)
3724 {
3725     int tmp;
3726     auto control = CKM::Control::create();
3727     RUNNER_ASSERT_MSG(
3728         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
3729         "Error=" << CKM::ErrorToString(tmp));
3730     RUNNER_ASSERT_MSG(
3731         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
3732         "Error=" << CKM::ErrorToString(tmp));
3733     RUNNER_ASSERT_MSG(
3734         CKM_API_SUCCESS == (tmp = control->unlockUserKey(0, "t190-special-password")),
3735         "Error=" << CKM::ErrorToString(tmp));
3736 }
3737
3738 RUNNER_TEST(T1902_get_data)
3739 {
3740     auto manager = CKM::Manager::create();
3741     CKM::KeyShPtr ptr;
3742
3743     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
3744
3745     RUNNER_ASSERT_MSG(
3746         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
3747         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
3748 }
3749
3750 RUNNER_TEST(T1903_lock_database)
3751 {
3752     int tmp;
3753     auto control = CKM::Control::create();
3754     RUNNER_ASSERT_MSG(
3755         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
3756         "Error=" << CKM::ErrorToString(tmp));
3757 }
3758
3759 RUNNER_TEST(T1904_get_data_from_locked_database)
3760 {
3761     auto manager = CKM::Manager::create();
3762     CKM::KeyShPtr ptr;
3763
3764     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
3765
3766     RUNNER_ASSERT_MSG(
3767         CKM_API_ERROR_DB_LOCKED == status1,
3768         "Could not get key from locked database. Error=" << CKM::ErrorToString(status1));
3769 }
3770
3771 RUNNER_TEST(T1905_deinit)
3772 {
3773     int tmp;
3774     auto control = CKM::Control::create();
3775     RUNNER_ASSERT_MSG(
3776         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
3777         "Error=" << CKM::ErrorToString(tmp));
3778 }
3779
3780 int main(int argc, char *argv[])
3781 {
3782     DPL::Log::LogSystemSingleton::Instance().SetTag("CKM_TESTS");
3783     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
3784 }