/*
* 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-module.h"
#include "gkm-gnome2-private-key.h"
#include "gkm-gnome2-public-key.h"
#include "gkm-gnome2-storage.h"
#include "gkm-gnome2-store.h"
#include "gkm/gkm-certificate.h"
#include "gkm/gkm-data-asn1.h"
#define DEBUG_FLAG GKM_DEBUG_STORAGE
#include "gkm/gkm-debug.h"
#include "gkm/gkm-manager.h"
#include "gkm/gkm-secret.h"
#include "gkm/gkm-transaction.h"
#include "gkm/gkm-util.h"
#include
struct _GkmGnome2Module {
GkmModule parent;
GkmGnome2Storage *storage;
gchar *directory;
GHashTable *unlocked_apps;
CK_TOKEN_INFO token_info;
};
static const CK_SLOT_INFO user_module_slot_info = {
"Gnome2 Key Storage",
"Gnome Keyring",
CKF_TOKEN_PRESENT,
{ 0, 0 },
{ 0, 0 }
};
static const CK_TOKEN_INFO user_module_token_info = {
"Gnome2 Key Storage",
"Gnome Keyring",
"1.0",
"1:USER:DEFAULT", /* 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 },
""
};
#define UNUSED_VALUE (GUINT_TO_POINTER (1))
G_DEFINE_TYPE (GkmGnome2Module, gkm_gnome2_module, GKM_TYPE_MODULE);
GkmModule * _gkm_gnome2_store_get_module_for_testing (void);
/* -----------------------------------------------------------------------------
* ACTUAL PKCS#11 Module Implementation
*/
/* Include all the module entry points */
#include "gkm/gkm-module-ep.h"
GKM_DEFINE_MODULE (gkm_gnome2_module, GKM_TYPE_GNOME2_MODULE);
/* -----------------------------------------------------------------------------
* INTERNAL
*/
/* -----------------------------------------------------------------------------
* OBJECT
*/
static const CK_SLOT_INFO*
gkm_gnome2_module_real_get_slot_info (GkmModule *base)
{
return &user_module_slot_info;
}
static const CK_TOKEN_INFO*
gkm_gnome2_module_real_get_token_info (GkmModule *base)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
/* Update the info with current info */
self->token_info.flags = gkm_gnome2_storage_token_flags (self->storage);
return &self->token_info;
}
static void
gkm_gnome2_module_real_parse_argument (GkmModule *base, const gchar *name, const gchar *value)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
if (g_str_equal (name, "directory")) {
g_free (self->directory);
self->directory = g_strdup (value);
}
}
static CK_RV
gkm_gnome2_module_real_refresh_token (GkmModule *base)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
gkm_gnome2_storage_refresh (self->storage);
return CKR_OK;
}
static void
gkm_gnome2_module_real_add_token_object (GkmModule *base, GkmTransaction *transaction, GkmObject *object)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
gkm_gnome2_storage_create (self->storage, transaction, object);
}
static void
gkm_gnome2_module_real_store_token_object (GkmModule *base, GkmTransaction *transaction, GkmObject *object)
{
/* Not necessary */
}
static void
gkm_gnome2_module_real_remove_token_object (GkmModule *base, GkmTransaction *transaction, GkmObject *object)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
gkm_gnome2_storage_destroy (self->storage, transaction, object);
}
static CK_RV
gkm_gnome2_module_real_login_change (GkmModule *base, CK_SLOT_ID slot_id, CK_UTF8CHAR_PTR old_pin,
CK_ULONG n_old_pin, CK_UTF8CHAR_PTR new_pin, CK_ULONG n_new_pin)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
GkmSecret *old_login, *new_login;
GkmTransaction *transaction;
CK_RV rv;
/*
* Remember this doesn't affect the currently logged in user. Logged in
* sessions will remain logged in, and vice versa.
*/
old_login = gkm_secret_new_from_login (old_pin, n_old_pin);
new_login = gkm_secret_new_from_login (new_pin, n_new_pin);
transaction = gkm_transaction_new ();
gkm_gnome2_storage_relock (self->storage, transaction, old_login, new_login);
g_object_unref (old_login);
g_object_unref (new_login);
gkm_transaction_complete (transaction);
rv = gkm_transaction_get_result (transaction);
g_object_unref (transaction);
return rv;
}
static CK_RV
gkm_gnome2_module_real_login_user (GkmModule *base, CK_SLOT_ID slot_id, CK_UTF8CHAR_PTR pin, CK_ULONG n_pin)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
GkmSecret *login;
CK_RV rv;
/* See if this application has logged in */
if (g_hash_table_lookup (self->unlocked_apps, &slot_id))
return CKR_USER_ALREADY_LOGGED_IN;
login = gkm_gnome2_storage_get_login (self->storage);
/* No application is logged in */
if (g_hash_table_size (self->unlocked_apps) == 0) {
g_return_val_if_fail (login == NULL, CKR_GENERAL_ERROR);
/* So actually unlock the store */
login = gkm_secret_new_from_login (pin, n_pin);
rv = gkm_gnome2_storage_unlock (self->storage, login);
g_object_unref (login);
/* An application is already logged in */
} else {
g_return_val_if_fail (login != NULL, CKR_GENERAL_ERROR);
/* Compare our pin to the one used originally */
if (!gkm_secret_equals (login, pin, n_pin))
rv = CKR_PIN_INCORRECT;
else
rv = CKR_OK;
}
/* Note that this application logged in */
if (rv == CKR_OK) {
g_hash_table_insert (self->unlocked_apps, gkm_util_ulong_alloc (slot_id), UNUSED_VALUE);
rv = GKM_MODULE_CLASS (gkm_gnome2_module_parent_class)->login_user (base, slot_id, pin, n_pin);
}
return rv;
}
static CK_RV
gkm_gnome2_module_real_login_so (GkmModule *base, CK_SLOT_ID slot_id, CK_UTF8CHAR_PTR pin, CK_ULONG n_pin)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
/* See if this application has unlocked, in which case we can't login */
if (g_hash_table_lookup (self->unlocked_apps, &slot_id))
return CKR_USER_ALREADY_LOGGED_IN;
/* Note that for an SO login, we don't actually unlock, and pin is always blank */
if (n_pin != 0)
return CKR_PIN_INCORRECT;
return GKM_MODULE_CLASS (gkm_gnome2_module_parent_class)->login_so (base, slot_id, pin, n_pin);
}
static CK_RV
gkm_gnome2_module_real_logout_user (GkmModule *base, CK_SLOT_ID slot_id)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (base);
CK_RV rv;
if (!g_hash_table_remove (self->unlocked_apps, &slot_id))
return CKR_USER_NOT_LOGGED_IN;
if (g_hash_table_size (self->unlocked_apps) > 0)
return CKR_OK;
rv = gkm_gnome2_storage_lock (self->storage);
if (rv == CKR_OK)
rv = GKM_MODULE_CLASS (gkm_gnome2_module_parent_class)->logout_user (base, slot_id);
return rv;
}
static GObject*
gkm_gnome2_module_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (G_OBJECT_CLASS (gkm_gnome2_module_parent_class)->constructor(type, n_props, props));
g_return_val_if_fail (self, NULL);
if (!self->directory)
self->directory = gkm_util_locate_keyrings_directory ();
gkm_debug ("gnome2 module directory: %s", self->directory);
self->storage = gkm_gnome2_storage_new (GKM_MODULE (self), self->directory);
return G_OBJECT (self);
}
static void
gkm_gnome2_module_init (GkmGnome2Module *self)
{
self->unlocked_apps = g_hash_table_new_full (gkm_util_ulong_hash, gkm_util_ulong_equal, gkm_util_ulong_free, NULL);
/* Our default token info, updated as module runs */
memcpy (&self->token_info, &user_module_token_info, sizeof (CK_TOKEN_INFO));
/* For creating stored keys */
gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_GNOME2_PRIVATE_KEY);
gkm_module_register_factory (GKM_MODULE (self), GKM_FACTORY_GNOME2_PUBLIC_KEY);
}
static void
gkm_gnome2_module_dispose (GObject *obj)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (obj);
if (self->storage)
g_object_unref (self->storage);
self->storage = NULL;
g_hash_table_remove_all (self->unlocked_apps);
G_OBJECT_CLASS (gkm_gnome2_module_parent_class)->dispose (obj);
}
static void
gkm_gnome2_module_finalize (GObject *obj)
{
GkmGnome2Module *self = GKM_GNOME2_MODULE (obj);
g_assert (self->storage == NULL);
g_assert (self->unlocked_apps);
g_hash_table_destroy (self->unlocked_apps);
self->unlocked_apps = NULL;
g_free (self->directory);
self->directory = NULL;
G_OBJECT_CLASS (gkm_gnome2_module_parent_class)->finalize (obj);
}
static void
gkm_gnome2_module_class_init (GkmGnome2ModuleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GkmModuleClass *module_class = GKM_MODULE_CLASS (klass);
gobject_class->constructor = gkm_gnome2_module_constructor;
gobject_class->dispose = gkm_gnome2_module_dispose;
gobject_class->finalize = gkm_gnome2_module_finalize;
module_class->get_slot_info = gkm_gnome2_module_real_get_slot_info;
module_class->get_token_info = gkm_gnome2_module_real_get_token_info;
module_class->parse_argument = gkm_gnome2_module_real_parse_argument;
module_class->refresh_token = gkm_gnome2_module_real_refresh_token;
module_class->add_token_object = gkm_gnome2_module_real_add_token_object;
module_class->store_token_object = gkm_gnome2_module_real_store_token_object;
module_class->remove_token_object = gkm_gnome2_module_real_remove_token_object;
module_class->login_user = gkm_gnome2_module_real_login_user;
module_class->login_so = gkm_gnome2_module_real_login_so;
module_class->logout_user = gkm_gnome2_module_real_logout_user;
module_class->login_change = gkm_gnome2_module_real_login_change;
}
/* ----------------------------------------------------------------------------
* PUBLIC
*/
CK_FUNCTION_LIST_PTR
gkm_gnome2_store_get_functions (void)
{
gkm_crypto_initialize ();
return gkm_gnome2_module_function_list;
}
GkmModule *
_gkm_gnome2_store_get_module_for_testing (void)
{
return pkcs11_module;
}