Moves cmix calculation stuff outisde of the node class.

Moves the computations and cryptography to the the libcmix library
where we can group and memory manage the underlying crypto-library.

1 files changed, 82 insertions, 143 deletions

diff --git a/node/node.cpp b/node/node.cpp
index 02ddb3e..fc41656 100644
--- a/node/node.cpp
+++ b/node/node.cpp
@@ -11,19 +11,19 @@ using namespace boost::asio::ip;
 
 Node::Node(ListenSettings const& listen_settings, NodeNetworkSettings network_settings)
 : io_service()
-, ctx(std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23))
-, server(io_service, listen_settings, ctx, [this](std::unique_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>&& socket, std::shared_ptr<boost::asio::ssl::context> ctx){accept_handler(std::move(socket), ctx);})
+, ssl_ctx(std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23))
+, server(io_service, listen_settings, ssl_ctx, [this](std::unique_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>&& socket, std::shared_ptr<boost::asio::ssl::context> ctx){accept_handler(std::move(socket), ctx);})
 , clients()
 , data()
 , network_settings(network_settings)
-, prev_node(SSLReceiver(std::unique_ptr<boost::asio::ssl::stream<tcp::socket>>(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(io_service, *ctx))))
-, next_node(SSLSender(std::unique_ptr<boost::asio::ssl::stream<tcp::socket>>(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(io_service, *ctx))))
-, api(get_implementation())
-, keypair(api.create_key_pair())
-, network_key()
+, prev_node(SSLReceiver(std::unique_ptr<boost::asio::ssl::stream<tcp::socket>>(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(io_service, *ssl_ctx))))
+, next_node(SSLSender(std::unique_ptr<boost::asio::ssl::stream<tcp::socket>>(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(io_service, *ssl_ctx))))
+, cmix_ctx(initialize_cmix_context(get_implementation()))
 , precomputation_data()
 , shutting_down(false)
 {
+	initialize_keypair(&cmix_ctx);
+	
 	GOOGLE_PROTOBUF_VERIFY_VERSION;
 
 	if(network_settings.is_first) {
@@ -32,7 +32,7 @@ Node::Node(ListenSettings const& listen_settings, NodeNetworkSettings network_se
 }
 
 Node::~Node() {
-	api.free_key_pair(&keypair);
+	deinitialize(&cmix_ctx);
 }
 
 void Node::run() {
@@ -56,7 +56,7 @@ void Node::accept_handler(std::unique_ptr<boost::asio::ssl::stream<boost::asio::
 void Node::connect_to_next_node()
 {
 	if(!network_settings.certdir.empty()) {
-		ctx->add_verify_path(network_settings.certdir);
+		ssl_ctx->add_verify_path(network_settings.certdir);
 	}
 	
 	auto on_connect = [this](){
@@ -70,11 +70,10 @@ void Node::connect_to_next_node()
 void Node::start_initialisation() {
 	cmix_proto::Initialization init;
 	
-	unsigned char* pub_key;
-	size_t len;
-	api.element_to_array(&pub_key, &len, keypair.pub);
-	init.set_public_share(pub_key, len);
-	free(pub_key);
+	size_t len = get_group_element_array_size(&cmix_ctx);
+	init.mutable_public_share()->resize(len);
+	
+	get_public_key(&cmix_ctx, &(*init.mutable_public_share())[0]);
 	
 	BOOST_LOG_TRIVIAL(trace) << "Sending intialization as first node";
 	next_node.async_send(init);
@@ -84,31 +83,21 @@ void Node::start_initialisation() {
 void Node::handle_node_initialization(const cmix_proto::Initialization& init)
 {
 	if(network_settings.is_first) {
-		network_key = api.array_to_element(init.public_share().c_str(), init.public_share().size(), true);
+		set_network_key(&cmix_ctx, init.public_share().data(), init.public_share().size());
 	
 		cmix_proto::SecretKey sec;
-		
-		unsigned char* data;
-		size_t len;
-		
-		api.element_to_array(&data, &len, network_key);
-		sec.set_secret_key(data, len);
-		
-		api.free_buffer(data);
+		sec.set_secret_key(init.public_share().data(), init.public_share().size());
 		
 		next_node.async_send(sec);
 	} else {
-	
-		char* buffer;
-		size_t len;
-		api.add_public_share(&buffer, &len, init.public_share().c_str(), init.public_share().size(), keypair.pub);
-		
-		cmix_proto::Initialization init;
-		init.set_public_share(buffer, len);
-		api.free_buffer(buffer);
+		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(init);
+		next_node.async_send(n_init);
 	}
 }
 
@@ -116,7 +105,7 @@ void Node::handle_node_secretkey(cmix_proto::SecretKey const& secret)
 {
 	std::string share = secret.secret_key();
 	
-	network_key = api.array_to_element(secret.secret_key().c_str(), secret.secret_key().size(), true);
+	set_network_key(&cmix_ctx, secret.secret_key().data(), secret.secret_key().size());
 	
 	if(network_settings.is_first) {
 		start_precomputation();
@@ -129,85 +118,58 @@ void Node::handle_node_prepre(cmix_proto::PrePre const& pre) {
 	if(network_settings.is_first) {
 		
 		cmix_proto::PreMix premix;
-		for(int i = 0; i < pre.m_er_size(); ++i) {
-			GroupElement random_r = api.array_to_element(pre.r_er(i).data(), pre.r_er(i).size(), true);
-			GroupElement message_r = api.array_to_element(pre.m_er(i).data(), pre.m_er(i).size(), true);
-			
-			GroupElement random_s;
-			GroupElement message_s;
-			
-			api.encrypt(&random_s, &message_s, precomputation_data[precomputation_data[i].new_location].s, network_key);
-			
-			GroupElement random_pirs = api.multiply(random_r, random_s, true);
-			GroupElement message_pirs = api.multiply(message_r, message_s, true);
-			
-			unsigned char* data;
-			size_t len;
+		for(int i = 0; i < cmix_ctx.nr_participants; ++i) {
+			auto new_pos = cmix_ctx.permutation[i];
+			size_t el_len = get_group_element_array_size(&cmix_ctx);
 			
-			api.element_to_array(&data, &len, random_pirs);
-			premix.set_r_epirs(precomputation_data[i].new_location, data, len);
-			api.free_buffer(data);
+			premix.mutable_r_epirs(new_pos)->resize(el_len);
+			premix.mutable_m_epirs(new_pos)->resize(el_len);
 			
-			api.element_to_array(&data, &len, message_pirs);
-			premix.set_m_epirs(precomputation_data[i].new_location, data, len);
-			api.free_buffer(data);
-			
-			api.free_group_element(random_r);
-			api.free_group_element(message_r);
-			api.free_group_element(random_s);
-			api.free_group_element(message_s);
+			multiply_s(
+				&cmix_ctx,
+				&(*premix.mutable_r_epirs(new_pos))[0],
+				&(*premix.mutable_m_epirs(new_pos))[0],
+				pre.r_er(i).data(),
+				pre.m_er(i).data(),
+				i
+			);
 		}
 		
 		next_node.async_send(premix);
 		
 	} else {
-		std::vector<size_t> permutation(clients.size());
-		std::iota(permutation.begin(), permutation.end(), 0);
-		//ToDo: generate something different than the ID permutation.
+		if(start_mix(&cmix_ctx, pre.r_er_size()) != no_error) {
+			exit(-1);
+		}
+		
+		if(initialize_mix_randomness(&cmix_ctx) != no_error) {
+			exit(-1);
+		}
 		
 		cmix_proto::PrePre prepre;
 		
 		for(int i = 0; i < pre.m_er_size(); ++i) {
-			GroupElement r = api.get_group_element(true);
-			GroupElement s = api.get_group_element(true);
-			
-			GroupElement random_element;
-			GroupElement message_element;
-			
-			api.encrypt(&random_element, &message_element, r, network_key);
-			
-			GroupElement other_random_element = api.array_to_element(pre.r_er(i).data(), pre.r_er(i).size(), true);
-			GroupElement other_message_element = api.array_to_element(pre.m_er(i).data(), pre.m_er(i).size(), true);
-			
-			GroupElement new_random_element = api.multiply(random_element, other_random_element, true);
-			GroupElement new_message_element = api.multiply(message_element, other_message_element, true);
-			
-			
-			unsigned char* buffer;
-			size_t len;
-			
-			api.element_to_array(&buffer, &len, new_random_element);
-			prepre.add_r_er(buffer, len);
-			api.free_buffer(buffer);
-			
-			api.element_to_array(&buffer, &len, new_message_element);
-			prepre.add_m_er(buffer, len);
-			api.free_buffer(buffer);
+			size_t len = get_group_element_array_size(&cmix_ctx);
 			
-			api.free_group_element(random_element);
-			api.free_group_element(message_element);
-			api.free_group_element(other_random_element);
-			api.free_group_element(other_message_element);
-			api.free_group_element(new_random_element);
-			api.free_group_element(new_message_element);
+			prepre.mutable_m_er(i)->resize(len);
+			prepre.mutable_r_er(i)->resize(len);
 			
-			precomputation_data.emplace_back(MixData{r, s, "", permutation[i]});
+			if(encrypt_r_and_multiply(&cmix_ctx, &(*prepre.mutable_r_er(i))[0], &(*prepre.mutable_m_er(i))[0], pre.r_er(i).data(), pre.m_er(i).data(), i) != no_error) {
+				exit(-1);
+			}
 		}
-		
 		next_node.async_send(prepre);
 	}
 }
 
+void Node::handle_node_premix(cmix_proto::PreMix const& premix) {
+	if(network_settings.is_first) {
+		
+	} else {
+		
+	}
+}
+
 void Node::handle_node_message(cmix_proto::CMixMessage message)
 {
 	switch(message.contents_case()) {
@@ -231,6 +193,11 @@ void Node::handle_node_message(cmix_proto::CMixMessage message)
 			handle_node_prepre(message.prepre());
 			break;
 		}
+		case cmix_proto::CMixMessage::ContentsCase::kPremix: {
+			BOOST_LOG_TRIVIAL(trace) << "Handling PreMix";
+			handle_node_premix(message.premix());
+			break;
+		}
 		default: {
 			BOOST_LOG_TRIVIAL(error) << "handle_node_message: CMixMessage contains unknown contents.";
 		}
@@ -241,30 +208,19 @@ void Node::handle_node_message(cmix_proto::CMixMessage message)
 }
 
 void Node::handle_client_keyexchange(ClientConnections::key_type handle, cmix_proto::KeyExchange ke) {
-	void* priv_el = api.get_group_element(true);
-	
-	data[handle].shared_value = api.derive_shared_key(keypair, reinterpret_cast<uint8_t const*>(ke.public_key().c_str()), ke.public_key().size(), reinterpret_cast<uint8_t const*>(ke.value().c_str()), ke.value().size(), priv_el, true);
-	
-	void* ex_val = api.get_key_exchange_value(priv_el);
+	CMixClientData d;
 	
-	api.free_group_element(priv_el);
+	size_t len = get_group_element_array_size(&cmix_ctx);
 	
-	cmix_proto::KeyExchange exchange;
+	cmix_proto::KeyExchange nke;
+	nke.mutable_public_key()->resize(len);
+	nke.mutable_value()->resize(len);
 	
-	unsigned char* buffer;
-	size_t len;
+	key_exchange(&cmix_ctx, &d.shared_value.shared, &(*nke.mutable_public_key())[0], &(*nke.mutable_value())[0], ke.public_key().data(), ke.value().data());
 	
-	api.element_to_array(&buffer, &len, keypair.pub);
-	exchange.set_public_key(buffer, len);
-	api.free_buffer(buffer);
+	data[handle] = d;
 	
-	api.element_to_array(&buffer, &len, ex_val);
-	exchange.set_value(buffer, len);
-	api.free_buffer(buffer);
-	
-	api.free_group_element(ex_val);
-	
-	clients.at(handle).async_send(exchange);
+	clients.at(handle).async_send(nke);
 }
 
 void Node::handle_client_bye(ClientConnections::key_type handle, cmix_proto::Bye)
@@ -347,42 +303,25 @@ void Node::handle_message(Purgatory::iterator handle, cmix_proto::CMixMessage me
 }
 
 void Node::start_precomputation() {
-	precomputation_data.clear();
-	precomputation_data.reserve(clients.size());
+	if(start_mix(&cmix_ctx, clients.size()) != no_error) {
+		exit(-1);
+	}
 	
-	std::vector<size_t> permutation(clients.size());
-	std::iota(permutation.begin(), permutation.end(), 0);
-	//ToDo: generate something different than the ID permutation.
+	if(initialize_mix_randomness(&cmix_ctx) != no_error) {
+		exit(-1);
+	}
 	
 	cmix_proto::PrePre prepre;
 	
-	auto perm_it = permutation.begin();
-	for(auto const& pair : clients) {
-		GroupElement r = api.get_group_element(true);
-		GroupElement s = api.get_group_element(true);
-	
-		GroupElement random_element;
-		GroupElement message_element;
-		
-		api.encrypt(&random_element, &message_element, r, network_key);
+	for(size_t i = 0; i < cmix_ctx.nr_participants; ++i) {
+		size_t len = get_group_element_array_size(&cmix_ctx);
 		
-		unsigned char* buffer;
-		size_t len;
+		prepre.mutable_r_er(i)->resize(len);
+		prepre.mutable_m_er(i)->resize(len);
 		
-		api.element_to_array(&buffer, &len, random_element);
-		prepre.add_m_er(buffer, len);
-		api.free_buffer(buffer);
-		
-		api.element_to_array(&buffer, &len, message_element);
-		prepre.add_m_er(buffer, len);
-		api.free_buffer(buffer);
-		
-		next_node.async_send(prepre);
-		
-		precomputation_data.emplace_back(MixData{r, s, pair.first, *perm_it++});
-		
-		api.free_group_element(random_element);
-		api.free_group_element(message_element);
+		if(encrypt_r(&cmix_ctx, &(*prepre.mutable_r_er(i))[0], &(*prepre.mutable_m_er(i))[0], i) != no_error) {
+			exit(-1);
+		}
 	}
 	
 	next_node.async_send(prepre);