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