1 #include <dpl/test/test_runner.h>
2 #include <dpl/test/test_runner_child.h>
4 #include <tests_common.h>
5 #include <ckm-common.h>
6 #include <access_provider2.h>
8 #include <ckm/ckm-manager.h>
9 #include <ckm/ckm-control.h>
10 #include <ckm/ckm-type.h>
12 #include <ckmc/ckmc-manager.h>
13 #include <ckmc/ckmc-control.h>
14 #include <ckmc/ckmc-type.h>
15 #include <ckmc/ckmc-error.h>
23 static const int USER_APP = 5000;
24 static const int GROUP_APP = 5000;
35 const char* USER_PASS = "user-pass";
37 int count_aliases(alias_type_ type, int minimum_initial_element_count = 0)
39 ckmc_alias_list_s *aliasList = NULL;
44 ec = ckmc_get_key_alias_list(&aliasList);
48 ec = ckmc_get_cert_alias_list(&aliasList);
52 ec = ckmc_get_data_alias_list(&aliasList);
55 if(ec == CKMC_ERROR_DB_ALIAS_UNKNOWN)
59 ckmc_alias_list_s *plist = aliasList;
66 ckmc_alias_list_all_free(aliasList);
69 return_count >= minimum_initial_element_count,
70 "Error: alias list failed, current element count: " << return_count <<
71 " while expected minimal count of " << minimum_initial_element_count <<
81 "Error: alias list failed, ec: " << ec);
87 ckmc_raw_buffer_s prepare_message_buffer(const char * input)
89 ckmc_raw_buffer_s retval;
90 retval.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(input));
91 retval.size = strlen(input);
97 RUNNER_TEST_GROUP_INIT (T301_CKMC_CONTROL_C_API);
99 RUNNER_TEST(T3011_Control_C_API)
103 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
106 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
110 RUNNER_TEST(T3012_Control_C_API)
114 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
116 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
120 RUNNER_TEST(T3013_Control_C_API)
124 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
128 RUNNER_TEST(T3014_Control_C_API)
131 const uid_t UNIQUE_USER = 15;
133 // clean up environment
134 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
136 // unlock with default password
137 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, NULL)),
139 // reset password (NULL, "simple-password")
140 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
142 // get rid of NULL DKEK
143 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, "simple-password")),
146 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(UNIQUE_USER)),
148 // try to reset password when db locked
149 RUNNER_ASSERT_MSG( CKMC_ERROR_BAD_REQUEST == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
151 // clean up environment
152 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
156 RUNNER_TEST(T3015_Control_C_API)
161 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(20, "test-pass")),
164 CKMC_ERROR_NONE == (temp = ckmc_change_user_password(20, "test-pass", "new-pass")),
166 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
168 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
172 RUNNER_TEST(T3016_Control_C_API)
177 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
180 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
183 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
186 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
190 RUNNER_TEST_GROUP_INIT (T302_CKMC_QUICK_SET_GET_TESTS_C_API);
192 RUNNER_TEST(T3021_init_C_API)
197 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
200 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
204 RUNNER_TEST(T3022_key_C_API)
208 ckmc_key_s test_key, *test_key2;
209 ckmc_policy_s test_policy;
211 char* password = NULL;
212 const char *alias = "mykey";
214 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
215 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
216 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
217 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
218 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
219 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
220 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
222 "-----END PUBLIC KEY-----";
224 char* char_keypem = new char[keyPem.length() + 1];
226 std::strcpy(char_keypem, keyPem.c_str());
227 test_key.raw_key = (unsigned char *)char_keypem;
228 test_key.key_size = keyPem.length();
229 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
230 test_key.password = password;
232 test_policy.password = password;
233 test_policy.extractable = 1;
235 test_key2 = &test_key;
238 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
242 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
246 RUNNER_TEST(T3023_certificate_C_API)
250 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
251 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
252 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
253 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
254 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
255 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
256 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
257 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
258 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
259 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
260 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
261 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
262 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
263 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
264 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
265 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
266 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
267 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
268 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
269 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
270 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
271 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
272 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
273 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
274 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
276 "-----END CERTIFICATE-----\n";
278 char* password = NULL;
282 const char *alias = "test-cert-1-RSA";
284 ckmc_policy_s test_policy;
285 test_policy.password = password;
286 test_policy.extractable = 1;
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;
295 CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias, cert, test_policy)),
299 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
302 ckmc_cert_free(cert2);
305 RUNNER_TEST(T3024_certificate_remove_C_API)
309 char* password = NULL;
311 const char *alias = "test-cert-1-RSA";
314 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
316 ckmc_cert_free(cert2);
319 CKMC_ERROR_NONE == (temp = ckmc_remove_cert(alias)),
323 CKMC_ERROR_NONE != (temp = ckmc_get_cert(alias, password, &cert2)),
327 RUNNER_TEST(T3025_certificate_list_C_API)
331 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
332 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
333 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
334 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
335 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
336 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
337 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
338 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
339 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
340 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
341 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
342 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
343 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
344 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
345 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
346 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
347 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
348 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
349 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
350 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
351 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
352 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
353 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
354 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
355 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
357 "-----END CERTIFICATE-----\n";
359 char* password = NULL;
362 ckmc_policy_s test_policy;
363 test_policy.password = password;
364 test_policy.extractable = 1;
366 char* char_certPem = new char[certPem.length() + 1];
367 std::strcpy(char_certPem, certPem.c_str());
368 cert.raw_cert = (unsigned char *)char_certPem;
369 cert.cert_size = certPem.length();
370 cert.data_format = CKMC_FORM_PEM;
372 int current_aliases_num = count_aliases(ALIAS_CERT);
375 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test1", cert, test_policy)),
379 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test2", cert, test_policy)),
383 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test3", cert, test_policy)),
387 (current_aliases_num+3) == (temp = count_aliases(ALIAS_CERT)),
388 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
392 RUNNER_CHILD_TEST(T3026_user_app_save_key_C_API)
394 AccessProvider ap("mylabel");
395 ap.allowAPI("key-manager::api-storage", "rw");
396 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
398 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
399 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
400 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
401 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
402 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
403 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
404 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
406 "-----END PUBLIC KEY-----";
410 ckmc_key_s test_key, *test_key2;
411 ckmc_policy_s test_policy;
413 char* password = NULL;
414 const char *passwordPolicy = "x";
415 const char *alias = "mykey";
416 char* char_keypem = new char[keyPem.length() + 1];
418 std::strcpy(char_keypem, keyPem.c_str());
419 test_key.raw_key = (unsigned char *)char_keypem;
420 test_key.key_size = keyPem.length();
421 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
422 test_key.password = password;
424 test_policy.password = const_cast<char *>(passwordPolicy);
425 test_policy.extractable = 1;
427 test_key2 = &test_key;
431 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
434 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, passwordPolicy, &test_key2)),
437 // RUNNER_ASSERT_MSG(
438 // key.getDER() == key2.getDER(), "Key value has been changed by service");
441 RUNNER_CHILD_TEST(T3027_app_user_save_keys_exportable_flag)
443 AccessProvider ap("mylabel");
444 ap.allowAPI("key-manager::api-storage", "rw");
445 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
448 auto manager = CKM::Manager::create();
450 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
451 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
452 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
453 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
454 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
455 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
456 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
458 "-----END PUBLIC KEY-----";
460 ckmc_policy_s test_policy;
461 ckmc_key_s test_key, *test_key2;
462 char* char_keypem = new char[keyPem.length() + 1];
463 char* password = NULL;
465 std::strcpy(char_keypem, keyPem.c_str());
466 test_key.raw_key = (unsigned char *)char_keypem;
467 test_key.key_size = keyPem.length();
468 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
469 test_key.password = password;
471 test_policy.password = password;
472 test_policy.extractable = 0;
475 CKMC_ERROR_NONE == (temp = ckmc_save_key("appkey1", test_key, test_policy)),
479 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key("appkey1", password, &test_key2)),
484 RUNNER_TEST(T3028_certificate_with_DSA_key_C_API)
488 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
489 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
490 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
491 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
492 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
493 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
494 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
495 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
496 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
497 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
498 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
499 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
500 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
501 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
502 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
503 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
504 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
505 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
506 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
507 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
508 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
509 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
510 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
511 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
512 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
514 "-----END CERTIFICATE-----\n";
516 char* password = NULL;
517 ckmc_cert_s *cert2 = NULL;
520 ckmc_policy_s test_policy;
521 test_policy.password = password;
522 test_policy.extractable = 1;
524 char* char_certPem = new char[certPem.length() + 1];
525 std::strcpy(char_certPem, certPem.c_str());
526 cert.raw_cert = (unsigned char *)char_certPem;
527 cert.cert_size = certPem.length();
528 cert.data_format = CKMC_FORM_PEM;
530 const char *alias = "test-cert-1-DSA";
532 CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias, cert, test_policy)),
536 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
539 ckmc_cert_free(cert2);
542 RUNNER_TEST(T3029_deinit_C_API)
546 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
548 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
551 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
554 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
559 RUNNER_TEST_GROUP_INIT (T3030_CKMC_QUICK_GET_ALIAS_TESTS_C_API);
561 RUNNER_TEST(T3031_init_C_API)
566 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
569 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
573 RUNNER_TEST(T3032_save_keys_get_alias_C_API)
577 char* password = NULL;
578 ckmc_policy_s test_policy1, test_policy2, test_policy3;
581 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
582 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
583 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
584 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
585 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
586 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
587 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
589 "-----END PUBLIC KEY-----";
591 char* char_keypem = new char[keyPem.length() + 1];
593 std::strcpy(char_keypem, keyPem.c_str());
594 test_key.raw_key = (unsigned char *)char_keypem;
595 test_key.key_size = keyPem.length();
596 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
597 test_key.password = password;
599 test_policy1.password = password;
600 test_policy1.extractable = 1;
602 test_policy2.password = password;
603 test_policy2.extractable = 0;
605 test_policy3.password = password;
606 test_policy3.extractable = 0;
608 int current_aliases_num = count_aliases(ALIAS_KEY);
611 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey1", test_key, test_policy1)),
615 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey2", test_key, test_policy2)),
619 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey3", test_key, test_policy3)),
623 (current_aliases_num+3) == (temp = count_aliases(ALIAS_KEY)),
624 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
628 RUNNER_TEST(T3033_remove_key_C_API)
632 char* password = NULL;
634 ckmc_key_s *test_key2;
636 CKMC_ERROR_NONE == (temp = ckmc_get_key("rootkey1", password, &test_key2)),
640 CKMC_ERROR_NONE == (temp = ckmc_remove_key("rootkey1")),
644 CKMC_ERROR_NONE != (temp = ckmc_get_key("rootkey1", password, &test_key2)),
648 RUNNER_TEST(T3034_deinit_C_API)
652 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
654 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
657 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
660 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
664 RUNNER_TEST_GROUP_INIT (T3040_CKMC_QUICK_REMOVE_BIN_DATA_TEST_C_API);
666 RUNNER_TEST(T3041_init_C_API)
670 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
673 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
677 RUNNER_TEST(T3042_save_get_bin_data_C_API)
681 ckmc_raw_buffer_s testData1, testData2, testData3;
682 char* password = NULL;
684 std::string binData1 = "My bin data1";
685 std::string binData2 = "My bin data2";
686 std::string binData3 = "My bin data3";
687 char* char_binData1 = new char[binData1.length() + 1];
688 char* char_binData2 = new char[binData2.length() + 1];
689 char* char_binData3 = new char[binData3.length() + 1];
690 std::strcpy(char_binData1, binData1.c_str());
691 std::strcpy(char_binData2, binData2.c_str());
692 std::strcpy(char_binData3, binData3.c_str());
693 testData1.data = (unsigned char *) char_binData1;
694 testData2.data = (unsigned char *) char_binData2;
695 testData3.data = (unsigned char *) char_binData3;
696 testData1.size = binData1.length()+1;
697 testData2.size = binData2.length()+1;
698 testData3.size = binData3.length()+1;
700 ckmc_policy_s test_policy1, test_policy2, test_policy3;
702 test_policy1.password = password;
703 test_policy1.extractable = 1;
704 test_policy2.password = password;
705 test_policy2.extractable = 1;
706 test_policy3.password = password;
707 test_policy3.extractable = 0;
709 int current_aliases_num = count_aliases(ALIAS_DATA);
712 CKMC_ERROR_NONE == (temp = ckmc_save_data("data1", testData1, test_policy1)), // should change it as null value
716 CKMC_ERROR_NONE == (temp = ckmc_save_data("data2", testData2, test_policy1)), // should change it as null value
720 CKMC_ERROR_NONE == (temp = ckmc_save_data("data3", testData3, test_policy2)),
724 CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_save_data("data4", testData3, test_policy3)),
728 (current_aliases_num+3) == (temp = count_aliases(ALIAS_DATA)),
729 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
731 ckmc_raw_buffer_s *testData4;
733 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData4)),
737 compareResult = (strcmp((const char *)testData2.data, (const char *)testData4->data));
738 RUNNER_ASSERT_MSG( compareResult == 0,
742 RUNNER_CHILD_TEST(T3043_app_user_save_bin_data_C_API)
744 AccessProvider ap("mylabel");
745 ap.allowAPI("key-manager::api-storage", "rw");
746 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
749 ckmc_raw_buffer_s testData1;
750 char* password = NULL;
751 std::string binData1 = "My bin data";
752 char* char_binData1 = new char[binData1.length() + 1];
753 std::strcpy(char_binData1, binData1.c_str());
754 testData1.data = (unsigned char *) char_binData1;
755 testData1.size = binData1.length()+1;
757 ckmc_policy_s test_policy1, test_policy2;
759 test_policy1.password = password;
760 test_policy1.extractable = 1;
762 test_policy2.password = password;
763 test_policy2.extractable = 1;
765 std::string binData = "My bin data";
767 int current_aliases_num = count_aliases(ALIAS_DATA);
770 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata1", testData1, test_policy1)),
773 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata2", testData1, test_policy1)),
776 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata3", testData1, test_policy2)),
780 (current_aliases_num+3) == (temp = count_aliases(ALIAS_DATA)),
781 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
784 RUNNER_TEST(T3044_remove_bin_data_C_API)
788 int current_aliases_num = count_aliases(ALIAS_DATA, 2);
791 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data1")),
794 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data3")),
798 (current_aliases_num-2) == (temp = count_aliases(ALIAS_DATA)),
799 "Error: expecting " << (current_aliases_num-2) << " aliases, while found " << temp);
801 char* password = NULL;
803 ckmc_raw_buffer_s *testData1, testData2;
805 std::string testStr = "My bin data2";
806 char* char_testData2 = new char[testStr.length() + 1];
807 std::strcpy(char_testData2, testStr.c_str());
808 testData2.data = (unsigned char *) char_testData2;
809 testData2.size = testStr.length()+1;
811 CKM::RawBuffer buffer;
813 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData1)),
817 compareResult = (strcmp((const char *)testData2.data, (const char *)testData1->data));
818 RUNNER_ASSERT_MSG( compareResult == 0,
822 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_data("data3", password, &testData1)),
826 RUNNER_TEST(T3045_deinit_C_API)
831 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
834 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
837 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
840 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
844 RUNNER_TEST_GROUP_INIT(T305_CKMC_QUICK_CREATE_PAIR_CAPI);
846 RUNNER_TEST(T3051_CAPI_init)
851 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
855 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
859 RUNNER_CHILD_TEST(T3052_CAPI_create_rsa_key)
863 AccessProvider ap("mylabel");
864 ap.allowAPI("key-manager::api-storage", "rw");
865 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
868 const char *private_key_alias = "RSA-test-1-priv";
869 const char *public_key_alias = "RSA-test-1-pub";
870 ckmc_policy_s policy_private_key;
871 ckmc_policy_s policy_public_key;
873 policy_private_key.password = NULL;
874 policy_private_key.extractable = 1;
876 policy_public_key.password = NULL;
877 policy_public_key.extractable = 1;
880 int current_aliases_num = count_aliases(ALIAS_KEY);
883 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
887 (current_aliases_num+2) == (temp = count_aliases(ALIAS_KEY)),
888 "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << temp);
890 ckmc_key_s *privateKey;
892 CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
895 privateKey->key_type == CKMC_KEY_RSA_PRIVATE,
896 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
898 privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
901 ckmc_key_s *publicKey;
903 CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &publicKey)),
906 publicKey->key_type == CKMC_KEY_RSA_PUBLIC,
907 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PUBLIC) << ", actual=" << static_cast<int>(publicKey->key_type));
909 publicKey != NULL && publicKey->key_size > 0 && publicKey->raw_key != NULL,
912 // on next attempt to generate keys with the same alias, expect fail (alias exists)
914 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
915 "Error=" << temp << ", ret=" << temp);
918 RUNNER_CHILD_TEST(T3053_CAPI_create_dsa_key)
922 const char *private_key_alias = "DSA-test-2-priv";
923 const char *public_key_alias = "DSA-test-2-pub";
924 ckmc_policy_s policy_private_key;
925 ckmc_policy_s policy_public_key;
927 policy_private_key.password = NULL;
928 policy_private_key.extractable = 1;
930 policy_public_key.password = NULL;
931 policy_public_key.extractable = 1;
933 int current_aliases_num = count_aliases(ALIAS_KEY);
936 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
940 (current_aliases_num+2) == (temp = count_aliases(ALIAS_KEY)),
941 "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << temp);
943 ckmc_key_s *privateKey = 0;
945 CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
948 privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
951 privateKey->key_type == CKMC_KEY_DSA_PRIVATE,
952 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
953 ckmc_key_free(privateKey);
955 ckmc_key_s *pubKey = 0;
957 CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &pubKey)),
960 pubKey != NULL && pubKey->key_size > 0 && pubKey->raw_key != NULL,
963 pubKey->key_type == CKMC_KEY_DSA_PUBLIC,
964 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PUBLIC) << ", actual=" << static_cast<int>(pubKey->key_type));
965 ckmc_key_free(pubKey);
967 // on next attempt to generate keys with the same alias, expect fail (alias exists)
969 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
970 "Error=" << temp << ", ret=" << temp);
974 RUNNER_TEST(T3054_CAPI_deinit)
979 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
982 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
987 RUNNER_TEST_GROUP_INIT(T306_CKMC_CAPI_CreateKeyPair);
989 RUNNER_TEST(T3061_CAPI_init)
993 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
996 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
999 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1002 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1006 RUNNER_TEST(T3062_CAPI_CreateKeyPairRSA)
1011 const char *private_key_alias = "rsa-test-1";
1012 const char *public_key_alias = "rsa-test-2";
1013 ckmc_policy_s policy_private_key;
1014 ckmc_policy_s policy_public_key;
1016 policy_private_key.password = const_cast<char *>("privatepassword");
1017 policy_private_key.extractable = 0;
1019 policy_public_key.password = NULL;
1020 policy_public_key.extractable = 1;
1023 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1026 // on next attempt to generate keys with the same alias, expect fail (alias exists)
1028 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1029 "Error=" << temp << ", ret=" << temp);
1032 RUNNER_TEST(T3063_CAPI_CreateKeyPairDSA)
1037 const char *private_key_alias = "dsa-test-1";
1038 const char *public_key_alias = "dsa-test-2";
1039 ckmc_policy_s policy_private_key;
1040 ckmc_policy_s policy_public_key;
1042 policy_private_key.password = const_cast<char *>("privatepassword");
1043 policy_private_key.extractable = 0;
1045 policy_public_key.password = NULL;
1046 policy_public_key.extractable = 1;
1049 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1053 RUNNER_TEST(T3064_CAPI_CreateKeyPairECDSA)
1057 ckmc_ec_type_e ectype = CKMC_EC_PRIME192V1;
1058 const char *private_key_alias = "ecdsa-test-1";
1059 const char *public_key_alias = "ecdsa-test-2";
1060 ckmc_policy_s policy_private_key;
1061 ckmc_policy_s policy_public_key;
1063 policy_private_key.password = const_cast<char *>("privatepassword");
1064 policy_private_key.extractable = 0;
1066 policy_public_key.password = NULL;
1067 policy_public_key.extractable = 1;
1070 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_ecdsa(ectype, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1074 RUNNER_TEST(T3065_CAPI_deinit)
1079 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1082 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1087 //RUNNER_TEST_GROUP_INIT(T120_NEGATIVE_TESTS);
1091 RUNNER_TEST_GROUP_INIT(T307_CKMC_CAPI_QUICK_SET_GET_TESTS);
1093 RUNNER_TEST(T3071_CAPI_init)
1097 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1101 RUNNER_TEST(T3072_CAPI_get_chain)
1104 "-----BEGIN CERTIFICATE-----\n"
1105 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
1106 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1107 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
1108 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
1109 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
1110 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
1111 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
1112 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
1113 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
1114 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
1115 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
1116 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
1117 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
1118 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
1119 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
1120 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
1121 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
1122 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
1123 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
1124 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
1125 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
1126 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
1127 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
1128 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
1129 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
1130 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
1131 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
1132 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
1133 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
1134 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
1135 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
1137 "-----END CERTIFICATE-----\n";
1140 "-----BEGIN CERTIFICATE-----\n"
1141 "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
1142 "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1143 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
1144 "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
1145 "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
1146 "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
1147 "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
1148 "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
1149 "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
1150 "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
1151 "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
1152 "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
1153 "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
1154 "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
1155 "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
1156 "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
1157 "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
1158 "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
1159 "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
1160 "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
1161 "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
1162 "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
1163 "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
1164 "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
1165 "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
1166 "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
1167 "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
1168 "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
1169 "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
1170 "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
1171 "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
1172 "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
1173 "-----END CERTIFICATE-----\n";
1176 c_cert.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(ee.c_str()));
1177 c_cert.cert_size = ee.size();
1178 c_cert.data_format = CKMC_FORM_PEM;
1180 ckmc_cert_s c_cert1;
1181 c_cert1.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(im.c_str()));
1182 c_cert1.cert_size = im.size();
1183 c_cert1.data_format = CKMC_FORM_PEM;
1185 ckmc_cert_list_s untrustedcerts;
1186 untrustedcerts.cert = &c_cert1;
1187 untrustedcerts.next = NULL;
1189 ckmc_cert_list_s *cert_chain_list;
1193 tmp = ckmc_get_cert_chain(&c_cert, &untrustedcerts, &cert_chain_list);
1195 CKMC_ERROR_NONE == tmp, "Error=" << tmp << "/" << CKM::ErrorToString(tmp));
1198 ckmc_cert_list_s *current;
1199 ckmc_cert_list_s *next =cert_chain_list;
1202 next = current->next;
1204 }while(next != NULL);
1205 RUNNER_ASSERT_MSG(cnt == 3, "Wrong size of certificate chain.");
1207 ckmc_cert_list_s *cert_chain_list2 = NULL;
1208 ckmc_cert_list_s *untrustedcerts2 = NULL;
1210 CKMC_ERROR_VERIFICATION_FAILED == (tmp = ckmc_get_cert_chain(&c_cert, untrustedcerts2, &cert_chain_list2)),
1211 "Error=" << tmp << "/" << CKM::ErrorToString(tmp));
1214 cert_chain_list2 == NULL,
1215 "Wrong size of certificate chain.");
1218 RUNNER_TEST(T3073_CAPI_get_chain_with_alias)
1221 "-----BEGIN CERTIFICATE-----\n"
1222 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
1223 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1224 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
1225 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
1226 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
1227 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
1228 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
1229 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
1230 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
1231 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
1232 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
1233 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
1234 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
1235 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
1236 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
1237 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
1238 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
1239 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
1240 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
1241 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
1242 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
1243 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
1244 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
1245 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
1246 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
1247 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
1248 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
1249 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
1250 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
1251 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
1252 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
1254 "-----END CERTIFICATE-----\n";
1257 "-----BEGIN CERTIFICATE-----\n"
1258 "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
1259 "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1260 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
1261 "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
1262 "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
1263 "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
1264 "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
1265 "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
1266 "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
1267 "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
1268 "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
1269 "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
1270 "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
1271 "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
1272 "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
1273 "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
1274 "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
1275 "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
1276 "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
1277 "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
1278 "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
1279 "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
1280 "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
1281 "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
1282 "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
1283 "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
1284 "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
1285 "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
1286 "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
1287 "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
1288 "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
1289 "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
1290 "-----END CERTIFICATE-----\n";
1293 c_cert.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(ee.c_str()));
1294 c_cert.cert_size = ee.size();
1295 c_cert.data_format = CKMC_FORM_PEM;
1297 // save untrusted certificate
1298 ckmc_cert_s c_cert1;
1299 c_cert1.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(im.c_str()));
1300 c_cert1.cert_size = im.size();
1301 c_cert1.data_format = CKMC_FORM_PEM;
1302 ckmc_policy_s test_policy;
1303 test_policy.password = NULL;
1304 test_policy.extractable = 1;
1306 const char *untrusted_alias = "untrusted_certificate";
1309 CKMC_ERROR_NONE == (tmp = ckmc_save_cert(untrusted_alias, c_cert1, test_policy)),
1312 CharPtr top_label = get_label();
1313 std::string full_address = aliasWithLabel(top_label.get(), untrusted_alias);
1315 // check if exists (access with full path)
1316 ckmc_cert_s *c_cert_tmp;
1318 CKMC_ERROR_NONE == (tmp = ckmc_get_cert(full_address.c_str(), NULL, &c_cert_tmp)),
1320 ckmc_cert_free(c_cert_tmp);
1322 // get cert chain using alias in full "label alias" form
1323 ckmc_alias_list_s *untrustedcerts = (ckmc_alias_list_s *)malloc(sizeof(ckmc_alias_list_s));
1324 untrustedcerts->alias = strdup(full_address.c_str());
1325 untrustedcerts->next = NULL;
1326 ckmc_cert_list_s *cert_chain_list;
1328 tmp = ckmc_get_cert_chain_with_alias(&c_cert, untrustedcerts, &cert_chain_list);
1330 CKMC_ERROR_NONE == tmp, "Error=" << tmp << "/" << CKM::ErrorToString(tmp));
1331 ckmc_alias_list_free(untrustedcerts);
1335 ckmc_cert_list_s *current;
1336 ckmc_cert_list_s *next = cert_chain_list;
1339 next = current->next;
1341 }while(next != NULL);
1342 RUNNER_ASSERT_MSG(cnt == 3, "Wrong size of certificate chain.");
1344 ckmc_cert_list_s *cert_chain_list2 = NULL;
1345 ckmc_alias_list_s *untrustedcerts2 = NULL;
1347 CKMC_ERROR_VERIFICATION_FAILED == (tmp = ckmc_get_cert_chain_with_alias(&c_cert, untrustedcerts2, &cert_chain_list2)),
1348 "Error=" << tmp << "/" << CKM::ErrorToString(tmp));
1351 cert_chain_list2 == NULL,
1352 "Wrong size of certificate chain.");
1355 RUNNER_TEST(T3074_CAPI_deinit)
1360 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1363 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1368 RUNNER_TEST_GROUP_INIT(T308_CAPI_CREATE_AND_VERIFY_SIGNATURE);
1370 RUNNER_TEST(T3081_CAPI__init)
1375 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1379 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1383 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1387 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1391 RUNNER_TEST(T3082_CAPI__rsa_key_create_verify)
1395 std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1396 "Proc-Type: 4,ENCRYPTED\n"
1397 "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1399 "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1400 "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1401 "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1402 "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1403 "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1404 "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1405 "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1406 "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1407 "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1408 "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1409 "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1410 "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1411 "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1412 "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1413 "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1414 "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1415 "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1416 "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1417 "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1418 "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1419 "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1420 "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1421 "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1422 "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1423 "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1424 "-----END RSA PRIVATE KEY-----\n";
1426 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1427 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1428 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1429 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1430 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1431 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1432 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1434 "-----END PUBLIC KEY-----\n";
1436 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1438 const char *pub_alias = "pub1";
1439 const char *pri_alias = "prv1";
1440 const char *key_passwd = "1234";
1441 char *pri_passwd = NULL;
1442 char *pub_passwd = NULL;
1443 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1444 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1445 ckmc_raw_buffer_s *signature;
1448 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1449 pubkey.key_size = pub.size();
1450 pubkey.key_type = CKMC_KEY_NONE;
1451 pubkey.password = NULL;
1453 ckmc_policy_s pubpolicy;
1454 pubpolicy.password = pub_passwd;
1455 pubpolicy.extractable = 0;
1457 ckmc_policy_s pripolicy;
1458 pripolicy.password = pri_passwd;
1459 pripolicy.extractable = 1;
1462 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1463 prikey.key_size = prv.size();
1464 prikey.key_type = CKMC_KEY_NONE;
1465 prikey.password = const_cast<char *>(key_passwd);
1469 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1473 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1477 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1487 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1497 RUNNER_TEST(T3083_CAPI__rsa_key_create_verify_negative)
1501 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message asdfaslkdfjlksadjf test");
1502 const char *pub_alias = "pub1";
1503 const char *pri_alias = "prv1";
1504 char *pri_passwd = NULL;
1505 char *pub_passwd = NULL;
1506 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1507 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1508 ckmc_raw_buffer_s *signature;
1511 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1521 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1530 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1531 memcpy((void*)signature->data, "BROKEN", 6);
1534 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1544 RUNNER_TEST(T3084_CAPI__ec_key_create_verify)
1548 std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1549 "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1550 "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1551 "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1552 "-----END EC PRIVATE KEY-----\n";
1554 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1555 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1556 "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1557 "-----END PUBLIC KEY-----\n";
1559 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1560 const char *pri_alias = "ecprv2";
1561 const char *pub_alias = "ecpub2";
1562 char *key_passwd = NULL;
1563 char *pri_passwd = NULL;
1564 char *pub_passwd = NULL;
1565 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1566 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1567 ckmc_raw_buffer_s *signature;
1570 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1571 pubkey.key_size = pub.size();
1572 pubkey.key_type = CKMC_KEY_NONE;
1573 pubkey.password = NULL;
1575 ckmc_policy_s pubpolicy;
1576 pubpolicy.password = pub_passwd;
1577 pubpolicy.extractable = 1;
1580 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1581 prikey.key_size = prv.size();
1582 prikey.key_type = CKMC_KEY_NONE;
1583 prikey.password = key_passwd;
1585 ckmc_policy_s pripolicy;
1586 pripolicy.password = pri_passwd;
1587 pripolicy.extractable = 0;
1590 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1593 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1597 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1607 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1616 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1617 memcpy((void*)signature->data, "BROKEN", 6);
1620 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1630 RUNNER_TEST(T3085_CAPI__rsa_cert_create_verify_signature)
1635 "-----BEGIN RSA PRIVATE KEY-----\n"
1636 "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1637 "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1638 "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1639 "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1640 "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1641 "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1642 "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1643 "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1644 "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1645 "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1646 "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1647 "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1648 "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1649 "-----END RSA PRIVATE KEY-----\n";
1652 "-----BEGIN CERTIFICATE-----\n"
1653 "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1654 "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1655 "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1656 "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1657 "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1658 "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1659 "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1660 "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1661 "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1662 "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1663 "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1664 "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1665 "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1666 "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1667 "-----END CERTIFICATE-----\n";
1669 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1671 const char *pri_alias = "prv3";
1672 const char *pub_alias = "pub3";
1673 char *key_passwd = NULL;
1674 char *pri_passwd = NULL;
1675 char *pub_passwd = NULL;
1676 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1677 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1678 ckmc_raw_buffer_s *signature;
1681 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1682 cert.cert_size = pub.size();
1683 cert.data_format = CKMC_FORM_PEM;
1685 ckmc_policy_s certpolicy;
1686 certpolicy.password = pub_passwd;
1687 certpolicy.extractable = 1;
1690 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1691 prikey.key_size = prv.size();
1692 prikey.key_type = CKMC_KEY_NONE;
1693 prikey.password = key_passwd;
1695 ckmc_policy_s pripolicy;
1696 pripolicy.password = pri_passwd;
1697 pripolicy.extractable = 0;
1700 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1703 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1708 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1718 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1727 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1728 memcpy((void*)signature->data, "BROKEN", 6);
1731 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1741 RUNNER_TEST(T3086_CAPI__dsa_ext_key_create_verify_with_negative)
1745 const std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1746 "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1747 "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1748 "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1749 "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1750 "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1751 "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1752 "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1753 "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1754 "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1755 "YMYCBhubtrVaLmc=\n"
1756 "-----END PUBLIC KEY-----";
1758 const std::string priv = "-----BEGIN DSA PRIVATE KEY-----\n"
1759 "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1760 "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1761 "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1762 "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1763 "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1764 "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1765 "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1766 "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1767 "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1768 "u1roOuaPY+Hl19BlTE2qdw==\n"
1769 "-----END DSA PRIVATE KEY-----";
1771 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1773 const char *pub_alias = "dsa-pub1";
1774 const char *pri_alias = "dsa-prv1";
1775 char *pri_passwd = NULL;
1776 char *pub_passwd = NULL;
1777 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1778 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1779 ckmc_raw_buffer_s *signature = NULL;
1782 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1783 pubkey.key_size = pub.size();
1784 pubkey.key_type = CKMC_KEY_NONE;
1785 pubkey.password = NULL;
1787 ckmc_policy_s pubpolicy;
1788 pubpolicy.password = pub_passwd;
1789 pubpolicy.extractable = 0;
1791 ckmc_policy_s pripolicy;
1792 pripolicy.password = pri_passwd;
1793 pripolicy.extractable = 1;
1796 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(priv.c_str()));
1797 prikey.key_size = priv.size();
1798 prikey.key_type = CKMC_KEY_NONE;
1799 prikey.password = NULL;
1803 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1807 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1811 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1822 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1832 ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1834 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1843 ckmc_buffer_free(signature);
1846 RUNNER_TEST(T3087_CAPI__dsa_int_key_create_verify_with_negative)
1851 ckmc_policy_s policy_private_key;
1852 ckmc_policy_s policy_public_key;
1854 policy_private_key.password = NULL;
1855 policy_private_key.extractable = 1;
1857 policy_public_key.password = NULL;
1858 policy_public_key.extractable = 1;
1860 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1862 const char *pub_alias = "dsa-pub2";
1863 const char *pri_alias = "dsa-prv2";
1866 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, pri_alias, pub_alias, policy_private_key, policy_public_key)),
1869 char *pri_passwd = NULL;
1870 char *pub_passwd = NULL;
1871 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1872 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1873 ckmc_raw_buffer_s *signature;
1875 ckmc_key_s *pubkey = NULL;
1876 ckmc_key_s *prikey = NULL;
1878 CKMC_ERROR_NONE == (temp = ckmc_get_key(pri_alias, 0, &prikey)),
1882 CKMC_ERROR_NONE == (temp = ckmc_get_key(pub_alias, 0, &pubkey)),
1886 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1897 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1907 ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1909 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1918 ckmc_key_free(prikey);
1919 ckmc_key_free(pubkey);
1920 ckmc_buffer_free(signature);
1923 RUNNER_TEST(T3088_CAPI__ecdsa_cert_create_verify_signature)
1928 "-----BEGIN EC PRIVATE KEY-----\n"
1929 "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1930 "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1931 "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1932 "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1933 "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1934 "ELyhe7yPCAuOoLZlTLgf\n"
1935 "-----END EC PRIVATE KEY-----\n";
1938 "-----BEGIN CERTIFICATE-----\n"
1939 "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1940 "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1941 "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1942 "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1943 "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1944 "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1945 "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1946 "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1947 "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1948 "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1949 "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1950 "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1951 "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1952 "Q1oBry6NEc+lLFmWMDesAA==\n"
1953 "-----END CERTIFICATE-----\n";
1955 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1957 const char *pri_alias = "prv4";
1958 const char *pub_alias = "pub4";
1959 char *key_passwd = NULL;
1960 char *pri_passwd = NULL;
1961 char *pub_passwd = NULL;
1962 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1963 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1964 ckmc_raw_buffer_s *signature;
1967 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1968 cert.cert_size = pub.size();
1969 cert.data_format = CKMC_FORM_PEM;
1971 ckmc_policy_s certpolicy;
1972 certpolicy.password = pub_passwd;
1973 certpolicy.extractable = 1;
1976 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1977 prikey.key_size = prv.size();
1978 prikey.key_type = CKMC_KEY_NONE;
1979 prikey.password = key_passwd;
1981 ckmc_policy_s pripolicy;
1982 pripolicy.password = pri_passwd;
1983 pripolicy.extractable = 0;
1987 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1990 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1994 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
2004 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
2013 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
2014 memcpy((void*)signature->data, "BROKEN", 6);
2017 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
2027 RUNNER_TEST(T3089_CAPI__deinit)
2032 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2035 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2040 //#######################################################################################
2042 void _assertKey(ckmc_key_s *key, unsigned char *raw_key, unsigned int key_size, ckmc_key_type_e key_type, char *password)
2044 RUNNER_ASSERT_MSG(key->key_size == key_size, "Key Size Error" );
2045 RUNNER_ASSERT_MSG(key->key_type == key_type, "Key Type Error" );
2047 if(key->password != NULL && password != NULL) {
2048 RUNNER_ASSERT_MSG(strcmp(key->password, password) == 0, "Password Error" );
2049 }else if(key->password == NULL && password == NULL) {
2050 RUNNER_ASSERT_MSG(true, "Password Error" );
2052 RUNNER_ASSERT_MSG(false, "Password Error" );
2055 if(key->raw_key != NULL && raw_key != NULL) {
2056 for(unsigned int i=0; i<key_size; i++) {
2057 RUNNER_ASSERT_MSG((key->raw_key)[i] == raw_key[i], "Raw Key Error" );
2059 }else if(key->raw_key == NULL && raw_key == NULL) {
2060 RUNNER_ASSERT_MSG(true, "Raw Key Error" );
2062 RUNNER_ASSERT_MSG(false, "Raw Key Error" );
2066 RUNNER_TEST_GROUP_INIT(T309_CKMC_CAPI_TYPES);
2068 RUNNER_TEST(T3091_CAPI_TYPE_init)
2072 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2075 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2078 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
2081 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
2085 RUNNER_TEST(T3092_CAPI_TYPE_KEY)
2087 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2088 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2089 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2090 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2091 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2092 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2093 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2095 "-----END PUBLIC KEY-----";
2097 unsigned char *raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
2098 unsigned int key_size = keyPem.size();
2099 ckmc_key_type_e key_type = CKMC_KEY_NONE;
2100 char *password = const_cast< char *>("");
2103 ckmc_key_new(raw_key, key_size, key_type, password, &key);
2105 _assertKey(key, raw_key, key_size, key_type, password);
2108 char *passwordNull = NULL;
2110 ckmc_key_new(raw_key, key_size, key_type, passwordNull, &key2);
2111 ckmc_key_free(key2);
2114 RUNNER_TEST(T3093_CAPI_TYPE_BUFFER)
2116 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2117 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2118 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2119 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2120 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2121 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2122 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2124 "-----END PUBLIC KEY-----";
2126 unsigned char *data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
2127 unsigned int size = keyPem.size();
2129 ckmc_raw_buffer_s *buff;
2130 ckmc_buffer_new(data, size, &buff);
2132 RUNNER_ASSERT_MSG(buff->size == size, "Size Error" );
2134 if(buff->data != NULL && data != NULL) {
2135 for(unsigned int i=0; i<size; i++) {
2136 RUNNER_ASSERT_MSG((buff->data)[i] == data[i], "Raw data Error" );
2138 }else if(buff->data == NULL && data == NULL) {
2139 RUNNER_ASSERT_MSG(true, "Raw data Error" );
2141 RUNNER_ASSERT_MSG(false, "Raw data Error" );
2144 ckmc_buffer_free(buff);
2147 RUNNER_TEST(T3094_CAPI_TYPE_CERT)
2149 std::string certPem =
2150 "-----BEGIN CERTIFICATE-----\n"
2151 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
2152 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
2153 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
2154 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
2155 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
2156 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
2157 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
2158 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
2159 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
2160 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
2161 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
2162 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
2163 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
2164 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
2165 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
2166 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
2167 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
2168 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
2169 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
2170 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
2171 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
2172 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
2173 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
2174 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
2176 "-----END CERTIFICATE-----\n";
2178 unsigned char *raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(certPem.c_str()));
2179 unsigned int size = certPem.size();
2180 ckmc_data_format_e form = CKMC_FORM_PEM;
2182 ckmc_cert_s *ckmCert;
2183 ckmc_cert_new(raw_cert, size, form, &ckmCert);
2185 RUNNER_ASSERT_MSG(ckmCert->cert_size == size, "Size Error" );
2187 if(ckmCert->raw_cert != NULL && raw_cert != NULL) {
2188 for(unsigned int i=0; i<size; i++) {
2189 RUNNER_ASSERT_MSG((ckmCert->raw_cert)[i] == raw_cert[i], "Raw data Error" );
2191 }else if(ckmCert->raw_cert == NULL && raw_cert == NULL) {
2192 RUNNER_ASSERT_MSG(true, "raw_cert Error" );
2194 RUNNER_ASSERT_MSG(false, "raw_cert Error" );
2197 RUNNER_ASSERT_MSG(ckmCert->data_format == form, "ckmc_cert_form Error" );
2199 ckmc_cert_free(ckmCert);
2203 RUNNER_TEST(T3095_CAPI_TYPE_load_cert_file)
2207 std::string certStr =
2208 "-----BEGIN CERTIFICATE-----\n"
2209 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2210 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2211 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2212 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2213 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2214 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2215 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2216 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2217 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2218 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2219 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2220 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2221 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2222 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2223 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2224 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2225 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2226 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2227 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2228 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2229 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2230 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2231 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2232 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2233 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2234 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2235 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2236 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2237 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2238 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2239 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2241 "-----END CERTIFICATE-----\n";
2243 const char *file_name = "/tmp/ckmc_test_cert.pem";
2247 cert_file = fopen(file_name, "w");
2248 fprintf(cert_file, "%s",certStr.c_str());
2254 CKMC_ERROR_NONE == (ret = ckmc_load_cert_from_file(file_name, &pcert)),
2255 "Error=" << CKM::ErrorToString(ret));
2258 pcert != NULL && pcert->cert_size > 0,"Fail to load cert from file.");
2260 const char *lcert_alias = "lcert_alias";
2261 ckmc_policy_s policy;
2262 policy.password = NULL;
2263 policy.extractable = 1;
2266 CKMC_ERROR_NONE == (ret = ckmc_save_cert(lcert_alias, *pcert, policy)),
2267 "Error=" << CKM::ErrorToString(ret));
2272 RUNNER_TEST(T3096_CAPI_TYPE_load_p12_file) {
2273 std::string p12Base64 =
2274 "MIINaQIBAzCCDS8GCSqGSIb3DQEHAaCCDSAEgg0cMIINGDCCChcGCSqGSIb3DQEH\n"
2275 "BqCCCggwggoEAgEAMIIJ/QYJKoZIhvcNAQcBMBwGCiqGSIb3DQEMAQYwDgQIvO01\n"
2276 "D2ODdkYCAggAgIIJ0NscvWq3hmXai5DQcleOgELPbu2c97d+KJnRGCK7K3eRb0/v\n"
2277 "4F3f3LFSFFT9OAK0/OS1ZYCiO+IuZ6Rpc8Baqe89xVcOHrQ0dQ7sIvbq10dnp5nY\n"
2278 "fEcrt7qPXcRa3IdOX4PFo4aCOFq5bHv5M3quHldKRh4itosjsAGuF/xtnVnO6lU5\n"
2279 "UlPhtAdr2Mpr4SHh+oBbJknLvyd6n/4xZ2elEA8ui4Qt5GfiHwWs2J7KO3Z8M1vW\n"
2280 "yukuyVTaZ6RNkj8dkq/RttvVinlgATYLoosjCsH7VVcd+/z9JqD37QQ89pzdjvJg\n"
2281 "CtXFVbqsOIbjPMkQMYtMdaPsLDDzw6l+q7BJreGIoJmTHbhTtNOJo03XPEnlVXUq\n"
2282 "Q+224ibNKzLAvpSWOo8BUHK7ZDc1oaLODDZ+WAA6jfgHkuhhWYr9dxce6UdhMghJ\n"
2283 "M7ixWwa350psdACREdGxNQzxmucmueprbDumVPAnnJfnKfgRXdKpTDFWS4TaYRc/\n"
2284 "TE4lKSBZpFFduy/gdpLGCHdklTs33aWZ/mEVZJnk2PggKyvSKH9oL3DxkZIFkGdQ\n"
2285 "wcy8gAuLBirdWB/q4JWqW7sH8kMfEwXACEm1z4SzCik8afamQNJEbovA3Pvrhw/P\n"
2286 "1HE5KPNvKMaIr9kk5rTnGGTSNrSMqUCnBl4MjVS4HacrZvvt60y0D3RFB8IqlFMt\n"
2287 "od2FagxojPyO/wP8jDERnySo2Irz0x0WUjWARtcLLH2FOK7ROkX1/WjRZmDV0jtv\n"
2288 "yL8r97XZf/NddVU13Jt13dBJCjxZRvfJZgNI8RybkPQ3Y9J5LIOLVFPU3ZKIi7W7\n"
2289 "KtCw/FCUfEdNarLQMWG0Z9bux7vu/eK1+KpF9pfzD3Q1V0sj2M158Q5W2gy9q/u0\n"
2290 "gOOuybiZB2AL9kxBv0rqb8h7SF5ZIRoy85PrwtnX7w4Xq+4I7RA68bcEGyqgTWWb\n"
2291 "XZxcY65F2slqekXddKeDSTizQk/APgWva/TwgaUeXR9YBCO4o71pla//FNqJ6pRm\n"
2292 "tZjEY9ALBCc083gsImc7+LAeubEcYzjhhgRPQwGJfJTMqgC/NOa9wFhvNO4QcFjf\n"
2293 "XQxxIFxlQJ64qU316FyeuyxLYGd02uakrLLgYtAGG7nPZCYNkUKvCwICKJYI+wAg\n"
2294 "CX0FVwXsR1f33kVuV6sd4YConz80Lk9ayvNJVeCzEOBvhthbMcP3mIn22X+GT3jU\n"
2295 "O5Z0bkXAU0C8XTfLQMk2m6Ag3mctrn4iJBPwQ7j12GnlSLko+e7IssRd4Qj4vBZd\n"
2296 "KXUIoRcOsXqWoQgXJAtdLJEHVo0SUyxVojXsXqUZ3yYOkVUykvXZUcBnS6xwtaUt\n"
2297 "EzdFsEO3NQSLOju5Tpp12lKbrgIToV75zyA3CULEdimEUWD/wA+pDaIS39shNyeE\n"
2298 "edtAp3WF3mDkHQFyKG52IVx7hJU8jXXunvY21tshTAx/Gda0X1CtgSU7Q00ROr+L\n"
2299 "TaehRiKsSgxQa6/jyJY5KY1hIDzwaem5Y7gDnxotmQuPhIX8MeD5Qdv6AVovfScN\n"
2300 "07QuWyUBgFsZzbp79AsnPRLzoiAMQljMn7TXDDLq+uF922OU47BQkzlPfKAuHbyu\n"
2301 "R+uZwtDfMD71FqWjCAHMPyENinsnUehCwX2pVxa6KSs61IsTfb3oUPY1TRxfZnfd\n"
2302 "8SAUfPjKVss9Eyahuv+kzenPUDZn5LV9E0G0DGNxIf493A5Z29scNkQcCBjTJJvx\n"
2303 "4BBJCES6SgkTQl7eFoBGOIqqytpYP9QZW5jy7ramgz/gF2kMKjAfikhbd5vB4Fwd\n"
2304 "QlExMlbW+wL/ffr4AGlwenlDzXBFKQM0mYZNKLuB9LrRzw35fVFZ9XY06VCxhbMa\n"
2305 "wI9gN4rKA3bNG3DCWTsr1TZ6CvrqFJjlfK4KF/+eNfnkIY8uVYxnPlRRkmPw4dpE\n"
2306 "KdaXUiu5WJvZupeYqqNsWdxs+v2KS1E/PcM9BgUFKFD4lW84WbWUHPxvxXoZhSCs\n"
2307 "nQ0hsPd53NKBBdEOao5HAAf+T5yFnJzZ3rVkYBEC67gHyWgXB1Zy283yAIihvUXw\n"
2308 "DOEVppNHnIqAjQpncQcDpV0/zYCvqOEfU+JPpmepgo737Tq2MlUKLTByhg1mQhKm\n"
2309 "2pI63BFiw2/2igImFbmhzJjilWkaM4kwM1uGKOKgjacXI/VSVEajuYAfo37quBxF\n"
2310 "ZWyWJoFXBvQ7jolTKXUVbCqnSSaItosZrS3vcDdGUegRm0rf6IzCRPdSIsfCDdZG\n"
2311 "9UeChoznNezoLENgmqQJTV3wDo3uSZbztlctoERvZpn457MLZEn8hXEwMLPXx2Ur\n"
2312 "HQ5fYAdTBzBpoLiy8ujzFxFJDzW9ytnb7aFF7YVivfj42eVGnCANvVcwkp2/E3MW\n"
2313 "Img0OyqKRQHaGGI7iGNO5KYpTk0CdSyErQarH52ZRvr0t2CK6J6vDgrhJnzd5Ayr\n"
2314 "6t+coAZBw8eIJqiM5WzAm4mlZRSHL+JcaKkrqoYOo+kewj7wgW2Kk/7S8re38RvP\n"
2315 "+V9nqpfr18gIV72G2yZ60C21eRqOFPgl1CYbmWHqYKXatuT4o+kgBmJpez5uvIHz\n"
2316 "LSd88An02ow+WQ+KP8YGV38ZtuA6D4FPA3fsMdhNOqjtwWiPei+ILaXD5PsOfDGH\n"
2317 "2fZgOWXivFYqq9Cm3B3ffFX/oD/7sFMs+/AWeZOh8XqU8ro73L1HNRXx4HdyRUY/\n"
2318 "pInwA0mWaFNGgBRPbNW0A6cZ2dY0Hn8sRRsF+5tIs0hOelpT1y/ZEVyGImTQgEbK\n"
2319 "KeggQGT9h9rhrrUK+hE27MorcRi6tVteKlNyGQsCJko0ZoqqctM4o7wT5ce4nWtb\n"
2320 "ixzp5xDkDmcP6eldHiVm8TsZn0hkmNDu0xpgIVtb4VDRmWP687EOaGHYhjOBw6X1\n"
2321 "GD1d1yyg/VxlUr0lKmbsFVC2mDiWbnWd49+FGsrySc2RO8DlC9xkXLaG+ubjmLpK\n"
2322 "lwagiI2P1MzkHuZiz7WlIjFefuYh0yrYvDA5UDiQTDdoZWFuR5r93QWdsUcHlvdF\n"
2323 "rYmhQ93F6I4gaT9HSVEDJfisIjIUmIwhh20tdGnf3FC5VyqBYS5GQObq3VnC8stU\n"
2324 "b7byCEMlKr5bWslEem6gRGTB9xektKgrsFgS7nb3Geegq9K+mWIBC/iBOInVqFYx\n"
2325 "Uw8+s6ywApXPLPEIrVZumkwo7Rl8lJfCTDNni/68XHhhVHY70N0PSdfnCAvV9G41\n"
2326 "3wuTZHqLOeQG3Sm8I1JJXkWSuuk0QI7DVKZpmz+x4aFBd+rncfvWOEbN9G0ZqbUT\n"
2327 "lGkfxtUWY6pWX/XJpyBzOlv2+fCPi/Yd0csb45IEuFHNG1svgqGMJw5BmFu5v0Qs\n"
2328 "0i1zKBrNA/Acd6+uL0UqDZStB6lyPn6+uifh3sMwggL5BgkqhkiG9w0BBwGgggLq\n"
2329 "BIIC5jCCAuIwggLeBgsqhkiG9w0BDAoBAqCCAqYwggKiMBwGCiqGSIb3DQEMAQMw\n"
2330 "DgQIBJuBj07uHGACAggABIICgJBfOlC99JJjEUBibYLXIJPe53Cy7eDXCtVaPbhX\n"
2331 "VHPCsBrUd7+6Ul7Vh/JHMlJL1VA3WvGnX93f0p5FICgZZA3sIZjpxBoeVkZ0Zx6r\n"
2332 "ZMnBPIN4GaHYufCGPyAlPXgEGjlBr3g6Sxr8j50vsWtfspwiILsyte+nQ3kE1nV4\n"
2333 "TjNBnayXmCMnEkf4kKu+dlLFbd1OY/fQJbiT+f9YtMfcfp2IR+7bXb23UIv8Wt1I\n"
2334 "XyqsYTcUjIvnByKSDrvVu941x1EN5DF1964qQbAZb/z5ueTl8tCpaCFlGbZcXz7X\n"
2335 "7L3k0YWdymx1J+szd6heQJrzqMjcHK3XWC7YlDytWB59j0eNMx42XEFP0pAO+gt9\n"
2336 "Iny2XL+sxJC/xzf6apYMmmGwEXrZkkudsSVMgLCtYyin4zM7PFzLAPK9ryEhsxaP\n"
2337 "g077MJ/aIaZ7PLi7cABz/g+gQ1dSXakNOof6EjRUADHpav9UKeKwWdR8ycB/8AQV\n"
2338 "XxQTpEsFJ7izdNZDNC/ZeOhc/ohnei169rfH0shVeeckjf++c8zlh/Y5UWIi3V6i\n"
2339 "5c7RlIJLMtHrvpB5UxRpZgWSdXvCuTCBEzlZAeWJ11I4DAeioqJ1V3h2KcUjNKf1\n"
2340 "z8mTJrzAycuhm8npaC0Gj6JU7jiYPZLvj+cK/e/gjadWggHFYsjAKhACDbAtG64N\n"
2341 "Gu9PWJszvhSO8ga7TOVEzdbe2jm4oWtqPe3gb6eYl2Ma6GTfj/PUEDpNAOnr99qV\n"
2342 "g3uKIXMBp2115bfUf5sbfPdMbnH12XILXR9Va+JjeQHexa64QWlsiRgtXEAXxoEb\n"
2343 "D2aTlfdsJpgilyj31Y45xOdN7FI+Ltfhudxt1kABPdmKwRMxJTAjBgkqhkiG9w0B\n"
2344 "CRUxFgQUMvxYuPi3XpEeXbzAkXaNbAw7P5gwMTAhMAkGBSsOAwIaBQAEFOBC4ppE\n"
2345 "AXO+xdzSBKimvjBBTLbEBAjlaWiC5IVtmAICCAA=\n";
2348 const char *p12base64file = "/tmp/ckmc_test_p12.p12.b64";
2349 const char *p12file = "/tmp/ckmc_test_p12.p12";
2350 const char *password = "password";
2352 remove(p12base64file);
2356 b64_file = fopen(p12base64file, "w");
2357 fprintf(b64_file, "%s",p12Base64.c_str());
2360 std::string cmd("openssl base64 -d -in ");
2361 cmd.append(p12base64file);
2362 cmd.append(" -out ");
2363 cmd.append(p12file);
2364 system(cmd.c_str());
2368 ckmc_key_s *private_key = NULL;
2369 ckmc_cert_s *cert = NULL;
2370 ckmc_cert_list_s *ca_cert_list = NULL;
2373 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file(p12file, password,
2374 &private_key, &cert, &ca_cert_list)),
2376 RUNNER_ASSERT_MSG(private_key != NULL, "Null private_key");
2377 RUNNER_ASSERT_MSG(cert != NULL, "Null cert");
2378 RUNNER_ASSERT_MSG(ca_cert_list != NULL, "Null ca_cert_list");
2380 ckmc_policy_s policy;
2381 policy.password = NULL;
2382 policy.extractable = 1;
2385 const char *pkey_alias = "pkey_alias";
2387 CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias, *private_key, policy)),
2390 const char *cert_alias = "cert_alias";
2392 CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias, *cert, policy)),
2394 std::string caCertAlias = "ca_cert_alias_";
2395 const char *idx = "0";
2397 ckmc_cert_list_s *tmpList = ca_cert_list;
2398 while(tmpList != NULL) {
2399 caCertAlias.append(idx);
2401 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2403 tmpList = tmpList->next;
2407 RUNNER_ASSERT_MSG(cnt == 2, "Invalid CA Cert Count");
2409 ckmc_key_free(private_key);
2410 ckmc_cert_free(cert);
2411 ckmc_cert_list_all_free(ca_cert_list);
2413 remove(p12base64file);
2417 RUNNER_TEST(T3097_CAPI_TYPE_load_p12_file2) {
2418 std::string p12Base64 =
2419 "MIINaQIBAzCCDS8GCSqGSIb3DQEHAaCCDSAEgg0cMIINGDCCChcGCSqGSIb3DQEH\n"
2420 "BqCCCggwggoEAgEAMIIJ/QYJKoZIhvcNAQcBMBwGCiqGSIb3DQEMAQYwDgQIvO01\n"
2421 "D2ODdkYCAggAgIIJ0NscvWq3hmXai5DQcleOgELPbu2c97d+KJnRGCK7K3eRb0/v\n"
2422 "4F3f3LFSFFT9OAK0/OS1ZYCiO+IuZ6Rpc8Baqe89xVcOHrQ0dQ7sIvbq10dnp5nY\n"
2423 "fEcrt7qPXcRa3IdOX4PFo4aCOFq5bHv5M3quHldKRh4itosjsAGuF/xtnVnO6lU5\n"
2424 "UlPhtAdr2Mpr4SHh+oBbJknLvyd6n/4xZ2elEA8ui4Qt5GfiHwWs2J7KO3Z8M1vW\n"
2425 "yukuyVTaZ6RNkj8dkq/RttvVinlgATYLoosjCsH7VVcd+/z9JqD37QQ89pzdjvJg\n"
2426 "CtXFVbqsOIbjPMkQMYtMdaPsLDDzw6l+q7BJreGIoJmTHbhTtNOJo03XPEnlVXUq\n"
2427 "Q+224ibNKzLAvpSWOo8BUHK7ZDc1oaLODDZ+WAA6jfgHkuhhWYr9dxce6UdhMghJ\n"
2428 "M7ixWwa350psdACREdGxNQzxmucmueprbDumVPAnnJfnKfgRXdKpTDFWS4TaYRc/\n"
2429 "TE4lKSBZpFFduy/gdpLGCHdklTs33aWZ/mEVZJnk2PggKyvSKH9oL3DxkZIFkGdQ\n"
2430 "wcy8gAuLBirdWB/q4JWqW7sH8kMfEwXACEm1z4SzCik8afamQNJEbovA3Pvrhw/P\n"
2431 "1HE5KPNvKMaIr9kk5rTnGGTSNrSMqUCnBl4MjVS4HacrZvvt60y0D3RFB8IqlFMt\n"
2432 "od2FagxojPyO/wP8jDERnySo2Irz0x0WUjWARtcLLH2FOK7ROkX1/WjRZmDV0jtv\n"
2433 "yL8r97XZf/NddVU13Jt13dBJCjxZRvfJZgNI8RybkPQ3Y9J5LIOLVFPU3ZKIi7W7\n"
2434 "KtCw/FCUfEdNarLQMWG0Z9bux7vu/eK1+KpF9pfzD3Q1V0sj2M158Q5W2gy9q/u0\n"
2435 "gOOuybiZB2AL9kxBv0rqb8h7SF5ZIRoy85PrwtnX7w4Xq+4I7RA68bcEGyqgTWWb\n"
2436 "XZxcY65F2slqekXddKeDSTizQk/APgWva/TwgaUeXR9YBCO4o71pla//FNqJ6pRm\n"
2437 "tZjEY9ALBCc083gsImc7+LAeubEcYzjhhgRPQwGJfJTMqgC/NOa9wFhvNO4QcFjf\n"
2438 "XQxxIFxlQJ64qU316FyeuyxLYGd02uakrLLgYtAGG7nPZCYNkUKvCwICKJYI+wAg\n"
2439 "CX0FVwXsR1f33kVuV6sd4YConz80Lk9ayvNJVeCzEOBvhthbMcP3mIn22X+GT3jU\n"
2440 "O5Z0bkXAU0C8XTfLQMk2m6Ag3mctrn4iJBPwQ7j12GnlSLko+e7IssRd4Qj4vBZd\n"
2441 "KXUIoRcOsXqWoQgXJAtdLJEHVo0SUyxVojXsXqUZ3yYOkVUykvXZUcBnS6xwtaUt\n"
2442 "EzdFsEO3NQSLOju5Tpp12lKbrgIToV75zyA3CULEdimEUWD/wA+pDaIS39shNyeE\n"
2443 "edtAp3WF3mDkHQFyKG52IVx7hJU8jXXunvY21tshTAx/Gda0X1CtgSU7Q00ROr+L\n"
2444 "TaehRiKsSgxQa6/jyJY5KY1hIDzwaem5Y7gDnxotmQuPhIX8MeD5Qdv6AVovfScN\n"
2445 "07QuWyUBgFsZzbp79AsnPRLzoiAMQljMn7TXDDLq+uF922OU47BQkzlPfKAuHbyu\n"
2446 "R+uZwtDfMD71FqWjCAHMPyENinsnUehCwX2pVxa6KSs61IsTfb3oUPY1TRxfZnfd\n"
2447 "8SAUfPjKVss9Eyahuv+kzenPUDZn5LV9E0G0DGNxIf493A5Z29scNkQcCBjTJJvx\n"
2448 "4BBJCES6SgkTQl7eFoBGOIqqytpYP9QZW5jy7ramgz/gF2kMKjAfikhbd5vB4Fwd\n"
2449 "QlExMlbW+wL/ffr4AGlwenlDzXBFKQM0mYZNKLuB9LrRzw35fVFZ9XY06VCxhbMa\n"
2450 "wI9gN4rKA3bNG3DCWTsr1TZ6CvrqFJjlfK4KF/+eNfnkIY8uVYxnPlRRkmPw4dpE\n"
2451 "KdaXUiu5WJvZupeYqqNsWdxs+v2KS1E/PcM9BgUFKFD4lW84WbWUHPxvxXoZhSCs\n"
2452 "nQ0hsPd53NKBBdEOao5HAAf+T5yFnJzZ3rVkYBEC67gHyWgXB1Zy283yAIihvUXw\n"
2453 "DOEVppNHnIqAjQpncQcDpV0/zYCvqOEfU+JPpmepgo737Tq2MlUKLTByhg1mQhKm\n"
2454 "2pI63BFiw2/2igImFbmhzJjilWkaM4kwM1uGKOKgjacXI/VSVEajuYAfo37quBxF\n"
2455 "ZWyWJoFXBvQ7jolTKXUVbCqnSSaItosZrS3vcDdGUegRm0rf6IzCRPdSIsfCDdZG\n"
2456 "9UeChoznNezoLENgmqQJTV3wDo3uSZbztlctoERvZpn457MLZEn8hXEwMLPXx2Ur\n"
2457 "HQ5fYAdTBzBpoLiy8ujzFxFJDzW9ytnb7aFF7YVivfj42eVGnCANvVcwkp2/E3MW\n"
2458 "Img0OyqKRQHaGGI7iGNO5KYpTk0CdSyErQarH52ZRvr0t2CK6J6vDgrhJnzd5Ayr\n"
2459 "6t+coAZBw8eIJqiM5WzAm4mlZRSHL+JcaKkrqoYOo+kewj7wgW2Kk/7S8re38RvP\n"
2460 "+V9nqpfr18gIV72G2yZ60C21eRqOFPgl1CYbmWHqYKXatuT4o+kgBmJpez5uvIHz\n"
2461 "LSd88An02ow+WQ+KP8YGV38ZtuA6D4FPA3fsMdhNOqjtwWiPei+ILaXD5PsOfDGH\n"
2462 "2fZgOWXivFYqq9Cm3B3ffFX/oD/7sFMs+/AWeZOh8XqU8ro73L1HNRXx4HdyRUY/\n"
2463 "pInwA0mWaFNGgBRPbNW0A6cZ2dY0Hn8sRRsF+5tIs0hOelpT1y/ZEVyGImTQgEbK\n"
2464 "KeggQGT9h9rhrrUK+hE27MorcRi6tVteKlNyGQsCJko0ZoqqctM4o7wT5ce4nWtb\n"
2465 "ixzp5xDkDmcP6eldHiVm8TsZn0hkmNDu0xpgIVtb4VDRmWP687EOaGHYhjOBw6X1\n"
2466 "GD1d1yyg/VxlUr0lKmbsFVC2mDiWbnWd49+FGsrySc2RO8DlC9xkXLaG+ubjmLpK\n"
2467 "lwagiI2P1MzkHuZiz7WlIjFefuYh0yrYvDA5UDiQTDdoZWFuR5r93QWdsUcHlvdF\n"
2468 "rYmhQ93F6I4gaT9HSVEDJfisIjIUmIwhh20tdGnf3FC5VyqBYS5GQObq3VnC8stU\n"
2469 "b7byCEMlKr5bWslEem6gRGTB9xektKgrsFgS7nb3Geegq9K+mWIBC/iBOInVqFYx\n"
2470 "Uw8+s6ywApXPLPEIrVZumkwo7Rl8lJfCTDNni/68XHhhVHY70N0PSdfnCAvV9G41\n"
2471 "3wuTZHqLOeQG3Sm8I1JJXkWSuuk0QI7DVKZpmz+x4aFBd+rncfvWOEbN9G0ZqbUT\n"
2472 "lGkfxtUWY6pWX/XJpyBzOlv2+fCPi/Yd0csb45IEuFHNG1svgqGMJw5BmFu5v0Qs\n"
2473 "0i1zKBrNA/Acd6+uL0UqDZStB6lyPn6+uifh3sMwggL5BgkqhkiG9w0BBwGgggLq\n"
2474 "BIIC5jCCAuIwggLeBgsqhkiG9w0BDAoBAqCCAqYwggKiMBwGCiqGSIb3DQEMAQMw\n"
2475 "DgQIBJuBj07uHGACAggABIICgJBfOlC99JJjEUBibYLXIJPe53Cy7eDXCtVaPbhX\n"
2476 "VHPCsBrUd7+6Ul7Vh/JHMlJL1VA3WvGnX93f0p5FICgZZA3sIZjpxBoeVkZ0Zx6r\n"
2477 "ZMnBPIN4GaHYufCGPyAlPXgEGjlBr3g6Sxr8j50vsWtfspwiILsyte+nQ3kE1nV4\n"
2478 "TjNBnayXmCMnEkf4kKu+dlLFbd1OY/fQJbiT+f9YtMfcfp2IR+7bXb23UIv8Wt1I\n"
2479 "XyqsYTcUjIvnByKSDrvVu941x1EN5DF1964qQbAZb/z5ueTl8tCpaCFlGbZcXz7X\n"
2480 "7L3k0YWdymx1J+szd6heQJrzqMjcHK3XWC7YlDytWB59j0eNMx42XEFP0pAO+gt9\n"
2481 "Iny2XL+sxJC/xzf6apYMmmGwEXrZkkudsSVMgLCtYyin4zM7PFzLAPK9ryEhsxaP\n"
2482 "g077MJ/aIaZ7PLi7cABz/g+gQ1dSXakNOof6EjRUADHpav9UKeKwWdR8ycB/8AQV\n"
2483 "XxQTpEsFJ7izdNZDNC/ZeOhc/ohnei169rfH0shVeeckjf++c8zlh/Y5UWIi3V6i\n"
2484 "5c7RlIJLMtHrvpB5UxRpZgWSdXvCuTCBEzlZAeWJ11I4DAeioqJ1V3h2KcUjNKf1\n"
2485 "z8mTJrzAycuhm8npaC0Gj6JU7jiYPZLvj+cK/e/gjadWggHFYsjAKhACDbAtG64N\n"
2486 "Gu9PWJszvhSO8ga7TOVEzdbe2jm4oWtqPe3gb6eYl2Ma6GTfj/PUEDpNAOnr99qV\n"
2487 "g3uKIXMBp2115bfUf5sbfPdMbnH12XILXR9Va+JjeQHexa64QWlsiRgtXEAXxoEb\n"
2488 "D2aTlfdsJpgilyj31Y45xOdN7FI+Ltfhudxt1kABPdmKwRMxJTAjBgkqhkiG9w0B\n"
2489 "CRUxFgQUMvxYuPi3XpEeXbzAkXaNbAw7P5gwMTAhMAkGBSsOAwIaBQAEFOBC4ppE\n"
2490 "AXO+xdzSBKimvjBBTLbEBAjlaWiC5IVtmAICCAA=\n";
2493 const char *p12base64file = "/tmp/ckmc_test_p12.p12.b64";
2494 const char *p12file = "/tmp/ckmc_test_p12.p12";
2495 const char *password = "password";
2497 remove(p12base64file);
2501 b64_file = fopen(p12base64file, "w");
2502 fprintf(b64_file, "%s",p12Base64.c_str());
2505 std::string cmd("openssl base64 -d -in ");
2506 cmd.append(p12base64file);
2507 cmd.append(" -out ");
2508 cmd.append(p12file);
2509 system(cmd.c_str());
2513 ckmc_pkcs12_s *ppkcs12 = NULL;
2516 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file2(p12file, password, &ppkcs12)),
2518 RUNNER_ASSERT_MSG(ppkcs12->priv_key != NULL, "Null private_key");
2519 RUNNER_ASSERT_MSG(ppkcs12->cert != NULL, "Null cert");
2520 RUNNER_ASSERT_MSG(ppkcs12->ca_chain != NULL, "Null ca_cert_list");
2522 ckmc_policy_s policy;
2523 policy.password = NULL;
2524 policy.extractable = 1;
2527 const char *pkey_alias = "pkey_alias2";
2529 CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias, *(ppkcs12->priv_key), policy)),
2532 const char *cert_alias = "cert_alias2";
2534 CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias, *(ppkcs12->cert), policy)),
2536 std::string caCertAlias = "ca_cert_alias_2_";
2537 const char *idx = "0";
2539 ckmc_cert_list_s *tmpList = ppkcs12->ca_chain;
2540 while(tmpList != NULL) {
2541 caCertAlias.append(idx);
2543 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2545 tmpList = tmpList->next;
2549 RUNNER_ASSERT_MSG(cnt == 2, "Invalid CA Cert Count");
2551 ckmc_pkcs12_free(ppkcs12);
2553 remove(p12base64file);
2557 RUNNER_TEST(T3098_CAPI_TYPE_deinit)
2561 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2564 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2567 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2570 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2574 RUNNER_TEST_GROUP_INIT(T310_CKMC_CAPI_PKCS12);
2578 const char* alias_PKCS_collision = "CAPI-test-PKCS-collision";
2579 const char* alias_PKCS_exportable = "CAPI-test-PKCS-export";
2580 const char* alias_PKCS_not_exportable = "CAPI-test-PKCS-no-export";
2581 const char* alias_PKCS_priv_key_copy = "CAPI-test-PKCS-private-key-copy";
2582 const char* alias_PKCS_priv_key_wrong = "CAPI-test-PKCS-private-key-wrong";
2585 RUNNER_TEST(T3101_CAPI_PKCS12_init)
2589 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2592 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
2595 ckmc_remove_pkcs12(alias_PKCS_collision);
2596 ckmc_remove_pkcs12(alias_PKCS_exportable);
2597 ckmc_remove_pkcs12(alias_PKCS_not_exportable);
2598 ckmc_remove_pkcs12(alias_PKCS_priv_key_copy);
2599 ckmc_remove_pkcs12(alias_PKCS_priv_key_wrong);
2602 RUNNER_TEST(T3102_CAPI_PKCS12_negative_wrong_password)
2604 const char *wrong_passwd = "wrong";
2605 ckmc_pkcs12_s *ppkcs12 = NULL;
2608 CKMC_ERROR_INVALID_FORMAT == (temp = ckmc_load_from_pkcs12_file2("/usr/share/ckm-test/test1801.pkcs12", wrong_passwd, &ppkcs12)),
2612 RUNNER_TEST(T3103_CAPI_PKCS12_add_bundle_with_chain_certs)
2614 ckmc_pkcs12_s *ppkcs12 = NULL;
2617 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file2("/usr/share/ckm-test/pkcs.p12", NULL, &ppkcs12)),
2620 RUNNER_ASSERT_MSG(NULL != ppkcs12->cert, "no certificate in PKCS12");
2621 RUNNER_ASSERT_MSG(NULL != ppkcs12->priv_key, "no private key in PKCS12");
2622 RUNNER_ASSERT_MSG(NULL != ppkcs12->ca_chain, "no chain certificates in PKCS12");
2626 ckmc_policy_s exportable;
2627 exportable.password = NULL;
2628 exportable.extractable = 1;
2629 ckmc_policy_s notExportable;
2630 notExportable.password = NULL;
2631 notExportable.extractable = 0;
2634 CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_exportable, ppkcs12, exportable, exportable)),
2637 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_exportable, ppkcs12, exportable, exportable)),
2640 CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable, ppkcs12, notExportable, notExportable)),
2643 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable, ppkcs12, notExportable, notExportable)),
2646 // try to lookup key
2647 ckmc_key_s *key_lookup = NULL;
2649 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias_PKCS_exportable, NULL, &key_lookup)),
2651 ckmc_key_free(key_lookup);
2654 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key(alias_PKCS_not_exportable, "", &key_lookup)),
2655 "Error=" << temp << " CKMC_ERROR_NOT_EXPORTABLE=" << CKMC_ERROR_NOT_EXPORTABLE << " CKMC_ERROR_DB_ERROR=" << CKMC_ERROR_DB_ERROR);
2656 ckmc_key_free(key_lookup);
2658 // try to lookup certificate
2659 ckmc_cert_s *cert_lookup = NULL;
2661 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias_PKCS_exportable, NULL, &cert_lookup)),
2663 ckmc_cert_free(cert_lookup);
2666 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_cert(alias_PKCS_not_exportable, NULL, &cert_lookup)),
2668 ckmc_cert_free(cert_lookup);
2671 RUNNER_TEST(T3103_CAPI_PKCS12_get_PKCS)
2674 auto manager = CKM::Manager::create();
2676 ckmc_pkcs12_s *pkcs = NULL;
2680 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_pkcs12("i-do-not-exist", &pkcs)),
2682 ckmc_pkcs12_free(pkcs);
2685 // fail - not exportable
2687 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_pkcs12(alias_PKCS_not_exportable, &pkcs)),
2689 ckmc_pkcs12_free(pkcs);
2692 // success - exportable
2694 CKMC_ERROR_NONE == (temp = ckmc_get_pkcs12(alias_PKCS_exportable, &pkcs)),
2697 RUNNER_ASSERT_MSG(NULL != pkcs->cert, "no certificate in PKCS12");
2698 RUNNER_ASSERT_MSG(NULL != pkcs->priv_key, "no private key in PKCS12");
2699 RUNNER_ASSERT_MSG(NULL != pkcs->ca_chain, "no chain certificates in PKCS12");
2701 ckmc_cert_list_s *iter = pkcs->ca_chain;
2706 RUNNER_ASSERT_MSG(2 == cntr, "invalid number of chain certificates in PKCS12");
2708 ckmc_pkcs12_free(pkcs);
2711 RUNNER_TEST(T3104_CAPI_PKCS12_create_and_verify_signature)
2713 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
2716 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
2717 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
2718 ckmc_raw_buffer_s *signature = NULL;
2721 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
2722 alias_PKCS_exportable,
2731 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
2732 alias_PKCS_exportable,
2741 RUNNER_TEST(T3105_CAPI_PKCS12_remove_bundle_with_chain_certs)
2745 // remove the whole PKCS12 bundles
2747 CKMC_ERROR_NONE == (tmp = ckmc_remove_pkcs12(alias_PKCS_exportable)),
2750 CKMC_ERROR_NONE == (tmp = ckmc_remove_pkcs12(alias_PKCS_not_exportable)),
2753 // expect lookup fails due to unknown alias
2754 // try to lookup key
2755 ckmc_key_s *key_lookup = NULL;
2757 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_exportable, NULL, &key_lookup)),
2759 ckmc_key_free(key_lookup);
2762 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_not_exportable, NULL, &key_lookup)),
2764 ckmc_key_free(key_lookup);
2766 // try to lookup certificate
2767 ckmc_cert_s *cert_lookup = NULL;
2769 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_exportable, NULL, &cert_lookup)),
2771 ckmc_cert_free(cert_lookup);
2774 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_not_exportable, NULL, &cert_lookup)),
2776 ckmc_cert_free(cert_lookup);
2779 RUNNER_TEST(T3109_CAPI_PKCS12_deinit)
2783 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2787 RUNNER_TEST_GROUP_INIT(T3110_CAPI_LOCKTYPE_TESTS);
2789 RUNNER_CHILD_TEST(T3111_CAPI_init_lock_key)
2792 AccessProvider ap("my-label");
2793 ap.allowAPI("key-manager::api-control", "rw");
2794 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2796 char *null_password = NULL;
2798 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,USER_PASS,null_password)),
2799 CKM::ErrorToString(tmp));
2801 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2802 CKM::ErrorToString(tmp));
2805 RUNNER_CHILD_TEST(T3112_CAPI_unlock_default_passwd)
2807 AccessProvider ap("my-label");
2808 ap.allowAPI("key-manager::api-storage", "rw");
2809 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2813 ckmc_key_s test_key, *test_key2;
2814 ckmc_policy_s test_policy;
2816 char* password = NULL;
2817 char alias[20] = "mykey_defpasswd";
2819 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2820 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2821 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2822 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2823 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2824 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2825 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2827 "-----END PUBLIC KEY-----";
2829 char* char_keypem = new char[keyPem.length() + 1];
2831 std::strcpy(char_keypem, keyPem.c_str());
2832 test_key.raw_key = (unsigned char *)char_keypem;
2833 test_key.key_size = keyPem.length();
2834 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2835 test_key.password = password;
2837 test_policy.password = password;
2838 test_policy.extractable = 1;
2840 test_key2 = &test_key;
2843 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
2847 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
2850 CKMC_ERROR_NONE == (temp = ckmc_remove_key(alias)),
2854 RUNNER_CHILD_TEST(T3113_CAPI_init_change_user_password)
2857 AccessProvider ap("my-label");
2858 ap.allowAPI("key-manager::api-control", "rw");
2859 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2861 char *null_password = NULL;
2863 // database has been automatically unlocked with NULL pw in previous test. Lock it now
2865 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2866 CKM::ErrorToString(tmp));
2868 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,null_password,USER_PASS)),
2869 CKM::ErrorToString(tmp));
2870 // get rid of NULL DKEK
2872 CKMC_ERROR_NONE == (tmp = ckmc_unlock_user_key(USER_APP,USER_PASS)),
2873 CKM::ErrorToString(tmp));
2875 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2876 CKM::ErrorToString(tmp));
2879 RUNNER_CHILD_TEST(T3114_CAPI_unlock_default_passwd_negative)
2881 AccessProvider ap("my-label");
2882 ap.allowAPI("key-manager::api-storage", "rw");
2883 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2887 ckmc_key_s test_key, *test_key2;
2888 ckmc_policy_s test_policy;
2890 char* password = NULL;
2891 char alias[20] = "mykey_defpasswd";
2893 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2894 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2895 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2896 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2897 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2898 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2899 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2901 "-----END PUBLIC KEY-----";
2903 char* char_keypem = new char[keyPem.length() + 1];
2905 std::strcpy(char_keypem, keyPem.c_str());
2906 test_key.raw_key = (unsigned char *)char_keypem;
2907 test_key.key_size = keyPem.length();
2908 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2909 test_key.password = password;
2911 test_policy.password = password;
2912 test_policy.extractable = 1;
2914 test_key2 = &test_key;
2917 CKMC_ERROR_DB_LOCKED == (temp = ckmc_save_key(alias, test_key, test_policy)),
2921 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key2)),
2925 RUNNER_CHILD_TEST(T3119_CAPI_deinit)
2929 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2932 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2936 RUNNER_TEST_GROUP_INIT(T320_CAPI_EMPTY_DATABASE);
2938 RUNNER_TEST(T3201_CAPI_unlock_database)
2941 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2943 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2945 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
2949 RUNNER_CHILD_TEST(T3202_CAPI_get_data_from_empty_database)
2952 char alias[10] = "mykey";
2953 char *password = NULL;
2954 ckmc_key_s *test_key = NULL;
2957 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(alias, password, &test_key)),
2960 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2963 RUNNER_CHILD_TEST(T3203_CAPI_lock_database)
2966 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2970 RUNNER_CHILD_TEST(T3204_CAPI_get_data_from_locked_database)
2973 char alias[10] = "mykey";
2974 char *password = NULL;
2975 ckmc_key_s *test_key = NULL;
2978 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key)),
2981 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2984 RUNNER_TEST(T3204_deinit)
2987 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),