/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* test-secret-test->collection.c: Test the test->collection keyring
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 "mock-secret-module.h"
#include "secret-store/gkm-secret-data.h"
#include "secret-store/gkm-secret-collection.h"
#include "secret-store/gkm-secret-item.h"
#include "gkm/gkm-credential.h"
#include "gkm/gkm-session.h"
#include "gkm/gkm-transaction.h"
#include "pkcs11/pkcs11i.h"
#include
#include
#include
#include
typedef struct {
GkmModule *module;
GkmSession *session;
CK_OBJECT_HANDLE credential;
CK_OBJECT_HANDLE credential2;
GkmSecretCollection *collection;
} Test;
static void
setup (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_CREDENTIAL;
GkmObject *cred;
CK_ATTRIBUTE attrs[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_VALUE, NULL, 0 }
};
test->module = test_secret_module_initialize_and_enter ();
test->session = test_secret_module_open_session (TRUE);
test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
"module", test->module,
"identifier", "test",
NULL);
g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
/* Make two credentials */
cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (cred != NULL);
test->credential = gkm_object_get_handle (GKM_OBJECT (cred));
g_object_unref (cred);
cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (cred != NULL);
test->credential2 = gkm_object_get_handle (GKM_OBJECT (cred));
g_object_unref (cred);
}
static void
teardown (Test *test, gconstpointer unused)
{
if (test->collection)
g_object_unref (test->collection);
test->collection = NULL;
test_secret_module_leave_and_finalize ();
test->module = NULL;
test->session = NULL;
test->credential = 0;
}
static void
test_is_locked (Test *test, gconstpointer unused)
{
gboolean locked;
/* By default is locked */
locked = gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session);
g_assert (locked == TRUE);
}
static void
test_unlocked_data (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
CK_RV rv;
/* Create test->credential, which unlocks test->collection */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
/* Collection should now be unlocked */
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (GKM_IS_SECRET_DATA (sdata));
g_assert (!gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session));
g_object_unref (sdata);
}
static void
test_get_filename (Test *test, gconstpointer unused)
{
GkmSecretCollection *other;
const gchar *filename;
other = g_object_new (GKM_TYPE_SECRET_COLLECTION,
"module", test->module,
"identifier", "test",
"filename", "/tmp/filename.keyring",
NULL);
filename = gkm_secret_collection_get_filename (other);
g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
g_object_unref (other);
}
static void
test_set_filename (Test *test, gconstpointer unused)
{
const gchar *filename;
gkm_secret_collection_set_filename (test->collection, "/tmp/filename.keyring");
filename = gkm_secret_collection_get_filename (test->collection);
g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
}
static void
test_has_item (Test *test, gconstpointer unused)
{
GkmSecretItem *item;
item = gkm_secret_collection_new_item (test->collection, "testo");
g_assert (gkm_secret_collection_has_item (test->collection, item));
}
static void
test_load_unlock_plain (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
GkmDataResult res;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/plain.keyring");
/* Load the data in the file */
res = gkm_secret_collection_load (test->collection);
g_assert (res == GKM_DATA_SUCCESS);
/* Unlock the keyring, which should load again */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
test_secret_collection_validate (test->collection, sdata);
g_object_unref (sdata);
}
static void
test_load_unlock_encrypted (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
GkmDataResult res;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
/* Load the data in the file */
res = gkm_secret_collection_load (test->collection);
g_assert (res == GKM_DATA_SUCCESS);
/* Unlock the keyring, which should load again */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"my-keyring-password", 19, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
test_secret_collection_validate (test->collection, sdata);
g_object_unref (sdata);
}
static void
test_load_unlock_bad_password (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmDataResult res;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
/* Load the data in the file */
res = gkm_secret_collection_load (test->collection);
g_assert (res == GKM_DATA_SUCCESS);
/* Unlock the keyring, which should load again */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"wrong", 5, &cred);
g_assert (rv == CKR_PIN_INCORRECT);
}
static void
test_unlock_without_load (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
/* Unlock the keyring, which should load it */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"my-keyring-password", 19, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
test_secret_collection_validate (test->collection, sdata);
g_object_unref (sdata);
}
static void
test_twice_unlock (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
/* Unlock the keyring, which should load */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"my-keyring-password", 19, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
/* Unlock the keyring again, which should not reload */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"my-keyring-password", 19, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
test_secret_collection_validate (test->collection, sdata);
g_object_unref (sdata);
}
static void
test_twice_unlock_bad_password (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmSecretData *sdata;
CK_RV rv;
gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
/* Unlock the keyring, which should load */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"my-keyring-password", 19, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
/* Unlock the keyring again, wrong password */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"wrong", 5, &cred);
g_assert (rv == CKR_PIN_INCORRECT);
sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
test_secret_collection_validate (test->collection, sdata);
g_object_unref (sdata);
}
static void
test_memory_unlock (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmDataResult res;
CK_RV rv;
/* Load the data in the file */
res = gkm_secret_collection_load (test->collection);
g_assert (res == GKM_DATA_SUCCESS);
/* Unlock the keyring, which should load again */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
NULL, 0, &cred);
g_assert (rv == CKR_OK);
gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
g_object_unref (cred);
}
static void
test_memory_unlock_bad_password (Test *test, gconstpointer unused)
{
GkmCredential *cred;
GkmDataResult res;
CK_RV rv;
/* Load the data in the file */
res = gkm_secret_collection_load (test->collection);
g_assert (res == GKM_DATA_SUCCESS);
/* Unlock the keyring, which should load again */
rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
(guchar*)"wrong", 5, &cred);
g_assert (rv == CKR_PIN_INCORRECT);
}
static void
test_factory (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
GkmObject *object;
CK_ATTRIBUTE attrs[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_LABEL, "blah", 4 },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
g_assert_cmpstr (gkm_secret_object_get_label (GKM_SECRET_OBJECT (object)), ==, "blah");
g_object_unref (object);
}
static void
test_factory_unnamed (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
const gchar *identifier;
GkmObject *object;
CK_ATTRIBUTE attrs[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_assert_cmpstr (identifier, !=, "");
g_object_unref (object);
}
static void
test_factory_token (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
const gchar *identifier;
GkmObject *object;
CK_BBOOL token = CK_TRUE;
CK_ATTRIBUTE attrs[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "blah", 4 },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_assert (strstr (identifier, "blah"));
g_object_unref (object);
}
static void
test_factory_duplicate (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
const gchar *identifier1, *identifier2;
GkmObject *object;
CK_ATTRIBUTE attrs[] = {
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_LABEL, "blah", 4 },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier1 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_assert (strstr (identifier1, "blah"));
g_object_unref (object);
/* Use second test->credential for second object */
attrs[0].pValue = &test->credential2;
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier2 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_assert (strstr (identifier2, "blah"));
g_object_unref (object);
g_assert_cmpstr (identifier1, !=, identifier2);
}
static void
test_factory_item (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
const gchar *identifier;
GkmObject *object;
CK_BBOOL token = CK_TRUE;
CK_ATTRIBUTE c_attrs[] = {
{ CKA_CLASS, &c_klass, sizeof (c_klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "three", 5 },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
CK_ATTRIBUTE i_attrs[] = {
{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
{ CKA_CLASS, &i_klass, sizeof (i_klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "Item", 4 },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
c_attrs, G_N_ELEMENTS (c_attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_object_unref (object);
i_attrs[0].pValue = (gpointer)identifier;
i_attrs[0].ulValueLen = strlen (identifier);
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
i_attrs, G_N_ELEMENTS (i_attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_ITEM (object));
g_object_unref (object);
}
static void
test_token_remove (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
GkmTransaction *transaction;
GkmObject *object;
CK_BBOOL token = CK_TRUE;
CK_ATTRIBUTE attrs[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "blah", 4 },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
attrs, G_N_ELEMENTS (attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
transaction = gkm_transaction_new ();
gkm_module_remove_token_object (test->module, transaction, object);
g_assert (!gkm_transaction_get_failed (transaction));
gkm_transaction_complete (transaction);
g_object_unref (transaction);
g_object_unref (object);
}
static void
test_token_item_remove (Test *test, gconstpointer unused)
{
CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
GkmTransaction *transaction;
const gchar *identifier;
GkmObject *object;
CK_BBOOL token = CK_TRUE;
CK_ATTRIBUTE c_attrs[] = {
{ CKA_CLASS, &c_klass, sizeof (c_klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "three", 5 },
{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
};
CK_ATTRIBUTE i_attrs[] = {
{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
{ CKA_CLASS, &i_klass, sizeof (i_klass) },
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_LABEL, "Item", 4 },
};
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
c_attrs, G_N_ELEMENTS (c_attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_COLLECTION (object));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
g_object_unref (object);
i_attrs[0].pValue = (gpointer)identifier;
i_attrs[0].ulValueLen = strlen (identifier);
object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
i_attrs, G_N_ELEMENTS (i_attrs));
g_assert (object != NULL);
g_assert (GKM_IS_SECRET_ITEM (object));
transaction = gkm_transaction_new ();
gkm_module_remove_token_object (test->module, transaction, object);
g_assert (!gkm_transaction_get_failed (transaction));
gkm_transaction_complete (transaction);
g_object_unref (transaction);
g_object_unref (object);
}
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 ("/secret-store/collection/is_locked", Test, NULL, setup, test_is_locked, teardown);
g_test_add ("/secret-store/collection/unlocked_data", Test, NULL, setup, test_unlocked_data, teardown);
g_test_add ("/secret-store/collection/get_filename", Test, NULL, setup, test_get_filename, teardown);
g_test_add ("/secret-store/collection/set_filename", Test, NULL, setup, test_set_filename, teardown);
g_test_add ("/secret-store/collection/has_item", Test, NULL, setup, test_has_item, teardown);
g_test_add ("/secret-store/collection/load_unlock_plain", Test, NULL, setup, test_load_unlock_plain, teardown);
g_test_add ("/secret-store/collection/load_unlock_encrypted", Test, NULL, setup, test_load_unlock_encrypted, teardown);
g_test_add ("/secret-store/collection/load_unlock_bad_password", Test, NULL, setup, test_load_unlock_bad_password, teardown);
g_test_add ("/secret-store/collection/unlock_without_load", Test, NULL, setup, test_unlock_without_load, teardown);
g_test_add ("/secret-store/collection/twice_unlock", Test, NULL, setup, test_twice_unlock, teardown);
g_test_add ("/secret-store/collection/twice_unlock_bad_password", Test, NULL, setup, test_twice_unlock_bad_password, teardown);
g_test_add ("/secret-store/collection/memory_unlock", Test, NULL, setup, test_memory_unlock, teardown);
g_test_add ("/secret-store/collection/memory_unlock_bad_password", Test, NULL, setup, test_memory_unlock_bad_password, teardown);
g_test_add ("/secret-store/collection/factory", Test, NULL, setup, test_factory, teardown);
g_test_add ("/secret-store/collection/factory_unnamed", Test, NULL, setup, test_factory_unnamed, teardown);
g_test_add ("/secret-store/collection/factory_token", Test, NULL, setup, test_factory_token, teardown);
g_test_add ("/secret-store/collection/factory_duplicate", Test, NULL, setup, test_factory_duplicate, teardown);
g_test_add ("/secret-store/collection/factory_item", Test, NULL, setup, test_factory_item, teardown);
g_test_add ("/secret-store/collection/token_remove", Test, NULL, setup, test_token_remove, teardown);
g_test_add ("/secret-store/collection/token_item_remove", Test, NULL, setup, test_token_item_remove, teardown);
return g_test_run ();
}