/* * 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-data.h" #include "gkm-secret-fields.h" #include "gkm-secret-item.h" #include "gkm/gkm-attributes.h" #include "gkm/gkm-module.h" #include "gkm/gkm-secret.h" #include "gkm/gkm-session.h" #include "gkm/gkm-transaction.h" #include "pkcs11/pkcs11i.h" #include enum { PROP_0, PROP_COLLECTION, PROP_FIELDS, PROP_SCHEMA }; struct _GkmSecretItem { GkmSecretObject parent; GHashTable *fields; gchar *schema; GkmSecretCollection *collection; }; G_DEFINE_TYPE (GkmSecretItem, gkm_secret_item, GKM_TYPE_SECRET_OBJECT); /* ----------------------------------------------------------------------------- * INTERNAL */ static gboolean complete_set_schema (GkmTransaction *transaction, GObject *obj, gpointer user_data) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); gchar *old_schema = user_data; if (gkm_transaction_get_failed (transaction)) { g_free (self->schema); self->schema = old_schema; } else { gkm_object_notify_attribute (GKM_OBJECT (obj), CKA_G_SCHEMA); g_object_notify (G_OBJECT (obj), "schema"); g_free (old_schema); } return TRUE; } static void begin_set_schema (GkmSecretItem *self, GkmTransaction *transaction, gchar *schema) { g_assert (GKM_IS_SECRET_OBJECT (self)); g_assert (!gkm_transaction_get_failed (transaction)); if (self->schema != schema) { gkm_secret_object_begin_modified (GKM_SECRET_OBJECT (self), transaction); gkm_transaction_add (transaction, self, complete_set_schema, self->schema); self->schema = schema; } } static gboolean complete_set_secret (GkmTransaction *transaction, GObject *obj, gpointer user_data) { if (!gkm_transaction_get_failed (transaction)) { gkm_object_notify_attribute (GKM_OBJECT (obj), CKA_VALUE); } return TRUE; } static gboolean complete_set_fields (GkmTransaction *transaction, GObject *obj, gpointer user_data) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); GHashTable *old_fields = user_data; if (gkm_transaction_get_failed (transaction)) { if (self->fields) g_hash_table_unref (self->fields); self->fields = old_fields; } else { gkm_object_notify_attribute (GKM_OBJECT (obj), CKA_G_FIELDS); g_object_notify (G_OBJECT (obj), "fields"); if (old_fields) g_hash_table_unref (old_fields); } return TRUE; } static void begin_set_fields (GkmSecretItem *self, GkmTransaction *transaction, GHashTable *fields) { g_assert (GKM_IS_SECRET_OBJECT (self)); g_assert (!gkm_transaction_get_failed (transaction)); gkm_secret_object_begin_modified (GKM_SECRET_OBJECT (self), transaction); gkm_transaction_add (transaction, self, complete_set_fields, self->fields); self->fields = fields; } static GkmObject* factory_create_item (GkmSession *session, GkmTransaction *transaction, CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs) { GkmSecretCollection *collection = NULL; GkmSecretItem *item; GkmManager *m_manager; GkmManager *s_manager; CK_ATTRIBUTE *attr; gboolean is_token; g_autofree gchar *identifier = NULL; g_return_val_if_fail (GKM_IS_TRANSACTION (transaction), NULL); g_return_val_if_fail (attrs || !n_attrs, NULL); /* See if a collection attribute was specified */ attr = gkm_attributes_find (attrs, n_attrs, CKA_G_COLLECTION); if (attr == NULL) { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCOMPLETE); return NULL; } m_manager = gkm_module_get_manager (gkm_session_get_module (session)); s_manager = gkm_session_get_manager (session); gkm_attribute_consume (attr); if (!gkm_attributes_find_boolean (attrs, n_attrs, CKA_TOKEN, &is_token)) collection = gkm_secret_collection_find (session, attr, m_manager, s_manager, NULL); else if (is_token) collection = gkm_secret_collection_find (session, attr, m_manager, NULL); else collection = gkm_secret_collection_find (session, attr, s_manager, NULL); if (!collection) { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT); return NULL; } /* If an ID was specified, then try and see if that ID already exists */ if (gkm_attributes_find_string (attrs, n_attrs, CKA_ID, &identifier)) { item = gkm_secret_collection_get_item (collection, identifier); if (item == NULL) { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT); return NULL; } else { gkm_session_complete_object_creation (session, transaction, GKM_OBJECT (item), FALSE, attrs, n_attrs); return GKM_OBJECT (g_object_ref (item)); } } /* Create a new collection which will own the item */ item = gkm_secret_collection_create_item (collection, transaction); gkm_session_complete_object_creation (session, transaction, GKM_OBJECT (item), TRUE, attrs, n_attrs); return GKM_OBJECT (g_object_ref (item)); } /* ----------------------------------------------------------------------------- * OBJECT */ static gboolean gkm_secret_item_real_is_locked (GkmSecretObject *obj, GkmSession *session) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); if (!self->collection) return TRUE; return gkm_secret_object_is_locked (GKM_SECRET_OBJECT (self->collection), session); } static CK_RV gkm_secret_item_real_get_attribute (GkmObject *base, GkmSession *session, CK_ATTRIBUTE_PTR attr) { GkmSecretItem *self = GKM_SECRET_ITEM (base); GkmSecretData *sdata; const gchar *identifier; const guchar *secret; gsize n_secret = 0; CK_RV rv; g_return_val_if_fail (self->collection, CKR_GENERAL_ERROR); switch (attr->type) { case CKA_CLASS: return gkm_attribute_set_ulong (attr, CKO_SECRET_KEY); case CKA_VALUE: sdata = gkm_secret_collection_unlocked_use (self->collection, session); if (sdata == NULL) return CKR_USER_NOT_LOGGED_IN; identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (self)); secret = gkm_secret_data_get_raw (sdata, identifier, &n_secret); rv = gkm_attribute_set_data (attr, secret, n_secret); gkm_object_mark_used (base); g_object_unref (sdata); return rv; case CKA_G_COLLECTION: g_return_val_if_fail (self->collection, CKR_GENERAL_ERROR); identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (self->collection)); return gkm_attribute_set_string (attr, identifier); case CKA_G_FIELDS: if (!self->fields) return gkm_attribute_set_data (attr, NULL, 0); return gkm_secret_fields_serialize (attr, self->fields, self->schema); case CKA_G_SCHEMA: return gkm_attribute_set_string (attr, self->schema); } return GKM_OBJECT_CLASS (gkm_secret_item_parent_class)->get_attribute (base, session, attr); } static void gkm_secret_item_real_set_attribute (GkmObject *base, GkmSession *session, GkmTransaction *transaction, CK_ATTRIBUTE_PTR attr) { GkmSecretItem *self = GKM_SECRET_ITEM (base); const gchar *identifier; GkmSecretData *sdata; GHashTable *fields; gchar *schema_name; GkmSecret *secret; gchar *schema; CK_RV rv; if (!self->collection) { gkm_transaction_fail (transaction, CKR_GENERAL_ERROR); g_return_if_reached (); } /* Check that the object is not locked */ if (!gkm_secret_collection_unlocked_have (self->collection, session)) { gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN); return; } switch (attr->type) { case CKA_VALUE: sdata = gkm_secret_collection_unlocked_use (self->collection, session); g_return_if_fail (sdata); identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (self)); secret = gkm_secret_new (attr->pValue, attr->ulValueLen); gkm_secret_data_set_transacted (sdata, transaction, identifier, secret); g_object_unref (secret); g_object_unref (sdata); gkm_secret_object_begin_modified (GKM_SECRET_OBJECT (self), transaction); if (!gkm_transaction_get_failed (transaction)) gkm_transaction_add (transaction, self, complete_set_secret, NULL); return; case CKA_G_FIELDS: rv = gkm_secret_fields_parse (attr, &fields, &schema_name); if (rv != CKR_OK) { gkm_transaction_fail (transaction, rv); } else { begin_set_fields (self, transaction, fields); if (schema_name) begin_set_schema (self, transaction, schema_name); } return; case CKA_G_SCHEMA: rv = gkm_attribute_get_string (attr, &schema); if (rv != CKR_OK) gkm_transaction_fail (transaction, rv); else begin_set_schema (self, transaction, schema); return; } GKM_OBJECT_CLASS (gkm_secret_item_parent_class)->set_attribute (base, session, transaction, attr); } static void gkm_secret_item_init (GkmSecretItem *self) { } static GObject* gkm_secret_item_constructor (GType type, guint n_props, GObjectConstructParam *props) { GkmSecretItem *self = GKM_SECRET_ITEM (G_OBJECT_CLASS (gkm_secret_item_parent_class)->constructor(type, n_props, props)); g_return_val_if_fail (self, NULL); g_return_val_if_fail (self->collection, NULL); return G_OBJECT (self); } static void gkm_secret_item_set_property (GObject *obj, guint prop_id, const GValue *value, GParamSpec *pspec) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); switch (prop_id) { case PROP_COLLECTION: g_return_if_fail (!self->collection); self->collection = g_value_get_object (value); g_return_if_fail (self->collection); g_object_add_weak_pointer (G_OBJECT (self->collection), (gpointer*)&(self->collection)); break; case PROP_FIELDS: gkm_secret_item_set_fields (self, g_value_get_boxed (value)); break; case PROP_SCHEMA: gkm_secret_item_set_schema (self, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } } static void gkm_secret_item_get_property (GObject *obj, guint prop_id, GValue *value, GParamSpec *pspec) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); switch (prop_id) { case PROP_COLLECTION: g_value_set_object (value, gkm_secret_item_get_collection (self)); break; case PROP_FIELDS: g_value_set_boxed (value, gkm_secret_item_get_fields (self)); break; case PROP_SCHEMA: g_value_set_string (value, gkm_secret_item_get_schema (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } } static void gkm_secret_item_dispose (GObject *obj) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); if (self->collection) g_object_remove_weak_pointer (G_OBJECT (self->collection), (gpointer*)&(self->collection)); self->collection = NULL; G_OBJECT_CLASS (gkm_secret_item_parent_class)->dispose (obj); } static void gkm_secret_item_finalize (GObject *obj) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); g_assert (!self->collection); if (self->fields) g_hash_table_unref (self->fields); self->fields = NULL; g_free (self->schema); self->schema = NULL; G_OBJECT_CLASS (gkm_secret_item_parent_class)->finalize (obj); } static void gkm_secret_item_class_init (GkmSecretItemClass *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_item_parent_class = g_type_class_peek_parent (klass); gobject_class->constructor = gkm_secret_item_constructor; gobject_class->dispose = gkm_secret_item_dispose; gobject_class->finalize = gkm_secret_item_finalize; gobject_class->set_property = gkm_secret_item_set_property; gobject_class->get_property = gkm_secret_item_get_property; gkm_class->get_attribute = gkm_secret_item_real_get_attribute; gkm_class->set_attribute = gkm_secret_item_real_set_attribute; secret_class->is_locked = gkm_secret_item_real_is_locked; g_object_class_install_property (gobject_class, PROP_COLLECTION, g_param_spec_object ("collection", "Collection", "Item's Collection", GKM_TYPE_SECRET_COLLECTION, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (gobject_class, PROP_FIELDS, g_param_spec_boxed ("fields", "Fields", "Item's fields", GKM_BOXED_SECRET_FIELDS, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_SCHEMA, g_param_spec_string ("schema", "Schema", "Item's type or schema", NULL, G_PARAM_READWRITE)); } /* ----------------------------------------------------------------------------- * PUBLIC */ GkmFactory* gkm_secret_item_get_factory (void) { static CK_OBJECT_CLASS klass = CKO_SECRET_KEY; static CK_ATTRIBUTE attributes[] = { { CKA_CLASS, &klass, sizeof (klass) }, }; static GkmFactory factory = { attributes, G_N_ELEMENTS (attributes), factory_create_item }; return &factory; } GkmSecretCollection* gkm_secret_item_get_collection (GkmSecretItem *self) { g_return_val_if_fail (GKM_IS_SECRET_ITEM (self), NULL); return self->collection; } GHashTable* gkm_secret_item_get_fields (GkmSecretItem *self) { g_return_val_if_fail (GKM_IS_SECRET_ITEM (self), NULL); if (self->fields == NULL) self->fields = gkm_secret_fields_new (); return self->fields; } void gkm_secret_item_set_fields (GkmSecretItem *self, GHashTable *fields) { g_return_if_fail (GKM_IS_SECRET_ITEM (self)); if (fields) g_hash_table_ref (fields); if (self->fields) g_hash_table_unref (self->fields); self->fields = fields; g_object_notify (G_OBJECT (self), "fields"); gkm_object_notify_attribute (GKM_OBJECT (self), CKA_G_FIELDS); } const gchar* gkm_secret_item_get_schema (GkmSecretItem *self) { g_return_val_if_fail (GKM_IS_SECRET_ITEM (self), NULL); return self->schema; } void gkm_secret_item_set_schema (GkmSecretItem *self, const gchar *schema) { g_return_if_fail (GKM_IS_SECRET_ITEM (self)); if (schema != self->schema) { g_free (self->schema); self->schema = g_strdup (schema); g_object_notify (G_OBJECT (self), "schema"); gkm_object_notify_attribute (GKM_OBJECT (self), CKA_G_SCHEMA); } }