/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* gkm-secret-textual.c - Textual non-encrypted format for the keyring
Copyright (C) 2007, 2009 Stefan Walter
The Gnome Keyring Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The Gnome Keyring Library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the Gnome Library; see the file COPYING.LIB. If not,
.
Author: Stef Walter
*/
#include "config.h"
#include "gkm-secret-collection.h"
#include "gkm-secret-compat.h"
#include "gkm-secret-data.h"
#include "gkm-secret-fields.h"
#include "gkm-secret-item.h"
#include "gkm-secret-textual.h"
#include "egg/egg-error.h"
#include "egg/egg-hex.h"
#include "egg/egg-secure-memory.h"
#include "gkm/gkm-secret.h"
#include
#include
#include
#include
#include
static void
key_file_set_uint64 (GKeyFile *file, const gchar *group,
const gchar *key, guint64 value)
{
gchar buffer[64];
g_snprintf (buffer, sizeof (buffer), "%llu",
(long long unsigned int)value);
g_key_file_set_value (file, group, key, buffer);
}
static gboolean
key_file_get_uint64 (GKeyFile *file, const gchar *group,
const gchar *key, guint64 *value)
{
gchar *str, *end;
str = g_key_file_get_value (file, group, key, NULL);
if (!str)
return FALSE;
*value = g_ascii_strtoull (str, &end, 10);
if (end[0]) {
g_free (str);
return FALSE;
}
g_free (str);
return TRUE;
}
static void
generate_attributes (GKeyFile *file, GkmSecretItem *item)
{
GHashTable *attributes;
gchar *groupname;
GList *names, *l;
guint32 number;
gint index = 0;
attributes = gkm_secret_item_get_fields (item);
g_return_if_fail (attributes);
names = gkm_secret_fields_get_names (attributes);
for (l = names; l; l = g_list_next (l)) {
groupname = g_strdup_printf ("%s:attribute%d",
gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item)),
index);
g_key_file_set_string (file, groupname, "name", l->data);
/*
* COMPATIBILITY:
*
* Our new Secrets API doesn't support integer attributes. However, to have
* compatibility with old keyring code reading this file, we need to set
* the type=uint32 attribute appropriately where expected.
*
* If there's an extra compat-uint32 attribute and the name of this attribute
* is contained in that list, then write as a uint32.
*/
/* Determine if it's a uint32 compatible value, and store as such if it is */
if (gkm_secret_fields_get_compat_uint32 (attributes, l->data, &number)) {
g_key_file_set_string (file, groupname, "type", "uint32");
key_file_set_uint64 (file, groupname, "value", number);
/* A normal string attribute */
} else {
g_key_file_set_string (file, groupname, "type", "string");
g_key_file_set_string (file, groupname, "value", gkm_secret_fields_get (attributes, l->data));
}
g_free (groupname);
++index;
}
g_list_free (names);
}
static void
parse_attributes (GKeyFile *file,
GkmSecretItem *item,
const gchar **groups,
gint compat_type)
{
GHashTable *attributes;
const gchar *identifier;
const gchar **g;
gchar *prefix;
gchar *name, *type;
guint64 number;
const gchar *schema_name;
/* Now do the attributes */
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
prefix = g_strdup_printf ("%s:attribute", identifier);
attributes = gkm_secret_fields_new ();
for (g = groups; *g; ++g) {
if (!g_str_has_prefix (*g, prefix))
continue;
name = g_key_file_get_string (file, *g, "name", NULL);
if (!name)
continue;
type = g_key_file_get_string (file, *g, "type", NULL);
/* A uint32 type value */
if (type && g_str_equal (type, "uint32")) {
if (key_file_get_uint64 (file, *g, "value", &number))
gkm_secret_fields_add_compat_uint32 (attributes, name, number);
g_free (name);
/* A string type value */
} else {
gkm_secret_fields_take (attributes, name,
g_key_file_get_string (file, *g, "value", NULL));
}
g_free (type);
}
gkm_secret_item_set_fields (item, attributes);
schema_name = g_hash_table_lookup (attributes, GKM_SECRET_FIELD_SCHEMA);
if (schema_name == NULL)
schema_name = gkm_secret_compat_format_item_type (compat_type);
gkm_secret_item_set_schema (item, schema_name);
g_hash_table_unref (attributes);
g_free (prefix);
}
static void
generate_acl (GKeyFile *file, GkmSecretItem *item)
{
const gchar *identifier;
GkmSecretAccess *ac;
gchar *groupname;
GList *acl;
gint i;
/*
* COMPATIBILITY: If we loaded ACLs and they're set on the item,
* then store them back in.
*/
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
acl = g_object_get_data (G_OBJECT (item), "compat-acl");
for (i = 0; acl != NULL; acl = g_list_next (acl), ++i) {
ac = acl->data;
/* Build a group name */
groupname = g_strdup_printf ("%s:acl%d", identifier, i);
if (ac->display_name)
g_key_file_set_string (file, groupname, "display-name", ac->display_name);
if (ac->pathname)
g_key_file_set_string (file, groupname, "path", ac->pathname);
g_key_file_set_boolean (file, groupname, "read-access",
ac->types_allowed & GKM_SECRET_ACCESS_READ);
g_key_file_set_boolean (file, groupname, "write-access",
ac->types_allowed & GKM_SECRET_ACCESS_WRITE);
g_key_file_set_boolean (file, groupname, "remove-access",
ac->types_allowed & GKM_SECRET_ACCESS_REMOVE);
g_free (groupname);
}
}
static void
parse_acl (GKeyFile *file, GkmSecretItem *item, const gchar **groups)
{
GkmSecretAccessType access_type;
GkmSecretAccess *ac;
const gchar *identifier;
const gchar **g;
gchar *prefix;
gchar *path, *display;
GError *err = NULL;
GList *acl;
/*
* COMPATIBILITY: We don't actually use ACLs, but if we find them in the
* file, then load them and save back later.
*/
identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item));
prefix = g_strdup_printf ("%s:acl", identifier);
acl = NULL;
for (g = groups; *g; ++g) {
if (!g_str_has_prefix (*g, prefix))
continue;
path = g_key_file_get_string (file, *g, "path", NULL);
if (!path)
continue;
display = g_key_file_get_string (file, *g, "display-name", NULL);
access_type = 0;
if (g_key_file_get_boolean (file, *g, "read-access", &err) && !err)
access_type |= GKM_SECRET_ACCESS_READ;
g_clear_error (&err);
if (g_key_file_get_boolean (file, *g, "write-access", &err) && !err)
access_type |= GKM_SECRET_ACCESS_WRITE;
g_clear_error (&err);
if (g_key_file_get_boolean (file, *g, "remove-access", &err) && !err)
access_type |= GKM_SECRET_ACCESS_REMOVE;
g_clear_error (&err);
ac = g_new0 (GkmSecretAccess, 1);
ac->display_name = display;
ac->pathname = path;
ac->types_allowed = access_type;
acl = g_list_prepend (acl, ac);
}
g_object_set_data_full (G_OBJECT (item), "compat-acl", acl, gkm_secret_compat_acl_free);
g_free (prefix);
}
static void
generate_item (GKeyFile *file, GkmSecretItem *item, GkmSecretData *sdata)
{
GkmSecretObject *obj;
const gchar *value;
const gchar *identifier;
const guchar *secret;
gsize n_secret;
gchar *hex;
g_assert (file);
g_assert (GKM_IS_SECRET_ITEM (item));
g_assert (GKM_IS_SECRET_DATA (sdata));
obj = GKM_SECRET_OBJECT (item);
identifier = gkm_secret_object_get_identifier (obj);
value = gkm_secret_item_get_schema (item);
g_key_file_set_integer (file, identifier, "item-type",
gkm_secret_compat_parse_item_type (value));
value = gkm_secret_object_get_label (obj);
if (value != NULL)
g_key_file_set_string (file, identifier, "display-name", value);
secret = gkm_secret_data_get_raw (sdata, identifier, &n_secret);
if (secret != NULL) {
/* A textual secret. Note that secrets are always null-terminated. */
if (g_utf8_validate ((gchar*)secret, n_secret, NULL)) {
g_key_file_set_value (file, identifier, "secret", (gchar*)secret);
/* A non-textual secret */
} else {
hex = egg_hex_encode (secret, n_secret);
g_key_file_set_value (file, identifier, "binary-secret", hex);
g_free (hex);
}
}
key_file_set_uint64 (file, identifier, "mtime", gkm_secret_object_get_modified (obj));
key_file_set_uint64 (file, identifier, "ctime", gkm_secret_object_get_created (obj));
generate_attributes (file, item);
generate_acl (file, item);
}
static void
parse_item (GKeyFile *file, GkmSecretItem *item, GkmSecretData *sdata,
const gchar **groups)
{
GkmSecretObject *obj;
const gchar *identifier;
GError *err = NULL;
GkmSecret *secret;
guchar *binary;
gsize n_binary;
gchar *val;
guint64 num;
gint type;
/* First the main item data */
obj = GKM_SECRET_OBJECT (item);
identifier = gkm_secret_object_get_identifier (obj);
type = g_key_file_get_integer (file, identifier, "item-type", &err);
if (err) {
g_clear_error (&err);
type = 0;
}
val = g_key_file_get_string (file, identifier, "display-name", NULL);
gkm_secret_object_set_label (obj, val);
g_free (val);
if (sdata) {
secret = NULL;
/* A textual secret */
val = g_key_file_get_string (file, identifier, "secret", NULL);
if (val != NULL) {
secret = gkm_secret_new_from_password (val);
g_free (val);
/* A binary secret */
} else {
val = g_key_file_get_string (file, identifier, "binary-secret", NULL);
if (val != NULL) {
binary = egg_hex_decode (val, -1, &n_binary);
secret = gkm_secret_new (binary, n_binary);
g_free (binary);
g_free (val);
}
}
/* Put the secret in the right place */
if (secret == NULL) {
gkm_secret_data_remove_secret (sdata, identifier);
} else {
gkm_secret_data_set_secret (sdata, identifier, secret);
g_object_unref (secret);
}
}
num = 0;
if (key_file_get_uint64 (file, identifier, "mtime", &num))
gkm_secret_object_set_modified (obj, num);
num = 0;
if (key_file_get_uint64 (file, identifier, "ctime", &num))
gkm_secret_object_set_created (obj, num);
/* Now the other stuff */
parse_attributes (file, item, groups, type);
parse_acl (file, item, groups);
}
GkmDataResult
gkm_secret_textual_write (GkmSecretCollection *collection, GkmSecretData *sdata,
gpointer *data, gsize *n_data)
{
GkmSecretObject *obj;
GList *items, *l;
const gchar *value;
GKeyFile *file;
GError *err = NULL;
gint idle_timeout;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (collection), GKM_DATA_FAILURE);
g_return_val_if_fail (GKM_IS_SECRET_DATA (sdata), GKM_DATA_LOCKED);
g_return_val_if_fail (data && n_data, GKM_DATA_FAILURE);
obj = GKM_SECRET_OBJECT (collection);
file = g_key_file_new ();
value = gkm_secret_object_get_label (obj);
if (value != NULL)
g_key_file_set_string (file, "keyring", "display-name", value);
key_file_set_uint64 (file, "keyring", "ctime", gkm_secret_object_get_created (obj));
key_file_set_uint64 (file, "keyring", "mtime", gkm_secret_object_get_modified (obj));
idle_timeout = gkm_secret_collection_get_lock_idle (collection);
g_key_file_set_boolean (file, "keyring", "lock-on-idle", idle_timeout > 0);
if (idle_timeout)
g_key_file_set_integer (file, "keyring", "lock-timeout", idle_timeout);
idle_timeout = gkm_secret_collection_get_lock_after (collection);
g_key_file_set_boolean (file, "keyring", "lock-after", idle_timeout > 0);
if (idle_timeout)
g_key_file_set_integer (file, "keyring", "lock-timeout", idle_timeout);
items = gkm_secret_collection_get_items (collection);
for (l = items; l; l = g_list_next (l))
generate_item (file, l->data, sdata);
g_list_free (items);
*data = (guchar*)g_key_file_to_data (file, n_data, &err);
g_key_file_free (file);
if (!*data) {
g_warning ("couldn't generate textual keyring file: %s", egg_error_message (err));
return GKM_DATA_FAILURE;
}
return GKM_DATA_SUCCESS;
}
static void
remove_unavailable_item (gpointer key, gpointer dummy, gpointer user_data)
{
/* Called to remove items from a keyring that no longer exist */
GkmSecretCollection *collection = GKM_SECRET_COLLECTION (user_data);
GkmSecretItem *item;
g_assert (GKM_IS_SECRET_COLLECTION (collection));
item = gkm_secret_collection_get_item (collection, key);
if (item != NULL)
gkm_secret_collection_remove_item (collection, item);
}
GkmDataResult
gkm_secret_textual_read (GkmSecretCollection *collection, GkmSecretData *sdata,
gconstpointer data, gsize n_data)
{
GkmSecretObject *obj;
GkmSecretItem *item;
GList *items, *l;
GError *err = NULL;
GKeyFile *file = NULL;
gchar **groups = NULL;
GkmDataResult res = GKM_DATA_FAILURE;
gchar *start = NULL;
const gchar *identifier;
GHashTable *checks = NULL;
gint lock_timeout;
gchar *value;
guint64 num;
gchar **g;
g_return_val_if_fail (GKM_IS_SECRET_COLLECTION (collection), GKM_DATA_FAILURE);
g_return_val_if_fail (!sdata || GKM_IS_SECRET_DATA (sdata), GKM_DATA_FAILURE);
file = g_key_file_new ();
obj = GKM_SECRET_OBJECT (collection);
if (!n_data) {
res = GKM_DATA_UNRECOGNIZED;
goto done;
}
if (!g_key_file_load_from_data (file, (const gchar*)data, n_data, G_KEY_FILE_NONE, &err)) {
if (g_error_matches (err, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE))
res = GKM_DATA_UNRECOGNIZED;
goto done;
}
start = g_key_file_get_start_group (file);
if (!start || !g_str_equal (start, "keyring")) {
g_message ("invalid keyring file: wrong header group");
goto done;
}
value = g_key_file_get_string (file, "keyring", "display-name", NULL);
gkm_secret_object_set_label (obj, value);
g_free (value);
num = 0;
key_file_get_uint64 (file, "keyring", "ctime", &num);
gkm_secret_object_set_created (obj, num);
num = 0;
key_file_get_uint64 (file, "keyring", "mtime", &num);
gkm_secret_object_set_modified (obj, num);
/* Not currently used :( */
lock_timeout = g_key_file_get_integer (file, "keyring", "lock-timeout", NULL);
if (g_key_file_get_boolean (file, "keyring", "lock-after", NULL))
gkm_secret_collection_set_lock_idle (collection, lock_timeout);
else if (g_key_file_get_boolean (file, "keyring", "lock-on-idle", NULL))
gkm_secret_collection_set_lock_idle (collection, lock_timeout);
g_object_set_data (G_OBJECT (collection), "lock-timeout", GINT_TO_POINTER (lock_timeout));
/* Build a Hash table where we can track ids we haven't yet seen */
checks = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
items = gkm_secret_collection_get_items (collection);
for (l = items; l; l = g_list_next (l)) {
identifier = gkm_secret_object_get_identifier (l->data);
g_hash_table_replace (checks, g_strdup (identifier), "unused");
}
g_list_free (items);
groups = g_key_file_get_groups (file, NULL);
for (g = groups; *g; ++g) {
identifier = *g;
if (g_str_equal (identifier, "keyring") || strchr (identifier, ':'))
continue;
/* We've seen this id */
g_hash_table_remove (checks, identifier);
item = gkm_secret_collection_get_item (collection, identifier);
if (item == NULL)
item = gkm_secret_collection_new_item (collection, identifier);
parse_item (file, item, sdata, (const gchar**)groups);
}
g_hash_table_foreach (checks, (GHFunc)remove_unavailable_item, collection);
res = GKM_DATA_SUCCESS;
done:
if (checks)
g_hash_table_destroy (checks);
if (file)
g_key_file_free (file);
g_strfreev (groups);
g_free (start);
g_clear_error (&err);
return res;
}