Preparing multiple mixes

7 files changed, 214 insertions, 147 deletions

diff --git a/.gitignore b/.gitignore
index 394decf..94bfc7b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 CMakeLists.txt.user
 build*
+certs
diff --git a/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c b/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c
index bcaca51..afee9b1 100644
--- a/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c
+++ b/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c
@@ -322,11 +322,9 @@ GroupElement DEF(get_group_element)(bool secure) {
 			check(error);
 		} while(gcry_mpi_cmp_ui(a, 0) == 0 || gcry_mpi_cmp(a, p) != -1);
 
-		char* encoded_point = (char*) calloc(nr_bytes+1, sizeof(char));
-		TRACE(__FILE__, __LINE__, encoded_point)
-
 		free(encoded_point);
 		encoded_point = (char*) calloc(nr_bytes+1, sizeof(char));
+		TRACE(__FILE__, __LINE__, encoded_point)
 		encoded_point[0] = 0x40;
 
 		unsigned int byte_size = (unsigned) ceil(gcry_mpi_get_nbits(a) / 8.0);
@@ -456,10 +454,14 @@ GroupElement DEF(derive_shared_key)(struct KeyPair keypair, unsigned char const*
 	(void)swap;
 	
 	GroupElement ga = DEF(array_to_element)((const char*) value, value_len, false);
-	
+
 	gcry_mpi_point_t gab = gcry_mpi_point_new(nr_point_bits);
-	gcry_mpi_ec_mul(gab, (gcry_mpi_t) priv_value, (gcry_mpi_point_t) ga, ctx);
+
+	gcry_mpi_t x = gcry_mpi_new(0);
+	gcry_mpi_ec_get_affine(x, NULL, (gcry_mpi_point_t) priv_value, ctx);
+	gcry_mpi_ec_mul(gab, x, (gcry_mpi_point_t) ga, ctx);
 	
+	gcry_mpi_release(x);
 	gcry_mpi_point_release((gcry_mpi_point_t) ga);
 	
 	TRACE(__FILE__, __LINE__, gab);
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.
 };
 
diff --git a/node/node.cpp b/node/node.cpp
index dd6061a..0249b77 100644
--- a/node/node.cpp
+++ b/node/node.cpp
@@ -31,6 +31,8 @@ Node::Node(ListenSettings const& listen_settings, NodeNetworkSettings network_se
 	}
 
 	initialize_keypair(&cmix_ctx);
+
+	cmix_ctx.nr_mixes = 1;
 	
 	GOOGLE_PROTOBUF_VERIFY_VERSION;
 
diff --git a/node/node_node.cpp b/node/node_node.cpp
index 37d878c..0086bf7 100644
--- a/node/node_node.cpp
+++ b/node/node_node.cpp
@@ -179,7 +179,7 @@ void fill_realtime_post_message(CMixContext& ctx, cmix_proto::RealPost& realpost
 	std::vector<char*> mv(ctx.nr_participants, nullptr);
 	for(size_t i = 0; i < ctx.nr_participants; ++i) {
 		std::string* m = realpost.add_m_epirs();
-		m->resize(len);
+		m->resize(len * ctx.nr_mixes);
 		mv[i] = &(*m)[0];
 	}
 	
@@ -455,7 +455,7 @@ void Node::handle_node_realpost(cmix_proto::RealPost const& realpost) {
 		
 		for(auto i = 0u; i < cmix_ctx.nr_participants; i++) {
 			char* message;
-			element_to_message(&cmix_ctx, (unsigned char**) &message, msgs[i]);
+			element_to_message(&cmix_ctx, reinterpret_cast<unsigned char**>(&message), msgs[i]);
 			
 			char* dest;
 			size_t dest_len;
diff --git a/run.sh b/run.sh
index 72d83d8..0a81758 100755
--- a/run.sh
+++ b/run.sh
@@ -18,25 +18,25 @@ else
 	tool=""
 fi
 
-nr_clients=500
+nr_clients=1
 
 tmux new-session -s cmix -d
 
 #tmux send-keys -t cmix:0 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool statsd/statsd" Enter
 
 tmux new-window -t cmix:1
-tmux send-keys -t cmix:1 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool node/node -f -m ${nr_clients} -n node2.local:9201 -s localhost:9199 -a node1 -c ../certs/cert1.pem -k ../certs/key1.pem -d ../certs/dh.pem --certdir ../certs/" Enter
+tmux send-keys -t cmix:1 "cd ${build_dir} && ASAN_OPTIONS=detect_odr_violation=0 LSAN_OPTIONS=report_objects=1 $tool node/node -f -m ${nr_clients} -n node2.local:9201 -s localhost:9199 -a node1 -c ../certs/cert1.pem -k ../certs/key1.pem -d ../certs/dh.pem --certdir ../certs/" Enter
 
 tmux new-window -t cmix:2
-tmux send-keys -t cmix:2 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool node/node -p 9201 -n node3.local:9202 -s localhost:9199 -a node2 -c ../certs/cert2.pem -k ../certs/key2.pem -d ../certs/dh.pem --certdir ../certs/" Enter
+tmux send-keys -t cmix:2 "cd ${build_dir} && ASAN_OPTIONS=detect_odr_violation=0 LSAN_OPTIONS=report_objects=1 $tool node/node -p 9201 -n node3.local:9202 -s localhost:9199 -a node2 -c ../certs/cert2.pem -k ../certs/key2.pem -d ../certs/dh.pem --certdir ../certs/" Enter
 
 tmux new-window -t cmix:3
-tmux send-keys -t cmix:3 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool node/node -l -p 9202 -n node1.local:9200 -s localhost:9199 -a node3 -c ../certs/cert3.pem -k ../certs/key3.pem -d ../certs/dh.pem --certdir ../certs/" Enter
+tmux send-keys -t cmix:3 "cd ${build_dir} && ASAN_OPTIONS=detect_odr_violation=0 LSAN_OPTIONS=report_objects=1 $tool node/node -l -p 9202 -n node1.local:9200 -s localhost:9199 -a node3 -c ../certs/cert3.pem -k ../certs/key3.pem -d ../certs/dh.pem --certdir ../certs/" Enter
 
 for i in $(seq 4 $((3+${nr_clients})));
 do
 	tmux new-window -t cmix:${i}
-	tmux send-keys -t cmix:${i} "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool client/client --certdir ../certs -n node1.local:9200 node2.local:9201 node3.local:9202" Enter
+	tmux send-keys -t cmix:${i} "cd ${build_dir} && ASAN_OPTIONS=detect_odr_violation=0 LSAN_OPTIONS=report_objects=1 $tool client/client --certdir ../certs -n node1.local:9200 node2.local:9201 node3.local:9202" Enter
 done
 
 tmux select-window -t cmix:4