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