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>
17 #include <ckm-common.h>
25 static const int USER_APP = 5000;
26 static const int GROUP_APP = 5000;
36 const char* USER_PASS = "user-pass";
38 int count_aliases(alias_type_ type, int minimum_initial_element_count = 0)
40 ckmc_alias_list_s *aliasList = NULL;
45 ec = ckmc_get_key_alias_list(&aliasList);
49 ec = ckmc_get_cert_alias_list(&aliasList);
53 ec = ckmc_get_data_alias_list(&aliasList);
56 if(ec == CKMC_ERROR_DB_ALIAS_UNKNOWN)
60 ckmc_alias_list_s *plist = aliasList;
67 ckmc_alias_list_all_free(aliasList);
70 return_count >= minimum_initial_element_count,
71 "Error: alias list failed, current element count: " << return_count <<
72 " while expected minimal count of " << minimum_initial_element_count <<
82 "Error: alias list failed, ec: " << ec);
88 ckmc_raw_buffer_s prepare_message_buffer(const char * input)
90 ckmc_raw_buffer_s retval;
91 retval.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(input));
92 retval.size = strlen(input);
96 } // namespace anonymous
99 RUNNER_TEST_GROUP_INIT (T301_CKMC_CONTROL_C_API);
101 RUNNER_TEST(T3011_Control_C_API)
105 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
106 CKMCReadableError(temp));
108 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
109 CKMCReadableError(temp));
112 RUNNER_TEST(T3012_Control_C_API)
116 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
117 CKMCReadableError(temp));
118 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
119 CKMCReadableError(temp));
122 RUNNER_TEST(T3013_Control_C_API)
126 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
127 CKMCReadableError(temp));
130 RUNNER_TEST(T3014_Control_C_API)
133 const uid_t UNIQUE_USER = 15;
135 // clean up environment
136 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
137 CKMCReadableError(temp));
138 // unlock with default password
139 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, NULL)),
140 CKMCReadableError(temp));
141 // reset password (NULL, "simple-password")
142 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
143 CKMCReadableError(temp));
144 // get rid of NULL DKEK
145 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, "simple-password")),
146 CKMCReadableError(temp));
148 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(UNIQUE_USER)),
149 CKMCReadableError(temp));
150 // try to reset password when db locked
151 RUNNER_ASSERT_MSG( CKMC_ERROR_BAD_REQUEST == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
152 CKMCReadableError(temp));
153 // clean up environment
154 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
155 CKMCReadableError(temp));
158 RUNNER_TEST(T3015_Control_C_API)
163 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(20, "test-pass")),
164 CKMCReadableError(temp));
166 CKMC_ERROR_NONE == (temp = ckmc_change_user_password(20, "test-pass", "new-pass")),
167 CKMCReadableError(temp));
168 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
169 CKMCReadableError(temp));
170 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
171 CKMCReadableError(temp));
174 RUNNER_TEST(T3016_Control_C_API)
179 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
180 CKMCReadableError(temp));
182 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
183 CKMCReadableError(temp));
185 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(20)),
186 CKMCReadableError(temp));
188 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(20)),
189 CKMCReadableError(temp));
192 RUNNER_TEST_GROUP_INIT (T302_CKMC_QUICK_SET_GET_TESTS_C_API);
194 RUNNER_TEST(T3021_init_C_API)
199 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
200 CKMCReadableError(temp));
202 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
203 CKMCReadableError(temp));
206 RUNNER_TEST(T3022_key_C_API)
210 ckmc_key_s test_key, *test_key2;
211 ckmc_policy_s test_policy;
213 char* password = NULL;
214 const char *alias = "mykey";
216 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
217 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
218 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
219 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
220 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
221 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
222 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
224 "-----END PUBLIC KEY-----";
226 char* char_keypem = new char[keyPem.length() + 1];
228 std::strcpy(char_keypem, keyPem.c_str());
229 test_key.raw_key = (unsigned char *)char_keypem;
230 test_key.key_size = keyPem.length();
231 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
232 test_key.password = password;
234 test_policy.password = password;
235 test_policy.extractable = 1;
237 test_key2 = &test_key;
240 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
241 CKMCReadableError(temp));
244 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
245 CKMCReadableError(temp));
248 RUNNER_TEST(T3023_certificate_C_API)
252 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
253 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
254 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
255 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
256 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
257 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
258 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
259 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
260 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
261 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
262 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
263 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
264 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
265 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
266 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
267 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
268 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
269 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
270 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
271 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
272 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
273 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
274 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
275 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
276 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
278 "-----END CERTIFICATE-----\n";
280 char* password = NULL;
284 const char *alias = "test-cert-1-RSA";
286 ckmc_policy_s test_policy;
287 test_policy.password = password;
288 test_policy.extractable = 1;
290 char* char_certPem = new char[certPem.length() + 1];
291 std::strcpy(char_certPem, certPem.c_str());
292 cert.raw_cert = (unsigned char *)char_certPem;
293 cert.cert_size = certPem.length();
294 cert.data_format = CKMC_FORM_PEM;
297 CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias, cert, test_policy)),
298 CKMCReadableError(temp));
301 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
302 CKMCReadableError(temp));
304 ckmc_cert_free(cert2);
307 RUNNER_TEST(T3024_certificate_remove_C_API)
311 char* password = NULL;
313 const char *alias = "test-cert-1-RSA";
316 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
317 CKMCReadableError(temp));
318 ckmc_cert_free(cert2);
321 CKMC_ERROR_NONE == (temp = ckmc_remove_cert(alias)),
322 CKMCReadableError(temp));
325 CKMC_ERROR_NONE != (temp = ckmc_get_cert(alias, password, &cert2)),
326 CKMCReadableError(temp));
329 RUNNER_TEST(T3025_certificate_list_C_API)
333 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
334 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
335 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
336 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
337 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
338 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
339 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
340 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
341 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
342 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
343 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
344 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
345 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
346 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
347 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
348 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
349 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
350 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
351 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
352 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
353 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
354 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
355 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
356 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
357 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
359 "-----END CERTIFICATE-----\n";
361 char* password = NULL;
364 ckmc_policy_s test_policy;
365 test_policy.password = password;
366 test_policy.extractable = 1;
368 char* char_certPem = new char[certPem.length() + 1];
369 std::strcpy(char_certPem, certPem.c_str());
370 cert.raw_cert = (unsigned char *)char_certPem;
371 cert.cert_size = certPem.length();
372 cert.data_format = CKMC_FORM_PEM;
374 int current_aliases_num = count_aliases(ALIAS_CERT);
377 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test1", cert, test_policy)),
378 CKMCReadableError(temp));
381 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test2", cert, test_policy)),
382 CKMCReadableError(temp));
385 CKMC_ERROR_NONE == (temp = ckmc_save_cert("cert_test3", cert, test_policy)),
386 CKMCReadableError(temp));
389 (current_aliases_num+3) == (temp = count_aliases(ALIAS_CERT)),
390 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
394 RUNNER_CHILD_TEST(T3026_user_app_save_key_C_API)
396 AccessProvider ap("mylabel");
397 ap.allowAPI("key-manager::api-storage", "rw");
398 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
400 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
401 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
402 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
403 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
404 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
405 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
406 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
408 "-----END PUBLIC KEY-----";
412 ckmc_key_s test_key, *test_key2;
413 ckmc_policy_s test_policy;
415 char* password = NULL;
416 const char *passwordPolicy = "x";
417 const char *alias = "mykey";
418 char* char_keypem = new char[keyPem.length() + 1];
420 std::strcpy(char_keypem, keyPem.c_str());
421 test_key.raw_key = (unsigned char *)char_keypem;
422 test_key.key_size = keyPem.length();
423 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
424 test_key.password = password;
426 test_policy.password = const_cast<char *>(passwordPolicy);
427 test_policy.extractable = 1;
429 test_key2 = &test_key;
433 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
434 CKMCReadableError(temp));
436 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, passwordPolicy, &test_key2)),
437 CKMCReadableError(temp));
439 // RUNNER_ASSERT_MSG(
440 // key.getDER() == key2.getDER(), "Key value has been changed by service");
443 RUNNER_CHILD_TEST(T3027_app_user_save_keys_exportable_flag)
445 AccessProvider ap("mylabel");
446 ap.allowAPI("key-manager::api-storage", "rw");
447 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
450 auto manager = CKM::Manager::create();
452 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
453 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
454 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
455 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
456 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
457 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
458 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
460 "-----END PUBLIC KEY-----";
462 ckmc_policy_s test_policy;
463 ckmc_key_s test_key, *test_key2;
464 char* char_keypem = new char[keyPem.length() + 1];
465 char* password = NULL;
467 std::strcpy(char_keypem, keyPem.c_str());
468 test_key.raw_key = (unsigned char *)char_keypem;
469 test_key.key_size = keyPem.length();
470 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
471 test_key.password = password;
473 test_policy.password = password;
474 test_policy.extractable = 0;
477 CKMC_ERROR_NONE == (temp = ckmc_save_key("appkey1", test_key, test_policy)),
478 CKMCReadableError(temp));
481 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key("appkey1", password, &test_key2)),
482 CKMCReadableError(temp));
486 RUNNER_TEST(T3028_certificate_with_DSA_key_C_API)
490 std::string certPem = "-----BEGIN CERTIFICATE-----\n"
491 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
492 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
493 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
494 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
495 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
496 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
497 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
498 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
499 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
500 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
501 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
502 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
503 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
504 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
505 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
506 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
507 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
508 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
509 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
510 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
511 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
512 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
513 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
514 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
516 "-----END CERTIFICATE-----\n";
518 char* password = NULL;
519 ckmc_cert_s *cert2 = NULL;
522 ckmc_policy_s test_policy;
523 test_policy.password = password;
524 test_policy.extractable = 1;
526 char* char_certPem = new char[certPem.length() + 1];
527 std::strcpy(char_certPem, certPem.c_str());
528 cert.raw_cert = (unsigned char *)char_certPem;
529 cert.cert_size = certPem.length();
530 cert.data_format = CKMC_FORM_PEM;
532 const char *alias = "test-cert-1-DSA";
534 CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias, cert, test_policy)),
535 CKMCReadableError(temp));
538 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias, password, &cert2)),
539 CKMCReadableError(temp));
541 ckmc_cert_free(cert2);
544 RUNNER_TEST(T3029_deinit_C_API)
548 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
549 CKMCReadableError(temp));
550 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
551 CKMCReadableError(temp));
553 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
554 CKMCReadableError(temp));
556 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
557 CKMCReadableError(temp));
561 RUNNER_TEST_GROUP_INIT (T3030_CKMC_QUICK_GET_ALIAS_TESTS_C_API);
563 RUNNER_TEST(T3031_init_C_API)
568 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
569 CKMCReadableError(temp));
571 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
572 CKMCReadableError(temp));
575 RUNNER_TEST(T3032_save_keys_get_alias_C_API)
579 char* password = NULL;
580 ckmc_policy_s test_policy1, test_policy2, test_policy3;
583 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
584 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
585 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
586 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
587 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
588 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
589 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
591 "-----END PUBLIC KEY-----";
593 char* char_keypem = new char[keyPem.length() + 1];
595 std::strcpy(char_keypem, keyPem.c_str());
596 test_key.raw_key = (unsigned char *)char_keypem;
597 test_key.key_size = keyPem.length();
598 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
599 test_key.password = password;
601 test_policy1.password = password;
602 test_policy1.extractable = 1;
604 test_policy2.password = password;
605 test_policy2.extractable = 0;
607 test_policy3.password = password;
608 test_policy3.extractable = 0;
610 int current_aliases_num = count_aliases(ALIAS_KEY);
613 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey1", test_key, test_policy1)),
614 CKMCReadableError(temp));
617 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey2", test_key, test_policy2)),
618 CKMCReadableError(temp));
621 CKMC_ERROR_NONE == (temp = ckmc_save_key("rootkey3", test_key, test_policy3)),
622 CKMCReadableError(temp));
625 (current_aliases_num+3) == (temp = count_aliases(ALIAS_KEY)),
626 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
630 RUNNER_TEST(T3033_remove_key_C_API)
634 char* password = NULL;
636 ckmc_key_s *test_key2;
638 CKMC_ERROR_NONE == (temp = ckmc_get_key("rootkey1", password, &test_key2)),
639 CKMCReadableError(temp));
642 CKMC_ERROR_NONE == (temp = ckmc_remove_key("rootkey1")),
643 CKMCReadableError(temp));
646 CKMC_ERROR_NONE != (temp = ckmc_get_key("rootkey1", password, &test_key2)),
647 CKMCReadableError(temp));
650 RUNNER_TEST(T3034_deinit_C_API)
654 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
655 CKMCReadableError(temp));
656 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
657 CKMCReadableError(temp));
659 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
660 CKMCReadableError(temp));
662 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
663 CKMCReadableError(temp));
666 RUNNER_TEST_GROUP_INIT (T3040_CKMC_QUICK_REMOVE_BIN_DATA_TEST_C_API);
668 RUNNER_TEST(T3041_init_C_API)
672 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
673 CKMCReadableError(temp));
675 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
676 CKMCReadableError(temp));
679 RUNNER_TEST(T3042_save_get_bin_data_C_API)
683 ckmc_raw_buffer_s testData1, testData2, testData3;
684 char* password = NULL;
686 std::string binData1 = "My bin data1";
687 std::string binData2 = "My bin data2";
688 std::string binData3 = "My bin data3";
689 char* char_binData1 = new char[binData1.length() + 1];
690 char* char_binData2 = new char[binData2.length() + 1];
691 char* char_binData3 = new char[binData3.length() + 1];
692 std::strcpy(char_binData1, binData1.c_str());
693 std::strcpy(char_binData2, binData2.c_str());
694 std::strcpy(char_binData3, binData3.c_str());
695 testData1.data = (unsigned char *) char_binData1;
696 testData2.data = (unsigned char *) char_binData2;
697 testData3.data = (unsigned char *) char_binData3;
698 testData1.size = binData1.length()+1;
699 testData2.size = binData2.length()+1;
700 testData3.size = binData3.length()+1;
702 ckmc_policy_s test_policy1, test_policy2, test_policy3;
704 test_policy1.password = password;
705 test_policy1.extractable = 1;
706 test_policy2.password = password;
707 test_policy2.extractable = 1;
708 test_policy3.password = password;
709 test_policy3.extractable = 0;
711 int current_aliases_num = count_aliases(ALIAS_DATA);
714 CKMC_ERROR_NONE == (temp = ckmc_save_data("data1", testData1, test_policy1)), // should change it as null value
715 CKMCReadableError(temp));
718 CKMC_ERROR_NONE == (temp = ckmc_save_data("data2", testData2, test_policy1)), // should change it as null value
719 CKMCReadableError(temp));
722 CKMC_ERROR_NONE == (temp = ckmc_save_data("data3", testData3, test_policy2)),
723 CKMCReadableError(temp));
726 CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_save_data("data4", testData3, test_policy3)),
727 CKMCReadableError(temp));
730 (current_aliases_num+3) == (temp = count_aliases(ALIAS_DATA)),
731 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
733 ckmc_raw_buffer_s *testData4;
735 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData4)),
736 CKMCReadableError(temp));
739 compareResult = (strcmp((const char *)testData2.data, (const char *)testData4->data));
740 RUNNER_ASSERT_MSG( compareResult == 0,
744 RUNNER_CHILD_TEST(T3043_app_user_save_bin_data_C_API)
746 AccessProvider ap("mylabel");
747 ap.allowAPI("key-manager::api-storage", "rw");
748 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
751 ckmc_raw_buffer_s testData1;
752 char* password = NULL;
753 std::string binData1 = "My bin data";
754 char* char_binData1 = new char[binData1.length() + 1];
755 std::strcpy(char_binData1, binData1.c_str());
756 testData1.data = (unsigned char *) char_binData1;
757 testData1.size = binData1.length()+1;
759 ckmc_policy_s test_policy1, test_policy2;
761 test_policy1.password = password;
762 test_policy1.extractable = 1;
764 test_policy2.password = password;
765 test_policy2.extractable = 1;
767 std::string binData = "My bin data";
769 int current_aliases_num = count_aliases(ALIAS_DATA);
772 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata1", testData1, test_policy1)),
773 CKMCReadableError(temp));
775 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata2", testData1, test_policy1)),
776 CKMCReadableError(temp));
778 CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata3", testData1, test_policy2)),
779 CKMCReadableError(temp));
782 (current_aliases_num+3) == (temp = count_aliases(ALIAS_DATA)),
783 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
786 RUNNER_TEST(T3044_remove_bin_data_C_API)
790 int current_aliases_num = count_aliases(ALIAS_DATA, 2);
793 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data1")),
794 CKMCReadableError(temp));
796 CKMC_ERROR_NONE == (temp = ckmc_remove_data("data3")),
797 CKMCReadableError(temp));
800 (current_aliases_num-2) == (temp = count_aliases(ALIAS_DATA)),
801 "Error: expecting " << (current_aliases_num-2) << " aliases, while found " << temp);
803 char* password = NULL;
805 ckmc_raw_buffer_s *testData1, testData2;
807 std::string testStr = "My bin data2";
808 char* char_testData2 = new char[testStr.length() + 1];
809 std::strcpy(char_testData2, testStr.c_str());
810 testData2.data = (unsigned char *) char_testData2;
811 testData2.size = testStr.length()+1;
813 CKM::RawBuffer buffer;
815 CKMC_ERROR_NONE == (temp = ckmc_get_data("data2", password, &testData1)),
816 CKMCReadableError(temp));
819 compareResult = (strcmp((const char *)testData2.data, (const char *)testData1->data));
820 RUNNER_ASSERT_MSG( compareResult == 0,
824 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_data("data3", password, &testData1)),
825 CKMCReadableError(temp));
828 RUNNER_TEST(T3045_deinit_C_API)
833 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
834 CKMCReadableError(temp));
836 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
837 CKMCReadableError(temp));
839 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
840 CKMCReadableError(temp));
842 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
843 CKMCReadableError(temp));
846 RUNNER_TEST_GROUP_INIT(T305_CKMC_QUICK_CREATE_PAIR_CAPI);
848 RUNNER_TEST(T3051_CAPI_init)
853 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
854 CKMCReadableError(temp));
857 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
858 CKMCReadableError(temp));
861 RUNNER_CHILD_TEST(T3052_CAPI_create_rsa_key)
865 AccessProvider ap("mylabel");
866 ap.allowAPI("key-manager::api-storage", "rw");
867 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
870 const char *private_key_alias = "RSA-test-1-priv";
871 const char *public_key_alias = "RSA-test-1-pub";
872 ckmc_policy_s policy_private_key;
873 ckmc_policy_s policy_public_key;
875 policy_private_key.password = NULL;
876 policy_private_key.extractable = 1;
878 policy_public_key.password = NULL;
879 policy_public_key.extractable = 1;
882 int current_aliases_num = count_aliases(ALIAS_KEY);
885 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
886 CKMCReadableError(temp));
889 (current_aliases_num+2) == (temp = count_aliases(ALIAS_KEY)),
890 "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << temp);
892 ckmc_key_s *privateKey;
894 CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
895 CKMCReadableError(temp));
897 privateKey->key_type == CKMC_KEY_RSA_PRIVATE,
898 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
900 privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
901 "Private key is broken.");
903 ckmc_key_s *publicKey;
905 CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &publicKey)),
906 CKMCReadableError(temp));
908 publicKey->key_type == CKMC_KEY_RSA_PUBLIC,
909 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PUBLIC) << ", actual=" << static_cast<int>(publicKey->key_type));
911 publicKey != NULL && publicKey->key_size > 0 && publicKey->raw_key != NULL,
912 "Public key is broken.");
914 // on next attempt to generate keys with the same alias, expect fail (alias exists)
916 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
917 CKMCReadableError(temp));
920 RUNNER_CHILD_TEST(T3053_CAPI_create_dsa_key)
924 const char *private_key_alias = "DSA-test-2-priv";
925 const char *public_key_alias = "DSA-test-2-pub";
926 ckmc_policy_s policy_private_key;
927 ckmc_policy_s policy_public_key;
929 policy_private_key.password = NULL;
930 policy_private_key.extractable = 1;
932 policy_public_key.password = NULL;
933 policy_public_key.extractable = 1;
935 int current_aliases_num = count_aliases(ALIAS_KEY);
938 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
939 CKMCReadableError(temp));
942 (current_aliases_num+2) == (temp = count_aliases(ALIAS_KEY)),
943 "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << temp);
945 ckmc_key_s *privateKey = 0;
947 CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
948 CKMCReadableError(temp));
950 privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
951 "Private key is broken.");
953 privateKey->key_type == CKMC_KEY_DSA_PRIVATE,
954 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
955 ckmc_key_free(privateKey);
957 ckmc_key_s *pubKey = 0;
959 CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &pubKey)),
960 CKMCReadableError(temp));
962 pubKey != NULL && pubKey->key_size > 0 && pubKey->raw_key != NULL,
963 "Public key is broken.");
965 pubKey->key_type == CKMC_KEY_DSA_PUBLIC,
966 "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PUBLIC) << ", actual=" << static_cast<int>(pubKey->key_type));
967 ckmc_key_free(pubKey);
969 // on next attempt to generate keys with the same alias, expect fail (alias exists)
971 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
972 CKMCReadableError(temp));
976 RUNNER_TEST(T3054_CAPI_deinit)
981 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
982 CKMCReadableError(temp));
984 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
985 CKMCReadableError(temp));
989 RUNNER_TEST_GROUP_INIT(T306_CKMC_CAPI_CreateKeyPair);
991 RUNNER_TEST(T3061_CAPI_init)
995 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
996 CKMCReadableError(temp));
998 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
999 CKMCReadableError(temp));
1001 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1002 CKMCReadableError(temp));
1004 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1005 CKMCReadableError(temp));
1008 RUNNER_TEST(T3062_CAPI_CreateKeyPairRSA)
1013 const char *private_key_alias = "rsa-test-1";
1014 const char *public_key_alias = "rsa-test-2";
1015 ckmc_policy_s policy_private_key;
1016 ckmc_policy_s policy_public_key;
1018 policy_private_key.password = const_cast<char *>("privatepassword");
1019 policy_private_key.extractable = 0;
1021 policy_public_key.password = NULL;
1022 policy_public_key.extractable = 1;
1025 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1026 CKMCReadableError(temp));
1028 // on next attempt to generate keys with the same alias, expect fail (alias exists)
1030 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1031 CKMCReadableError(temp));
1034 RUNNER_TEST(T3063_CAPI_CreateKeyPairDSA)
1039 const char *private_key_alias = "dsa-test-1";
1040 const char *public_key_alias = "dsa-test-2";
1041 ckmc_policy_s policy_private_key;
1042 ckmc_policy_s policy_public_key;
1044 policy_private_key.password = const_cast<char *>("privatepassword");
1045 policy_private_key.extractable = 0;
1047 policy_public_key.password = NULL;
1048 policy_public_key.extractable = 1;
1051 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1052 CKMCReadableError(temp));
1055 RUNNER_TEST(T3064_CAPI_CreateKeyPairECDSA)
1059 ckmc_ec_type_e ectype = CKMC_EC_PRIME192V1;
1060 const char *private_key_alias = "ecdsa-test-1";
1061 const char *public_key_alias = "ecdsa-test-2";
1062 ckmc_policy_s policy_private_key;
1063 ckmc_policy_s policy_public_key;
1065 policy_private_key.password = const_cast<char *>("privatepassword");
1066 policy_private_key.extractable = 0;
1068 policy_public_key.password = NULL;
1069 policy_public_key.extractable = 1;
1072 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_ecdsa(ectype, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1073 CKMCReadableError(temp));
1076 RUNNER_TEST(T3065_CAPI_deinit)
1081 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1082 CKMCReadableError(temp));
1084 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1085 CKMCReadableError(temp));
1089 //RUNNER_TEST_GROUP_INIT(T120_NEGATIVE_TESTS);
1093 RUNNER_TEST_GROUP_INIT(T307_CKMC_CAPI_OCSP_TESTS);
1095 RUNNER_TEST(T3071_CAPI_init)
1099 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1100 CKMCReadableError(temp));
1103 RUNNER_TEST(T3074_CAPI_ckmc_ocsp_check)
1106 "-----BEGIN CERTIFICATE-----\n"
1107 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
1108 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1109 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
1110 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
1111 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
1112 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
1113 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
1114 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
1115 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
1116 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
1117 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
1118 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
1119 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
1120 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
1121 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
1122 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
1123 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
1124 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
1125 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
1126 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
1127 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
1128 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
1129 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
1130 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
1131 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
1132 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
1133 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
1134 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
1135 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
1136 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
1137 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
1139 "-----END CERTIFICATE-----\n";
1142 "-----BEGIN CERTIFICATE-----\n"
1143 "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
1144 "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
1145 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
1146 "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
1147 "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
1148 "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
1149 "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
1150 "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
1151 "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
1152 "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
1153 "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
1154 "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
1155 "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
1156 "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
1157 "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
1158 "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
1159 "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
1160 "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
1161 "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
1162 "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
1163 "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
1164 "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
1165 "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
1166 "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
1167 "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
1168 "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
1169 "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
1170 "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
1171 "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
1172 "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
1173 "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
1174 "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
1175 "-----END CERTIFICATE-----\n";
1178 c_cert.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(ee.c_str()));
1179 c_cert.cert_size = ee.size();
1180 c_cert.data_format = CKMC_FORM_PEM;
1182 ckmc_cert_s c_cert1;
1183 c_cert1.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(im.c_str()));
1184 c_cert1.cert_size = im.size();
1185 c_cert1.data_format = CKMC_FORM_PEM;
1187 ckmc_cert_list_s untrustedcerts;
1188 untrustedcerts.cert = &c_cert1;
1189 untrustedcerts.next = NULL;
1191 ckmc_cert_list_s *cert_chain_list;
1193 int tmp = ckmc_get_cert_chain(&c_cert, &untrustedcerts, &cert_chain_list);
1195 CKMC_ERROR_NONE == tmp, CKMCReadableError(tmp));
1197 RUNNER_ASSERT_MSG(cert_chain_list != NULL, "Wrong size of certificate chain.");
1199 ckmc_ocsp_status_e ocsp_status;
1200 RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == (tmp = ckmc_ocsp_check(cert_chain_list, &ocsp_status)), CKMCReadableError(tmp));
1201 RUNNER_ASSERT_MSG(ocsp_status == CKMC_OCSP_STATUS_GOOD, "Wrong status: " << static_cast<int>(ocsp_status));
1204 RUNNER_TEST(T3075_CAPI_deinit)
1209 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1210 CKMCReadableError(temp));
1212 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1213 CKMCReadableError(temp));
1217 RUNNER_TEST_GROUP_INIT(T308_CAPI_CREATE_AND_VERIFY_SIGNATURE);
1219 RUNNER_TEST(T3081_CAPI__init)
1224 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1225 CKMCReadableError(temp));
1228 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1229 CKMCReadableError(temp));
1232 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1233 CKMCReadableError(temp));
1236 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1237 CKMCReadableError(temp));
1240 RUNNER_TEST(T3082_CAPI__rsa_key_create_verify)
1244 std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1245 "Proc-Type: 4,ENCRYPTED\n"
1246 "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1248 "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1249 "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1250 "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1251 "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1252 "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1253 "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1254 "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1255 "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1256 "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1257 "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1258 "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1259 "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1260 "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1261 "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1262 "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1263 "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1264 "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1265 "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1266 "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1267 "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1268 "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1269 "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1270 "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1271 "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1272 "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1273 "-----END RSA PRIVATE KEY-----\n";
1275 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1276 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1277 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1278 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1279 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1280 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1281 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1283 "-----END PUBLIC KEY-----\n";
1285 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1287 const char *pub_alias = "pub1";
1288 const char *pri_alias = "prv1";
1289 const char *key_passwd = "1234";
1290 char *pri_passwd = NULL;
1291 char *pub_passwd = NULL;
1292 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1293 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1294 ckmc_raw_buffer_s *signature;
1297 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1298 pubkey.key_size = pub.size();
1299 pubkey.key_type = CKMC_KEY_NONE;
1300 pubkey.password = NULL;
1302 ckmc_policy_s pubpolicy;
1303 pubpolicy.password = pub_passwd;
1304 pubpolicy.extractable = 0;
1306 ckmc_policy_s pripolicy;
1307 pripolicy.password = pri_passwd;
1308 pripolicy.extractable = 1;
1311 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1312 prikey.key_size = prv.size();
1313 prikey.key_type = CKMC_KEY_NONE;
1314 prikey.password = const_cast<char *>(key_passwd);
1318 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1319 CKMCReadableError(temp));
1322 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1323 CKMCReadableError(temp));
1326 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1333 CKMCReadableError(temp));
1336 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1343 CKMCReadableError(temp));
1346 RUNNER_TEST(T3083_CAPI__rsa_key_create_verify_negative)
1350 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message asdfaslkdfjlksadjf test");
1351 const char *pub_alias = "pub1";
1352 const char *pri_alias = "prv1";
1353 char *pri_passwd = NULL;
1354 char *pub_passwd = NULL;
1355 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1356 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1357 ckmc_raw_buffer_s *signature;
1360 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1367 CKMCReadableError(temp));
1370 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1377 CKMCReadableError(temp));
1379 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1380 memcpy((void*)signature->data, "BROKEN", 6);
1383 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1390 CKMCReadableError(temp));
1393 RUNNER_TEST(T3084_CAPI__ec_key_create_verify)
1397 std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1398 "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1399 "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1400 "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1401 "-----END EC PRIVATE KEY-----\n";
1403 std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1404 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1405 "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1406 "-----END PUBLIC KEY-----\n";
1408 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1409 const char *pri_alias = "ecprv2";
1410 const char *pub_alias = "ecpub2";
1411 char *key_passwd = NULL;
1412 char *pri_passwd = NULL;
1413 char *pub_passwd = NULL;
1414 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1415 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1416 ckmc_raw_buffer_s *signature;
1419 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1420 pubkey.key_size = pub.size();
1421 pubkey.key_type = CKMC_KEY_NONE;
1422 pubkey.password = NULL;
1424 ckmc_policy_s pubpolicy;
1425 pubpolicy.password = pub_passwd;
1426 pubpolicy.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_key(pub_alias, pubkey, pubpolicy)),
1440 CKMCReadableError(temp));
1442 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1443 CKMCReadableError(temp));
1446 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1453 CKMCReadableError(temp));
1456 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1463 CKMCReadableError(temp));
1465 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1466 memcpy((void*)signature->data, "BROKEN", 6);
1469 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1476 CKMCReadableError(temp));
1479 RUNNER_TEST(T3085_CAPI__rsa_cert_create_verify_signature)
1484 "-----BEGIN RSA PRIVATE KEY-----\n"
1485 "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1486 "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1487 "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1488 "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1489 "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1490 "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1491 "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1492 "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1493 "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1494 "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1495 "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1496 "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1497 "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1498 "-----END RSA PRIVATE KEY-----\n";
1501 "-----BEGIN CERTIFICATE-----\n"
1502 "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1503 "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1504 "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1505 "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1506 "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1507 "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1508 "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1509 "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1510 "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1511 "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1512 "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1513 "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1514 "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1515 "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1516 "-----END CERTIFICATE-----\n";
1518 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1520 const char *pri_alias = "prv3";
1521 const char *pub_alias = "pub3";
1522 char *key_passwd = NULL;
1523 char *pri_passwd = NULL;
1524 char *pub_passwd = NULL;
1525 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1526 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1527 ckmc_raw_buffer_s *signature;
1530 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1531 cert.cert_size = pub.size();
1532 cert.data_format = CKMC_FORM_PEM;
1534 ckmc_policy_s certpolicy;
1535 certpolicy.password = pub_passwd;
1536 certpolicy.extractable = 1;
1539 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1540 prikey.key_size = prv.size();
1541 prikey.key_type = CKMC_KEY_NONE;
1542 prikey.password = key_passwd;
1544 ckmc_policy_s pripolicy;
1545 pripolicy.password = pri_passwd;
1546 pripolicy.extractable = 0;
1549 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1550 CKMCReadableError(temp));
1552 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1553 CKMCReadableError(temp));
1557 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1564 CKMCReadableError(temp));
1567 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1574 CKMCReadableError(temp));
1576 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1577 memcpy((void*)signature->data, "BROKEN", 6);
1580 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1587 CKMCReadableError(temp));
1590 RUNNER_TEST(T3086_CAPI__dsa_ext_key_create_verify_with_negative)
1594 const std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1595 "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1596 "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1597 "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1598 "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1599 "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1600 "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1601 "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1602 "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1603 "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1604 "YMYCBhubtrVaLmc=\n"
1605 "-----END PUBLIC KEY-----";
1607 const std::string priv = "-----BEGIN DSA PRIVATE KEY-----\n"
1608 "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1609 "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1610 "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1611 "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1612 "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1613 "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1614 "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1615 "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1616 "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1617 "u1roOuaPY+Hl19BlTE2qdw==\n"
1618 "-----END DSA PRIVATE KEY-----";
1620 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1622 const char *pub_alias = "dsa-pub1";
1623 const char *pri_alias = "dsa-prv1";
1624 char *pri_passwd = NULL;
1625 char *pub_passwd = NULL;
1626 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1627 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1628 ckmc_raw_buffer_s *signature = NULL;
1631 pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1632 pubkey.key_size = pub.size();
1633 pubkey.key_type = CKMC_KEY_NONE;
1634 pubkey.password = NULL;
1636 ckmc_policy_s pubpolicy;
1637 pubpolicy.password = pub_passwd;
1638 pubpolicy.extractable = 0;
1640 ckmc_policy_s pripolicy;
1641 pripolicy.password = pri_passwd;
1642 pripolicy.extractable = 1;
1645 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(priv.c_str()));
1646 prikey.key_size = priv.size();
1647 prikey.key_type = CKMC_KEY_NONE;
1648 prikey.password = NULL;
1652 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1653 CKMCReadableError(temp));
1656 CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias, pubkey, pubpolicy)),
1657 CKMCReadableError(temp));
1660 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1667 CKMCReadableError(temp));
1671 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1678 CKMCReadableError(temp));
1681 ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1683 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1690 CKMCReadableError(temp));
1692 ckmc_buffer_free(signature);
1695 RUNNER_TEST(T3087_CAPI__dsa_int_key_create_verify_with_negative)
1700 ckmc_policy_s policy_private_key;
1701 ckmc_policy_s policy_public_key;
1703 policy_private_key.password = NULL;
1704 policy_private_key.extractable = 1;
1706 policy_public_key.password = NULL;
1707 policy_public_key.extractable = 1;
1709 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1711 const char *pub_alias = "dsa-pub2";
1712 const char *pri_alias = "dsa-prv2";
1715 CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, pri_alias, pub_alias, policy_private_key, policy_public_key)),
1718 char *pri_passwd = NULL;
1719 char *pub_passwd = NULL;
1720 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1721 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1722 ckmc_raw_buffer_s *signature;
1724 ckmc_key_s *pubkey = NULL;
1725 ckmc_key_s *prikey = NULL;
1727 CKMC_ERROR_NONE == (temp = ckmc_get_key(pri_alias, 0, &prikey)),
1728 CKMCReadableError(temp));
1731 CKMC_ERROR_NONE == (temp = ckmc_get_key(pub_alias, 0, &pubkey)),
1732 CKMCReadableError(temp));
1735 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1742 CKMCReadableError(temp));
1746 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1753 CKMCReadableError(temp));
1756 ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1758 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1765 CKMCReadableError(temp));
1767 ckmc_key_free(prikey);
1768 ckmc_key_free(pubkey);
1769 ckmc_buffer_free(signature);
1772 RUNNER_TEST(T3088_CAPI__ecdsa_cert_create_verify_signature)
1777 "-----BEGIN EC PRIVATE KEY-----\n"
1778 "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1779 "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1780 "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1781 "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1782 "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1783 "ELyhe7yPCAuOoLZlTLgf\n"
1784 "-----END EC PRIVATE KEY-----\n";
1787 "-----BEGIN CERTIFICATE-----\n"
1788 "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1789 "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1790 "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1791 "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1792 "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1793 "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1794 "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1795 "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1796 "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1797 "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1798 "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1799 "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1800 "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1801 "Q1oBry6NEc+lLFmWMDesAA==\n"
1802 "-----END CERTIFICATE-----\n";
1804 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1806 const char *pri_alias = "prv4";
1807 const char *pub_alias = "pub4";
1808 char *key_passwd = NULL;
1809 char *pri_passwd = NULL;
1810 char *pub_passwd = NULL;
1811 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1812 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1813 ckmc_raw_buffer_s *signature;
1816 cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1817 cert.cert_size = pub.size();
1818 cert.data_format = CKMC_FORM_PEM;
1820 ckmc_policy_s certpolicy;
1821 certpolicy.password = pub_passwd;
1822 certpolicy.extractable = 1;
1825 prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1826 prikey.key_size = prv.size();
1827 prikey.key_type = CKMC_KEY_NONE;
1828 prikey.password = key_passwd;
1830 ckmc_policy_s pripolicy;
1831 pripolicy.password = pri_passwd;
1832 pripolicy.extractable = 0;
1836 CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias, cert, certpolicy)),
1837 CKMCReadableError(temp));
1839 CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias, prikey, pripolicy)),
1840 CKMCReadableError(temp));
1843 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1850 CKMCReadableError(temp));
1853 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1860 CKMCReadableError(temp));
1862 RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1863 memcpy((void*)signature->data, "BROKEN", 6);
1866 CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1873 CKMCReadableError(temp));
1876 RUNNER_TEST(T3089_CAPI__deinit)
1881 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
1882 CKMCReadableError(temp));
1884 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1885 CKMCReadableError(temp));
1889 //#######################################################################################
1891 void _assertKey(ckmc_key_s *key, unsigned char *raw_key, unsigned int key_size, ckmc_key_type_e key_type, char *password)
1893 RUNNER_ASSERT_MSG(key->key_size == key_size, "Key Size Error" );
1894 RUNNER_ASSERT_MSG(key->key_type == key_type, "Key Type Error" );
1896 if(key->password != NULL && password != NULL) {
1897 RUNNER_ASSERT_MSG(strcmp(key->password, password) == 0, "Password Error" );
1898 }else if(key->password == NULL && password == NULL) {
1899 RUNNER_ASSERT_MSG(true, "Password Error" );
1901 RUNNER_ASSERT_MSG(false, "Password Error" );
1904 if(key->raw_key != NULL && raw_key != NULL) {
1905 for(unsigned int i=0; i<key_size; i++) {
1906 RUNNER_ASSERT_MSG((key->raw_key)[i] == raw_key[i], "Raw Key Error" );
1908 }else if(key->raw_key == NULL && raw_key == NULL) {
1909 RUNNER_ASSERT_MSG(true, "Raw Key Error" );
1911 RUNNER_ASSERT_MSG(false, "Raw Key Error" );
1915 RUNNER_TEST_GROUP_INIT(T309_CKMC_CAPI_TYPES);
1917 RUNNER_TEST(T3091_CAPI_TYPE_init)
1921 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
1922 CKMCReadableError(temp));
1924 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1925 CKMCReadableError(temp));
1927 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "test-pass")),
1928 CKMCReadableError(temp));
1930 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1931 CKMCReadableError(temp));
1934 RUNNER_TEST(T3092_CAPI_TYPE_KEY)
1936 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1937 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1938 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1939 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1940 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1941 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1942 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1944 "-----END PUBLIC KEY-----";
1946 unsigned char *raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1947 unsigned int key_size = keyPem.size();
1948 ckmc_key_type_e key_type = CKMC_KEY_NONE;
1949 char *password = const_cast< char *>("");
1952 ckmc_key_new(raw_key, key_size, key_type, password, &key);
1954 _assertKey(key, raw_key, key_size, key_type, password);
1957 char *passwordNull = NULL;
1959 ckmc_key_new(raw_key, key_size, key_type, passwordNull, &key2);
1960 ckmc_key_free(key2);
1963 RUNNER_TEST(T3093_CAPI_TYPE_BUFFER)
1965 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1966 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1967 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1968 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1969 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1970 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1971 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1973 "-----END PUBLIC KEY-----";
1975 unsigned char *data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1976 unsigned int size = keyPem.size();
1978 ckmc_raw_buffer_s *buff;
1979 ckmc_buffer_new(data, size, &buff);
1981 RUNNER_ASSERT_MSG(buff->size == size, "Size Error" );
1983 if(buff->data != NULL && data != NULL) {
1984 for(unsigned int i=0; i<size; i++) {
1985 RUNNER_ASSERT_MSG((buff->data)[i] == data[i], "Raw data Error" );
1987 }else if(buff->data == NULL && data == NULL) {
1988 RUNNER_ASSERT_MSG(true, "Raw data Error" );
1990 RUNNER_ASSERT_MSG(false, "Raw data Error" );
1993 ckmc_buffer_free(buff);
1996 RUNNER_TEST(T3094_CAPI_TYPE_CERT)
1998 std::string certPem =
1999 "-----BEGIN CERTIFICATE-----\n"
2000 "MIIEgDCCA2igAwIBAgIIcjtBYJGQtOAwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE\n"
2001 "BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl\n"
2002 "cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwNTIyMTEyOTQyWhcNMTQwODIwMDAwMDAw\n"
2003 "WjBtMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN\n"
2004 "TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEcMBoGA1UEAwwTYWNj\n"
2005 "b3VudHMuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
2006 "ALtlLWVWPN3q3bSEQl1Z97gPdgl5vbgJOZSAr0ZY0tJCuFLBbUKetJWryyE+5KpG\n"
2007 "gMMpLS4v8/bvXaZc6mAs+RfAqGM24C3vQg5hPnj4dflnhL0WiOCZBurm1tV4oexk\n"
2008 "HLXs3jr/jpnb738AQpj8zZ9a4VEBuHJRZALnWZ/XhqU+dvYomAoRQNuL5OhkT7uu\n"
2009 "d0NKJL9JjYLyQglGgE2sVsWv2kj7EO/P9Q6NEKt9BGmhMsFvtfeKUaymynaxpR1g\n"
2010 "wEPlqYvB38goh1dIOgVLT0OVyLImeg5Mdwar/8c1U0OYhLOc6PJapOZAfUkE+3+w\n"
2011 "xYt8AChLN1b5szOwInrCVpECAwEAAaOCAUYwggFCMB0GA1UdJQQWMBQGCCsGAQUF\n"
2012 "BwMBBggrBgEFBQcDAjAeBgNVHREEFzAVghNhY2NvdW50cy5nb29nbGUuY29tMGgG\n"
2013 "CCsGAQUFBwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29t\n"
2014 "L0dJQUcyLmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5j\n"
2015 "b20vb2NzcDAdBgNVHQ4EFgQU0/UtToEtNIfwDwHuYGuVKcj0xK8wDAYDVR0TAQH/\n"
2016 "BAIwADAfBgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAO\n"
2017 "MAwGCisGAQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29n\n"
2018 "bGUuY29tL0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAcGNI/X9f0g+7ij0o\n"
2019 "ehLpk6vxSMQGrmOZ4+PG/MC9SLClCkt7zJkfU7erZnyVXyxCpwlljq+Wk9YTPUOq\n"
2020 "xD/V2ikQVSAANoxGJFO9UoL5jzWusPhKKv8CcM7fuiERz8K+CfBcqfxbgI5rH0g5\n"
2021 "dYclmLC81cJ/08i+9Nltvxv69Y3hGfEICT6K+EdSxwnQzOhpMZmvxZsIj+d6CVNa\n"
2022 "9ICYgUthsNQVWzrIs5wknpjjZ9liDMwJX0vu8A0rce4X/Lna5hh2bW9igz2iP5WM\n"
2023 "9fuwdbTw4y3jfPQgszU4YZxWxhMzccxe058Qx1tLndAknBQEBesQjXytVQpuM1SV\n"
2025 "-----END CERTIFICATE-----\n";
2027 unsigned char *raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(certPem.c_str()));
2028 unsigned int size = certPem.size();
2029 ckmc_data_format_e form = CKMC_FORM_PEM;
2031 ckmc_cert_s *ckmCert;
2032 ckmc_cert_new(raw_cert, size, form, &ckmCert);
2034 RUNNER_ASSERT_MSG(ckmCert->cert_size == size, "Size Error" );
2036 if(ckmCert->raw_cert != NULL && raw_cert != NULL) {
2037 for(unsigned int i=0; i<size; i++) {
2038 RUNNER_ASSERT_MSG((ckmCert->raw_cert)[i] == raw_cert[i], "Raw data Error" );
2040 }else if(ckmCert->raw_cert == NULL && raw_cert == NULL) {
2041 RUNNER_ASSERT_MSG(true, "raw_cert Error" );
2043 RUNNER_ASSERT_MSG(false, "raw_cert Error" );
2046 RUNNER_ASSERT_MSG(ckmCert->data_format == form, "ckmc_cert_form Error" );
2048 ckmc_cert_free(ckmCert);
2052 RUNNER_TEST(T3095_CAPI_TYPE_load_cert_file)
2056 std::string certStr =
2057 "-----BEGIN CERTIFICATE-----\n"
2058 "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
2059 "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
2060 "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
2061 "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
2062 "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
2063 "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
2064 "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
2065 "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
2066 "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
2067 "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
2068 "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
2069 "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
2070 "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
2071 "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
2072 "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
2073 "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
2074 "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
2075 "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
2076 "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
2077 "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
2078 "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
2079 "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
2080 "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
2081 "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
2082 "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
2083 "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
2084 "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
2085 "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
2086 "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
2087 "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
2088 "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
2090 "-----END CERTIFICATE-----\n";
2092 const char *file_name = "/tmp/ckmc_test_cert.pem";
2096 cert_file = fopen(file_name, "w");
2097 fprintf(cert_file, "%s",certStr.c_str());
2103 CKMC_ERROR_NONE == (ret = ckmc_load_cert_from_file(file_name, &pcert)),
2104 CKMCReadableError(ret));
2107 pcert != NULL && pcert->cert_size > 0,"Fail to load cert from file.");
2109 const char *lcert_alias = "lcert_alias";
2110 ckmc_policy_s policy;
2111 policy.password = NULL;
2112 policy.extractable = 1;
2115 CKMC_ERROR_NONE == (ret = ckmc_save_cert(lcert_alias, *pcert, policy)),
2116 CKMCReadableError(ret));
2121 RUNNER_TEST(T3096_CAPI_TYPE_load_p12_file) {
2122 const char *p12file = "/usr/share/ckm-test/capi-t3096.p12";
2123 const char *password = "password";
2127 ckmc_key_s *private_key = NULL;
2128 ckmc_cert_s *cert = NULL;
2129 ckmc_cert_list_s *ca_cert_list = NULL;
2132 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file(p12file, password,
2133 &private_key, &cert, &ca_cert_list)),
2135 RUNNER_ASSERT_MSG(private_key != NULL, "Null private_key");
2136 RUNNER_ASSERT_MSG(cert != NULL, "Null cert");
2137 RUNNER_ASSERT_MSG(ca_cert_list != NULL, "Null ca_cert_list");
2139 ckmc_policy_s policy;
2140 policy.password = NULL;
2141 policy.extractable = 1;
2144 const char *pkey_alias = "pkey_alias";
2146 CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias, *private_key, policy)),
2147 CKMCReadableError(temp));
2149 const char *cert_alias = "cert_alias";
2151 CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias, *cert, policy)),
2152 CKMCReadableError(temp));
2153 std::string caCertAlias = "ca_cert_alias_";
2154 const char *idx = "0";
2156 ckmc_cert_list_s *tmpList = ca_cert_list;
2157 while(tmpList != NULL) {
2158 caCertAlias.append(idx);
2160 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2161 CKMCReadableError(temp));
2162 tmpList = tmpList->next;
2166 RUNNER_ASSERT_MSG(cnt == 2, "Invalid CA Cert Count");
2168 ckmc_key_free(private_key);
2169 ckmc_cert_free(cert);
2170 ckmc_cert_list_all_free(ca_cert_list);
2173 RUNNER_TEST(T3097_CAPI_TYPE_load_p12_file2) {
2174 const char *p12file = "/usr/share/ckm-test/capi-t3096.p12";
2175 const char *password = "password";
2179 ckmc_pkcs12_s *ppkcs12 = NULL;
2182 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file2(p12file, password, &ppkcs12)),
2183 CKMCReadableError(temp));
2184 RUNNER_ASSERT_MSG(ppkcs12->priv_key != NULL, "Null private_key");
2185 RUNNER_ASSERT_MSG(ppkcs12->cert != NULL, "Null cert");
2186 RUNNER_ASSERT_MSG(ppkcs12->ca_chain != NULL, "Null ca_cert_list");
2188 ckmc_policy_s policy;
2189 policy.password = NULL;
2190 policy.extractable = 1;
2193 const char *pkey_alias = "pkey_alias2";
2195 CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias, *(ppkcs12->priv_key), policy)),
2196 CKMCReadableError(temp));
2198 const char *cert_alias = "cert_alias2";
2200 CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias, *(ppkcs12->cert), policy)),
2201 CKMCReadableError(temp));
2202 std::string caCertAlias = "ca_cert_alias_2_";
2203 const char *idx = "0";
2205 ckmc_cert_list_s *tmpList = ppkcs12->ca_chain;
2206 while(tmpList != NULL) {
2207 caCertAlias.append(idx);
2209 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2210 CKMCReadableError(temp));
2211 tmpList = tmpList->next;
2215 RUNNER_ASSERT_MSG(cnt == 2, "Invalid CA Cert Count");
2217 ckmc_pkcs12_free(ppkcs12);
2220 RUNNER_TEST(T3098_CAPI_TYPE_deinit)
2224 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2225 CKMCReadableError(temp));
2227 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2228 CKMCReadableError(temp));
2230 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2231 CKMCReadableError(temp));
2233 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2234 CKMCReadableError(temp));
2237 RUNNER_TEST_GROUP_INIT(T310_CKMC_CAPI_PKCS12);
2241 const char* alias_PKCS_collision = "CAPI-test-PKCS-collision";
2242 const char* alias_PKCS_exportable = "CAPI-test-PKCS-export";
2243 const char* alias_PKCS_not_exportable = "CAPI-test-PKCS-no-export";
2244 const char* alias_PKCS_priv_key_copy = "CAPI-test-PKCS-private-key-copy";
2245 const char* alias_PKCS_priv_key_wrong = "CAPI-test-PKCS-private-key-wrong";
2248 RUNNER_TEST(T3101_CAPI_PKCS12_init)
2252 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2253 CKMCReadableError(temp));
2255 CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "user-pass")),
2256 CKMCReadableError(temp));
2258 ckmc_remove_pkcs12(alias_PKCS_collision);
2259 ckmc_remove_pkcs12(alias_PKCS_exportable);
2260 ckmc_remove_pkcs12(alias_PKCS_not_exportable);
2261 ckmc_remove_pkcs12(alias_PKCS_priv_key_copy);
2262 ckmc_remove_pkcs12(alias_PKCS_priv_key_wrong);
2265 RUNNER_TEST(T3102_CAPI_PKCS12_negative_wrong_password)
2267 const char *wrong_passwd = "wrong";
2268 ckmc_pkcs12_s *ppkcs12 = NULL;
2271 CKMC_ERROR_INVALID_FORMAT == (temp = ckmc_load_from_pkcs12_file2("/usr/share/ckm-test/test1801.pkcs12", wrong_passwd, &ppkcs12)),
2272 CKMCReadableError(temp));
2275 RUNNER_TEST(T3103_CAPI_PKCS12_add_bundle_with_chain_certs)
2277 ckmc_pkcs12_s *ppkcs12 = NULL;
2280 CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file2("/usr/share/ckm-test/pkcs.p12", NULL, &ppkcs12)),
2281 CKMCReadableError(temp));
2283 RUNNER_ASSERT_MSG(NULL != ppkcs12->cert, "no certificate in PKCS12");
2284 RUNNER_ASSERT_MSG(NULL != ppkcs12->priv_key, "no private key in PKCS12");
2285 RUNNER_ASSERT_MSG(NULL != ppkcs12->ca_chain, "no chain certificates in PKCS12");
2288 ckmc_policy_s exportable;
2289 exportable.password = NULL;
2290 exportable.extractable = 1;
2291 ckmc_policy_s notExportable;
2292 notExportable.password = NULL;
2293 notExportable.extractable = 0;
2296 CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_exportable, ppkcs12, exportable, exportable)),
2297 CKMCReadableError(temp));
2299 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_exportable, ppkcs12, exportable, exportable)),
2300 CKMCReadableError(temp));
2302 CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable, ppkcs12, notExportable, notExportable)),
2303 CKMCReadableError(temp));
2305 CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable, ppkcs12, notExportable, notExportable)),
2306 CKMCReadableError(temp));
2308 // try to lookup key
2309 ckmc_key_s *key_lookup = NULL;
2311 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias_PKCS_exportable, NULL, &key_lookup)),
2312 CKMCReadableError(temp));
2313 ckmc_key_free(key_lookup);
2316 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key(alias_PKCS_not_exportable, "", &key_lookup)),
2317 CKMCReadableError(temp));
2318 ckmc_key_free(key_lookup);
2320 // try to lookup certificate
2321 ckmc_cert_s *cert_lookup = NULL;
2323 CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias_PKCS_exportable, NULL, &cert_lookup)),
2324 CKMCReadableError(temp));
2325 ckmc_cert_free(cert_lookup);
2328 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_cert(alias_PKCS_not_exportable, NULL, &cert_lookup)),
2329 CKMCReadableError(temp));
2330 ckmc_cert_free(cert_lookup);
2333 RUNNER_TEST(T3103_CAPI_PKCS12_get_PKCS)
2336 auto manager = CKM::Manager::create();
2338 ckmc_pkcs12_s *pkcs = NULL;
2342 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_pkcs12("i-do-not-exist", NULL, NULL, &pkcs)),
2343 CKMCReadableError(temp));
2344 ckmc_pkcs12_free(pkcs);
2347 // fail - not exportable
2349 CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_pkcs12(alias_PKCS_not_exportable, NULL, NULL, &pkcs)),
2350 CKMCReadableError(temp));
2351 ckmc_pkcs12_free(pkcs);
2354 // success - exportable
2356 CKMC_ERROR_NONE == (temp = ckmc_get_pkcs12(alias_PKCS_exportable, NULL, NULL, &pkcs)),
2357 CKMCReadableError(temp));
2359 RUNNER_ASSERT_MSG(NULL != pkcs->cert, "no certificate in PKCS12");
2360 RUNNER_ASSERT_MSG(NULL != pkcs->priv_key, "no private key in PKCS12");
2361 RUNNER_ASSERT_MSG(NULL != pkcs->ca_chain, "no chain certificates in PKCS12");
2363 ckmc_cert_list_s *iter = pkcs->ca_chain;
2368 RUNNER_ASSERT_MSG(2 == cntr, "invalid number of chain certificates in PKCS12");
2370 ckmc_pkcs12_free(pkcs);
2373 RUNNER_TEST(T3104_CAPI_PKCS12_create_and_verify_signature)
2375 ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
2378 ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
2379 ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
2380 ckmc_raw_buffer_s *signature = NULL;
2383 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
2384 alias_PKCS_exportable,
2390 CKMCReadableError(temp));
2393 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
2394 alias_PKCS_exportable,
2400 CKMCReadableError(temp));
2403 RUNNER_TEST(T3105_CAPI_PKCS12_remove_bundle_with_chain_certs)
2407 // remove the whole PKCS12 bundles
2409 CKMC_ERROR_NONE == (tmp = ckmc_remove_pkcs12(alias_PKCS_exportable)),
2410 CKMCReadableError(tmp));
2412 CKMC_ERROR_NONE == (tmp = ckmc_remove_pkcs12(alias_PKCS_not_exportable)),
2413 CKMCReadableError(tmp));
2415 // expect lookup fails due to unknown alias
2416 // try to lookup key
2417 ckmc_key_s *key_lookup = NULL;
2419 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_exportable, NULL, &key_lookup)),
2420 CKMCReadableError(tmp));
2421 ckmc_key_free(key_lookup);
2424 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_not_exportable, NULL, &key_lookup)),
2425 CKMCReadableError(tmp));
2426 ckmc_key_free(key_lookup);
2428 // try to lookup certificate
2429 ckmc_cert_s *cert_lookup = NULL;
2431 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_exportable, NULL, &cert_lookup)),
2432 CKMCReadableError(tmp));
2433 ckmc_cert_free(cert_lookup);
2436 CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_not_exportable, NULL, &cert_lookup)),
2437 CKMCReadableError(tmp));
2438 ckmc_cert_free(cert_lookup);
2441 RUNNER_TEST(T3109_CAPI_PKCS12_deinit)
2445 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2446 CKMCReadableError(temp));
2449 RUNNER_TEST_GROUP_INIT(T3110_CAPI_LOCKTYPE_TESTS);
2451 RUNNER_CHILD_TEST(T3111_CAPI_init_lock_key)
2454 AccessProvider ap("my-label");
2455 ap.allowAPI("key-manager::api-control", "rw");
2456 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2458 char *null_password = NULL;
2460 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,USER_PASS,null_password)),
2461 CKMCReadableError(tmp));
2462 RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)), CKMCReadableError(tmp));
2465 RUNNER_CHILD_TEST(T3112_CAPI_unlock_default_passwd)
2467 AccessProvider ap("my-label");
2468 ap.allowAPI("key-manager::api-storage", "rw");
2469 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2473 ckmc_key_s test_key, *test_key2;
2474 ckmc_policy_s test_policy;
2476 char* password = NULL;
2477 char alias[20] = "mykey_defpasswd";
2479 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2480 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2481 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2482 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2483 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2484 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2485 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2487 "-----END PUBLIC KEY-----";
2489 char* char_keypem = new char[keyPem.length() + 1];
2491 std::strcpy(char_keypem, keyPem.c_str());
2492 test_key.raw_key = (unsigned char *)char_keypem;
2493 test_key.key_size = keyPem.length();
2494 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2495 test_key.password = password;
2497 test_policy.password = password;
2498 test_policy.extractable = 1;
2500 test_key2 = &test_key;
2503 CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
2504 CKMCReadableError(temp));
2507 CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, password, &test_key2)),
2508 CKMCReadableError(temp));
2510 CKMC_ERROR_NONE == (temp = ckmc_remove_key(alias)),
2511 CKMCReadableError(temp));
2514 RUNNER_CHILD_TEST(T3113_CAPI_init_change_user_password)
2517 AccessProvider ap("my-label");
2518 ap.allowAPI("key-manager::api-control", "rw");
2519 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2521 char *null_password = NULL;
2523 // database has been automatically unlocked with NULL pw in previous test. Lock it now
2525 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2526 CKMCReadableError(tmp));
2528 CKMC_ERROR_NONE == (tmp = ckmc_change_user_password(USER_APP,null_password,USER_PASS)),
2529 CKMCReadableError(tmp));
2530 // get rid of NULL DKEK
2532 CKMC_ERROR_NONE == (tmp = ckmc_unlock_user_key(USER_APP,USER_PASS)),
2533 CKMCReadableError(tmp));
2535 CKMC_ERROR_NONE == (tmp = ckmc_lock_user_key(USER_APP)),
2536 CKMCReadableError(tmp));
2539 RUNNER_CHILD_TEST(T3114_CAPI_unlock_default_passwd_negative)
2541 AccessProvider ap("my-label");
2542 ap.allowAPI("key-manager::api-storage", "rw");
2543 ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2547 ckmc_key_s test_key, *test_key2;
2548 ckmc_policy_s test_policy;
2550 char* password = NULL;
2551 char alias[20] = "mykey_defpasswd";
2553 std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
2554 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
2555 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
2556 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
2557 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
2558 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
2559 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
2561 "-----END PUBLIC KEY-----";
2563 char* char_keypem = new char[keyPem.length() + 1];
2565 std::strcpy(char_keypem, keyPem.c_str());
2566 test_key.raw_key = (unsigned char *)char_keypem;
2567 test_key.key_size = keyPem.length();
2568 test_key.key_type = CKMC_KEY_RSA_PUBLIC;
2569 test_key.password = password;
2571 test_policy.password = password;
2572 test_policy.extractable = 1;
2574 test_key2 = &test_key;
2577 CKMC_ERROR_DB_LOCKED == (temp = ckmc_save_key(alias, test_key, test_policy)),
2578 CKMCReadableError(temp));
2581 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key2)),
2582 CKMCReadableError(temp));
2585 RUNNER_CHILD_TEST(T3119_CAPI_deinit)
2589 CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2590 CKMCReadableError(temp));
2592 CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2593 CKMCReadableError(temp));
2596 RUNNER_TEST_GROUP_INIT(T320_CAPI_EMPTY_DATABASE);
2598 RUNNER_TEST(T3201_CAPI_unlock_database)
2601 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2602 CKMCReadableError(temp));
2603 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2604 CKMCReadableError(temp));
2605 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(0, "simple-password")),
2606 CKMCReadableError(temp));
2609 RUNNER_CHILD_TEST(T3202_CAPI_get_data_from_empty_database)
2612 char alias[10] = "mykey";
2613 char *password = NULL;
2614 ckmc_key_s *test_key = NULL;
2617 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(alias, password, &test_key)),
2620 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2623 RUNNER_CHILD_TEST(T3203_CAPI_lock_database)
2626 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(0)),
2627 CKMCReadableError(temp));
2630 RUNNER_CHILD_TEST(T3204_CAPI_get_data_from_locked_database)
2633 char alias[10] = "mykey";
2634 char *password = NULL;
2635 ckmc_key_s *test_key = NULL;
2638 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias, password, &test_key)),
2639 CKMCReadableError(temp));
2641 RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2644 RUNNER_TEST(T3204_deinit)
2647 RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
2648 CKMCReadableError(temp));