Preparing multiple mixes

2 files changed, 197 insertions, 135 deletions

diff --git a/libcmix/cmix.c b/libcmix/cmix.c
index f697dc0..695fb05 100644
--- a/libcmix/cmix.c
+++ b/libcmix/cmix.c
@@ -9,6 +9,7 @@
 struct CMixContext initialize_cmix_context(struct Api api) {
 	return (struct CMixContext){
 		.api = api,
+		.nr_mixes = 0,
 		.nr_participants = 0,
 		.network_key = NULL,
 		.r = NULL,
@@ -21,11 +22,21 @@ struct CMixContext initialize_cmix_context(struct Api api) {
 }
 
 enum cmix_error alloc_mix(struct CMixContext* ctx) {
-	ctx->r = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
-	ctx->s = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
-	ctx->permutation = (unsigned int*) calloc(ctx->nr_participants, sizeof(unsigned int));
-	ctx->decryption_shares = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
-	ctx->EPiRS = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
+	ctx->r = (GroupElement**) calloc(ctx->nr_mixes, sizeof(GroupElement*));
+	ctx->s = (GroupElement**) calloc(ctx->nr_mixes, sizeof(GroupElement*));
+	ctx->permutation = (unsigned int**) calloc(ctx->nr_mixes, sizeof(unsigned int*));
+	ctx->decryption_shares = (GroupElement**) calloc(ctx->nr_mixes, sizeof(GroupElement*));
+	ctx->EPiRS = (GroupElement**) calloc(ctx->nr_mixes, sizeof(GroupElement*));
+
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		ctx->r[m] = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
+		ctx->s[m] = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
+		ctx->permutation[m] = (unsigned int*) calloc(ctx->nr_participants, sizeof(unsigned int));
+		ctx->decryption_shares[m] = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
+		ctx->EPiRS[m] = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
+	}
+
+
 	ctx->PiMRS = (GroupElement*) calloc(ctx->nr_participants, sizeof(GroupElement));
 	if(!ctx->r || !ctx->s || !ctx->permutation || !ctx->decryption_shares || !ctx->EPiRS || !ctx->PiMRS ) {
 		return out_of_memory;
@@ -34,13 +45,41 @@ enum cmix_error alloc_mix(struct CMixContext* ctx) {
 }
 
 void release_mix(struct CMixContext* ctx) {
+
+	if(ctx->r && ctx->s && ctx->permutation && ctx->decryption_shares && ctx->EPiRS) {
+		for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+			if(ctx->r[m]) {
+				for(size_t i = 0; i < ctx->nr_participants; ++i) {
+					ctx->api.free_group_element(ctx->r[m][i]);
+				}
+				free(ctx->r[m]);
+			}
+			if(ctx->s[m]){
+				for(size_t i = 0; i < ctx->nr_participants; ++i) {
+					ctx->api.free_group_element(ctx->s[m][i]);
+				}
+			}
+			free(ctx->permutation[m]);
+
+			if(ctx->decryption_shares[m]){
+				for(size_t i = 0; i < ctx->nr_participants; ++i) {
+					ctx->api.free_group_element(ctx->decryption_shares[m][i]);
+				}
+			}
+			if(ctx->EPiRS[m]) {
+				for(size_t i = 0; i < ctx->nr_participants; ++i) {
+					ctx->api.free_group_element(ctx->EPiRS[m][i]);
+				}
+			}
+		}
+	}
+
+
 	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		ctx->api.free_group_element(ctx->r[i]);
-		ctx->api.free_group_element(ctx->s[i]);
-		ctx->api.free_group_element(ctx->decryption_shares[i]);
-		ctx->api.free_group_element(ctx->EPiRS[i]);
+
 		ctx->api.free_group_element(ctx->PiMRS[i]);
 	}
+
 	free(ctx->r);
 	ctx->r = NULL;
 	
@@ -121,26 +160,31 @@ enum cmix_error generate_permutation(struct CMixContext* ctx) {
 		return no_error;
 	}
 	
-	for(unsigned int i = 0; i < ctx->nr_participants; ++i) {
-		ctx->permutation[i] = i;
-	}
-	
-	//Fisher-Yates shuffle
-	unsigned int temp = 0;
-	for(unsigned int i = ctx->nr_participants - 1; i > 0; --i) {
-		unsigned int rand = ctx->api.get_uniform_int(i+1);
-		temp = ctx->permutation[i];
-		ctx->permutation[i] = ctx->permutation[rand];
-		ctx->permutation[rand] = temp;
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(unsigned int i = 0; i < ctx->nr_participants; ++i) {
+			ctx->permutation[m][i] = i;
+		}
+
+		//Fisher-Yates shuffle
+		unsigned int temp = 0;
+		for(unsigned int i = ctx->nr_participants - 1; i > 0; --i) {
+			unsigned int rand = ctx->api.get_uniform_int(i+1);
+			temp = ctx->permutation[m][i];
+			ctx->permutation[m][i] = ctx->permutation[m][rand];
+			ctx->permutation[m][rand] = temp;
+		}
 	}
 
+
 	return no_error;
 }
 
 enum cmix_error initialize_mix_randomness(struct CMixContext* ctx) {
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		ctx->r[i] = ctx->api.get_group_element(true);
-		ctx->s[i] = ctx->api.get_group_element(true);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			ctx->r[m][i] = ctx->api.get_group_element(true);
+			ctx->s[m][i] = ctx->api.get_group_element(true);
+		}
 	}
 	
 	return generate_permutation(ctx);
