/* * 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-collection.h" #include "gkm-secret-item.h" #include "gkm-secret-module.h" #include "gkm-secret-search.h" #include "gkm-secret-store.h" #include "gkm/gkm-credential.h" #define DEBUG_FLAG GKM_DEBUG_STORAGE #include "gkm/gkm-debug.h" #include "gkm/gkm-transaction.h" #include "gkm/gkm-util.h" #include "egg/egg-file-tracker.h" #include #include #include #include struct _GkmSecretModule { GkmModule parent; EggFileTracker *tracker; GHashTable *collections; gchar *directory; GkmCredential *session_credential; }; static const CK_SLOT_INFO gkm_secret_module_slot_info = { "Secret Store", "Gnome Keyring", CKF_TOKEN_PRESENT, { 0, 0 }, { 0, 0 } }; static const CK_TOKEN_INFO gkm_secret_module_token_info = { "Secret Store", "Gnome Keyring", "1.0", "1:SECRET:MAIN", /* Unique serial number for manufacturer */ CKF_TOKEN_INITIALIZED | CKF_USER_PIN_INITIALIZED | CKF_LOGIN_REQUIRED, 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 }, "" }; G_DEFINE_TYPE (GkmSecretModule, gkm_secret_module, GKM_TYPE_MODULE); GkmModule* _gkm_secret_store_get_module_for_testing (void); /* Forward declarations */ static void add_collection (GkmSecretModule *, GkmTransaction *, GkmSecretCollection *); static void remove_collection (GkmSecretModule *, GkmTransaction *, GkmSecretCollection *); /* ----------------------------------------------------------------------------- * ACTUAL PKCS#11 Module Implementation */ /* Include all the module entry points */ #include "gkm/gkm-module-ep.h" GKM_DEFINE_MODULE (gkm_secret_module, GKM_TYPE_SECRET_MODULE); /* ----------------------------------------------------------------------------- * INTERNAL */ static gboolean complete_add (GkmTransaction *transaction, GObject *obj, gpointer user_data) { GkmSecretCollection *collection = GKM_SECRET_COLLECTION (user_data); if (gkm_transaction_get_failed (transaction)) remove_collection (GKM_SECRET_MODULE (obj), NULL, collection); g_object_unref (collection); return TRUE; } static void add_collection (GkmSecretModule *self, GkmTransaction *transaction, GkmSecretCollection *collection) { const gchar *filename; g_assert (GKM_IS_SECRET_MODULE(self)); g_assert (GKM_IS_SECRET_COLLECTION (collection)); filename = gkm_secret_collection_get_filename (collection); g_return_if_fail (filename); g_hash_table_replace (self->collections, g_strdup (filename), g_object_ref (collection)); gkm_object_expose_full (GKM_OBJECT (collection), transaction, TRUE); if (transaction) gkm_transaction_add (transaction, self, complete_add, g_object_ref (collection)); } static gboolean complete_remove (GkmTransaction *transaction, GObject *obj, gpointer user_data) { GkmSecretCollection *collection = GKM_SECRET_COLLECTION (user_data); if (gkm_transaction_get_failed (transaction)) add_collection (GKM_SECRET_MODULE (obj), NULL, collection); g_object_unref (collection); return TRUE; } static void remove_collection (GkmSecretModule *self, GkmTransaction *transaction, GkmSecretCollection *collection) { const gchar *filename; g_assert (GKM_IS_SECRET_MODULE (self)); g_assert (GKM_IS_SECRET_COLLECTION (collection)); filename = gkm_secret_collection_get_filename (collection); g_return_if_fail (filename); g_hash_table_remove (self->collections, filename); gkm_object_expose_full (GKM_OBJECT (collection), transaction, FALSE); if (transaction) gkm_transaction_add (transaction, self, complete_remove, g_object_ref (collection)); } static gchar* identifier_from_filename (GkmSecretModule *self, const gchar *filename) { gchar *identifier; /* Do we have one for this path yet? */ identifier = g_path_get_basename (filename); /* Remove the keyring suffix */ if (g_str_has_suffix (identifier, ".keyring")) identifier[strlen(identifier) - 8] = 0; return identifier; } static gchar* identifier_to_new_filename (GkmSecretModule *self, const gchar *identifier) { gchar *filename; gint i; int fd; for (i = 0; i < G_MAXINT; ++i) { if (i == 0) filename = g_strdup_printf ("%s/%s.keyring", self->directory, identifier); else filename = g_strdup_printf ("%s/%s_%d.keyring", self->directory, identifier, i); /* Try to create the file, and check that it doesn't exist */ fd = g_open (filename, O_RDONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR); if (fd == -1) { if (errno != EEXIST) break; } else { close (fd); break; } g_free (filename); } return filename; } static void on_file_load (EggFileTracker *tracker, const gchar *path, GkmSecretModule *self) { GkmSecretCollection *collection; GkmManager *manager; GkmDataResult res; gboolean created; gchar *identifier; manager = gkm_module_get_manager (GKM_MODULE (self)); g_return_if_fail (manager); /* Do we have one for this path yet? */ identifier = identifier_from_filename (self, path); collection = g_hash_table_lookup (self->collections, path); if (collection == NULL) { created = TRUE; collection = g_object_new (GKM_TYPE_SECRET_COLLECTION, "module", self, "identifier", identifier, "filename", path, "manager", manager, NULL); } else { created = FALSE; g_object_ref (collection); } res = gkm_secret_collection_load (collection); switch (res) { case GKM_DATA_SUCCESS: if (created) add_collection (self, NULL, collection); break; case GKM_DATA_LOCKED: g_message ("master password for keyring changed without our knowledge: %s", path); gkm_secret_collection_unlocked_clear (collection); break; case GKM_DATA_UNRECOGNIZED: g_message ("keyring was in an invalid or unrecognized format: %s", path); break; case GKM_DATA_FAILURE: g_message ("failed to parse keyring: %s", path); break; default: g_assert_not_reached (); } g_object_unref (collection); g_free (identifier); } static void on_file_remove (EggFileTracker *tracker, const gchar *path, GkmSecretModule *self) { GkmSecretCollection *collection; g_return_if_fail (path); g_return_if_fail (GKM_IS_SECRET_MODULE (self)); collection = g_hash_table_lookup (self->collections, path); if (collection) remove_collection (self, NULL, collection); } /* ----------------------------------------------------------------------------- * OBJECT */ static const CK_SLOT_INFO* gkm_secret_module_real_get_slot_info (GkmModule *self) { return &gkm_secret_module_slot_info; } static const CK_TOKEN_INFO* gkm_secret_module_real_get_token_info (GkmModule *self) { return &gkm_secret_module_token_info; } static void gkm_secret_module_real_parse_argument (GkmModule *base, const gchar *name, const gchar *value) { GkmSecretModule *self = GKM_SECRET_MODULE (base); if (g_str_equal (name, "directory")) { g_free (self->directory); self->directory = g_strdup (value); } } static CK_RV gkm_secret_module_real_refresh_token (GkmModule *base) { GkmSecretModule *self = GKM_SECRET_MODULE (base); if (self->tracker) egg_file_tracker_refresh (self->tracker, FALSE); return CKR_OK; } static void gkm_secret_module_real_add_object (GkmModule *module, GkmTransaction *transaction, GkmObject *object) { GkmSecretModule *self = GKM_SECRET_MODULE (module); GkmSecretCollection *collection; const gchar *identifier; gchar *filename; g_return_if_fail (!gkm_transaction_get_failed (transaction)); if (GKM_IS_SECRET_COLLECTION (object)) { collection = GKM_SECRET_COLLECTION (object); /* Setup a filename for this collection */ identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (collection)); filename = identifier_to_new_filename (self, identifier); gkm_secret_collection_set_filename (collection, filename); g_free (filename); add_collection (self, transaction, collection); } } static void gkm_secret_module_real_store_object (GkmModule *module, GkmTransaction *transaction, GkmObject *object) { GkmSecretModule *self = GKM_SECRET_MODULE (module); GkmSecretCollection *collection = NULL; /* Store the item's collection */ if (GKM_IS_SECRET_ITEM (object)) { collection = gkm_secret_item_get_collection (GKM_SECRET_ITEM (object)); g_return_if_fail (GKM_IS_SECRET_COLLECTION (collection)); gkm_module_store_token_object (GKM_MODULE (self), transaction, GKM_OBJECT (collection)); /* Storing a collection */ } else if (GKM_IS_SECRET_COLLECTION (object)) { collection = GKM_SECRET_COLLECTION (object); gkm_secret_collection_save (collection, transaction); /* No other kind of token object */ } else { g_warning ("can't store object of type '%s' on secret token", G_OBJECT_TYPE_NAME (object)); gkm_transaction_fail (transaction, CKR_GENERAL_ERROR); } } static void gkm_secret_module_real_remove_object (GkmModule *module, GkmTransaction *transaction, GkmObject *object) { GkmSecretModule *self = GKM_SECRET_MODULE (module); GkmSecretCollection *collection; /* Ignore the session keyring credentials */ if (self->session_credential != NULL && GKM_OBJECT (self->session_credential) == object) return; /* Removing an item */ if (GKM_IS_SECRET_ITEM (object)) { collection = gkm_secret_item_get_collection (GKM_SECRET_ITEM (object)); g_return_if_fail (GKM_IS_SECRET_COLLECTION (collection)); gkm_secret_collection_destroy_item (collection, transaction, GKM_SECRET_ITEM (object)); if (!gkm_transaction_get_failed (transaction)) gkm_secret_collection_save (collection, transaction); /* Removing a collection */ } else if (GKM_IS_SECRET_COLLECTION (object)) { collection = GKM_SECRET_COLLECTION (object); gkm_secret_collection_destroy (collection, transaction); if (!gkm_transaction_get_failed (transaction)) remove_collection (self, transaction, collection); /* No other token objects */ } else { g_warning ("Trying to remove token object of type '%s' from secret " "module, but that type is not supported.", G_OBJECT_TYPE_NAME (object)); gkm_transaction_fail (transaction, CKR_FUNCTION_NOT_SUPPORTED); } } static GObject* gkm_secret_module_constructor (GType type, guint n_props, GObjectConstructParam *props) { GkmSecretModule *self = GKM_SECRET_MODULE (G_OBJECT_CLASS (gkm_secret_module_parent_class)->constructor(type, n_props, props)); GkmManager *manager; GkmObject *collection; CK_RV rv; g_return_val_if_fail (self, NULL); if (!self->directory) self->directory = gkm_util_locate_keyrings_directory (); gkm_debug ("secret store directory: %s", self->directory); self->tracker = egg_file_tracker_new (self->directory, "*.keyring", NULL); g_signal_connect (self->tracker, "file-added", G_CALLBACK (on_file_load), self); g_signal_connect (self->tracker, "file-changed", G_CALLBACK (on_file_load), self); g_signal_connect (self->tracker, "file-removed", G_CALLBACK (on_file_remove), self); manager = gkm_module_get_manager (GKM_MODULE (self)); collection = g_object_new (GKM_TYPE_SECRET_COLLECTION, "module", self, "identifier", "session", "manager", manager, "transient", TRUE, NULL); /* Create the 'session' keyring, which is not stored to disk */ g_return_val_if_fail (gkm_object_is_transient (collection), NULL); gkm_module_add_token_object (GKM_MODULE (self), NULL, collection); gkm_object_expose (collection, TRUE); /* Unlock the 'session' keyring */ rv = gkm_credential_create (GKM_MODULE (self), manager, GKM_OBJECT (collection), NULL, 0, &self->session_credential); if (rv == CKR_OK) gkm_object_expose (GKM_OBJECT (self->session_credential), TRUE); else g_warning ("couldn't unlock the 'session' keyring"); g_object_unref (collection); return G_OBJECT (self); } static void gkm_secret_module_init (GkmSecretModule *self) { self->collections = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_SECRET_SEARCH); gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_SECRET_ITEM); gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_SECRET_COLLECTION); } static void gkm_secret_module_dispose (GObject *obj) { GkmSecretModule *self = GKM_SECRET_MODULE (obj); if (self->tracker) g_object_unref (self->tracker); self->tracker = NULL; if (self->session_credential) g_object_unref (self->session_credential); self->session_credential = NULL; g_hash_table_remove_all (self->collections); G_OBJECT_CLASS (gkm_secret_module_parent_class)->dispose (obj); } static void gkm_secret_module_finalize (GObject *obj) { GkmSecretModule *self = GKM_SECRET_MODULE (obj); g_assert (self->tracker == NULL); g_hash_table_destroy (self->collections); self->collections = NULL; g_free (self->directory); self->directory = NULL; g_assert (!self->session_credential); G_OBJECT_CLASS (gkm_secret_module_parent_class)->finalize (obj); } static void gkm_secret_module_class_init (GkmSecretModuleClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GkmModuleClass *module_class = GKM_MODULE_CLASS (klass); gobject_class->constructor = gkm_secret_module_constructor; gobject_class->dispose = gkm_secret_module_dispose; gobject_class->finalize = gkm_secret_module_finalize; module_class->get_slot_info = gkm_secret_module_real_get_slot_info; module_class->get_token_info = gkm_secret_module_real_get_token_info; module_class->parse_argument = gkm_secret_module_real_parse_argument; module_class->refresh_token = gkm_secret_module_real_refresh_token; module_class->add_token_object = gkm_secret_module_real_add_object; module_class->store_token_object = gkm_secret_module_real_store_object; module_class->remove_token_object = gkm_secret_module_real_remove_object; } /* --------------------------------------------------------------------------------------- * PUBLIC */ CK_FUNCTION_LIST_PTR gkm_secret_store_get_functions (void) { gkm_crypto_initialize (); return gkm_secret_module_function_list; } GkmModule* _gkm_secret_store_get_module_for_testing (void) { return pkcs11_module; }