src/ckm/unprivileged/main.cpp

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