@@ -170,47 +214,50 @@ enum cmix_error set_network_key(struct CMixContext* ctx, char const* buffer) {
 
 enum cmix_error encrypt_r(struct CMixContext const* ctx, char** random_buffer, char** message_buffer) {
 	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		GroupElement random_element;
-		GroupElement message_element;
-	
-		ctx->api.encrypt(&random_element, &message_element, ctx->r[i], ctx->network_key);
-	
-		element_to_buffer(ctx, random_buffer[i], random_element);
-		element_to_buffer(ctx, message_buffer[i], message_element);
-		
-		ctx->api.free_group_element(random_element);
-		ctx->api.free_group_element(message_element);
+	for(size_t m = 0; m < ctx->nr_mixes; m++) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			GroupElement random_element;
+			GroupElement message_element;
+
+			ctx->api.encrypt(&random_element, &message_element, ctx->r[m][i], ctx->network_key);
+
+			element_to_buffer(ctx, random_buffer[i], random_element);
+			element_to_buffer(ctx, message_buffer[i], message_element);
+
+			ctx->api.free_group_element(random_element);
+			ctx->api.free_group_element(message_element);
+		}
 	}
-	
 	return no_error;
 }
 
 enum cmix_error encrypt_r_and_multiply(struct CMixContext const* ctx, char** random_buffer, char** message_buffer, const char** random_element, const char** message_element) {
 	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		GroupElement enc_random_element;
-		GroupElement enc_message_element;
-		
-		ctx->api.encrypt(&enc_random_element, &enc_message_element, ctx->r[i], ctx->network_key);
-		
-		size_t el_size = get_group_element_array_size(ctx);
-		
-		GroupElement other_random_element = ctx->api.array_to_element(random_element[i], el_size, true);
-		GroupElement other_message_element = ctx->api.array_to_element(message_element[i], el_size, true);
-		
-		GroupElement new_random_element = ctx->api.combine(enc_random_element, other_random_element, true);
-		GroupElement new_message_element = ctx->api.combine(enc_message_element, other_message_element, true);
-		
-		element_to_buffer(ctx, random_buffer[i], new_random_element);
-		element_to_buffer(ctx, message_buffer[i], new_message_element);
-		
-		ctx->api.free_group_element(enc_random_element);
-		ctx->api.free_group_element(enc_message_element);
-		ctx->api.free_group_element(other_random_element);
-		ctx->api.free_group_element(other_message_element);
-		ctx->api.free_group_element(new_random_element);
-		ctx->api.free_group_element(new_message_element);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			GroupElement enc_random_element;
+			GroupElement enc_message_element;
+
+			ctx->api.encrypt(&enc_random_element, &enc_message_element, ctx->r[m][i], ctx->network_key);
+
+			size_t el_size = get_group_element_array_size(ctx);
+
+			GroupElement other_random_element = ctx->api.array_to_element(random_element[i], el_size, true);
+			GroupElement other_message_element = ctx->api.array_to_element(message_element[i], el_size, true);
+
+			GroupElement new_random_element = ctx->api.combine(enc_random_element, other_random_element, true);
+			GroupElement new_message_element = ctx->api.combine(enc_message_element, other_message_element, true);
+
+			element_to_buffer(ctx, random_buffer[i], new_random_element);
+			element_to_buffer(ctx, message_buffer[i], new_message_element);
+
+			ctx->api.free_group_element(enc_random_element);
+			ctx->api.free_group_element(enc_message_element);
+			ctx->api.free_group_element(other_random_element);
+			ctx->api.free_group_element(other_message_element);
+			ctx->api.free_group_element(new_random_element);
+			ctx->api.free_group_element(new_message_element);
+		}
 	}
 	
 	return no_error;
