tests/ckm/main.cpp

   1 #include <netdb.h>
   2
   3 #include <dpl/test/test_runner.h>
   4 #include <dpl/test/test_runner_child.h>
   5
   6 #include <tests_common.h>
   7 #include <access_provider2.h>
   8
   9 #include <ckm/ckm-manager.h>
  10 #include <ckm/ckm-control.h>
  11 #include <ckm/ckm-password.h>
  12 #include <ckm/ckm-type.h>
  13 #include <ckm/ckm-pkcs12.h>
  14
  15 #include <fstream>
  16
  17 #include <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     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     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     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     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     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     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     RUNNER_IGNORED_MSG("Fixed in next version of ckm!");
1196
1197     std::string ee = "-----BEGIN CERTIFICATE-----\n"
1198       "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
1199       "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1200       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
1201       "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
1202       "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
1203       "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
1204       "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
1205       "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
1206       "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
1207       "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
1208       "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
1209       "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
1210       "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
1211       "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
1212       "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
1213       "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
1214       "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
1215       "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
1216       "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
1217       "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
1218       "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
1219       "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
1220       "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
1221       "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
1222       "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
1223       "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
1224       "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
1225       "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
1226       "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
1227       "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
1228       "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
1229       "oFXtrg0=\n"
1230       "-----END CERTIFICATE-----\n";
1231
1232     std::string im =
1233       "-----BEGIN CERTIFICATE-----\n"
1234       "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
1235       "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1236       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
1237       "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
1238       "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
1239       "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
1240       "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
1241       "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
1242       "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
1243       "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
1244       "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
1245       "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
1246       "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
1247       "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
1248       "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
1249       "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
1250       "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
1251       "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
1252       "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
1253       "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
1254       "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
1255       "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
1256       "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
1257       "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
1258       "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
1259       "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
1260       "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
1261       "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
1262       "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
1263       "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
1264       "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
1265       "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
1266       "-----END CERTIFICATE-----\n";
1267
1268     auto cert = CKM::Certificate::create(CKM::RawBuffer(ee.begin(), ee.end()), CKM::DataFormat::FORM_PEM);
1269     auto cert1 = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
1270     CKM::CertificateShPtrVector certVector = {cert1};
1271     CKM::CertificateShPtrVector certChain;
1272
1273     int tmp;
1274     auto manager = CKM::Manager::create();
1275
1276     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
1277     RUNNER_ASSERT_MSG(NULL != cert1.get(), "Certificate should not be empty");
1278
1279     RUNNER_ASSERT_MSG(
1280         CKM_API_ERROR_VERIFICATION_FAILED == (tmp = manager->getCertificateChain(cert, CKM::CertificateShPtrVector(), certChain)),
1281         "Error=" << CKM::ErrorToString(tmp));
1282
1283     RUNNER_ASSERT_MSG(
1284         0 == certChain.size(),
1285         "Wrong size of certificate chain.");
1286
1287     RUNNER_ASSERT_MSG(
1288         CKM_API_SUCCESS == (tmp = manager->getCertificateChain(cert, certVector, certChain)),
1289         "Error=" << CKM::ErrorToString(tmp));
1290
1291     RUNNER_ASSERT_MSG(
1292         3 == certChain.size(),
1293         "Wrong size of certificate chain.");
1294
1295     int status;
1296     RUNNER_ASSERT_MSG(
1297         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certChain, status)),
1298         "Error=" << CKM::ErrorToString(tmp));
1299
1300     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_GOOD == status, "Verfication failed");
1301 }
1302
1303 RUNNER_TEST(T1315_deinit)
1304 {
1305     int temp;
1306     auto control = CKM::Control::create();
1307
1308     RUNNER_ASSERT_MSG(
1309         CKM_API_SUCCESS == (temp = control->lockUserKey(0)),
1310         "Error=" << CKM::ErrorToString(temp));
1311     RUNNER_ASSERT_MSG(
1312         CKM_API_SUCCESS == (temp = control->removeUserData(0)),
1313         "Error=" << CKM::ErrorToString(temp));
1314 }
1315
1316 RUNNER_TEST_GROUP_INIT(T141_CREATE_AND_VERIFY_SIGNATURE);
1317
1318 RUNNER_TEST(T1411_init)
1319 {
1320     int temp;
1321     auto control = CKM::Control::create();
1322     RUNNER_ASSERT_MSG(
1323         CKM_API_SUCCESS == (temp = control->unlockUserKey(0, "test-pass")),
1324         "Error=" << CKM::ErrorToString(temp));
1325 }
1326
1327 RUNNER_TEST(T1412_rsa_key_create_verify)
1328 {
1329     int temp;
1330     auto manager = CKM::Manager::create();
1331
1332     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1333       "Proc-Type: 4,ENCRYPTED\n"
1334       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1335       "\n"
1336       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1337       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1338       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1339       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1340       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1341       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1342       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1343       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1344       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1345       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1346       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1347       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1348       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1349       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1350       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1351       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1352       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1353       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1354       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1355       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1356       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1357       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1358       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1359       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1360       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1361       "-----END RSA PRIVATE KEY-----\n";
1362
1363     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1364       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1365       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1366       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1367       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1368       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1369       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1370       "zQIDAQAB\n"
1371       "-----END PUBLIC KEY-----\n";
1372
1373     std::string message = "message test";
1374
1375     CKM::Alias aliasPub = "pub1";
1376     CKM::Alias aliasPrv = "prv1";
1377     CKM::Password password = "1234";
1378     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1379     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1380     CKM::RawBuffer signature;
1381
1382     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1383     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
1384
1385     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1386         "Key is empty. Failed to import public key.");
1387     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1388         "Key is empty. Failed to import private key.");
1389
1390     RUNNER_ASSERT_MSG(
1391         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1392         "Error=" << CKM::ErrorToString(temp));
1393     RUNNER_ASSERT_MSG(
1394         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1395         "Error=" << CKM::ErrorToString(temp));
1396
1397     RUNNER_ASSERT_MSG(
1398         CKM_API_SUCCESS == (temp = manager->createSignature(
1399                                         aliasPrv,
1400                                         CKM::Password(),
1401                                         CKM::RawBuffer(message.begin(), message.end()),
1402                                         hash,
1403                                         padd,
1404                                         signature)),
1405         "Error=" << CKM::ErrorToString(temp));
1406
1407     RUNNER_ASSERT_MSG(
1408         CKM_API_SUCCESS == (temp = manager->verifySignature(
1409                                         aliasPub,
1410                                         CKM::Password(),
1411                                         CKM::RawBuffer(message.begin(), message.end()),
1412                                         signature,
1413                                         hash,
1414                                         padd)),
1415         "Error=" << CKM::ErrorToString(temp));
1416 }
1417
1418 RUNNER_TEST(T1413_dsa_key_create_verify)
1419 {
1420     int temp;
1421     auto manager = CKM::Manager::create();
1422
1423     std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1424             "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1425             "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1426             "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1427             "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1428             "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1429             "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1430             "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1431             "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1432             "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1433             "u1roOuaPY+Hl19BlTE2qdw==\n"
1434             "-----END DSA PRIVATE KEY-----";
1435
1436     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1437             "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1438             "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1439             "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1440             "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1441             "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1442             "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1443             "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1444             "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1445             "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1446             "YMYCBhubtrVaLmc=\n"
1447             "-----END PUBLIC KEY-----";
1448
1449     std::string message = "message test";
1450
1451     CKM::Alias aliasPub = "pub2";
1452     CKM::Alias aliasPrv = "prv2";
1453     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1454     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1455     CKM::RawBuffer signature;
1456
1457     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1458     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
1459
1460     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1461         "Key is empty. Failed to import public key.");
1462     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1463         "Key is empty. Failed to import private key.");
1464
1465     RUNNER_ASSERT_MSG(
1466         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1467         "Error=" << CKM::ErrorToString(temp));
1468     RUNNER_ASSERT_MSG(
1469         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1470         "Error=" << CKM::ErrorToString(temp));
1471
1472     RUNNER_ASSERT_MSG(
1473         CKM_API_SUCCESS == (temp = manager->createSignature(
1474                                         aliasPrv,
1475                                         CKM::Password(),
1476                                         CKM::RawBuffer(message.begin(), message.end()),
1477                                         hash,
1478                                         padd,
1479                                         signature)),
1480         "Error=" << CKM::ErrorToString(temp));
1481
1482     RUNNER_ASSERT_MSG(
1483         CKM_API_SUCCESS == (temp = manager->verifySignature(
1484                                         aliasPub,
1485                                         CKM::Password(),
1486                                         CKM::RawBuffer(message.begin(), message.end()),
1487                                         signature,
1488                                         hash,
1489                                         padd)),
1490         "Error=" << CKM::ErrorToString(temp));
1491 }
1492
1493
1494 RUNNER_TEST(T1414_ec_key_create_verify)
1495 {
1496     int temp;
1497     auto manager = CKM::Manager::create();
1498
1499     std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1500         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1501         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1502         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1503         "-----END EC PRIVATE KEY-----\n";
1504
1505     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1506         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1507         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1508         "-----END PUBLIC KEY-----\n";
1509
1510     std::string message = "message test";
1511
1512     CKM::Alias aliasPub = "ecpub2";
1513     CKM::Alias aliasPrv = "ecprv2";
1514     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1515     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1516     CKM::RawBuffer signature;
1517
1518     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1519     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1520
1521     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1522         "Key is empty. Failed to import public key.");
1523     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1524         "Key is empty. Failed to import private key.");
1525
1526     RUNNER_ASSERT_MSG(
1527         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1528         "Error=" << CKM::ErrorToString(temp));
1529     RUNNER_ASSERT_MSG(
1530         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1531         "Error=" << CKM::ErrorToString(temp));
1532
1533     RUNNER_ASSERT_MSG(
1534         CKM_API_SUCCESS == (temp = manager->createSignature(
1535                                         aliasPrv,
1536                                         CKM::Password(),
1537                                         CKM::RawBuffer(message.begin(), message.end()),
1538                                         hash,
1539                                         padd,
1540                                         signature)),
1541         "Error=" << CKM::ErrorToString(temp));
1542
1543     RUNNER_ASSERT_MSG(
1544         CKM_API_SUCCESS == (temp = manager->verifySignature(
1545                                         aliasPub,
1546                                         CKM::Password(),
1547                                         CKM::RawBuffer(message.begin(), message.end()),
1548                                         signature,
1549                                         hash,
1550                                         padd)),
1551         "Error=" << CKM::ErrorToString(temp));
1552
1553     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1554
1555     memcpy((void*)signature.data(), "BROKEN", 6);
1556
1557     RUNNER_ASSERT_MSG(
1558         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1559                                         aliasPub,
1560                                         CKM::Password(),
1561                                         CKM::RawBuffer(message.begin(), message.end()),
1562                                         signature,
1563                                         hash,
1564                                         padd)),
1565         "Error=" << CKM::ErrorToString(temp));
1566 }
1567
1568 RUNNER_TEST(T1415_rsa_key_create_verify_negative)
1569 {
1570     int temp;
1571     auto manager = CKM::Manager::create();
1572     std::string message = "message asdfaslkdfjlksadjf test";
1573
1574     CKM::Alias aliasPub = "pub1";
1575     CKM::Alias aliasPrv = "prv1";
1576
1577     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1578     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1579     CKM::RawBuffer signature;
1580
1581     RUNNER_ASSERT_MSG(
1582         CKM_API_SUCCESS == (temp = manager->createSignature(
1583                                         aliasPrv,
1584                                         CKM::Password(),
1585                                         CKM::RawBuffer(message.begin(), message.end()),
1586                                         hash,
1587                                         padd,
1588                                         signature)),
1589         "Error=" << CKM::ErrorToString(temp));
1590
1591     RUNNER_ASSERT_MSG(
1592         CKM_API_SUCCESS == (temp = manager->verifySignature(
1593                                         aliasPub,
1594                                         CKM::Password(),
1595                                         CKM::RawBuffer(message.begin(), message.end()),
1596                                         signature,
1597                                         hash,
1598                                         padd)),
1599         "Error=" << CKM::ErrorToString(temp));
1600
1601     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1602     memcpy((void*)signature.data(), "BROKEN", 6);
1603
1604     RUNNER_ASSERT_MSG(
1605         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1606                                         aliasPub,
1607                                         CKM::Password(),
1608                                         CKM::RawBuffer(message.begin(), message.end()),
1609                                         signature,
1610                                         hash,
1611                                         padd)),
1612         "Error=" << CKM::ErrorToString(temp));
1613 }
1614
1615 RUNNER_TEST(T1416_dsa_key_create_verify_negative)
1616 {
1617     int temp;
1618     auto manager = CKM::Manager::create();
1619     std::string message = "message asdfaslkdfjlksadjf test";
1620
1621     CKM::Alias aliasPub = "pub2";
1622     CKM::Alias aliasPrv = "prv2";
1623
1624     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1625     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1626     CKM::RawBuffer signature;
1627
1628     RUNNER_ASSERT_MSG(
1629         CKM_API_SUCCESS == (temp = manager->createSignature(
1630                                         aliasPrv,
1631                                         CKM::Password(),
1632                                         CKM::RawBuffer(message.begin(), message.end()),
1633                                         hash,
1634                                         padd,
1635                                         signature)),
1636         "Error=" << CKM::ErrorToString(temp));
1637
1638     RUNNER_ASSERT_MSG(
1639         CKM_API_SUCCESS == (temp = manager->verifySignature(
1640                                         aliasPub,
1641                                         CKM::Password(),
1642                                         CKM::RawBuffer(message.begin(), message.end()),
1643                                         signature,
1644                                         hash,
1645                                         padd)),
1646         "Error=" << CKM::ErrorToString(temp));
1647
1648     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1649     memcpy((void*)signature.data(), "BROKEN", 6);
1650
1651     RUNNER_ASSERT_MSG(
1652         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1653                                         aliasPub,
1654                                         CKM::Password(),
1655                                         CKM::RawBuffer(message.begin(), message.end()),
1656                                         signature,
1657                                         hash,
1658                                         padd)),
1659         "Error=" << CKM::ErrorToString(temp));
1660 }
1661
1662 RUNNER_TEST(T1417_rsa_cert_create_verify_signature)
1663 {
1664     int temp;
1665     auto manager = CKM::Manager::create();
1666
1667     std::string prv =
1668       "-----BEGIN RSA PRIVATE KEY-----\n"
1669       "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1670       "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1671       "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1672       "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1673       "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1674       "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1675       "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1676       "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1677       "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1678       "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1679       "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1680       "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1681       "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1682       "-----END RSA PRIVATE KEY-----\n";
1683
1684     std::string pub =
1685       "-----BEGIN CERTIFICATE-----\n"
1686       "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1687       "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1688       "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1689       "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1690       "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1691       "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1692       "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1693       "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1694       "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1695       "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1696       "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1697       "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1698       "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1699       "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1700       "-----END CERTIFICATE-----\n";
1701
1702     std::string message = "message test";
1703
1704     CKM::Alias aliasPub = "pub1-cert";
1705     CKM::Alias aliasPrv = "prv1-cert";
1706     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1707     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1708     CKM::RawBuffer signature;
1709
1710     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1711     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1712
1713     RUNNER_ASSERT_MSG(NULL != cert.get(),
1714         "Key is empty. Failed to import public key.");
1715     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1716         "Key is empty. Failed to import private key.");
1717
1718     RUNNER_ASSERT_MSG(
1719         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1720         "Error=" << CKM::ErrorToString(temp));
1721     RUNNER_ASSERT_MSG(
1722         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1723         "Error=" << CKM::ErrorToString(temp));
1724
1725     RUNNER_ASSERT_MSG(
1726         CKM_API_SUCCESS == (temp = manager->createSignature(
1727                                         aliasPrv,
1728                                         CKM::Password(),
1729                                         CKM::RawBuffer(message.begin(), message.end()),
1730                                         hash,
1731                                         padd,
1732                                         signature)),
1733         "Error=" << CKM::ErrorToString(temp));
1734
1735     RUNNER_ASSERT_MSG(
1736         CKM_API_SUCCESS == (temp = manager->verifySignature(
1737                                         aliasPub,
1738                                         CKM::Password(),
1739                                         CKM::RawBuffer(message.begin(), message.end()),
1740                                         signature,
1741                                         hash,
1742                                         padd)),
1743         "Error=" << CKM::ErrorToString(temp));
1744
1745     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1746
1747     memcpy((void*)signature.data(), "BROKEN", 6);
1748
1749     RUNNER_ASSERT_MSG(
1750         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1751                                         aliasPub,
1752                                         CKM::Password(),
1753                                         CKM::RawBuffer(message.begin(), message.end()),
1754                                         signature,
1755                                         hash,
1756                                         padd)),
1757         "Error=" << CKM::ErrorToString(temp));
1758 }
1759
1760 RUNNER_TEST(T1418_dsa_cert_create_verify_signature)
1761 {
1762     int temp;
1763     auto manager = CKM::Manager::create();
1764
1765     const std::string pub = "-----BEGIN CERTIFICATE-----\n"
1766         "MIIDUzCCAxECCQCer/fKcXtJgTALBglghkgBZQMEAwIwgYsxCzAJBgNVBAYTAlBM\n"
1767         "MQ8wDQYDVQQIDAZQb2xhbmQxDzANBgNVBAcMBldhcnNhdzEQMA4GA1UECgwHU2Ft\n"
1768         "c3VuZzEMMAoGA1UECwwDS1NGMRMwEQYDVQQDDAptLmthcnBpdWsyMSUwIwYJKoZI\n"
1769         "hvcNAQkBFhZtLmthcnBpdWsyQHNhbXN1bmcuY29tMCAXDTE0MDkyNjEzNTQwN1oY\n"
1770         "DzIxNDAwOTA1MTM1NDA3WjCBizELMAkGA1UEBhMCUEwxDzANBgNVBAgMBlBvbGFu\n"
1771         "ZDEPMA0GA1UEBwwGV2Fyc2F3MRAwDgYDVQQKDAdTYW1zdW5nMQwwCgYDVQQLDANL\n"
1772         "U0YxEzARBgNVBAMMCm0ua2FycGl1azIxJTAjBgkqhkiG9w0BCQEWFm0ua2FycGl1\n"
1773         "azJAc2Ftc3VuZy5jb20wggG3MIIBKwYHKoZIzjgEATCCAR4CgYEA9Bhh7ZA4onkY\n"
1774         "uDNQbYR4EwkJ6RpD505hB0GF6yppUNp2LanvNcQXcyXY88MB6OdP7Rikbu1H2zP4\n"
1775         "gONCtdxKW58Za7h9bFzYjxcObZsS52F9DP7sv3C4sX4xNWApfhUgbfzKaRCJOkOs\n"
1776         "06tV7teu3G/v26PdI8dlykIuQXQZmH8CFQCHsIV0njb2yC3ggfKz+exH+g5jAQKB\n"
1777         "gBVLYfVCMjUz5XJH+xYU3A8W8rpSLqZKIK2d9mbXqhpz8QK1bvNQUlSRZo+o1ZYV\n"
1778         "mJn3Mx2YuiifHZNKdBNweCqe5a+HV2RSl1Yv/TV9famZKlogGslsmPHUOJMlSIdh\n"
1779         "MfMwVny4/rNtjEtEFE1WnaTr1W6MKH1EBbizVo8fmWFrA4GFAAKBgQCaPjrlkAyX\n"
1780         "kBitWo+w0xZN4OSk13SsCzZ/PG+5zOgMRaFm2XbiC04YsGCi4NFOd9kaiP7w1CsP\n"
1781         "iqG6Vwv0T/VcoxBl/hp6jEqTDSrM6z0ungjDO9wGOdI+jZS0UjVahgC4ZLDHhrOa\n"
1782         "CjfxcHruO3e416b/Rm2CjhOzjKdoSFUWVzALBglghkgBZQMEAwIDLwAwLAIUHa+A\n"
1783         "5xo8O/tPuH9gXkr1mee6kRYCFGNycJ1xkc3nIJaEQOtGfDe7S71A\n"
1784         "-----END CERTIFICATE-----\n";
1785
1786     const std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1787         "MIIBuwIBAAKBgQD0GGHtkDiieRi4M1BthHgTCQnpGkPnTmEHQYXrKmlQ2nYtqe81\n"
1788         "xBdzJdjzwwHo50/tGKRu7UfbM/iA40K13EpbnxlruH1sXNiPFw5tmxLnYX0M/uy/\n"
1789         "cLixfjE1YCl+FSBt/MppEIk6Q6zTq1Xu167cb+/bo90jx2XKQi5BdBmYfwIVAIew\n"
1790         "hXSeNvbILeCB8rP57Ef6DmMBAoGAFUth9UIyNTPlckf7FhTcDxbyulIupkogrZ32\n"
1791         "ZteqGnPxArVu81BSVJFmj6jVlhWYmfczHZi6KJ8dk0p0E3B4Kp7lr4dXZFKXVi/9\n"
1792         "NX19qZkqWiAayWyY8dQ4kyVIh2Ex8zBWfLj+s22MS0QUTVadpOvVbowofUQFuLNW\n"
1793         "jx+ZYWsCgYEAmj465ZAMl5AYrVqPsNMWTeDkpNd0rAs2fzxvuczoDEWhZtl24gtO\n"
1794         "GLBgouDRTnfZGoj+8NQrD4qhulcL9E/1XKMQZf4aeoxKkw0qzOs9Lp4IwzvcBjnS\n"
1795         "Po2UtFI1WoYAuGSwx4azmgo38XB67jt3uNem/0Ztgo4Ts4ynaEhVFlcCFGMH+Z9l\n"
1796         "vonbjii3BYe4AIdkzOvp\n"
1797         "-----END DSA PRIVATE KEY-----\n";
1798
1799     std::string message = "message test";
1800
1801     CKM::Alias aliasPub = "pub2-cert";
1802     CKM::Alias aliasPrv = "prv2-cert";
1803     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1804     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1805     CKM::RawBuffer signature;
1806
1807     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1808     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1809
1810     RUNNER_ASSERT_MSG(NULL != cert.get(),
1811         "Key is empty. Failed to import public key.");
1812     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1813         "Key is empty. Failed to import private key.");
1814
1815     RUNNER_ASSERT_MSG(
1816         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1817         "Error=" << CKM::ErrorToString(temp));
1818     RUNNER_ASSERT_MSG(
1819         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1820         "Error=" << CKM::ErrorToString(temp));
1821
1822     RUNNER_ASSERT_MSG(
1823         CKM_API_SUCCESS == (temp = manager->createSignature(
1824                                         aliasPrv,
1825                                         CKM::Password(),
1826                                         CKM::RawBuffer(message.begin(), message.end()),
1827                                         hash,
1828                                         padd,
1829                                         signature)),
1830         "Error=" << CKM::ErrorToString(temp));
1831
1832     RUNNER_ASSERT_MSG(
1833         CKM_API_SUCCESS == (temp = manager->verifySignature(
1834                                         aliasPub,
1835                                         CKM::Password(),
1836                                         CKM::RawBuffer(message.begin(), message.end()),
1837                                         signature,
1838                                         hash,
1839                                         padd)),
1840         "Error=" << CKM::ErrorToString(temp));
1841
1842     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1843
1844     memcpy((void*)signature.data(), "BROKEN", 6);
1845
1846     RUNNER_ASSERT_MSG(
1847         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1848                                         aliasPub,
1849                                         CKM::Password(),
1850                                         CKM::RawBuffer(message.begin(), message.end()),
1851                                         signature,
1852                                         hash,
1853                                         padd)),
1854         "Error=" << CKM::ErrorToString(temp));
1855 }
1856
1857 RUNNER_TEST(T1419_ecdsa_cert_create_verify_signature)
1858 {
1859     int temp;
1860     auto manager = CKM::Manager::create();
1861
1862     std::string prv =
1863       "-----BEGIN EC PRIVATE KEY-----\n"
1864       "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1865       "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1866       "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1867       "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1868       "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1869       "ELyhe7yPCAuOoLZlTLgf\n"
1870       "-----END EC PRIVATE KEY-----\n";
1871
1872     std::string pub =
1873       "-----BEGIN CERTIFICATE-----\n"
1874       "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1875       "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1876       "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1877       "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1878       "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1879       "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1880       "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1881       "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1882       "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1883       "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1884       "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1885       "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1886       "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1887       "Q1oBry6NEc+lLFmWMDesAA==\n"
1888       "-----END CERTIFICATE-----\n";
1889
1890     std::string message = "message test";
1891
1892     CKM::Alias aliasPub = "pub3";
1893     CKM::Alias aliasPrv = "prv3";
1894     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1895     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1896     CKM::RawBuffer signature;
1897
1898     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1899     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1900
1901     RUNNER_ASSERT_MSG(NULL != cert.get(),
1902         "Key is empty. Failed to import public key.");
1903     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1904         "Key is empty. Failed to import private key.");
1905
1906     RUNNER_ASSERT_MSG(
1907         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1908         "Error=" << CKM::ErrorToString(temp));
1909     RUNNER_ASSERT_MSG(
1910         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1911         "Error=" << CKM::ErrorToString(temp));
1912
1913     RUNNER_ASSERT_MSG(
1914         CKM_API_SUCCESS == (temp = manager->createSignature(
1915                                         aliasPrv,
1916                                         CKM::Password(),
1917                                         CKM::RawBuffer(message.begin(), message.end()),
1918                                         hash,
1919                                         padd,
1920                                         signature)),
1921         "Error=" << CKM::ErrorToString(temp));
1922
1923     RUNNER_ASSERT_MSG(
1924         CKM_API_SUCCESS == (temp = manager->verifySignature(
1925                                         aliasPub,
1926                                         CKM::Password(),
1927                                         CKM::RawBuffer(message.begin(), message.end()),
1928                                         signature,
1929                                         hash,
1930                                         padd)),
1931         "Error=" << CKM::ErrorToString(temp));
1932
1933     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1934
1935     memcpy((void*)signature.data(), "BROKEN", 6);
1936
1937     RUNNER_ASSERT_MSG(
1938         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1939                                         aliasPub,
1940                                         CKM::Password(),
1941                                         CKM::RawBuffer(message.begin(), message.end()),
1942                                         signature,
1943                                         hash,
1944                                         padd)),
1945         "Error=" << CKM::ErrorToString(temp));
1946 }
1947
1948 RUNNER_TEST(T1420_deinit)
1949 {
1950     int temp;
1951     auto control = CKM::Control::create();
1952
1953     RUNNER_ASSERT_MSG(
1954         CKM_API_SUCCESS == (temp = control->lockUserKey(0)),
1955         "Error=" << CKM::ErrorToString(temp));
1956     RUNNER_ASSERT_MSG(
1957         CKM_API_SUCCESS == (temp = control->removeUserData(0)),
1958         "Error=" << CKM::ErrorToString(temp));
1959 }
1960
1961 RUNNER_TEST(T14180_init)
1962 {
1963     int temp;
1964     auto control = CKM::Control::create();
1965     RUNNER_ASSERT_MSG(
1966         CKM_API_SUCCESS == (temp = control->unlockUserKey(0, "test-pass")),
1967         "Error=" << CKM::ErrorToString(temp));
1968
1969     auto manager = CKM::Manager::create();
1970
1971     // Prepare RSA Key Pair
1972     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1973       "Proc-Type: 4,ENCRYPTED\n"
1974       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1975       "\n"
1976       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1977       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1978       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1979       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1980       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1981       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1982       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1983       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1984       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1985       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1986       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1987       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1988       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1989       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1990       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1991       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1992       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1993       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1994       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1995       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1996       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1997       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1998       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1999       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
2000       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
2001       "-----END RSA PRIVATE KEY-----\n";
2002
2003     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
2004       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2005       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2006       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2007       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2008       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2009       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2010       "zQIDAQAB\n"
2011       "-----END PUBLIC KEY-----\n";
2012
2013     CKM::Alias aliasPub = "pub_nohash1";
2014     CKM::Alias aliasPrv = "prv_nohash1";
2015     CKM::Password password = "1234";
2016
2017     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
2018     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
2019
2020     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
2021         "Key is empty. Failed to import public key.");
2022     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2023         "Key is empty. Failed to import private key.");
2024
2025     RUNNER_ASSERT_MSG(
2026         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
2027         "Error=" << CKM::ErrorToString(temp));
2028     RUNNER_ASSERT_MSG(
2029         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
2030         "Error=" << CKM::ErrorToString(temp));
2031
2032     // Prepare ECDSA Key Pair
2033     std::string ecprv = "-----BEGIN EC PRIVATE KEY-----\n"
2034         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
2035         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
2036         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2037         "-----END EC PRIVATE KEY-----\n";
2038
2039     std::string ecpub = "-----BEGIN PUBLIC KEY-----\n"
2040         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
2041         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2042         "-----END PUBLIC KEY-----\n";
2043
2044     CKM::Alias aliasEcPub = "ecpub_nohash1";
2045     CKM::Alias aliasEcPrv = "ecprv_nohash1";
2046
2047     auto ecKeyPub = CKM::Key::create(CKM::RawBuffer(ecpub.begin(), ecpub.end()));
2048     auto ecKeyPrv = CKM::Key::create(CKM::RawBuffer(ecprv.begin(), ecprv.end()));
2049
2050     RUNNER_ASSERT_MSG(NULL != ecKeyPub.get(),
2051         "Key is empty. Failed to import public key.");
2052     RUNNER_ASSERT_MSG(NULL != ecKeyPrv.get(),
2053         "Key is empty. Failed to import private key.");
2054
2055     RUNNER_ASSERT_MSG(
2056         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPub, ecKeyPub, CKM::Policy())),
2057         "Error=" << CKM::ErrorToString(temp));
2058     RUNNER_ASSERT_MSG(
2059         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPrv, ecKeyPrv, CKM::Policy())),
2060         "Error=" << CKM::ErrorToString(temp));
2061 }
2062
2063
2064 RUNNER_TEST(T14181_rsa_create_signatue_nohash)
2065 {
2066     int temp;
2067     auto manager = CKM::Manager::create();
2068     std::string message = "message asdfaslkdfjlksadjf test";
2069
2070     CKM::Alias aliasPub = "pub_nohash1";
2071     CKM::Alias aliasPrv = "prv_nohash1";
2072
2073     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2074     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2075     CKM::RawBuffer signature;
2076
2077     RUNNER_ASSERT_MSG(
2078         CKM_API_SUCCESS == (temp = manager->createSignature(
2079                                         aliasPrv,
2080                                         CKM::Password(),
2081                                         CKM::RawBuffer(message.begin(), message.end()),
2082                                         hash,
2083                                         padd,
2084                                         signature)),
2085         "Error=" << CKM::ErrorToString(temp));
2086
2087     RUNNER_ASSERT_MSG(
2088         CKM_API_SUCCESS == (temp = manager->verifySignature(
2089                                         aliasPub,
2090                                         CKM::Password(),
2091                                         CKM::RawBuffer(message.begin(), message.end()),
2092                                         signature,
2093                                         hash,
2094                                         padd)),
2095         "Error=" << CKM::ErrorToString(temp));
2096
2097     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2098     memcpy((void*)signature.data(), "BROKEN", 6);
2099
2100     RUNNER_ASSERT_MSG(
2101         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2102                                         aliasPub,
2103                                         CKM::Password(),
2104                                         CKM::RawBuffer(message.begin(), message.end()),
2105                                         signature,
2106                                         hash,
2107                                         padd)),
2108         "Error=" << CKM::ErrorToString(temp));
2109 }
2110
2111 RUNNER_TEST(T14182_rsa_create_signatue_nohash_nopad)
2112 {
2113     int temp;
2114     auto manager = CKM::Manager::create();
2115     std::string message = "message asdfaslkdfjlksadjf test";
2116
2117     CKM::Alias aliasPub = "pub_nohash1";
2118     CKM::Alias aliasPrv = "prv_nohash1";
2119
2120     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2121     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2122     CKM::RawBuffer signature;
2123
2124     RUNNER_ASSERT_MSG(
2125         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2126                                         aliasPrv,
2127                                         CKM::Password(),
2128                                         CKM::RawBuffer(message.begin(), message.end()),
2129                                         hash,
2130                                         padd,
2131                                         signature)),
2132         "Error=" << CKM::ErrorToString(temp));
2133 }
2134
2135 RUNNER_TEST(T14183_rsa_create_signatue_nohash_bigmsg)
2136 {
2137     int temp;
2138     auto manager = CKM::Manager::create();
2139     std::string message = "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                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2158                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
2159
2160     CKM::Alias aliasPub = "pub_nohash1";
2161     CKM::Alias aliasPrv = "prv_nohash1";
2162
2163     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2164     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2165     CKM::RawBuffer signature;
2166
2167     RUNNER_ASSERT_MSG(
2168         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2169                                         aliasPrv,
2170                                         CKM::Password(),
2171                                         CKM::RawBuffer(message.begin(), message.end()),
2172                                         hash,
2173                                         padd,
2174                                         signature)),
2175         "Error=" << CKM::ErrorToString(temp));
2176 }
2177
2178
2179 RUNNER_TEST(T14184_ec_create_signatue_nohash)
2180 {
2181     int temp;
2182     auto manager = CKM::Manager::create();
2183
2184     std::string message = "message test";
2185
2186     CKM::Alias aliasPub = "ecpub_nohash1";
2187     CKM::Alias aliasPrv = "ecprv_nohash1";
2188     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2189     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2190     CKM::RawBuffer signature;
2191
2192     RUNNER_ASSERT_MSG(
2193         CKM_API_SUCCESS == (temp = manager->createSignature(
2194                                         aliasPrv,
2195                                         CKM::Password(),
2196                                         CKM::RawBuffer(message.begin(), message.end()),
2197                                         hash,
2198                                         padd,
2199                                         signature)),
2200         "Error=" << CKM::ErrorToString(temp));
2201
2202     RUNNER_ASSERT_MSG(
2203         CKM_API_SUCCESS == (temp = manager->verifySignature(
2204                                         aliasPub,
2205                                         CKM::Password(),
2206                                         CKM::RawBuffer(message.begin(), message.end()),
2207                                         signature,
2208                                         hash,
2209                                         padd)),
2210         "Error=" << CKM::ErrorToString(temp));
2211
2212     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2213
2214     memcpy((void*)signature.data(), "BROKEN", 6);
2215
2216     RUNNER_ASSERT_MSG(
2217         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2218                                         aliasPub,
2219                                         CKM::Password(),
2220                                         CKM::RawBuffer(message.begin(), message.end()),
2221                                         signature,
2222                                         hash,
2223                                         padd)),
2224         "Error=" << CKM::ErrorToString(temp));
2225 }
2226
2227 RUNNER_TEST(T14185_ec_create_signatue_nohash_bigmsg)
2228 {
2229     int temp;
2230     auto manager = CKM::Manager::create();
2231
2232     int msgSize = 1024*1024;
2233     char big_msg[msgSize];
2234     for(int i =0; i<msgSize-1; i++) {
2235         big_msg[i] = 'a';
2236     }
2237     big_msg[msgSize-1]=0x00;
2238     std::string message(big_msg);
2239
2240     CKM::Alias aliasPub = "ecpub_nohash1";
2241     CKM::Alias aliasPrv = "ecprv_nohash1";
2242     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2243     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2244     CKM::RawBuffer signature;
2245
2246     RUNNER_ASSERT_MSG(
2247             CKM_API_SUCCESS == (temp = manager->createSignature(
2248                                         aliasPrv,
2249                                         CKM::Password(),
2250                                         CKM::RawBuffer(message.begin(), message.end()),
2251                                         hash,
2252                                         padd,
2253                                         signature)),
2254         "Error=" << CKM::ErrorToString(temp));
2255 }
2256
2257
2258 RUNNER_TEST(T14189_deinit)
2259 {
2260     int temp;
2261     auto control = CKM::Control::create();
2262
2263     RUNNER_ASSERT_MSG(
2264         CKM_API_SUCCESS == (temp = control->lockUserKey(0)),
2265         "Error=" << CKM::ErrorToString(temp));
2266     RUNNER_ASSERT_MSG(
2267         CKM_API_SUCCESS == (temp = control->removeUserData(0)),
2268         "Error=" << CKM::ErrorToString(temp));
2269 }
2270
2271
2272 RUNNER_TEST_GROUP_INIT(T151_CKM_STORAGE_PERNAMENT_TESTS);
2273
2274 RUNNER_CHILD_TEST(T1510_init_unlock_key)
2275 {
2276     int tmp;
2277     AccessProvider ap("my-label");
2278     ap.allowAPI("key-manager::api-control", "rw");
2279     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2280
2281     auto control = CKM::Control::create();
2282     RUNNER_ASSERT_MSG(
2283         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST, "strong-password")),
2284         "Error=" << CKM::ErrorToString(tmp));
2285 }
2286
2287 RUNNER_CHILD_TEST(T1511_init_insert_data)
2288 {
2289     AccessProvider ap("my-label");
2290     ap.allowAPI("key-manager::api-storage", "rw");
2291     ap.applyAndSwithToUser(USER_TEST, GROUP_APP);
2292
2293     std::string ee = "-----BEGIN CERTIFICATE-----\n"
2294       "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2295       "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2296       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2297       "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2298       "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2299       "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2300       "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2301       "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2302       "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2303       "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2304       "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2305       "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2306       "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2307       "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2308       "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2309       "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2310       "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2311       "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2312       "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2313       "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2314       "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2315       "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2316       "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2317       "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2318       "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2319       "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2320       "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2321       "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2322       "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2323       "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2324       "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2325       "oFXtrg0=\n"
2326       "-----END CERTIFICATE-----\n";
2327
2328     std::string im =
2329       "-----BEGIN CERTIFICATE-----\n"
2330       "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
2331       "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2332       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
2333       "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
2334       "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
2335       "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
2336       "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
2337       "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
2338       "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
2339       "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
2340       "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
2341       "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
2342       "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
2343       "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
2344       "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
2345       "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
2346       "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
2347       "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
2348       "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
2349       "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
2350       "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
2351       "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
2352       "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
2353       "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
2354       "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
2355       "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
2356       "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
2357       "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
2358       "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
2359       "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
2360       "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
2361       "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
2362       "-----END CERTIFICATE-----\n";
2363
2364     auto manager = CKM::Manager::create();
2365     auto certee = CKM::Certificate::create(CKM::RawBuffer(ee.begin(), ee.end()), CKM::DataFormat::FORM_PEM);
2366     auto certim = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
2367
2368     int status1 = manager->saveCertificate(CKM::Alias("CertEE"), certee, CKM::Policy());
2369     int status2 = manager->saveCertificate(CKM::Alias("CertIM"), certim, CKM::Policy());
2370
2371     RUNNER_ASSERT_MSG(
2372         CKM_API_ERROR_DB_ALIAS_EXISTS == status1,
2373         "Certificate should be in database already. Error=" << CKM::ErrorToString(status1));
2374
2375     RUNNER_ASSERT_MSG(
2376         CKM_API_ERROR_DB_ALIAS_EXISTS == status2,
2377         "Certificate should be in database already. Error=" << CKM::ErrorToString(status2));
2378 }
2379
2380 RUNNER_CHILD_TEST(T1519_deinit)
2381 {
2382     int tmp;
2383     AccessProvider ap("my-label");
2384     ap.allowAPI("key-manager::api-control", "rw");
2385     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2386
2387     auto control = CKM::Control::create();
2388     RUNNER_ASSERT_MSG(
2389         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST)),
2390         "Error=" << CKM::ErrorToString(tmp));
2391 }
2392
2393
2394 RUNNER_TEST_GROUP_INIT(T161_CKM_LOCKTYPE_TESTS);
2395
2396 RUNNER_CHILD_TEST(T1610_init_lock_key)
2397 {
2398     int tmp;
2399     AccessProvider ap("my-label");
2400     ap.allowAPI("key-manager::api-control", "rw");
2401     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2402
2403     auto control = CKM::Control::create();
2404     RUNNER_ASSERT_MSG(
2405         CKM_API_SUCCESS == (tmp = control->changeUserPassword(USER_APP,"user-pass","")),
2406         "Error=" << CKM::ErrorToString(tmp));
2407     RUNNER_ASSERT_MSG(
2408         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2409         "Error=" << CKM::ErrorToString(tmp));
2410 }
2411
2412 RUNNER_CHILD_TEST(T1611_unlock_default_passwd)
2413 {
2414     AccessProvider ap("my-label");
2415     ap.allowAPI("key-manager::api-storage", "rw");
2416     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2417
2418     int temp;
2419     auto manager = CKM::Manager::create();
2420
2421     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2422         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2423         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2424         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2425         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2426         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2427         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2428         "zQIDAQAB\n"
2429         "-----END PUBLIC KEY-----";
2430
2431     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
2432     auto key = CKM::Key::create(buffer, CKM::Password());
2433     CKM::KeyShPtr key2;
2434     CKM::Alias alias = "mykey_defpasswd";
2435
2436     RUNNER_ASSERT_MSG(
2437         CKM_API_SUCCESS == (temp = manager->saveKey(alias, key, CKM::Policy())),
2438         "Error=" << CKM::ErrorToString(temp));
2439     RUNNER_ASSERT_MSG(
2440         CKM_API_SUCCESS == (temp = manager->getKey(alias, CKM::Password(), key2)),
2441         "Error=" << CKM::ErrorToString(temp));
2442     RUNNER_ASSERT_MSG(
2443         key->getDER() == key2->getDER(),
2444         "Key value has been changed by service");
2445     RUNNER_ASSERT_MSG(
2446             CKM_API_SUCCESS == (temp = manager->removeKey(alias)),
2447             "Error=" << CKM::ErrorToString(temp));
2448 }
2449
2450 RUNNER_CHILD_TEST(T1612_init_change_user_password)
2451 {
2452     int tmp;
2453     AccessProvider ap("my-label");
2454     ap.allowAPI("key-manager::api-control", "rw");
2455     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2456
2457     auto control = CKM::Control::create();
2458     RUNNER_ASSERT_MSG(
2459         CKM_API_SUCCESS == (tmp = control->changeUserPassword(USER_APP,"","user-pass")),
2460         "Error=" << CKM::ErrorToString(tmp));
2461     RUNNER_ASSERT_MSG(
2462         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2463         "Error=" << CKM::ErrorToString(tmp));
2464 }
2465
2466 RUNNER_CHILD_TEST(T1613_unlock_default_passwd_negative)
2467 {
2468     AccessProvider ap("my-label");
2469     ap.allowAPI("key-manager::api-storage", "rw");
2470     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2471
2472     int temp;
2473     auto manager = CKM::Manager::create();
2474
2475     std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2476         "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2477         "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2478         "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2479         "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2480         "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2481         "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2482         "zQIDAQAB\n"
2483         "-----END PUBLIC KEY-----";
2484
2485     CKM::RawBuffer buffer(keyPem.begin(), keyPem.end());
2486     auto key = CKM::Key::create(buffer, CKM::Password());
2487     CKM::KeyShPtr key2;
2488     CKM::Alias alias = "mykey_defpasswd";
2489
2490     RUNNER_ASSERT_MSG(
2491         CKM_API_ERROR_DB_LOCKED == (temp = manager->saveKey(alias, key, CKM::Policy())),
2492         "Error=" << CKM::ErrorToString(temp));
2493     RUNNER_ASSERT_MSG(
2494         CKM_API_ERROR_DB_LOCKED == (temp = manager->getKey(alias, CKM::Password(), key2)),
2495         "Error=" << CKM::ErrorToString(temp));
2496     RUNNER_ASSERT_MSG(
2497         CKM_API_ERROR_DB_LOCKED == (temp = manager->removeKey(alias)),
2498         "Error=" << CKM::ErrorToString(temp));
2499 }
2500
2501 RUNNER_CHILD_TEST(T1619_deinit)
2502 {
2503     AccessProvider ap("my-label");
2504     ap.allowAPI("key-manager::api-control", "rw");
2505     ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2506 }
2507
2508 RUNNER_TEST_GROUP_INIT(T170_CKM_STORAGE_PERNAMENT_TESTS);
2509
2510 RUNNER_TEST(T1701_init_unlock_key)
2511 {
2512     int tmp;
2513     auto control = CKM::Control::create();
2514     RUNNER_ASSERT_MSG(
2515         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+1, "t170-special-password")),
2516         "Error=" << CKM::ErrorToString(tmp));
2517 }
2518
2519 RUNNER_CHILD_TEST(T1702_init_insert_data)
2520 {
2521     int temp;
2522     AccessProvider ap("t170-special-label");
2523     ap.allowAPI("key-manager::api-storage", "rw");
2524     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2525
2526     std::string ee = "-----BEGIN CERTIFICATE-----\n"
2527       "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2528       "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2529       "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2530       "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2531       "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2532       "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2533       "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2534       "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2535       "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2536       "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2537       "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2538       "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2539       "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2540       "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2541       "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2542       "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2543       "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2544       "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2545       "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2546       "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2547       "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2548       "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2549       "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2550       "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2551       "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2552       "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2553       "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2554       "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2555       "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2556       "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2557       "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2558       "oFXtrg0=\n"
2559       "-----END CERTIFICATE-----\n";
2560
2561     auto manager = CKM::Manager::create();
2562     auto certee = CKM::Certificate::create(CKM::RawBuffer(ee.begin(), ee.end()), CKM::DataFormat::FORM_PEM);
2563
2564     int status1 = manager->saveCertificate(CKM::Alias("CertEEE"), certee, CKM::Policy());
2565
2566     RUNNER_ASSERT_MSG(
2567         CKM_API_SUCCESS == status1,
2568         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
2569
2570     CKM::AliasVector av;
2571
2572     RUNNER_ASSERT_MSG(
2573         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2574         "Error=" << CKM::ErrorToString(temp));
2575     RUNNER_ASSERT_MSG(
2576         1 == (temp = av.size()),
2577         "Vector size: " << temp << ". Expected: 1");
2578 }
2579
2580 RUNNER_TEST(T1703_removeApplicationData)
2581 {
2582     int tmp;
2583     auto control = CKM::Control::create();
2584     RUNNER_ASSERT_MSG(
2585         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t170-special-label")),
2586         "Error=" << CKM::ErrorToString(tmp));
2587 }
2588
2589 RUNNER_CHILD_TEST(T1704_data_test)
2590 {
2591     int temp;
2592     AccessProvider ap("t170-special-label");
2593     ap.allowAPI("key-manager::api-storage", "rw");
2594     ap.applyAndSwithToUser(USER_TEST+1, GROUP_APP);
2595
2596     CKM::AliasVector av;
2597     auto manager = CKM::Manager::create();
2598
2599     RUNNER_ASSERT_MSG(
2600         CKM_API_SUCCESS == (temp = manager->getCertificateAliasVector(av)),
2601         "Error=" << CKM::ErrorToString(temp));
2602     RUNNER_ASSERT_MSG(
2603         0 == (temp = av.size()),
2604         "Vector size: " << temp << ". Expected: 0");
2605 }
2606
2607 RUNNER_TEST(T1705_deinit)
2608 {
2609     int tmp;
2610
2611     auto control = CKM::Control::create();
2612     RUNNER_ASSERT_MSG(
2613         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+1)),
2614         "Error=" << CKM::ErrorToString(tmp));
2615     RUNNER_ASSERT_MSG(
2616         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+1)),
2617         "Error=" << CKM::ErrorToString(tmp));
2618 }
2619
2620 RUNNER_TEST(T17101_init)
2621 {
2622     int tmp;
2623
2624     auto control = CKM::Control::create();
2625     RUNNER_ASSERT_MSG(
2626         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
2627         "Error=" << CKM::ErrorToString(tmp));
2628     RUNNER_ASSERT_MSG(
2629         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
2630         "Error=" << CKM::ErrorToString(tmp));
2631     RUNNER_ASSERT_MSG(
2632         CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+2, "t1706-special-password")),
2633         "Error=" << CKM::ErrorToString(tmp));
2634
2635     RUNNER_ASSERT_MSG(
2636         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2637         "Error=" << CKM::ErrorToString(tmp));
2638     RUNNER_ASSERT_MSG(
2639         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
2640         "Error=" << CKM::ErrorToString(tmp));
2641     RUNNER_ASSERT_MSG(
2642          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
2643          "Error=" << CKM::ErrorToString(tmp));
2644 }
2645
2646 RUNNER_CHILD_TEST(T17102_prep_data_01)
2647 {
2648     int temp;
2649     AccessProvider ap("t1706-special-label");
2650     ap.allowAPI("key-manager::api-storage", "rw");
2651     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2652
2653     CKM::AliasVector av;
2654     auto manager = CKM::Manager::create();
2655
2656     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2657
2658     CKM::RawBuffer buffer(data.begin(), data.end());
2659     CKM::Policy exportable(CKM::Password(), true);
2660
2661     RUNNER_ASSERT_MSG(
2662         CKM_API_SUCCESS == (temp = manager->saveData("data1", buffer, exportable)),
2663         "Error=" << CKM::ErrorToString(temp));
2664 }
2665
2666 RUNNER_CHILD_TEST(T17103_prep_data_02)
2667 {
2668     int temp;
2669     AccessProvider ap("t1706-special-label2");
2670     ap.allowAPI("key-manager::api-storage", "rw");
2671     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2672
2673     CKM::AliasVector av;
2674     auto manager = CKM::Manager::create();
2675
2676     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2677
2678     CKM::RawBuffer buffer(data.begin(), data.end());
2679     CKM::Policy exportable(CKM::Password(), true);
2680
2681     RUNNER_ASSERT_MSG(
2682         CKM_API_SUCCESS == (temp = manager->saveData("data2", buffer, exportable)),
2683         "Error=" << CKM::ErrorToString(temp));
2684 }
2685
2686 RUNNER_CHILD_TEST(T17104_prep_data_03)
2687 {
2688     int temp;
2689     AccessProvider ap("t1706-special-label");
2690     ap.allowAPI("key-manager::api-storage", "rw");
2691     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2692
2693     CKM::AliasVector av;
2694     auto manager = CKM::Manager::create();
2695
2696     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2697
2698     CKM::RawBuffer buffer(data.begin(), data.end());
2699     CKM::Policy exportable(CKM::Password(), true);
2700
2701     RUNNER_ASSERT_MSG(
2702         CKM_API_SUCCESS == (temp = manager->saveData("data3", buffer, exportable)),
2703         "Error=" << CKM::ErrorToString(temp));
2704 }
2705
2706 RUNNER_CHILD_TEST(T17105_prep_data_04)
2707 {
2708     int temp;
2709     AccessProvider ap("t1706-special-label2");
2710     ap.allowAPI("key-manager::api-storage", "rw");
2711     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2712
2713     CKM::AliasVector av;
2714     auto manager = CKM::Manager::create();
2715
2716     std::string data = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4";
2717
2718     CKM::RawBuffer buffer(data.begin(), data.end());
2719     CKM::Policy exportable(CKM::Password(), true);
2720
2721     RUNNER_ASSERT_MSG(
2722         CKM_API_SUCCESS == (temp = manager->saveData("data4", buffer, exportable)),
2723         "Error=" << CKM::ErrorToString(temp));
2724 }
2725
2726 RUNNER_TEST(T17106_remove_application)
2727 {
2728     int tmp;
2729
2730     auto control = CKM::Control::create();
2731     RUNNER_ASSERT_MSG(
2732         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2733         "Error=" << CKM::ErrorToString(tmp));
2734     RUNNER_ASSERT_MSG(
2735         CKM_API_SUCCESS == (tmp = control->removeApplicationData("t1706-special-label")),
2736         "Error=" << CKM::ErrorToString(tmp));
2737 }
2738
2739 RUNNER_CHILD_TEST(T17107_check_data_01)
2740 {
2741     int temp;
2742     AccessProvider ap("t1706-special-label");
2743     ap.allowAPI("key-manager::api-storage", "rw");
2744     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2745
2746     CKM::AliasVector av;
2747     auto manager = CKM::Manager::create();
2748
2749     RUNNER_ASSERT_MSG(
2750         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2751         "Error=" << CKM::ErrorToString(temp));
2752     RUNNER_ASSERT_MSG(
2753         0 == (temp = av.size()),
2754         "Vector size: " << temp << ". Expected: 0");
2755 }
2756
2757 RUNNER_CHILD_TEST(T17108_check_data_02)
2758 {
2759     int temp;
2760     AccessProvider ap("t1706-special-label2");
2761     ap.allowAPI("key-manager::api-storage", "rw");
2762     ap.applyAndSwithToUser(USER_TEST+2, GROUP_APP);
2763
2764     CKM::AliasVector av;
2765     auto manager = CKM::Manager::create();
2766
2767     RUNNER_ASSERT_MSG(
2768         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2769         "Error=" << CKM::ErrorToString(temp));
2770     RUNNER_ASSERT_MSG(
2771         1 == (temp = av.size()),
2772         "Vector size: " << temp << ". Expected: 1");
2773 }
2774
2775 RUNNER_TEST(T17109_unlock_user2)
2776 {
2777     int tmp;
2778
2779     auto control = CKM::Control::create();
2780     RUNNER_ASSERT_MSG(
2781          CKM_API_SUCCESS == (tmp = control->unlockUserKey(USER_TEST+3, "t1706-special-password")),
2782          "Error=" << CKM::ErrorToString(tmp));
2783 }
2784
2785 RUNNER_CHILD_TEST(T17110_check_data_03)
2786 {
2787     int temp;
2788     AccessProvider ap("t1706-special-label");
2789     ap.allowAPI("key-manager::api-storage", "rw");
2790     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2791
2792     CKM::AliasVector av;
2793     auto manager = CKM::Manager::create();
2794
2795     RUNNER_ASSERT_MSG(
2796         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2797         "Error=" << CKM::ErrorToString(temp));
2798     RUNNER_ASSERT_MSG(
2799         0 == (temp = av.size()),
2800         "Vector size: " << temp << ". Expected: 0");
2801 }
2802
2803 RUNNER_CHILD_TEST(T17111_check_data_04)
2804 {
2805     int temp;
2806     AccessProvider ap("t1706-special-label2");
2807     ap.allowAPI("key-manager::api-storage", "rw");
2808     ap.applyAndSwithToUser(USER_TEST+3, GROUP_APP);
2809
2810     CKM::AliasVector av;
2811     auto manager = CKM::Manager::create();
2812
2813     RUNNER_ASSERT_MSG(
2814         CKM_API_SUCCESS == (temp = manager->getDataAliasVector(av)),
2815         "Error=" << CKM::ErrorToString(temp));
2816     RUNNER_ASSERT_MSG(
2817         1 == (temp = av.size()),
2818         "Vector size: " << temp << ". Expected: 1");
2819 }
2820
2821 RUNNER_TEST(T17112_deinit)
2822 {
2823     int tmp;
2824
2825     auto control = CKM::Control::create();
2826     RUNNER_ASSERT_MSG(
2827         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+2)),
2828         "Error=" << CKM::ErrorToString(tmp));
2829     RUNNER_ASSERT_MSG(
2830         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+2)),
2831         "Error=" << CKM::ErrorToString(tmp));
2832
2833     RUNNER_ASSERT_MSG(
2834         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_TEST+3)),
2835         "Error=" << CKM::ErrorToString(tmp));
2836     RUNNER_ASSERT_MSG(
2837         CKM_API_SUCCESS == (tmp = control->removeUserData(USER_TEST+3)),
2838         "Error=" << CKM::ErrorToString(tmp));
2839 }
2840
2841 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
2842
2843 RUNNER_TEST(T1801) {
2844     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2845     std::istreambuf_iterator<char> begin(is), end;
2846     std::vector<char> buff(begin, end);
2847
2848     CKM::RawBuffer buffer(buff.size());
2849     memcpy(buffer.data(), buff.data(), buff.size());
2850
2851     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2852     RUNNER_ASSERT_MSG(
2853         NULL != pkcs.get(),
2854         "Error in PKCS12::create()");
2855
2856     auto cert = pkcs->getCertificate();
2857     RUNNER_ASSERT_MSG(
2858         NULL != cert.get(),
2859         "Error in PKCS12::getCertificate()");
2860
2861     auto key = pkcs->getKey();
2862     RUNNER_ASSERT_MSG(
2863         NULL != key.get(),
2864         "Error in PKCS12::getKey()");
2865
2866     auto caVector = pkcs->getCaCertificateShPtrVector();
2867     RUNNER_ASSERT_MSG(
2868         0 == caVector.size(),
2869         "Wrong size of vector");
2870 }
2871
2872 RUNNER_TEST(T1802_negative_wrong_password) {
2873     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2874     std::istreambuf_iterator<char> begin(is), end;
2875     std::vector<char> buff(begin, end);
2876
2877     CKM::RawBuffer buffer(buff.size());
2878     memcpy(buffer.data(), buff.data(), buff.size());
2879
2880     auto pkcs = CKM::PKCS12::create(buffer, "error");
2881     RUNNER_ASSERT_MSG(
2882         NULL == pkcs.get(),
2883         "Expected error in PKCS12::create()");
2884 }
2885
2886 RUNNER_TEST(T1803_negative_broken_buffer) {
2887     std::ifstream is("/usr/share/ckm-test/test1801.pkcs12");
2888     std::istreambuf_iterator<char> begin(is), end;
2889     std::vector<char> buff(begin, end);
2890
2891     CKM::RawBuffer buffer(buff.size());
2892     memcpy(buffer.data(), buff.data(), buff.size());
2893
2894     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
2895     buffer[4]=0;
2896
2897     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2898     RUNNER_ASSERT_MSG(
2899         NULL == pkcs.get(),
2900         "Expected error in PKCS12::create()");
2901 }
2902
2903 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
2904
2905 RUNNER_TEST(T1901_init_unlock_key)
2906 {
2907     int tmp;
2908     auto control = CKM::Control::create();
2909     RUNNER_ASSERT_MSG(
2910         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
2911         "Error=" << CKM::ErrorToString(tmp));
2912     RUNNER_ASSERT_MSG(
2913         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
2914         "Error=" << CKM::ErrorToString(tmp));
2915     RUNNER_ASSERT_MSG(
2916         CKM_API_SUCCESS == (tmp = control->unlockUserKey(0, "t190-special-password")),
2917         "Error=" << CKM::ErrorToString(tmp));
2918 }
2919
2920 RUNNER_TEST(T1902_get_data)
2921 {
2922     auto manager = CKM::Manager::create();
2923     CKM::KeyShPtr ptr;
2924
2925     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2926
2927     RUNNER_ASSERT_MSG(
2928         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
2929         "Could not put certificate in datbase. Error=" << CKM::ErrorToString(status1));
2930 }
2931
2932 RUNNER_TEST(T1903_lock_database)
2933 {
2934     int tmp;
2935     auto control = CKM::Control::create();
2936     RUNNER_ASSERT_MSG(
2937         CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
2938         "Error=" << CKM::ErrorToString(tmp));
2939 }
2940
2941 RUNNER_TEST(T1904_get_data_from_locked_database)
2942 {
2943     auto manager = CKM::Manager::create();
2944     CKM::KeyShPtr ptr;
2945
2946     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2947
2948     RUNNER_ASSERT_MSG(
2949         CKM_API_ERROR_DB_LOCKED == status1,
2950         "Could not get key from locked database. Error=" << CKM::ErrorToString(status1));
2951 }
2952
2953 RUNNER_TEST(T1905_deinit)
2954 {
2955     int tmp;
2956     auto control = CKM::Control::create();
2957     RUNNER_ASSERT_MSG(
2958         CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
2959         "Error=" << CKM::ErrorToString(tmp));
2960 }
2961
2962 RUNNER_TEST_GROUP_INIT (T200_CKM_CC_MODE_TESTS); // this test group is only for non-cc certified device
2963 /*  sequence
2964  *  default status : no event callback registered. // vconftool unset file/security_mdpp/security_mdpp_state
2965  *   - `ps axf | grep key-manager-listener | grep -v grep | awk '{print "kill -9 " $1}'`
2966  *   - vconftool unset file/security_mdpp/security_mdpp_state
2967  *   - /usr/bin/key-manager-listener
2968
2969  *   - Create RSA key // createKeyPairRSA
2970  *   - try to get private key -> must be success // getKey
2971  *   - vconftool set -t string file/security_mdpp/security_mdpp_state "Enabled"
2972  *   - try to get private key : must be success because no callback registered. // getKey
2973  *
2974  *  new status : event callback registered. // unset mdpp_state vconf key and reset mdpp state vconf key
2975  *   - `ps axf | grep key-manager-listener | grep -v grep | awk '{print "kill -9 " $1}'`
2976  *   - vconftool set -t string file/security_mdpp/security_mdpp_state "Disabled" -f
2977  *   - /usr/bin/key-manager-listener
2978  *   - Create RSA key // createKeyPairRSA
2979  *   - try to get private key -> must be success // getKey
2980  *   - vconftool set -t string file/security_mdpp/security_mdpp_state "Enabled" -f
2981  *   - try to get private key -> must be fail because cc mode is set to 1
2982  */
2983
2984 RUNNER_TEST(T2001_init_cc_mode_tests)
2985 {
2986     system("`ps axf | grep key-manager-listener | grep -v grep | awk '{print \"kill -9 \" $1}'`");
2987     system("vconftool unset file/security_mdpp/security_mdpp_state");
2988     system("/usr/bin/key-manager-listener");
2989
2990     int tmp;
2991     auto control = CKM::Control::create();
2992         RUNNER_ASSERT_MSG( CKM_API_SUCCESS == (tmp = control->setCCMode(CKM::CCModeState::CC_MODE_OFF)), // default state : cc mode off
2993         "Error=" << CKM::ErrorToString(tmp));
2994     RUNNER_ASSERT_MSG( CKM_API_SUCCESS == (tmp = control->lockUserKey(0)),
2995         "Error=" << CKM::ErrorToString(tmp));
2996     RUNNER_ASSERT_MSG( CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
2997         "Error=" << CKM::ErrorToString(tmp));
2998     RUNNER_ASSERT_MSG(
2999         CKM_API_SUCCESS == (tmp = control->unlockUserKey(0, "t200-special-password")),
3000         "Error=" << CKM::ErrorToString(tmp));
3001     system("");
3002 }
3003
3004 RUNNER_TEST(T2002_CC_Mode_Changed_Event_Callback_Not_Registered)
3005 {
3006     int temp;
3007     auto manager = CKM::Manager::create();
3008     CKM::Alias rsa_pri_alias("rsa-private-T2002");
3009     CKM::Alias rsa_pub_alias("rsa-public-T2002");
3010     CKM::Alias ecdsa_pri_alias("ecdsa-private-T2002");
3011     CKM::Alias ecdsa_pub_alias("ecdsa-public-T2002");
3012
3013     RUNNER_ASSERT_MSG(
3014         CKM_API_SUCCESS == (temp = manager->createKeyPairRSA(
3015                 1024,
3016                 rsa_pri_alias,
3017                 rsa_pub_alias,
3018                 CKM::Policy(CKM::Password(), true),
3019                 CKM::Policy(CKM::Password(), true))),
3020             "Error=" << CKM::ErrorToString(temp));
3021
3022     RUNNER_ASSERT_MSG(
3023         CKM_API_SUCCESS == (temp = manager->createKeyPairECDSA(
3024                 CKM::ElipticCurve::prime192v1,
3025                 ecdsa_pri_alias,
3026                 ecdsa_pub_alias,
3027                 CKM::Policy(CKM::Password(), true),
3028                 CKM::Policy(CKM::Password(), true))),
3029             "Error=" << CKM::ErrorToString(temp));
3030
3031     CKM::KeyShPtr key1;
3032
3033     RUNNER_ASSERT_MSG(
3034         CKM_API_SUCCESS == (temp = manager->getKey(
3035                 rsa_pri_alias,
3036                 CKM::Password(),
3037                 key1)),
3038             "Error=" << CKM::ErrorToString(temp));
3039
3040     RUNNER_ASSERT_MSG(
3041         CKM_API_SUCCESS == (temp = manager->getKey(
3042                 ecdsa_pri_alias,
3043                 CKM::Password(),
3044                 key1)),
3045             "Error=" << CKM::ErrorToString(temp));
3046
3047     system("vconftool set -t string file/security_mdpp/security_mdpp_state \"Enabled\"");
3048
3049     RUNNER_ASSERT_MSG(
3050         CKM_API_SUCCESS == (temp = manager->getKey(
3051                 rsa_pri_alias,
3052                 CKM::Password(),
3053                 key1)),
3054             "Error=" << CKM::ErrorToString(temp));
3055
3056     RUNNER_ASSERT_MSG(
3057         CKM_API_SUCCESS == (temp = manager->getKey(
3058                 ecdsa_pri_alias,
3059                 CKM::Password(),
3060                 key1)),
3061             "Error=" << CKM::ErrorToString(temp));
3062 }
3063
3064 RUNNER_TEST(T2003_CC_Mode_Changed_Event_Callback_Registered)
3065 {
3066     system("`ps axf | grep key-manager-listener | grep -v grep | awk '{print \"kill -9 \" $1}'`");
3067     system("vconftool set -t string file/security_mdpp/security_mdpp_state \"Disabled\" -f");
3068     system("/usr/bin/key-manager-listener");
3069
3070     int temp;
3071     auto manager = CKM::Manager::create();
3072     CKM::Alias rsa_pri_alias("rsa-private-T2003");
3073     CKM::Alias rsa_pub_alias("rsa-public-T2003");
3074     CKM::Alias ecdsa_pri_alias("ecdsa-private-T2003");
3075     CKM::Alias ecdsa_pub_alias("ecdsa-public-T2003");
3076
3077     RUNNER_ASSERT_MSG(
3078         CKM_API_SUCCESS == (temp = manager->createKeyPairRSA(
3079                 1024,
3080                 rsa_pri_alias,
3081                 rsa_pub_alias,
3082                 CKM::Policy(CKM::Password(), true),
3083                 CKM::Policy(CKM::Password(), true))),
3084             "Error=" << CKM::ErrorToString(temp));
3085
3086     RUNNER_ASSERT_MSG(
3087         CKM_API_SUCCESS == (temp = manager->createKeyPairECDSA(
3088                 CKM::ElipticCurve::prime192v1,
3089                 ecdsa_pri_alias,
3090                 ecdsa_pub_alias,
3091                 CKM::Policy(CKM::Password(), true),
3092                 CKM::Policy(CKM::Password(), true))),
3093             "Error=" << CKM::ErrorToString(temp));
3094
3095     CKM::KeyShPtr key1;
3096
3097     RUNNER_ASSERT_MSG(
3098         CKM_API_SUCCESS == (temp = manager->getKey(
3099                 rsa_pri_alias,
3100                 CKM::Password(),
3101                 key1)),
3102             "Error=" << CKM::ErrorToString(temp));
3103
3104     RUNNER_ASSERT_MSG(
3105         CKM_API_SUCCESS == (temp = manager->getKey(
3106                 ecdsa_pri_alias,
3107                 CKM::Password(),
3108                 key1)),
3109             "Error=" << CKM::ErrorToString(temp));
3110
3111     system("vconftool set -t string file/security_mdpp/security_mdpp_state \"Enabled\" -f");
3112
3113     RUNNER_ASSERT_MSG(
3114         CKM_API_ERROR_BAD_REQUEST == (temp = manager->getKey(
3115                 rsa_pri_alias,
3116                 CKM::Password(),
3117                 key1)),
3118             "Error=" << CKM::ErrorToString(temp));
3119
3120     RUNNER_ASSERT_MSG(
3121         CKM_API_ERROR_BAD_REQUEST == (temp = manager->getKey(
3122                 ecdsa_pri_alias,
3123                 CKM::Password(),
3124                 key1)),
3125             "Error=" << CKM::ErrorToString(temp));
3126 }
3127
3128 RUNNER_TEST(T2004_deinit)
3129 {
3130     int tmp;
3131     auto control = CKM::Control::create();
3132     RUNNER_ASSERT_MSG( CKM_API_SUCCESS == (tmp = control->removeUserData(0)),
3133         "Error=" << CKM::ErrorToString(tmp));
3134     RUNNER_ASSERT_MSG( CKM_API_SUCCESS == (tmp = control->setCCMode(CKM::CCModeState::CC_MODE_OFF)), // default state : cc mode off
3135         "Error=" << CKM::ErrorToString(tmp));
3136     system("`ps axf | grep key-manager-listener | grep -v grep | awk '{print \"kill -9 \" $1}'`");
3137     system("vconftool unset file/security_mdpp/security_mdpp_state");
3138     system("/usr/bin/key-manager-listener");
3139 }
3140
3141 int main(int argc, char *argv[])
3142 {
3143     DPL::Log::LogSystemSingleton::Instance().SetTag("CKM_TESTS");
3144     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
3145 }