/*
* gnome-keyring
*
* Copyright (C) 2010 Stefan Walter
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This program 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see
* .
*/
#include "config.h"
#include "gkm-xdg-assertion.h"
#include "gkm-xdg-module.h"
#include "gkm-xdg-store.h"
#include "gkm-xdg-trust.h"
#include "egg/egg-asn1x.h"
#include "egg/egg-asn1-defs.h"
#include "egg/egg-dn.h"
#include "egg/egg-error.h"
#include "egg/egg-file-tracker.h"
#include "egg/egg-hex.h"
#include "gkm/gkm-assertion.h"
#include "gkm/gkm-certificate.h"
#define DEBUG_FLAG GKM_DEBUG_STORAGE
#include "gkm/gkm-debug.h"
#include "gkm/gkm-serializable.h"
#include "gkm/gkm-transaction.h"
#include "gkm/gkm-util.h"
#include "pkcs11x.h"
#include
struct _GkmXdgModule {
GkmModule parent;
gchar *directory;
GHashTable *objects_by_path;
EggFileTracker *tracker;
CK_TOKEN_INFO token_info;
};
static const CK_SLOT_INFO user_module_slot_info = {
"User Key Storage",
"Gnome Keyring",
CKF_TOKEN_PRESENT,
{ 0, 0 },
{ 0, 0 }
};
static const CK_TOKEN_INFO user_module_token_info = {
"User Key Storage",
"Gnome Keyring",
"1.0",
"1:XDG:DEFAULT", /* Unique serial number for manufacturer */
CKF_TOKEN_INITIALIZED,
CK_EFFECTIVELY_INFINITE,
CK_EFFECTIVELY_INFINITE,
CK_EFFECTIVELY_INFINITE,
CK_EFFECTIVELY_INFINITE,
1024,
1,
CK_UNAVAILABLE_INFORMATION,
CK_UNAVAILABLE_INFORMATION,
CK_UNAVAILABLE_INFORMATION,
CK_UNAVAILABLE_INFORMATION,
{ 0, 0 },
{ 0, 0 },
""
};
#define UNUSED_VALUE (GUINT_TO_POINTER (1))
#define UNWANTED_FILENAME_CHARS ":/\\<>|\t\n\r\v "
G_DEFINE_TYPE (GkmXdgModule, gkm_xdg_module, GKM_TYPE_MODULE);
GkmModule* _gkm_xdg_store_get_module_for_testing (void);
/* Forward declarations */
static void remove_object_from_module (GkmXdgModule *self, GkmObject *object,
const gchar *filename, GkmTransaction *transaction);
static void add_object_to_module (GkmXdgModule *self, GkmObject *object,
const gchar *filename, GkmTransaction *transaction);
/* -----------------------------------------------------------------------------
* ACTUAL PKCS#11 Module Implementation
*/
/* Include all the module entry points */
#include "gkm/gkm-module-ep.h"
GKM_DEFINE_MODULE (gkm_xdg_module, GKM_TYPE_XDG_MODULE);
/* -----------------------------------------------------------------------------
* INTERNAL
*/
static GType
type_from_path (const gchar *path)
{
const gchar *ext;
ext = strrchr (path, '.');
/* The file tracker doesn't match files without exts */
g_return_val_if_fail (ext, 0);
if (g_str_equal (ext, ".trust"))
return GKM_XDG_TYPE_TRUST;
else if (strcmp (ext, ".cer") == 0)
return GKM_TYPE_CERTIFICATE;
return 0;
}
static const gchar*
lookup_filename_for_object (GkmObject *object)
{
return g_object_get_data (G_OBJECT (object), "xdg-module-filename");
}
static gboolean
complete_add_object (GkmTransaction *transaction, GObject *module, gpointer user_data)
{
GkmXdgModule *self = GKM_XDG_MODULE (module);
GkmObject *object = GKM_OBJECT (user_data);
const gchar *filename;
/* If the transaction failed, revert it */
if (gkm_transaction_get_failed (transaction)) {
filename = g_object_get_data (G_OBJECT (object), "xdg-module-filename");
g_return_val_if_fail (filename, FALSE);
remove_object_from_module (self, object, filename, NULL);
}
g_object_unref (object);
return TRUE;
}
static void
add_object_to_module (GkmXdgModule *self, GkmObject *object,
const gchar *filename, GkmTransaction *transaction)
{
g_assert (!g_hash_table_lookup (self->objects_by_path, filename));
g_hash_table_insert (self->objects_by_path, g_strdup (filename), g_object_ref (object));
g_assert (!lookup_filename_for_object (object));
g_object_set_data_full (G_OBJECT (object), "xdg-module-filename",
g_strdup (filename), g_free);
gkm_object_expose (object, TRUE);
if (transaction != NULL)
gkm_transaction_add (transaction, self, complete_add_object, g_object_ref (object));
}
static gboolean
complete_remove_object (GkmTransaction *transaction, GObject *module, gpointer user_data)
{
GkmXdgModule *self = GKM_XDG_MODULE (module);
GkmObject *object = GKM_OBJECT (user_data);
const gchar *filename;
/* If the transaction failed, revert it */
if (gkm_transaction_get_failed (transaction)) {
filename = g_object_get_data (G_OBJECT (object), "xdg-module-filename");
g_return_val_if_fail (filename, FALSE);
add_object_to_module (self, object, filename, NULL);
}
g_object_unref (object);
return TRUE;
}
static void
remove_object_from_module (GkmXdgModule *self, GkmObject *object,
const gchar *filename, GkmTransaction *transaction)
{
gkm_object_expose (object, FALSE);
if (transaction != NULL)
gkm_transaction_add (transaction, self, complete_remove_object, g_object_ref (object));
g_assert (g_hash_table_lookup (self->objects_by_path, filename) == object);
g_hash_table_remove (self->objects_by_path, filename);
}
static void
file_load (EggFileTracker *tracker,
const gchar *path,
GkmXdgModule *self)
{
GkmObject *object;
GkmManager *manager;
gboolean added = FALSE;
GError *error = NULL;
GBytes *bytes;
GType type;
guchar *data;
gsize n_data;
g_return_if_fail (path);
g_return_if_fail (GKM_IS_XDG_MODULE (self));
manager = gkm_module_get_manager (GKM_MODULE (self));
/* Already have this object? */
object = g_hash_table_lookup (self->objects_by_path, path);
if (object == NULL) {
/* Figure out what type of object we're dealing with */
type = type_from_path (path);
if (type == 0) {
gkm_debug ("don't know how to load file in key store: %s", path);
return;
}
/* Create a new object for this identifier */
object = g_object_new (type,
"module", GKM_MODULE (self),
"manager", manager, NULL);
g_return_if_fail (GKM_IS_SERIALIZABLE (object));
g_return_if_fail (GKM_SERIALIZABLE_GET_INTERFACE (object)->extension);
added = TRUE;
} else {
g_object_ref (object);
}
/* Read the file in */
if (!g_file_get_contents (path, (gchar**)&data, &n_data, &error)) {
g_warning ("couldn't read file in key store: %s: %s", path,
egg_error_message (error));
g_object_unref (object);
g_clear_error (&error);
return;
}
bytes = g_bytes_new_take (data, n_data);
/* And load the data into it */
if (gkm_serializable_load (GKM_SERIALIZABLE (object), NULL, bytes)) {
if (added)
add_object_to_module (self, object, path, NULL);
gkm_object_expose (object, TRUE);
} else {
g_message ("failed to load file in user store: %s", path);
if (!added) {
gkm_object_expose (object, FALSE);
remove_object_from_module (self, object, path, NULL);
}
}
g_bytes_unref (bytes);
g_object_unref (object);
}
static void
file_remove (EggFileTracker *tracker,
const gchar *path,
GkmXdgModule *self)
{
GkmObject *object;
g_return_if_fail (path);
g_return_if_fail (GKM_IS_XDG_MODULE (self));
object = g_hash_table_lookup (self->objects_by_path, path);
if (object != NULL)
remove_object_from_module (self, object, path, NULL);
}
static gchar*
name_for_subject (gconstpointer data,
gsize n_data)
{
GBytes *subject;
GNode *asn;
gchar *name;
g_assert (data != NULL);
subject = g_bytes_new (data, n_data);
asn = egg_asn1x_create_and_decode (pkix_asn1_tab, "Name", subject);
g_return_val_if_fail (asn != NULL, NULL);
g_bytes_unref (subject);
name = egg_dn_read_part (egg_asn1x_node (asn, "rdnSequence", NULL), "CN");
egg_asn1x_destroy (asn);
return name;
}
static gchar*
guess_basename_for_object (GkmObject *object)
{
GkmSerializableIface *serial;
const gchar *ext;
gchar *filename;
gchar *name = NULL;
guchar *data;
gsize n_data;
g_assert (GKM_IS_OBJECT (object));
g_assert (GKM_IS_SERIALIZABLE (object));
/* Figure out the extension and prefix */
serial = GKM_SERIALIZABLE_GET_INTERFACE (object);
ext = serial->extension;
g_return_val_if_fail (ext, NULL);
/* First we try to use the CN of a subject */
data = gkm_object_get_attribute_data (object, NULL, CKA_SUBJECT, &n_data);
if (data && n_data)
name = name_for_subject (data, n_data);
g_free (data);
/* Next we try and see if it has a peer (is a trust assertion) */
if (name == NULL) {
data = gkm_object_get_attribute_data (object, NULL, CKA_X_PEER, &n_data);
if (data && n_data)
name = g_strndup ((gchar *)data, n_data);
g_free (data);
}
/* Next we try hex encoding the ID */
if (name == NULL) {
data = gkm_object_get_attribute_data (object, NULL, CKA_ID, &n_data);
if (data && n_data)
name = egg_hex_encode (data, n_data);
g_free (data);
}
if (name == NULL)
name = g_strdup_printf ("object-%08x", ABS (g_random_int ()));
/* Build up the identifier */
filename = g_strconcat (name, ext, NULL);
g_strdelimit (filename, UNWANTED_FILENAME_CHARS, '_');
g_free (name);
return filename;
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static const CK_SLOT_INFO*
gkm_xdg_module_real_get_slot_info (GkmModule *base)
{
return &user_module_slot_info;
}
static const CK_TOKEN_INFO*
gkm_xdg_module_real_get_token_info (GkmModule *base)
{
GkmXdgModule *self = GKM_XDG_MODULE (base);
/* TODO: Update the info with current info */
return &self->token_info;
}
static void
gkm_xdg_module_real_parse_argument (GkmModule *base, const gchar *name, const gchar *value)
{
GkmXdgModule *self = GKM_XDG_MODULE (base);
if (g_str_equal (name, "directory")) {
g_free (self->directory);
self->directory = g_strdup (value);
}
}
static CK_RV
gkm_xdg_module_real_refresh_token (GkmModule *base)
{
GkmXdgModule *self = GKM_XDG_MODULE (base);
egg_file_tracker_refresh (self->tracker, FALSE);
return CKR_OK;
}
static void
gkm_xdg_module_real_add_token_object (GkmModule *module, GkmTransaction *transaction,
GkmObject *object)
{
gchar *filename = NULL;
GkmXdgModule *self;
GkmTrust *trust;
gchar *basename;
gchar *actual;
self = GKM_XDG_MODULE (module);
/* Always serialize the trust object for each assertion */
if (GKM_XDG_IS_ASSERTION (object)) {
trust = gkm_assertion_get_trust_object (GKM_ASSERTION (object));
object = GKM_OBJECT (trust);
/* If this trust object has already been added, then ignore */
if (lookup_filename_for_object (object))
return;
}
/* Double check that the object is in fact serializable */
if (!GKM_IS_SERIALIZABLE (object)) {
g_message ("can't store object of type '%s' on token", G_OBJECT_TYPE_NAME (object));
gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT);
return;
}
g_return_if_fail (lookup_filename_for_object (object) == NULL);
basename = guess_basename_for_object (object);
g_return_if_fail (basename);
actual = gkm_transaction_unique_file (transaction, self->directory, basename);
if (!gkm_transaction_get_failed (transaction)) {
filename = g_build_filename (self->directory, actual, NULL);
add_object_to_module (self, object, filename, transaction);
g_free (filename);
}
g_free (actual);
g_free (basename);
}
static void
gkm_xdg_module_real_store_token_object (GkmModule *module, GkmTransaction *transaction,
GkmObject *object)
{
GkmXdgModule *self = GKM_XDG_MODULE (module);
const gchar *filename;
GBytes *bytes;
GkmTrust *trust;
/* Always serialize the trust object for each assertion */
if (GKM_XDG_IS_ASSERTION (object)) {
trust = gkm_assertion_get_trust_object (GKM_ASSERTION (object));
object = GKM_OBJECT (trust);
}
/* Double check that the object is in fact serializable */
if (!GKM_IS_SERIALIZABLE (object)) {
g_message ("can't store object of type '%s' on token", G_OBJECT_TYPE_NAME (object));
gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT);
return;
}
/* Serialize the object in question */
bytes = gkm_serializable_save (GKM_SERIALIZABLE (object), NULL);
if (bytes == NULL) {
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
g_return_if_reached ();
}
filename = lookup_filename_for_object (object);
g_return_if_fail (filename != NULL);
g_return_if_fail (g_hash_table_lookup (self->objects_by_path, filename) == object);
gkm_transaction_write_file (transaction, filename,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes));
g_bytes_unref (bytes);
}
static void
gkm_xdg_module_real_remove_token_object (GkmModule *module, GkmTransaction *transaction,
GkmObject *object)
{
GkmXdgModule *self = GKM_XDG_MODULE (module);
const gchar *filename;
GkmXdgTrust *trust;
/* Always serialize the trust object for each assertion */
if (GKM_XDG_IS_ASSERTION (object)) {
trust = GKM_XDG_TRUST (gkm_assertion_get_trust_object (GKM_ASSERTION (object)));
gkm_xdg_trust_remove_assertion (trust, GKM_ASSERTION (object), transaction);
/* Remove the trust object if it has no assertions */
if (!gkm_xdg_trust_have_assertion (trust))
object = GKM_OBJECT (trust);
else
object = NULL;
}
if (object && !gkm_transaction_get_failed (transaction)) {
filename = lookup_filename_for_object (object);
g_return_if_fail (filename != NULL);
g_return_if_fail (g_hash_table_lookup (self->objects_by_path, filename) == object);
gkm_transaction_remove_file (transaction, filename);
remove_object_from_module (self, object, filename, transaction);
}
}
static GObject*
gkm_xdg_module_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GkmXdgModule *self = GKM_XDG_MODULE (G_OBJECT_CLASS (gkm_xdg_module_parent_class)->constructor(type, n_props, props));
g_return_val_if_fail (self, NULL);
if (!self->directory)
self->directory = g_build_filename (g_get_user_data_dir (), "keystore", NULL);
self->tracker = egg_file_tracker_new (self->directory, "*.*", NULL);
g_signal_connect (self->tracker, "file-added", G_CALLBACK (file_load), self);
g_signal_connect (self->tracker, "file-changed", G_CALLBACK (file_load), self);
g_signal_connect (self->tracker, "file-removed", G_CALLBACK (file_remove), self);
return G_OBJECT (self);
}
static void
gkm_xdg_module_init (GkmXdgModule *self)
{
self->objects_by_path = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, gkm_util_dispose_unref);
/* Our default token info, updated as module runs */
memcpy (&self->token_info, &user_module_token_info, sizeof (CK_TOKEN_INFO));
/* For creating stored objects */
gkm_module_register_factory (GKM_MODULE (self), GKM_XDG_FACTORY_ASSERTION);
gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_CERTIFICATE);
}
static void
gkm_xdg_module_dispose (GObject *obj)
{
GkmXdgModule *self = GKM_XDG_MODULE (obj);
if (self->tracker)
g_object_unref (self->tracker);
self->tracker = NULL;
g_hash_table_remove_all (self->objects_by_path);
G_OBJECT_CLASS (gkm_xdg_module_parent_class)->dispose (obj);
}
static void
gkm_xdg_module_finalize (GObject *obj)
{
GkmXdgModule *self = GKM_XDG_MODULE (obj);
g_assert (self->tracker == NULL);
g_hash_table_destroy (self->objects_by_path);
self->objects_by_path = NULL;
g_free (self->directory);
self->directory = NULL;
G_OBJECT_CLASS (gkm_xdg_module_parent_class)->finalize (obj);
}
static void
gkm_xdg_module_class_init (GkmXdgModuleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GkmModuleClass *module_class = GKM_MODULE_CLASS (klass);
gobject_class->constructor = gkm_xdg_module_constructor;
gobject_class->dispose = gkm_xdg_module_dispose;
gobject_class->finalize = gkm_xdg_module_finalize;
module_class->get_slot_info = gkm_xdg_module_real_get_slot_info;
module_class->get_token_info = gkm_xdg_module_real_get_token_info;
module_class->parse_argument = gkm_xdg_module_real_parse_argument;
module_class->refresh_token = gkm_xdg_module_real_refresh_token;
module_class->add_token_object = gkm_xdg_module_real_add_token_object;
module_class->store_token_object = gkm_xdg_module_real_store_token_object;
module_class->remove_token_object = gkm_xdg_module_real_remove_token_object;
}
/* ----------------------------------------------------------------------------
* PUBLIC
*/
CK_FUNCTION_LIST_PTR
gkm_xdg_store_get_functions (void)
{
gkm_crypto_initialize ();
return gkm_xdg_module_function_list;
}
GkmModule*
_gkm_xdg_store_get_module_for_testing (void)
{
return pkcs11_module;
}