@@ -219,28 +266,30 @@ enum cmix_error encrypt_r_and_multiply(struct CMixContext const* ctx, char** ran
 enum cmix_error permute_and_multiply_encrypted_s(struct CMixContext const* ctx, char** random_buffer, char** message_buffer, char const** random_element, char const** message_element) {
 	size_t el_size = get_group_element_array_size(ctx);
 	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		unsigned int new_pos = ctx->permutation[i];
-		GroupElement random_r = ctx->api.array_to_element(random_element[i], el_size, true);
-		GroupElement message_r = ctx->api.array_to_element(message_element[i], el_size, true);
-	
-		GroupElement random_s;
-		GroupElement message_s;
-		
-		ctx->api.encrypt(&random_s, &message_s, ctx->s[new_pos], ctx->network_key);
-		
-		GroupElement random_pirs = ctx->api.combine(random_r, random_s, true);
-		GroupElement message_pirs = ctx->api.combine(message_r, message_s, true);
-		
-		element_to_buffer(ctx, random_buffer[new_pos], random_pirs);
-		element_to_buffer(ctx, message_buffer[new_pos], message_pirs);
-		
-		ctx->api.free_group_element(random_r);
-		ctx->api.free_group_element(message_r);
-		ctx->api.free_group_element(random_s);
-		ctx->api.free_group_element(message_s);
-		ctx->api.free_group_element(random_pirs);
-		ctx->api.free_group_element(message_pirs);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			unsigned int new_pos = ctx->permutation[m][i];
+			GroupElement random_r = ctx->api.array_to_element(random_element[i], el_size, true);
+			GroupElement message_r = ctx->api.array_to_element(message_element[i], el_size, true);
+
+			GroupElement random_s;
+			GroupElement message_s;
+
+			ctx->api.encrypt(&random_s, &message_s, ctx->s[m][new_pos], ctx->network_key);
+
+			GroupElement random_pirs = ctx->api.combine(random_r, random_s, true);
+			GroupElement message_pirs = ctx->api.combine(message_r, message_s, true);
+
+			element_to_buffer(ctx, random_buffer[new_pos], random_pirs);
+			element_to_buffer(ctx, message_buffer[new_pos], message_pirs);
+
+			ctx->api.free_group_element(random_r);
+			ctx->api.free_group_element(message_r);
+			ctx->api.free_group_element(random_s);
+			ctx->api.free_group_element(message_s);
+			ctx->api.free_group_element(random_pirs);
+			ctx->api.free_group_element(message_pirs);
+		}
 	}
 	
 	return no_error;
@@ -249,33 +298,35 @@ enum cmix_error permute_and_multiply_encrypted_s(struct CMixContext const* ctx,
 enum cmix_error permute_and_multiply_s(struct CMixContext* ctx, char** out_buffer, char const** message) {
 	size_t el_size = get_group_element_array_size(ctx);
 	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		unsigned int new_pos = ctx->permutation[i];
-		
-		GroupElement message_el = ctx->api.array_to_element(message[i], el_size, false);
-		ctx->PiMRS[new_pos] = ctx->api.combine(message_el, ctx->s[new_pos], false);
-		
-		element_to_buffer(ctx, out_buffer[new_pos], ctx->PiMRS[new_pos]);
-		
-		ctx->api.free_group_element(message_el);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			unsigned int new_pos = ctx->permutation[m][i];
+
+			GroupElement message_el = ctx->api.array_to_element(message[i], el_size, false);
+			ctx->PiMRS[new_pos] = ctx->api.combine(message_el, ctx->s[m][new_pos], false);
+
+			element_to_buffer(ctx, out_buffer[new_pos], ctx->PiMRS[new_pos]);
+
+			ctx->api.free_group_element(message_el);
+		}
 	}
 	
