/*
* gnome-keyring
*
* Copyright (C) 2010 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-wrap-login.h"
#include "gkm-wrap-prompt.h"
#include "egg/egg-error.h"
#include "egg/egg-secure-memory.h"
#include "gkm/gkm-attributes.h"
#include "gkm/gkm-log.h"
#include "gkm/gkm-util.h"
#include "pkcs11/pkcs11.h"
#include "pkcs11/pkcs11i.h"
#include
#include
#include
EGG_SECURE_DECLARE (wrap_prompt);
#define GKM_TYPE_WRAP_PROMPT (gkm_wrap_prompt_get_type ())
#define GKM_WRAP_PROMPT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GKM_TYPE_WRAP_PROMPT, GkmWrapPrompt))
#define GKM_WRAP_PROMPT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GKM_TYPE_WRAP_PROMPT, GkmWrapPromptClass))
#define GKM_IS_WRAP_PROMPT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GKM_TYPE_WRAP_PROMPT))
#define GKM_IS_WRAP_PROMPT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GKM_TYPE_WRAP_PROMPT))
#define GKM_WRAP_PROMPT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GKM_TYPE_WRAP_PROMPT, GkmWrapPromptClass))
GType gkm_wrap_prompt_get_type (void);
typedef struct _GkmWrapPromptClass GkmWrapPromptClass;
struct _GkmWrapPromptClass {
GcrSystemPromptClass parent_class;
};
struct _GkmWrapPrompt {
GcrSystemPrompt parent;
gboolean initialized;
CK_FUNCTION_LIST_PTR module;
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
gpointer prompt_data;
GDestroyNotify destroy_data;
guint iteration;
GQueue pool;
};
G_DEFINE_TYPE (GkmWrapPrompt, gkm_wrap_prompt, GCR_TYPE_SYSTEM_PROMPT);
static const gchar *the_prompter_name = NULL;
/* -----------------------------------------------------------------------------
* UTILITIES
*/
static gpointer
pool_alloc (GkmWrapPrompt *self, gsize length)
{
gpointer memory = g_malloc0 (length);
g_assert (GKM_IS_WRAP_PROMPT (self));
g_queue_push_tail (&self->pool, memory);
return memory;
}
static gpointer
pool_dup (GkmWrapPrompt *self, gconstpointer original, gsize length)
{
gpointer memory = pool_alloc (self, length);
memcpy (memory, original, length);
return memory;
}
/* -----------------------------------------------------------------------------
* AUTO UNLOCK
*/
static gboolean
is_login_keyring (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
gboolean is_login = FALSE;
if (!gkm_attributes_find_boolean (attrs, n_attrs, CKA_G_LOGIN_COLLECTION, &is_login))
return FALSE;
return is_login;
}
static gchar*
auto_unlock_keyring_location (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
CK_ATTRIBUTE_PTR attr;
if (is_login_keyring (attrs, n_attrs))
return NULL;
attr = gkm_attributes_find (attrs, n_attrs, CKA_ID);
if (attr == NULL)
return NULL;
/*
* COMPAT: Format it into a string. This is done this way for compatibility
* with old gnome-keyring releases. In the future this may change.
*/
return g_strdup_printf ("LOCAL:/keyrings/%s.keyring", (gchar*)attr->pValue);
}
static gchar*
auto_unlock_object_unique (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
CK_ATTRIBUTE_PTR attr;
attr = gkm_attributes_find (attrs, n_attrs, CKA_GNOME_UNIQUE);
if (attr == NULL)
return NULL;
return g_strndup (attr->pValue, attr->ulValueLen);
}
static void
convert_upper_case (gchar *str)
{
for (; *str; ++str)
*str = g_ascii_toupper (*str);
}
static gchar*
auto_unlock_object_digest (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
CK_ATTRIBUTE_PTR attr;
gchar *result;
attr = gkm_attributes_find (attrs, n_attrs, CKA_GNOME_INTERNAL_SHA1);
if (attr == NULL)
return NULL;
result = g_strndup (attr->pValue, attr->ulValueLen);
convert_upper_case (result);
return result;
}
static gchar*
auto_unlock_lookup_keyring (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
gchar *location;
gchar *password;
location = auto_unlock_keyring_location (attrs, n_attrs);
if (location == NULL)
return NULL;
password = gkm_wrap_login_lookup_secret ("keyring", location, NULL);
g_free (location);
return password;
}
static gchar*
auto_unlock_lookup_object (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
CK_OBJECT_CLASS klass;
gchar *value;
gchar *password;
if (!gkm_attributes_find_ulong (attrs, n_attrs, CKA_CLASS, &klass))
return NULL;
if (klass == CKO_G_COLLECTION)
return auto_unlock_lookup_keyring (attrs, n_attrs);
value = auto_unlock_object_unique (attrs, n_attrs);
if (value != NULL) {
password = gkm_wrap_login_lookup_secret ("unique", value, NULL);
g_free (value);
if (password)
return password;
}
/* COMPAT: Check old method of storing secrets for objects in login keyring */
value = auto_unlock_object_digest (attrs, n_attrs);
if (value != NULL) {
password = gkm_wrap_login_lookup_secret ("object-digest", value, NULL);
g_free (value);
if (password)
return password;
}
return NULL;
}
static gchar*
auto_unlock_lookup_token (CK_TOKEN_INFO_PTR info)
{
gchar *password = NULL;
gchar *manufacturer;
gchar *serial;
g_assert (info);
manufacturer = g_strndup ((gchar*)info->manufacturerID, sizeof (info->manufacturerID));
g_strchomp (manufacturer);
serial = g_strndup ((gchar*)info->serialNumber, sizeof (info->serialNumber));
g_strchomp (serial);
if (!g_str_equal (manufacturer, "") && !g_str_equal (serial, ""))
password = gkm_wrap_login_lookup_secret ("manufacturer", manufacturer,
"serial-number", serial,
NULL);
g_free (manufacturer);
g_free (serial);
return password;
}
static gboolean
auto_unlock_should_attach (GkmWrapPrompt *self)
{
return gcr_prompt_get_choice_chosen (GCR_PROMPT (self));
}
static void
auto_unlock_attach_keyring (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, const gchar *password)
{
gchar *location;
gchar *label;
if (!password)
return;
location = auto_unlock_keyring_location (attrs, n_attrs);
if (location == NULL)
return;
if (!gkm_attributes_find_string (attrs, n_attrs, CKA_LABEL, &label))
if (!gkm_attributes_find_string (attrs, n_attrs, CKA_ID, &label))
label = g_strdup (location);
gkm_wrap_login_attach_secret (label, password, "keyring", location, NULL);
g_free (location);
g_free (label);
}
static void
auto_unlock_attach_object (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, const gchar *password)
{
CK_OBJECT_CLASS klass;
gchar *label;
gchar *unique;
if (!password)
return;
if (!gkm_attributes_find_ulong (attrs, n_attrs, CKA_CLASS, &klass))
return;
if (klass == CKO_G_COLLECTION) {
auto_unlock_attach_keyring (attrs, n_attrs, password);
return;
}
unique = auto_unlock_object_unique (attrs, n_attrs);
if (unique == NULL)
return;
if (!gkm_attributes_find_string (attrs, n_attrs, CKA_LABEL, &label))
label = g_strdup (unique);
gkm_wrap_login_attach_secret (label, password, "unique", unique, NULL);
g_free (unique);
g_free (label);
}
static void
auto_unlock_attach_token (CK_TOKEN_INFO_PTR info, const gchar *password)
{
gchar *manufacturer;
gchar *serial;
gchar *label;
g_assert (info);
if (!password)
return;
manufacturer = g_strndup ((gchar*)info->manufacturerID, sizeof (info->manufacturerID));
g_strchomp (manufacturer);
serial = g_strndup ((gchar*)info->serialNumber, sizeof (info->serialNumber));
g_strchomp (serial);
label = g_strndup ((gchar*)info->label, sizeof (info->label));
g_strchomp (label);
if (g_str_equal (label, "")) {
g_free (label);
label = g_strdup (manufacturer);
}
if (!g_str_equal (manufacturer, "") && !g_str_equal (serial, ""))
gkm_wrap_login_attach_secret (label, password,
"manufacturer", manufacturer,
"serial-number", serial,
NULL);
g_free (manufacturer);
g_free (serial);
g_free (label);
}
static void
auto_unlock_remove_keyring (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
gchar *location;
location = auto_unlock_keyring_location (attrs, n_attrs);
if (location == NULL)
return;
gkm_wrap_login_remove_secret ("keyring", location, NULL);
g_free (location);
}
static void
auto_unlock_remove_object (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
CK_OBJECT_CLASS klass;
gchar *value;
if (!gkm_attributes_find_ulong (attrs, n_attrs, CKA_CLASS, &klass))
return;
if (klass == CKO_G_COLLECTION) {
auto_unlock_remove_keyring (attrs, n_attrs);
return;
}
value = auto_unlock_object_unique (attrs, n_attrs);
if (value != NULL) {
gkm_wrap_login_remove_secret ("unique", value, NULL);
g_free (value);
}
/* COMPAT: Clear old method of storing secrets for objects in login keyring */
value = auto_unlock_object_digest (attrs, n_attrs);
if (value != NULL) {
gkm_wrap_login_remove_secret ("object-digest", value, NULL);
g_free (value);
}
}
static void
auto_unlock_remove_token (CK_TOKEN_INFO_PTR info)
{
gchar *manufacturer;
gchar *serial;
g_assert (info);
manufacturer = g_strndup ((gchar*)info->manufacturerID, sizeof (info->manufacturerID));
g_strchomp (manufacturer);
serial = g_strndup ((gchar*)info->serialNumber, sizeof (info->serialNumber));
g_strchomp (serial);
if (!g_str_equal (manufacturer, "") && !g_str_equal (serial, ""))
gkm_wrap_login_remove_secret ("manufacturer", manufacturer,
"serial-number", serial,
NULL);
g_free (manufacturer);
g_free (serial);
}
/* -----------------------------------------------------------------------------------------
* PROMPTING
*/
static void
set_unlock_options_on_object (GkmWrapPrompt *self, CK_ATTRIBUTE_PTR options, CK_ULONG n_options)
{
CK_ATTRIBUTE attr;
CK_RV rv;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->module);
g_assert (options);
attr.type = CKA_G_CREDENTIAL_TEMPLATE;
attr.pValue = options;
attr.ulValueLen = sizeof (CK_ATTRIBUTE) * n_options;
rv = (self->module->C_SetAttributeValue) (self->session, self->object, &attr, 1);
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID) {
if (rv != CKR_TOKEN_WRITE_PROTECTED)
g_warning ("Couldn't set credential template for prompt: %s",
gkm_log_rv (rv));
}
}
static CK_ATTRIBUTE_PTR
get_unlock_options_from_prompt (GkmWrapPrompt *self, CK_ULONG_PTR n_options)
{
CK_ATTRIBUTE_PTR options;
CK_BBOOL bval;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (n_options);
*n_options = 2;
options = pool_alloc (self, sizeof (CK_ATTRIBUTE) * (*n_options));
/* CKA_TOKEN */
bval = TRUE;
options[0].type = CKA_TOKEN;
options[0].pValue = pool_dup (self, &bval, sizeof (bval));
options[0].ulValueLen = sizeof (bval);
/* CKA_GNOME_TRANSIENT */
bval = TRUE;
options[1].type = CKA_GNOME_TRANSIENT;
options[1].pValue = pool_dup (self, &bval, sizeof (bval));
options[1].ulValueLen = sizeof (bval);
return options;
}
static void
set_unlock_options_on_prompt (GkmWrapPrompt *self)
{
gboolean chosen = FALSE;
g_assert (GKM_IS_WRAP_PROMPT (self));
gcr_prompt_set_choice_chosen (GCR_PROMPT (self), chosen);
}
static CK_ATTRIBUTE_PTR
get_attributes_from_object (GkmWrapPrompt *self, CK_ULONG *n_attrs)
{
CK_ATTRIBUTE attrs[6];
CK_ULONG i;
CK_RV rv;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (n_attrs);
g_assert (self->module);
memset (attrs, 0, sizeof (attrs));
attrs[0].type = CKA_LABEL;
attrs[1].type = CKA_ID;
attrs[2].type = CKA_CLASS;
attrs[3].type = CKA_G_LOGIN_COLLECTION;
attrs[4].type = CKA_GNOME_UNIQUE;
attrs[5].type = CKA_GNOME_INTERNAL_SHA1;
rv = (self->module->C_GetAttributeValue) (self->session, self->object, attrs, G_N_ELEMENTS (attrs));
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID) {
g_warning ("Couldn't retrieve information about object to unlock: %s",
gkm_log_rv (rv));
return NULL;
}
/* Allocate for each value, note we're null terminating values */
for (i = 0; i < G_N_ELEMENTS (attrs); ++i) {
if (attrs[i].ulValueLen != (CK_ULONG)-1)
attrs[i].pValue = pool_alloc (self, attrs[i].ulValueLen + 1);
}
/* Now get the actual values */
rv = (self->module->C_GetAttributeValue) (self->session, self->object, attrs, G_N_ELEMENTS (attrs));
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID) {
g_warning ("couldn't retrieve credential template for prompt: %s",
gkm_log_rv (rv));
return NULL;
}
*n_attrs = G_N_ELEMENTS (attrs);
return pool_dup (self, attrs, sizeof (attrs));
}
static gboolean
get_info_for_token (GkmWrapPrompt *self, CK_TOKEN_INFO_PTR tinfo)
{
CK_SESSION_INFO sinfo;
return (self->module->C_GetSessionInfo) (self->session, &sinfo) == CKR_OK &&
(self->module->C_GetTokenInfo) (sinfo.slotID, tinfo) == CKR_OK;
}
static void
setup_unlock_keyring_login (GkmWrapPrompt *self)
{
GcrPrompt *prompt;
const gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
prompt = GCR_PROMPT (self);
gcr_prompt_set_title (prompt, _("Unlock Login Keyring"));
gcr_prompt_set_message (prompt, _("Authentication required"));
if (gkm_wrap_login_did_unlock_fail ())
text = _("The password you use to log in to your computer no longer matches that of your login keyring.");
else
text = _("The login keyring did not get unlocked when you logged into your computer.");
gcr_prompt_set_description (prompt, text);
gcr_prompt_set_choice_label (prompt, NULL);
gcr_prompt_set_continue_label (prompt, _("Unlock"));
}
static void
setup_unlock_keyring_other (GkmWrapPrompt *self,
const gchar *label)
{
GcrPrompt *prompt;
const gchar *choice;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
prompt = GCR_PROMPT (self);
gcr_prompt_set_title (prompt, _("Unlock Keyring"));
gcr_prompt_set_message (prompt, _("Authentication required"));
text = g_markup_printf_escaped (_("An application wants access to the keyring “%s”, but it is locked"), label);
gcr_prompt_set_description (prompt, text);
g_free (text);
choice = NULL;
if (gkm_wrap_login_is_usable ())
choice = _("Automatically unlock this keyring whenever I’m logged in");
gcr_prompt_set_choice_label (prompt, choice);
gcr_prompt_set_continue_label (prompt, _("Unlock"));
}
static const gchar*
calc_unlock_object_title (CK_OBJECT_CLASS klass)
{
switch (klass) {
case CKO_PRIVATE_KEY:
return _("Unlock private key");
case CKO_CERTIFICATE:
return _("Unlock certificate");
case CKO_PUBLIC_KEY:
return _("Unlock public key");
default:
return _("Unlock");
}
}
static const gchar *
calc_unlock_object_choice (CK_OBJECT_CLASS klass)
{
switch (klass) {
case CKO_PRIVATE_KEY:
case CKO_PUBLIC_KEY:
return _("Automatically unlock this key whenever I’m logged in");
case CKO_CERTIFICATE:
return _("Automatically unlock this certificate whenever I’m logged in");
default:
return _("Automatically unlock whenever I’m logged in");
}
}
static gchar*
calc_unlock_object_secondary (CK_OBJECT_CLASS klass,
const gchar *label)
{
switch (klass) {
case CKO_PRIVATE_KEY:
/* TRANSLATORS: The private key is locked */
return g_strdup_printf (_("An application wants access to the private key “%s”, but it is locked"), label);
case CKO_CERTIFICATE:
/* TRANSLATORS: The certificate is locked */
return g_strdup_printf (_("An application wants access to the certificate “%s”, but it is locked"), label);
case CKO_PUBLIC_KEY:
/* TRANSLATORS: The public key is locked */
return g_strdup_printf (_("An application wants access to the public key “%s”, but it is locked"), label);
default:
/* TRANSLATORS: The object '%s' is locked */
return g_strdup_printf (_("An application wants access to “%s”, but it is locked"), label);
}
}
static void
setup_unlock_object (GkmWrapPrompt *self,
const gchar *label,
CK_OBJECT_CLASS klass)
{
GcrPrompt *prompt;
const gchar *choice;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
prompt = GCR_PROMPT (self);
gcr_prompt_set_title (prompt, calc_unlock_object_title (klass));
gcr_prompt_set_message (prompt, _("Authentication required"));
text = calc_unlock_object_secondary (klass, label);
gcr_prompt_set_description (prompt, text);
g_free (text);
choice = NULL;
if (gkm_wrap_login_is_usable ())
choice = calc_unlock_object_choice (klass);
gcr_prompt_set_choice_label (prompt, choice);
gcr_prompt_set_continue_label (prompt, _("Unlock"));
}
static void
setup_unlock_prompt (GkmWrapPrompt *self,
CK_ATTRIBUTE_PTR attrs,
CK_ULONG n_attrs,
gboolean first)
{
CK_ATTRIBUTE_PTR attr;
GcrPrompt *prompt;
const gchar *label = NULL;
CK_OBJECT_CLASS klass;
g_assert (GKM_IS_WRAP_PROMPT (self));
prompt = GCR_PROMPT (self);
/* Load up the object class */
if (!gkm_attributes_find_ulong (attrs, n_attrs, CKA_CLASS, &klass))
klass = (CK_ULONG)-1;
/* Load up its label */
attr = gkm_attributes_find (attrs, n_attrs, CKA_LABEL);
if (attr != NULL)
label = attr->pValue;
/* Load up the identifier */
attr = gkm_attributes_find (attrs, n_attrs, CKA_ID);
if (attr != NULL && !label)
label = attr->pValue;
if (!label)
label = _("Unnamed");
if (klass == CKO_G_COLLECTION) {
if (is_login_keyring (attrs, n_attrs))
setup_unlock_keyring_login (self);
else
setup_unlock_keyring_other (self, label);
} else {
setup_unlock_object (self, label, klass);
}
if (!first)
gcr_prompt_set_warning (prompt, _("The unlock password was incorrect"));
gcr_prompt_set_continue_label (prompt, _("Unlock"));
}
static void
setup_unlock_token (GkmWrapPrompt *self,
CK_TOKEN_INFO_PTR tinfo)
{
GcrPrompt *prompt;
const gchar *choice;
gchar *label;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
prompt = GCR_PROMPT (self);
label = g_strndup ((gchar*)tinfo->label, sizeof (tinfo->label));
g_strchomp (label);
/* Build up the prompt */
gcr_prompt_set_title (prompt, _("Unlock certificate/key storage"));
gcr_prompt_set_message (prompt, _("Authentication required"));
/* TRANSLATORS: The storage is locked, and needs unlocking before the application can use it. */
text = g_strdup_printf (_("An application wants access to the certificate/key storage “%s”, but it is locked"), label);
gcr_prompt_set_description (prompt, text);
g_free (text);
choice = NULL;
if (gkm_wrap_login_is_usable ())
choice = _("Automatically unlock whenever I’m logged in");
gcr_prompt_set_choice_label (prompt, choice);
gcr_prompt_set_continue_label (prompt, _("Unlock"));
g_free (label);
}
static void
fix_login_keyring_if_unlock_failed (GkmWrapPrompt *self, const gchar *password)
{
CK_OBJECT_CLASS klass = CKO_G_CREDENTIAL;
CK_OBJECT_HANDLE cred;
CK_BBOOL tval = CK_TRUE;
CK_ATTRIBUTE attrs[4];
gchar *failed;
CK_RV rv;
failed = gkm_wrap_login_steal_failed_password ();
/* Do we have a failed unlock password? */
if (!failed || !failed[0]) {
egg_secure_strfree (failed);
return;
}
attrs[0].type = CKA_CLASS;
attrs[0].pValue = &klass;
attrs[0].ulValueLen = sizeof (klass);
attrs[1].type = CKA_VALUE;
attrs[1].pValue = failed;
attrs[1].ulValueLen = strlen (failed);
attrs[2].type = CKA_GNOME_TRANSIENT;
attrs[2].pValue = &tval;
attrs[2].ulValueLen = sizeof (tval);
attrs[3].type = CKA_TOKEN;
attrs[3].pValue = &tval;
attrs[3].ulValueLen = sizeof (tval);
/* Create a credential object for the failed password */
rv = (self->module->C_CreateObject) (self->session, attrs, G_N_ELEMENTS (attrs), &cred);
egg_secure_strfree (failed);
if (rv != CKR_OK) {
g_warning ("couldn't create credential to fix login password: %s",
gkm_log_rv (rv));
return;
}
attrs[0].type = CKA_G_CREDENTIAL;
attrs[0].pValue = &cred;
attrs[0].ulValueLen = sizeof (cred);
/* Set the credential on the object */
rv = (self->module->C_SetAttributeValue) (self->session, self->object, attrs, 1);
if (rv != CKR_OK) {
g_warning ("couldn't change credential to fix login keyring password: %s",
gkm_log_rv (rv));
return;
}
g_message ("fixed login keyring password to match login password");
}
static gboolean
gkm_wrap_prompt_prepare (GkmWrapPrompt *self)
{
GError *error = NULL;
if (!self->initialized) {
if (!g_initable_init (G_INITABLE (self), NULL, &error)) {
g_warning ("couldn't create system prompt: %s", egg_error_message (error));
g_error_free (error);
return FALSE;
}
self->initialized = TRUE;
}
return TRUE;
}
static const gchar *
gkm_wrap_prompt_request_password (GkmWrapPrompt *self)
{
GError *error = NULL;
const gchar *password;
g_assert (GKM_IS_WRAP_PROMPT (self));
if (!gkm_wrap_prompt_prepare (self))
return NULL;
password = gcr_prompt_password (GCR_PROMPT (self), NULL, &error);
if (error != NULL) {
g_warning ("couldn't prompt for password: %s", egg_error_message (error));
g_error_free (error);
}
return password;
}
static void
gkm_wrap_prompt_init (GkmWrapPrompt *self)
{
g_queue_init (&self->pool);
}
static void
gkm_wrap_prompt_clear_prompt_data (GkmWrapPrompt *self)
{
if (self->destroy_data && self->prompt_data)
(self->destroy_data) (self->prompt_data);
self->destroy_data = NULL;
self->prompt_data = NULL;
}
static void
gkm_wrap_prompt_set_prompt_data (GkmWrapPrompt *self,
gpointer prompt_data,
GDestroyNotify destroy_data)
{
gkm_wrap_prompt_clear_prompt_data (self);
self->destroy_data = destroy_data;
self->prompt_data = prompt_data;
}
static void
gkm_wrap_prompt_finalize (GObject *obj)
{
GkmWrapPrompt *self = GKM_WRAP_PROMPT (obj);
gkm_wrap_prompt_clear_prompt_data (self);
while (!g_queue_is_empty(&self->pool))
g_free (g_queue_pop_head (&self->pool));
G_OBJECT_CLASS (gkm_wrap_prompt_parent_class)->finalize (obj);
}
static void
gkm_wrap_prompt_class_init (GkmWrapPromptClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = gkm_wrap_prompt_finalize;
}
/* -----------------------------------------------------------------------------
* CREDENTIAL
*/
typedef struct _CredentialPrompt {
GArray *template;
CK_ULONG n_template;
gchar *password;
} CredentialPrompt;
static void
credential_prompt_free (gpointer user_data)
{
CredentialPrompt *data = user_data;
g_array_free (data->template, TRUE);
egg_secure_strfree (data->password);
g_slice_free (CredentialPrompt, data);
}
GkmWrapPrompt*
gkm_wrap_prompt_for_credential (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session,
CK_ATTRIBUTE_PTR template, CK_ULONG n_template)
{
CredentialPrompt *data;
CK_ATTRIBUTE_PTR attr;
CK_OBJECT_CLASS klass;
CK_OBJECT_HANDLE object;
GkmWrapPrompt *self;
CK_ULONG i;
g_return_val_if_fail (module, NULL);
g_return_val_if_fail (session, NULL);
g_return_val_if_fail (n_template || !template, NULL);
/* Must be credential and have object for protected outh path */
if (!gkm_attributes_find_ulong (template, n_template, CKA_CLASS, &klass) ||
!gkm_attributes_find_ulong (template, n_template, CKA_G_OBJECT, &object) ||
klass != CKO_G_CREDENTIAL || object == 0)
return NULL;
/* Must have CKA_VALUE with pValue set to null for protected auth path */
attr = gkm_attributes_find (template, n_template, CKA_VALUE);
if (attr == NULL || attr->pValue != NULL)
return NULL;
self = g_object_new (GKM_TYPE_WRAP_PROMPT,
"timeout-seconds", -1,
"bus-name", gkm_wrap_prompt_get_prompter_name (),
NULL);
/* Build up the prompt */
data = g_slice_new0 (CredentialPrompt);
gkm_wrap_prompt_set_prompt_data (self, data, credential_prompt_free);
self->module = module;
self->session = session;
self->object = object;
/* Build up a copy of the template with CKA_VALUE first */
data->template = g_array_new (FALSE, FALSE, sizeof (CK_ATTRIBUTE));
g_array_append_val (data->template, *attr);
for (i = 0; i < n_template; ++i) {
if (template[i].type != CKA_VALUE)
g_array_append_val (data->template, template[i]);
}
data->n_template = n_template;
return self;
}
gboolean
gkm_wrap_prompt_do_credential (GkmWrapPrompt *self, CK_ATTRIBUTE_PTR *template,
CK_ULONG *n_template)
{
CK_ATTRIBUTE_PTR options;
CK_ATTRIBUTE_PTR attrs;
CK_ATTRIBUTE_PTR attr;
CK_ULONG n_attrs, n_options, i;
CredentialPrompt *data;
GError *error = NULL;
g_return_val_if_fail (GKM_IS_WRAP_PROMPT (self), FALSE);
g_return_val_if_fail (template, FALSE);
g_return_val_if_fail (n_template, FALSE);
g_assert (self->destroy_data == credential_prompt_free);
data = self->prompt_data;
attrs = get_attributes_from_object (self, &n_attrs);
g_return_val_if_fail (attrs, FALSE);
egg_secure_strfree (data->password);
data->password = NULL;
if (self->iteration == 0) {
++(self->iteration);
data->password = auto_unlock_lookup_object (attrs, n_attrs);
} else if (self->iteration == 1) {
auto_unlock_remove_object (attrs, n_attrs);
}
if (!data->password) {
const char *password;
setup_unlock_prompt (self, attrs, n_attrs, self->iteration == 1);
/* Now load up the unlock options into the prompt*/
if (self->iteration == 1)
set_unlock_options_on_prompt (self);
++(self->iteration);
password = gkm_wrap_prompt_request_password (self);
if (password == NULL) {
if (error != NULL) {
g_warning ("couldn't prompt for password: %s", egg_error_message (error));
g_error_free (error);
}
return FALSE;
}
data->password = egg_secure_strdup (password);
}
/* Truncate any extra options off the end of template */
g_assert (data->n_template > 0);
g_assert (data->template->len >= data->n_template);
g_array_set_size (data->template, data->n_template);
/* Put the password into the template, always first */
attr = &g_array_index (data->template, CK_ATTRIBUTE, 0);
g_assert (attr->type == CKA_VALUE);
attr->pValue = (gpointer)data->password;
attr->ulValueLen = strlen (data->password);
/* Tag any options onto the end of template */
options = get_unlock_options_from_prompt (self, &n_options);
for (i = 0; options && i < n_options; ++i)
g_array_append_val (data->template, options[i]);
*template = (CK_ATTRIBUTE_PTR)data->template->data;
*n_template = data->template->len;
return TRUE;
}
void
gkm_wrap_prompt_done_credential (GkmWrapPrompt *self, CK_RV call_result)
{
CK_ATTRIBUTE_PTR options;
CK_ATTRIBUTE_PTR attrs;
CK_ULONG n_options, n_attrs;
CredentialPrompt *data;
g_return_if_fail (GKM_IS_WRAP_PROMPT (self));
g_assert (self->destroy_data == credential_prompt_free);
data = self->prompt_data;
/* Save the options, and possibly auto unlock */
if (call_result == CKR_OK) {
attrs = get_attributes_from_object (self, &n_attrs);
/*
* For the login keyring, we check for a previous unlock failure,
* that would have come from PAM, and try to change the password to
* the one that failed earlier.
*/
if (is_login_keyring (attrs, n_attrs))
fix_login_keyring_if_unlock_failed (self, data->password);
options = get_unlock_options_from_prompt (self, &n_options);
if (options != NULL)
set_unlock_options_on_object (self, options, n_options);
if (auto_unlock_should_attach (self))
auto_unlock_attach_object (attrs, n_attrs, data->password);
}
}
/* ------------------------------------------------------------------------------------
* INITPIN
*/
static void
setup_init_token (GkmWrapPrompt *self,
CK_TOKEN_INFO_PTR tinfo)
{
GcrPrompt *prompt;
const gchar *choice;
gchar *label;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (tinfo);
prompt = GCR_PROMPT (self);
label = g_strndup ((gchar*)tinfo->label, sizeof (tinfo->label));
g_strchomp (label);
/* Build up the prompt */
gcr_prompt_set_password_new (prompt, TRUE);
gcr_prompt_set_title (prompt, _("New Password Required"));
gcr_prompt_set_message (prompt, _("New password required"));
text = g_strdup_printf (_("In order to prepare “%s” for storage of certificates or keys, a password is required"), label);
gcr_prompt_set_description (prompt, text);
g_free (text);
choice = NULL;
if (gkm_wrap_login_is_usable ())
choice = _("Automatically unlock whenever I’m logged in");
gcr_prompt_set_choice_label (prompt, choice);
gcr_prompt_set_continue_label (prompt, _("Continue"));
g_free (label);
}
GkmWrapPrompt*
gkm_wrap_prompt_for_init_pin (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session,
CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
{
GkmWrapPrompt *self;
g_assert (module != NULL);
if (pin != NULL || pin_len != 0)
return NULL;
self = g_object_new (GKM_TYPE_WRAP_PROMPT,
"timeout-seconds", -1,
"bus-name", gkm_wrap_prompt_get_prompter_name (),
NULL);
/* Build up the prompt */
self->module = module;
self->session = session;
return self;
}
gboolean
gkm_wrap_prompt_do_init_pin (GkmWrapPrompt *self, CK_RV last_result,
CK_UTF8CHAR_PTR *pin, CK_ULONG *n_pin)
{
CK_TOKEN_INFO tinfo;
gchar *password;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->module);
g_assert (pin);
g_assert (n_pin);
if (!get_info_for_token (self, &tinfo))
return FALSE;
setup_init_token (self, &tinfo);
password = (char *)gkm_wrap_prompt_request_password (self);
if (password == NULL)
return FALSE;
g_assert (self->destroy_data == NULL);
gkm_wrap_prompt_set_prompt_data (self, password, NULL);
*pin = (gpointer)password;
*n_pin = strlen (password);
return TRUE;
}
void
gkm_wrap_prompt_done_init_pin (GkmWrapPrompt *self, CK_RV call_result)
{
CK_TOKEN_INFO tinfo;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->destroy_data == NULL);
/* Save auto auto unlock */
if (call_result == CKR_OK && auto_unlock_should_attach (self)) {
if (get_info_for_token (self, &tinfo))
auto_unlock_attach_token (&tinfo, self->prompt_data);
}
}
/* ------------------------------------------------------------------------------------
* SETPIN
*/
typedef struct _SetPinPrompt {
gchar *original;
gchar *password;
} SetPinPrompt;
static void
set_pin_prompt_free (gpointer user_data)
{
SetPinPrompt *data = user_data;
egg_secure_strfree (data->original);
egg_secure_strfree (data->password);
g_slice_free (SetPinPrompt, data);
}
static void
setup_set_token_original (GkmWrapPrompt *self,
CK_TOKEN_INFO_PTR tinfo)
{
GcrPrompt *prompt;
gchar *label;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (tinfo != NULL);
prompt = GCR_PROMPT (self);
label = g_strndup ((gchar*)tinfo->label, sizeof (tinfo->label));
g_strchomp (label);
/* Build up the prompt */
gcr_prompt_set_password_new (prompt, FALSE);
gcr_prompt_set_title (prompt, _("Change Password"));
gcr_prompt_set_message (prompt, _("Authentication required"));
text = g_strdup_printf (_("To change the password for “%s”, the original password is required"), label);
gcr_prompt_set_description (prompt, text);
g_free (text);
gcr_prompt_set_continue_label (prompt, _("Continue"));
gcr_prompt_set_choice_label (prompt, NULL);
g_free (label);
}
static void
setup_set_token_password (GkmWrapPrompt *self,
CK_TOKEN_INFO_PTR tinfo)
{
GcrPrompt *prompt;
const gchar *choice;
gchar *label;
gchar *text;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (tinfo != NULL);
prompt = GCR_PROMPT (self);
label = g_strndup ((gchar*)tinfo->label, sizeof (tinfo->label));
g_strchomp (label);
/* Build up the prompt */
gcr_prompt_set_password_new (prompt, TRUE);
gcr_prompt_set_title (prompt, _("Change Password"));
gcr_prompt_set_message (prompt, _("Change password"));
text = g_strdup_printf (_("Type a new password for “%s”"), label);
gcr_prompt_set_description (prompt, text);
g_free (text);
choice = NULL;
if (gkm_wrap_login_is_usable ())
choice = _("Automatically unlock whenever I’m logged in");
gcr_prompt_set_continue_label (prompt, _("Continue"));
gcr_prompt_set_choice_label (prompt, choice);
g_free (label);
}
GkmWrapPrompt*
gkm_wrap_prompt_for_set_pin (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session,
CK_UTF8CHAR_PTR old_pin, CK_ULONG n_old_pin,
CK_UTF8CHAR_PTR new_pin, CK_ULONG n_new_pin)
{
GkmWrapPrompt *self;
g_assert (module != NULL);
if (new_pin != NULL || n_new_pin != 0)
return NULL;
self = g_object_new (GKM_TYPE_WRAP_PROMPT,
"timeout-seconds", -1,
"bus-name", gkm_wrap_prompt_get_prompter_name (),
NULL);
/* Build up the prompt */
self->module = module;
self->session = session;
gkm_wrap_prompt_set_prompt_data (self,
g_slice_new0 (SetPinPrompt),
set_pin_prompt_free);
return self;
}
gboolean
gkm_wrap_prompt_do_set_pin (GkmWrapPrompt *self, CK_RV last_result,
CK_UTF8CHAR_PTR *old_pin, CK_ULONG *n_old_pin,
CK_UTF8CHAR_PTR *new_pin, CK_ULONG *n_new_pin)
{
gboolean initializing = FALSE;
CK_TOKEN_INFO tinfo;
SetPinPrompt *data;
const gchar *password;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->module);
g_assert (old_pin);
g_assert (n_old_pin);
g_assert (new_pin);
g_assert (n_new_pin);
g_assert (self->destroy_data == set_pin_prompt_free);
data = self->prompt_data;
if (!get_info_for_token (self, &tinfo))
return FALSE;
initializing = !(tinfo.flags & CKF_USER_PIN_INITIALIZED);
/* Prompt for the original password */
if (!initializing || last_result != CKR_OK) {
setup_set_token_original (self, &tinfo);
password = gkm_wrap_prompt_request_password (self);
if (password == NULL)
return FALSE;
egg_secure_strfree (data->original);
data->original = egg_secure_strdup (password);
}
/* Prompt for the new password */
if (data->password == NULL) {
setup_set_token_password (self, &tinfo);
password = gkm_wrap_prompt_request_password (self);
if (password == NULL)
return FALSE;
data->password = egg_secure_strdup (password);
}
*new_pin = (guchar *)data->password;
*n_new_pin = data->password ? strlen (data->password) : 0;
*old_pin = (guchar *)data->original;
*n_old_pin = data->original ? strlen (data->original) : 0;
return TRUE;
}
void
gkm_wrap_prompt_done_set_pin (GkmWrapPrompt *self, CK_RV call_result)
{
CK_TOKEN_INFO tinfo;
SetPinPrompt *data;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->destroy_data == set_pin_prompt_free);
data = self->prompt_data;
/* Save auto auto unlock */
if (call_result == CKR_OK && auto_unlock_should_attach (self)) {
if (get_info_for_token (self, &tinfo))
auto_unlock_attach_token (&tinfo, data->password);
}
}
/* -----------------------------------------------------------------------------
* LOGIN
*/
static GkmWrapPrompt*
login_prompt_for_specific (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session,
CK_OBJECT_HANDLE object)
{
GkmWrapPrompt *self;
CK_ATTRIBUTE attr;
CK_BBOOL always;
CK_RV rv;
g_assert (module);
/*
* Should have an object at this point, if none exists it's an
* indication of either a buggy PKCS#11 module, or bugs in this
* wrap-layer not stashing away the context specific object.
*/
g_return_val_if_fail (object != 0, NULL);
/* Find out if the object is CKA_ALWAYS_AUTHENTICATE */
always = CK_FALSE;
attr.type = CKA_ALWAYS_AUTHENTICATE;
attr.pValue = &always;
attr.ulValueLen = sizeof (always);
rv = (module->C_GetAttributeValue) (session, object, &attr, 1);
if (rv != CKR_OK || always != CK_TRUE)
return NULL;
self = g_object_new (GKM_TYPE_WRAP_PROMPT,
"timeout-seconds", -1,
"bus-name", gkm_wrap_prompt_get_prompter_name (),
NULL);
/* Build up the prompt */
self->module = module;
self->session = session;
self->object = object;
return self;
}
static gboolean
login_prompt_do_specific (GkmWrapPrompt *self, CK_RV last_result,
CK_UTF8CHAR_PTR *pin, CK_ULONG *n_pin)
{
gchar *password = NULL;
CK_ATTRIBUTE_PTR attrs;
CK_ULONG n_attrs;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (pin);
g_assert (n_pin);
attrs = get_attributes_from_object (self, &n_attrs);
g_return_val_if_fail (attrs, FALSE);
if (self->iteration == 0) {
++(self->iteration);
password = auto_unlock_lookup_object (attrs, n_attrs);
if (password)
gkm_wrap_prompt_set_prompt_data (self, password,
(GDestroyNotify)egg_secure_strfree);
} else if (self->iteration == 1 && last_result == CKR_PIN_INCORRECT) {
auto_unlock_remove_object (attrs, n_attrs);
}
if (!password) {
setup_unlock_prompt (self, attrs, n_attrs, self->iteration == 1);
password = (char *)gkm_wrap_prompt_request_password (self);
if (password == NULL)
return FALSE;
gkm_wrap_prompt_set_prompt_data (self, password, NULL);
}
*pin = (guchar *)password;
*n_pin = strlen (password);
return TRUE;
}
static void
login_prompt_done_specific (GkmWrapPrompt *self, CK_RV call_result)
{
CK_ATTRIBUTE_PTR attrs;
CK_ULONG n_attrs;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->destroy_data == NULL ||
self->destroy_data == (GDestroyNotify)egg_secure_strfree);
/* Possibly save away auto unlock */
if (call_result == CKR_OK && auto_unlock_should_attach (self)) {
attrs = get_attributes_from_object (self, &n_attrs);
auto_unlock_attach_object (attrs, n_attrs, self->prompt_data);
}
}
static GkmWrapPrompt*
login_prompt_for_user (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session)
{
GkmWrapPrompt *self;
g_assert (module != NULL);
self = g_object_new (GKM_TYPE_WRAP_PROMPT,
"timeout-seconds", -1,
"bus-name", gkm_wrap_prompt_get_prompter_name (),
NULL);
/* Build up the prompt */
self->module = module;
self->session = session;
return self;
}
static gboolean
login_prompt_do_user (GkmWrapPrompt *self, CK_RV last_result,
CK_UTF8CHAR_PTR *pin, CK_ULONG *n_pin)
{
CK_TOKEN_INFO tinfo;
gchar *password = NULL;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->module);
g_assert (pin);
g_assert (n_pin);
if (!get_info_for_token (self, &tinfo))
return FALSE;
if (self->iteration == 0) {
++(self->iteration);
password = auto_unlock_lookup_token (&tinfo);
if (password)
gkm_wrap_prompt_set_prompt_data (self, password,
(GDestroyNotify)egg_secure_strfree);
} else if (self->iteration == 1 && last_result == CKR_PIN_INCORRECT) {
auto_unlock_remove_token (&tinfo);
}
if (!password) {
setup_unlock_token (self, &tinfo);
password = (char *)gkm_wrap_prompt_request_password (self);
if (password == NULL)
return FALSE;
gkm_wrap_prompt_set_prompt_data (self, password, NULL);
}
*pin = (guchar *)password;
*n_pin = strlen (password);
return TRUE;
}
static void
login_prompt_done_user (GkmWrapPrompt *self, CK_RV call_result)
{
CK_TOKEN_INFO tinfo;
g_assert (GKM_IS_WRAP_PROMPT (self));
g_assert (self->destroy_data == NULL ||
self->destroy_data == (GDestroyNotify)egg_secure_strfree);
/* Save the options, and possibly auto unlock */
if (call_result == CKR_OK && auto_unlock_should_attach (self)) {
if (get_info_for_token (self, &tinfo))
auto_unlock_attach_token (&tinfo, self->prompt_data);
}
}
GkmWrapPrompt*
gkm_wrap_prompt_for_login (CK_FUNCTION_LIST_PTR module, CK_USER_TYPE user_type,
CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object,
CK_UTF8CHAR_PTR pin, CK_ULONG n_pin)
{
g_return_val_if_fail (module, NULL);
if (pin != NULL || n_pin != 0)
return NULL;
switch (user_type) {
case CKU_CONTEXT_SPECIFIC:
return login_prompt_for_specific (module, session, object);
case CKU_USER:
return login_prompt_for_user (module, session);
default:
return NULL;
}
}
gboolean
gkm_wrap_prompt_do_login (GkmWrapPrompt *self, CK_USER_TYPE user_type, CK_RV last_result,
CK_UTF8CHAR_PTR *pin, CK_ULONG *n_pin)
{
g_return_val_if_fail (GKM_IS_WRAP_PROMPT (self), FALSE);
g_return_val_if_fail (pin, FALSE);
g_return_val_if_fail (n_pin, FALSE);
switch (user_type) {
case CKU_CONTEXT_SPECIFIC:
return login_prompt_do_specific (self, last_result, pin, n_pin);
case CKU_USER:
return login_prompt_do_user (self, last_result, pin, n_pin);
default:
return FALSE;
}
}
void
gkm_wrap_prompt_done_login (GkmWrapPrompt *self, CK_USER_TYPE user_type, CK_RV call_result)
{
g_return_if_fail (GKM_IS_WRAP_PROMPT (self));
switch (user_type) {
case CKU_CONTEXT_SPECIFIC:
login_prompt_done_specific (self, call_result);
break;
case CKU_USER:
login_prompt_done_user (self, call_result);
break;
}
}
const gchar *
gkm_wrap_prompt_get_prompter_name (void)
{
const gchar *prompter_name;
if (the_prompter_name)
return the_prompter_name;
prompter_name = g_getenv ("GNOME_KEYRING_TEST_PROMPTER");
if (prompter_name)
return prompter_name;
return NULL;
}
void
gkm_wrap_prompt_set_prompter_name (const gchar *prompter_name)
{
the_prompter_name = g_intern_string (prompter_name);
}