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);
}
