static gpointer
run_client_thread (gpointer data)
{
gint *socket = data;
GkdSshAgentCall call;
EggBuffer req;
EggBuffer resp;
guchar op;
g_assert (GP11_IS_MODULE (pkcs11_module));
memset (&call, 0, sizeof (call));
call.sock = g_atomic_int_get (socket);
g_assert (call.sock != -1);
egg_buffer_init_full (&req, 128, egg_secure_realloc);
egg_buffer_init_full (&resp, 128, (EggBufferAllocator)g_realloc);
call.req = &req;
call.resp = &resp;
call.module = g_object_ref (pkcs11_module);
for (;;) {
egg_buffer_reset (call.req);
/* 1. Read in the request */
if (!read_packet_with_size (&call))
break;
/* 2. Now decode the operation */
if (!egg_buffer_get_byte (call.req, 4, NULL, &op))
break;
if (op >= GKD_SSH_OP_MAX)
break;
g_assert (gkd_ssh_agent_operations[op]);
/* 3. Execute the right operation */
egg_buffer_reset (call.resp);
egg_buffer_add_uint32 (call.resp, 0);
if (!(gkd_ssh_agent_operations[op]) (&call))
break;
if (!egg_buffer_set_uint32 (call.resp, 0, call.resp->len - 4))
break;
/* 4. Write the reply back out */
if (!write_all (call.sock, call.resp->buf, call.resp->len))
break;
}
egg_buffer_uninit (&req);
egg_buffer_uninit (&resp);
g_object_unref (call.module);
close (call.sock);
g_atomic_int_set (socket, -1);
return NULL;
}
GkmRpcMessage*
gkm_rpc_message_new (EggBufferAllocator allocator)
{
GkmRpcMessage *msg;
assert (allocator);
msg = (GkmRpcMessage*) (allocator)(NULL, sizeof (GkmRpcMessage));
if (!msg)
return NULL;
memset (msg, 0, sizeof (*msg));
if (!egg_buffer_init_full (&msg->buffer, 64, allocator)) {
(allocator) (msg, 0); /* Frees allocation */
return NULL;
}
gkm_rpc_message_reset (msg);
return msg;
}
GkmDataResult
gkm_secret_binary_write (GkmSecretCollection *collection, GkmSecretData *sdata,
gpointer *data, gsize *n_data)
{
GkmSecretObject *obj;
EggBuffer to_encrypt;
GkmSecret *master;
guchar digest[16];
EggBuffer buffer;
gint hash_iterations;
gint lock_timeout;
guchar salt[8];
guint flags = 0;
int i;
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);
g_return_val_if_fail (gcry_md_get_algo_dlen (GCRY_MD_MD5) == sizeof (digest), GKM_DATA_FAILURE);
obj = GKM_SECRET_OBJECT (collection);
egg_buffer_init_full (&buffer, 256, g_realloc);
/* Prepare the keyring for encryption */
hash_iterations = g_random_int_range (1000, 4096);
gcry_create_nonce (salt, sizeof (salt));
egg_buffer_append (&buffer, (guchar*)KEYRING_FILE_HEADER, KEYRING_FILE_HEADER_LEN);
egg_buffer_add_byte (&buffer, 0); /* Major version */
egg_buffer_add_byte (&buffer, 0); /* Minor version */
egg_buffer_add_byte (&buffer, 0); /* crypto (0 == AES) */
egg_buffer_add_byte (&buffer, 0); /* hash (0 == MD5) */
buffer_add_utf8_string (&buffer, gkm_secret_object_get_label (obj));
buffer_add_time (&buffer, gkm_secret_object_get_modified (obj));
buffer_add_time (&buffer, gkm_secret_object_get_created (obj));
lock_timeout = gkm_secret_collection_get_lock_idle (collection);
if (lock_timeout) {
flags |= LOCK_ON_IDLE_FLAG;
} else {
lock_timeout = gkm_secret_collection_get_lock_after (collection);
if (lock_timeout)
flags |= LOCK_AFTER_FLAG;
}
egg_buffer_add_uint32 (&buffer, flags);
egg_buffer_add_uint32 (&buffer, lock_timeout);
egg_buffer_add_uint32 (&buffer, hash_iterations);
egg_buffer_append (&buffer, salt, 8);
/* Reserved: */
for (i = 0; i < 4; i++)
egg_buffer_add_uint32 (&buffer, 0);
/* Hashed items: */
generate_hashed_items (collection, &buffer);
/* Encrypted data. Use non-pageable memory */
egg_buffer_init_full (&to_encrypt, 4096, egg_secure_realloc);
egg_buffer_append (&to_encrypt, (guchar*)digest, 16); /* Space for hash */
if (!generate_encrypted_data (&to_encrypt, collection, sdata)) {
egg_buffer_uninit (&to_encrypt);
egg_buffer_uninit (&buffer);
return GKM_DATA_FAILURE;
}
/* Pad with zeros to multiple of 16 bytes */
while (to_encrypt.len % 16 != 0)
egg_buffer_add_byte (&to_encrypt, 0);
gcry_md_hash_buffer (GCRY_MD_MD5, (void*)digest,
(guchar*)to_encrypt.buf + 16, to_encrypt.len - 16);
memcpy (to_encrypt.buf, digest, 16);
/* If no master password is set, we shouldn't be writing binary... */
master = gkm_secret_data_get_master (sdata);
g_return_val_if_fail (master, GKM_DATA_FAILURE);
if (!encrypt_buffer (&to_encrypt, master, salt, hash_iterations)) {
egg_buffer_uninit (&buffer);
egg_buffer_uninit (&to_encrypt);
return GKM_DATA_FAILURE;
}
if (egg_buffer_has_error (&to_encrypt) || egg_buffer_has_error (&buffer)) {
egg_buffer_uninit (&buffer);
egg_buffer_uninit (&to_encrypt);
return GKM_DATA_FAILURE;
}
egg_buffer_add_uint32 (&buffer, to_encrypt.len);
egg_buffer_append (&buffer, to_encrypt.buf, to_encrypt.len);
egg_buffer_uninit (&to_encrypt);
*data = egg_buffer_uninit_steal (&buffer, n_data);
return GKM_DATA_SUCCESS;
}
