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