/*
* gnome-keyring
*
* Copyright (C) 2009 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-secret-binary.h"
#include "gkm-secret-collection.h"
#include "gkm-secret-data.h"
#include "gkm-secret-item.h"
#include "gkm-secret-textual.h"
#include "egg/egg-error.h"
#include "gkm/gkm-attributes.h"
#include "gkm/gkm-credential.h"
#include "gkm/gkm-secret.h"
#include "gkm/gkm-session.h"
#include "gkm/gkm-transaction.h"
#include
#include "pkcs11/pkcs11i.h"
enum {
PROP_0,
PROP_FILENAME
};
struct _GkmSecretCollection {
GkmSecretObject parent;
GkmSecretData *sdata;
GHashTable *items;
gchar *filename;
guint32 watermark;
GArray *template;
};
G_DEFINE_TYPE (GkmSecretCollection, gkm_secret_collection, GKM_TYPE_SECRET_OBJECT);
/* Forward declarations */
static void add_item (GkmSecretCollection *, GkmTransaction *, GkmSecretItem *);
static void remove_item (GkmSecretCollection *, GkmTransaction *, GkmSecretItem *);
/* -----------------------------------------------------------------------------
* INTERNAL
*/
static GkmDataResult
load_collection_and_secret_data (GkmSecretCollection *self, GkmSecretData *sdata,
const gchar *path)
{
GkmDataResult res;
GError *error = NULL;
guchar *data;
gsize n_data;
/* Read in the keyring */
if (!g_file_get_contents (path, (gchar**)&data, &n_data, &error)) {
g_message ("problem reading keyring: %s: %s",
path, egg_error_message (error));
g_clear_error (&error);
return GKM_DATA_FAILURE;
}
/* Try to load from an encrypted file, and otherwise plain text */
res = gkm_secret_binary_read (self, sdata, data, n_data);
if (res == GKM_DATA_UNRECOGNIZED)
res = gkm_secret_textual_read (self, sdata, data, n_data);
g_free (data);
return res;
}
static GkmCredential*
lookup_unassociated_credential (GkmSession *session, CK_OBJECT_HANDLE handle)
{
GkmObject *object;
if (gkm_session_lookup_readable_object (session, handle, &object) != CKR_OK)
return NULL;
if (gkm_credential_get_object (GKM_CREDENTIAL (object)) != NULL)
return NULL;
return GKM_CREDENTIAL (object);
}
static gboolean
find_unlocked_credential (GkmCredential *cred, GkmObject *object, gpointer user_data)
{
CK_OBJECT_HANDLE *result = user_data;
g_return_val_if_fail (!*result, FALSE);
if (gkm_credential_peek_data (cred, GKM_TYPE_SECRET_DATA)) {
*result = gkm_object_get_handle (GKM_OBJECT (cred));
return TRUE;
}
return FALSE;
}
static gboolean
find_unlocked_secret_data (GkmCredential *cred, GkmObject *object, gpointer user_data)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (object);
GkmSecretData **result = user_data;
g_return_val_if_fail (!*result, FALSE);
*result = gkm_credential_pop_data (cred, GKM_TYPE_SECRET_DATA);
if (*result) {
g_return_val_if_fail (*result == self->sdata, FALSE);
return TRUE;
}
return FALSE;
}
static void
track_secret_data (GkmSecretCollection *self, GkmSecretData *data)
{
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
if (self->sdata)
g_object_remove_weak_pointer (G_OBJECT (self->sdata),
(gpointer*)&(self->sdata));
self->sdata = data;
if (self->sdata)
g_object_add_weak_pointer (G_OBJECT (self->sdata),
(gpointer*)&(self->sdata));
}
static void
each_value_to_list (gpointer key, gpointer value, gpointer user_data)
{
GList **list = user_data;
*list = g_list_prepend (*list, value);
}
static void
expose_each_item (gpointer key, gpointer value, gpointer user_data)
{
gboolean expose = GPOINTER_TO_INT (user_data);
gkm_object_expose (value, expose);
}
static gboolean
complete_add (GkmTransaction *transaction, GkmSecretCollection *self, GkmSecretItem *item)
{
if (gkm_transaction_get_failed (transaction))
remove_item (self, NULL, item);
g_object_unref (item);
return TRUE;
}
static void
add_item (GkmSecretCollection *self, GkmTransaction *transaction, GkmSecretItem *item)
{
const gchar *identifier;
guint32 number;
g_assert (GKM_IS_SECRET_COLLECTION (self));
g_assert (GKM_IS_SECRET_ITEM (item));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
g_return_if_fail (identifier);
/* Make note of the highest numeric identifier, for later use */
number = strtoul (identifier, NULL, 10);
if (number > self->watermark)
self->watermark = number;
g_hash_table_replace (self->items, g_strdup (identifier), g_object_ref (item));
if (gkm_object_is_exposed (GKM_OBJECT (self)))
gkm_object_expose_full (GKM_OBJECT (item), transaction, TRUE);
if (transaction)
gkm_transaction_add (transaction, self, (GkmTransactionFunc)complete_add,
g_object_ref (item));
}
static gboolean
complete_remove (GkmTransaction *transaction, GkmSecretCollection *self, GkmSecretItem *item)
{
if (gkm_transaction_get_failed (transaction))
add_item (self, NULL, item);
g_object_unref (item);
return TRUE;
}
static void
remove_item (GkmSecretCollection *self, GkmTransaction *transaction, GkmSecretItem *item)
{
const gchar *identifier;
g_assert (GKM_IS_SECRET_COLLECTION (self));
g_assert (GKM_IS_SECRET_ITEM (item));
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
g_return_if_fail (identifier);
g_object_ref (item);
g_hash_table_remove (self->items, identifier);
gkm_object_expose_full (GKM_OBJECT (item), transaction, FALSE);
if (transaction)
gkm_transaction_add (transaction, self, (GkmTransactionFunc)complete_remove,
g_object_ref (item));
g_object_unref (item);
}
static GkmObject*
factory_create_collection (GkmSession *session, GkmTransaction *transaction,
CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
GkmSecretCollection *collection = NULL;
CK_OBJECT_HANDLE handle;
CK_ATTRIBUTE *attr;
GkmManager *manager;
GkmModule *module;
gchar *identifier = NULL;
GkmSecretData *sdata;
gchar *label = NULL;
GkmCredential *cred;
gboolean is_token;
CK_RV rv;
g_return_val_if_fail (GKM_IS_TRANSACTION (transaction), NULL);
g_return_val_if_fail (attrs || !n_attrs, NULL);
manager = gkm_manager_for_template (attrs, n_attrs, session);
module = gkm_session_get_module (session);
/* Must have a credential, which is not associated with an object yet */
if (!gkm_attributes_find_ulong (attrs, n_attrs, CKA_G_CREDENTIAL, &handle)) {
gkm_transaction_fail (transaction, CKR_TEMPLATE_INCOMPLETE);
return NULL;
}
cred = lookup_unassociated_credential (session, handle);
if (cred == NULL) {
gkm_transaction_fail (transaction, CKR_ATTRIBUTE_VALUE_INVALID);
return NULL;
}
/* The identifier */
attr = gkm_attributes_find (attrs, n_attrs, CKA_ID);
if (attr != NULL) {
gkm_attribute_consume (attr);
rv = gkm_attribute_get_string (attr, &identifier);
if (rv != CKR_OK) {
gkm_transaction_fail (transaction, rv);
return NULL;
}
/* Try to find the collection with that identifier */
if (!gkm_attributes_find_boolean (attrs, n_attrs, CKA_TOKEN, &is_token))
collection = gkm_secret_collection_find (session, attr,
gkm_module_get_manager (module),
gkm_session_get_manager (session), NULL);
else if (is_token)
collection = gkm_secret_collection_find (session, attr,
gkm_module_get_manager (module), NULL);
else
collection = gkm_secret_collection_find (session, attr,
gkm_session_get_manager (session), NULL);
/* Already have one with this identifier? Just return that */
if (collection != NULL) {
gkm_session_complete_object_creation (session, transaction, GKM_OBJECT (collection),
FALSE, attrs, n_attrs);
return GKM_OBJECT (g_object_ref (collection));
}
}
/* The label */
attr = gkm_attributes_find (attrs, n_attrs, CKA_LABEL);
if (attr != NULL) {
gkm_attribute_consume (attr);
rv = gkm_attribute_get_string (attr, &label);
if (rv != CKR_OK) {
gkm_transaction_fail (transaction, rv);
return NULL;
}
/* No identifier? Use label */
if (identifier == NULL)
identifier = g_strdup (label);
}
if (!identifier || !identifier[0]) {
g_free (identifier);
identifier = g_strdup ("unnamed");
}
if (!label || !label[0]) {
g_free (label);
if (identifier) {
label = g_strdup (identifier);
} else {
/* TRANSLATORS: This is the label for an keyring created without a label */
label = g_strdup (_("Unnamed"));
}
}
g_strdelimit (identifier, ":/\\<>|\t\n\r\v ", '_');
collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
"module", gkm_session_get_module (session),
"identifier", identifier,
"manager", manager,
"label", label,
NULL);
gkm_secret_object_mark_created (GKM_SECRET_OBJECT (collection));
g_free (identifier);
g_free (label);
gkm_credential_connect (cred, GKM_OBJECT (collection));
sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
gkm_credential_set_data (cred, GKM_TYPE_SECRET_DATA, sdata);
gkm_secret_data_set_master (sdata, gkm_credential_get_secret (cred));
track_secret_data (collection, sdata);
g_object_unref (sdata);
gkm_attributes_consume (attrs, n_attrs, CKA_G_CREDENTIAL, G_MAXULONG);
gkm_session_complete_object_creation (session, transaction, GKM_OBJECT (collection),
TRUE, attrs, n_attrs);
return GKM_OBJECT (collection);
}
static gboolean
complete_master_password (GkmTransaction *transaction, GObject *object, gpointer user_data)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (object);
GkmSecret *previous = user_data;
if (gkm_transaction_get_failed (transaction)) {
if (self->sdata)
gkm_secret_data_set_master (self->sdata, previous);
}
if (previous)
g_object_unref (previous);
return TRUE;
}
static void
change_master_password (GkmSecretCollection *self, GkmTransaction *transaction,
GkmCredential *cred)
{
GkmSecret *previous;
g_assert (GKM_IS_SECRET_COLLECTION (self));
g_assert (GKM_IS_TRANSACTION (transaction));
g_assert (GKM_IS_CREDENTIAL (cred));
if (!self->sdata) {
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
}
previous = gkm_secret_data_get_master (self->sdata);
if (previous != NULL)
g_object_ref (previous);
gkm_credential_connect (cred, GKM_OBJECT (self));
gkm_credential_set_data (cred, GKM_TYPE_SECRET_DATA, self->sdata);
gkm_secret_data_set_master (self->sdata, gkm_credential_get_secret (cred));
gkm_transaction_add (transaction, self, complete_master_password, previous);
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static CK_RV
gkm_secret_collection_get_attribute (GkmObject *base, GkmSession *session, CK_ATTRIBUTE_PTR attr)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (base);
const gchar *identifier;
GkmSecret *master;
switch (attr->type) {
case CKA_CLASS:
return gkm_attribute_set_ulong (attr, CKO_G_COLLECTION);
case CKA_G_CREDENTIAL_TEMPLATE:
return gkm_attribute_set_template (attr, self->template);
case CKA_G_LOGIN_COLLECTION:
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (base));
g_return_val_if_fail (identifier, CKR_GENERAL_ERROR);
return gkm_attribute_set_bool (attr, g_str_equal (identifier, "login"));
case CKA_TRUSTED:
if (!self->sdata)
return gkm_attribute_set_bool (attr, CK_FALSE);
master = gkm_secret_data_get_master (self->sdata);
return gkm_attribute_set_bool (attr, (master && !gkm_secret_is_trivially_weak (master)));
}
return GKM_OBJECT_CLASS (gkm_secret_collection_parent_class)->get_attribute (base, session, attr);
}
static void
gkm_secret_collection_set_attribute (GkmObject *object, GkmSession *session,
GkmTransaction *transaction, CK_ATTRIBUTE *attr)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (object);
CK_OBJECT_HANDLE handle = 0;
GkmCredential *cred;
GArray *template;
CK_RV rv;
switch (attr->type) {
case CKA_G_CREDENTIAL:
gkm_credential_for_each (session, GKM_OBJECT (self),
find_unlocked_credential, &handle);
if (handle == 0) {
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
}
rv = gkm_attribute_get_ulong (attr, &handle);
if (rv != CKR_OK) {
gkm_transaction_fail (transaction, rv);
return;
}
cred = lookup_unassociated_credential (session, handle);
if (cred == NULL) {
gkm_transaction_fail (transaction, CKR_ATTRIBUTE_VALUE_INVALID);
return;
}
change_master_password (self, transaction, cred);
return;
case CKA_G_CREDENTIAL_TEMPLATE:
rv = gkm_attribute_get_template (attr, &template);
if (rv != CKR_OK) {
gkm_transaction_fail (transaction, rv);
return;
}
gkm_template_free (self->template);
self->template = template;
return;
};
GKM_OBJECT_CLASS (gkm_secret_collection_parent_class)->set_attribute (object, session, transaction, attr);
}
static CK_RV
gkm_secret_collection_real_unlock (GkmObject *obj, GkmCredential *cred)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
GkmDataResult res;
GkmSecretData *sdata;
GkmSecret *master;
CK_RV rv = CKR_GENERAL_ERROR;
master = gkm_credential_get_secret (cred);
/* Already unlocked, make sure pin matches */
if (self->sdata) {
if (!gkm_secret_equal (gkm_secret_data_get_master (self->sdata), master))
return CKR_PIN_INCORRECT;
/* Credential now tracks our secret data */
gkm_credential_set_data (cred, GKM_TYPE_SECRET_DATA, self->sdata);
return CKR_OK;
}
/* New secret data object, setup master password */
sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
gkm_secret_data_set_master (sdata, master);
/* Load the data from a file, and decrypt if necessary */
if (self->filename) {
res = load_collection_and_secret_data (self, sdata, self->filename);
/* No filename, password must be null */
} else {
if (gkm_secret_equals (master, NULL, 0))
res = GKM_DATA_SUCCESS;
else
res = GKM_DATA_LOCKED;
}
switch (res) {
case GKM_DATA_SUCCESS:
gkm_credential_set_data (cred, GKM_TYPE_SECRET_DATA, sdata);
track_secret_data (self, sdata);
rv = CKR_OK;
break;
case GKM_DATA_LOCKED:
rv = CKR_PIN_INCORRECT;
break;
case GKM_DATA_UNRECOGNIZED:
g_message ("unrecognized or invalid keyring: %s", self->filename);
rv = CKR_FUNCTION_FAILED;
break;
case GKM_DATA_FAILURE:
g_message ("failed to read or parse keyring: %s", self->filename);
rv = CKR_GENERAL_ERROR;
break;
default:
g_assert_not_reached ();
}
g_object_unref (sdata);
return rv;
}
static void
gkm_secret_collection_expose (GkmObject *base, gboolean expose)
{
GKM_OBJECT_CLASS (gkm_secret_collection_parent_class)->expose_object (base, expose);
g_hash_table_foreach (GKM_SECRET_COLLECTION (base)->items, expose_each_item, GINT_TO_POINTER (expose));
}
static gboolean
gkm_secret_collection_real_is_locked (GkmSecretObject *obj, GkmSession *session)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
return !gkm_secret_collection_unlocked_have (self, session);
}
static void
gkm_secret_collection_init (GkmSecretCollection *self)
{
CK_ULONG idle = 0;
CK_ULONG after = 0;
CK_BBOOL token = CK_TRUE;
CK_ATTRIBUTE attrs[] = {
{ CKA_TOKEN, &token, sizeof (token) },
{ CKA_GNOME_TRANSIENT, &token, sizeof (token) },
{ CKA_G_DESTRUCT_IDLE, &idle, sizeof (idle) },
{ CKA_G_DESTRUCT_AFTER, &after, sizeof (after) },
};
self->items = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
self->template = gkm_template_new (attrs, G_N_ELEMENTS (attrs));
}
static void
gkm_secret_collection_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
switch (prop_id) {
case PROP_FILENAME:
gkm_secret_collection_set_filename (self, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_secret_collection_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
switch (prop_id) {
case PROP_FILENAME:
g_value_set_string (value, gkm_secret_collection_get_filename (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_secret_collection_dispose (GObject *obj)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
track_secret_data (self, NULL);
g_hash_table_remove_all (self->items);
G_OBJECT_CLASS (gkm_secret_collection_parent_class)->dispose (obj);
}
static void
gkm_secret_collection_finalize (GObject *obj)
{
GkmSecretCollection *self = GKM_SECRET_COLLECTION (obj);
g_assert (self->sdata == NULL);
g_hash_table_destroy (self->items);
self->items = NULL;
g_free (self->filename);
self->filename = NULL;
gkm_template_free (self->template);
self->template = NULL;
G_OBJECT_CLASS (gkm_secret_collection_parent_class)->finalize (obj);
}
static void
gkm_secret_collection_class_init (GkmSecretCollectionClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GkmObjectClass *gkm_class = GKM_OBJECT_CLASS (klass);
GkmSecretObjectClass *secret_class = GKM_SECRET_OBJECT_CLASS (klass);
gkm_secret_collection_parent_class = g_type_class_peek_parent (klass);
gobject_class->set_property = gkm_secret_collection_set_property;
gobject_class->get_property = gkm_secret_collection_get_property;
gobject_class->dispose = gkm_secret_collection_dispose;
gobject_class->finalize = gkm_secret_collection_finalize;
gkm_class->get_attribute = gkm_secret_collection_get_attribute;
gkm_class->set_attribute = gkm_secret_collection_set_attribute;
gkm_class->unlock = gkm_secret_collection_real_unlock;
gkm_class->expose_object = gkm_secret_collection_expose;
secret_class->is_locked = gkm_secret_collection_real_is_locked;
g_object_class_install_property (gobject_class, PROP_FILENAME,
g_param_spec_string ("filename", "Filename", "Collection filename (without path)",
NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
gkm_secret_object_class_unique_identifiers (secret_class);
}
/* -----------------------------------------------------------------------------
* PUBLIC
*/
GkmFactory*
gkm_secret_collection_get_factory (void)
{
static CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
static CK_ATTRIBUTE attributes[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
};
static GkmFactory factory = {
attributes,
G_N_ELEMENTS (attributes),
factory_create_collection
};
return &factory;
}
const gchar*
gkm_secret_collection_get_filename (GkmSecretCollection *self)
{
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
return self->filename;
}
void
gkm_secret_collection_set_filename (GkmSecretCollection *self, const gchar *filename)
{
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
if (self->filename == filename)
return;
g_free (self->filename);
self->filename = g_strdup (filename);
g_object_notify (G_OBJECT (self), "filename");
}
GList*
gkm_secret_collection_get_items (GkmSecretCollection *self)
{
GList *items = NULL;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
g_hash_table_foreach (self->items, each_value_to_list, &items);
return items;
}
GkmSecretItem*
gkm_secret_collection_get_item (GkmSecretCollection *self, const gchar *identifier)
{
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
g_return_val_if_fail (identifier, NULL);
return g_hash_table_lookup (self->items, identifier);
}
gboolean
gkm_secret_collection_has_item (GkmSecretCollection *self, GkmSecretItem *item)
{
const gchar *identifier;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), FALSE);
g_return_val_if_fail (GKM_IS_SECRET_ITEM (item), FALSE);
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
return g_hash_table_lookup (self->items, identifier) == item;
}
GkmSecretCollection*
gkm_secret_collection_find (GkmSession *session, CK_ATTRIBUTE_PTR attr, ...)
{
CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
GkmSecretCollection *result = NULL;
GkmManager *manager;
CK_ATTRIBUTE attrs[2];
GList *objects;
va_list va;
g_assert (attr);
attrs[0].type = CKA_CLASS;
attrs[0].ulValueLen = sizeof (klass);
attrs[0].pValue = &klass;
attrs[1].type = CKA_ID;
attrs[1].ulValueLen = attr->ulValueLen;
attrs[1].pValue = attr->pValue;
va_start (va, attr);
while (!result && (manager = va_arg (va, GkmManager*)) != NULL) {
objects = gkm_manager_find_by_attributes (manager, session, attrs, 2);
if (objects && GKM_IS_SECRET_COLLECTION (objects->data))
result = objects->data;
g_list_free (objects);
}
va_end (va);
return result;
}
GkmSecretItem*
gkm_secret_collection_new_item (GkmSecretCollection *self, const gchar *identifier)
{
GkmSecretItem *item;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
g_return_val_if_fail (identifier, NULL);
g_return_val_if_fail (!g_hash_table_lookup (self->items, identifier), NULL);
item = g_object_new (GKM_TYPE_SECRET_ITEM,
"module", gkm_object_get_module (GKM_OBJECT (self)),
"manager", gkm_object_get_manager (GKM_OBJECT (self)),
"collection", self,
"identifier", identifier,
NULL);
add_item (self, NULL, item);
g_object_unref (item);
return item;
}
GkmSecretItem*
gkm_secret_collection_create_item (GkmSecretCollection *self, GkmTransaction *transaction)
{
GkmSecretItem *item;
gchar *identifier = NULL;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
g_return_val_if_fail (transaction, NULL);
g_return_val_if_fail (!gkm_transaction_get_failed (transaction), NULL);
do {
g_free (identifier);
identifier = g_strdup_printf ("%d", ++(self->watermark));
} while (g_hash_table_lookup (self->items, identifier));
item = g_object_new (GKM_TYPE_SECRET_ITEM,
"module", gkm_object_get_module (GKM_OBJECT (self)),
"manager", gkm_object_get_manager (GKM_OBJECT (self)),
"collection", self,
"identifier", identifier,
NULL);
g_free (identifier);
add_item (self, transaction, item);
gkm_secret_object_mark_created (GKM_SECRET_OBJECT (item));
g_object_unref (item);
return item;
}
void
gkm_secret_collection_remove_item (GkmSecretCollection *self, GkmSecretItem *item)
{
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
g_return_if_fail (GKM_IS_SECRET_ITEM (item));
g_return_if_fail (gkm_secret_collection_has_item (self, item));
remove_item (self, NULL, item);
}
void
gkm_secret_collection_destroy_item (GkmSecretCollection *self, GkmTransaction *transaction,
GkmSecretItem *item)
{
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (GKM_IS_SECRET_ITEM (item));
g_return_if_fail (gkm_secret_collection_has_item (self, item));
remove_item (self, transaction, item);
}
gboolean
gkm_secret_collection_unlocked_have (GkmSecretCollection *self, GkmSession *session)
{
CK_OBJECT_HANDLE handle = 0;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), FALSE);
g_return_val_if_fail (GKM_IS_SESSION (session), FALSE);
/*
* Look for credential objects that this session has access
* to, and use those to find the secret data. If a secret data is
* found, it should match the one we are tracking in self->sdata.
*/
gkm_credential_for_each (session, GKM_OBJECT (self), find_unlocked_credential, &handle);
return handle != 0;
}
GkmSecretData*
gkm_secret_collection_unlocked_use (GkmSecretCollection *self, GkmSession *session)
{
GkmSecretData *sdata = NULL;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), NULL);
g_return_val_if_fail (GKM_IS_SESSION (session), NULL);
/*
* Look for credential objects that this session has access
* to, and use those to find the secret data. If a secret data is
* found, it should match the one we are tracking in self->sdata.
*/
gkm_credential_for_each (session, GKM_OBJECT (self),
find_unlocked_secret_data, &sdata);
return sdata;
}
void
gkm_secret_collection_unlocked_clear (GkmSecretCollection *self)
{
/*
* TODO: This is a tough one to implement. I'm holding off and wondering
* if we don't need it, perhaps? As it currently stands, what needs to happen
* here is we need to find each and every credential that references the
* secret data for this collection and completely delete those objects.
*/
g_warning ("Clearing of secret data needs implementing");
track_secret_data (self, NULL);
}
GkmDataResult
gkm_secret_collection_load (GkmSecretCollection *self)
{
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), GKM_DATA_FAILURE);
if (!self->filename)
return GKM_DATA_SUCCESS;
return load_collection_and_secret_data (self, self->sdata, self->filename);
}
void
gkm_secret_collection_save (GkmSecretCollection *self, GkmTransaction *transaction)
{
GkmSecret *master;
GkmDataResult res;
gpointer data;
gsize n_data;
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (!gkm_transaction_get_failed (transaction));
/* HACK: We can't save unless the secret data was loaded */
if (!self->sdata) {
gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN);
return;
}
/* Don't save ourselves if no filename */
if (!self->filename)
return;
master = gkm_secret_data_get_master (self->sdata);
if (master == NULL || gkm_secret_equals (master, NULL, 0))
res = gkm_secret_textual_write (self, self->sdata, &data, &n_data);
else
res = gkm_secret_binary_write (self, self->sdata, &data, &n_data);
switch (res) {
case GKM_DATA_FAILURE:
case GKM_DATA_UNRECOGNIZED:
g_warning ("couldn't prepare to write out keyring: %s", self->filename);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
break;
case GKM_DATA_LOCKED:
g_warning ("locked error while writing out keyring: %s", self->filename);
gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
break;
case GKM_DATA_SUCCESS:
gkm_transaction_write_file (transaction, self->filename, data, n_data);
g_free (data);
break;
default:
g_assert_not_reached ();
};
}
void
gkm_secret_collection_destroy (GkmSecretCollection *self, GkmTransaction *transaction)
{
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
g_return_if_fail (GKM_IS_TRANSACTION (transaction));
g_return_if_fail (!gkm_transaction_get_failed (transaction));
gkm_object_expose_full (GKM_OBJECT (self), transaction, FALSE);
if (self->filename)
gkm_transaction_remove_file (transaction, self->filename);
}
gint
gkm_secret_collection_get_lock_idle (GkmSecretCollection *self)
{
gulong value;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), 0);
if (!gkm_template_find_ulong (self->template, CKA_G_DESTRUCT_IDLE, &value))
value = 0;
return (gint)value;
}
void
gkm_secret_collection_set_lock_idle (GkmSecretCollection *self, gint lock_timeout)
{
CK_ULONG value = (lock_timeout < 0) ? 0 : lock_timeout;
CK_ATTRIBUTE attr = { CKA_G_DESTRUCT_IDLE, &value, sizeof (value) };
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
gkm_template_set (self->template, &attr);
}
gint
gkm_secret_collection_get_lock_after (GkmSecretCollection *self)
{
gulong value;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (self), 0);
if (!gkm_template_find_ulong (self->template, CKA_G_DESTRUCT_AFTER, &value))
value = 0;
return (gint)value;
}
void
gkm_secret_collection_set_lock_after (GkmSecretCollection *self, gint lock_timeout)
{
CK_ULONG value = (lock_timeout < 0) ? 0 : lock_timeout;
CK_ATTRIBUTE attr = { CKA_G_DESTRUCT_AFTER, &value, sizeof (value) };
g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
gkm_template_set (self->template, &attr);
}