tests/ckm/main.cpp

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