Splits up the Node.cpp class in 3 parts.

1 files changed, 174 insertions, 0 deletions

diff --git a/node/node_node.cpp b/node/node_node.cpp
new file mode 100644
index 0000000..fecc4ad
--- /dev/null
+++ b/node/node_node.cpp
@@ -0,0 +1,174 @@
+
+#include "node.hpp"
+
+template <typename T>
+cmix_proto::PrePre fill_precomputation_pre_message(CMixContext& ctx, T const& rs, T const& ms) {
+	if(start_mix(&ctx, rs.size()) != no_error) {
+		exit(-1);
+	}
+	
+	if(initialize_mix_randomness(&ctx) != no_error) {
+		exit(-1);
+	}
+	
+	cmix_proto::PrePre prepre;
+	
+	for(size_t i = 0; i < ctx.nr_participants; ++i) {
+		size_t len = get_group_element_array_size(&ctx);
+		
+		prepre.mutable_m_er(i)->resize(len);
+		prepre.mutable_r_er(i)->resize(len);
+		
+		if(encrypt_r_and_multiply(
+			&ctx, 
+			&(*prepre.mutable_r_er(i))[0],
+			&(*prepre.mutable_m_er(i))[0],
+			rs.Get(i).data(),
+			ms.Get(i).data(),
+			i
+		) != no_error) {
+			exit(-1);
+		}
+	}
+	return prepre;
+}
+
+template <typename T>
+cmix_proto::PreMix fill_precomputation_mix_message(CMixContext const& ctx, T const& rs, T const& ms) {
+	cmix_proto::PreMix premix;
+	for(size_t i = 0; i < ctx.nr_participants; ++i) {
+		auto new_pos = ctx.permutation[i];
+		size_t el_len = get_group_element_array_size(&ctx);
+		
+		premix.mutable_r_epirs(new_pos)->resize(el_len);
+		premix.mutable_m_epirs(new_pos)->resize(el_len);
+		
+		multiply_s(
+			&ctx,
+			&(*premix.mutable_r_epirs(new_pos))[0],
+			&(*premix.mutable_m_epirs(new_pos))[0],
+			rs.Get(i).data(),
+			ms.Get(i).data(),
+			i
+		);
+	}
+	return premix;
+}
+
+template <typename T>
+cmix_proto::PrePost fill_precomputation_post_message(CMixContext& ctx, T const& rs, T const& ms) {
+	cmix_proto::PrePost prepost;
+	
+	for(size_t i = 0; i < ctx.nr_participants; ++i) {
+		post_process(&ctx, rs.Get(i).data(), ms.Get(i).data(), i);
+		*prepost.mutable_r_epirs(i) = rs.Get(i);
+		*prepost.mutable_m_epirs(i) = ms.Get(i);
+	}
+	
+	return prepost;
+}
+
+void Node::handle_node_initialization(const cmix_proto::Initialization& init)
+{
+	if(network_settings.is_first) {
+		set_network_key(&cmix_ctx, init.public_share().data(), init.public_share().size());
+	
+		cmix_proto::SecretKey sec;
+		sec.set_secret_key(init.public_share().data(), init.public_share().size());
+		
+		next_node.async_send(sec);
+	} else {
+		size_t len = get_group_element_array_size(&cmix_ctx);
+		
+		cmix_proto::Initialization n_init;
+		n_init.mutable_public_share()->resize(len);
+		add_public_share(&cmix_ctx, &(*n_init.mutable_public_share())[0], init.public_share().data());
+	
+		BOOST_LOG_TRIVIAL(trace) << "Sending intialization";
+		next_node.async_send(n_init);
+	}
+}
+
+void Node::handle_node_secretkey(cmix_proto::SecretKey const& secret)
+{
+	std::string share = secret.secret_key();
+	
+	set_network_key(&cmix_ctx, secret.secret_key().data(), secret.secret_key().size());
+	
+	if(network_settings.is_first) {
+		start_precomputation();
+	} else {
+		next_node.async_send(secret);
+	}
+}
+
+void Node::handle_node_prepre(cmix_proto::PrePre const& pre) {
+	if(network_settings.is_first) {
+		cmix_proto::PreMix premix = fill_precomputation_mix_message(cmix_ctx, pre.r_er(), pre.m_er());
+		next_node.async_send(premix);
+	} else {
+		cmix_proto::PrePre prepre = fill_precomputation_pre_message(cmix_ctx, pre.r_er(), pre.m_er());
+		next_node.async_send(prepre);
+	}
+}
+
+void Node::handle_node_premix(cmix_proto::PreMix const& premix) {
+	if(network_settings.is_first) {
+		cmix_proto::PrePost prepost = fill_precomputation_post_message(cmix_ctx, premix.r_epirs(), premix.m_epirs());
+		next_node.async_send(prepost);	
+	} else {
+		cmix_proto::PreMix n_premix = fill_precomputation_mix_message(cmix_ctx, premix.r_epirs(), premix.m_epirs());
+		next_node.async_send(n_premix);
+	}
+}
+
+void Node::handle_node_prepost(cmix_proto::PrePost const& prepost) {
+	if(network_settings.is_first) {
+		
+	} else {
+		cmix_proto::PrePost n_prepost = fill_precomputation_post_message(cmix_ctx, prepost.r_epirs(), prepost.m_epirs());
+		next_node.async_send(n_prepost);
+	}
+}
+
+void Node::handle_node_message(cmix_proto::CMixMessage message)
+{
+	switch(message.contents_case()) {
+		case cmix_proto::CMixMessage::ContentsCase::kInitialization: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling initialization";
+			handle_node_initialization(message.initialization());
+			break;
+		}
+		case cmix_proto::CMixMessage::ContentsCase::kBye: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling bye";
+			//Todo: find a nice way to handle network shutdown.
+			break;
+		}
+		case cmix_proto::CMixMessage::ContentsCase::kSecretkey: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling SecretKey";
+			handle_node_secretkey(message.secretkey());
+			break;
+		}
+		case cmix_proto::CMixMessage::ContentsCase::kPrepre: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling PrePre";
+			handle_node_prepre(message.prepre());
+			break;
+		}
+		case cmix_proto::CMixMessage::ContentsCase::kPremix: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling PreMix";
+			handle_node_premix(message.premix());
+			break;
+		}
+		case cmix_proto::CMixMessage::ContentsCase::kPrepost: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling PrePost";
+			handle_node_prepost(message.prepost());
+			break;
+		}
+		default: {
+			BOOST_LOG_TRIVIAL(error) << "handle_node_message: CMixMessage contains unknown contents.";
+		}
+	}
+	prev_node.async_receive([this](cmix_proto::CMixMessage message) {
+		handle_node_message(message);
+	});
+}
\ No newline at end of file