int gkm_rpc_message_write_version (GkmRpcMessage *msg, CK_VERSION* version) { assert (msg); assert (version); /* Check that we're supposed to have this at this point */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "v")); egg_buffer_add_byte (&msg->buffer, version->major); egg_buffer_add_byte (&msg->buffer, version->minor); return !egg_buffer_has_error (&msg->buffer); }
int gkm_rpc_message_write_byte (GkmRpcMessage *msg, CK_BYTE val) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "y")); return egg_buffer_add_byte (&msg->buffer, val); }
int gkm_rpc_message_write_byte_array (GkmRpcMessage *msg, CK_BYTE_PTR arr, CK_ULONG num) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "ay")); /* No array, no data, just length */ if (!arr) { egg_buffer_add_byte (&msg->buffer, 0); egg_buffer_add_uint32 (&msg->buffer, num); } else { egg_buffer_add_byte (&msg->buffer, 1); egg_buffer_add_byte_array (&msg->buffer, arr, num); } return !egg_buffer_has_error (&msg->buffer); }
int gkm_rpc_message_write_ulong_array (GkmRpcMessage *msg, CK_ULONG_PTR array, CK_ULONG n_array) { CK_ULONG i; assert (msg); /* Check that we're supposed to have this at this point */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "au")); /* We send a byte which determines whether there's actual data present or not */ egg_buffer_add_byte (&msg->buffer, array ? 1 : 0); egg_buffer_add_uint32 (&msg->buffer, n_array); /* Now send the data if valid */ if (array) { for (i = 0; i < n_array; ++i) egg_buffer_add_uint64 (&msg->buffer, array[i]); } return !egg_buffer_has_error (&msg->buffer); }
int gkm_rpc_message_write_attribute_array (GkmRpcMessage *msg, CK_ATTRIBUTE_PTR arr, CK_ULONG num) { CK_ULONG i; CK_ATTRIBUTE_PTR attr; unsigned char validity; assert (!num || arr); assert (msg); /* Make sure this is in the rigth order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "aA")); /* Write the number of items */ egg_buffer_add_uint32 (&msg->buffer, num); for (i = 0; i < num; ++i) { attr = &(arr[i]); /* The attribute type */ egg_buffer_add_uint32 (&msg->buffer, attr->type); /* Write out the attribute validity */ validity = (((CK_LONG)attr->ulValueLen) == -1) ? 0 : 1; egg_buffer_add_byte (&msg->buffer, validity); /* The attribute length and value */ if (validity) { egg_buffer_add_uint32 (&msg->buffer, attr->ulValueLen); egg_buffer_add_byte_array (&msg->buffer, attr->pValue, attr->ulValueLen); } } return !egg_buffer_has_error (&msg->buffer); }
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; }