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