/*
* 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-file.h"
#include "gkm/gkm-attributes.h"
#include "gkm/gkm-crypto.h"
#include "gkm/gkm-data-types.h"
#include "gkm/gkm-util.h"
#include "gkm-marshal.h"
#include "egg/egg-buffer.h"
#include "egg/egg-hex.h"
#include "egg/egg-secure-memory.h"
#include "egg/egg-symkey.h"
#include
#include
#include
#include
#include
#include
enum {
ENTRY_ADDED,
ENTRY_CHANGED,
ENTRY_REMOVED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
struct _GkmGnome2File {
GObject parent;
/* The data itself */
GHashTable *identifiers;
GHashTable *privates;
GHashTable *publics;
GList *unknowns;
/* All the sections seen */
guint sections;
gboolean incomplete;
/* Stuff notseen on this read */
GHashTable *checks;
};
typedef struct _UnknownBlock {
guint type;
EggBuffer buffer;
} UnknownBlock;
G_DEFINE_TYPE (GkmGnome2File, gkm_gnome2_file, G_TYPE_OBJECT);
#define PUBLIC_ALLOC (EggBufferAllocator)g_realloc
#define PRIVATE_ALLOC (EggBufferAllocator)egg_secure_realloc
typedef GkmDataResult (*BlockFunc) (guint block, EggBuffer *buffer, GkmSecret *login, gpointer user_data);
#define FILE_HEADER ((const guchar*)"Gnome Keyring Store 2\n\r\0")
#define FILE_HEADER_LEN 24
#define FILE_BLOCK_INDEX 0x49445832 /* ie: "IDX2" */
#define FILE_BLOCK_PRIVATE 0x50525632 /* ie: "PRV2" */
#define FILE_BLOCK_PUBLIC 0x50554232 /* ie: "PUB2" */
#define UNUSED_VALUE GUINT_TO_POINTER (1)
EGG_SECURE_DECLARE (data_file);
/* -----------------------------------------------------------------------------
* HELPERS
*/
static void
attribute_free (gpointer data)
{
CK_ATTRIBUTE_PTR attr = data;
if (attr) {
g_free (attr->pValue);
g_slice_free (CK_ATTRIBUTE, attr);
}
}
static CK_ATTRIBUTE_PTR
attribute_dup (CK_ATTRIBUTE_PTR attr)
{
CK_ATTRIBUTE_PTR copy;
g_assert (attr);
copy = g_slice_new (CK_ATTRIBUTE);
copy->ulValueLen = attr->ulValueLen;
copy->pValue = g_memdup2 (attr->pValue, copy->ulValueLen);
copy->type = attr->type;
return copy;
}
static GHashTable*
attributes_new (void)
{
return g_hash_table_new_full (gkm_util_ulong_hash, gkm_util_ulong_equal, NULL, attribute_free);
}
static GHashTable*
entries_new (void)
{
return g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify)g_free, (GDestroyNotify)g_hash_table_unref);
}
static gboolean
read_all_bytes (int fd, guchar *buf, gsize len)
{
gsize all = len;
int res;
while (len > 0) {
res = read (fd, buf, len);
if (res < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
g_warning ("couldn't read %u bytes from store file: %s",
(guint)all, g_strerror (errno));
return FALSE;
} else if (res == 0) {
if (len != all)
g_warning ("couldn't read %u bytes from store file", (guint)all);
return FALSE;
} else {
len -= res;
buf += res;
}
}
return TRUE;
}
static gboolean
write_all_bytes (int fd, const guchar *buf, gsize len)
{
gsize all = len;
int res;
while (len > 0) {
res = write (fd, buf, len);
if (res < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
g_warning ("couldn't write %u bytes to store file: %s",
(guint)all, g_strerror (errno));
return FALSE;
} else if (res == 0) {
g_warning ("couldn't write %u bytes to store file", (guint)all);
return FALSE;
} else {
len -= res;
buf += res;
}
}
return TRUE;
}
static GkmDataResult
parse_file_blocks (int file, BlockFunc block_func, GkmSecret *login, gpointer user_data)
{
gchar header[FILE_HEADER_LEN];
GkmDataResult res;
EggBuffer buffer;
guint32 block;
guint32 length;
gsize offset;
g_assert (file != -1);
g_assert (block_func);
/* Zero length file is valid */
if (!read_all_bytes (file, (guchar*)header, FILE_HEADER_LEN))
return TRUE;
/* Check the header */
if (memcmp (header, FILE_HEADER, FILE_HEADER_LEN) != 0) {
g_message ("invalid header in store file");
return FALSE;
}
egg_buffer_init_full (&buffer, 1024, (EggBufferAllocator)g_realloc);
res = GKM_DATA_SUCCESS;
for (;;) {
egg_buffer_reset (&buffer);
egg_buffer_resize (&buffer, 8);
offset = 0;
/* Read in a set of bytes */
if (!read_all_bytes (file, buffer.buf, 8)) {
res = GKM_DATA_SUCCESS; /* end of file */
break;
}
/* Decode it as the number of bytes in the next section */
if (!egg_buffer_get_uint32 (&buffer, offset, &offset, &length) ||
!egg_buffer_get_uint32 (&buffer, offset, &offset, &block) ||
length < 8) {
res = GKM_DATA_FAILURE;
g_message ("invalid block size or length in store file");
break;
}
/* Read in that amount of bytes */
egg_buffer_resize (&buffer, length - 8);
if (!read_all_bytes (file, buffer.buf, length - 8)) {
res = GKM_DATA_FAILURE;
break;
}
res = (block_func) (block, &buffer, login, user_data);
if (res != GKM_DATA_SUCCESS)
break;
}
egg_buffer_uninit (&buffer);
return res;
}
static gboolean
write_file_block (int file, guint block, EggBuffer *buffer)
{
EggBuffer header;
gboolean ret;
g_assert (file != -1);
g_assert (buffer);
/* Write out the 8 bytes of header */
egg_buffer_init_full (&header, 8, (EggBufferAllocator)g_realloc);
egg_buffer_add_uint32 (&header, buffer->len + 8);
egg_buffer_add_uint32 (&header, block);
g_assert (!egg_buffer_has_error (&header));
g_assert (header.len == 8);
ret = write_all_bytes (file, header.buf, header.len);
egg_buffer_uninit (&header);
if (ret != TRUE)
return FALSE;
/* Now write out the remainder of the data */
return write_all_bytes (file, buffer->buf, buffer->len);
}
static gboolean
hash_buffer (EggBuffer *buffer)
{
const gchar *salgo;
gsize length;
guchar *hash;
gsize n_hash;
int algo;
/* The length needs to be the first thing in the buffer */
g_assert (buffer->len > 4);
g_assert (egg_buffer_decode_uint32 (buffer->buf) == buffer->len);
length = buffer->len;
algo = GCRY_MD_SHA256;
salgo = gcry_md_algo_name (algo);
g_return_val_if_fail (salgo, FALSE);
n_hash = gcry_md_get_algo_dlen (algo);
g_return_val_if_fail (n_hash > 0, FALSE);
egg_buffer_add_string (buffer, salgo);
hash = egg_buffer_add_byte_array_empty (buffer, n_hash);
g_return_val_if_fail (hash, FALSE);
gcry_md_hash_buffer (algo, hash, buffer->buf, length);
return TRUE;
}
static gboolean
validate_buffer (EggBuffer *buffer, gsize *offset)
{
const guchar *hash;
gchar *salgo, *check;
gsize n_hash, hash_offset;
guint32 length;
int algo;
gboolean valid;
g_assert (buffer);
g_assert (offset);
*offset = 0;
if (!egg_buffer_get_uint32 (buffer, *offset, offset, &length) ||
!egg_buffer_get_string (buffer, length, &hash_offset, &salgo, PUBLIC_ALLOC))
return FALSE;
algo = gcry_md_map_name (salgo);
if (algo == 0) {
g_warning ("unsupported hash algorithm: %s", salgo);
g_free (salgo);
return FALSE;
}
g_free (salgo);
if (!egg_buffer_get_byte_array (buffer, hash_offset, &hash_offset, &hash, &n_hash))
return FALSE;
if (n_hash != gcry_md_get_algo_dlen (algo)) {
g_warning ("invalid hash length in store file");
return FALSE;
}
check = g_malloc0 (n_hash);
gcry_md_hash_buffer (algo, check, buffer->buf, length);
valid = (memcmp (check, hash, n_hash) == 0);
g_free (check);
return valid;
}
static gboolean
create_cipher (GkmSecret *login, int calgo, int halgo, const guchar *salt,
gsize n_salt, guint iterations, gcry_cipher_hd_t *cipher)
{
gsize n_key, n_block;
const gchar *password;
gsize n_password;
guchar *key, *iv;
gcry_error_t gcry;
g_assert (login);
g_assert (salt);
g_assert (cipher);
n_key = gcry_cipher_get_algo_keylen (calgo);
g_return_val_if_fail (n_key, FALSE);
n_block = gcry_cipher_get_algo_blklen (calgo);
g_return_val_if_fail (n_block, FALSE);
password = gkm_secret_get_password (login, &n_password);
if (!egg_symkey_generate_simple (calgo, halgo, password, n_password,
salt, n_salt, iterations, &key, &iv)) {
return FALSE;
}
gcry = gcry_cipher_open (cipher, calgo, GCRY_CIPHER_MODE_CBC, 0);
if (gcry) {
g_warning ("couldn't create cipher context: %s", gcry_strerror (gcry));
egg_secure_free (key);
g_free (iv);
return FALSE;
}
gcry = gcry_cipher_setkey (*cipher, key, n_key);
g_return_val_if_fail (!gcry, FALSE);
egg_secure_free (key);
gcry = gcry_cipher_setiv (*cipher, iv, n_block);
g_return_val_if_fail (!gcry, FALSE);
g_free (iv);
return TRUE;
}
static gboolean
encrypt_buffer (EggBuffer *input, GkmSecret *login, EggBuffer *output)
{
gcry_cipher_hd_t cipher;
gcry_error_t gcry;
guchar salt[8];
guint32 iterations;
int calgo, halgo;
const gchar *salgo;
guchar *dest;
gsize n_block;
g_assert (input);
g_assert (output);
g_assert (login);
/* The algorithms we're going to use */
calgo = GCRY_CIPHER_AES128;
halgo = GCRY_MD_SHA256;
/* Prepare us some salt */
gcry_create_nonce (salt, sizeof (salt));
/* Prepare us the iterations */
iterations = 1000 + (int) (1000.0 * rand() / (RAND_MAX + 1.0));
/* Write out crypto algorithm */
salgo = gcry_cipher_algo_name (calgo);
g_return_val_if_fail (salgo, FALSE);
egg_buffer_add_string (output, salgo);
/* Write out the hash algorithm */
salgo = gcry_md_algo_name (halgo);
g_return_val_if_fail (halgo, FALSE);
egg_buffer_add_string (output, salgo);
/* Write out the iterations */
egg_buffer_add_uint32 (output, iterations);
/* And write out the salt */
egg_buffer_add_byte_array (output, salt, sizeof (salt));
/* Okay now use the above info to create our cipher context */
if (!create_cipher (login, calgo, halgo, salt, sizeof (salt), iterations, &cipher))
return FALSE;
/* Significant block sizes */
n_block = gcry_cipher_get_algo_blklen (calgo);
g_return_val_if_fail (n_block, FALSE);
/* Pad the buffer to a multiple of block length */
while (input->len % n_block != 0)
egg_buffer_add_byte (input, 0);
/* Now reserve space for it in the output block, and encrypt */
dest = egg_buffer_add_byte_array_empty (output, input->len);
g_return_val_if_fail (dest, FALSE);
gcry = gcry_cipher_encrypt (cipher, dest, input->len, input->buf, input->len);
g_return_val_if_fail (!gcry, FALSE);
gcry_cipher_close (cipher);
return TRUE;
}
static gboolean
decrypt_buffer (EggBuffer *input, gsize *offset, GkmSecret *login, EggBuffer *output)
{
gcry_cipher_hd_t cipher;
gcry_error_t gcry;
const guchar *salt, *data;
gsize n_block, n_salt, n_data;
guint32 iterations;
int calgo, halgo;
gchar *salgo;
g_assert (input);
g_assert (output);
g_assert (offset);
g_assert (login);
/* Read in and interpret the cipher algorithm */
if (!egg_buffer_get_string (input, *offset, offset, &salgo, NULL))
return FALSE;
calgo = gcry_cipher_map_name (salgo);
if (!calgo) {
g_warning ("unsupported crypto algorithm: %s", salgo);
g_free (salgo);
return FALSE;
}
g_free (salgo);
/* Read in and interpret the hash algorithm */
if (!egg_buffer_get_string (input, *offset, offset, &salgo, NULL))
return FALSE;
halgo = gcry_md_map_name (salgo);
if (!halgo) {
g_warning ("unsupported crypto algorithm: %s", salgo);
g_free (salgo);
return FALSE;
}
g_free (salgo);
/* Read in the iterations, salt, and encrypted data */
if (!egg_buffer_get_uint32 (input, *offset, offset, &iterations) ||
!egg_buffer_get_byte_array (input, *offset, offset, &salt, &n_salt) ||
!egg_buffer_get_byte_array (input, *offset, offset, &data, &n_data))
return FALSE;
/* Significant block sizes */
n_block = gcry_cipher_get_algo_blklen (calgo);
g_return_val_if_fail (n_block, FALSE);
/* Make sure the encrypted data is of a good length */
if (n_data % n_block != 0) {
g_warning ("encrypted data in file store is of an invalid length for algorithm");
return FALSE;
}
/* Create the cipher context */
if (!create_cipher (login, calgo, halgo, salt, n_salt, iterations, &cipher))
return FALSE;
/* Now reserve space for it in the output block, and encrypt */
egg_buffer_reset (output);
egg_buffer_resize (output, n_data);
gcry = gcry_cipher_decrypt (cipher, output->buf, output->len, data, n_data);
g_return_val_if_fail (!gcry, FALSE);
gcry_cipher_close (cipher);
return TRUE;
}
/* ----------------------------------------------------------------------------------------
* INTERNAL
*/
static GkmDataResult
update_entries_from_block (GkmGnome2File *self, guint section, GHashTable *entries,
EggBuffer *buffer, gsize *offset)
{
GHashTable *attributes;
const gchar *identifier;
gboolean added;
CK_ATTRIBUTE_PTR at;
CK_ATTRIBUTE attr;
gpointer key, value;
guint32 n_entries, i;
guint32 n_attrs, j;
gchar *str;
guint sect;
const guchar *data;
gsize n_data;
guint64 type;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (entries);
g_assert (buffer);
g_assert (offset);
/* The number of entries */
if (!egg_buffer_get_uint32 (buffer, *offset, offset, &n_entries))
return GKM_DATA_FAILURE;
for (i = 0; i < n_entries; ++i) {
added = FALSE;
/* The attributes */
if (!egg_buffer_get_string (buffer, *offset, offset, &str, (EggBufferAllocator)g_realloc))
return GKM_DATA_FAILURE;
/* Make sure we have this one */
sect = GPOINTER_TO_UINT (g_hash_table_lookup (self->identifiers, str));
if (sect != section) {
g_message ("data file entry in wrong section: %s", str);
g_free (str);
return GKM_DATA_FAILURE;
}
/* Lookup or create a new table for it */
if (!g_hash_table_lookup_extended (entries, str, &key, &value)) {
added = TRUE;
value = attributes_new ();
key = g_strdup (str);
g_hash_table_replace (entries, key, value);
}
g_free (str);
identifier = key;
attributes = value;
if (!egg_buffer_get_uint32 (buffer, *offset, offset, &n_attrs))
return GKM_DATA_FAILURE;
for (j = 0; j < n_attrs; ++j) {
if (!egg_buffer_get_uint64 (buffer, *offset, offset, &type) ||
!egg_buffer_get_byte_array (buffer, *offset, offset, &data, &n_data))
return GKM_DATA_FAILURE;
attr.type = type;
attr.pValue = (CK_VOID_PTR)data;
attr.ulValueLen = n_data;
at = g_hash_table_lookup (attributes, &attr.type);
if (at != NULL && gkm_attribute_equal (&attr, at))
continue;
at = attribute_dup (&attr);
g_hash_table_replace (attributes, &(at->type), at);
/* Only emit the changed signal if we haven't just added this one */
if (added == FALSE)
g_signal_emit (self, signals[ENTRY_CHANGED], 0, identifier, attr.type);
}
/* A new entry was loaded */
if (added == TRUE)
g_signal_emit (self, signals[ENTRY_ADDED], 0, identifier);
}
return GKM_DATA_SUCCESS;
}
static GkmDataResult
update_from_public_block (GkmGnome2File *self, EggBuffer *buffer)
{
gsize offset = 0;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
self->sections |= GKM_GNOME2_FILE_SECTION_PUBLIC;
/* Validate the buffer hash, failure in this case is corruption */
if (!validate_buffer (buffer, &offset))
return GKM_DATA_FAILURE;
return update_entries_from_block (self, GKM_GNOME2_FILE_SECTION_PUBLIC,
self->publics, buffer, &offset);
}
static GkmDataResult
update_from_private_block (GkmGnome2File *self, EggBuffer *buffer, GkmSecret *login)
{
EggBuffer custom;
GkmDataResult res;
gsize offset;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
self->sections |= GKM_GNOME2_FILE_SECTION_PRIVATE;
/* Skip private blocks when not unlocked */
if (login == NULL) {
if (self->privates)
g_hash_table_destroy (self->privates);
self->privates = NULL;
return GKM_DATA_UNRECOGNIZED;
}
offset = 0;
egg_buffer_init_full (&custom, 1024, egg_secure_realloc);
/* Decrypt the buffer */
if (!decrypt_buffer (buffer, &offset, login, &custom)) {
egg_buffer_uninit (&custom);
return GKM_DATA_FAILURE;
}
offset = 0;
/* Validate the buffer hash, failure is usually a bad password */
if (!validate_buffer (&custom, &offset)) {
egg_buffer_uninit (&custom);
return GKM_DATA_LOCKED;
}
/* We're loading privates, so fill that in */
if (!self->privates)
self->privates = entries_new ();
res = update_entries_from_block (self, GKM_GNOME2_FILE_SECTION_PRIVATE,
self->privates, &custom, &offset);
egg_buffer_uninit (&custom);
return res;
}
static void
copy_each_identifier (gpointer key, gpointer value, gpointer data)
{
g_hash_table_insert (data, g_strdup (key), UNUSED_VALUE);
}
static void
remove_each_identifier (gpointer key, gpointer value, gpointer data)
{
GkmGnome2File *self = GKM_GNOME2_FILE (data);
GHashTable *entries;
guint section;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (key);
if (!gkm_gnome2_file_lookup_entry (self, key, §ion))
g_assert_not_reached ();
if (section == GKM_GNOME2_FILE_SECTION_PRIVATE)
entries = self->privates;
else
entries = self->publics;
if (!g_hash_table_remove (self->identifiers, key))
g_assert_not_reached ();
if (entries != NULL) {
if (!g_hash_table_remove (entries, key))
g_return_if_reached ();
/*
* Note that we only fire the removed signal when the identifier
* was accessible. We don't fire removed for private items in
* a locked file.
*/
g_signal_emit (self, signals[ENTRY_REMOVED], 0, key);
}
}
static GkmDataResult
update_from_index_block (GkmGnome2File *self, EggBuffer *buffer)
{
gchar *identifier;
gsize offset;
guint section;
guint count, i;
guint value;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
offset = 0;
/* The number of entries */
if (!egg_buffer_get_uint32 (buffer, offset, &offset, &count))
return FALSE;
for (i = 0; i < count; ++i) {
/* The identifier */
if (!egg_buffer_get_string (buffer, offset, &offset, &identifier, (EggBufferAllocator)g_realloc))
break;
/* The section */
if (!egg_buffer_get_uint32 (buffer, offset, &offset, &value)) {
g_free (identifier);
break;
}
section = value;
g_hash_table_replace (self->identifiers, identifier, GUINT_TO_POINTER (section));
/* Track that we've seen this identifier */
g_hash_table_remove (self->checks, identifier);
}
/* Completed reading all */
if (i == count)
return GKM_DATA_SUCCESS;
/* Failed for some reason, data is bad */
return GKM_DATA_FAILURE;
}
static GkmDataResult
update_from_any_block (guint block, EggBuffer *buffer, GkmSecret *login, gpointer user_data)
{
UnknownBlock *unknown;
GkmGnome2File *self;
GkmDataResult res;
g_assert (GKM_IS_GNOME2_FILE (user_data));
self = GKM_GNOME2_FILE (user_data);
switch (block) {
case FILE_BLOCK_INDEX:
res = update_from_index_block (self, buffer);
break;
case FILE_BLOCK_PRIVATE:
res = update_from_private_block (self, buffer, login);
break;
case FILE_BLOCK_PUBLIC:
res = update_from_public_block (self, buffer);
break;
default:
res = GKM_DATA_UNRECOGNIZED;
break;
};
/* If unrecognized data block, then stash as unknown */
if (res == GKM_DATA_UNRECOGNIZED) {
unknown = g_slice_new0 (UnknownBlock);
unknown->type = block;
egg_buffer_init_full (&unknown->buffer, buffer->len, PUBLIC_ALLOC);
egg_buffer_append (&unknown->buffer, buffer->buf, buffer->len);
self->unknowns = g_list_prepend (self->unknowns, unknown);
res = GKM_DATA_SUCCESS;
}
return res;
}
static void
write_each_attribute (gpointer key, gpointer value, gpointer data)
{
CK_ATTRIBUTE_PTR attr = value;
EggBuffer *buffer = data;
egg_buffer_add_uint64 (buffer, attr->type);
g_assert (attr->ulValueLen != (gulong)-1);
egg_buffer_add_byte_array (buffer, attr->pValue, attr->ulValueLen);
}
static void
write_each_entry (gpointer key, gpointer value, gpointer data)
{
EggBuffer *buffer = data;
const gchar *unique = key;
GHashTable *attributes = value;
egg_buffer_add_string (buffer, unique);
egg_buffer_add_uint32 (buffer, g_hash_table_size (attributes));
g_hash_table_foreach (attributes, write_each_attribute, buffer);
}
static GkmDataResult
write_entries_to_block (GkmGnome2File *self, GHashTable *entries, EggBuffer *buffer)
{
gsize offset;
g_assert (GKM_GNOME2_FILE (self));
g_assert (entries);
g_assert (buffer);
/* Reserve space for the length */
offset = buffer->len;
egg_buffer_add_uint32 (buffer, 0);
/* The number of attributes we'll be encountering */
egg_buffer_add_uint32 (buffer, g_hash_table_size (entries));
/* Fill in the attributes */
g_hash_table_foreach (entries, write_each_entry, buffer);
g_return_val_if_fail (!egg_buffer_has_error (buffer), GKM_DATA_FAILURE);
/* Fill in the length */
egg_buffer_set_uint32 (buffer, offset, buffer->len);
/* Hash the entire dealio */
if (!hash_buffer (buffer))
return GKM_DATA_FAILURE;
return GKM_DATA_SUCCESS;
}
static GkmDataResult
write_private_to_block (GkmGnome2File *self, EggBuffer *buffer, GkmSecret *login)
{
EggBuffer secure;
GkmDataResult res;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
if (login == NULL) {
/* Must lock the private data in some way */
if (self->privates && g_hash_table_size (self->privates))
return GKM_DATA_LOCKED;
/* Not storing privates */
else
return GKM_DATA_UNRECOGNIZED;
} else {
/* We didn't load the privates, can't store them back */
if (self->privates == NULL)
return GKM_DATA_LOCKED;
}
egg_buffer_init_full (&secure, 1024, PRIVATE_ALLOC);
res = write_entries_to_block (self, self->privates, &secure);
if (res == GKM_DATA_SUCCESS)
res = encrypt_buffer (&secure, login, buffer);
egg_buffer_uninit (&secure);
return res;
}
static GkmDataResult
write_public_to_block (GkmGnome2File *self, EggBuffer *buffer)
{
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
return write_entries_to_block (self, self->publics, buffer);
}
static void
write_each_index_identifier (gpointer key, gpointer value, gpointer data)
{
egg_buffer_add_string (data, key);
egg_buffer_add_uint32 (data, GPOINTER_TO_UINT (value));
}
static GkmDataResult
write_index_to_block (GkmGnome2File *self, EggBuffer *buffer)
{
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (buffer);
/* The number of entries */
egg_buffer_add_uint32 (buffer, g_hash_table_size (self->identifiers));
/* Now write out all the entries */
g_hash_table_foreach (self->identifiers, write_each_index_identifier, buffer);
return egg_buffer_has_error (buffer) ? GKM_DATA_FAILURE : GKM_DATA_SUCCESS;
}
static GkmDataResult
identifier_to_attributes (GkmGnome2File *self, const gchar *identifier, GHashTable **attributes)
{
GHashTable *entries;
gpointer value;
guint section;
g_assert (GKM_IS_GNOME2_FILE (self));
g_assert (identifier);
g_assert (attributes);
if (!g_hash_table_lookup_extended (self->identifiers, identifier, NULL, &value))
return GKM_DATA_UNRECOGNIZED;
section = GPOINTER_TO_UINT (value);
if (section == GKM_GNOME2_FILE_SECTION_PRIVATE)
entries = self->privates;
else
entries = self->publics;
if (entries == NULL)
return GKM_DATA_LOCKED;
*attributes = g_hash_table_lookup (entries, identifier);
g_return_val_if_fail (*attributes, GKM_DATA_UNRECOGNIZED);
return GKM_DATA_SUCCESS;
}
static void
free_unknown_block_list (GList *list)
{
UnknownBlock *unknown;
GList *l;
for (l = list; l; l = g_list_next (l)) {
unknown = l->data;
g_assert (unknown);
egg_buffer_uninit (&unknown->buffer);
g_slice_free (UnknownBlock, unknown);
}
g_list_free (list);
}
static gint
sort_unknowns_by_type (gconstpointer a, gconstpointer b)
{
const UnknownBlock *ua = a;
const UnknownBlock *ub = b;
g_assert (ua);
g_assert (ub);
if (ua->type == ub->type)
return 0;
return ua->type > ub->type ? 1 : -1;
}
typedef struct _ForeachArgs {
GkmGnome2File *self;
GkmGnome2FileFunc func;
gpointer user_data;
} ForeachArgs;
static void
foreach_identifier (gpointer key, gpointer value, gpointer data)
{
ForeachArgs *args = data;
g_assert (GKM_IS_GNOME2_FILE (args->self));
(args->func) (args->self, key, args->user_data);
}
static void
dump_attributes (gpointer key, gpointer value, gpointer user_data)
{
CK_ATTRIBUTE_PTR attr = value;
gulong *type = key;
gchar *text;
g_assert (type);
g_assert (value);
if (attr->pValue == NULL)
text = g_strdup ("NULL");
else
text = egg_hex_encode_full (attr->pValue, attr->ulValueLen, TRUE, " ", 1);
g_print ("\t0x%08x: %s\n", (guint)*type, text);
g_free (text);
}
static void
dump_identifier_and_attributes (GkmGnome2File *self, const gchar *identifier, gpointer user_data)
{
GHashTable *attributes;
guint section;
g_assert (GKM_IS_GNOME2_FILE (self));
if (!gkm_gnome2_file_lookup_entry (self, identifier, §ion))
g_assert_not_reached ();
if (GPOINTER_TO_UINT (user_data) == section) {
g_print ("%s\n", identifier);
if (identifier_to_attributes (self, identifier, &attributes) != GKM_DATA_SUCCESS)
g_assert_not_reached ();
g_hash_table_foreach (attributes, dump_attributes, NULL);
g_print ("\n");
}
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static void
gkm_gnome2_file_init (GkmGnome2File *self)
{
self->identifiers = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
self->publics = entries_new ();
self->privates = entries_new ();
self->unknowns = NULL;
self->checks = NULL;
}
static void
gkm_gnome2_file_finalize (GObject *obj)
{
GkmGnome2File *self = GKM_GNOME2_FILE (obj);
g_assert (self->identifiers);
g_hash_table_destroy (self->identifiers);
self->identifiers = NULL;
g_assert (self->checks == NULL);
g_assert (self->publics);
g_hash_table_destroy (self->publics);
self->publics = NULL;
if (self->privates)
g_hash_table_destroy (self->privates);
self->privates = NULL;
free_unknown_block_list (self->unknowns);
self->unknowns = NULL;
G_OBJECT_CLASS (gkm_gnome2_file_parent_class)->finalize (obj);
}
static void
gkm_gnome2_file_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_file_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_file_class_init (GkmGnome2FileClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = gkm_gnome2_file_finalize;
gobject_class->set_property = gkm_gnome2_file_set_property;
gobject_class->get_property = gkm_gnome2_file_get_property;
signals[ENTRY_ADDED] = g_signal_new ("entry-added", GKM_TYPE_GNOME2_FILE,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmGnome2FileClass, entry_added),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
signals[ENTRY_CHANGED] = g_signal_new ("entry-changed", GKM_TYPE_GNOME2_FILE,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmGnome2FileClass, entry_changed),
NULL, NULL, gkm_marshal_VOID__STRING_ULONG,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_ULONG);
signals[ENTRY_REMOVED] = g_signal_new ("entry-removed", GKM_TYPE_GNOME2_FILE,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmGnome2FileClass, entry_removed),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
}
/* -----------------------------------------------------------------------------
* PUBLIC
*/
GkmGnome2File*
gkm_gnome2_file_new (void)
{
return g_object_new (GKM_TYPE_GNOME2_FILE, NULL);
}
GkmDataResult
gkm_gnome2_file_read_fd (GkmGnome2File *self, int fd, GkmSecret *login)
{
GkmDataResult res;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
/* Reads are not reentrant for a single data file */
g_return_val_if_fail (self->checks == NULL, GKM_DATA_FAILURE);
self->sections = 0;
/* Free all the old unknowns */
free_unknown_block_list (self->unknowns);
self->unknowns = NULL;
/* Setup a hash table to monitor the actual data read */
self->checks = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_foreach (self->identifiers, copy_each_identifier, self->checks);
res = parse_file_blocks (fd, update_from_any_block, login, self);
if (res == GKM_DATA_SUCCESS) {
/* Our last read was a success, can write */
self->incomplete = FALSE;
/* Remove the ones we didn't see */
g_hash_table_foreach (self->checks, remove_each_identifier, self);
/*
* There's a special where we've read a file without a private section.
* We should be ready to accept privates (and then lock them next
* time around).
*/
if (self->privates == NULL && !(self->sections & GKM_GNOME2_FILE_SECTION_PRIVATE))
self->privates = entries_new ();
/* Note that our last read failed */
} else {
self->incomplete = TRUE;
}
g_hash_table_destroy (self->checks);
self->checks = NULL;
return res;
}
GkmDataResult
gkm_gnome2_file_write_fd (GkmGnome2File *self, int fd, GkmSecret *login)
{
guint types[3] = { FILE_BLOCK_INDEX, FILE_BLOCK_PRIVATE, FILE_BLOCK_PUBLIC };
GList *unknowns, *unk;
UnknownBlock *block;
GkmDataResult res;
EggBuffer buffer;
guint type;
gint i;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (!self->incomplete, GKM_DATA_FAILURE);
/* Write out the header */
if (!write_all_bytes (fd, FILE_HEADER, FILE_HEADER_LEN))
return GKM_DATA_FAILURE;
unknowns = g_list_copy (self->unknowns);
unknowns = g_list_sort (unknowns, sort_unknowns_by_type);
egg_buffer_init_full (&buffer, 8192, PUBLIC_ALLOC);
/*
* All blocks are written in sorted order by their block
* type. This includes unknown blocks.
*/
unk = unknowns;
res = GKM_DATA_SUCCESS;
for (i = 0; i < G_N_ELEMENTS(types); ++i) {
type = types[i];
/* Write out all the unknowns before this block */
while (unk != NULL && res == GKM_DATA_SUCCESS) {
block = (UnknownBlock*)unk->data;
if (block->type > type)
break;
res = write_file_block (fd, block->type, &block->buffer);
unk = g_list_next (unk);
}
if (res != GKM_DATA_SUCCESS)
break;
/* Prepare the block of this type */
egg_buffer_reset (&buffer);
switch (type) {
case FILE_BLOCK_INDEX:
res = write_index_to_block (self, &buffer);
break;
case FILE_BLOCK_PRIVATE:
res = write_private_to_block (self, &buffer, login);
break;
case FILE_BLOCK_PUBLIC:
res = write_public_to_block (self, &buffer);
break;
}
/* Write it out, if we got anything */
if (res == GKM_DATA_SUCCESS)
res = write_file_block (fd, type, &buffer);
else if (res == GKM_DATA_UNRECOGNIZED)
res = GKM_DATA_SUCCESS;
if (res != GKM_DATA_SUCCESS)
break;
}
/* Write out all remaining unknowns */
while (unk != NULL && res == GKM_DATA_SUCCESS) {
block = (UnknownBlock*)unk->data;
res = write_file_block (fd, block->type, &block->buffer);
unk = g_list_next (unk);
}
g_list_free (unknowns);
egg_buffer_uninit (&buffer);
return res;
}
gboolean
gkm_gnome2_file_lookup_entry (GkmGnome2File *self, const gchar *identifier, guint *section)
{
gpointer value;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), FALSE);
g_return_val_if_fail (identifier, FALSE);
if (!g_hash_table_lookup_extended (self->identifiers, identifier, NULL, &value))
return FALSE;
if (section != NULL)
*section = GPOINTER_TO_UINT (value);
return TRUE;
}
void
gkm_gnome2_file_foreach_entry (GkmGnome2File *self, GkmGnome2FileFunc func, gpointer user_data)
{
ForeachArgs args = { self, func, user_data };
g_return_if_fail (GKM_IS_GNOME2_FILE (self));
g_return_if_fail (func);
g_hash_table_foreach (self->identifiers, foreach_identifier, &args);
}
GkmDataResult
gkm_gnome2_file_unique_entry (GkmGnome2File *self, gchar **identifier)
{
gchar *base, *ext;
guint seed = 1;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (identifier, GKM_DATA_FAILURE);
/* Check if original is unique */
if (*identifier != NULL) {
if (!gkm_gnome2_file_lookup_entry (self, *identifier, NULL))
return GKM_DATA_SUCCESS;
}
if (*identifier == NULL)
*identifier = g_strdup_printf ("object-%08x", ABS (g_random_int ()));
/* Take ownership of the identifier, and out an extension */
base = *identifier;
*identifier = NULL;
ext = strrchr (base, '.');
if (ext != NULL)
*(ext++) = '\0';
for (seed = 0; TRUE; ++seed) {
*identifier = g_strdup_printf ("%s-%d%s%s", base, seed, ext ? "." : "", ext ? ext : "");
if (!gkm_gnome2_file_lookup_entry (self, *identifier, NULL))
break;
if (seed > 1000000) {
g_warning ("couldn't find a unique identifier in a %d tries", seed);
g_free (base);
return GKM_DATA_FAILURE;
}
g_free (*identifier);
*identifier = NULL;
}
g_free (base);
return GKM_DATA_SUCCESS;
}
GkmDataResult
gkm_gnome2_file_create_entry (GkmGnome2File *self, const gchar *identifier, guint section)
{
GHashTable *attributes;
GHashTable *entries;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (identifier, GKM_DATA_FAILURE);
if (section == GKM_GNOME2_FILE_SECTION_PRIVATE) {
if (!self->privates)
return GKM_DATA_LOCKED;
entries = self->privates;
} else {
entries = self->publics;
}
/* Make sure it's not already here */
g_return_val_if_fail (g_hash_table_lookup (entries, identifier) == NULL, GKM_DATA_FAILURE);
/* Add the new entry to the appropriate table */
attributes = attributes_new ();
g_hash_table_replace (entries, g_strdup (identifier), attributes);
g_hash_table_replace (self->identifiers, g_strdup (identifier), GUINT_TO_POINTER (section));
g_signal_emit (self, signals[ENTRY_ADDED], 0, identifier);
return GKM_DATA_SUCCESS;
}
GkmDataResult
gkm_gnome2_file_destroy_entry (GkmGnome2File *self, const gchar *identifier)
{
GHashTable *entries;
guint section;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (identifier, GKM_DATA_FAILURE);
if (!gkm_gnome2_file_lookup_entry (self, identifier, §ion))
return GKM_DATA_UNRECOGNIZED;
if (section == GKM_GNOME2_FILE_SECTION_PRIVATE) {
if (!self->privates)
return GKM_DATA_LOCKED;
entries = self->privates;
} else {
entries = self->publics;
}
if (!g_hash_table_remove (self->identifiers, identifier))
g_return_val_if_reached (GKM_DATA_UNRECOGNIZED);
if (!g_hash_table_remove (entries, identifier))
g_return_val_if_reached (GKM_DATA_UNRECOGNIZED);
g_signal_emit (self, signals[ENTRY_REMOVED], 0, identifier);
return GKM_DATA_SUCCESS;
}
GkmDataResult
gkm_gnome2_file_write_value (GkmGnome2File *self, const gchar *identifier,
gulong type, gconstpointer value, gsize n_value)
{
GHashTable *attributes;
CK_ATTRIBUTE_PTR at;
CK_ATTRIBUTE attr;
GkmDataResult res;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (identifier, GKM_DATA_FAILURE);
g_return_val_if_fail (value || !n_value, GKM_DATA_FAILURE);
/* Find the right set of attributes */
res = identifier_to_attributes (self, identifier, &attributes);
if (res != GKM_DATA_SUCCESS)
return res;
attr.type = type;
attr.pValue = (void*)value;
attr.ulValueLen = n_value;
at = g_hash_table_lookup (attributes, &type);
if (at != NULL && gkm_attribute_equal (at, &attr))
return GKM_DATA_SUCCESS;
at = attribute_dup (&attr);
g_hash_table_replace (attributes, &(at->type), at);
g_signal_emit (self, signals[ENTRY_CHANGED], 0, identifier, type);
return GKM_DATA_SUCCESS;
}
GkmDataResult
gkm_gnome2_file_read_value (GkmGnome2File *self, const gchar *identifier,
gulong type, gconstpointer *value, gsize *n_value)
{
CK_ATTRIBUTE_PTR attr;
GHashTable *attributes;
GkmDataResult res;
g_return_val_if_fail (GKM_IS_GNOME2_FILE (self), GKM_DATA_FAILURE);
g_return_val_if_fail (identifier, GKM_DATA_FAILURE);
g_return_val_if_fail (value, GKM_DATA_FAILURE);
g_return_val_if_fail (n_value, GKM_DATA_FAILURE);
/* Find the right set of attributes */
res = identifier_to_attributes (self, identifier, &attributes);
if (res != GKM_DATA_SUCCESS)
return res;
attr = g_hash_table_lookup (attributes, &type);
if (attr == NULL)
return GKM_DATA_UNRECOGNIZED;
g_assert (attr->type == type);
*value = attr->pValue;
*n_value = attr->ulValueLen;
return GKM_DATA_SUCCESS;
}
gboolean
gkm_gnome2_file_have_section (GkmGnome2File *self, guint section)
{
return (self->sections & section) ? TRUE : FALSE;
}
void
gkm_gnome2_file_dump (GkmGnome2File *self)
{
g_print ("PUBLIC:\n\n");
gkm_gnome2_file_foreach_entry (self, dump_identifier_and_attributes,
GUINT_TO_POINTER (GKM_GNOME2_FILE_SECTION_PUBLIC));
g_print ("PRIVATE:\n\n");
gkm_gnome2_file_foreach_entry (self, dump_identifier_and_attributes,
GUINT_TO_POINTER (GKM_GNOME2_FILE_SECTION_PRIVATE));
}