/*
* gnome-keyring
*
* Copyright (C) 2008 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-gnome2-file.h"
#include "gkm-gnome2-private-key.h"
#include "gkm-gnome2-public-key.h"
#include "gkm-gnome2-storage.h"
#include "gkm/gkm-certificate.h"
#define DEBUG_FLAG GKM_DEBUG_STORAGE
#include "gkm/gkm-debug.h"
#include "gkm/gkm-data-asn1.h"
#include "gkm/gkm-manager.h"
#include "gkm/gkm-module.h"
#include "gkm/gkm-secret.h"
#include "gkm/gkm-serializable.h"
#include "gkm/gkm-util.h"
#include "egg/dotlock.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-hex.h"
#include "pkcs11/pkcs11i.h"
#include
#include
#include
#include
#include
#include
enum {
PROP_0,
PROP_MODULE,
PROP_DIRECTORY,
PROP_MANAGER,
PROP_LOGIN
};
struct _GkmGnome2Storage {
GkmStore parent;
GkmModule *module;
GkmManager *manager;
/* Information about file data */
gchar *directory;
gchar *filename;
GkmGnome2File *file;
time_t last_mtime;
GkmSecret *login;
/* Mapping of objects loaded */
GHashTable *object_to_identifier;
GHashTable *identifier_to_object;
/* Valid when in write state */
GkmTransaction *transaction;
gchar *write_path;
gint write_fd;
gint read_fd;
};
G_DEFINE_TYPE (GkmGnome2Storage, gkm_gnome2_storage, GKM_TYPE_STORE);
#define LOCK_TIMEOUT 4000 /*(4 seconds)*/
#define UNWANTED_IDENTIFIER_CHARS ":/\\<>|\t\n\r\v "
static gchar*
name_for_subject (const guchar *subject,
gsize n_subject)
{
GNode *asn;
gchar *name;
GBytes *bytes;
g_assert (subject);
g_assert (n_subject);
bytes = g_bytes_new (subject, n_subject);
asn = egg_asn1x_create_and_decode (pkix_asn1_tab, "Name", bytes);
g_return_val_if_fail (asn != NULL, NULL);
g_bytes_unref (bytes);
name = egg_dn_read_part (egg_asn1x_node (asn, "rdnSequence", NULL), "CN");
egg_asn1x_destroy (asn);
return name;
}
static gchar*
identifier_for_object (GkmObject *object)
{
GkmSerializableIface *serial;
const gchar *ext;
gchar *identifier;
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 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);
}
/* Build up the identifier */
identifier = g_strconcat (name, ext, NULL);
g_strdelimit (identifier, UNWANTED_IDENTIFIER_CHARS, '_');
g_free (name);
return identifier;
}
static GType
type_from_extension (const gchar *extension)
{
g_assert (extension);
if (strcmp (extension, ".pkcs8") == 0)
return GKM_TYPE_GNOME2_PRIVATE_KEY;
else if (strcmp (extension, ".pub") == 0)
return GKM_TYPE_GNOME2_PUBLIC_KEY;
else if (strcmp (extension, ".cer") == 0)
return GKM_TYPE_CERTIFICATE;
return 0;
}
static GType
type_from_identifier (const gchar *identifier)
{
const gchar *ext;
g_assert (identifier);
ext = strrchr (identifier, '.');
if (ext == NULL)
return 0;
return type_from_extension (ext);
}
static dotlock_t
lock_and_open_file (const gchar *filename,
gint flags)
{
dotlock_t lockh;
gint fd = -1;
/*
* In this function we don't actually put the object into a 'write' state,
* that's the callers job if necessary.
*/
fd = open (filename, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR);
if (fd == -1) {
g_message ("couldn't open store file: %s: %s",
filename, g_strerror (errno));
return NULL;
}
lockh = dotlock_create (filename, 0);
if (!lockh) {
g_message ("couldn't create lock for store file: %s: %s",
filename, g_strerror (errno));
close (fd);
return NULL;
}
if (dotlock_take (lockh, LOCK_TIMEOUT)) {
if (errno == EACCES)
g_message ("couldn't write to store file:"
" %s: file is locked", filename);
else
g_message ("couldn't lock store file: %s: %s",
filename, g_strerror (errno));
dotlock_destroy (lockh);
close (fd);
return NULL;
}
/* Successfully opened file */;
dotlock_set_fd (lockh, fd);
return lockh;
}
static gboolean
complete_lock_file (GkmTransaction *transaction, GObject *object, gpointer data)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (object);
dotlock_t lockh = data;
int fd = dotlock_get_fd (lockh);
gkm_debug ("closing: %s", self->filename);
/*
* Note that there is no error checking for release and
* destroy. These functions will log errors anyway and we
* can't do much else than logging those errors.
*/
dotlock_release (lockh);
dotlock_destroy (lockh);
close (fd);
/* Completed successfully */
return TRUE;
}
static gint
begin_lock_file (GkmGnome2Storage *self, GkmTransaction *transaction)
{
dotlock_t lockh;
/*
* In this function we don't actually put the object into a 'write' state,
* that's the callers job if necessary.
*/
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (GKM_IS_TRANSACTION (transaction));
g_return_val_if_fail (!gkm_transaction_get_failed (transaction), -1);
gkm_debug ("modifying: %s", self->filename);
lockh = lock_and_open_file (self->filename, O_RDONLY | O_CREAT);
if (!lockh) {
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return -1;
}
/* Successfully opened file */;
gkm_transaction_add (transaction, self, complete_lock_file, lockh);
return dotlock_get_fd (lockh);
}
static gboolean
complete_write_state (GkmTransaction *transaction, GObject *object, gpointer unused)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (object);
gboolean ret = TRUE;
struct stat sb;
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (object), FALSE);
g_return_val_if_fail (GKM_IS_TRANSACTION (transaction), FALSE);
g_return_val_if_fail (self->transaction == transaction, FALSE);
if (!gkm_transaction_get_failed (transaction)) {
/* Transaction succeeded, overwrite the old with the new */
if (g_rename (self->write_path, self->filename) == -1) {
g_warning ("couldn't rename temporary store file: %s", self->write_path);
ret = FALSE;
} else {
if (fstat (self->write_fd, &sb) >= 0)
self->last_mtime = sb.st_mtime;
}
} else {
/* Transaction failed, remove temporary file */
if (g_unlink (self->write_path) == -1)
g_warning ("couldn't delete temporary store file: %s", self->write_path);
}
/* read_fd is closed by complete_lock_file */
if (self->write_fd != -1)
close (self->write_fd);
self->write_fd = -1;
g_free (self->write_path);
self->write_path = NULL;
g_object_unref (self->transaction);
self->transaction = NULL;
return ret;
}
static gboolean
begin_write_state (GkmGnome2Storage *self, GkmTransaction *transaction)
{
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (GKM_IS_TRANSACTION (transaction));
g_return_val_if_fail (!gkm_transaction_get_failed (transaction), FALSE);
/* Already in write state for this transaction? */
if (self->transaction != NULL) {
g_return_val_if_fail (self->transaction == transaction, FALSE);
return TRUE;
}
/* Lock file for the transaction */
self->read_fd = begin_lock_file (self, transaction);
if (self->read_fd == -1)
return FALSE;
gkm_transaction_add (transaction, self, complete_write_state, NULL);
self->transaction = g_object_ref (transaction);
/* Open the new file */
g_assert (self->write_fd == -1);
self->write_path = g_strdup_printf ("%s.XXXXXX", self->filename);
self->write_fd = g_mkstemp (self->write_path);
if (self->write_fd == -1) {
g_message ("couldn't open new temporary store file: %s: %s", self->write_path, g_strerror (errno));
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return FALSE;
}
return TRUE;
}
static gboolean
complete_modification_state (GkmTransaction *transaction, GObject *object, gpointer unused)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (object);
GkmDataResult res;
if (!gkm_transaction_get_failed (transaction)) {
res = gkm_gnome2_file_write_fd (self->file, self->write_fd, self->login);
switch(res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
g_warning ("couldn't write to temporary store file: %s", self->write_path);
return FALSE;
case GKM_DATA_LOCKED:
g_warning ("couldn't encrypt temporary store file: %s", self->write_path);
return FALSE;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached ();
}
}
return TRUE;
}
static gboolean
begin_modification_state (GkmGnome2Storage *self, GkmTransaction *transaction)
{
GkmDataResult res;
CK_RV rv = CKR_OK;
/* Already in write state for this transaction? */
if (self->transaction != NULL) {
g_return_val_if_fail (self->transaction == transaction, FALSE);
return TRUE;
}
if (!begin_write_state (self, transaction))
return FALSE;
/* See if file needs updating */
res = gkm_gnome2_file_read_fd (self->file, self->read_fd, self->login);
switch (res) {
case GKM_DATA_FAILURE:
g_message ("failure updating user store file: %s", self->filename);
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_LOCKED:
rv = CKR_USER_NOT_LOGGED_IN;
break;
case GKM_DATA_UNRECOGNIZED:
g_message ("unrecognized or invalid user store file: %s", self->filename);
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_SUCCESS:
rv = CKR_OK;
break;
default:
g_assert_not_reached ();
break;
}
if (rv != CKR_OK) {
gkm_transaction_fail (transaction, rv);
return FALSE;
}
/* Write out the data once completed with modifications */
gkm_transaction_add (transaction, self, complete_modification_state, NULL);
return TRUE;
}
static void
take_object_ownership (GkmGnome2Storage *self, const gchar *identifier, GkmObject *object)
{
gchar *str;
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (GKM_IS_OBJECT (object));
g_assert (g_hash_table_lookup (self->identifier_to_object, identifier) == NULL);
g_assert (g_hash_table_lookup (self->object_to_identifier, object) == NULL);
str = g_strdup (identifier);
object = g_object_ref (object);
g_hash_table_replace (self->identifier_to_object, str, object);
g_hash_table_replace (self->object_to_identifier, object, str);;
g_object_set (object, "store", self, NULL);
gkm_object_expose (object, TRUE);
}
static gboolean
check_object_hash (GkmGnome2Storage *self, const gchar *identifier, const guchar *data, gsize n_data)
{
gconstpointer value;
GkmDataResult res;
gboolean result;
gsize n_value;
gchar *digest;
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (identifier);
g_assert (data);
digest = g_compute_checksum_for_data (G_CHECKSUM_SHA1, data, n_data);
g_return_val_if_fail (digest, FALSE);
res = gkm_gnome2_file_read_value (self->file, identifier, CKA_GNOME_INTERNAL_SHA1, &value, &n_value);
g_return_val_if_fail (res == GKM_DATA_SUCCESS, FALSE);
result = (strlen (digest) == n_value && memcmp (digest, value, n_value) == 0);
g_free (digest);
return result;
}
static void
store_object_hash (GkmGnome2Storage *self, GkmTransaction *transaction, const gchar *identifier,
const guchar *data, gsize n_data)
{
GkmDataResult res;
gchar *digest;
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (GKM_IS_TRANSACTION (transaction));
g_assert (identifier);
g_assert (data);
digest = g_compute_checksum_for_data (G_CHECKSUM_SHA1, data, n_data);
if (digest == NULL) {
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
g_return_if_reached ();
}
res = gkm_gnome2_file_write_value (self->file, identifier, CKA_GNOME_INTERNAL_SHA1, digest, strlen (digest));
g_free (digest);
if (res != GKM_DATA_SUCCESS)
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
}
static void
data_file_entry_added (GkmGnome2File *store, const gchar *identifier, GkmGnome2Storage *self)
{
GError *error = NULL;
GkmObject *object;
GBytes *bytes;
gboolean ret;
guchar *data;
gsize n_data;
GType type;
gchar *path;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (identifier);
/* Already have this object? */
object = g_hash_table_lookup (self->identifier_to_object, identifier);
if (object != NULL)
return;
/* Figure out what type of object we're dealing with */
type = type_from_identifier (identifier);
if (type == 0) {
g_warning ("don't know how to load file in user store: %s", identifier);
return;
}
/* Read the file in */
path = g_build_filename (self->directory, identifier, NULL);
ret = g_file_get_contents (path, (gchar**)&data, &n_data, &error);
g_free (path);
if (ret == FALSE) {
g_warning ("couldn't read file in user store: %s: %s", identifier,
egg_error_message (error));
g_clear_error (&error);
return;
}
/* Make sure that the object wasn't tampered with */
if (!check_object_hash (self, identifier, data, n_data)) {
g_message ("file in user store doesn't match hash: %s", identifier);
g_free (data);
return;
}
/* Create a new object for this identifier */
object = g_object_new (type, "unique", identifier, "module", self->module,
"manager", gkm_module_get_manager (self->module), NULL);
g_return_if_fail (GKM_IS_SERIALIZABLE (object));
g_return_if_fail (GKM_SERIALIZABLE_GET_INTERFACE (object)->extension);
bytes = g_bytes_new_take (data, n_data);
/* And load the data into it */
if (gkm_serializable_load (GKM_SERIALIZABLE (object), self->login, bytes))
take_object_ownership (self, identifier, object);
else
g_message ("failed to load file in user store: %s", identifier);
g_bytes_unref (bytes);
g_object_unref (object);
}
static void
data_file_entry_changed (GkmGnome2File *store, const gchar *identifier, CK_ATTRIBUTE_TYPE type, GkmGnome2Storage *self)
{
GkmObject *object;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (identifier);
object = g_hash_table_lookup (self->identifier_to_object, identifier);
if (object != NULL)
gkm_object_notify_attribute (object, type);
}
static void
data_file_entry_removed (GkmGnome2File *store, const gchar *identifier, GkmGnome2Storage *self)
{
GkmObject *object;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (identifier);
object = g_hash_table_lookup (self->identifier_to_object, identifier);
if (object != NULL) {
g_object_set (object, "store", NULL, NULL);
/* Unrefs and also disposes the object, which unregisters from manager*/
g_hash_table_remove (self->identifier_to_object, identifier);
g_hash_table_remove (self->object_to_identifier, object);
}
}
static void
relock_object (GkmGnome2Storage *self, GkmTransaction *transaction, const gchar *path,
const gchar *identifier, GkmSecret *old_login, GkmSecret *new_login)
{
GError *error = NULL;
GkmObject *object;
GBytes *bytes;
gpointer data;
gsize n_data;
GType type;
g_assert (GKM_IS_GNOME2_STORAGE (self));
g_assert (GKM_IS_TRANSACTION (transaction));
g_assert (identifier);
g_assert (path);
g_assert (!gkm_transaction_get_failed (transaction));
/* Figure out the type of object */
type = type_from_identifier (identifier);
if (type == 0) {
g_warning ("don't know how to relock file in user store: %s", identifier);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
return;
}
/* Create a dummy object for this identifier */
object = g_object_new (type, "unique", identifier, "module", self->module, NULL);
if (!GKM_IS_SERIALIZABLE (object)) {
g_warning ("cannot relock unserializable object for file in user store: %s", identifier);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
return;
}
/* Read in the data for the object */
if (!g_file_get_contents (path, (gchar**)&data, &n_data, &error)) {
g_message ("couldn't load file in user store in order to relock: %s: %s", identifier,
egg_error_message (error));
g_clear_error (&error);
g_object_unref (object);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
return;
}
/* Make sure the data matches the hash */
if (!check_object_hash (self, identifier, data, n_data)) {
g_message ("file in data store doesn't match hash: %s", identifier);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
g_free (data);
return;
}
bytes = g_bytes_new_take (data, n_data);
/* Load it into our temporary object */
if (!gkm_serializable_load (GKM_SERIALIZABLE (object), old_login, bytes)) {
g_message ("unrecognized or invalid user store file: %s", identifier);
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
g_bytes_unref (bytes);
g_object_unref (object);
return;
}
g_bytes_unref (bytes);
/* Read it out of our temporary object */
bytes = gkm_serializable_save (GKM_SERIALIZABLE (object), new_login);
if (bytes == NULL) {
g_warning ("unable to serialize data with new login: %s", identifier);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
g_object_unref (object);
g_free (data);
return;
}
g_object_unref (object);
/* And write it back out to the file */
gkm_transaction_write_file (transaction, path, data, n_data);
/* Create and save the hash here */
if (!gkm_transaction_get_failed (transaction))
store_object_hash (self, transaction, identifier, data, n_data);
g_bytes_unref (bytes);
}
typedef struct _RelockArgs {
GkmGnome2Storage *self;
GkmTransaction *transaction;
GkmSecret *old_login;
GkmSecret *new_login;
} RelockArgs;
static void
relock_each_object (GkmGnome2File *file, const gchar *identifier, gpointer data)
{
RelockArgs *args = data;
gchar *path;
guint section;
g_assert (GKM_IS_GNOME2_STORAGE (args->self));
if (gkm_transaction_get_failed (args->transaction))
return;
if (!gkm_gnome2_file_lookup_entry (file, identifier, §ion))
g_return_if_reached ();
/* Only operate on private files */
if (section != GKM_GNOME2_FILE_SECTION_PRIVATE)
return;
path = g_build_filename (args->self->directory, identifier, NULL);
relock_object (args->self, args->transaction, path, identifier, args->old_login, args->new_login);
g_free (path);
}
static CK_RV
refresh_with_login (GkmGnome2Storage *self, GkmSecret *login)
{
GkmDataResult res;
dotlock_t lockh;
struct stat sb;
CK_RV rv;
int fd;
g_assert (GKM_GNOME2_STORAGE (self));
gkm_debug ("refreshing: %s", self->filename);
/* Open the file for reading */
lockh = lock_and_open_file (self->filename, O_RDONLY);
if (!lockh) {
/* No file, no worries */
if (errno == ENOENT)
return login ? CKR_USER_PIN_NOT_INITIALIZED : CKR_OK;
g_message ("couldn't open store file: %s: %s", self->filename, g_strerror (errno));
return CKR_FUNCTION_FAILED;
}
fd = dotlock_get_fd (lockh);
/* Try and update the last read time */
if (fstat (fd, &sb) >= 0)
self->last_mtime = sb.st_mtime;
res = gkm_gnome2_file_read_fd (self->file, fd, login);
switch (res) {
case GKM_DATA_FAILURE:
g_message ("failure reading from file: %s", self->filename);
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_LOCKED:
rv = CKR_USER_NOT_LOGGED_IN;
break;
case GKM_DATA_UNRECOGNIZED:
g_message ("unrecognized or invalid user store file: %s", self->filename);
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_SUCCESS:
rv = CKR_OK;
break;
default:
g_assert_not_reached ();
break;
}
/* Force a reread on next write */
if (rv == CKR_FUNCTION_FAILED)
self->last_mtime = 0;
gkm_debug ("closing: %s", self->filename);
/*
* Note that there is no error checking for release and
* destroy. These functions will log errors anyway and we
* can't do much else than logging those errors.
*/
dotlock_release (lockh);
dotlock_destroy (lockh);
close (fd);
return rv;
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static CK_RV
gkm_gnome2_storage_real_read_value (GkmStore *base, GkmObject *object, CK_ATTRIBUTE_PTR attr)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (base);
const gchar *identifier;
GkmDataResult res;
gconstpointer value;
gsize n_value;
CK_RV rv;
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), CKR_GENERAL_ERROR);
g_return_val_if_fail (GKM_IS_OBJECT (object), CKR_GENERAL_ERROR);
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
if (self->last_mtime == 0) {
rv = gkm_gnome2_storage_refresh (self);
if (rv != CKR_OK)
return rv;
}
identifier = g_hash_table_lookup (self->object_to_identifier, object);
if (!identifier) {
gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: object not stored in gnome2 storage");
return CKR_ATTRIBUTE_TYPE_INVALID;
}
res = gkm_gnome2_file_read_value (self->file, identifier, attr->type, &value, &n_value);
switch (res) {
case GKM_DATA_FAILURE:
g_return_val_if_reached (CKR_GENERAL_ERROR);
case GKM_DATA_UNRECOGNIZED:
gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: attribute %s not present",
gkm_log_attr_type (attr->type));
return CKR_ATTRIBUTE_TYPE_INVALID;
case GKM_DATA_LOCKED:
return CKR_USER_NOT_LOGGED_IN;
case GKM_DATA_SUCCESS:
/* Yes, we don't fill a buffer, just return pointer */
attr->pValue = (CK_VOID_PTR)value;
attr->ulValueLen = n_value;
return CKR_OK;
default:
g_assert_not_reached ();
}
}
static void
gkm_gnome2_storage_real_write_value (GkmStore *base, GkmTransaction *transaction, GkmObject *object, CK_ATTRIBUTE_PTR attr)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (base);
const gchar *identifier;
GkmDataResult res;
CK_RV rv;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (GKM_IS_OBJECT (object));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (!gkm_transaction_get_failed (transaction));
g_return_if_fail (attr);
if (!begin_modification_state (self, transaction))
return;
identifier = g_hash_table_lookup (self->object_to_identifier, object);
if (!identifier) {
gkm_transaction_fail (transaction, CKR_ATTRIBUTE_READ_ONLY);
return;
}
res = gkm_gnome2_file_write_value (self->file, identifier, attr->type, attr->pValue, attr->ulValueLen);
switch (res) {
case GKM_DATA_FAILURE:
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_UNRECOGNIZED:
rv = CKR_ATTRIBUTE_READ_ONLY;
break;
case GKM_DATA_LOCKED:
rv = CKR_USER_NOT_LOGGED_IN;
break;
case GKM_DATA_SUCCESS:
rv = CKR_OK;
break;
default:
g_assert_not_reached ();
}
if (rv != CKR_OK)
gkm_transaction_fail (transaction, rv);
}
static GObject*
gkm_gnome2_storage_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (G_OBJECT_CLASS (gkm_gnome2_storage_parent_class)->constructor(type, n_props, props));
CK_ATTRIBUTE attr;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (self->directory, NULL);
self->filename = g_build_filename (self->directory, "user.keystore", NULL);
g_return_val_if_fail (self->manager, NULL);
g_return_val_if_fail (self->module, NULL);
/* Register store attributes */
attr.type = CKA_LABEL;
attr.pValue = "";
attr.ulValueLen = 0;
gkm_store_register_schema (GKM_STORE (self), &attr, NULL, 0);
return G_OBJECT (self);
}
static void
gkm_gnome2_storage_init (GkmGnome2Storage *self)
{
self->file = gkm_gnome2_file_new ();
g_signal_connect (self->file, "entry-added", G_CALLBACK (data_file_entry_added), self);
g_signal_connect (self->file, "entry-changed", G_CALLBACK (data_file_entry_changed), self);
g_signal_connect (self->file, "entry-removed", G_CALLBACK (data_file_entry_removed), self);
/* Each one owns the key and contains weak ref to other's key as its value */
self->object_to_identifier = g_hash_table_new_full (g_direct_hash, g_direct_equal, gkm_util_dispose_unref, NULL);
self->identifier_to_object = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
self->read_fd = -1;
self->write_fd = -1;
}
static void
gkm_gnome2_storage_dispose (GObject *obj)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (obj);
if (self->manager)
g_object_unref (self->manager);
self->manager = NULL;
if (self->login)
g_object_unref (self->login);
self->login = NULL;
g_signal_handlers_disconnect_by_func (self->file, data_file_entry_added, self);
g_signal_handlers_disconnect_by_func (self->file, data_file_entry_changed, self);
g_signal_handlers_disconnect_by_func (self->file, data_file_entry_removed, self);
g_hash_table_remove_all (self->object_to_identifier);
g_hash_table_remove_all (self->identifier_to_object);
G_OBJECT_CLASS (gkm_gnome2_storage_parent_class)->dispose (obj);
}
static void
gkm_gnome2_storage_finalize (GObject *obj)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (obj);
g_assert (self->file);
g_object_unref (self->file);
self->file = NULL;
g_free (self->filename);
self->filename = NULL;
g_assert (self->directory);
g_free (self->directory);
self->directory = NULL;
g_assert (self->object_to_identifier);
g_hash_table_destroy (self->object_to_identifier);
g_hash_table_destroy (self->identifier_to_object);
G_OBJECT_CLASS (gkm_gnome2_storage_parent_class)->finalize (obj);
}
static void
gkm_gnome2_storage_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (obj);
switch (prop_id) {
case PROP_DIRECTORY:
g_return_if_fail (!self->directory);
self->directory = g_value_dup_string (value);
g_return_if_fail (self->directory);
break;
case PROP_MODULE:
g_return_if_fail (!self->module);
self->module = g_value_get_object (value);
break;
case PROP_MANAGER:
g_return_if_fail (!self->manager);
self->manager = g_value_dup_object (value);
g_return_if_fail (self->manager);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_gnome2_storage_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
GkmGnome2Storage *self = GKM_GNOME2_STORAGE (obj);
switch (prop_id) {
case PROP_DIRECTORY:
g_value_set_string (value, gkm_gnome2_storage_get_directory (self));
break;
case PROP_MODULE:
g_value_set_object (value, self->module);
break;
case PROP_MANAGER:
g_value_set_object (value, gkm_gnome2_storage_get_manager (self));
break;
case PROP_LOGIN:
g_value_set_object (value, gkm_gnome2_storage_get_login (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_gnome2_storage_class_init (GkmGnome2StorageClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GkmStoreClass *store_class = GKM_STORE_CLASS (klass);
gobject_class->constructor = gkm_gnome2_storage_constructor;
gobject_class->dispose = gkm_gnome2_storage_dispose;
gobject_class->finalize = gkm_gnome2_storage_finalize;
gobject_class->set_property = gkm_gnome2_storage_set_property;
gobject_class->get_property = gkm_gnome2_storage_get_property;
store_class->read_value = gkm_gnome2_storage_real_read_value;
store_class->write_value = gkm_gnome2_storage_real_write_value;
g_object_class_install_property (gobject_class, PROP_DIRECTORY,
g_param_spec_string ("directory", "Storage Directory", "Directory for storage",
NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (gobject_class, PROP_MODULE,
g_param_spec_object ("module", "Module", "Module for objects",
GKM_TYPE_MODULE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (gobject_class, PROP_MANAGER,
g_param_spec_object ("manager", "Object Manager", "Object Manager",
GKM_TYPE_MANAGER, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (gobject_class, PROP_LOGIN,
g_param_spec_object ("login", "Login", "Login used to unlock",
GKM_TYPE_SECRET, G_PARAM_READABLE));
}
/* -----------------------------------------------------------------------------
* PUBLIC
*/
GkmGnome2Storage*
gkm_gnome2_storage_new (GkmModule *module, const gchar *directory)
{
GkmManager *manager;
g_return_val_if_fail (GKM_IS_MODULE (module), NULL);
g_return_val_if_fail (directory, NULL);
manager = gkm_module_get_manager (module);
g_return_val_if_fail (GKM_IS_MANAGER (manager), NULL);
return g_object_new (GKM_TYPE_GNOME2_STORAGE,
"module", module,
"manager", manager,
"directory", directory,
NULL);
}
CK_RV
gkm_gnome2_storage_refresh (GkmGnome2Storage *self)
{
g_return_val_if_fail (GKM_GNOME2_STORAGE (self), CKR_GENERAL_ERROR);
return refresh_with_login (self, self->login);
}
void
gkm_gnome2_storage_create (GkmGnome2Storage *self, GkmTransaction *transaction, GkmObject *object)
{
gboolean is_private;
GkmDataResult res;
gchar *identifier;
GBytes *data;
gchar *path;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (!gkm_transaction_get_failed (transaction));
g_return_if_fail (GKM_IS_OBJECT (object));
/* Make sure we haven't already stored it */
identifier = g_hash_table_lookup (self->object_to_identifier, object);
g_return_if_fail (identifier == NULL);
/* Double check that the object is in fact serializable */
if (!GKM_IS_SERIALIZABLE (object)) {
g_warning ("can't store object of type '%s' on token", G_OBJECT_TYPE_NAME (object));
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
g_return_if_reached ();
}
/* Figure out whether this is a private object */
if (!gkm_object_get_attribute_boolean (object, NULL, CKA_PRIVATE, &is_private))
is_private = FALSE;
/* Can't serialize private if we're not unlocked */
if (is_private && !self->login) {
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
}
/* Hook ourselves into the transaction */
if (!begin_modification_state (self, transaction))
return;
/* Create an identifier guaranteed unique by this transaction */
identifier = identifier_for_object (object);
if (gkm_gnome2_file_unique_entry (self->file, &identifier) != GKM_DATA_SUCCESS) {
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
g_return_if_reached ();
}
/* We don't want to get signals about this item being added */
g_signal_handlers_block_by_func (self->file, data_file_entry_added, self);
g_signal_handlers_block_by_func (self->file, data_file_entry_changed, self);
res = gkm_gnome2_file_create_entry (self->file, identifier,
is_private ? GKM_GNOME2_FILE_SECTION_PRIVATE : GKM_GNOME2_FILE_SECTION_PUBLIC);
g_signal_handlers_unblock_by_func (self->file, data_file_entry_added, self);
g_signal_handlers_unblock_by_func (self->file, data_file_entry_changed, self);
switch(res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
g_free (identifier);
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return;
case GKM_DATA_LOCKED:
g_free (identifier);
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached ();
}
/* Serialize the object in question */
data = gkm_serializable_save (GKM_SERIALIZABLE (object), is_private ? self->login : NULL);
if (data == NULL) {
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
g_return_if_reached ();
}
path = g_build_filename (self->directory, identifier, NULL);
gkm_transaction_write_file (transaction, path,
g_bytes_get_data (data, NULL),
g_bytes_get_size (data));
/* Make sure we write in the object hash */
if (!gkm_transaction_get_failed (transaction))
store_object_hash (self, transaction, identifier,
g_bytes_get_data (data, NULL),
g_bytes_get_size (data));
/* Now we decide to own the object */
if (!gkm_transaction_get_failed (transaction))
take_object_ownership (self, identifier, object);
g_free (identifier);
g_free (path);
g_bytes_unref (data);
}
void
gkm_gnome2_storage_destroy (GkmGnome2Storage *self, GkmTransaction *transaction, GkmObject *object)
{
GkmDataResult res;
gchar *identifier;
gchar *path;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (!gkm_transaction_get_failed (transaction));
g_return_if_fail (object);
/* Lookup the object identifier */
identifier = g_hash_table_lookup (self->object_to_identifier, object);
g_return_if_fail (identifier);
if (!begin_modification_state (self, transaction))
return;
/* First actually delete the file */
path = g_build_filename (self->directory, identifier, NULL);
gkm_transaction_remove_file (transaction, path);
g_free (path);
if (gkm_transaction_get_failed (transaction))
return;
/* Now delete the entry from our store */
res = gkm_gnome2_file_destroy_entry (self->file, identifier);
switch(res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return;
case GKM_DATA_LOCKED:
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached ();
}
/* Actual removal of object happened as a callback above */
g_return_if_fail (g_hash_table_lookup (self->object_to_identifier, object) == NULL);
}
void
gkm_gnome2_storage_relock (GkmGnome2Storage *self, GkmTransaction *transaction,
GkmSecret *old_login, GkmSecret *new_login)
{
GkmGnome2File *file;
GkmDataResult res;
RelockArgs args;
g_return_if_fail (GKM_IS_GNOME2_STORAGE (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
/* Reload the file with the old password and start transaction */
if (!begin_write_state (self, transaction))
return;
file = gkm_gnome2_file_new ();
/* Read in from the old file */
res = gkm_gnome2_file_read_fd (file, self->read_fd, old_login);
switch(res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return;
case GKM_DATA_LOCKED:
gkm_transaction_fail (transaction, CKR_PIN_INCORRECT);
return;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached ();
}
/* Write out to new path as new file */
res = gkm_gnome2_file_write_fd (file, self->write_fd, new_login);
switch(res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED);
return;
case GKM_DATA_LOCKED:
gkm_transaction_fail (transaction, CKR_PIN_INCORRECT);
return;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached ();
}
/* Now go through all objects in the file, and load and reencode them */
args.transaction = transaction;
args.old_login = old_login;
args.new_login = new_login;
args.self = self;
gkm_gnome2_file_foreach_entry (file, relock_each_object, &args);
if (!gkm_transaction_get_failed (transaction) && self->login) {
if (new_login)
g_object_ref (new_login);
g_object_unref (self->login);
self->login = new_login;
g_object_notify (G_OBJECT (self), "login");
}
g_object_unref (file);
}
CK_RV
gkm_gnome2_storage_unlock (GkmGnome2Storage *self, GkmSecret *login)
{
CK_RV rv;
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), CKR_GENERAL_ERROR);
g_return_val_if_fail (!self->transaction, CKR_GENERAL_ERROR);
if (self->login)
return CKR_USER_ALREADY_LOGGED_IN;
self->login = login;
rv = refresh_with_login (self, login);
if (rv == CKR_USER_NOT_LOGGED_IN)
rv = CKR_PIN_INCORRECT;
/* Take on new login for good */
if (rv == CKR_OK) {
g_assert (self->login == login);
if (self->login)
g_object_ref (self->login);
g_object_notify (G_OBJECT (self), "login");
/* Failed, so keep our previous NULL login */
} else {
self->login = NULL;
}
return rv;
}
CK_RV
gkm_gnome2_storage_lock (GkmGnome2Storage *self)
{
GkmSecret *prev;
CK_RV rv;
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), CKR_GENERAL_ERROR);
g_return_val_if_fail (!self->transaction, CKR_GENERAL_ERROR);
if (!self->login)
return CKR_USER_NOT_LOGGED_IN;
/* While loading set new NULL login */
prev = self->login;
self->login = NULL;
rv = refresh_with_login (self, NULL);
/* Take on new login for good */
if (rv == CKR_OK) {
g_object_unref (prev);
g_assert (self->login == NULL);
g_object_notify (G_OBJECT (self), "login");
/* Failed so revert to previous login */
} else {
self->login = prev;
}
return rv;
}
GkmManager*
gkm_gnome2_storage_get_manager (GkmGnome2Storage *self)
{
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), NULL);
return self->manager;
}
const gchar*
gkm_gnome2_storage_get_directory (GkmGnome2Storage *self)
{
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), NULL);
return self->directory;
}
GkmSecret*
gkm_gnome2_storage_get_login (GkmGnome2Storage *self)
{
g_return_val_if_fail (GKM_IS_GNOME2_STORAGE (self), NULL);
return self->login;
}
gulong
gkm_gnome2_storage_token_flags (GkmGnome2Storage *self)
{
gulong flags = 0;
CK_RV rv;
/* We don't changing SO logins, so always initialized */
flags |= CKF_TOKEN_INITIALIZED | CKF_LOGIN_REQUIRED;
/* No file has been loaded yet? */
if (self->last_mtime == 0) {
rv = gkm_gnome2_storage_refresh (self);
if (rv == CKR_USER_PIN_NOT_INITIALIZED)
flags |= CKF_USER_PIN_TO_BE_CHANGED;
else if (rv != CKR_OK)
g_return_val_if_reached (flags);
}
/* No private stuff in the file? */
if (gkm_gnome2_file_have_section (self->file, GKM_GNOME2_FILE_SECTION_PRIVATE))
flags |= CKF_USER_PIN_INITIALIZED;
return flags;
}