Fixes decryption share calculation, adds lots of debugging statements.

2 files changed, 77 insertions, 15 deletions

diff --git a/libcmix/cmix.c b/libcmix/cmix.c
index a47a9fa..4465011 100644
--- a/libcmix/cmix.c
+++ b/libcmix/cmix.c
@@ -46,7 +46,6 @@ struct CMixContext initialize_cmix_context(struct Api api) {
 		.s = NULL,
 		.permutation = NULL,
 		.pirs = NULL,
-		.messages = NULL
 	};
 }
 
@@ -55,13 +54,11 @@ void release_mix(struct CMixContext* ctx) {
 		ctx->api.free_group_element(ctx->r[i]);
 		ctx->api.free_group_element(ctx->s[i]);
 		ctx->api.free_group_element(ctx->pirs[i]);
-		ctx->api.free_group_element(ctx->messages[i]);
 	}
 	free(ctx->r);
 	free(ctx->s);
 	free(ctx->permutation);
 	free(ctx->pirs);
-	free(ctx->messages);
 }
 
 void deinitialize(struct CMixContext* ctx)
@@ -71,7 +68,7 @@ void deinitialize(struct CMixContext* ctx)
 	ctx->api.deinitialize();
 }
 
-void element_to_buffer(struct CMixContext const* ctx, char* out_buffer, GroupElement element) {
+void element_to_buffer(struct CMixContext const* ctx, char* out_buffer, GroupElement const element) {
 	size_t el_size = get_group_element_array_size(ctx);
 	
 	unsigned char* buffer;
@@ -110,8 +107,7 @@ enum cmix_error alloc_mix(struct CMixContext* ctx) {
 	ctx->s = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
 	ctx->permutation = (unsigned int*) calloc(ctx->nr_participants, sizeof(unsigned int));
 	ctx->pirs = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
-	ctx->pirs = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
-	if(!ctx->r || !ctx->s || !ctx->permutation || !ctx->pirs || !ctx->messages) {
+	if(!ctx->r || !ctx->s || !ctx->permutation || !ctx->pirs) {
 		return out_of_memory;
 	}
 	return no_error;
@@ -132,8 +128,11 @@ enum cmix_error initialize_mix_randomness(struct CMixContext* ctx) {
 	return no_error;
 }
 
-enum cmix_error generate_random_message(struct CMixContext* ctx, size_t index) {
-	ctx->messages[index] = ctx->api.get_group_element(true);
+enum cmix_error generate_random_message(struct CMixContext* ctx, char* buffer) {
+	GroupElement el = ctx->api.get_group_element(true);
+	element_to_buffer(ctx, buffer, el);
+	ctx->api.free_group_element(el);
+	
 	return no_error;
 }
 
@@ -185,7 +184,7 @@ enum cmix_error encrypt_r_and_multiply(struct CMixContext const* ctx, char* rand
 	return no_error;
 }
 
-enum cmix_error multiply_s(struct CMixContext const* ctx, char* r_out_buffer, char* m_out_buffer, char const* r_in_buffer, char const* m_in_buffer, size_t index) {
+enum cmix_error multiply_encrypted_s(struct CMixContext const* ctx, char* r_out_buffer, char* m_out_buffer, char const* r_in_buffer, char const* m_in_buffer, size_t index) {
 	size_t el_size = get_group_element_array_size(ctx);
 	
 	GroupElement random_r = ctx->api.array_to_element(r_in_buffer, el_size, true);
@@ -210,9 +209,23 @@ enum cmix_error multiply_s(struct CMixContext const* ctx, char* r_out_buffer, ch
 	return no_error;
 }
 
+enum cmix_error multiply_s(struct CMixContext const* ctx, char* out_buffer, char const* message, size_t index) {
+	size_t el_size = get_group_element_array_size(ctx);
+	
+	GroupElement message_el = ctx->api.array_to_element(message, el_size, false);
+	GroupElement mult = ctx->api.multiply(message_el, ctx->s[ctx->permutation[index]], false);
+	
+	element_to_buffer(ctx, out_buffer, mult);
+	
+	ctx->api.free_group_element(message_el);
+	ctx->api.free_group_element(mult);
+	
+	return no_error;
+}
+
 enum cmix_error key_exchange_init(struct CMixContext const* ctx, char* pubkey_buffer, char* value_buffer, GroupElement* priv_el) {
 	*priv_el = ctx->api.get_group_element(true);
-	GroupElement value = ctx->api.get_key_exchange_value(priv_el);
+	GroupElement value = ctx->api.get_key_exchange_value(*priv_el);
 	
 	get_public_key(ctx, pubkey_buffer);
 	element_to_buffer(ctx, value_buffer, value);
@@ -239,7 +252,7 @@ enum cmix_error key_exchange_responder(struct CMixContext const* ctx, GroupEleme
 
 enum cmix_error key_exchange_initiator(struct CMixContext const* ctx, GroupElement* shared_key, char const* pubkey, char const* value, GroupElement* priv_el) {
 	size_t el_len = get_group_element_array_size(ctx);
-	*shared_key = ctx->api.derive_shared_key(ctx->keypair, (unsigned char*)pubkey, el_len, (unsigned char*)value, el_len, priv_el, false);
+	*shared_key = ctx->api.derive_shared_key(ctx->keypair, (unsigned char*)pubkey, el_len, (unsigned char*)value, el_len, *priv_el, false);
 	
 	ctx->api.free_group_element(*priv_el);
 	*priv_el = NULL;
@@ -250,17 +263,20 @@ enum cmix_error key_exchange_initiator(struct CMixContext const* ctx, GroupEleme
 enum cmix_error post_process(struct CMixContext* ctx, char* r_out, char* m_out, char const* r_epirs, char const* m_epirs, size_t index) {
 	GroupElement x = ctx->api.array_to_element(r_epirs, get_group_element_array_size(ctx), true);
 	GroupElement D = ctx->api.get_decryption_share(x, ctx->keypair.sec);
-	element_to_buffer(ctx, r_out, D);
+	//element_to_buffer(ctx, r_out, D);
 	
 	GroupElement msg = ctx->api.array_to_element(m_epirs, get_group_element_array_size(ctx), true);
 	GroupElement pirs = ctx->api.multiply(D, msg, true);
 	element_to_buffer(ctx, m_out, pirs);
+	GroupElement new_r = ctx->api.multiply(x, D, true);
+	element_to_buffer(ctx, r_out, new_r);
 	
 	ctx->pirs[index] = pirs; // this is not always usable as only the last node will be able to use this effectively, but we store it anyways.
 	
 	ctx->api.free_group_element(x);
 	ctx->api.free_group_element(D);
 	ctx->api.free_group_element(msg);
+	ctx->api.free_group_element(new_r);
 	
 	return no_error;
 }
@@ -280,3 +296,36 @@ enum cmix_error blind_message(struct CMixContext const* ctx, char* m_out, char c
 	
 	return no_error;
 }
+
+enum cmix_error swap_k_for_r(struct CMixContext const* ctx, char* out_buffer, char const* message, GroupElement const key, size_t index) {
+	size_t len = get_group_element_array_size(ctx);
+	
+	GroupElement mes = ctx->api.array_to_element(message, len, false);
+	GroupElement inv_key = ctx->api.invert(key);
+	
+	GroupElement unblinded = ctx->api.multiply(mes, inv_key, false);
+	GroupElement blinded = ctx->api.multiply(unblinded, ctx->r[index], false);
+	
+	element_to_buffer(ctx, out_buffer, blinded);
+	ctx->api.free_group_element(mes);
+	ctx->api.free_group_element(inv_key);
+	ctx->api.free_group_element(unblinded);
+	ctx->api.free_group_element(blinded);
+	
+	return no_error;
+}
+
+enum cmix_error remove_r_and_s(struct CMixContext const* ctx, char* out_buffer, char const* message, size_t index) {
+	size_t len = get_group_element_array_size(ctx);
+	
+	GroupElement mes = ctx->api.array_to_element(message, len, false);
+	GroupElement inv_pirs = ctx->api.invert(ctx->pirs[index]);
+	
+	GroupElement mult = ctx->api.multiply(mes, inv_pirs, false);
+	
+	element_to_buffer(ctx, out_buffer, mult);
+	
+	ctx->api.free_group_element(mes);
+	ctx->api.free_group_element(inv_pirs);
+	ctx->api.free_group_element(mult);
+}
diff --git a/libcmix/cmix.h b/libcmix/cmix.h
index 33b99d2..ba0b826 100644
--- a/libcmix/cmix.h
+++ b/libcmix/cmix.h
@@ -78,9 +78,12 @@ struct CMixContext {
 	GroupElement* s;
 	unsigned int* permutation;
 	GroupElement* pirs;
-	GroupElement* messages;
 };
 
+#ifndef NDEBUG
+void element_to_buffer(struct CMixContext const* ctx, char* buffer, GroupElement const element);
+#endif
+
 struct CMixContext initialize_cmix_context(struct Api api);
 
 void deinitialize(struct CMixContext* ctx);
@@ -95,7 +98,7 @@ enum cmix_error start_mix(struct CMixContext* ctx, size_t nr_participants);
 
 enum cmix_error initialize_mix_randomness(struct CMixContext* ctx);
 
-enum cmix_error generate_random_message(struct CMixContext* ctx, size_t index);
+enum cmix_error generate_random_message(struct CMixContext* ctx, char* buffer);
 
 size_t get_group_element_array_size(struct CMixContext const* ctx);
 
@@ -105,7 +108,9 @@ enum cmix_error encrypt_r(struct CMixContext const* ctx, char* random_buffer, ch
 
 enum cmix_error encrypt_r_and_multiply(struct CMixContext const* ctx, char* random_buffer, char* message_buffer, char const* random_element, char const* message_element, size_t index);
 
-enum cmix_error multiply_s(struct CMixContext const* ctx, char* r_out_buffer, char* m_out_buffer, char const* r_in_buffer, char const* m_in_buffer, size_t index);
+enum cmix_error multiply_encrypted_s(struct CMixContext const* ctx, char* r_out_buffer, char* m_out_buffer, char const* r_in_buffer, char const* m_in_buffer, size_t index);
+
+enum cmix_error multiply_s(struct CMixContext const* ctx, char* out_buffer, char const* message, size_t index);
 
 enum cmix_error get_key_exchange_value(struct CMixContext const* ctx, char* buffer, GroupElement priv_element);
 
@@ -119,6 +124,14 @@ enum cmix_error post_process(struct CMixContext* ctx, char* r_out, char* m_out,
 
 enum cmix_error blind_message(struct CMixContext const* ctx, char* m_out, char const* message, GroupElement const* keys, size_t const nr_nodes);
 
+enum cmix_error enqueue_message(struct CMixContext* ctx, char const* message, size_t index);
+
+enum cmix_error enqueue_random_message(struct CMixContext* ctx, size_t index);
+
+enum cmix_error swap_k_for_r(struct CMixContext const* ctx, char* out_buffer, char const* message, GroupElement const key, size_t index);
+
+enum cmix_error remove_r_and_s(struct CMixContext const* ctx, char* out_buffer, char const* message, size_t index);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif