/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* unit-test-memory-test->store.c: Test memory test->store functionality
Copyright (C) 2008 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
#include
#include
#include
#include "mock-module.h"
#include "egg/egg-secure-memory.h"
#include "gkm/gkm-object.h"
#include "gkm/gkm-memory-store.h"
#include "gkm/gkm-transaction.h"
typedef struct {
GkmModule *module;
GkmStore *store;
GkmObject *object;
GkmTransaction *transaction;
guchar buffer[1024];
} Test;
static CK_RV
check_validator (GkmObject *obj, CK_ATTRIBUTE_PTR attr)
{
const gchar *data;
guint i;
g_assert (attr);
g_assert (attr->type == CKA_LABEL);
/* Test that the whole string is ascii and lower case */
data = attr->pValue;
for (i = 0; i < attr->ulValueLen; ++i) {
if (!g_ascii_isprint(data[i]) || !g_ascii_islower (data[i]))
return CKR_ATTRIBUTE_VALUE_INVALID;
}
return CKR_OK;
}
static void
setup (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_ULONG twentyfour = 24;
test->module = mock_module_initialize_and_enter ();
attr.type = CKA_LABEL;
attr.pValue = "label";
attr.ulValueLen = 5;
test->store = GKM_STORE (gkm_memory_store_new ());
gkm_store_register_schema (test->store, &attr, check_validator, 0);
g_assert (gkm_store_lookup_schema (test->store, CKA_LABEL, NULL));
attr.type = CKA_VALUE;
attr.pValue = NULL;
attr.ulValueLen = 0;
gkm_store_register_schema (test->store, &attr, NULL, GKM_STORE_IS_SENSITIVE);
attr.type = CKA_BITS_PER_PIXEL;
attr.pValue = &twentyfour;
attr.ulValueLen = sizeof (twentyfour);
gkm_store_register_schema (test->store, &attr, NULL, GKM_STORE_IS_INTERNAL);
test->object = g_object_new (GKM_TYPE_OBJECT, "module", test->module, NULL);
test->transaction = gkm_transaction_new ();
}
static void
teardown (Test *test, gconstpointer unused)
{
g_object_unref (test->store);
test->store = NULL;
g_object_unref (test->transaction);
test->transaction = NULL;
if (test->object != NULL)
g_object_unref (test->object);
test->object = NULL;
mock_module_leave_and_finalize ();
test->module = NULL;
}
static void
test_get_attribute_default (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_RV rv;
attr.type = CKA_LABEL;
attr.pValue = NULL;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_OK);
g_assert (attr.ulValueLen == 5);
attr.pValue = test->buffer;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_OK);
g_assert (attr.ulValueLen == 5);
g_assert (memcmp (attr.pValue, "label", 5) == 0);
}
static void
test_read_value_default (Test *test, gconstpointer unused)
{
gconstpointer value;
gsize n_value;
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value);
g_assert (n_value == 5);
g_assert (memcmp (value, "label", 5) == 0);
value = gkm_store_read_value (test->store, test->object, CKA_BITS_PER_PIXEL, &n_value);
g_assert (value);
g_assert (n_value == sizeof (CK_ULONG));
g_assert (*((CK_ULONG_PTR)value) == 24);
}
static void
test_read_string (Test *test, gconstpointer unused)
{
gchar *str;
str = gkm_store_read_string (test->store, test->object, CKA_LABEL);
g_assert_cmpstr (str, ==, "label");
g_free (str);
}
static void
test_get_invalid (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_RV rv;
attr.type = CKA_APPLICATION;
attr.pValue = NULL;
attr.ulValueLen = 0;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_ATTRIBUTE_TYPE_INVALID);
}
static void
test_get_sensitive (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_RV rv;
attr.type = CKA_VALUE;
attr.pValue = NULL;
attr.ulValueLen = 0;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_ATTRIBUTE_SENSITIVE);
}
static void
test_get_internal (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_RV rv;
attr.type = CKA_BITS_PER_PIXEL;
attr.pValue = NULL;
attr.ulValueLen = 0;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_ATTRIBUTE_TYPE_INVALID);
}
static void
test_set_invalid (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
attr.type = CKA_APPLICATION;
attr.pValue = "me";
attr.ulValueLen = 2;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_ATTRIBUTE_TYPE_INVALID);
}
static void
test_set_internal (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_ULONG five = 5;
attr.type = CKA_BITS_PER_PIXEL;
attr.pValue = &five;
attr.ulValueLen = sizeof (five);
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_ATTRIBUTE_TYPE_INVALID);
}
static void
test_set_get_attribute (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_RV rv;
attr.type = CKA_LABEL;
attr.pValue = "booyah";
attr.ulValueLen = 6;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_OK);
attr.pValue = test->buffer;
attr.ulValueLen = 1024;
rv = gkm_store_get_attribute (test->store, test->object, &attr);
g_assert (rv == CKR_OK);
g_assert (attr.ulValueLen == 6);
g_assert (memcmp (attr.pValue, "booyah", 6) == 0);
}
static void
test_write_read_value (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_ULONG five = 5;
gconstpointer value;
gsize n_value;
attr.type = CKA_BITS_PER_PIXEL;
attr.pValue = &five;
attr.ulValueLen = sizeof (five);
gkm_store_write_value (test->store, test->transaction, test->object, &attr);
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_OK);
value = gkm_store_read_value (test->store, test->object, CKA_BITS_PER_PIXEL, &n_value);
g_assert (value);
g_assert (n_value == sizeof (five));
g_assert (memcmp (value, &five, sizeof (five)) == 0);
}
static void
test_set_no_validate (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
attr.type = CKA_LABEL;
attr.pValue = "CAPITALS";
attr.ulValueLen = 8;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_failed (test->transaction));
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_ATTRIBUTE_VALUE_INVALID);
}
static void
test_set_transaction_default (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
gconstpointer value;
gsize n_value;
attr.type = CKA_LABEL;
attr.pValue = "another";
attr.ulValueLen = 7;
/* Change the attribute */
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_failed (test->transaction) == FALSE);
/* Should get new value */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == attr.ulValueLen);
g_assert (memcmp (attr.pValue, value, n_value) == 0);
/* Fail for some arbitrary reason */
gkm_transaction_fail (test->transaction, CKR_ATTRIBUTE_VALUE_INVALID);
/* Value should not have changed yet */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == attr.ulValueLen);
g_assert (memcmp (attr.pValue, value, n_value) == 0);
/* Now complete the test->transaction */
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_failed (test->transaction) == TRUE);
/* Value should now have changed, back to default */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == 5);
g_assert (memcmp (value, "label", 5) == 0);
}
static void
test_set_transaction_revert_first (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr, prev;
gconstpointer value;
gsize n_value;
prev.type = CKA_LABEL;
prev.pValue = "numberone";
prev.ulValueLen = 9;
/* Change the attribute */
gkm_store_set_attribute (test->store, test->transaction, test->object, &prev);
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_failed (test->transaction) == FALSE);
/* Value should be new value */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == prev.ulValueLen);
g_assert (memcmp (prev.pValue, value, n_value) == 0);
/* A new test->transaction */
g_object_unref (test->transaction);
test->transaction = gkm_transaction_new ();
attr.type = CKA_LABEL;
attr.pValue = "second";
attr.ulValueLen = 6;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_failed (test->transaction) == FALSE);
/* Should get new value */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == attr.ulValueLen);
g_assert (memcmp (attr.pValue, value, n_value) == 0);
attr.type = CKA_LABEL;
attr.pValue = "third";
attr.ulValueLen = 5;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
g_assert (gkm_transaction_get_failed (test->transaction) == FALSE);
/* Should get new value */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == attr.ulValueLen);
g_assert (memcmp (attr.pValue, value, n_value) == 0);
/* Fail for some arbitrary reason */
gkm_transaction_fail (test->transaction, CKR_ATTRIBUTE_VALUE_INVALID);
/* Value should not have changed yet */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == attr.ulValueLen);
g_assert (memcmp (attr.pValue, value, n_value) == 0);
/* Now complete the test->transaction */
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_failed (test->transaction) == TRUE);
/* Value should now have changed, back to default */
value = gkm_store_read_value (test->store, test->object, CKA_LABEL, &n_value);
g_assert (value && n_value == prev.ulValueLen);
g_assert (memcmp (prev.pValue, value, n_value) == 0);
}
static void
notify_attribute (GkmObject *obj, CK_ATTRIBUTE_TYPE type, gpointer data)
{
g_assert (type == CKA_LABEL);
g_assert (data);
*((CK_ATTRIBUTE_TYPE*)data) = type;
}
static void
test_set_notifies (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
CK_ATTRIBUTE_TYPE type = 0;
attr.type = CKA_LABEL;
attr.pValue = "valid";
attr.ulValueLen = 5;
g_signal_connect (test->object, "notify-attribute", G_CALLBACK (notify_attribute), &type);
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
/* We should have been notified that the attribute changed at this point */
g_assert (type == CKA_LABEL);
/* Reset for next notify */
type = 0;
/* Fail for some arbitrary reason */
gkm_transaction_fail (test->transaction, CKR_ATTRIBUTE_VALUE_INVALID);
/* We should not have been notified yet */
g_assert (type == 0);
/* Now complete the test->transaction */
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_failed (test->transaction) == TRUE);
/* Now we should have been notified that this changed back */
g_assert (type == CKA_LABEL);
}
static void
test_set_object_gone_first (Test *test, gconstpointer unused)
{
CK_ATTRIBUTE attr;
attr.type = CKA_LABEL;
attr.pValue = "valid";
attr.ulValueLen = 5;
gkm_store_set_attribute (test->store, test->transaction, test->object, &attr);
gkm_transaction_complete (test->transaction);
g_assert (gkm_transaction_get_result (test->transaction) == CKR_OK);
/* This tests memory test->store internal tracking */
g_object_unref (test->object);
test->object = NULL;
}
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 ("/gkm/memory-test->store/get_attribute_default", Test, NULL, setup, test_get_attribute_default, teardown);
g_test_add ("/gkm/memory-test->store/read_value_default", Test, NULL, setup, test_read_value_default, teardown);
g_test_add ("/gkm/memory-test->store/read_string", Test, NULL, setup, test_read_string, teardown);
g_test_add ("/gkm/memory-test->store/get_invalid", Test, NULL, setup, test_get_invalid, teardown);
g_test_add ("/gkm/memory-test->store/get_sensitive", Test, NULL, setup, test_get_sensitive, teardown);
g_test_add ("/gkm/memory-test->store/get_internal", Test, NULL, setup, test_get_internal, teardown);
g_test_add ("/gkm/memory-test->store/set_invalid", Test, NULL, setup, test_set_invalid, teardown);
g_test_add ("/gkm/memory-test->store/set_internal", Test, NULL, setup, test_set_internal, teardown);
g_test_add ("/gkm/memory-test->store/set_get_attribute", Test, NULL, setup, test_set_get_attribute, teardown);
g_test_add ("/gkm/memory-test->store/write_read_value", Test, NULL, setup, test_write_read_value, teardown);
g_test_add ("/gkm/memory-test->store/set_no_validate", Test, NULL, setup, test_set_no_validate, teardown);
g_test_add ("/gkm/memory-test->store/set_transaction_default", Test, NULL, setup, test_set_transaction_default, teardown);
g_test_add ("/gkm/memory-test->store/set_transaction_revert_first", Test, NULL, setup, test_set_transaction_revert_first, teardown);
g_test_add ("/gkm/memory-test->store/set_notifies", Test, NULL, setup, test_set_notifies, teardown);
g_test_add ("/gkm/memory-test->store/set_object_gone_first", Test, NULL, setup, test_set_object_gone_first, teardown);
return g_test_run ();
}