/*
* 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-private-key.h"
#include "gkm/gkm-attributes.h"
#include "gkm/gkm-crypto.h"
#include "gkm/gkm-data-der.h"
#include "gkm/gkm-factory.h"
#include "gkm/gkm-manager.h"
#include "gkm/gkm-object.h"
#include "gkm/gkm-secret.h"
#include "gkm/gkm-serializable.h"
#include "gkm/gkm-session.h"
#include "gkm/gkm-sexp.h"
#include "gkm/gkm-util.h"
#include "egg/egg-secure-memory.h"
#include
enum {
PROP_0,
};
struct _GkmGnome2PrivateKey {
GkmPrivateXsaKey parent;
GBytes *private_bytes;
GkmSexp *private_sexp;
gboolean is_encrypted;
GkmSecret *login;
};
static void gkm_gnome2_private_key_serializable (GkmSerializableIface *iface);
G_DEFINE_TYPE_EXTENDED (GkmGnome2PrivateKey, gkm_gnome2_private_key, GKM_TYPE_PRIVATE_XSA_KEY, 0,
G_IMPLEMENT_INTERFACE (GKM_TYPE_SERIALIZABLE, gkm_gnome2_private_key_serializable));
/* -----------------------------------------------------------------------------
* INTERNAL
*/
static GkmObject*
factory_create_private_key (GkmSession *session, GkmTransaction *transaction,
CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
GkmGnome2PrivateKey *key;
GkmSexp *sexp;
g_return_val_if_fail (attrs || !n_attrs, NULL);
sexp = gkm_private_xsa_key_create_sexp (session, transaction, attrs, n_attrs);
if (sexp == NULL)
return NULL;
key = g_object_new (GKM_TYPE_GNOME2_PRIVATE_KEY, "base-sexp", sexp,
"module", gkm_session_get_module (session),
"manager", gkm_manager_for_template (attrs, n_attrs, session),
NULL);
g_return_val_if_fail (!key->private_sexp, NULL);
key->private_sexp = gkm_sexp_ref (sexp);
gkm_sexp_unref (sexp);
/* TODO: We don't support setting these yet, so ignore them */
gkm_attributes_consume (attrs, n_attrs,
CKA_SIGN_RECOVER, CKA_UNWRAP, CKA_ID,
G_MAXULONG);
gkm_session_complete_object_creation (session, transaction, GKM_OBJECT (key),
TRUE, attrs, n_attrs);
return GKM_OBJECT (key);
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static CK_RV
gkm_gnome2_private_key_real_get_attribute (GkmObject *base, GkmSession *session, CK_ATTRIBUTE_PTR attr)
{
switch (attr->type) {
case CKA_ALWAYS_AUTHENTICATE:
return gkm_attribute_set_bool (attr, FALSE);
}
return GKM_OBJECT_CLASS (gkm_gnome2_private_key_parent_class)->get_attribute (base, session, attr);
}
static GkmSexp*
gkm_gnome2_private_key_real_acquire_crypto_sexp (GkmSexpKey *base, GkmSession *unused)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (base);
gcry_sexp_t sexp;
GkmDataResult res;
const gchar *password;
gsize n_password;
/* Non encrypted case */
if (self->private_sexp)
return gkm_sexp_ref (self->private_sexp);
g_return_val_if_fail (self->login, NULL);
g_return_val_if_fail (self->is_encrypted, NULL);
password = gkm_secret_get_password (self->login, &n_password);
res = gkm_data_der_read_private_pkcs8 (self->private_bytes, password, n_password, &sexp);
g_return_val_if_fail (res == GKM_DATA_SUCCESS, NULL);
return gkm_sexp_new (sexp);
}
static void
gkm_gnome2_private_key_init (GkmGnome2PrivateKey *self)
{
}
static void
gkm_gnome2_private_key_dispose (GObject *obj)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (obj);
if (self->login)
g_object_unref (self->login);
self->login = NULL;
G_OBJECT_CLASS (gkm_gnome2_private_key_parent_class)->dispose (obj);
}
static void
gkm_gnome2_private_key_finalize (GObject *obj)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (obj);
g_assert (self->login == NULL);
if (self->private_bytes)
g_bytes_unref (self->private_bytes);
if (self->private_sexp)
gkm_sexp_unref (self->private_sexp);
self->private_sexp = NULL;
G_OBJECT_CLASS (gkm_gnome2_private_key_parent_class)->finalize (obj);
}
static void
gkm_gnome2_private_key_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_gnome2_private_key_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_gnome2_private_key_class_init (GkmGnome2PrivateKeyClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GkmObjectClass *gkm_class = GKM_OBJECT_CLASS (klass);
GkmSexpKeyClass *key_class = GKM_SEXP_KEY_CLASS (klass);
gobject_class->dispose = gkm_gnome2_private_key_dispose;
gobject_class->finalize = gkm_gnome2_private_key_finalize;
gobject_class->set_property = gkm_gnome2_private_key_set_property;
gobject_class->get_property = gkm_gnome2_private_key_get_property;
gkm_class->get_attribute = gkm_gnome2_private_key_real_get_attribute;
key_class->acquire_crypto_sexp = gkm_gnome2_private_key_real_acquire_crypto_sexp;
}
static gboolean
gkm_gnome2_private_key_real_load (GkmSerializable *base,
GkmSecret *login,
GBytes *data)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (base);
GkmDataResult res;
gcry_sexp_t sexp, pub;
GkmSexp *wrapper;
const gchar *password;
gsize n_password;
if (g_bytes_get_size (data) == 0)
return FALSE;
res = gkm_data_der_read_private_pkcs8 (data, NULL, 0, &sexp);
/* An unencrypted pkcs8 file */
if (res == GKM_DATA_SUCCESS) {
self->is_encrypted = FALSE;
/* If it's locked, then use our token password */
} else if (res == GKM_DATA_LOCKED) {
self->is_encrypted = TRUE;
if (!login) {
g_message ("encountered private key but no private key present");
return FALSE;
}
password = gkm_secret_get_password (login, &n_password);
res = gkm_data_der_read_private_pkcs8 (data, password, n_password, &sexp);
}
switch (res) {
case GKM_DATA_LOCKED:
g_message ("private key is encrypted with wrong password");
return FALSE;
case GKM_DATA_FAILURE:
g_message ("couldn't parse private key");
return FALSE;
case GKM_DATA_UNRECOGNIZED:
g_message ("invalid or unrecognized private key");
return FALSE;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached();
}
/* Calculate a public key as our 'base' */
if (!gkm_sexp_key_to_public (sexp, &pub))
g_return_val_if_reached (FALSE);
/* Keep the public part of the key around for answering queries */
wrapper = gkm_sexp_new (pub);
gkm_sexp_key_set_base (GKM_SEXP_KEY (self), wrapper);
gkm_sexp_unref (wrapper);
/* Encrypted private key, keep login and data */
if (self->is_encrypted) {
if (self->private_bytes)
g_bytes_unref (self->private_bytes);
self->private_bytes = g_bytes_ref (data);
g_object_ref (login);
if (self->login)
g_object_unref (self->login);
self->login = login;
/* Don't need the private key any more */
gcry_sexp_release (sexp);
/* Not encrypted, just keep the parsed key */
} else {
wrapper = gkm_sexp_new (sexp);
if (self->private_sexp)
gkm_sexp_unref (self->private_sexp);
self->private_sexp = wrapper;
if (self->login)
g_object_unref (login);
self->login = NULL;
}
return TRUE;
}
static GBytes *
gkm_gnome2_private_key_real_save (GkmSerializable *base, GkmSecret *login)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (base);
const gchar *password = NULL;
gsize n_password;
GkmSexp *sexp;
GBytes *result;
g_return_val_if_fail (GKM_IS_GNOME2_PRIVATE_KEY (self), FALSE);
sexp = gkm_gnome2_private_key_real_acquire_crypto_sexp (GKM_SEXP_KEY (self), NULL);
g_return_val_if_fail (sexp, FALSE);
if (login != NULL)
password = gkm_secret_get_password (login, &n_password);
if (password == NULL) {
result = gkm_data_der_write_private_pkcs8_plain (gkm_sexp_get (sexp));
} else {
result = gkm_data_der_write_private_pkcs8_crypted (gkm_sexp_get (sexp), password,
n_password);
}
gkm_sexp_unref (sexp);
return result;
}
static void
gkm_gnome2_private_key_serializable (GkmSerializableIface *iface)
{
iface->extension = ".pkcs8";
iface->load = gkm_gnome2_private_key_real_load;
iface->save = gkm_gnome2_private_key_real_save;
}
/* -----------------------------------------------------------------------------
* PUBLIC
*/
GkmFactory*
gkm_gnome2_private_key_get_factory (void)
{
static CK_OBJECT_CLASS klass = CKO_PRIVATE_KEY;
static CK_BBOOL token = CK_TRUE;
static CK_ATTRIBUTE attributes[] = {
{ CKA_CLASS, &klass, sizeof (klass) },
{ CKA_TOKEN, &token, sizeof (token) },
};
static GkmFactory factory = {
attributes,
G_N_ELEMENTS (attributes),
factory_create_private_key
};
return &factory;
}