/* * 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-layer.h" #include "gkm-wrap-login.h" #include "gkm/gkm-attributes.h" #include "gkm/gkm-log.h" #include "gkm/gkm-util.h" #include "egg/egg-secure-memory.h" #include "pkcs11/pkcs11.h" #include "pkcs11/pkcs11i.h" #include #include /* Holds failed unlock password, accessed atomically */ static gpointer unlock_failure = NULL; EGG_SECURE_DECLARE (wrap_login); void gkm_wrap_layer_mark_login_unlock_success (void) { gpointer oldval = g_atomic_pointer_get (&unlock_failure); if (g_atomic_pointer_compare_and_exchange (&unlock_failure, oldval, NULL)) egg_secure_strfree (oldval); } void gkm_wrap_layer_mark_login_unlock_failure (const gchar *failed_password) { gpointer oldval; gpointer newval; g_return_if_fail (failed_password); oldval = g_atomic_pointer_get (&unlock_failure); newval = egg_secure_strdup (failed_password); if (g_atomic_pointer_compare_and_exchange (&unlock_failure, oldval, newval)) egg_secure_strfree (oldval); else egg_secure_strfree (newval); } gboolean gkm_wrap_login_did_unlock_fail (void) { return g_atomic_pointer_get (&unlock_failure) ? TRUE : FALSE; } gchar* gkm_wrap_login_steal_failed_password (void) { gpointer oldval; oldval = g_atomic_pointer_get (&unlock_failure); if (!g_atomic_pointer_compare_and_exchange (&unlock_failure, oldval, NULL)) oldval = NULL; return oldval; } static gboolean prepare_template_for_storage (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session, CK_OBJECT_HANDLE collection, GArray *template) { CK_ATTRIBUTE attr; CK_RV rv; g_assert (module); g_assert (session); g_assert (template); /* Lookup the ID attribute */ attr.type = CKA_ID; attr.pValue = NULL; attr.ulValueLen = 0; rv = (module->C_GetAttributeValue) (session, collection, &attr, 1); if (rv != CKR_OK || attr.ulValueLen == (CK_ULONG)-1) return FALSE; attr.pValue = g_malloc0 (attr.ulValueLen); rv = (module->C_GetAttributeValue) (session, collection, &attr, 1); g_return_val_if_fail (rv == CKR_OK, FALSE); /* Use the ID as the collection attribute */ attr.type = CKA_G_COLLECTION; gkm_template_set (template, &attr); g_free (attr.pValue); gkm_template_set_ulong (template, CKA_CLASS, CKO_SECRET_KEY); gkm_template_set_boolean (template, CKA_TOKEN, TRUE); return TRUE; } static gboolean prepare_module_session_and_collection (CK_FUNCTION_LIST_PTR_PTR module, CK_SESSION_HANDLE_PTR session, CK_OBJECT_HANDLE_PTR object) { CK_OBJECT_CLASS klass = CKO_G_COLLECTION; CK_BBOOL trueval = CK_TRUE; CK_BBOOL falseval = CK_FALSE; CK_ATTRIBUTE attrs[] = { { CKA_G_LOGIN_COLLECTION, &trueval, sizeof (trueval) }, { CKA_G_LOCKED, &falseval, sizeof (falseval) }, { CKA_CLASS, &klass, sizeof (klass) }, { CKA_TOKEN, &trueval, sizeof (trueval) }, { CKA_TRUSTED, &trueval, sizeof (trueval) }, }; CK_SESSION_INFO sinfo; CK_SLOT_ID_PTR slots = NULL; CK_FUNCTION_LIST_PTR funcs; CK_ULONG n_slots = 0, i; gboolean ret = FALSE; CK_ULONG n_objects = 0; CK_RV rv; g_assert (module); g_assert (session); funcs = gkm_wrap_layer_get_functions_no_prompts (); g_return_val_if_fail (funcs, FALSE); rv = (funcs->C_GetSlotList) (CK_TRUE, NULL, &n_slots); g_return_val_if_fail (rv == CKR_OK, FALSE); slots = g_new0 (CK_SLOT_ID, n_slots); rv = (funcs->C_GetSlotList) (CK_TRUE, slots, &n_slots); g_return_val_if_fail (rv == CKR_OK, FALSE); for (i = 0; !ret && i < n_slots; ++i) { /* Open a session with this module */ rv = (funcs->C_OpenSession) (slots[i], CKF_RW_SESSION | CKF_SERIAL_SESSION, NULL, NULL, session); if (rv != CKR_OK) continue; rv = (funcs->C_GetSessionInfo) (*session, &sinfo); if (rv != CKR_OK) continue; /* Log into the session with no password, in case its needed */ if (sinfo.state == CKS_RO_PUBLIC_SESSION || sinfo.state == CKS_RW_PUBLIC_SESSION) (funcs->C_Login) (*session, CKU_USER, (guchar*)"", 0); rv = (funcs->C_FindObjectsInit) (*session, attrs, G_N_ELEMENTS (attrs)); if (rv == CKR_OK) { rv = (funcs->C_FindObjects) (*session, object, 1, &n_objects); (funcs->C_FindObjectsFinal) (*session); if (rv == CKR_OK && n_objects == 1) ret = TRUE; } if (!ret) (funcs->C_CloseSession) (*session); } g_free (slots); *module = funcs; return ret; } static void string_fields_to_template_va (va_list args, const gchar *name, GArray *template) { GString *fields = g_string_sized_new (128); const gchar *last = NULL; gint cmp; g_assert (name); g_assert (template); while (name != NULL) { g_string_append (fields, name); g_string_append_c (fields, '\0'); g_string_append (fields, va_arg (args, const gchar*)); g_string_append_c (fields, '\0'); /* Names must be in alphabetical order */ if (name && last) { cmp = strcmp (last, name); if (cmp == 0) g_warning ("duplicate names in attributes not allowed: %s %s", last, name); else if (cmp > 0) g_warning ("names in attributes must in alphabetical order: %s %s", last, name); } last = name; name = va_arg (args, const gchar*); } gkm_template_set_value (template, CKA_G_FIELDS, fields->str, fields->len); g_string_free (fields, TRUE); } static CK_OBJECT_HANDLE find_login_keyring_item (CK_FUNCTION_LIST_PTR module, CK_SESSION_HANDLE session, GArray *template) { CK_OBJECT_HANDLE item = 0; CK_ATTRIBUTE_PTR attr; CK_ATTRIBUTE matched; CK_OBJECT_HANDLE search; GArray *attrs; CK_RV rv; g_assert (module); g_assert (template); /* Template for search object */ attrs = gkm_template_new (NULL, 0); gkm_template_set_ulong (attrs, CKA_CLASS, CKO_G_SEARCH); gkm_template_set_boolean (attrs, CKA_TOKEN, CK_FALSE); attr = gkm_template_find (template, CKA_G_COLLECTION); if (attr != NULL) gkm_template_set (attrs, attr); attr = gkm_template_find (template, CKA_G_FIELDS); g_return_val_if_fail (attr, 0); gkm_template_set (attrs, attr); /* Create new search object */ rv = (module->C_CreateObject) (session, (CK_ATTRIBUTE_PTR)attrs->data, attrs->len, &search); gkm_template_free (attrs); if (rv != CKR_OK) { g_warning ("couldn't create search for login keyring: %s", gkm_log_rv (rv)); return 0; } matched.type = CKA_G_MATCHED; matched.pValue = NULL; matched.ulValueLen = 0; rv = (module->C_GetAttributeValue) (session, search, &matched, 1); g_return_val_if_fail (rv == CKR_OK, 0); g_return_val_if_fail (matched.ulValueLen != (CK_ULONG)-1, 0); if (matched.ulValueLen >= sizeof (CK_OBJECT_HANDLE)) { matched.pValue = g_malloc (matched.ulValueLen); rv = (module->C_GetAttributeValue) (session, search, &matched, 1); g_return_val_if_fail (rv == CKR_OK, 0); item = *((CK_OBJECT_HANDLE_PTR)matched.pValue); g_return_val_if_fail (item != 0, 0); g_free (matched.pValue); } /* Destroy the search object */ (module->C_DestroyObject) (session, search); return item; } void gkm_wrap_login_attach_secret (const gchar *label, const gchar *secret, const gchar *first, ...) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session; CK_OBJECT_HANDLE collection; CK_OBJECT_HANDLE item; CK_ATTRIBUTE attr; gchar *display_name; GArray *template; gsize original_len; va_list va; CK_RV rv; if (first == NULL) return; if (secret == NULL) secret = ""; /* We only support storing utf-8 strings */ g_return_if_fail (g_utf8_validate (secret, -1, NULL)); if (!prepare_module_session_and_collection (&module, &session, &collection)) return; template = gkm_template_new (NULL, 0); if (!prepare_template_for_storage (module, session, collection, template)) { gkm_template_free (template); return; } va_start(va, first); string_fields_to_template_va (va, first, template); va_end(va); /* * If there already is such an item, then include its identifier. * What this does is overwrite that item, rather than creating new. */ item = find_login_keyring_item (module, session, template); if (item != 0) { attr.type = CKA_ID; attr.ulValueLen = 0; attr.pValue = NULL; rv = (module->C_GetAttributeValue) (session, item, &attr, 1); if (rv == CKR_OK && attr.ulValueLen != (CK_ULONG)-1) { attr.pValue = g_malloc (attr.ulValueLen); rv = (module->C_GetAttributeValue) (session, item, &attr, 1); if (rv == CKR_OK) gkm_template_set (template, &attr); g_free (attr.pValue); } } /* Get the label ready */ display_name = g_strdup_printf (_("Unlock password for: %s"), label ? label : _("Unnamed")); gkm_template_set_string (template, CKA_LABEL, display_name); g_free (display_name); /* Instead of duplicating the password, we tack it into the template */ original_len = template->len; attr.type = CKA_VALUE; attr.pValue = (CK_VOID_PTR)secret; attr.ulValueLen = strlen (secret); g_array_append_val (template, attr); /* Actually make the object */ rv = (module->C_CreateObject) (session, ((CK_ATTRIBUTE_PTR)template->data), template->len, &item); if (rv != CKR_OK) g_warning ("couldn't store secret in login keyring: %s", gkm_log_rv (rv)); /* Before freeing, truncate our password attribute we tacked on the end */ g_array_set_size (template, original_len); gkm_template_free (template); (module->C_CloseSession) (session); } gchar* gkm_wrap_login_lookup_secret (const gchar *first, ...) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session; CK_OBJECT_HANDLE collection; CK_OBJECT_HANDLE item; CK_ATTRIBUTE attr; GArray *template; gchar *password = NULL; va_list va; CK_RV rv; if (first == NULL) return NULL; if (!prepare_module_session_and_collection (&module, &session, &collection)) return NULL; template = gkm_template_new (NULL, 0); gkm_template_set_ulong (template, CKA_CLASS, CKO_SECRET_KEY); gkm_template_set_boolean (template, CKA_G_LOCKED, FALSE); va_start(va, first); string_fields_to_template_va (va, first, template); va_end(va); item = find_login_keyring_item (module, session, template); gkm_template_free (template); if (item != 0) { attr.type = CKA_VALUE; attr.pValue = NULL; attr.ulValueLen = 0; rv = (module->C_GetAttributeValue) (session, item, &attr, 1); if (rv == CKR_OK && attr.ulValueLen != (CK_ULONG)-1) { /* Allocate memory for password. Note we're null terminating */ password = attr.pValue = egg_secure_alloc (attr.ulValueLen + 1); rv = (module->C_GetAttributeValue) (session, item, &attr, 1); /* Double check that this is a password */ if (rv == CKR_OK) { if (!g_utf8_validate (password, -1, NULL)) { g_message ("expected string, but found binary secret in login keyring"); egg_secure_strfree (password); password = NULL; } /* Couldn't read the value. Remember object can go away due to race */ } else { if (rv != CKR_OBJECT_HANDLE_INVALID) g_warning ("couldn't read stored secret from login keyring: %s", gkm_log_rv (rv)); egg_secure_free (password); password = NULL; } /* Failure. Remember object can go away due to race */ } else if (rv != CKR_OK && rv != CKR_OBJECT_HANDLE_INVALID) { g_warning ("couldn't get stored secret from login keyring: %s", gkm_log_rv (rv)); } } (module->C_CloseSession) (session); return password; } void gkm_wrap_login_remove_secret (const gchar *first, ...) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session; CK_OBJECT_HANDLE collection; CK_OBJECT_HANDLE item; GArray *template; va_list va; CK_RV rv; if (first == NULL) return; if (!prepare_module_session_and_collection (&module, &session, &collection)) return; template = gkm_template_new (NULL, 0); if (!prepare_template_for_storage (module, session, collection, template)) { gkm_template_free (template); return; } va_start(va, first); string_fields_to_template_va (va, first, template); va_end(va); item = find_login_keyring_item (module, session, template); gkm_template_free (template); if (item != 0) { rv = (module->C_DestroyObject) (session, item); if (rv != CKR_OK && rv != CKR_OBJECT_HANDLE_INVALID) g_warning ("couldn't remove stored secret from login keyring: %s", gkm_log_rv (rv)); } (module->C_CloseSession) (session); } gboolean gkm_wrap_login_is_usable (void) { CK_FUNCTION_LIST_PTR module; CK_OBJECT_HANDLE collection; CK_SESSION_HANDLE session; if (!prepare_module_session_and_collection (&module, &session, &collection)) return FALSE; (module->C_CloseSession) (session); return TRUE; }