/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* test-secret-fields.c: Test secret fields Copyright (C) 2009 Stefan Walter The Gnome Keyring Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The Gnome Keyring Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the Gnome Library; see the file COPYING.LIB. If not, . Author: Stef Walter */ #include "config.h" #include "secret-store/gkm-secret-fields.h" #include "pkcs11/pkcs11i.h" #include #include #include #include static void test_new (void) { GHashTable *fields = gkm_secret_fields_new (); g_hash_table_unref (fields); } static void test_boxed (void) { GType boxed = gkm_secret_fields_boxed_type (); GType check = gkm_secret_fields_boxed_type (); g_assert (boxed == check); } static void test_add_get_values (void) { GHashTable *fields = gkm_secret_fields_new (); const gchar *value; gkm_secret_fields_add (fields, "one", "value1"); gkm_secret_fields_take (fields, g_strdup ("two"), g_strdup ("value2")); gkm_secret_fields_add (fields, "three", NULL); value = gkm_secret_fields_get (fields, "one"); g_assert_cmpstr (value, ==, "value1"); value = gkm_secret_fields_get (fields, "two"); g_assert_cmpstr (value, ==, "value2"); value = gkm_secret_fields_get (fields, "three"); g_assert_cmpstr (value, ==, ""); g_hash_table_unref (fields); } static void test_parse (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0value1\0two\0value2\0three\0value3\0", 35 }; gchar *schema_name; GHashTable *fields; const gchar *value; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, &schema_name); g_assert (rv == CKR_OK); g_assert_cmpuint (g_hash_table_size (fields), ==, 3); value = g_hash_table_lookup (fields, "one"); g_assert_cmpstr (value, ==, "value1"); value = g_hash_table_lookup (fields, "two"); g_assert_cmpstr (value, ==, "value2"); value = g_hash_table_lookup (fields, "three"); g_assert_cmpstr (value, ==, "value3"); g_assert (schema_name == NULL); g_hash_table_unref (fields); } static void test_parse_schema (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0value1\0two\0valu\0xdg:schema\0xxx\0", 35 }; gchar *schema_name; GHashTable *fields; const gchar *value; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, &schema_name); g_assert (rv == CKR_OK); g_assert_cmpuint (g_hash_table_size (fields), ==, 3); value = g_hash_table_lookup (fields, "one"); g_assert_cmpstr (value, ==, "value1"); value = g_hash_table_lookup (fields, "two"); g_assert_cmpstr (value, ==, "valu"); value = g_hash_table_lookup (fields, GKM_SECRET_FIELD_SCHEMA); g_assert_cmpstr (value, ==, "xxx"); g_assert_cmpstr (schema_name, ==, "xxx"); g_free (schema_name); g_hash_table_unref (fields); } static void test_parse_empty (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "", 0 }; GHashTable *fields; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, NULL); g_assert (rv == CKR_OK); g_assert_cmpuint (g_hash_table_size (fields), == , 0); g_hash_table_unref (fields); } static void test_parse_null_invalid (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, NULL, 5 }; GHashTable *fields; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, NULL); g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID); } static void test_parse_missing_value (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one", 3 }; GHashTable *fields; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, NULL); g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID); } static void test_parse_missing_terminator (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0value", 9 }; GHashTable *fields; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, NULL); g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID); } static void test_parse_not_utf8 (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0not\234utf8\0", 13 }; GHashTable *fields; CK_RV rv; rv = gkm_secret_fields_parse (&attr, &fields, NULL); g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID); } static void test_serialize (void) { gchar buffer[32]; CK_ATTRIBUTE attr = { CKA_G_FIELDS, buffer, 32 }; GHashTable *fields; CK_RV rv; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "one", "value1"); rv = gkm_secret_fields_serialize (&attr, fields, NULL); g_assert (rv == CKR_OK); g_assert (attr.ulValueLen == 11); g_assert (memcmp (buffer, "one\0value1\0", 11) == 0); g_hash_table_unref (fields); } static void test_serialize_schema (void) { gchar buffer[32]; CK_ATTRIBUTE attr = { CKA_G_FIELDS, buffer, 32 }; GHashTable *fields; CK_RV rv; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "one", "value1"); rv = gkm_secret_fields_serialize (&attr, fields, "xxx"); g_assert (rv == CKR_OK); g_assert_cmpint (attr.ulValueLen, ==, 26); g_assert (memcmp (buffer, "one\0value1\0xdg:schema\0xxx\0", 26) == 0); g_hash_table_unref (fields); } static void test_serialize_schema_already (void) { gchar buffer[32]; CK_ATTRIBUTE attr = { CKA_G_FIELDS, buffer, 32 }; GHashTable *fields; CK_RV rv; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, GKM_SECRET_FIELD_SCHEMA, "yyy"); rv = gkm_secret_fields_serialize (&attr, fields, "xxx"); g_assert (rv == CKR_OK); g_assert (attr.ulValueLen == 15); g_assert (memcmp (buffer, "xdg:schema\0yyy\0", 15) == 0); g_hash_table_unref (fields); } static void test_serialize_length (void) { CK_ATTRIBUTE attr = { CKA_G_FIELDS, NULL, 0 }; GHashTable *fields; CK_RV rv; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "one", "value1"); rv = gkm_secret_fields_serialize (&attr, fields, NULL); g_assert (rv == CKR_OK); g_assert (attr.ulValueLen == 11); g_hash_table_unref (fields); } static void test_add_get_compat_uint32 (void) { GHashTable *fields; gboolean ret; guint32 value; fields = gkm_secret_fields_new (); gkm_secret_fields_add_compat_uint32 (fields, "field", 992); ret = gkm_secret_fields_get_compat_uint32 (fields, "field", &value); g_assert (ret == TRUE); g_assert_cmpuint (value, ==, 992); g_hash_table_unref (fields); } static void test_get_compat_uint32_fail (void) { GHashTable *fields; gboolean ret; guint32 value; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "test", "value"); ret = gkm_secret_fields_get_compat_uint32 (fields, "test", &value); g_assert (ret == FALSE); g_hash_table_unref (fields); } static void test_get_compat_hashed_string (void) { GHashTable *fields; gboolean ret; gchar *value; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "test", "value"); ret = gkm_secret_fields_get_compat_hashed_string (fields, "test", &value); g_assert (ret == TRUE); /* Must be the same as the old gnome-keyring code */ g_assert_cmpstr (value, ==, "2063c1608d6e0baf80249c42e2be5804"); g_free (value); g_hash_table_unref (fields); } static void test_get_compat_hashed_already (void) { GHashTable *fields; gboolean ret; gchar *value; fields = gkm_secret_fields_new (); gkm_secret_fields_add_compat_hashed_string (fields, "test", "e991664529cd0caeb6e9fce8fac3d611"); ret = gkm_secret_fields_get_compat_hashed_string (fields, "test", &value); g_assert (ret == TRUE); /* What went in comes out */ g_assert_cmpstr (value, ==, "e991664529cd0caeb6e9fce8fac3d611"); g_free (value); g_hash_table_unref (fields); } static void test_get_compat_hashed_uint32 (void) { GHashTable *fields; gboolean ret; guint32 value; guint32 val = 992; fields = gkm_secret_fields_new (); gkm_secret_fields_add_compat_uint32 (fields, "test", val); ret = gkm_secret_fields_get_compat_hashed_uint32 (fields, "test", &value); g_assert (ret == TRUE); /* Must be the same as the old gnome-keyring code */ g_assert_cmpuint (value, ==, 0x18273645 ^ val ^ (val << 16 | val >> 16)); g_hash_table_unref (fields); } static void test_get_compat_hashed_uint32_already (void) { GHashTable *fields; gboolean ret; guint32 value; guint32 val = 0x1bc735a5; fields = gkm_secret_fields_new (); gkm_secret_fields_add_compat_hashed_uint32 (fields, "test", val); ret = gkm_secret_fields_get_compat_hashed_uint32 (fields, "test", &value); g_assert (ret == TRUE); /* What went in comes out */ g_assert_cmpuint (value, ==, val); g_hash_table_unref (fields); } static void test_get_names (void) { GHashTable *fields; GList *names, *l; fields = gkm_secret_fields_new (); gkm_secret_fields_add (fields, "one", "11111"); gkm_secret_fields_add_compat_uint32 (fields, "two", 2); gkm_secret_fields_add_compat_hashed_string (fields, "test", "2063c1608d6e0baf80249c42e2be5804"); names = gkm_secret_fields_get_names (fields); g_assert_cmpuint (g_list_length (names), ==, 3); for (l = names; l; l = g_list_next (l)) { g_assert (l->data); if (!g_str_equal (l->data, "one") && !g_str_equal (l->data, "two") && !g_str_equal (l->data, "test")) g_assert_not_reached (); } g_list_free (names); g_hash_table_unref (fields); } static void test_match (void) { GHashTable *haystack; GHashTable *needle; gboolean ret; haystack = gkm_secret_fields_new (); gkm_secret_fields_add (haystack, "one", "11111"); gkm_secret_fields_add_compat_uint32 (haystack, "two", 2); gkm_secret_fields_add_compat_hashed_string (haystack, "test", "2063c1608d6e0baf80249c42e2be5804"); /* Hashed 'value' */ gkm_secret_fields_add_compat_hashed_uint32 (haystack, "number", 0x1bc735a5); /* Hashed 992 */ gkm_secret_fields_add (haystack, "extra", "an extra value"); needle = gkm_secret_fields_new (); gkm_secret_fields_add (needle, "one", "11111"); gkm_secret_fields_add (needle, "two", "2"); gkm_secret_fields_add (needle, "test", "value"); gkm_secret_fields_add (needle, "number", "992"); ret = gkm_secret_fields_match (haystack, needle); g_assert (ret == TRUE); g_hash_table_unref (haystack); g_hash_table_unref (needle); } static void test_match_mismatch_value (void) { GHashTable *haystack; GHashTable *needle; gboolean ret; haystack = gkm_secret_fields_new (); gkm_secret_fields_add (haystack, "field", "value"); needle = gkm_secret_fields_new (); gkm_secret_fields_add (needle, "field", "another"); ret = gkm_secret_fields_match (haystack, needle); g_assert (ret == FALSE); g_hash_table_unref (haystack); g_hash_table_unref (needle); } static void test_match_mismatch_field (void) { GHashTable *haystack; GHashTable *needle; gboolean ret; haystack = gkm_secret_fields_new (); gkm_secret_fields_add (haystack, "test", "value"); needle = gkm_secret_fields_new (); gkm_secret_fields_add (needle, "field", "value"); ret = gkm_secret_fields_match (haystack, needle); g_assert (ret == FALSE); g_hash_table_unref (haystack); g_hash_table_unref (needle); } static void test_match_wrong_hashed (void) { GHashTable *haystack; GHashTable *needle; gboolean ret; haystack = gkm_secret_fields_new (); gkm_secret_fields_add_compat_hashed_uint32 (haystack, "number", 0x1bc735a5); /* Hashed 992 */ needle = gkm_secret_fields_new (); gkm_secret_fields_add (needle, "number", "1000"); ret = gkm_secret_fields_match (haystack, needle); g_assert (ret == FALSE); g_hash_table_unref (haystack); g_hash_table_unref (needle); } int main (int argc, char **argv) { #if !GLIB_CHECK_VERSION(2,35,0) g_type_init (); #endif g_test_init (&argc, &argv, NULL); g_test_add_func ("/secret-store/fields/new", test_new); g_test_add_func ("/secret-store/fields/boxed", test_boxed); g_test_add_func ("/secret-store/fields/add_get_values", test_add_get_values); g_test_add_func ("/secret-store/fields/parse", test_parse); g_test_add_func ("/secret-store/fields/parse_schema", test_parse_schema); g_test_add_func ("/secret-store/fields/parse_empty", test_parse_empty); g_test_add_func ("/secret-store/fields/parse_null_invalid", test_parse_null_invalid); g_test_add_func ("/secret-store/fields/parse_missing_value", test_parse_missing_value); g_test_add_func ("/secret-store/fields/parse_missing_terminator", test_parse_missing_terminator); g_test_add_func ("/secret-store/fields/parse_not_utf8", test_parse_not_utf8); g_test_add_func ("/secret-store/fields/serialize", test_serialize); g_test_add_func ("/secret-store/fields/serialize_schema", test_serialize_schema); g_test_add_func ("/secret-store/fields/serialize_schema_already", test_serialize_schema_already); g_test_add_func ("/secret-store/fields/serialize_length", test_serialize_length); g_test_add_func ("/secret-store/fields/add_get_compat_uint32", test_add_get_compat_uint32); g_test_add_func ("/secret-store/fields/get_compat_uint32_fail", test_get_compat_uint32_fail); g_test_add_func ("/secret-store/fields/get_compat_hashed_string", test_get_compat_hashed_string); g_test_add_func ("/secret-store/fields/get_compat_hashed_already", test_get_compat_hashed_already); g_test_add_func ("/secret-store/fields/get_compat_hashed_uint32", test_get_compat_hashed_uint32); g_test_add_func ("/secret-store/fields/get_compat_hashed_uint32_already", test_get_compat_hashed_uint32_already); g_test_add_func ("/secret-store/fields/get_names", test_get_names); g_test_add_func ("/secret-store/fields/match", test_match); g_test_add_func ("/secret-store/fields/match_mismatch_value", test_match_mismatch_value); g_test_add_func ("/secret-store/fields/match_mismatch_field", test_match_mismatch_field); g_test_add_func ("/secret-store/fields/match_wrong_hashed", test_match_wrong_hashed); return g_test_run (); }