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