-	
-	
 	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.combine(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);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		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.combine(message_el, ctx->s[m][ctx->permutation[m][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;
 }
@@ -348,14 +399,17 @@ size_t get_commitment_length(struct CMixContext const* ctx) {
 enum cmix_error precomputation_post_process(struct CMixContext* ctx, char* commitment, const char** r_epirs, const char** m_epirs) {
 	size_t len = get_group_element_array_size(ctx);
 	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		GroupElement x = ctx->api.array_to_element(r_epirs[i], get_group_element_array_size(ctx), true);
-		ctx->decryption_shares[i] = ctx->api.get_decryption_share(x, ctx->keypair.sec);
-		
-		ctx->EPiRS[i] = ctx->api.array_to_element(m_epirs[i], len, true);
-		
-		ctx->api.free_group_element(x);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			GroupElement x = ctx->api.array_to_element(r_epirs[i], get_group_element_array_size(ctx), true);
+			ctx->decryption_shares[m][i] = ctx->api.get_decryption_share(x, ctx->keypair.sec);
+
+			ctx->EPiRS[m][i] = ctx->api.array_to_element(m_epirs[i], len, true);
+
+			ctx->api.free_group_element(x);
+		}
 	}
+
 	
 	//ToDo: actually calculate commitment.
 	
@@ -398,19 +452,21 @@ enum cmix_error blind_message(struct CMixContext const* ctx, char* m_out, char c
 
 enum cmix_error swap_k_for_r(struct CMixContext const* ctx, char** out_buffer, const char** message, const GroupElement* key) {
 	size_t len = get_group_element_array_size(ctx);
-	
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		GroupElement mes = ctx->api.array_to_element(message[i], len, false);
-		GroupElement inv_key = ctx->api.invert(key[i]);
-		
-		GroupElement unblinded = ctx->api.uncombine(mes, key[i], false);
-		GroupElement blinded = ctx->api.combine(unblinded, ctx->r[i], false);
-		
-		element_to_buffer(ctx, out_buffer[i], 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);
+
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			GroupElement mes = ctx->api.array_to_element(message[i], len, false);
+			GroupElement inv_key = ctx->api.invert(key[i]);
+
+			GroupElement unblinded = ctx->api.uncombine(mes, key[i], false);
+			GroupElement blinded = ctx->api.combine(unblinded, ctx->r[m][i], false);
+
+			element_to_buffer(ctx, out_buffer[i], 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;
@@ -418,9 +474,12 @@ enum cmix_error swap_k_for_r(struct CMixContext const* ctx, char** out_buffer, c
 
 
 enum cmix_error get_epirs(struct CMixContext const* ctx, char** out_buffer) {
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		element_to_buffer(ctx, out_buffer[i], ctx->EPiRS[i]);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			element_to_buffer(ctx, out_buffer[i] + m * get_group_element_array_size(ctx), ctx->EPiRS[m][i]);
+		}
 	}
+
 	return no_error;
 }
 
@@ -431,15 +490,17 @@ enum cmix_error get_pimrs_commitment(struct CMixContext const* ctx, char* out_bu
 }
 
 enum cmix_error decrypt_epirs(struct CMixContext const* ctx, char** out_buffer, const char** epirs) {
-	for(size_t i = 0; i < ctx->nr_participants; ++i) {
-		GroupElement msg = ctx->api.array_to_element(epirs[i], get_group_element_array_size(ctx), true);
-		GroupElement pirs = ctx->api.combine(ctx->decryption_shares[i], msg, true);
-		element_to_buffer(ctx, out_buffer[i], pirs);
-		
-		ctx->api.free_group_element(msg);
-		ctx->api.free_group_element(pirs);
+	for(size_t m = 0; m < ctx->nr_mixes; ++m) {
+		for(size_t i = 0; i < ctx->nr_participants; ++i) {
+			GroupElement msg = ctx->api.array_to_element(epirs[i], get_group_element_array_size(ctx), true);
+			GroupElement pirs = ctx->api.combine(ctx->decryption_shares[m][i], msg, true);
+			element_to_buffer(ctx, out_buffer[i], pirs);
+
+			ctx->api.free_group_element(msg);
+			ctx->api.free_group_element(pirs);
+		}
 	}
-	
+
 	return no_error;
 }
 
diff --git a/libcmix/cmix.h b/libcmix/cmix.h
index 563fc02..f060762 100644
--- a/libcmix/cmix.h
+++ b/libcmix/cmix.h
@@ -45,12 +45,13 @@ struct CMixContext {
 	struct Api api; ///< The crypto api in use.
 	struct KeyPair keypair; ///< The keypair used in the crypto api.
 	GroupElement network_key; ///< The network key (called d in the paper).
+	size_t nr_mixes; ///< The amount of mixes to do simultanuous
 	size_t nr_participants; ///< The number of mix participants.
-	GroupElement* r; ///< An array of random values (R in the paper).
-	GroupElement* s; ///< An array of random values (S in the paper).
-	unsigned int* permutation; ///< a permutation (Pi in the paper (called Pi in source)).
-	GroupElement* decryption_shares; ///< The decryption share for each slot.
-	GroupElement* EPiRS; ///< stores teh current Pi(R) * S for this node. Only usfull for the last node.
+	GroupElement** r; ///< An array of random values (R in the paper).
+	GroupElement** s; ///< An array of random values (S in the paper).
+	unsigned int** permutation; ///< a permutation (Pi in the paper (called Pi in source)).
+	GroupElement** decryption_shares; ///< The decryption share for each slot.
+	GroupElement** EPiRS; ///< stores the current Pi(R) * S for this node. Only usfull for the last node.
 	GroupElement* PiMRS; ///< stores the current Pi(M * R) * S for this node. Only usefull for the last node.
 };