static void test_hash_count (void) { p11_dict *map; int *value; int i; bool ret; map = p11_dict_new (p11_dict_intptr_hash, p11_dict_intptr_equal, NULL, free); assert_num_eq (0, p11_dict_size (map)); for (i = 0; i < 20000; ++i) { value = malloc (sizeof (int)); assert (value != NULL); *value = i; if (!p11_dict_set (map, value, value)) assert_not_reached (); assert_num_eq (i + 1, p11_dict_size (map)); } for (i = 0; i < 20000; ++i) { ret = p11_dict_remove (map, &i); assert_num_eq (true, ret); assert_num_eq (20000 - (i + 1), p11_dict_size (map)); } p11_dict_clear (map); assert_num_eq (0, p11_dict_size (map)); p11_dict_free (map); }
static void test_iterate (void) { p11_dict *map; p11_dictiter iter; int key = 1; int value = 2; void *pkey; void *pvalue; int ret; map = p11_dict_new (p11_dict_direct_hash, p11_dict_direct_equal, NULL, NULL); assert_ptr_not_null (map); if (!p11_dict_set (map, &key, &value)) assert_not_reached (); p11_dict_iterate (map, &iter); ret = p11_dict_next (&iter, &pkey, &pvalue); assert_num_eq (1, ret); assert_ptr_eq (pkey, &key); assert_ptr_eq (pvalue, &value); ret = p11_dict_next (&iter, &pkey, &pvalue); assert_num_eq (0, ret); p11_dict_free (map); }
static void test_uri_slot_id (void) { P11KitUri *uri; CK_SLOT_ID slot_id; char *string; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); p11_kit_uri_set_slot_id (uri, 12345); slot_id = p11_kit_uri_get_slot_id (uri); assert_num_eq (12345, slot_id); ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string); assert_num_eq (P11_KIT_URI_OK, ret); assert (strstr (string, "pkcs11:slot-id=12345") != NULL); free (string); ret = p11_kit_uri_parse ("pkcs11:slot-id=67890", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); slot_id = p11_kit_uri_get_slot_id (uri); assert_num_eq (67890, slot_id); p11_kit_uri_free (uri); }
static void test_uri_pin_value (void) { P11KitUri *uri; const char *pin_value; char *string; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); p11_kit_uri_set_pin_value (uri, "123456"); pin_value = p11_kit_uri_get_pin_value (uri); assert_str_eq ("123456", pin_value); p11_kit_uri_set_pin_value (uri, "1*&#%&@("); pin_value = p11_kit_uri_get_pin_value (uri); assert_str_eq ("1*&#%&@(", pin_value); ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string); assert_num_eq (P11_KIT_URI_OK, ret); assert (strstr (string, "pkcs11:?pin-value=1%2a%26%23%25%26%40%28") != NULL); free (string); ret = p11_kit_uri_parse ("pkcs11:?pin-value=blah%2Fblah", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); pin_value = p11_kit_uri_get_pin_value (uri); assert_str_eq ("blah/blah", pin_value); p11_kit_uri_free (uri); }
static void test_uri_match_version (void) { CK_INFO info; P11KitUri *uri; int ret; memset (&info, 0, sizeof (info)); uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:library-version=5.8", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); info.libraryVersion.major = 5; info.libraryVersion.minor = 8; ret = p11_kit_uri_match_module_info (uri, &info); assert_num_eq (1, ret); info.libraryVersion.major = 2; info.libraryVersion.minor = 3; ret = p11_kit_uri_match_module_info (uri, &info); assert_num_eq (0, ret); p11_kit_uri_free (uri); }
static void test_set_get_remove (void) { char *key = "KEY"; char *value = "VALUE"; char *check; p11_dict *map; bool ret; map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL); if (!p11_dict_set (map, key, value)) assert_not_reached (); check = p11_dict_get (map, key); assert_ptr_eq (check, value); ret = p11_dict_remove (map, key); assert_num_eq (true, ret); ret = p11_dict_remove (map, key); assert_num_eq (false, ret); check = p11_dict_get (map, key); assert (check == NULL); p11_dict_free (map); }
static void test_uri_parse_with_empty_id (void) { CK_ATTRIBUTE_PTR attr; P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:id=;type=cert", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); attr = p11_kit_uri_get_attribute (uri, CKA_ID); assert_ptr_not_null (attr); p11_kit_uri_free (uri); /* really empty */ uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:type=cert", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); attr = p11_kit_uri_get_attribute (uri, CKA_ID); assert (attr == NULL); p11_kit_uri_free (uri); }
static void test_uri_get_set_attribute (void) { CK_ATTRIBUTE attr; CK_ATTRIBUTE_PTR ptr; P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ptr = p11_kit_uri_get_attribute (uri, CKA_LABEL); assert_ptr_eq (NULL, ptr); ret = p11_kit_uri_clear_attribute (uri, CKA_LABEL); assert_num_eq (P11_KIT_URI_OK, ret); ret = p11_kit_uri_clear_attribute (uri, CKA_COLOR); assert_num_eq (P11_KIT_URI_NOT_FOUND, ret); attr.type = CKA_LABEL; attr.pValue = "Test"; attr.ulValueLen = 4; ret = p11_kit_uri_set_attribute (uri, &attr); assert_num_eq (P11_KIT_URI_OK, ret); /* We can set other attributes */ attr.type = CKA_COLOR; ret = p11_kit_uri_set_attribute (uri, &attr); assert_num_eq (P11_KIT_URI_OK, ret); /* And get them too */ ptr = p11_kit_uri_get_attribute (uri, CKA_COLOR); assert_ptr_not_null (ptr); ptr = p11_kit_uri_get_attribute (uri, CKA_LABEL); assert_ptr_not_null (ptr); assert (ptr->type == CKA_LABEL); assert (ptr->ulValueLen == 4); assert (memcmp (ptr->pValue, "Test", 4) == 0); ret = p11_kit_uri_clear_attribute (uri, CKA_LABEL); assert_num_eq (P11_KIT_URI_OK, ret); ptr = p11_kit_uri_get_attribute (uri, CKA_LABEL); assert_ptr_eq (NULL, ptr); p11_kit_uri_free (uri); }
static void test_iterate_remove (void) { p11_dict *map; p11_dictiter iter; char *keys[] = { "111", "222", "333" }; char *values[] = { "444", "555", "666" }; void *okeys[3]; void *ovalues[3]; bool ret; int i; map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL); assert_ptr_not_null (map); for (i = 0; i < 3; i++) { if (!p11_dict_set (map, keys[i], values[i])) assert_not_reached (); } p11_dict_iterate (map, &iter); ret = p11_dict_next (&iter, &okeys[0], &ovalues[0]); assert_num_eq (true, ret); ret = p11_dict_next (&iter, &okeys[1], &ovalues[1]); assert_num_eq (true, ret); if (!p11_dict_remove (map, okeys[1])) assert_not_reached (); ret = p11_dict_next (&iter, &okeys[2], &ovalues[2]); assert_num_eq (true, ret); ret = p11_dict_next (&iter, NULL, NULL); assert_num_eq (false, ret); assert_num_eq (2, p11_dict_size (map)); p11_dict_free (map); qsort (okeys, 3, sizeof (void *), compar_strings); qsort (ovalues, 3, sizeof (void *), compar_strings); for (i = 0; i < 3; i++) { assert_str_eq (keys[i], okeys[i]); assert_ptr_eq (keys[i], okeys[i]); assert_str_eq (values[i], ovalues[i]); assert_ptr_eq (values[i], ovalues[i]); } }
static void test_password_bad (void) { char *response; char *challenge; assert_num_eq (mock_reauthorize ("prepare", user, "actual-password", NULL), 0); assert_num_eq (mock_reauthorize ("perform", user, NULL, &challenge), REAUTHORIZE_CONTINUE); assert_num_eq (reauthorize_crypt1 (challenge, "bad password", &response), 0); assert_num_eq (mock_reauthorize ("perform", user, response, NULL), REAUTHORIZE_NO); free (response); free (challenge); }
static void test_password_success (void) { const char *password = "******"; char *response; char *challenge; assert_num_eq (mock_reauthorize ("prepare", user, password, NULL), 0); assert_num_eq (mock_reauthorize ("perform", user, NULL, &challenge), REAUTHORIZE_CONTINUE); assert_num_eq (reauthorize_crypt1 (challenge, password, &response), 0); assert_num_eq (mock_reauthorize ("perform", user, response, NULL), REAUTHORIZE_YES); free (response); free (challenge); }
static void test_free_destroys (void) { p11_dict *map; Key key = { 8, 0 }; int value = 0; map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy); assert_ptr_not_null (map); if (!p11_dict_set (map, &key, &value)) assert_not_reached (); p11_dict_free (map); assert_num_eq (true, key.freed); assert_num_eq (2, value); }
static void test_uri_build_object_type_secret (void) { CK_ATTRIBUTE attr; CK_OBJECT_CLASS klass; P11KitUri *uri; char *string; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); klass = CKO_SECRET_KEY; attr.type = CKA_CLASS; attr.pValue = &klass; attr.ulValueLen = sizeof (klass); p11_kit_uri_set_attribute (uri, &attr); ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string); assert_num_eq (P11_KIT_URI_OK, ret); assert (strstr (string, "type=secret-key") != NULL); p11_kit_uri_free (uri); free (string); }
static void test_hash_ulongptr (void) { p11_dict *map; unsigned long *value; unsigned long i; map = p11_dict_new (p11_dict_ulongptr_hash, p11_dict_ulongptr_equal, NULL, free); for (i = 0; i < 20000; ++i) { value = malloc (sizeof (unsigned long)); assert (value != NULL); *value = i; if (!p11_dict_set (map, value, value)) assert_not_reached (); } for (i = 0; i < 20000; ++i) { value = p11_dict_get (map, &i); assert_ptr_not_null (value); assert_num_eq (i, *value); } p11_dict_free (map); }
static void test_uri_parse_with_label_and_new_klass (void) { CK_ATTRIBUTE_PTR attr; P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:object=Test%20Label;type=cert", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); attr = p11_kit_uri_get_attribute (uri, CKA_LABEL); assert_ptr_not_null (attr); assert (attr->ulValueLen == strlen ("Test Label")); assert (memcmp (attr->pValue, "Test Label", attr->ulValueLen) == 0); attr = p11_kit_uri_get_attribute (uri, CKA_CLASS); assert_ptr_not_null (attr); assert (attr->ulValueLen == sizeof (CK_OBJECT_CLASS)); assert (*((CK_OBJECT_CLASS_PTR)attr->pValue) == CKO_CERTIFICATE); p11_kit_uri_free (uri); }
static void test_hash_add_check_lots_and_collisions (void) { p11_dict *map; int *value; int i; map = p11_dict_new (test_hash_intptr_with_collisions, p11_dict_intptr_equal, NULL, free); for (i = 0; i < 20000; ++i) { value = malloc (sizeof (int)); assert (value != NULL); *value = i; if (!p11_dict_set (map, value, value)) assert_not_reached (); } for (i = 0; i < 20000; ++i) { value = p11_dict_get (map, &i); assert_ptr_not_null (value); assert_num_eq (i, *value); } p11_dict_free (map); }
static void test_uri_parse_unrecognized (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:x-blah=some-value", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); ret = p11_kit_uri_any_unrecognized (uri); assert_num_eq (1, ret); p11_kit_uri_free (uri); }
static void test_uri_parse_too_long_is_unrecognized (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:model=a-value-that-is-too-long-for-the-field-that-it-goes-with", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); ret = p11_kit_uri_any_unrecognized (uri); assert_num_eq (1, ret); p11_kit_uri_free (uri); }
static void test_password_no_prepare (void) { char *challenge = NULL; assert_num_eq (mock_reauthorize ("perform", user, NULL, &challenge), REAUTHORIZE_NO); free (challenge); }
static void test_initialize (void) { CK_FUNCTION_LIST_PTR module; Override over = { }; CK_RV rv; p11_virtual_init (&over.virt, &p11_virtual_stack, &mock_x_module_no_slots, test_destroyer); over.virt.funcs.C_Initialize = override_initialize; over.check = "overide-arg"; test_destroyed = false; module = p11_virtual_wrap (&over.virt, (p11_destroyer)p11_virtual_uninit); assert_ptr_not_null (module); rv = (module->C_Initialize) ("initialize-arg"); assert_num_eq (CKR_NEED_TO_CREATE_THREADS, rv); p11_virtual_unwrap (module); assert_num_eq (true, test_destroyed); }
static void test_clear_destroys (void) { p11_dict *map; Key key = { 18, 0 }; int value = 0; map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy); assert_ptr_not_null (map); if (!p11_dict_set (map, &key, &value)) assert_not_reached (); p11_dict_clear (map); assert_num_eq (true, key.freed); assert_num_eq (2, value); /* should not be destroyed again */ key.freed = false; value = 0; p11_dict_clear (map); assert_num_eq (false, key.freed); assert_num_eq (0, value); /* should not be destroyed again */ key.freed = false; value = 0; p11_dict_free (map); assert_num_eq (false, key.freed); assert_num_eq (0, value); }
static void test_uri_build_with_token_info (void) { char *string = NULL; P11KitUri *uri; P11KitUri *check; CK_TOKEN_INFO_PTR token; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); token = p11_kit_uri_get_token_info (uri); set_space_string (token->label, sizeof (token->label), "The Label"); set_space_string (token->serialNumber, sizeof (token->serialNumber), "44444"); set_space_string (token->manufacturerID, sizeof (token->manufacturerID), "Me"); set_space_string (token->model, sizeof (token->model), "Deluxe"); ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string); assert_num_eq (P11_KIT_URI_OK, ret); assert_ptr_not_null (string); check = p11_kit_uri_new (); assert_ptr_not_null (check); ret = p11_kit_uri_parse (string, P11_KIT_URI_FOR_TOKEN, check); assert_num_eq (P11_KIT_URI_OK, ret); p11_kit_uri_match_token_info (check, p11_kit_uri_get_token_info (uri)); p11_kit_uri_free (uri); p11_kit_uri_free (check); assert (strstr (string, "token=The%20Label") != NULL); assert (strstr (string, "serial=44444") != NULL); assert (strstr (string, "manufacturer=Me") != NULL); assert (strstr (string, "model=Deluxe") != NULL); free (string); }
static void test_uri_parse_bad_scheme (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("http:\\example.com\test", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_BAD_SCHEME, ret); p11_kit_uri_free (uri); }
static void test_uri_pin_value_bad (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:?pin-value=blahblah%2", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_BAD_ENCODING, ret); p11_kit_uri_free (uri); }
static void test_uri_slot_id_bad (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:slot-id=123^456", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_BAD_SYNTAX, ret); p11_kit_uri_free (uri); }
static void test_uri_parse_with_bad_hex_encoding (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:object=T%xxest", P11_KIT_URI_FOR_OBJECT, uri); assert_num_eq (P11_KIT_URI_BAD_ENCODING, ret); p11_kit_uri_free (uri); }
static void test_uri_parse_with_token_bad_encoding (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:token=Token%", P11_KIT_URI_FOR_TOKEN, uri); assert_num_eq (P11_KIT_URI_BAD_ENCODING, ret); p11_kit_uri_free (uri); }
static void test_uri_parse_with_bad_syntax (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:token", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_BAD_SYNTAX, ret); p11_kit_uri_free (uri); }
static void test_uri_parse_with_library_bad_encoding (void) { P11KitUri *uri; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); ret = p11_kit_uri_parse ("pkcs11:library-description=Library%", P11_KIT_URI_FOR_MODULE, uri); assert_num_eq (P11_KIT_URI_BAD_ENCODING, ret); p11_kit_uri_free (uri); }
static void test_uri_pin_source (void) { P11KitUri *uri; const char *pin_source; char *string; int ret; uri = p11_kit_uri_new (); assert_ptr_not_null (uri); p11_kit_uri_set_pin_source (uri, "|my-pin-source"); pin_source = p11_kit_uri_get_pin_source (uri); assert_str_eq ("|my-pin-source", pin_source); pin_source = p11_kit_uri_get_pinfile (uri); assert_str_eq ("|my-pin-source", pin_source); p11_kit_uri_set_pinfile (uri, "|my-pin-file"); pin_source = p11_kit_uri_get_pin_source (uri); assert_str_eq ("|my-pin-file", pin_source); ret = p11_kit_uri_format (uri, P11_KIT_URI_FOR_ANY, &string); assert_num_eq (P11_KIT_URI_OK, ret); assert (strstr (string, "pin-source=%7cmy-pin-file") != NULL); free (string); ret = p11_kit_uri_parse ("pkcs11:?pin-source=blah%2Fblah", P11_KIT_URI_FOR_ANY, uri); assert_num_eq (P11_KIT_URI_OK, ret); pin_source = p11_kit_uri_get_pin_source (uri); assert_str_eq ("blah/blah", pin_source); p11_kit_uri_free (uri); }