tests/ckm/main.cpp

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