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