1 #include <dpl/test/test_runner.h>
2 #include <dpl/test/test_runner_child.h>
4 #include <tests_common.h>
5 #include <access_provider.h>
7 #include <ckm/ckm-manager.h>
8 #include <ckm/ckm-control.h>
9 #include <ckm/ckm-type.h>
11 #include <ckmc/ckmc-manager.h>
12 #include <ckmc/ckmc-control.h>
13 #include <ckmc/ckmc-type.h>
14 #include <ckmc/ckmc-error.h>
22 static const int USER_APP = 5000;
23 static const int GROUP_APP = 5000;
25 RUNNER_TEST_GROUP_INIT (T201_CKMC_CONTROL_C_API);
27 RUNNER_TEST(T2011_Control_C_API)
31 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
34 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
38 RUNNER_TEST(T2012_Control_C_API)
42 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
44 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
48 RUNNER_TEST(T2013_Control_C_API)
52 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
56 RUNNER_TEST(T2014_Control_C_API)
60 RUNNER_ASSERT_MSG( CKMC_ERROR_BAD_REQUEST == (temp = ckmc_reset_user_password(14, "simple-password")),
64 RUNNER_TEST(T2015_Control_C_API)
69 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(20, "test-pass")),
72 CKMC_ERROR_NONE == (temp = ckmc_change_user_password(20, "test-pass", "new-pass")),
74 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
76 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
80 RUNNER_TEST(TT2016_Control_C_API)
85 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
88 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
91 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
94 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
98 RUNNER_TEST_GROUP_INIT (T202_CKMC_QUICK_SET_GET_TESTS_C_API);
100 RUNNER_TEST(T2021_init_C_API)
105 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
108 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
112 RUNNER_TEST(T2022_key_C_API)
116 ckmc_key_s test_key, *test_key2;
117 ckmc_policy_s test_policy;
119 char* password = NULL;
120 char alias[10] = "mykey";
122 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
123 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
124 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
125 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
126 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
127 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
128 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
130 "-----END PUBLIC KEY-----";
132 char* char_keypem = new char[keyPem.length() + 1];
134 std::strcpy(char_keypem, keyPem.c_str());
135 test_key.raw_key = (unsigned char *)char_keypem;
136 test_key.key_size = keyPem.length();
137 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
138 test_key.password = password;
140 test_policy.password = password;
141 test_policy.extractable = 1;
143 test_key2 = &test_key;
146 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
150 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
153 // int compareResult;
154 // compareResult = (strcmp((const char *)test_key.raw_key, (const char *)test_key2->raw_key));
155 // printf("compare !! %s \n compare 2 !! = %s\n",test_key.raw_key, test_key2->raw_key);
157 // RUNNER_ASSERT_MSG(
158 // compareResult == 0,
162 RUNNER_TEST(T2023_certificate_C_API)
166 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
167 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
168 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
169 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
170 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
171 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
172 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
173 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
174 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
175 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
176 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
177 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
178 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
179 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
180 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
181 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
182 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
183 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
184 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
185 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
186 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
187 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
188 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
189 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
190 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
192 "-----END CERTIFICATE-----\n";
194 char* password = NULL;
198 ckmc_policy_s test_policy;
199 test_policy.password = password;
200 test_policy.extractable = 1;
202 char* char_certPem = new char[certPem.length() + 1];
203 std::strcpy(char_certPem, certPem.c_str());
204 cert.raw_cert = (unsigned char *)char_certPem;
205 cert.cert_size = certPem.length();
206 cert.data_format = CKMC_FORM_PEM;
208 char alias[10] = "myCert";
210 CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias, cert, test_policy)),
214 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
217 // int compareResult;
218 // printf("compare !! %s \n compare 2 !!\n\n %s",cert.raw_cert, cert2->raw_cert);
219 // compareResult = (strcmp((const char *)cert.raw_cert, (const char *)cert2->raw_cert));
221 // RUNNER_ASSERT_MSG(
222 // compareResult == 0,
226 RUNNER_TEST(T2024_certificate_remove_C_API)
230 char* password = NULL;
232 char alias[10] = "myCert";
237 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
241 CKMC_ERROR_NONE == (temp = ckmc_remove_cert(alias)),
245 CKMC_ERROR_NONE != (temp = ckmc_get_cert(alias, password, &cert2)),
249 RUNNER_TEST(T2025_certificate_list_C_API)
253 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
254 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
255 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
256 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
257 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
258 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
259 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
260 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
261 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
262 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
263 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
264 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
265 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
266 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
267 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
268 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
269 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
270 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
271 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
272 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
273 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
274 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
275 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
276 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
277 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
279 "-----END CERTIFICATE-----\n";
281 char* password = NULL;
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("cert_test1", cert, test_policy)),
299 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test2", cert, test_policy)),
303 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test3", cert, test_policy)),
306 ckmc_alias_list_s *aliasList;
309 CKMC_ERROR_NONE == (temp = ckmc_get_cert_alias_list(&aliasList)),
312 ckmc_alias_list_s *plist = aliasList;
316 while(plist && plist->next!=NULL) {
321 RUNNER_ASSERT_MSG( count_list == 3,
322 "Wrong size of list: " << count_list << " Expected: 3");
326 RUNNER_CHILD_TEST(T2026_user_app_save_key_C_API)
328 SecurityServer::AccessProvider ap("mylabel");
329 ap.addObjectRule("key-manager::api-storage", "rw");
330 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
332 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
333 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
334 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
335 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
336 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
337 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
338 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
340 "-----END PUBLIC KEY-----";
344 ckmc_key_s test_key, *test_key2;
345 ckmc_policy_s test_policy;
347 char* password = NULL;
348 char passwordPolicy[3] = "x";
349 char alias[10] = "mykey";
350 char* char_keypem = new char[keyPem.length() + 1];
352 std::strcpy(char_keypem, keyPem.c_str());
353 test_key.raw_key = (unsigned char *)char_keypem;
354 test_key.key_size = keyPem.length();
355 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
356 test_key.password = password;
358 test_policy.password = passwordPolicy;
359 test_policy.extractable = 1;
361 test_key2 = &test_key;
365 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
368 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, passwordPolicy, &test_key2)),
371 // RUNNER_ASSERT_MSG(
372 // key.getDER() == key2.getDER(), "Key value has been changed by service");
375 RUNNER_CHILD_TEST(T2027_app_user_save_keys_exportable_flag)
377 SecurityServer::AccessProvider ap("mylabel");
378 ap.addObjectRule("key-manager::api-storage", "rw");
379 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
382 auto manager = CKM::Manager::create();
384 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
385 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
386 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
387 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
388 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
389 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
390 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
392 "-----END PUBLIC KEY-----";
394 ckmc_policy_s test_policy;
395 ckmc_key_s test_key, *test_key2;
396 char* char_keypem = new char[keyPem.length() + 1];
397 char* password = NULL;
399 std::strcpy(char_keypem, keyPem.c_str());
400 test_key.raw_key = (unsigned char *)char_keypem;
401 test_key.key_size = keyPem.length();
402 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
403 test_key.password = password;
405 test_policy.password = password;
406 test_policy.extractable = 0;
409 CKMC_ERROR_NONE == (temp = ckmc_save_key("appkey1", test_key, test_policy)),
413 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key("appkey1", password, &test_key2)),
417 RUNNER_TEST(T2028_deinit_C_API)
421 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
423 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
426 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
429 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
434 RUNNER_TEST_GROUP_INIT (T2030_CKMC_QUICK_GET_ALIAS_TESTS_C_API);
436 RUNNER_TEST(T2031_init_C_API)
441 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
444 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
448 RUNNER_TEST(T2032_save_keys_get_alias_C_API)
452 char* password = NULL;
453 ckmc_policy_s test_policy1, test_policy2, test_policy3;
456 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
457 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
458 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
459 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
460 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
461 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
462 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
464 "-----END PUBLIC KEY-----";
466 char* char_keypem = new char[keyPem.length() + 1];
468 std::strcpy(char_keypem, keyPem.c_str());
469 test_key.raw_key = (unsigned char *)char_keypem;
470 test_key.key_size = keyPem.length();
471 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
472 test_key.password = password;
473 ckmc_alias_list_s *aliasList;
475 test_policy1.password = password;
476 test_policy1.extractable = 1;
478 test_policy2.password = password;
479 test_policy2.extractable = 0;
481 test_policy3.password = password;
482 test_policy3.extractable = 0;
485 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey1", test_key, test_policy1)),
489 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey2", test_key, test_policy2)),
493 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey3", test_key, test_policy3)),
497 CKMC_ERROR_NONE == (temp = ckmc_get_key_alias_list(&aliasList)),
500 ckmc_alias_list_s *plist = aliasList;
504 while(plist && plist->next!=NULL) {
509 RUNNER_ASSERT_MSG( count_list == 3,
510 "Wrong size of list: " << count_list << " Expected: 3");
514 RUNNER_TEST(T2033_remove_key_C_API)
518 char* password = NULL;
520 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
521 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
522 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
523 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
524 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
525 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
526 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
528 "-----END PUBLIC KEY-----";
530 char* char_keypem = new char[keyPem.length() + 1];
532 std::strcpy(char_keypem, keyPem.c_str());
533 ckmc_key_s *test_key2;
535 CKMC_ERROR_NONE == (temp = ckmc_get_key("rootkey1", password, &test_key2)),
539 CKMC_ERROR_NONE == (temp = ckmc_remove_key("rootkey1")),
543 CKMC_ERROR_NONE != (temp = ckmc_get_key("rootkey1", password, &test_key2)),
547 RUNNER_TEST(T2034_deinit_C_API)
551 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
553 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
556 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
559 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
563 RUNNER_TEST_GROUP_INIT (T2040_CKMC_QUICK_REMOVE_BIN_DATA_TEST_C_API);
565 RUNNER_TEST(T2041_init_C_API)
569 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
572 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
576 RUNNER_TEST(T2042_save_get_bin_data_C_API)
580 ckmc_raw_buffer_s testData1, testData2, testData3;
581 char* password = NULL;
583 std::string binData1 = "My bin data1";
584 std::string binData2 = "My bin data2";
585 std::string binData3 = "My bin data3";
586 char* char_binData1 = new char[binData1.length() + 1];
587 char* char_binData2 = new char[binData2.length() + 1];
588 char* char_binData3 = new char[binData3.length() + 1];
589 std::strcpy(char_binData1, binData1.c_str());
590 std::strcpy(char_binData2, binData2.c_str());
591 std::strcpy(char_binData3, binData3.c_str());
592 testData1.data = (unsigned char *) char_binData1;
593 testData2.data = (unsigned char *) char_binData2;
594 testData3.data = (unsigned char *) char_binData3;
595 testData1.size = binData1.length()+1;
596 testData2.size = binData2.length()+1;
597 testData3.size = binData3.length()+1;
599 ckmc_policy_s test_policy1, test_policy2, test_policy3;
601 test_policy1.password = password;
602 test_policy1.extractable = 1;
603 test_policy2.password = password;
604 test_policy2.extractable = 1;
605 test_policy3.password = password;
606 test_policy3.extractable = 0;
608 ckmc_alias_list_s *aliasList;
611 CKMC_ERROR_NONE == (temp = ckmc_save_data("data1", testData1, test_policy1)), // should change it as null value
615 CKMC_ERROR_NONE == (temp = ckmc_save_data("data2", testData2, test_policy1)), // should change it as null value
619 CKMC_ERROR_NONE == (temp = ckmc_save_data("data3", testData3, test_policy2)),
623 CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_save_data("data4", testData3, test_policy3)),
627 CKMC_ERROR_NONE == (temp = ckmc_get_data_alias_list(&aliasList)),
630 ckmc_alias_list_s *plist = aliasList;
634 while(plist && plist->next!=NULL) {
639 RUNNER_ASSERT_MSG( count_list == 3,
640 "Wrong size of list: " << count_list << " Expected: 3");
642 ckmc_raw_buffer_s *testData4;
644 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData4)),
648 compareResult = (strcmp((const char *)testData2.data, (const char *)testData4->data));
649 RUNNER_ASSERT_MSG( compareResult == 0,
653 RUNNER_CHILD_TEST(T2043_app_user_save_bin_data_C_API)
655 SecurityServer::AccessProvider ap("mylabel");
656 ap.addObjectRule("key-manager::api-storage", "rw");
657 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
660 ckmc_raw_buffer_s testData1;
661 char* password = NULL;
662 std::string binData1 = "My bin data";
663 char* char_binData1 = new char[binData1.length() + 1];
664 std::strcpy(char_binData1, binData1.c_str());
665 testData1.data = (unsigned char *) char_binData1;
666 testData1.size = binData1.length()+1;
668 ckmc_policy_s test_policy1, test_policy2;
670 test_policy1.password = password;
671 test_policy1.extractable = 1;
673 test_policy2.password = password;
674 test_policy2.extractable = 1;
676 std::string binData = "My bin data";
678 ckmc_alias_list_s *aliasList;
681 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata1", testData1, test_policy1)),
684 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata2", testData1, test_policy1)),
687 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata3", testData1, test_policy2)),
690 CKMC_ERROR_NONE == (temp = ckmc_get_data_alias_list(&aliasList)),
693 ckmc_alias_list_s *plist = aliasList;
698 while(plist && plist->next!=NULL) {
703 RUNNER_ASSERT_MSG( count_list == 3,
704 "Wrong size of list: " << count_list << " Expected: 3");
707 RUNNER_TEST(T2044_remove_bin_data_C_API)
711 ckmc_alias_list_s *aliasList;
714 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data1")),
717 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data3")),
720 CKMC_ERROR_NONE == (temp = ckmc_get_data_alias_list(&aliasList)),
723 ckmc_alias_list_s *plist = aliasList;
727 while(plist && plist->next!=NULL) {
734 "Wrong size of list: " << count_list << " Expected: 1");
735 char* password = NULL;
737 ckmc_raw_buffer_s *testData1, testData2;
739 std::string testStr = "My bin data2";
740 char* char_testData2 = new char[testStr.length() + 1];
741 std::strcpy(char_testData2, testStr.c_str());
742 testData2.data = (unsigned char *) char_testData2;
743 testData2.size = testStr.length()+1;
745 CKM::RawBuffer buffer;
747 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData1)),
751 compareResult = (strcmp((const char *)testData2.data, (const char *)testData1->data));
752 RUNNER_ASSERT_MSG( compareResult == 0,
756 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_data("data3", password, &testData1)),
760 RUNNER_TEST(T2045_deinit_C_API)
765 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
768 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
771 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
774 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
778 RUNNER_TEST_GROUP_INIT(T205_CKMC_QUICK_CREATE_PAIR_CAPI);
780 RUNNER_TEST(T2051_CAPI_init)
785 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
789 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
793 RUNNER_CHILD_TEST(T2052_CAPI_create_rsa_key)
797 SecurityServer::AccessProvider ap("mylabel");
798 ap.addObjectRule("key-manager::api-storage", "rw");
799 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
802 const char *private_key_alias = "PRV_KEY1";
803 const char *public_key_alias = "PUB_KEY1";
804 ckmc_policy_s policy_private_key;
805 ckmc_policy_s policy_public_key;
807 policy_private_key.password = NULL;
808 policy_private_key.extractable = 1;
810 policy_public_key.password = NULL;
811 policy_public_key.extractable = 1;
814 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
817 ckmc_key_s *privateKey;
819 CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
822 privateKey->key_type == CKMC_KEY_RSA_PRIVATE,
823 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
825 privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
828 ckmc_key_s *publicKey;
830 CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &publicKey)),
833 publicKey->key_type == CKMC_KEY_RSA_PUBLIC,
834 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PUBLIC) << ", actual=" << static_cast<int>(publicKey->key_type));
836 publicKey != NULL && publicKey->key_size > 0 && publicKey->raw_key != NULL,
839 ckmc_alias_list_s *alias_list;
841 CKMC_ERROR_NONE == (temp = ckmc_get_key_alias_list(&alias_list)),
844 ckmc_alias_list_s *current;
845 ckmc_alias_list_s *next =alias_list;
848 next = current->next;
850 }while(next != NULL);
851 RUNNER_ASSERT_MSG(cnt == 2, "Error=Invalid Key Number");
854 RUNNER_TEST(T2053_CAPI_deinit)
859 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
862 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
867 RUNNER_TEST_GROUP_INIT(T206_CKMC_CAPI_CreateKeyPairRSA);
869 RUNNER_TEST(T2061_CAPI_init)
873 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
876 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
879 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
882 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
886 RUNNER_TEST(T2062_CAPI_CreateKeyPairRSA)
891 const char *private_key_alias = "rsa-test-1";
892 const char *public_key_alias = "rsa-test-2";
893 ckmc_policy_s policy_private_key;
894 ckmc_policy_s policy_public_key;
896 policy_private_key.password = const_cast<char *>("privatepassword");
897 policy_private_key.extractable = 0;
899 policy_public_key.password = NULL;
900 policy_public_key.extractable = 1;
903 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
908 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
909 "Error=" << temp << ", ret=" << temp);
912 RUNNER_TEST(T2063_CAPI_CreateKeyPairECDSA)
916 ckmc_ec_type_e ectype = CKMC_EC_PRIME192V1;
917 const char *private_key_alias = "ecdsa-test-1";
918 const char *public_key_alias = "ecdsa-test-2";
919 ckmc_policy_s policy_private_key;
920 ckmc_policy_s policy_public_key;
922 policy_private_key.password = const_cast<char *>("privatepassword");
923 policy_private_key.extractable = 0;
925 policy_public_key.password = NULL;
926 policy_public_key.extractable = 1;
929 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_ecdsa(ectype, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
933 RUNNER_TEST(T2064_CAPI_deinit)
938 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
941 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
946 //RUNNER_TEST_GROUP_INIT(T120_NEGATIVE_TESTS);
950 RUNNER_TEST_GROUP_INIT(T207_CKMC_CAPI_QUICK_SET_GET_TESTS);
952 RUNNER_TEST(T2071_CAPI_init)
956 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
960 RUNNER_TEST(T2072_CAPI_get_chain)
963 "-----BEGIN CERTIFICATE-----\n"
964 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
965 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
966 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
967 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
968 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
969 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
970 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
971 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
972 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
973 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
974 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
975 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
976 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
977 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
978 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
979 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
980 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
981 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
982 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
983 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
984 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
985 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
986 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
987 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
988 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
989 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
990 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
991 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
992 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
993 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
994 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
996 "-----END CERTIFICATE-----\n";
999 "-----BEGIN CERTIFICATE-----\n"
1000 "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
1001 "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1002 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
1003 "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
1004 "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
1005 "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
1006 "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
1007 "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
1008 "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
1009 "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
1010 "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
1011 "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
1012 "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
1013 "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
1014 "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
1015 "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
1016 "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
1017 "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
1018 "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
1019 "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
1020 "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
1021 "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
1022 "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
1023 "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
1024 "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
1025 "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
1026 "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
1027 "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
1028 "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
1029 "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
1030 "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
1031 "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
1032 "-----END CERTIFICATE-----\n";
1035 c_cert.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(ee.c_str()));
1036 c_cert.cert_size = ee.size();
1037 c_cert.data_format = CKMC_FORM_PEM;
1039 ckmc_cert_s c_cert1;
1040 c_cert1.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(im.c_str()));
1041 c_cert1.cert_size = im.size();
1042 c_cert1.data_format = CKMC_FORM_PEM;
1044 ckmc_cert_list_s untrustedcerts;
1045 untrustedcerts.cert = &c_cert1;
1046 untrustedcerts.next = NULL;
1048 ckmc_cert_list_s *cert_chain_list;
1052 tmp = ckmc_get_cert_chain(&c_cert, &untrustedcerts, &cert_chain_list);
1054 CKMC_ERROR_NONE == tmp, "Error=" << CKM::ErrorToString(tmp));
1057 ckmc_cert_list_s *current;
1058 ckmc_cert_list_s *next =cert_chain_list;
1061 next = current->next;
1063 }while(next != NULL);
1064 RUNNER_ASSERT_MSG(cnt == 3, "Wrong size of certificate chain.");
1066 ckmc_cert_list_s *cert_chain_list2 = NULL;
1067 ckmc_cert_list_s *untrustedcerts2 = NULL;
1069 CKMC_ERROR_VERIFICATION_FAILED == (tmp = ckmc_get_cert_chain(&c_cert, untrustedcerts2, &cert_chain_list2)),
1070 "Error=" << CKM::ErrorToString(tmp));
1073 cert_chain_list2 == NULL,
1074 "Wrong size of certificate chain.");
1077 RUNNER_TEST(T2073_CAPI_deinit)
1082 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1085 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1090 RUNNER_TEST_GROUP_INIT(T208_CAPI_CREATE_AND_VERIFY_SIGNATURE);
1092 RUNNER_TEST(T2081_CAPI__init)
1097 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1101 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
1105 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1109 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1113 RUNNER_TEST(T2082_CAPI__rsa_key_create_verify)
1117 std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1118 "Proc-Type: 4,ENCRYPTED\n"
1119 "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1121 "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1122 "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1123 "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1124 "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1125 "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1126 "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1127 "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1128 "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1129 "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1130 "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1131 "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1132 "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1133 "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1134 "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1135 "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1136 "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1137 "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1138 "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1139 "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1140 "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1141 "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1142 "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1143 "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1144 "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1145 "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1146 "-----END RSA PRIVATE KEY-----\n";
1148 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1149 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1150 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1151 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1152 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1153 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1154 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1156 "-----END PUBLIC KEY-----\n";
1158 std::string message = "message test";
1159 ckmc_raw_buffer_s msg_buff;
1160 msg_buff.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(message.c_str()));
1161 msg_buff.size = message.size();
1163 const char *pub_alias = "pub1";
1164 const char *pri_alias = "prv1";
1165 char *key_passwd = (char *) "1234";
1166 char *pri_passwd = NULL;
1167 char *pub_passwd = NULL;
1168 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1169 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1170 ckmc_raw_buffer_s *signature;
1173 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1174 pubkey.key_size = pub.size();
1175 pubkey.key_type = CKMC_KEY_NONE;
1176 pubkey.password = NULL;
1178 ckmc_policy_s pubpolicy;
1179 pubpolicy.password = pub_passwd;
1180 pubpolicy.extractable = 0;
1182 ckmc_policy_s pripolicy;
1183 pripolicy.password = pri_passwd;
1184 pripolicy.extractable = 1;
1187 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1188 prikey.key_size = prv.size();
1189 prikey.key_type = CKMC_KEY_NONE;
1190 prikey.password = key_passwd;
1194 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1198 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1202 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1212 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1223 RUNNER_TEST(T2083_CAPI__rsa_key_create_verify_negative)
1226 std::string message = "message asdfaslkdfjlksadjf test";
1228 ckmc_raw_buffer_s msg_buff;
1229 msg_buff.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(message.c_str()));
1230 msg_buff.size = message.size();
1232 const char *pub_alias = "pub1";
1233 const char *pri_alias = "prv1";
1234 char *pri_passwd = NULL;
1235 char *pub_passwd = NULL;
1236 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1237 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1238 ckmc_raw_buffer_s *signature;
1241 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1251 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1260 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1261 memcpy((void*)signature->data, "BROKEN", 6);
1264 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1274 RUNNER_TEST(T2084_CAPI__ec_key_create_verify)
1278 std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1279 "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1280 "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1281 "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1282 "-----END EC PRIVATE KEY-----\n";
1284 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1285 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1286 "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1287 "-----END PUBLIC KEY-----\n";
1289 std::string message = "message test";
1291 ckmc_raw_buffer_s msg_buff;
1292 msg_buff.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(message.c_str()));
1293 msg_buff.size = message.size();
1295 const char *pri_alias = "ecprv2";
1296 const char *pub_alias = "ecpub2";
1297 char *key_passwd = NULL;
1298 char *pri_passwd = NULL;
1299 char *pub_passwd = NULL;
1300 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1301 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1302 ckmc_raw_buffer_s *signature;
1305 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1306 pubkey.key_size = pub.size();
1307 pubkey.key_type = CKMC_KEY_NONE;
1308 pubkey.password = NULL;
1310 ckmc_policy_s pubpolicy;
1311 pubpolicy.password = pub_passwd;
1312 pubpolicy.extractable = 1;
1315 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1316 prikey.key_size = prv.size();
1317 prikey.key_type = CKMC_KEY_NONE;
1318 prikey.password = key_passwd;
1320 ckmc_policy_s pripolicy;
1321 pripolicy.password = (char *)pri_passwd;
1322 pripolicy.extractable = 0;
1325 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1328 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1332 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1342 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1351 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1352 memcpy((void*)signature->data, "BROKEN", 6);
1355 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1365 RUNNER_TEST(T2085_CAPI__rsa_cert_create_verify_signature)
1370 "-----BEGIN RSA PRIVATE KEY-----\n"
1371 "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1372 "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1373 "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1374 "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1375 "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1376 "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1377 "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1378 "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1379 "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1380 "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1381 "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1382 "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1383 "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1384 "-----END RSA PRIVATE KEY-----\n";
1387 "-----BEGIN CERTIFICATE-----\n"
1388 "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1389 "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1390 "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1391 "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1392 "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1393 "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1394 "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1395 "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1396 "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1397 "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1398 "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1399 "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1400 "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1401 "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1402 "-----END CERTIFICATE-----\n";
1404 std::string message = "message test";
1406 ckmc_raw_buffer_s msg_buff;
1407 msg_buff.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(message.c_str()));
1408 msg_buff.size = message.size();
1410 const char *pri_alias = "prv3";
1411 const char *pub_alias = "pub3";
1412 char *key_passwd = NULL;
1413 char *pri_passwd = NULL;
1414 char *pub_passwd = NULL;
1415 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1416 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1417 ckmc_raw_buffer_s *signature;
1420 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1421 cert.cert_size = pub.size();
1422 cert.data_format = CKMC_FORM_PEM;
1424 ckmc_policy_s certpolicy;
1425 certpolicy.password = pub_passwd;
1426 certpolicy.extractable = 1;
1429 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1430 prikey.key_size = prv.size();
1431 prikey.key_type = CKMC_KEY_NONE;
1432 prikey.password = key_passwd;
1434 ckmc_policy_s pripolicy;
1435 pripolicy.password = pri_passwd;
1436 pripolicy.extractable = 0;
1439 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1442 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1447 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1457 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1466 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1467 memcpy((void*)signature->data, "BROKEN", 6);
1470 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1480 RUNNER_TEST(T2086_CAPI__ecdsa_cert_create_verify_signature)
1485 "-----BEGIN EC PRIVATE KEY-----\n"
1486 "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1487 "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1488 "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1489 "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1490 "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1491 "ELyhe7yPCAuOoLZlTLgf\n"
1492 "-----END EC PRIVATE KEY-----\n";
1495 "-----BEGIN CERTIFICATE-----\n"
1496 "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1497 "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1498 "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1499 "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1500 "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1501 "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1502 "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1503 "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1504 "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1505 "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1506 "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1507 "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1508 "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1509 "Q1oBry6NEc+lLFmWMDesAA==\n"
1510 "-----END CERTIFICATE-----\n";
1512 std::string message = "message test";
1515 ckmc_raw_buffer_s msg_buff;
1516 msg_buff.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(message.c_str()));
1517 msg_buff.size = message.size();
1519 const char *pri_alias = "prv4";
1520 const char *pub_alias = "pub4";
1521 char *key_passwd = NULL;
1522 char *pri_passwd = NULL;
1523 char *pub_passwd = NULL;
1524 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1525 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1526 ckmc_raw_buffer_s *signature;
1529 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1530 cert.cert_size = pub.size();
1531 cert.data_format = CKMC_FORM_PEM;
1533 ckmc_policy_s certpolicy;
1534 certpolicy.password = pub_passwd;
1535 certpolicy.extractable = 1;
1538 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1539 prikey.key_size = prv.size();
1540 prikey.key_type = CKMC_KEY_NONE;
1541 prikey.password = key_passwd;
1543 ckmc_policy_s pripolicy;
1544 pripolicy.password = pri_passwd;
1545 pripolicy.extractable = 0;
1549 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1552 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1556 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1566 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1575 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1576 memcpy((void*)signature->data, "BROKEN", 6);
1579 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1589 RUNNER_TEST(T2087_CAPI__deinit)
1594 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1597 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1602 //#######################################################################################
1604 void _assertKey(ckmc_key_s *key, unsigned char *raw_key, unsigned int key_size, ckmc_key_type_e key_type, char *password)
1606 RUNNER_ASSERT_MSG(key->key_size == key_size, "Key Size Error" );
1607 RUNNER_ASSERT_MSG(key->key_type == key_type, "Key Type Error" );
1609 if(key->password != NULL && password != NULL) {
1610 RUNNER_ASSERT_MSG(strcmp(key->password, password) == 0, "Password Error" );
1611 }else if(key->password == NULL && password == NULL) {
1612 RUNNER_ASSERT_MSG(true, "Password Error" );
1614 RUNNER_ASSERT_MSG(false, "Password Error" );
1617 if(key->raw_key != NULL && raw_key != NULL) {
1618 for(unsigned int i=0; i<key_size; i++) {
1619 RUNNER_ASSERT_MSG((key->raw_key)[i] == raw_key[i], "Raw Key Error" );
1621 }else if(key->raw_key == NULL && raw_key == NULL) {
1622 RUNNER_ASSERT_MSG(true, "Raw Key Error" );
1624 RUNNER_ASSERT_MSG(false, "Raw Key Error" );
1628 RUNNER_TEST_GROUP_INIT(T209_CKMC_CAPI_TYPES);
1630 RUNNER_TEST(T2091_CAPI_TYPE_init)
1634 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1637 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1640 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1643 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
1647 RUNNER_TEST(T2092_CAPI_TYPE_KEY)
1649 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1650 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1651 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1652 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1653 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1654 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1655 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1657 "-----END PUBLIC KEY-----";
1659 unsigned char *raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1660 unsigned int key_size = keyPem.size();
1661 ckmc_key_type_e key_type = CKMC_KEY_NONE;
1662 char *password = const_cast< char *>("");
1665 ckmc_key_new(raw_key, key_size, key_type, password, &key);
1667 _assertKey(key, raw_key, key_size, key_type, password);
1670 char *passwordNull = NULL;
1672 ckmc_key_new(raw_key, key_size, key_type, passwordNull, &key2);
1673 ckmc_key_free(key2);
1676 RUNNER_TEST(T2093_CAPI_TYPE_BUFFER)
1678 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1679 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1680 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1681 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1682 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1683 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1684 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1686 "-----END PUBLIC KEY-----";
1688 unsigned char *data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1689 unsigned int size = keyPem.size();
1691 ckmc_raw_buffer_s *buff;
1692 ckmc_buffer_new(data, size, &buff);
1694 RUNNER_ASSERT_MSG(buff->size == size, "Size Error" );
1696 if(buff->data != NULL && data != NULL) {
1697 for(unsigned int i=0; i<size; i++) {
1698 RUNNER_ASSERT_MSG((buff->data)[i] == data[i], "Raw data Error" );
1700 }else if(buff->data == NULL && data == NULL) {
1701 RUNNER_ASSERT_MSG(true, "Raw data Error" );
1703 RUNNER_ASSERT_MSG(false, "Raw data Error" );
1706 ckmc_buffer_free(buff);
1709 RUNNER_TEST(T2094_CAPI_TYPE_CERT)
1711 std::string certPem =
1712 "-----BEGIN CERTIFICATE-----\n"
1713 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
1714 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
1715 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
1716 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
1717 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
1718 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
1719 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
1720 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
1721 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
1722 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
1723 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
1724 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
1725 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
1726 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
1727 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
1728 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
1729 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
1730 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
1731 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
1732 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
1733 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
1734 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
1735 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
1736 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
1738 "-----END CERTIFICATE-----\n";
1740 unsigned char *raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(certPem.c_str()));
1741 unsigned int size = certPem.size();
1742 ckmc_data_format_e form = CKMC_FORM_PEM;
1744 ckmc_cert_s *ckmCert;
1745 ckmc_cert_new(raw_cert, size, form, &ckmCert);
1747 RUNNER_ASSERT_MSG(ckmCert->cert_size == size, "Size Error" );
1749 if(ckmCert->raw_cert != NULL && raw_cert != NULL) {
1750 for(unsigned int i=0; i<size; i++) {
1751 RUNNER_ASSERT_MSG((ckmCert->raw_cert)[i] == raw_cert[i], "Raw data Error" );
1753 }else if(ckmCert->raw_cert == NULL && raw_cert == NULL) {
1754 RUNNER_ASSERT_MSG(true, "raw_cert Error" );
1756 RUNNER_ASSERT_MSG(false, "raw_cert Error" );
1759 RUNNER_ASSERT_MSG(ckmCert->data_format == form, "ckmc_cert_form Error" );
1761 ckmc_cert_free(ckmCert);
1765 RUNNER_TEST(T2095_CAPI_TYPE_load_cert_file)
1769 std::string certStr =
1770 "-----BEGIN CERTIFICATE-----\n"
1771 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
1772 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1773 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
1774 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
1775 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
1776 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
1777 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
1778 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
1779 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
1780 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
1781 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
1782 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
1783 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
1784 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
1785 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
1786 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
1787 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
1788 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
1789 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
1790 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
1791 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
1792 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
1793 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
1794 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
1795 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
1796 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
1797 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
1798 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
1799 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
1800 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
1801 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
1803 "-----END CERTIFICATE-----\n";
1805 const char *file_name = "/tmp/ckmc_test_cert.pem";
1809 cert_file = fopen(file_name, "w");
1810 fprintf(cert_file, "%s",certStr.c_str());
1816 CKMC_ERROR_NONE == (ret = ckmc_load_cert_from_file(file_name, &pcert)),
1817 "Error=" << CKM::ErrorToString(ret));
1820 pcert != NULL && pcert->cert_size > 0,"Fail to load cert from file.");
1822 const char *lcert_alias = "lcert_alias";
1823 ckmc_policy_s policy;
1824 policy.password = NULL;
1825 policy.extractable = 1;
1828 CKMC_ERROR_NONE == (ret = ckmc_save_cert(lcert_alias, *pcert, policy)),
1829 "Error=" << CKM::ErrorToString(ret));
1834 RUNNER_TEST(T2096_CAPI_TYPE_load_p12_file) {
1835 std::string p12Base64 =
1836 "MIINaQIBAzCCDS8GCSqGSIb3DQEHAaCCDSAEgg0cMIINGDCCChcGCSqGSIb3DQEH\n"
1837 "BqCCCggwggoEAgEAMIIJ/QYJKoZIhvcNAQcBMBwGCiqGSIb3DQEMAQYwDgQIvO01\n"
1838 "D2ODdkYCAggAgIIJ0NscvWq3hmXai5DQcleOgELPbu2c97d+KJnRGCK7K3eRb0/v\n"
1839 "4F3f3LFSFFT9OAK0/OS1ZYCiO+IuZ6Rpc8Baqe89xVcOHrQ0dQ7sIvbq10dnp5nY\n"
1840 "fEcrt7qPXcRa3IdOX4PFo4aCOFq5bHv5M3quHldKRh4itosjsAGuF/xtnVnO6lU5\n"
1841 "UlPhtAdr2Mpr4SHh+oBbJknLvyd6n/4xZ2elEA8ui4Qt5GfiHwWs2J7KO3Z8M1vW\n"
1842 "yukuyVTaZ6RNkj8dkq/RttvVinlgATYLoosjCsH7VVcd+/z9JqD37QQ89pzdjvJg\n"
1843 "CtXFVbqsOIbjPMkQMYtMdaPsLDDzw6l+q7BJreGIoJmTHbhTtNOJo03XPEnlVXUq\n"
1844 "Q+224ibNKzLAvpSWOo8BUHK7ZDc1oaLODDZ+WAA6jfgHkuhhWYr9dxce6UdhMghJ\n"
1845 "M7ixWwa350psdACREdGxNQzxmucmueprbDumVPAnnJfnKfgRXdKpTDFWS4TaYRc/\n"
1846 "TE4lKSBZpFFduy/gdpLGCHdklTs33aWZ/mEVZJnk2PggKyvSKH9oL3DxkZIFkGdQ\n"
1847 "wcy8gAuLBirdWB/q4JWqW7sH8kMfEwXACEm1z4SzCik8afamQNJEbovA3Pvrhw/P\n"
1848 "1HE5KPNvKMaIr9kk5rTnGGTSNrSMqUCnBl4MjVS4HacrZvvt60y0D3RFB8IqlFMt\n"
1849 "od2FagxojPyO/wP8jDERnySo2Irz0x0WUjWARtcLLH2FOK7ROkX1/WjRZmDV0jtv\n"
1850 "yL8r97XZf/NddVU13Jt13dBJCjxZRvfJZgNI8RybkPQ3Y9J5LIOLVFPU3ZKIi7W7\n"
1851 "KtCw/FCUfEdNarLQMWG0Z9bux7vu/eK1+KpF9pfzD3Q1V0sj2M158Q5W2gy9q/u0\n"
1852 "gOOuybiZB2AL9kxBv0rqb8h7SF5ZIRoy85PrwtnX7w4Xq+4I7RA68bcEGyqgTWWb\n"
1853 "XZxcY65F2slqekXddKeDSTizQk/APgWva/TwgaUeXR9YBCO4o71pla//FNqJ6pRm\n"
1854 "tZjEY9ALBCc083gsImc7+LAeubEcYzjhhgRPQwGJfJTMqgC/NOa9wFhvNO4QcFjf\n"
1855 "XQxxIFxlQJ64qU316FyeuyxLYGd02uakrLLgYtAGG7nPZCYNkUKvCwICKJYI+wAg\n"
1856 "CX0FVwXsR1f33kVuV6sd4YConz80Lk9ayvNJVeCzEOBvhthbMcP3mIn22X+GT3jU\n"
1857 "O5Z0bkXAU0C8XTfLQMk2m6Ag3mctrn4iJBPwQ7j12GnlSLko+e7IssRd4Qj4vBZd\n"
1858 "KXUIoRcOsXqWoQgXJAtdLJEHVo0SUyxVojXsXqUZ3yYOkVUykvXZUcBnS6xwtaUt\n"
1859 "EzdFsEO3NQSLOju5Tpp12lKbrgIToV75zyA3CULEdimEUWD/wA+pDaIS39shNyeE\n"
1860 "edtAp3WF3mDkHQFyKG52IVx7hJU8jXXunvY21tshTAx/Gda0X1CtgSU7Q00ROr+L\n"
1861 "TaehRiKsSgxQa6/jyJY5KY1hIDzwaem5Y7gDnxotmQuPhIX8MeD5Qdv6AVovfScN\n"
1862 "07QuWyUBgFsZzbp79AsnPRLzoiAMQljMn7TXDDLq+uF922OU47BQkzlPfKAuHbyu\n"
1863 "R+uZwtDfMD71FqWjCAHMPyENinsnUehCwX2pVxa6KSs61IsTfb3oUPY1TRxfZnfd\n"
1864 "8SAUfPjKVss9Eyahuv+kzenPUDZn5LV9E0G0DGNxIf493A5Z29scNkQcCBjTJJvx\n"
1865 "4BBJCES6SgkTQl7eFoBGOIqqytpYP9QZW5jy7ramgz/gF2kMKjAfikhbd5vB4Fwd\n"
1866 "QlExMlbW+wL/ffr4AGlwenlDzXBFKQM0mYZNKLuB9LrRzw35fVFZ9XY06VCxhbMa\n"
1867 "wI9gN4rKA3bNG3DCWTsr1TZ6CvrqFJjlfK4KF/+eNfnkIY8uVYxnPlRRkmPw4dpE\n"
1868 "KdaXUiu5WJvZupeYqqNsWdxs+v2KS1E/PcM9BgUFKFD4lW84WbWUHPxvxXoZhSCs\n"
1869 "nQ0hsPd53NKBBdEOao5HAAf+T5yFnJzZ3rVkYBEC67gHyWgXB1Zy283yAIihvUXw\n"
1870 "DOEVppNHnIqAjQpncQcDpV0/zYCvqOEfU+JPpmepgo737Tq2MlUKLTByhg1mQhKm\n"
1871 "2pI63BFiw2/2igImFbmhzJjilWkaM4kwM1uGKOKgjacXI/VSVEajuYAfo37quBxF\n"
1872 "ZWyWJoFXBvQ7jolTKXUVbCqnSSaItosZrS3vcDdGUegRm0rf6IzCRPdSIsfCDdZG\n"
1873 "9UeChoznNezoLENgmqQJTV3wDo3uSZbztlctoERvZpn457MLZEn8hXEwMLPXx2Ur\n"
1874 "HQ5fYAdTBzBpoLiy8ujzFxFJDzW9ytnb7aFF7YVivfj42eVGnCANvVcwkp2/E3MW\n"
1875 "Img0OyqKRQHaGGI7iGNO5KYpTk0CdSyErQarH52ZRvr0t2CK6J6vDgrhJnzd5Ayr\n"
1876 "6t+coAZBw8eIJqiM5WzAm4mlZRSHL+JcaKkrqoYOo+kewj7wgW2Kk/7S8re38RvP\n"
1877 "+V9nqpfr18gIV72G2yZ60C21eRqOFPgl1CYbmWHqYKXatuT4o+kgBmJpez5uvIHz\n"
1878 "LSd88An02ow+WQ+KP8YGV38ZtuA6D4FPA3fsMdhNOqjtwWiPei+ILaXD5PsOfDGH\n"
1879 "2fZgOWXivFYqq9Cm3B3ffFX/oD/7sFMs+/AWeZOh8XqU8ro73L1HNRXx4HdyRUY/\n"
1880 "pInwA0mWaFNGgBRPbNW0A6cZ2dY0Hn8sRRsF+5tIs0hOelpT1y/ZEVyGImTQgEbK\n"
1881 "KeggQGT9h9rhrrUK+hE27MorcRi6tVteKlNyGQsCJko0ZoqqctM4o7wT5ce4nWtb\n"
1882 "ixzp5xDkDmcP6eldHiVm8TsZn0hkmNDu0xpgIVtb4VDRmWP687EOaGHYhjOBw6X1\n"
1883 "GD1d1yyg/VxlUr0lKmbsFVC2mDiWbnWd49+FGsrySc2RO8DlC9xkXLaG+ubjmLpK\n"
1884 "lwagiI2P1MzkHuZiz7WlIjFefuYh0yrYvDA5UDiQTDdoZWFuR5r93QWdsUcHlvdF\n"
1885 "rYmhQ93F6I4gaT9HSVEDJfisIjIUmIwhh20tdGnf3FC5VyqBYS5GQObq3VnC8stU\n"
1886 "b7byCEMlKr5bWslEem6gRGTB9xektKgrsFgS7nb3Geegq9K+mWIBC/iBOInVqFYx\n"
1887 "Uw8+s6ywApXPLPEIrVZumkwo7Rl8lJfCTDNni/68XHhhVHY70N0PSdfnCAvV9G41\n"
1888 "3wuTZHqLOeQG3Sm8I1JJXkWSuuk0QI7DVKZpmz+x4aFBd+rncfvWOEbN9G0ZqbUT\n"
1889 "lGkfxtUWY6pWX/XJpyBzOlv2+fCPi/Yd0csb45IEuFHNG1svgqGMJw5BmFu5v0Qs\n"
1890 "0i1zKBrNA/Acd6+uL0UqDZStB6lyPn6+uifh3sMwggL5BgkqhkiG9w0BBwGgggLq\n"
1891 "BIIC5jCCAuIwggLeBgsqhkiG9w0BDAoBAqCCAqYwggKiMBwGCiqGSIb3DQEMAQMw\n"
1892 "DgQIBJuBj07uHGACAggABIICgJBfOlC99JJjEUBibYLXIJPe53Cy7eDXCtVaPbhX\n"
1893 "VHPCsBrUd7+6Ul7Vh/JHMlJL1VA3WvGnX93f0p5FICgZZA3sIZjpxBoeVkZ0Zx6r\n"
1894 "ZMnBPIN4GaHYufCGPyAlPXgEGjlBr3g6Sxr8j50vsWtfspwiILsyte+nQ3kE1nV4\n"
1895 "TjNBnayXmCMnEkf4kKu+dlLFbd1OY/fQJbiT+f9YtMfcfp2IR+7bXb23UIv8Wt1I\n"
1896 "XyqsYTcUjIvnByKSDrvVu941x1EN5DF1964qQbAZb/z5ueTl8tCpaCFlGbZcXz7X\n"
1897 "7L3k0YWdymx1J+szd6heQJrzqMjcHK3XWC7YlDytWB59j0eNMx42XEFP0pAO+gt9\n"
1898 "Iny2XL+sxJC/xzf6apYMmmGwEXrZkkudsSVMgLCtYyin4zM7PFzLAPK9ryEhsxaP\n"
1899 "g077MJ/aIaZ7PLi7cABz/g+gQ1dSXakNOof6EjRUADHpav9UKeKwWdR8ycB/8AQV\n"
1900 "XxQTpEsFJ7izdNZDNC/ZeOhc/ohnei169rfH0shVeeckjf++c8zlh/Y5UWIi3V6i\n"
1901 "5c7RlIJLMtHrvpB5UxRpZgWSdXvCuTCBEzlZAeWJ11I4DAeioqJ1V3h2KcUjNKf1\n"
1902 "z8mTJrzAycuhm8npaC0Gj6JU7jiYPZLvj+cK/e/gjadWggHFYsjAKhACDbAtG64N\n"
1903 "Gu9PWJszvhSO8ga7TOVEzdbe2jm4oWtqPe3gb6eYl2Ma6GTfj/PUEDpNAOnr99qV\n"
1904 "g3uKIXMBp2115bfUf5sbfPdMbnH12XILXR9Va+JjeQHexa64QWlsiRgtXEAXxoEb\n"
1905 "D2aTlfdsJpgilyj31Y45xOdN7FI+Ltfhudxt1kABPdmKwRMxJTAjBgkqhkiG9w0B\n"
1906 "CRUxFgQUMvxYuPi3XpEeXbzAkXaNbAw7P5gwMTAhMAkGBSsOAwIaBQAEFOBC4ppE\n"
1907 "AXO+xdzSBKimvjBBTLbEBAjlaWiC5IVtmAICCAA=\n";
1910 const char *p12base64file = "/tmp/ckmc_test_p12.p12.b64";
1911 const char *p12file = "/tmp/ckmc_test_p12.p12";
1912 const char *password = "password";
1914 remove(p12base64file);
1918 b64_file = fopen(p12base64file, "w");
1919 fprintf(b64_file, "%s",p12Base64.c_str());
1922 std::string cmd("openssl base64 -d -in ");
1923 cmd.append(p12base64file);
1924 cmd.append(" -out ");
1925 cmd.append(p12file);
1926 system(cmd.c_str());
1930 ckmc_key_s *private_key = NULL;
1931 ckmc_cert_s *cert = NULL;
1932 ckmc_cert_list_s *ca_cert_list = NULL;
1935 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file(p12file, password,
1936 &private_key, &cert, &ca_cert_list)),
1938 RUNNER_ASSERT_MSG(private_key != NULL, "Null private_key");
1939 RUNNER_ASSERT_MSG(cert != NULL, "Null cert");
1940 RUNNER_ASSERT_MSG(ca_cert_list != NULL, "Null ca_cert_list");
1942 ckmc_policy_s policy;
1943 policy.password = NULL;
1944 policy.extractable = 1;
1947 const char *pkey_alias = "pkey_alias";
1949 CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias, *private_key, policy)),
1952 const char *cert_alias = "cert_alias";
1954 CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias, *cert, policy)),
1956 std::string caCertAlias = "ca_cert_alias_";
1957 const char *idx = "0";
1959 ckmc_cert_list_s *tmpList = ca_cert_list;
1960 while(tmpList != NULL) {
1961 caCertAlias.append(idx);
1963 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
1965 tmpList = tmpList->next;
1969 RUNNER_ASSERT_MSG(cnt == 2,"Invalid CA Cert Count");
1971 ckmc_key_free(private_key);
1972 ckmc_cert_free(cert);
1973 ckmc_cert_list_all_free(ca_cert_list);
1975 remove(p12base64file);
1980 RUNNER_TEST(T2098_CAPI_TYPE_deinit)
1984 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1987 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
1990 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1993 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1998 RUNNER_TEST_GROUP_INIT(T2000_CAPI_LOCKTYPE_TESTS);
2000 RUNNER_CHILD_TEST(T2101_CAPI_init_lock_key)
2003 SecurityServer::AccessProvider ap("my-label");
2004 ap.addObjectRule("key-manager::api-control", "rw");
2005 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2007 char *null_password = NULL;
2009 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,"user-pass",null_password)),
2010 "Error=" << CKM::ErrorToString(tmp));
2012 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2013 "Error=" << CKM::ErrorToString(tmp));
2016 RUNNER_CHILD_TEST(T2102_CAPI_unlock_default_passwd)
2018 SecurityServer::AccessProvider ap("my-label");
2019 ap.addObjectRule("key-manager::api-storage", "rw");
2020 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2024 ckmc_key_s test_key, *test_key2;
2025 ckmc_policy_s test_policy;
2027 char* password = NULL;
2028 char alias[20] = "mykey_defpasswd";
2030 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2031 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2032 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2033 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2034 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2035 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2036 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2038 "-----END PUBLIC KEY-----";
2040 char* char_keypem = new char[keyPem.length() + 1];
2042 std::strcpy(char_keypem, keyPem.c_str());
2043 test_key.raw_key = (unsigned char *)char_keypem;
2044 test_key.key_size = keyPem.length();
2045 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2046 test_key.password = password;
2048 test_policy.password = password;
2049 test_policy.extractable = 1;
2051 test_key2 = &test_key;
2054 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
2058 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
2061 CKMC_ERROR_NONE == (temp = ckmc_remove_key(alias)),
2065 RUNNER_CHILD_TEST(T2103_CAPI_init_change_user_password)
2068 SecurityServer::AccessProvider ap("my-label");
2069 ap.addObjectRule("key-manager::api-control", "rw");
2070 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2072 char *null_password = NULL;
2074 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,null_password,"user-pass")),
2075 "Error=" << CKM::ErrorToString(tmp));
2077 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2078 "Error=" << CKM::ErrorToString(tmp));
2081 RUNNER_CHILD_TEST(T2104_CAPI_unlock_default_passwd_negative)
2083 SecurityServer::AccessProvider ap("my-label");
2084 ap.addObjectRule("key-manager::api-storage", "rw");
2085 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2089 ckmc_key_s test_key, *test_key2;
2090 ckmc_policy_s test_policy;
2092 char* password = NULL;
2093 char alias[20] = "mykey_defpasswd";
2095 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2096 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2097 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2098 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2099 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2100 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2101 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2103 "-----END PUBLIC KEY-----";
2105 char* char_keypem = new char[keyPem.length() + 1];
2107 std::strcpy(char_keypem, keyPem.c_str());
2108 test_key.raw_key = (unsigned char *)char_keypem;
2109 test_key.key_size = keyPem.length();
2110 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2111 test_key.password = password;
2113 test_policy.password = password;
2114 test_policy.extractable = 1;
2116 test_key2 = &test_key;
2119 CKMC_ERROR_DB_LOCKED == (temp = ckmc_save_key(alias, test_key, test_policy)),
2123 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key2)),
2127 RUNNER_CHILD_TEST(T2109_CAPI_deinit)
2129 SecurityServer::AccessProvider ap("my-label");
2130 ap.addObjectRule("key-manager::api-control", "rw");
2131 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2134 RUNNER_TEST_GROUP_INIT(T220_CAPI_EMPTY_DATABASE);
2136 RUNNER_TEST(T2201_CAPI_unlock_database)
2139 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2141 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2143 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
2147 RUNNER_CHILD_TEST(T2202_CAPI_get_data_from_empty_database)
2150 char alias[10] = "mykey";
2151 char *password = NULL;
2152 ckmc_key_s *test_key = NULL;
2155 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(alias, password, &test_key)),
2158 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2161 RUNNER_CHILD_TEST(T2203_CAPI_deinit_lock_database)
2164 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2166 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2170 RUNNER_CHILD_TEST(T2204_CAPI_get_data_from_locked_database)
2173 char alias[10] = "mykey";
2174 char *password = NULL;
2175 ckmc_key_s *test_key = NULL;
2178 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key)),
2181 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");