tests/ckm/capi-testcases.cpp

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