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::GIAG2);
 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::GIAG2);
 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::GIAG2);
 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::MBANK);
1117     auto cert1 = TestData::getTestCertificate(TestData::SYMANTEC);
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::MBANK);
1151     auto cert1 = TestData::getTestCertificate(TestData::SYMANTEC);
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::MBANK);
1188     auto cert1 = TestData::getTestCertificate(TestData::SYMANTEC);
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::EQUIFAX);
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::EQUIFAX);
1269     auto ca2 = TestData::getTestCertificate(TestData::GEOTRUST);
1270     auto ca1 = TestData::getTestCertificate(TestData::GIAG2);
1271
1272     CKM::CertificateShPtrVector certVector = {ca1, ca2, root};
1273
1274     auto manager = CKM::Manager::create();
1275
1276     RUNNER_ASSERT_MSG(NULL != root.get(), "Certificate should not be empty");
1277     RUNNER_ASSERT_MSG(NULL != ca2.get(), "Certificate should not be empty");
1278     RUNNER_ASSERT_MSG(NULL != ca1.get(), "Certificate should not be empty");
1279
1280     int tmp;
1281     int status;
1282     RUNNER_ASSERT_MSG(
1283         CKM_API_SUCCESS == (tmp = manager->ocspCheck(certVector, status)),
1284         "Error=" << CKMErrorToString(tmp));
1285
1286     RUNNER_ASSERT_MSG(CKM_API_OCSP_STATUS_UNSUPPORTED == status, "Verfication failed");
1287 }
1288
1289 RUNNER_TEST(T1315_deinit)
1290 {
1291     remove_user_data(USER_APP);
1292 }
1293
1294 RUNNER_TEST_GROUP_INIT(T141_CREATE_AND_VERIFY_SIGNATURE);
1295
1296 RUNNER_TEST(T1411_init)
1297 {
1298     remove_user_data(USER_APP);
1299 }
1300
1301 RUNNER_TEST(T1412_RSA_key_create_verify)
1302 {
1303     int temp;
1304     auto manager = CKM::Manager::create();
1305
1306     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1307       "Proc-Type: 4,ENCRYPTED\n"
1308       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1309       "\n"
1310       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1311       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1312       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1313       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1314       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1315       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1316       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1317       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1318       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1319       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1320       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1321       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1322       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1323       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1324       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1325       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1326       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1327       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1328       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1329       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1330       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1331       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1332       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1333       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1334       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1335       "-----END RSA PRIVATE KEY-----\n";
1336
1337     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1338       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1339       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1340       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1341       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1342       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1343       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1344       "zQIDAQAB\n"
1345       "-----END PUBLIC KEY-----\n";
1346
1347     std::string message = "message test";
1348
1349     CKM::Alias aliasPub = "pub1";
1350     CKM::Alias aliasPrv = "prv1";
1351     CKM::Password password = "1234";
1352     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1353     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1354     CKM::RawBuffer signature;
1355
1356     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1357     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
1358
1359     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1360         "Key is empty. Failed to import public key.");
1361     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1362         "Key is empty. Failed to import private key.");
1363
1364     RUNNER_ASSERT_MSG(
1365         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1366         "Error=" << CKMErrorToString(temp));
1367     RUNNER_ASSERT_MSG(
1368         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1369         "Error=" << CKMErrorToString(temp));
1370
1371     RUNNER_ASSERT_MSG(
1372         CKM_API_SUCCESS == (temp = manager->createSignature(
1373                                         aliasPrv,
1374                                         CKM::Password(),
1375                                         CKM::RawBuffer(message.begin(), message.end()),
1376                                         hash,
1377                                         padd,
1378                                         signature)),
1379         "Error=" << CKMErrorToString(temp));
1380
1381     RUNNER_ASSERT_MSG(
1382         CKM_API_SUCCESS == (temp = manager->verifySignature(
1383                                         aliasPub,
1384                                         CKM::Password(),
1385                                         CKM::RawBuffer(message.begin(), message.end()),
1386                                         signature,
1387                                         hash,
1388                                         padd)),
1389         "Error=" << CKMErrorToString(temp));
1390 }
1391
1392 RUNNER_TEST(T1413_DSA_key_create_verify)
1393 {
1394     int temp;
1395     auto manager = CKM::Manager::create();
1396
1397     std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1398             "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1399             "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1400             "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1401             "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1402             "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1403             "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1404             "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1405             "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1406             "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1407             "u1roOuaPY+Hl19BlTE2qdw==\n"
1408             "-----END DSA PRIVATE KEY-----";
1409
1410     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1411             "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1412             "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1413             "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1414             "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1415             "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1416             "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1417             "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1418             "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1419             "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1420             "YMYCBhubtrVaLmc=\n"
1421             "-----END PUBLIC KEY-----";
1422
1423     std::string message = "message test";
1424
1425     CKM::Alias aliasPub = "pub2";
1426     CKM::Alias aliasPrv = "prv2";
1427     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1428     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1429     CKM::RawBuffer signature;
1430
1431     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1432     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
1433
1434     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1435         "Key is empty. Failed to import public key.");
1436     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1437         "Key is empty. Failed to import private key.");
1438
1439     RUNNER_ASSERT_MSG(
1440         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1441         "Error=" << CKMErrorToString(temp));
1442     RUNNER_ASSERT_MSG(
1443         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1444         "Error=" << CKMErrorToString(temp));
1445
1446     RUNNER_ASSERT_MSG(
1447         CKM_API_SUCCESS == (temp = manager->createSignature(
1448                                         aliasPrv,
1449                                         CKM::Password(),
1450                                         CKM::RawBuffer(message.begin(), message.end()),
1451                                         hash,
1452                                         padd,
1453                                         signature)),
1454         "Error=" << CKMErrorToString(temp));
1455
1456     RUNNER_ASSERT_MSG(
1457         CKM_API_SUCCESS == (temp = manager->verifySignature(
1458                                         aliasPub,
1459                                         CKM::Password(),
1460                                         CKM::RawBuffer(message.begin(), message.end()),
1461                                         signature,
1462                                         hash,
1463                                         padd)),
1464         "Error=" << CKMErrorToString(temp));
1465 }
1466
1467
1468 RUNNER_TEST(T1414_ECDSA_key_create_verify)
1469 {
1470     int temp;
1471     auto manager = CKM::Manager::create();
1472
1473     std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1474         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1475         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1476         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1477         "-----END EC PRIVATE KEY-----\n";
1478
1479     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1480         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1481         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1482         "-----END PUBLIC KEY-----\n";
1483
1484     std::string message = "message test";
1485
1486     CKM::Alias aliasPub = "ecpub2";
1487     CKM::Alias aliasPrv = "ecprv2";
1488     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1489     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1490     CKM::RawBuffer signature;
1491
1492     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1493     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1494
1495     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1496         "Key is empty. Failed to import public key.");
1497     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1498         "Key is empty. Failed to import private key.");
1499
1500     RUNNER_ASSERT_MSG(
1501         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1502         "Error=" << CKMErrorToString(temp));
1503     RUNNER_ASSERT_MSG(
1504         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1505         "Error=" << CKMErrorToString(temp));
1506
1507     RUNNER_ASSERT_MSG(
1508         CKM_API_SUCCESS == (temp = manager->createSignature(
1509                                         aliasPrv,
1510                                         CKM::Password(),
1511                                         CKM::RawBuffer(message.begin(), message.end()),
1512                                         hash,
1513                                         padd,
1514                                         signature)),
1515         "Error=" << CKMErrorToString(temp));
1516
1517     RUNNER_ASSERT_MSG(
1518         CKM_API_SUCCESS == (temp = manager->verifySignature(
1519                                         aliasPub,
1520                                         CKM::Password(),
1521                                         CKM::RawBuffer(message.begin(), message.end()),
1522                                         signature,
1523                                         hash,
1524                                         padd)),
1525         "Error=" << CKMErrorToString(temp));
1526
1527     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1528
1529     memcpy((void*)signature.data(), "BROKEN", 6);
1530
1531     RUNNER_ASSERT_MSG(
1532         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1533                                         aliasPub,
1534                                         CKM::Password(),
1535                                         CKM::RawBuffer(message.begin(), message.end()),
1536                                         signature,
1537                                         hash,
1538                                         padd)),
1539         "Error=" << CKMErrorToString(temp));
1540 }
1541
1542 RUNNER_TEST(T1415_RSA_key_create_verify_negative)
1543 {
1544     int temp;
1545     auto manager = CKM::Manager::create();
1546     std::string message = "message asdfaslkdfjlksadjf test";
1547
1548     CKM::Alias aliasPub = "pub1";
1549     CKM::Alias aliasPrv = "prv1";
1550
1551     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1552     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1553     CKM::RawBuffer signature;
1554
1555     RUNNER_ASSERT_MSG(
1556         CKM_API_SUCCESS == (temp = manager->createSignature(
1557                                         aliasPrv,
1558                                         CKM::Password(),
1559                                         CKM::RawBuffer(message.begin(), message.end()),
1560                                         hash,
1561                                         padd,
1562                                         signature)),
1563         "Error=" << CKMErrorToString(temp));
1564
1565     RUNNER_ASSERT_MSG(
1566         CKM_API_SUCCESS == (temp = manager->verifySignature(
1567                                         aliasPub,
1568                                         CKM::Password(),
1569                                         CKM::RawBuffer(message.begin(), message.end()),
1570                                         signature,
1571                                         hash,
1572                                         padd)),
1573         "Error=" << CKMErrorToString(temp));
1574
1575     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1576     memcpy((void*)signature.data(), "BROKEN", 6);
1577
1578     RUNNER_ASSERT_MSG(
1579         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1580                                         aliasPub,
1581                                         CKM::Password(),
1582                                         CKM::RawBuffer(message.begin(), message.end()),
1583                                         signature,
1584                                         hash,
1585                                         padd)),
1586         "Error=" << CKMErrorToString(temp));
1587 }
1588
1589 RUNNER_TEST(T1416_DSA_key_create_verify_negative)
1590 {
1591     int temp;
1592     auto manager = CKM::Manager::create();
1593     std::string message = "message asdfaslkdfjlksadjf test";
1594
1595     CKM::Alias aliasPub = "pub2";
1596     CKM::Alias aliasPrv = "prv2";
1597
1598     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1599     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1600     CKM::RawBuffer signature;
1601
1602     RUNNER_ASSERT_MSG(
1603         CKM_API_SUCCESS == (temp = manager->createSignature(
1604                                         aliasPrv,
1605                                         CKM::Password(),
1606                                         CKM::RawBuffer(message.begin(), message.end()),
1607                                         hash,
1608                                         padd,
1609                                         signature)),
1610         "Error=" << CKMErrorToString(temp));
1611
1612     RUNNER_ASSERT_MSG(
1613         CKM_API_SUCCESS == (temp = manager->verifySignature(
1614                                         aliasPub,
1615                                         CKM::Password(),
1616                                         CKM::RawBuffer(message.begin(), message.end()),
1617                                         signature,
1618                                         hash,
1619                                         padd)),
1620         "Error=" << CKMErrorToString(temp));
1621
1622     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1623     memcpy((void*)signature.data(), "BROKEN", 6);
1624
1625     RUNNER_ASSERT_MSG(
1626         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1627                                         aliasPub,
1628                                         CKM::Password(),
1629                                         CKM::RawBuffer(message.begin(), message.end()),
1630                                         signature,
1631                                         hash,
1632                                         padd)),
1633         "Error=" << CKMErrorToString(temp));
1634 }
1635
1636 RUNNER_TEST(T1417_RSA_cert_create_verify_signature)
1637 {
1638     int temp;
1639     auto manager = CKM::Manager::create();
1640
1641     std::string prv =
1642       "-----BEGIN RSA PRIVATE KEY-----\n"
1643       "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1644       "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1645       "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1646       "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1647       "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1648       "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1649       "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1650       "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1651       "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1652       "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1653       "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1654       "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1655       "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1656       "-----END RSA PRIVATE KEY-----\n";
1657
1658     std::string pub =
1659       "-----BEGIN CERTIFICATE-----\n"
1660       "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1661       "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1662       "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1663       "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1664       "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1665       "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1666       "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1667       "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1668       "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1669       "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1670       "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1671       "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1672       "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1673       "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1674       "-----END CERTIFICATE-----\n";
1675
1676     std::string message = "message test";
1677
1678     CKM::Alias aliasPub = "pub1-cert";
1679     CKM::Alias aliasPrv = "prv1-cert";
1680     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1681     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1682     CKM::RawBuffer signature;
1683
1684     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1685     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1686
1687     RUNNER_ASSERT_MSG(NULL != cert.get(),
1688         "Key is empty. Failed to import public key.");
1689     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1690         "Key is empty. Failed to import private key.");
1691
1692     RUNNER_ASSERT_MSG(
1693         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1694         "Error=" << CKMErrorToString(temp));
1695     RUNNER_ASSERT_MSG(
1696         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1697         "Error=" << CKMErrorToString(temp));
1698
1699     RUNNER_ASSERT_MSG(
1700         CKM_API_SUCCESS == (temp = manager->createSignature(
1701                                         aliasPrv,
1702                                         CKM::Password(),
1703                                         CKM::RawBuffer(message.begin(), message.end()),
1704                                         hash,
1705                                         padd,
1706                                         signature)),
1707         "Error=" << CKMErrorToString(temp));
1708
1709     RUNNER_ASSERT_MSG(
1710         CKM_API_SUCCESS == (temp = manager->verifySignature(
1711                                         aliasPub,
1712                                         CKM::Password(),
1713                                         CKM::RawBuffer(message.begin(), message.end()),
1714                                         signature,
1715                                         hash,
1716                                         padd)),
1717         "Error=" << CKMErrorToString(temp));
1718
1719     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1720
1721     memcpy((void*)signature.data(), "BROKEN", 6);
1722
1723     RUNNER_ASSERT_MSG(
1724         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1725                                         aliasPub,
1726                                         CKM::Password(),
1727                                         CKM::RawBuffer(message.begin(), message.end()),
1728                                         signature,
1729                                         hash,
1730                                         padd)),
1731         "Error=" << CKMErrorToString(temp));
1732 }
1733
1734 RUNNER_TEST(T1418_DSA_cert_create_verify_signature)
1735 {
1736     int temp;
1737     auto manager = CKM::Manager::create();
1738
1739     const std::string pub = "-----BEGIN CERTIFICATE-----\n"
1740         "MIIDUzCCAxECCQCer/fKcXtJgTALBglghkgBZQMEAwIwgYsxCzAJBgNVBAYTAlBM\n"
1741         "MQ8wDQYDVQQIDAZQb2xhbmQxDzANBgNVBAcMBldhcnNhdzEQMA4GA1UECgwHU2Ft\n"
1742         "c3VuZzEMMAoGA1UECwwDS1NGMRMwEQYDVQQDDAptLmthcnBpdWsyMSUwIwYJKoZI\n"
1743         "hvcNAQkBFhZtLmthcnBpdWsyQHNhbXN1bmcuY29tMCAXDTE0MDkyNjEzNTQwN1oY\n"
1744         "DzIxNDAwOTA1MTM1NDA3WjCBizELMAkGA1UEBhMCUEwxDzANBgNVBAgMBlBvbGFu\n"
1745         "ZDEPMA0GA1UEBwwGV2Fyc2F3MRAwDgYDVQQKDAdTYW1zdW5nMQwwCgYDVQQLDANL\n"
1746         "U0YxEzARBgNVBAMMCm0ua2FycGl1azIxJTAjBgkqhkiG9w0BCQEWFm0ua2FycGl1\n"
1747         "azJAc2Ftc3VuZy5jb20wggG3MIIBKwYHKoZIzjgEATCCAR4CgYEA9Bhh7ZA4onkY\n"
1748         "uDNQbYR4EwkJ6RpD505hB0GF6yppUNp2LanvNcQXcyXY88MB6OdP7Rikbu1H2zP4\n"
1749         "gONCtdxKW58Za7h9bFzYjxcObZsS52F9DP7sv3C4sX4xNWApfhUgbfzKaRCJOkOs\n"
1750         "06tV7teu3G/v26PdI8dlykIuQXQZmH8CFQCHsIV0njb2yC3ggfKz+exH+g5jAQKB\n"
1751         "gBVLYfVCMjUz5XJH+xYU3A8W8rpSLqZKIK2d9mbXqhpz8QK1bvNQUlSRZo+o1ZYV\n"
1752         "mJn3Mx2YuiifHZNKdBNweCqe5a+HV2RSl1Yv/TV9famZKlogGslsmPHUOJMlSIdh\n"
1753         "MfMwVny4/rNtjEtEFE1WnaTr1W6MKH1EBbizVo8fmWFrA4GFAAKBgQCaPjrlkAyX\n"
1754         "kBitWo+w0xZN4OSk13SsCzZ/PG+5zOgMRaFm2XbiC04YsGCi4NFOd9kaiP7w1CsP\n"
1755         "iqG6Vwv0T/VcoxBl/hp6jEqTDSrM6z0ungjDO9wGOdI+jZS0UjVahgC4ZLDHhrOa\n"
1756         "CjfxcHruO3e416b/Rm2CjhOzjKdoSFUWVzALBglghkgBZQMEAwIDLwAwLAIUHa+A\n"
1757         "5xo8O/tPuH9gXkr1mee6kRYCFGNycJ1xkc3nIJaEQOtGfDe7S71A\n"
1758         "-----END CERTIFICATE-----\n";
1759
1760     const std::string prv = "-----BEGIN DSA PRIVATE KEY-----\n"
1761         "MIIBuwIBAAKBgQD0GGHtkDiieRi4M1BthHgTCQnpGkPnTmEHQYXrKmlQ2nYtqe81\n"
1762         "xBdzJdjzwwHo50/tGKRu7UfbM/iA40K13EpbnxlruH1sXNiPFw5tmxLnYX0M/uy/\n"
1763         "cLixfjE1YCl+FSBt/MppEIk6Q6zTq1Xu167cb+/bo90jx2XKQi5BdBmYfwIVAIew\n"
1764         "hXSeNvbILeCB8rP57Ef6DmMBAoGAFUth9UIyNTPlckf7FhTcDxbyulIupkogrZ32\n"
1765         "ZteqGnPxArVu81BSVJFmj6jVlhWYmfczHZi6KJ8dk0p0E3B4Kp7lr4dXZFKXVi/9\n"
1766         "NX19qZkqWiAayWyY8dQ4kyVIh2Ex8zBWfLj+s22MS0QUTVadpOvVbowofUQFuLNW\n"
1767         "jx+ZYWsCgYEAmj465ZAMl5AYrVqPsNMWTeDkpNd0rAs2fzxvuczoDEWhZtl24gtO\n"
1768         "GLBgouDRTnfZGoj+8NQrD4qhulcL9E/1XKMQZf4aeoxKkw0qzOs9Lp4IwzvcBjnS\n"
1769         "Po2UtFI1WoYAuGSwx4azmgo38XB67jt3uNem/0Ztgo4Ts4ynaEhVFlcCFGMH+Z9l\n"
1770         "vonbjii3BYe4AIdkzOvp\n"
1771         "-----END DSA PRIVATE KEY-----\n";
1772
1773     std::string message = "message test";
1774
1775     CKM::Alias aliasPub = "pub2-cert";
1776     CKM::Alias aliasPrv = "prv2-cert";
1777     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1778     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1779     CKM::RawBuffer signature;
1780
1781     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1782     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1783
1784     RUNNER_ASSERT_MSG(NULL != cert.get(),
1785         "Key is empty. Failed to import public key.");
1786     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1787         "Key is empty. Failed to import private key.");
1788
1789     RUNNER_ASSERT_MSG(
1790         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1791         "Error=" << CKMErrorToString(temp));
1792     RUNNER_ASSERT_MSG(
1793         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1794         "Error=" << CKMErrorToString(temp));
1795
1796     RUNNER_ASSERT_MSG(
1797         CKM_API_SUCCESS == (temp = manager->createSignature(
1798                                         aliasPrv,
1799                                         CKM::Password(),
1800                                         CKM::RawBuffer(message.begin(), message.end()),
1801                                         hash,
1802                                         padd,
1803                                         signature)),
1804         "Error=" << CKMErrorToString(temp));
1805
1806     RUNNER_ASSERT_MSG(
1807         CKM_API_SUCCESS == (temp = manager->verifySignature(
1808                                         aliasPub,
1809                                         CKM::Password(),
1810                                         CKM::RawBuffer(message.begin(), message.end()),
1811                                         signature,
1812                                         hash,
1813                                         padd)),
1814         "Error=" << CKMErrorToString(temp));
1815
1816     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1817
1818     memcpy((void*)signature.data(), "BROKEN", 6);
1819
1820     RUNNER_ASSERT_MSG(
1821         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1822                                         aliasPub,
1823                                         CKM::Password(),
1824                                         CKM::RawBuffer(message.begin(), message.end()),
1825                                         signature,
1826                                         hash,
1827                                         padd)),
1828         "Error=" << CKMErrorToString(temp));
1829 }
1830
1831 RUNNER_TEST(T1419_ECDSA_cert_create_verify_signature)
1832 {
1833     int temp;
1834     auto manager = CKM::Manager::create();
1835
1836     std::string prv =
1837       "-----BEGIN EC PRIVATE KEY-----\n"
1838       "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1839       "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1840       "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1841       "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1842       "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1843       "ELyhe7yPCAuOoLZlTLgf\n"
1844       "-----END EC PRIVATE KEY-----\n";
1845
1846     std::string pub =
1847       "-----BEGIN CERTIFICATE-----\n"
1848       "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1849       "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1850       "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1851       "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1852       "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1853       "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1854       "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1855       "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1856       "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1857       "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1858       "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1859       "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1860       "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1861       "Q1oBry6NEc+lLFmWMDesAA==\n"
1862       "-----END CERTIFICATE-----\n";
1863
1864     std::string message = "message test";
1865
1866     CKM::Alias aliasPub = "pub3";
1867     CKM::Alias aliasPrv = "prv3";
1868     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
1869     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
1870     CKM::RawBuffer signature;
1871
1872     auto cert = CKM::Certificate::create(CKM::RawBuffer(pub.begin(), pub.end()), CKM::DataFormat::FORM_PEM);
1873     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()));
1874
1875     RUNNER_ASSERT_MSG(NULL != cert.get(),
1876         "Key is empty. Failed to import public key.");
1877     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1878         "Key is empty. Failed to import private key.");
1879
1880     RUNNER_ASSERT_MSG(
1881         CKM_API_SUCCESS == (temp = manager->saveCertificate(aliasPub, cert, CKM::Policy())),
1882         "Error=" << CKMErrorToString(temp));
1883     RUNNER_ASSERT_MSG(
1884         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1885         "Error=" << CKMErrorToString(temp));
1886
1887     RUNNER_ASSERT_MSG(
1888         CKM_API_SUCCESS == (temp = manager->createSignature(
1889                                         aliasPrv,
1890                                         CKM::Password(),
1891                                         CKM::RawBuffer(message.begin(), message.end()),
1892                                         hash,
1893                                         padd,
1894                                         signature)),
1895         "Error=" << CKMErrorToString(temp));
1896
1897     RUNNER_ASSERT_MSG(
1898         CKM_API_SUCCESS == (temp = manager->verifySignature(
1899                                         aliasPub,
1900                                         CKM::Password(),
1901                                         CKM::RawBuffer(message.begin(), message.end()),
1902                                         signature,
1903                                         hash,
1904                                         padd)),
1905         "Error=" << CKMErrorToString(temp));
1906
1907     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
1908
1909     memcpy((void*)signature.data(), "BROKEN", 6);
1910
1911     RUNNER_ASSERT_MSG(
1912         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
1913                                         aliasPub,
1914                                         CKM::Password(),
1915                                         CKM::RawBuffer(message.begin(), message.end()),
1916                                         signature,
1917                                         hash,
1918                                         padd)),
1919         "Error=" << CKMErrorToString(temp));
1920 }
1921
1922 RUNNER_TEST(T1420_deinit)
1923 {
1924     remove_user_data(USER_APP);
1925 }
1926
1927 RUNNER_TEST_GROUP_INIT(T1418_signature_tests);
1928
1929 RUNNER_TEST(T14180_init)
1930 {
1931     int temp;
1932     remove_user_data(USER_APP);
1933
1934     auto manager = CKM::Manager::create();
1935
1936     // Prepare RSA Key Pair
1937     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1938       "Proc-Type: 4,ENCRYPTED\n"
1939       "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1940       "\n"
1941       "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1942       "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1943       "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1944       "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1945       "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1946       "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1947       "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1948       "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1949       "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1950       "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1951       "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1952       "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1953       "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1954       "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1955       "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1956       "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1957       "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1958       "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1959       "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1960       "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1961       "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1962       "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1963       "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1964       "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1965       "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1966       "-----END RSA PRIVATE KEY-----\n";
1967
1968     std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1969       "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1970       "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1971       "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1972       "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1973       "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1974       "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1975       "zQIDAQAB\n"
1976       "-----END PUBLIC KEY-----\n";
1977
1978     CKM::Alias aliasPub = "pub_nohash1";
1979     CKM::Alias aliasPrv = "prv_nohash1";
1980     CKM::Password password = "1234";
1981
1982     auto keyPub = CKM::Key::create(CKM::RawBuffer(pub.begin(), pub.end()));
1983     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), password);
1984
1985     RUNNER_ASSERT_MSG(NULL != keyPub.get(),
1986         "Key is empty. Failed to import public key.");
1987     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
1988         "Key is empty. Failed to import private key.");
1989
1990     RUNNER_ASSERT_MSG(
1991         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPub, keyPub, CKM::Policy())),
1992         "Error=" << CKMErrorToString(temp));
1993     RUNNER_ASSERT_MSG(
1994         CKM_API_SUCCESS == (temp = manager->saveKey(aliasPrv, keyPrv, CKM::Policy())),
1995         "Error=" << CKMErrorToString(temp));
1996
1997     // Prepare ECDSA Key Pair
1998     std::string ecprv = "-----BEGIN EC PRIVATE KEY-----\n"
1999         "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
2000         "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
2001         "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2002         "-----END EC PRIVATE KEY-----\n";
2003
2004     std::string ecpub = "-----BEGIN PUBLIC KEY-----\n"
2005         "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
2006         "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
2007         "-----END PUBLIC KEY-----\n";
2008
2009     CKM::Alias aliasEcPub = "ecpub_nohash1";
2010     CKM::Alias aliasEcPrv = "ecprv_nohash1";
2011
2012     auto ecKeyPub = CKM::Key::create(CKM::RawBuffer(ecpub.begin(), ecpub.end()));
2013     auto ecKeyPrv = CKM::Key::create(CKM::RawBuffer(ecprv.begin(), ecprv.end()));
2014
2015     RUNNER_ASSERT_MSG(NULL != ecKeyPub.get(),
2016         "Key is empty. Failed to import public key.");
2017     RUNNER_ASSERT_MSG(NULL != ecKeyPrv.get(),
2018         "Key is empty. Failed to import private key.");
2019
2020     RUNNER_ASSERT_MSG(
2021         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPub, ecKeyPub, CKM::Policy())),
2022         "Error=" << CKMErrorToString(temp));
2023     RUNNER_ASSERT_MSG(
2024         CKM_API_SUCCESS == (temp = manager->saveKey(aliasEcPrv, ecKeyPrv, CKM::Policy())),
2025         "Error=" << CKMErrorToString(temp));
2026 }
2027
2028
2029 RUNNER_TEST(T14181_RSA_create_signatue_nohash)
2030 {
2031     int temp;
2032     auto manager = CKM::Manager::create();
2033     std::string message = "message asdfaslkdfjlksadjf test";
2034
2035     CKM::Alias aliasPub = "pub_nohash1";
2036     CKM::Alias aliasPrv = "prv_nohash1";
2037
2038     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2039     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2040     CKM::RawBuffer signature;
2041
2042     RUNNER_ASSERT_MSG(
2043         CKM_API_SUCCESS == (temp = manager->createSignature(
2044                                         aliasPrv,
2045                                         CKM::Password(),
2046                                         CKM::RawBuffer(message.begin(), message.end()),
2047                                         hash,
2048                                         padd,
2049                                         signature)),
2050         "Error=" << CKMErrorToString(temp));
2051
2052     RUNNER_ASSERT_MSG(
2053         CKM_API_SUCCESS == (temp = manager->verifySignature(
2054                                         aliasPub,
2055                                         CKM::Password(),
2056                                         CKM::RawBuffer(message.begin(), message.end()),
2057                                         signature,
2058                                         hash,
2059                                         padd)),
2060         "Error=" << CKMErrorToString(temp));
2061
2062     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2063     memcpy((void*)signature.data(), "BROKEN", 6);
2064
2065     RUNNER_ASSERT_MSG(
2066         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2067                                         aliasPub,
2068                                         CKM::Password(),
2069                                         CKM::RawBuffer(message.begin(), message.end()),
2070                                         signature,
2071                                         hash,
2072                                         padd)),
2073         "Error=" << CKMErrorToString(temp));
2074 }
2075
2076 RUNNER_TEST(T14182_RSA_create_signatue_nohash_nopad)
2077 {
2078     int temp;
2079     auto manager = CKM::Manager::create();
2080     std::string message = "message asdfaslkdfjlksadjf test";
2081
2082     CKM::Alias aliasPub = "pub_nohash1";
2083     CKM::Alias aliasPrv = "prv_nohash1";
2084
2085     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2086     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2087     CKM::RawBuffer signature;
2088
2089     RUNNER_ASSERT_MSG(
2090         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2091                                         aliasPrv,
2092                                         CKM::Password(),
2093                                         CKM::RawBuffer(message.begin(), message.end()),
2094                                         hash,
2095                                         padd,
2096                                         signature)),
2097         "Error=" << CKMErrorToString(temp));
2098 }
2099
2100 RUNNER_TEST(T14183_RSA_create_signatue_nohash_bigmsg)
2101 {
2102     int temp;
2103     auto manager = CKM::Manager::create();
2104     std::string message = "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                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
2123                           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
2124
2125     CKM::Alias aliasPub = "pub_nohash1";
2126     CKM::Alias aliasPrv = "prv_nohash1";
2127
2128     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2129     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2130     CKM::RawBuffer signature;
2131
2132     RUNNER_ASSERT_MSG(
2133         CKM_API_ERROR_INPUT_PARAM == (temp = manager->createSignature(
2134                                         aliasPrv,
2135                                         CKM::Password(),
2136                                         CKM::RawBuffer(message.begin(), message.end()),
2137                                         hash,
2138                                         padd,
2139                                         signature)),
2140         "Error=" << CKMErrorToString(temp));
2141 }
2142
2143
2144 RUNNER_TEST(T14184_ECDSA_create_signatue_nohash)
2145 {
2146     int temp;
2147     auto manager = CKM::Manager::create();
2148
2149     std::string message = "message test";
2150
2151     CKM::Alias aliasPub = "ecpub_nohash1";
2152     CKM::Alias aliasPrv = "ecprv_nohash1";
2153     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2154     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2155     CKM::RawBuffer signature;
2156
2157     RUNNER_ASSERT_MSG(
2158         CKM_API_SUCCESS == (temp = manager->createSignature(
2159                                         aliasPrv,
2160                                         CKM::Password(),
2161                                         CKM::RawBuffer(message.begin(), message.end()),
2162                                         hash,
2163                                         padd,
2164                                         signature)),
2165         "Error=" << CKMErrorToString(temp));
2166
2167     RUNNER_ASSERT_MSG(
2168         CKM_API_SUCCESS == (temp = manager->verifySignature(
2169                                         aliasPub,
2170                                         CKM::Password(),
2171                                         CKM::RawBuffer(message.begin(), message.end()),
2172                                         signature,
2173                                         hash,
2174                                         padd)),
2175         "Error=" << CKMErrorToString(temp));
2176
2177     RUNNER_ASSERT_MSG(signature.size() > 6, "Signature is too small");
2178
2179     memcpy((void*)signature.data(), "BROKEN", 6);
2180
2181     RUNNER_ASSERT_MSG(
2182         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2183                                         aliasPub,
2184                                         CKM::Password(),
2185                                         CKM::RawBuffer(message.begin(), message.end()),
2186                                         signature,
2187                                         hash,
2188                                         padd)),
2189         "Error=" << CKMErrorToString(temp));
2190 }
2191
2192 RUNNER_TEST(T14185_ECDSA_create_signatue_nohash_bigmsg)
2193 {
2194     int temp;
2195     auto manager = CKM::Manager::create();
2196
2197     int msgSize = 1024*1024;
2198     char big_msg[msgSize];
2199     for(int i =0; i<msgSize-1; i++) {
2200         big_msg[i] = 'a';
2201     }
2202     big_msg[msgSize-1]=0x00;
2203     std::string message(big_msg);
2204
2205     CKM::Alias aliasPub = "ecpub_nohash1";
2206     CKM::Alias aliasPrv = "ecprv_nohash1";
2207     CKM::HashAlgorithm hash = CKM::HashAlgorithm::NONE;
2208     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::NONE;
2209     CKM::RawBuffer signature;
2210
2211     RUNNER_ASSERT_MSG(
2212             CKM_API_SUCCESS == (temp = manager->createSignature(
2213                                         aliasPrv,
2214                                         CKM::Password(),
2215                                         CKM::RawBuffer(message.begin(), message.end()),
2216                                         hash,
2217                                         padd,
2218                                         signature)),
2219         "Error=" << CKMErrorToString(temp));
2220 }
2221
2222
2223 RUNNER_TEST(T14189_deinit)
2224 {
2225     remove_user_data(USER_APP);
2226 }
2227
2228
2229 RUNNER_TEST_GROUP_INIT(T180_PKCS12);
2230
2231 namespace
2232 {
2233 CKM::Alias alias_PKCS_collision = "test-PKCS-collision";
2234 CKM::Alias alias_PKCS_exportable = "test-PKCS-export";
2235 CKM::Alias alias_PKCS_not_exportable = "test-PKCS-no-export";
2236 CKM::Alias alias_PKCS_priv_key_copy = "test-PKCS-private-key-copy";
2237 CKM::Alias alias_PKCS_priv_key_wrong = "test-PKCS-private-key-wrong";
2238 }
2239
2240 RUNNER_TEST(T1800_init)
2241 {
2242     remove_user_data(USER_APP);
2243 }
2244
2245 RUNNER_TEST(T1801_parse_PKCS12) {
2246     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2247     std::istreambuf_iterator<char> begin(is), end;
2248     std::vector<char> buff(begin, end);
2249
2250     CKM::RawBuffer buffer(buff.size());
2251     memcpy(buffer.data(), buff.data(), buff.size());
2252
2253     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2254     RUNNER_ASSERT_MSG(
2255         NULL != pkcs.get(),
2256         "Error in PKCS12::create()");
2257
2258     auto cert = pkcs->getCertificate();
2259     RUNNER_ASSERT_MSG(
2260         NULL != cert.get(),
2261         "Error in PKCS12::getCertificate()");
2262
2263     auto key = pkcs->getKey();
2264     RUNNER_ASSERT_MSG(
2265         NULL != key.get(),
2266         "Error in PKCS12::getKey()");
2267
2268     auto caVector = pkcs->getCaCertificateShPtrVector();
2269     RUNNER_ASSERT_MSG(
2270         0 == caVector.size(),
2271         "Wrong size of vector");
2272 }
2273
2274 RUNNER_TEST(T1802_negative_wrong_password) {
2275     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2276     std::istreambuf_iterator<char> begin(is), end;
2277     std::vector<char> buff(begin, end);
2278
2279     CKM::RawBuffer buffer(buff.size());
2280     memcpy(buffer.data(), buff.data(), buff.size());
2281
2282     auto pkcs = CKM::PKCS12::create(buffer, "error");
2283     RUNNER_ASSERT_MSG(
2284         NULL == pkcs.get(),
2285         "Expected error in PKCS12::create()");
2286 }
2287
2288 RUNNER_TEST(T1803_negative_broken_buffer) {
2289     std::ifstream is(CKM_TEST_DIR "/test1801.pkcs12");
2290     std::istreambuf_iterator<char> begin(is), end;
2291     std::vector<char> buff(begin, end);
2292
2293     CKM::RawBuffer buffer(buff.size());
2294     memcpy(buffer.data(), buff.data(), buff.size());
2295
2296     RUNNER_ASSERT_MSG(buffer.size() > 5, "PKCS file is too small.");
2297     buffer[4]=0;
2298
2299     auto pkcs = CKM::PKCS12::create(buffer, "secret");
2300     RUNNER_ASSERT_MSG(
2301         NULL == pkcs.get(),
2302         "Expected error in PKCS12::create()");
2303 }
2304
2305 RUNNER_TEST(T1804_add_PKCS_collision_with_existing_alias)
2306 {
2307     auto manager = CKM::Manager::create();
2308     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2309     std::istreambuf_iterator<char> begin(is), end;
2310     std::vector<char> buff(begin, end);
2311
2312     CKM::RawBuffer buffer(buff.size());
2313     memcpy(buffer.data(), buff.data(), buff.size());
2314
2315     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2316     RUNNER_ASSERT_MSG(
2317         NULL != pkcs.get(),
2318         "Error in PKCS12::create()");
2319
2320     // save private key
2321     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2322         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2323         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2324         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2325         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2326         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2327         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2328         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2329         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2330         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2331         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2332         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2333         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2334         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2335         "-----END RSA PRIVATE KEY-----\n";
2336
2337     std::string message = "message test";
2338
2339     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2340     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2341         "Key is empty. Failed to import private key.");
2342
2343     int temp;
2344     RUNNER_ASSERT_MSG(
2345         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_collision, keyPrv, CKM::Policy())),
2346         "Error=" << CKMErrorToString(temp));
2347
2348     RUNNER_ASSERT_MSG(
2349         CKM_API_ERROR_DB_ALIAS_EXISTS == (temp = manager->savePKCS12(alias_PKCS_collision, pkcs, CKM::Policy(), CKM::Policy())),
2350         "Error=" << CKMErrorToString(temp));
2351 }
2352
2353 RUNNER_TEST(T1805_add_bundle_with_chain_certificates)
2354 {
2355     auto manager = CKM::Manager::create();
2356     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2357     std::istreambuf_iterator<char> begin(is), end;
2358     std::vector<char> buff(begin, end);
2359
2360     CKM::RawBuffer buffer(buff.size());
2361     memcpy(buffer.data(), buff.data(), buff.size());
2362
2363     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2364     RUNNER_ASSERT_MSG(
2365         NULL != pkcs.get(),
2366         "Error in PKCS12::create()");
2367
2368     auto cert = pkcs->getCertificate();
2369     RUNNER_ASSERT_MSG(
2370         NULL != cert.get(),
2371         "Error in PKCS12::getCertificate()");
2372
2373     auto key = pkcs->getKey();
2374     RUNNER_ASSERT_MSG(
2375         NULL != key.get(),
2376         "Error in PKCS12::getKey()");
2377
2378     auto caVector = pkcs->getCaCertificateShPtrVector();
2379     RUNNER_ASSERT_MSG(
2380         2 == caVector.size(),
2381         "Wrong size of vector");
2382
2383     // save to the CKM
2384     int tmp;
2385     CKM::Policy exportable;
2386     CKM::Policy notExportable(CKM::Password(), false);
2387
2388     RUNNER_ASSERT_MSG(
2389         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2390         "Error=" << CKMErrorToString(tmp));
2391     RUNNER_ASSERT_MSG(
2392         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_exportable, pkcs, exportable, exportable)),
2393         "Error=" << CKMErrorToString(tmp));
2394     RUNNER_ASSERT_MSG(
2395         CKM_API_SUCCESS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2396         "Error=" << CKMErrorToString(tmp));
2397     RUNNER_ASSERT_MSG(
2398         CKM_API_ERROR_DB_ALIAS_EXISTS == (tmp = manager->savePKCS12(alias_PKCS_not_exportable, pkcs, notExportable, notExportable)),
2399         "Error=" << CKMErrorToString(tmp));
2400
2401     // try to lookup key
2402     CKM::KeyShPtr key_lookup;
2403     RUNNER_ASSERT_MSG(
2404         CKM_API_SUCCESS == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2405         "Error=" << CKMErrorToString(tmp));
2406     RUNNER_ASSERT_MSG(
2407         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2408         "Error=" << CKMErrorToString(tmp));
2409
2410     // try to lookup certificate
2411     CKM::CertificateShPtr cert_lookup;
2412     RUNNER_ASSERT_MSG(
2413         CKM_API_SUCCESS == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2414         "Error=" << CKMErrorToString(tmp));
2415     RUNNER_ASSERT_MSG(
2416         CKM_API_ERROR_NOT_EXPORTABLE == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2417         "Error=" << CKMErrorToString(tmp));
2418 }
2419
2420 RUNNER_TEST(T1806_get_PKCS)
2421 {
2422     int temp;
2423     auto manager = CKM::Manager::create();
2424
2425     CKM::PKCS12ShPtr pkcs;
2426
2427     // fail - no entry
2428     RUNNER_ASSERT_MSG(
2429         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (temp = manager->getPKCS12("i-do-not-exist", pkcs)),
2430         "Error=" << CKMErrorToString(temp));
2431
2432     // fail - not exportable
2433     RUNNER_ASSERT_MSG(
2434         CKM_API_ERROR_NOT_EXPORTABLE == (temp = manager->getPKCS12(alias_PKCS_not_exportable, pkcs)),
2435         "Error=" << CKMErrorToString(temp));
2436
2437     // success - exportable
2438     RUNNER_ASSERT_MSG(
2439         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias_PKCS_exportable, pkcs)),
2440         "Error=" << CKMErrorToString(temp));
2441
2442     auto cert = pkcs->getCertificate();
2443     RUNNER_ASSERT_MSG(
2444         NULL != cert.get(),
2445         "Error in PKCS12::getCertificate()");
2446
2447     auto key = pkcs->getKey();
2448     RUNNER_ASSERT_MSG(
2449         NULL != key.get(),
2450         "Error in PKCS12::getKey()");
2451
2452     auto caVector = pkcs->getCaCertificateShPtrVector();
2453     RUNNER_ASSERT_MSG(
2454         2 == caVector.size(),
2455         "Wrong size of vector");
2456 }
2457
2458 RUNNER_TEST(T1807_create_and_verify_signature)
2459 {
2460     int temp;
2461     auto manager = CKM::Manager::create();
2462
2463     std::string message = "message test";
2464
2465     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2466     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2467     CKM::RawBuffer signature;
2468
2469     RUNNER_ASSERT_MSG(
2470         CKM_API_SUCCESS == (temp = manager->createSignature(
2471                                         alias_PKCS_exportable,
2472                                         CKM::Password(),
2473                                         CKM::RawBuffer(message.begin(), message.end()),
2474                                         hash,
2475                                         padd,
2476                                         signature)),
2477         "Error=" << CKMErrorToString(temp));
2478
2479     RUNNER_ASSERT_MSG(
2480         CKM_API_SUCCESS == (temp = manager->verifySignature(
2481                                         alias_PKCS_exportable,
2482                                         CKM::Password(),
2483                                         CKM::RawBuffer(message.begin(), message.end()),
2484                                         signature,
2485                                         hash,
2486                                         padd)),
2487         "Error=" << CKMErrorToString(temp));
2488 }
2489
2490 RUNNER_TEST(T1808_create_signature_on_raw_key_and_verify_on_PKCS)
2491 {
2492     int temp;
2493     auto manager = CKM::Manager::create();
2494
2495     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2496         "MIICXQIBAAKBgQD1W9neUbXL1rnq9SvyzprjhWBKXyYKQirG3V2zyUnUaE24Sq2I\n"
2497         "v7ISrwMN/G6WcjrGmeZDEWwrL4zXh002N8BD1waJPRonxwtVkhFy3emGatSmx7eI\n"
2498         "ely5H+PBNImRvBh2u4GWga6OEXcUNdfaBUcxn+P6548/zpDhyNLzQKk5FwIDAQAB\n"
2499         "AoGAR+4WkBuqTUj1FlGsAbHaLKt0UDlWwJknS0eoacWwFEpDxqx19WolfV67aYVA\n"
2500         "snBolMKXg7/+0yZMhv8Ofr+XaHkPQplVVn9BwT0rmtEovJXwx+poRP9Bm3emglj/\n"
2501         "iYd8EkaXDlIXCtewtQW9JEIctWppntHj3TvA/h7FCXPN6SkCQQD/N7sn5S1gBkVh\n"
2502         "dyXQKoyKsZDb7hMIS1q6cKwYCMf2UrsD1/lnr7xXkvORdL213MfueO8g0WkuKfRY\n"
2503         "bDD6WGX1AkEA9hxiOlsgvermqLJkOlJffbSaM8n/6wtnM0HV+Vd9NfSBOmxFDXPO\n"
2504         "vrvdgiDPENhbqTJSQVDsfzHilTpK7lEvWwJBAJLxHoOg0tg3pBiyxgWtic+M3q+R\n"
2505         "ykl7QViY6KzJ2X98MIrM/Z7yMollZXE4+sVLwZ0O6fdGOr3GkBWc7TImVUUCQQC7\n"
2506         "pf6bQfof9Ce0fnf/I+ldHkPost7nJsWkBlGQkM2OQwP5OK4ZyK/dK76DxmI7FMwm\n"
2507         "oJCo7nuzq6R4ZX7WYJ47AkBavxBDo/e9/0Vk5yrloGKW3f8RQXBJLcCkVUGyyJ3D\n"
2508         "3gu/nafW4hzjSJniTjC1fOj0eb0OSg1JAvqHTYAnUsI7\n"
2509         "-----END RSA PRIVATE KEY-----";
2510     std::string message = "message test";
2511
2512     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2513     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2514         "Key is empty. Failed to import private key.");
2515
2516     RUNNER_ASSERT_MSG(
2517         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_copy, keyPrv, CKM::Policy())),
2518         "Error=" << CKMErrorToString(temp));
2519
2520     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2521     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2522     CKM::RawBuffer signature;
2523
2524     RUNNER_ASSERT_MSG(
2525         CKM_API_SUCCESS == (temp = manager->createSignature(
2526                                         alias_PKCS_priv_key_copy,
2527                                         CKM::Password(),
2528                                         CKM::RawBuffer(message.begin(), message.end()),
2529                                         hash,
2530                                         padd,
2531                                         signature)),
2532         "Error=" << CKMErrorToString(temp));
2533
2534     RUNNER_ASSERT_MSG(
2535         CKM_API_SUCCESS == (temp = manager->verifySignature(
2536                                         alias_PKCS_exportable,
2537                                         CKM::Password(),
2538                                         CKM::RawBuffer(message.begin(), message.end()),
2539                                         signature,
2540                                         hash,
2541                                         padd)),
2542         "Error=" << CKMErrorToString(temp));
2543 }
2544
2545 RUNNER_TEST(T1809_create_signature_on_wrong_key_and_verify_on_PKCS)
2546 {
2547     int temp;
2548     auto manager = CKM::Manager::create();
2549
2550     std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
2551         "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
2552         "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
2553         "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
2554         "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
2555         "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
2556         "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
2557         "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
2558         "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
2559         "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
2560         "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
2561         "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
2562         "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
2563         "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
2564         "-----END RSA PRIVATE KEY-----\n";
2565
2566     std::string message = "message test";
2567
2568     auto keyPrv = CKM::Key::create(CKM::RawBuffer(prv.begin(), prv.end()), CKM::Password());
2569     RUNNER_ASSERT_MSG(NULL != keyPrv.get(),
2570         "Key is empty. Failed to import private key.");
2571
2572     RUNNER_ASSERT_MSG(
2573         CKM_API_SUCCESS == (temp = manager->saveKey(alias_PKCS_priv_key_wrong, keyPrv, CKM::Policy())),
2574         "Error=" << CKMErrorToString(temp));
2575
2576     CKM::HashAlgorithm hash = CKM::HashAlgorithm::SHA256;
2577     CKM::RSAPaddingAlgorithm padd = CKM::RSAPaddingAlgorithm::PKCS1;
2578     CKM::RawBuffer signature;
2579
2580     RUNNER_ASSERT_MSG(
2581         CKM_API_SUCCESS == (temp = manager->createSignature(
2582                                         alias_PKCS_priv_key_wrong,
2583                                         CKM::Password(),
2584                                         CKM::RawBuffer(message.begin(), message.end()),
2585                                         hash,
2586                                         padd,
2587                                         signature)),
2588         "Error=" << CKMErrorToString(temp));
2589
2590     RUNNER_ASSERT_MSG(
2591         CKM_API_ERROR_VERIFICATION_FAILED == (temp = manager->verifySignature(
2592                                         alias_PKCS_exportable,
2593                                         CKM::Password(),
2594                                         CKM::RawBuffer(message.begin(), message.end()),
2595                                         signature,
2596                                         hash,
2597                                         padd)),
2598         "Error=" << CKMErrorToString(temp));
2599 }
2600
2601 RUNNER_TEST(T1810_verify_get_certificate_chain)
2602 {
2603     // this certificate has been signed using PKCS chain
2604     std::string im =
2605         "-----BEGIN CERTIFICATE-----\n"
2606         "MIIBozCCAQwCAQEwDQYJKoZIhvcNAQEFBQAwHDEaMBgGA1UEAwwRc2VydmVyQHRl\n"
2607         "c3RtZS5jb20wHhcNMTUxMjA5MTA0NjU0WhcNMjUxMjA2MTA0NjU0WjAYMRYwFAYD\n"
2608         "VQQDDA1lZUB0ZXN0bWUuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDP\n"
2609         "+fNsZB1Vlmhnk0IwYDs7Pw9E38KQfTt/egqqRFN6IvIt0CCDBXqnPTujuvlO2OyL\n"
2610         "XVuALnIBmTDm5Oz+oz+qiY6/XrVS/CoACNZyMo6ihG9OeocvDbU3jXEaPGL6ib/x\n"
2611         "jlms0aA9d5L9TO2lEzEP7bFKgHCB8FWINcxSP5zl1QIDAQABMA0GCSqGSIb3DQEB\n"
2612         "BQUAA4GBAKBpVJMkdK6/qnAz7d7Bul/BhhSLEYbNPdxRiUj3U2dt0GJgswMu2SNT\n"
2613         "/3NXB8V8mnnXR6cWn5bmjyA7ZpQEKAatS/KEQ9wfLXyCgYDRebX71mVKAI3XcyxB\n"
2614         "p2qsOWWaJhuHmC1GVjx3foL+RDrmRo6BiucNHMIuvrd1W36eKdhj\n"
2615         "-----END CERTIFICATE-----\n";
2616
2617     auto cert = CKM::Certificate::create(CKM::RawBuffer(im.begin(), im.end()), CKM::DataFormat::FORM_PEM);
2618     CKM::CertificateShPtrVector certChain;
2619     CKM::AliasVector aliasVector;
2620
2621     int tmp;
2622     auto manager = CKM::Manager::create();
2623
2624     RUNNER_ASSERT_MSG(NULL != cert.get(), "Certificate should not be empty");
2625
2626     tmp = manager->getCertificateChain(cert,
2627                                        EMPTY_ALIAS_VECTOR,
2628                                        EMPTY_ALIAS_VECTOR,
2629                                        true,
2630                                        certChain);
2631     RUNNER_ASSERT_MSG(CKM_API_ERROR_VERIFICATION_FAILED == tmp,
2632                          "Error=" << CKMErrorToString(tmp));
2633
2634     RUNNER_ASSERT_MSG(
2635         0 == certChain.size(),
2636         "Wrong size of certificate chain.");
2637
2638     aliasVector.push_back(alias_PKCS_exportable);
2639
2640     tmp = manager->getCertificateChain(cert, EMPTY_ALIAS_VECTOR, aliasVector, false, certChain);
2641     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == tmp, "Error=" << CKMErrorToString(tmp));
2642
2643     // 1(cert) + 1(pkcs12 cert) + 2(pkcs12 chain cert) = 4
2644     RUNNER_ASSERT_MSG(
2645         4 == certChain.size(),
2646         "Wrong size of certificate chain: " << certChain.size());
2647 }
2648
2649 RUNNER_TEST(T1811_remove_bundle_with_chain_certificates)
2650 {
2651     auto manager = CKM::Manager::create();
2652     int tmp;
2653
2654
2655     // remove the whole PKCS12 bundles
2656     RUNNER_ASSERT_MSG(
2657         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_exportable)),
2658         "Error=" << CKMErrorToString(tmp));
2659     RUNNER_ASSERT_MSG(
2660         CKM_API_SUCCESS == (tmp = manager->removeAlias(alias_PKCS_not_exportable)),
2661         "Error=" << CKMErrorToString(tmp));
2662
2663     // expect lookup fails due to unknown alias
2664     // try to lookup key
2665     CKM::KeyShPtr key_lookup;
2666     RUNNER_ASSERT_MSG(
2667         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_exportable, CKM::Password(), key_lookup)),
2668         "Error=" << CKMErrorToString(tmp));
2669     RUNNER_ASSERT_MSG(
2670         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getKey(alias_PKCS_not_exportable, CKM::Password(), key_lookup)),
2671         "Error=" << CKMErrorToString(tmp));
2672
2673     // try to lookup certificate
2674     CKM::CertificateShPtr cert_lookup;
2675     RUNNER_ASSERT_MSG(
2676         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_exportable, CKM::Password(), cert_lookup)),
2677         "Error=" << CKMErrorToString(tmp));
2678     RUNNER_ASSERT_MSG(
2679         CKM_API_ERROR_DB_ALIAS_UNKNOWN == (tmp = manager->getCertificate(alias_PKCS_not_exportable, CKM::Password(), cert_lookup)),
2680         "Error=" << CKMErrorToString(tmp));
2681 }
2682
2683 RUNNER_TEST(T1812_get_pkcs12_password_tests)
2684 {
2685     CKM::Alias alias = "t1812alias1";
2686
2687     auto manager = CKM::Manager::create();
2688     std::ifstream is(CKM_TEST_DIR "/pkcs.p12");
2689     std::istreambuf_iterator<char> begin(is), end;
2690     std::vector<char> buff(begin, end);
2691
2692     CKM::PKCS12ShPtr pkcs12;
2693     CKM::Password pass1 = "easypass1";
2694     CKM::Password pass2 = "easypass2";
2695
2696     CKM::RawBuffer buffer(buff.size());
2697     memcpy(buffer.data(), buff.data(), buff.size());
2698
2699     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
2700     RUNNER_ASSERT_MSG(
2701         NULL != pkcs.get(),
2702         "Error in PKCS12::create()");
2703
2704     int temp;
2705     RUNNER_ASSERT_MSG(
2706         CKM_API_SUCCESS == (temp = manager->savePKCS12(alias, pkcs, CKM::Policy(pass1), CKM::Policy(pass2))),
2707         "Error=" << CKMErrorToString(temp));
2708
2709     RUNNER_ASSERT_MSG(
2710         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pkcs)),
2711         "Error=" << CKMErrorToString(temp));
2712
2713     RUNNER_ASSERT_MSG(
2714         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), CKM::Password(), pkcs)),
2715         "Error=" << CKMErrorToString(temp));
2716
2717     RUNNER_ASSERT_MSG(
2718         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, pass1, CKM::Password(), pkcs)),
2719         "Error=" << CKMErrorToString(temp));
2720
2721     RUNNER_ASSERT_MSG(
2722         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getPKCS12(alias, CKM::Password(), pass2, pkcs)),
2723         "Error=" << CKMErrorToString(temp));
2724
2725     RUNNER_ASSERT_MSG(
2726         CKM_API_SUCCESS == (temp = manager->getPKCS12(alias, pass1, pass2, pkcs)),
2727         "Error=" << CKMErrorToString(temp));
2728
2729     CKM::CertificateShPtr cert;
2730     RUNNER_ASSERT_MSG(
2731         CKM_API_SUCCESS == (temp = manager->getCertificate(alias, pass2, cert)),
2732         "Error=" << CKMErrorToString(temp));
2733
2734     CKM::CertificateShPtrVector certChain;
2735     CKM::AliasVector certVect;
2736     certVect.push_back(alias);
2737
2738     RUNNER_ASSERT_MSG(
2739         CKM_API_ERROR_AUTHENTICATION_FAILED == (temp = manager->getCertificateChain(cert, certVect, certVect, true, certChain)),
2740         "Error=" << CKMErrorToString(temp));
2741 }
2742
2743 RUNNER_TEST(T1813_deinit)
2744 {
2745     int temp;
2746     auto control = CKM::Control::create();
2747
2748     RUNNER_ASSERT_MSG(
2749         CKM_API_SUCCESS == (temp = control->lockUserKey(USER_APP)),
2750         "Error=" << CKMErrorToString(temp));
2751 }
2752
2753 RUNNER_TEST_GROUP_INIT(T190_CKM_EMPTY_STORAGE_TESTS);
2754 namespace {
2755 const char * const T190_PASSWD = "t190-special-password";
2756 }
2757 RUNNER_TEST(T1901_init_unlock_key)
2758 {
2759     reset_user_data(USER_APP, T190_PASSWD);
2760 }
2761
2762 RUNNER_TEST(T1902_get_data)
2763 {
2764     ScopedDBUnlock unlock(USER_APP, T190_PASSWD);
2765
2766     auto manager = CKM::Manager::create();
2767     CKM::KeyShPtr ptr;
2768
2769     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2770
2771     RUNNER_ASSERT_MSG(
2772         CKM_API_ERROR_DB_ALIAS_UNKNOWN == status1,
2773         "Could not put certificate in datbase. Error=" << CKMErrorToString(status1));
2774 }
2775
2776 RUNNER_TEST(T1903_lock_database)
2777 {
2778     int tmp;
2779     auto control = CKM::Control::create();
2780     RUNNER_ASSERT_MSG(
2781         CKM_API_SUCCESS == (tmp = control->lockUserKey(USER_APP)),
2782         "Error=" << CKMErrorToString(tmp));
2783 }
2784
2785 RUNNER_TEST(T1904_get_data_from_locked_database)
2786 {
2787     auto manager = CKM::Manager::create();
2788     CKM::KeyShPtr ptr;
2789
2790     int status1 = manager->getKey(CKM::Alias("CertEEE"), CKM::Password(), ptr);
2791
2792     RUNNER_ASSERT_MSG(
2793         CKM_API_ERROR_DB_LOCKED == status1,
2794         "Could not get key from locked database. Error=" << CKMErrorToString(status1));
2795 }
2796
2797 RUNNER_TEST(T1905_deinit)
2798 {
2799     remove_user_data(USER_APP);
2800 }
2801
2802 int main(int argc, char *argv[])
2803 {
2804     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
2805 }