Working Ed25519 Implementation of libcmix.

38 files changed, 1062 insertions, 128 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5855117..691860f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,6 +22,13 @@ include(warning_settings)
 
 add_sane_warning_flags()
 
+check_compiling_with_clang(COMPILING_WITH_CLANG)
+
+if(COMPILING_WITH_CLANG)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-documentation-unknown-command -Wno-documentation -Wno-shadow-field-in-constructor")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-documentation-unknown-command -Wno-documentation -Wno-shadow-field-in-constructor")
+endif(COMPILING_WITH_CLANG)
+
 set(VERSION_MAJOR 0 CACHE STRING "Project major version number.")
 set(VERSION_MINOR 1 CACHE STRING "Project minor version number.")
 set(VERSION_PATCH 0 CACHE STRING "Project patch version number.")
diff --git a/CMakeModules/curve25519_implementations.cmake b/CMakeModules/curve25519_implementations.cmake
deleted file mode 100644
index 6be8dca..0000000
--- a/CMakeModules/curve25519_implementations.cmake
+++ /dev/null
@@ -1,3 +0,0 @@
-include(implementations)
-
-DefineImplementations("curve25519")
diff --git a/CMakeModules/ed25519_implementations.cmake b/CMakeModules/ed25519_implementations.cmake
new file mode 100644
index 0000000..8730b69
--- /dev/null
+++ b/CMakeModules/ed25519_implementations.cmake
@@ -0,0 +1,3 @@
+include(implementations)
+
+DefineImplementations("ed25519")
diff --git a/CMakeModules/get_target_name.cmake b/CMakeModules/get_target_name.cmake
index 90d585d..9154d12 100644
--- a/CMakeModules/get_target_name.cmake
+++ b/CMakeModules/get_target_name.cmake
@@ -1,10 +1,12 @@
 
-function(get_target_name target_name)
+function(get_target_name target_name algorithm_name implementation_name)
 
 	get_filename_component(implementation ${CMAKE_CURRENT_LIST_DIR} NAME)
 	get_filename_component(implementation_path ${CMAKE_CURRENT_LIST_DIR} DIRECTORY)
 	get_filename_component(algorithm ${implementation_path} NAME)
 
+	set(${algorithm_name} "${algorithm}" PARENT_SCOPE)
+	set(${implementation_name} "${implementation}" PARENT_SCOPE)
 	set(${target_name} "${algorithm}-${implementation}" PARENT_SCOPE)
 
 endfunction(get_target_name)
diff --git a/client/cmixclient.cpp b/client/cmixclient.cpp
index 5109b81..fca653b 100644
--- a/client/cmixclient.cpp
+++ b/client/cmixclient.cpp
@@ -76,7 +76,7 @@ void CMixClient::handle_key_exchange(size_t node_id, cmix_proto::KeyExchange con
 	);
 	
 	if(std::all_of(shared_values.begin(), shared_values.end(), [](GroupElement const& value){return value != nullptr;})) {
-		size_t len = get_group_element_array_size(&cmix_ctx);
+		size_t len = get_message_size(&cmix_ctx);
 		
 		std::vector<char> vec(len, '\0');
 		
@@ -91,7 +91,7 @@ void CMixClient::handle_key_exchange(size_t node_id, cmix_proto::KeyExchange con
 		free(id);
 		
 		cmix_proto::UserMessage message;
-		message.mutable_m()->resize(len);
+		message.mutable_m()->resize(get_group_element_array_size(&cmix_ctx));
 	
 		blind_message(&cmix_ctx, &(*message.mutable_m())[0], vec.data(), shared_values.data(), shared_values.size());
 		
diff --git a/libcmix-crypto/CMakeLists.txt b/libcmix-crypto/CMakeLists.txt
index 56dd553..3a4b2db 100644
--- a/libcmix-crypto/CMakeLists.txt
+++ b/libcmix-crypto/CMakeLists.txt
@@ -10,14 +10,15 @@ set(interface_sources
 	${CMAKE_CURRENT_SOURCE_DIR}/keypair.h
 	${CMAKE_CURRENT_SOURCE_DIR}/sharedkey.h
 	${CMAKE_CURRENT_SOURCE_DIR}/groupelement.h
+	${CMAKE_CURRENT_SOURCE_DIR}/impl_macros.h
 )
 
 target_sources(cmix-crypto-interface
 	INTERFACE ${interface_sources}
 )
 
-include(curve25519_implementations)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/curve25519/)
+include(ed25519_implementations)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ed25519/)
 
 include(elgamal_implementations)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/elgamal)
@@ -32,11 +33,11 @@ target_sources(cmix-crypto
 	INTERFACE ${interface_sources}
 )
 
-option(UseEC "Use curve25519 instead of elgamal in a multiplicative group" OFF)
+option(UseEC "Use ed25519 instead of elgamal in a multiplicative group" OFF)
 
 if(UseEC)
 	target_link_libraries(cmix-crypto
-		INTERFACE curve25519-implementation
+		INTERFACE ed25519-implementation
 	)
 else(UseEC)
 	target_link_libraries(cmix-crypto
diff --git a/libcmix-crypto/api.h b/libcmix-crypto/api.h
index 0fa4916..8279dbb 100644
--- a/libcmix-crypto/api.h
+++ b/libcmix-crypto/api.h
@@ -63,6 +63,16 @@ typedef GroupElement(*ArrayToElement)(char const*, size_t size, bool);
 /*!
  *
  */
+typedef GroupElement(*MessageToElement)(char const*, size_t size, bool);
+
+/*!
+ *
+ */
+typedef void(*ElementToMessage)(unsigned char** message, const GroupElement element);
+
+/*!
+ *
+ */
 typedef void(*PubKeyHashGetter)(char** buffer, size_t* len, GroupElement const pub);
 
 /*!
@@ -88,7 +98,12 @@ typedef GroupElement(*KeyExchangeValueGetter)(GroupElement);
 /*!
  *
  */
-typedef GroupElement(*GroupElementMultiplier)(GroupElement, GroupElement, bool);
+typedef GroupElement(*GroupElementCombiner)(GroupElement, GroupElement, bool);
+
+/*!
+ *
+ */
+typedef GroupElement(*GroupElementUncombiner)(GroupElement, GroupElement, bool);
 
 /*!
  *
@@ -98,6 +113,11 @@ typedef size_t(*GroupElementArraySizeGetter)();
 /*!
  *
  */
+typedef size_t(*MessageSizeGetter)();
+
+/*!
+ *
+ */
 typedef void(*GroupElementDeleter)(GroupElement);
 
 /*!
@@ -130,13 +150,17 @@ struct Api {
 	ElementToArray element_to_array; ///< Get the array representation of a public key
 	BufferDeleter free_buffer; ///< frees library allocated buffers.
 	ArrayToElement array_to_element; ///< The the GroupElement representation of this array.
+	MessageToElement message_to_element; ///< Convert Message to element.
+	ElementToMessage element_to_message; ///< Convert Element to message.
 	PubKeyHashGetter get_pub_key_hash; ///< Get the hash of the public key.
 	PubKeyHashLengthGetter get_pub_key_hash_length; ///< Get the length of the pubkey hash.
 	GroupElementGetter get_group_element; ///< get group element
 	GroupElementArraySizeGetter get_group_element_array_size; ///< Return the size required to store a groupelement in an array;
+	MessageSizeGetter get_message_size; ///< Retrieve how large a message can be.
 	GroupElementDeleter free_group_element; ///< frees a base type of the cryptolibrary.
 	KeyExchangeValueGetter get_key_exchange_value; ///< get generator *op* group element.
-	GroupElementMultiplier multiply; ///< Multiplies two groupelements modulo group.
+	GroupElementCombiner combine; ///< Combines two groupelements modulo group.
+	GroupElementUncombiner uncombine; ///< Uncombines two groupelements;
 	DecryptionShareGetter get_decryption_share; ///< calculates the first argument to the power of Inverse second argument;
 	PublicShareAdder add_public_share; ///< Adds the public key stored in void* to the existing share.
 	SharedKeyDeriver derive_shared_key; ///< Pointer to shared key derivation function
diff --git a/libcmix-crypto/curve25519/curve25519.c b/libcmix-crypto/curve25519/curve25519.c
index a963840..2fb99c3 100644
--- a/libcmix-crypto/curve25519/curve25519.c
+++ b/libcmix-crypto/curve25519/curve25519.c
@@ -5,23 +5,29 @@ struct Api get_curve25519_implementation()
 {
 	curve25519_initialize();
 	return (struct Api) {
-		.initialize                   = curve25519_initialize,
-		.create_keypair               = curve25519_create_keypair,
-		.free_keypair                 = curve25519_delete_keypair,
-		.element_to_array             = curve25519_element_to_array,
-		.free_buffer                  = curve25519_free_buffer,
-		.array_to_element             = curve25519_array_to_element,
-		.get_group_element            = curve25519_get_group_element,
+		.initialize = curve25519_initialize,
+		.create_keypair = curve25519_create_keypair,
+		.free_keypair = curve25519_delete_keypair,
+		.element_to_array = curve25519_element_to_array,
+		.free_buffer = curve25519_free_buffer,
+		.array_to_element = curve25519_array_to_element,
+		.message_to_element = curve25519_message_to_element,
+		.get_pub_key_hash = curve25519_get_pub_key_hash,
+		.get_pub_key_hash_length = curve25519_get_pub_key_hash_length,
+		.get_group_element = curve25519_get_group_element,
 		.get_group_element_array_size = curve25519_get_group_element_array_size,
-		.free_group_element           = curve25519_delete_group_element,
-		.get_key_exchange_value       = curve25519_get_key_exchange_value,
-		.multiply                     = curve25519_multiply,
-		.get_decryption_share         = curve25519_get_decryption_share,
-		.add_public_share             = curve25519_add_public_share,
-		.derive_shared_key            = curve25519_derive_shared_key,
-		.free_shared_key              = curve25519_delete_shared_key,
-		.encrypt                      = curve25519_encrypt,
-		.deinitialize                 = curve25519_deinitialize
+		.free_group_element = curve25519_delete_group_element,
+		.get_key_exchange_value = curve25519_get_key_exchange_value,
+		.combine = curve25519_combine,
+		.uncombine = curve25519_uncombine,
+		.get_decryption_share = curve25519_get_decryption_share,
+		.add_public_share = curve25519_add_public_share,
+		.derive_shared_key = curve25519_derive_shared_key,
+		.free_shared_key = curve25519_delete_shared_key,
+		.encrypt = curve25519_encrypt,
+		.invert = curve25519_invert,
+		.get_uniform_int = curve25519_get_uniform_int,
+		.deinitialize = curve25519_deinitialize
 	};
 }
 
diff --git a/libcmix-crypto/curve25519/curve25519.h b/libcmix-crypto/curve25519/curve25519.h
index 5f30915..f424144 100644
--- a/libcmix-crypto/curve25519/curve25519.h
+++ b/libcmix-crypto/curve25519/curve25519.h
@@ -22,13 +22,21 @@ extern BufferDeleter curve25519_free_buffer;
 
 extern ArrayToElement curve25519_array_to_element;
 
+extern MessageToElement curve25519_message_to_element;
+
+extern PubKeyHashGetter curve25519_get_pub_key_hash;
+
+extern PubKeyHashLengthGetter curve25519_get_pub_key_hash_length;
+
 extern GroupElementGetter curve25519_get_group_element;
 
 extern GroupElementDeleter curve25519_delete_group_element;
 
 extern KeyExchangeValueGetter curve25519_get_key_exchange_value;
 
-extern GroupElementMultiplier curve25519_multiply;
+extern GroupElementCombiner curve25519_combine;
+
+extern GroupElementUncombiner curve25519_uncombine;
 
 extern DecryptionShareGetter curve25519_get_decryption_share;
 
@@ -42,6 +50,10 @@ extern SharedKeyDeleter curve25519_delete_shared_key;
 
 extern Encrypter curve25519_encrypt;
 
+extern Inverter curve25519_invert;
+
+extern UniformIntGetter curve25519_get_uniform_int;
+
 extern Deinitializer curve25519_deinitialize;
 
 /*!
diff --git a/libcmix-crypto/curve25519/null/CMakeLists.txt b/libcmix-crypto/curve25519/null/CMakeLists.txt
index eb13fdf..94dac1b 100644
--- a/libcmix-crypto/curve25519/null/CMakeLists.txt
+++ b/libcmix-crypto/curve25519/null/CMakeLists.txt
@@ -1,6 +1,6 @@
 include(get_target_name)
 
-get_target_name(target_name)
+get_target_name(target_name algo api)
 
 add_library(${target_name} SHARED
 	null_curve25519.c
diff --git a/libcmix-crypto/curve25519/null/null_curve25519.c b/libcmix-crypto/curve25519/null/null_curve25519.c
index d261791..19c52f4 100644
--- a/libcmix-crypto/curve25519/null/null_curve25519.c
+++ b/libcmix-crypto/curve25519/null/null_curve25519.c
@@ -37,7 +37,7 @@ ArrayToElement curve25519_array_to_element = NULL;//&null_curve25519_array_to_el
 GroupElementGetter curve25519_get_group_element = NULL;//&null_curve25519_get_group_element;
 GroupElementDeleter curve25519_delete_group_element = NULL;//&null_curve25519_delete_group_element;
 KeyExchangeValueGetter curve25519_get_key_exchange_value = NULL;//&null_curve25519_get_key_exchange_value;
-GroupElementMultiplier curve25519_multiply = NULL;//&null_curve25519_multiply;
+GroupElementCombiner curve25519_multiply = NULL;//&null_curve25519_multiply;
 DecryptionShareGetter curve25519_get_decryption_share = NULL;//&null_curve25519_get_decryption_share;
 GroupElementArraySizeGetter curve25519_get_group_element_array_size = NULL;//&null_curve25519_get_group_element_array_size;
 PublicShareAdder curve25519_add_public_share = NULL;//&null_curve25519_add_public_share;
diff --git a/libcmix-crypto/curve25519/sodium/CMakeLists.txt b/libcmix-crypto/curve25519/sodium/CMakeLists.txt
index fbbedb1..f93abb4 100644
--- a/libcmix-crypto/curve25519/sodium/CMakeLists.txt
+++ b/libcmix-crypto/curve25519/sodium/CMakeLists.txt
@@ -1,6 +1,6 @@
 include(get_target_name)
 
-get_target_name(target_name)
+get_target_name(target_name algo api)
 
 find_package(sodium REQUIRED CONFIG)
 
diff --git a/libcmix-crypto/curve25519/sodium/libsodium_curve25519.c b/libcmix-crypto/curve25519/sodium/libsodium_curve25519.c
index 1bad378..b8ed4c2 100644
--- a/libcmix-crypto/curve25519/sodium/libsodium_curve25519.c
+++ b/libcmix-crypto/curve25519/sodium/libsodium_curve25519.c
@@ -93,7 +93,8 @@ ArrayToElement curve25519_array_to_element = NULL;//&sodium_curve25519_array_to_
 GroupElementGetter curve25519_get_group_element = NULL;//&sodium_curve25519_get_group_element;
 GroupElementDeleter curve25519_delete_group_element = NULL;//&sodium_curve25519_delete_group_element;
 KeyExchangeValueGetter curve25519_get_key_exchange_value = NULL;//&sodium_curve25519_get_key_exchange_value;
-GroupElementMultiplier curve25519_multiply = NULL;//&sodium_curve25519_multiply;
+GroupElementCombiner curve25519_combine = NULL;//&sodium_curve25519_multiply;
+GroupElementUncombiner curve25519_uncombine = NULL;
 DecryptionShareGetter curve25519_get_decryption_share = NULL;//&sodium_curve25519_get_decryption_share;
 GroupElementArraySizeGetter curve25519_get_group_element_array_size = NULL;//&sodium_curve25519_get_group_element_array_size;
 PublicShareAdder curve25519_add_public_share = NULL;//&sodium_curve25519_add_public_share;
diff --git a/libcmix-crypto/ed25519/CMakeLists.txt b/libcmix-crypto/ed25519/CMakeLists.txt
new file mode 100644
index 0000000..3aae9fe
--- /dev/null
+++ b/libcmix-crypto/ed25519/CMakeLists.txt
@@ -0,0 +1,32 @@
+add_library(ed25519-interface INTERFACE)
+
+target_include_directories(ed25519-interface
+	INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_sources(ed25519-interface
+	INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/ed25519.h
+)
+
+target_link_libraries(ed25519-interface
+	INTERFACE cmix-crypto-interface
+)
+
+foreach(impl ${libcmix_crypto_ed25519_implementations})
+	add_subdirectory(${impl})
+endforeach()
+
+add_library(ed25519-implementation
+	ed25519.h ed25519.c
+)
+
+target_include_directories(ed25519-implementation
+	PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(ed25519-implementation
+	PUBLIC ed25519-interface
+	PUBLIC ed25519-${libcmix_crypto_ed25519_implementation}
+)
+
+
diff --git a/libcmix-crypto/ed25519/ed25519.c b/libcmix-crypto/ed25519/ed25519.c
new file mode 100644
index 0000000..835edfa
--- /dev/null
+++ b/libcmix-crypto/ed25519/ed25519.c
@@ -0,0 +1,36 @@
+
+#include "ed25519.h"
+
+struct Api get_ed25519_implementation()
+{
+	ed25519_initialize();
+	return (struct Api) {
+		.initialize = ed25519_initialize,
+		.create_keypair = ed25519_create_keypair,
+		.free_keypair = ed25519_delete_keypair,
+		.element_to_array = ed25519_element_to_array,
+		.free_buffer = ed25519_free_buffer,
+		.array_to_element = ed25519_array_to_element,
+		.message_to_element = ed25519_message_to_element,
+		.element_to_message = ed25519_element_to_message,
+		.get_pub_key_hash = ed25519_get_pub_key_hash,
+		.get_pub_key_hash_length = ed25519_get_pub_key_hash_length,
+		.get_group_element = ed25519_get_group_element,
+		.get_group_element_array_size = ed25519_get_group_element_array_size,
+		.get_message_size = ed25519_get_message_size,
+		.free_group_element = ed25519_delete_group_element,
+		.get_key_exchange_value = ed25519_get_key_exchange_value,
+		.combine = ed25519_combine,
+		.uncombine = ed25519_uncombine,
+		.get_decryption_share = ed25519_get_decryption_share,
+		.add_public_share = ed25519_add_public_share,
+		.derive_shared_key = ed25519_derive_shared_key,
+		.free_shared_key = ed25519_delete_shared_key,
+		.encrypt = ed25519_encrypt,
+		.invert = ed25519_invert,
+		.get_uniform_int = ed25519_get_uniform_int,
+		.deinitialize = ed25519_deinitialize
+	};
+}
+
+ImplementationGetter get_implementation = &get_ed25519_implementation;
diff --git a/libcmix-crypto/ed25519/ed25519.h b/libcmix-crypto/ed25519/ed25519.h
new file mode 100644
index 0000000..1cd9e66
--- /dev/null
+++ b/libcmix-crypto/ed25519/ed25519.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * \file
+ */
+
+extern Initializer ed25519_initialize;
+
+extern KeyPairCreator ed25519_create_keypair;
+
+extern KeyPairDeleter ed25519_delete_keypair;
+
+extern ElementToArray ed25519_element_to_array;
+
+extern BufferDeleter ed25519_free_buffer;
+
+extern ArrayToElement ed25519_array_to_element;
+
+extern MessageToElement ed25519_message_to_element;
+
+extern ElementToMessage ed25519_element_to_message;
+
+extern PubKeyHashGetter ed25519_get_pub_key_hash;
+
+extern PubKeyHashLengthGetter ed25519_get_pub_key_hash_length;
+
+extern GroupElementGetter ed25519_get_group_element;
+
+extern GroupElementDeleter ed25519_delete_group_element;
+
+extern KeyExchangeValueGetter ed25519_get_key_exchange_value;
+
+extern GroupElementCombiner ed25519_combine;
+
+extern GroupElementUncombiner ed25519_uncombine;
+
+extern DecryptionShareGetter ed25519_get_decryption_share;
+
+extern GroupElementArraySizeGetter ed25519_get_group_element_array_size;
+
+extern MessageSizeGetter ed25519_get_message_size;
+
+extern PublicShareAdder ed25519_add_public_share;
+
+extern SharedKeyDeriver ed25519_derive_shared_key;
+
+extern SharedKeyDeleter ed25519_delete_shared_key;
+
+extern Encrypter ed25519_encrypt;
+
+extern Inverter ed25519_invert;
+
+extern UniformIntGetter ed25519_get_uniform_int;
+
+extern Deinitializer ed25519_deinitialize;
+
+/*!
+ * \brief get_ed25519_implementation
+ * \return An Api struct filled with a ed25519 implementation.
+ */
+struct Api get_ed25519_implementation();
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libcmix-crypto/ed25519/gcrypt/CMakeLists.txt b/libcmix-crypto/ed25519/gcrypt/CMakeLists.txt
new file mode 100644
index 0000000..d020e4b
--- /dev/null
+++ b/libcmix-crypto/ed25519/gcrypt/CMakeLists.txt
@@ -0,0 +1,46 @@
+include(get_target_name)
+
+get_target_name(target_name algo api)
+
+find_package(Gcrypt REQUIRED)
+
+option(trace_pointers "trace alloced pointers by gcrypt" OFF)
+
+add_library(${target_name} SHARED
+	gcrypt_ed25519.c
+)
+
+set_property(SOURCE gcrypt_ed25519.c PROPERTY COMPILE_DEFINITIONS
+	API=${api};ALGORITHM=${algo}
+)
+
+if(trace_pointers)
+	target_compile_definitions(${target_name}
+		PRIVATE "POINTER_TRACING"
+	)
+endif(trace_pointers)
+
+if(NOT Gcrypt_CFLAGS STREQUAL "")
+	IF(WIN32)
+		separate_arguments(flags WINDOWS_COMMAND ${Gcrypt_CFLAGS})
+	else(WIN32)
+		separate_arguments(flags UNIX_COMMAND ${Gcrypt_CFLAGS})
+	endif(WIN32)
+
+	foreach(flag ${flags})
+		target_compile_options(${target_name}
+			PUBLIC ${flag}
+		)
+	endforeach(flag)
+endif(NOT Gcrypt_CFLAGS STREQUAL "")
+
+if(UNIX)
+	target_link_libraries(${target_name}
+		PRIVATE m
+	)
+endif(UNIX)
+
+target_link_libraries(${target_name}
+	PRIVATE ed25519-interface
+	PUBLIC ${Gcrypt_LIBRARIES}
+)
diff --git a/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c b/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c
new file mode 100644
index 0000000..54202be
--- /dev/null
+++ b/libcmix-crypto/ed25519/gcrypt/gcrypt_ed25519.c
@@ -0,0 +1,526 @@
+#include "ed25519.h"
+
+#include "api.h"
+#include "impl_macros.h"
+
+#include "gcrypt.h"
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <math.h>
+
+#ifdef POINTER_TRACING
+	#define TRACE(FILE, LINE, PTR) \
+		fprintf(stderr, "%s %d %p\n", FILE, LINE, PTR);
+#else
+	#define TRACE(FILE, LINE, PTR)
+#endif
+
+static gcry_ctx_t ctx;
+
+static gcry_mpi_point_t g;
+static gcry_mpi_t p;
+
+static unsigned int nr_bits = 256;
+static unsigned int nr_point_bits = 256 * 2;
+static unsigned int nr_bytes = 256 / 8;
+static unsigned int stride = 16;
+
+void check(gcry_error_t error) {
+	if (error) {
+		fprintf (stderr, "Error: %s/%s\n", gcry_strsource (error), gcry_strerror (error));
+		exit(1);
+	}
+}
+
+void print_sexp(gcry_sexp_t exp) {
+	size_t required_size = gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, NULL, 0); //passing NULL as the buffer will return the size needed.
+
+	char* str = (char *) malloc(sizeof(char)*required_size);
+
+	gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, str, required_size); //So we ignore the size here.
+	
+	printf("size = %zu\n", required_size);
+	for(size_t i = 0; i < required_size; i++)
+		printf("%c", str[i]);
+	printf("\n");
+
+	free(str);
+}
+
+void DEF(initialize)(void) {
+	if (!gcry_check_version (GCRYPT_VERSION)) {
+		fprintf(stderr, "libgcrypt version mismatch\n");
+		exit(-1);
+	}
+
+	gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
+	gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
+	gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
+	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+	
+	gcry_error_t error;
+	
+	error = gcry_mpi_ec_new(&ctx, NULL, "Ed25519");
+	check(error);
+	
+	g = gcry_mpi_ec_get_point("g", ctx, false);
+	p = gcry_mpi_ec_get_mpi("p", ctx, false);
+}
+
+struct KeyPair DEF(create_keypair)(void) {
+	size_t parse_error_offset;
+	gcry_error_t error;
+	
+	gcry_sexp_t key_gen_sexp;
+	error = gcry_sexp_build(&key_gen_sexp, &parse_error_offset, "(genkey (ecc (curve Ed25519)))", NULL);
+	check(error);
+	
+	gcry_sexp_t key_pair;
+	error = gcry_pk_genkey(&key_pair, key_gen_sexp);
+	check(error);
+	
+	gcry_mpi_t d;
+	gcry_mpi_t q_mpi;
+	
+	gcry_sexp_extract_param(key_pair, "key-data!private-key", "q d", &q_mpi, &d, NULL);
+	
+	gcry_mpi_point_t q = gcry_mpi_point_new(nr_point_bits);
+	error = gcry_mpi_ec_decode_point(q, q_mpi, ctx);
+	check(error);
+	
+	assert(gcry_mpi_ec_curve_point(q, ctx));
+	
+	gcry_mpi_release(q_mpi);
+	gcry_sexp_release(key_gen_sexp);
+	gcry_sexp_release(key_pair);
+	
+	return (struct KeyPair) {
+		.sec = d,
+		.pub = q
+	};
+}
+
+void DEF(delete_keypair)(struct KeyPair* pair) {
+	gcry_mpi_release((gcry_mpi_t)pair->sec);
+	gcry_mpi_point_release((gcry_mpi_point_t)pair->pub);
+	pair->sec = NULL;
+	pair->pub = NULL;
+}
+
+void DEF(element_to_array)(unsigned char** buffer, size_t* len, GroupElement element) {
+	gcry_error_t error;
+	
+	gcry_mpi_t x = gcry_mpi_new(nr_bits);
+	gcry_mpi_t y = gcry_mpi_new(nr_bits);
+	
+	int ret = gcry_mpi_ec_get_affine(x, y, (gcry_mpi_point_t) element, ctx);
+	
+	if(ret != 0) {
+		abort();
+	}
+	
+	*len = nr_bytes * 2;
+	*buffer = (unsigned char*) calloc(*len, sizeof(unsigned char));
+	
+	unsigned char* temp = (unsigned char*) calloc(nr_bytes, sizeof(unsigned char));
+	size_t nwritten = 0;
+	
+	error = gcry_mpi_print(GCRYMPI_FMT_USG, temp, nr_bytes, &nwritten, (gcry_mpi_t) x);
+	check(error);
+	memcpy(*buffer + (nr_bytes - nwritten), temp, nwritten);
+
+	memset(temp, '\0', nr_bytes);
+	error = gcry_mpi_print(GCRYMPI_FMT_USG, temp, nr_bytes, &nwritten, (gcry_mpi_t) y);
+	check(error);
+	memcpy(*buffer + nr_bytes + (nr_bytes - nwritten), temp, nwritten);
+	
+	free(temp);
+	gcry_mpi_release(y);
+	gcry_mpi_release(x);
+}
+
+GroupElement DEF(message_to_element)(char const* buffer, size_t len, bool secure) {
+	(void) secure;
+	gcry_error_t error;
+	
+	assert(len == 31);
+	
+	gcry_mpi_t mpi;
+	gcry_mpi_scan(&mpi, GCRYMPI_FMT_USG, buffer, len, NULL);
+	
+	//mpi * stride
+	gcry_mpi_dump(mpi);
+	printf("\n");
+	gcry_mpi_lshift(mpi, mpi, (unsigned) lround(log2(stride)));
+	gcry_mpi_dump(mpi);
+	printf("\n");
+	
+	char* encoded_point = (char*) calloc(nr_bytes+1, sizeof(char));
+	gcry_mpi_point_t point = gcry_mpi_point_new(0);
+	unsigned int count = 0;
+	do {
+		encoded_point[0] = 0x40;
+		
+		unsigned int byte_size = (unsigned) ceil(gcry_mpi_get_nbits(mpi) / 8.0);
+		printf("byte_size: %i\n", byte_size);
+		//gcry_mpi_print(GCRYMPI_FMT_USG, (unsigned char*) encoded_point + 1 + (32 - byte_size), byte_size, NULL, mpi);
+		gcry_mpi_print(GCRYMPI_FMT_USG, (unsigned char*) encoded_point + 1, 32, NULL, mpi);
+	
+		for(int i = 0; i < 16; i++) {
+			char temp = encoded_point[i+1];
+			encoded_point[i+1] = encoded_point[32-i];
+			encoded_point[32-i] = temp;
+		}
+	
+		for(int i = 0; i < nr_bytes+1; i++) {
+			printf("%02x", 0xFF & (unsigned) encoded_point[i]);
+		}
+		printf("\n");
+	
+		gcry_mpi_t encoded_mpi = gcry_mpi_new(0);
+		gcry_mpi_set_opaque_copy(encoded_mpi, encoded_point, (nr_bytes + 1) * sizeof(char) * 8);
+		
+		error = gcry_mpi_ec_decode_point(point, encoded_mpi, ctx);
+		check(error);
+		
+		gcry_mpi_t x = gcry_mpi_new(0);
+		gcry_mpi_t y = gcry_mpi_new(0);
+		gcry_mpi_ec_get_affine(x, y, point, ctx);
+		
+		gcry_mpi_release(encoded_mpi);
+	
+		printf("%i %i\n", count, stride);
+		gcry_mpi_dump(x);
+		printf(",\n");
+		gcry_mpi_dump(y);
+		printf("\n");
+		gcry_mpi_dump(mpi);
+		printf("\n");
+		gcry_mpi_dump(encoded_mpi);
+		printf("\n");
+		gcry_mpi_dump(p);
+		printf("\n");
+		assert(gcry_mpi_cmp(mpi, p) == -1);
+		assert(count < stride);
+		gcry_mpi_add_ui(mpi, mpi, 1);
+		count++;
+		
+		if(!gcry_mpi_ec_curve_point(point, ctx)) {
+			gcry_mpi_point_release(point);
+			point = gcry_mpi_point_new(0);
+		}
+		
+	} while(!gcry_mpi_ec_curve_point(point, ctx));
+	
+	gcry_mpi_release(mpi);
+	free(encoded_point);
+	
+	return point;
+}
+
+void DEF(element_to_message)(unsigned char** buffer, const GroupElement el) {
+	gcry_mpi_t y = gcry_mpi_new(0);
+	gcry_mpi_ec_get_affine(NULL, y, (gcry_mpi_point_t) el, ctx);
+	
+	gcry_mpi_rshift(y, y, (unsigned) lround(log2(stride)));
+	
+	size_t nr_written;
+	gcry_mpi_aprint(GCRYMPI_FMT_USG, buffer, &nr_written, y);
+	
+	gcry_mpi_dump(y);
+	printf("\n");
+	
+	assert(nr_written == 31);
+	
+	gcry_mpi_release(y);
+}
+
+void DEF(free_buffer)(void* buffer) {
+	gcry_free(buffer);
+}
+
+GroupElement DEF(array_to_element)(char const* buffer, size_t len, bool secure) {
+	(void) secure;
+	size_t error_pos;
+	gcry_error_t error;
+	
+	printf("%i\n", len);
+	for(int i = 0; i < len; i++) {
+		if(i == 32) { printf("\n"); }
+		printf("%02x", 0xFF & buffer[i]);
+	}
+	printf("\n");
+	
+	gcry_mpi_t x;
+	error = gcry_mpi_scan(&x, GCRYMPI_FMT_USG, buffer, len/2, &error_pos);
+	check(error);
+	
+	gcry_mpi_t y;
+	error = gcry_mpi_scan(&y, GCRYMPI_FMT_USG, buffer + len/2, len/2, &error_pos);
+	
+	gcry_mpi_dump(y);
+	printf("\n");
+	
+	gcry_mpi_point_t point = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_point_set(point, x, y, GCRYMPI_CONST_ONE);
+	
+	gcry_mpi_release(x);
+	gcry_mpi_release(y);
+	
+	return point;
+}
+
+size_t DEF(get_pub_key_hash_length)(void) {
+	return 20;
+}
+
+//TODO: fix this up
+void DEF(get_pub_key_hash)(char** buffer, size_t* len, GroupElement const pub) {
+	(void)pub;
+	//gcry_sexp_t pubkey;
+	//gcry_error_t error;
+	//size_t err_off;
+	
+	//error = gcry_sexp_build(&pubkey, &err_off, "(public-key (ecc (curve Curve25519) (flags eddsa) (q %M)))", (gcry_mpi_point_t) pub);
+	//check(error);
+	
+	//*buffer = (char*) gcry_pk_get_keygrip(pubkey, NULL);
+	//TODO: see if we can instantiate a public key sexp;
+	
+	gcry_mpi_t x = gcry_mpi_new(0);
+	gcry_mpi_t y = gcry_mpi_new(0);
+	
+	gcry_mpi_point_get(x, y, NULL, (gcry_mpi_point_t)pub);
+	
+	printf("pub: %p\n", pub);
+	
+	fprintf(stderr, "lel1: ");
+	gcry_mpi_dump(x);
+	printf("\n");
+	fprintf(stderr, "lel2: ");
+	gcry_mpi_dump(y);
+	printf("\n");
+	
+	*len = DEF(get_pub_key_hash_length)();
+	*buffer = (char*) calloc(*len, sizeof(char));
+	
+	unsigned char* temp;
+	size_t len2;
+	DEF(element_to_array(&temp, &len2, pub));
+	
+	if(len2 < *len) {
+		memcpy((*buffer) + (*len - len2), temp, len2);
+	} else {
+		memcpy(*buffer, temp, *len);
+	}
+	gcry_free(temp);
+	
+	TRACE(__FILE__, __LINE__, *buffer);
+	//gcry_sexp_release(pubkey);
+}
+
+GroupElement DEF(get_group_element)(bool secure) {
+	(void) secure;
+	size_t parse_error_offset;
+	gcry_error_t error;
+	
+	gcry_mpi_t a = NULL;
+	void* bytes = NULL;
+	do {
+		gcry_free(bytes);
+		gcry_mpi_release(a);
+		bytes = gcry_random_bytes_secure(nr_bytes, GCRY_VERY_STRONG_RANDOM);
+		TRACE(__FILE__, __LINE__, bytes);
+		error = gcry_mpi_scan(&a, GCRYMPI_FMT_USG, bytes, nr_bytes, &parse_error_offset);
+		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));
+	gcry_mpi_point_t point = gcry_mpi_point_new(0);
+	do {
+		encoded_point[0] = 0x40;
+		
+		unsigned int byte_size = (unsigned) ceil(gcry_mpi_get_nbits(a) / 8.0);
+		gcry_mpi_print(GCRYMPI_FMT_USG, (unsigned char*) encoded_point + 1, 32, NULL, a);
+	
+		for(int i = 0; i < 16; i++) {
+			char temp = encoded_point[i+1];
+			encoded_point[i+1] = encoded_point[32-i];
+			encoded_point[32-i] = temp;
+		}
+	
+		gcry_mpi_t encoded_mpi = gcry_mpi_new(0);
+		gcry_mpi_set_opaque_copy(encoded_mpi, encoded_point, (nr_bytes + 1) * sizeof(char) * 8);
+		
+		error = gcry_mpi_ec_decode_point(point, encoded_mpi, ctx);
+		check(error);
+			
+		gcry_mpi_release(encoded_mpi);
+		
+		if(!gcry_mpi_ec_curve_point(point, ctx)) {
+			gcry_mpi_point_release(point);
+			point = gcry_mpi_point_new(0);
+			
+			gcry_mpi_add_ui(a, a, 1);
+		}
+	
+	} while(!gcry_mpi_ec_curve_point(point, ctx));
+	
+	gcry_mpi_release(a);
+	gcry_free(bytes);
+	
+	return point;
+}
+
+GroupElement DEF(get_key_exchange_value)(GroupElement group_el) {	
+	gcry_mpi_t x = gcry_mpi_new(nr_bits);
+	gcry_mpi_point_get(x, NULL, NULL, (gcry_mpi_point_t) group_el);
+	
+	gcry_mpi_point_t mult = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_mul(mult, x, g, ctx);
+	
+	gcry_mpi_release(x);
+	
+	return mult;
+}
+
+GroupElement DEF(combine)(GroupElement lh, GroupElement rh, bool secure) {
+	(void) secure;
+	gcry_mpi_point_t addition = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_add(addition, (gcry_mpi_point_t)lh, (gcry_mpi_point_t)rh, ctx);
+	return addition;
+}
+
+GroupElement DEF(invert)(GroupElement const el) {
+	gcry_mpi_t x = gcry_mpi_new(nr_bits);
+	gcry_mpi_t y = gcry_mpi_new(nr_bits);
+	
+	gcry_mpi_ec_get_affine(x, y, (gcry_mpi_point_t) el, ctx);
+	
+	gcry_mpi_t neg_x = gcry_mpi_new(nr_bits);
+	gcry_mpi_subm(neg_x, p, x, p);
+	
+	gcry_mpi_point_t point = gcry_mpi_point_set(NULL, neg_x, y, GCRYMPI_CONST_ONE);
+	
+	gcry_mpi_release(neg_x);
+	gcry_mpi_release(x);
+	gcry_mpi_release(y);
+	
+	return point;
+}
+
+void DEF(delete_group_element)(GroupElement element) {
+	gcry_mpi_point_release((gcry_mpi_point_t)element);
+}
+
+GroupElement DEF(uncombine)(GroupElement lh, GroupElement rh, bool secure) {
+	(void) secure;
+	
+	gcry_mpi_point_t inv_rh = DEF(invert)(rh);
+	gcry_mpi_point_t ret = DEF(combine)(lh, inv_rh, secure);
+	
+	//gcry_mpi_point_t ret = gcry_mpi_point_new(0);
+	//gcry_mpi_ec_sub(ret, (gcry_mpi_point_t)lh, (gcry_mpi_point_t)rh, ctx);
+	return ret;
+}
+
+GroupElement DEF(get_decryption_share)(GroupElement r, GroupElement e) {
+	gcry_mpi_point_t inv_d = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_mul(inv_d, (gcry_mpi_t)e, (gcry_mpi_point_t) r, ctx);
+	
+	GroupElement d = DEF(invert)(inv_d);
+	gcry_mpi_point_release(inv_d);
+	
+	return d;
+}
+
+size_t DEF(get_group_element_array_size)(void) {
+	return nr_bytes*2;
+}
+
+size_t DEF(get_message_size)(void) {
+	return nr_bytes-1;
+}
+
+void DEF(add_public_share)(GroupElement* el, char const* share, size_t in_len, GroupElement pubkey) {
+	GroupElement share_el = DEF(array_to_element)(share, in_len, false);
+	*el = DEF(combine)(share_el, pubkey, false);
+	gcry_mpi_point_release((gcry_mpi_point_t)share_el);
+}
+
+GroupElement DEF(derive_shared_key)(struct KeyPair keypair, unsigned char const* other_pub, size_t pub_len, unsigned char const* value, size_t value_len, void* priv_value, bool swap) {
+	(void)keypair;
+	(void)other_pub;
+	(void)pub_len;
+	(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_point_release((gcry_mpi_point_t) ga);
+	
+	return gab;
+}
+
+void DEF(delete_shared_key)(struct SharedKey* s) {
+	gcry_mpi_point_release((gcry_mpi_point_t)s->shared);
+	s->shared = NULL;
+}
+
+void DEF(encrypt)(GroupElement* random_element, GroupElement* message_element, GroupElement value, GroupElement key) {
+	GroupElement random = DEF(get_group_element)(true);
+	
+	gcry_mpi_t random_mpi = gcry_mpi_new(nr_bits);
+	gcry_mpi_ec_get_affine(random_mpi, NULL, (gcry_mpi_point_t)random, ctx);
+	
+	*random_element = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_mul((gcry_mpi_point_t)*random_element, random_mpi, g, ctx);
+	
+	gcry_mpi_point_t c2 = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_mul(c2, random_mpi, (gcry_mpi_point_t) key, ctx);
+	
+	*message_element = gcry_mpi_point_new(nr_point_bits);
+	gcry_mpi_ec_add((gcry_mpi_point_t)* message_element, c2, (gcry_mpi_point_t) value, ctx);
+	
+	gcry_mpi_release(random_mpi);
+	gcry_mpi_point_release(c2);
+}
+
+unsigned int DEF(get_uniform_int)(unsigned int upper) {
+	unsigned int random_value;
+	
+	if(upper == 0) {
+		void* buffer = gcry_random_bytes_secure(sizeof(unsigned int), GCRY_STRONG_RANDOM);
+		TRACE(__FILE__, __LINE__, buffer);
+		memcpy(&random_value, buffer, sizeof(unsigned int));
+		gcry_free(buffer);
+		
+		return random_value;
+	}
+	
+	unsigned int lower = -upper % upper;
+	do {
+		void* buffer = gcry_random_bytes_secure(sizeof(unsigned int), GCRY_STRONG_RANDOM);
+		TRACE(__FILE__, __LINE__, buffer);
+		memcpy(&random_value, buffer, sizeof(unsigned int));
+		gcry_free(buffer);
+		
+		if (random_value >= lower)
+			return random_value % upper;
+		
+		
+	} while(true);
+}
+
+void DEF(deinitialize)(void) {
+	gcry_mpi_point_release(g);
+	gcry_mpi_release(p);
+	gcry_ctx_release(ctx);
+}
+
+LINK_IMPLEMENTATION
\ No newline at end of file
diff --git a/libcmix-crypto/elgamal/elgamal.c b/libcmix-crypto/elgamal/elgamal.c
index 399d952..d103230 100644
--- a/libcmix-crypto/elgamal/elgamal.c
+++ b/libcmix-crypto/elgamal/elgamal.c
@@ -10,13 +10,16 @@ struct Api get_elgamal_implementation()
 		.element_to_array = elgamal_element_to_array,
 		.free_buffer = elgamal_free_buffer,
 		.array_to_element = elgamal_array_to_element,
+		.message_to_element = elgamal_message_to_element,
 		.get_pub_key_hash = elgamal_get_pub_key_hash,
 		.get_pub_key_hash_length = elgamal_get_pub_key_hash_length,
 		.get_group_element = elgamal_get_group_element,
 		.get_group_element_array_size = elgamal_get_group_element_array_size,
+		.get_message_size = elgamal_get_message_size,
 		.free_group_element = elgamal_delete_group_element,
 		.get_key_exchange_value = elgamal_get_key_exchange_value,
-		.multiply = elgamal_multiply,
+		.combine = elgamal_combine,
+		.uncombine = elgamal_uncombine,
 		.get_decryption_share = elgamal_get_decryption_share,
 		.add_public_share = elgamal_add_public_share,
 		.derive_shared_key = elgamal_derive_shared_key,
diff --git a/libcmix-crypto/elgamal/elgamal.h b/libcmix-crypto/elgamal/elgamal.h
index 1fe4447..4cc3013 100644
--- a/libcmix-crypto/elgamal/elgamal.h
+++ b/libcmix-crypto/elgamal/elgamal.h
@@ -22,6 +22,8 @@ extern BufferDeleter elgamal_free_buffer;
 
 extern ArrayToElement elgamal_array_to_element;
 
+extern MessageToElement elgamal_message_to_element;
+
 extern PubKeyHashGetter elgamal_get_pub_key_hash;
 
 extern PubKeyHashLengthGetter elgamal_get_pub_key_hash_length;
@@ -32,12 +34,16 @@ extern GroupElementDeleter elgamal_delete_group_element;
 
 extern KeyExchangeValueGetter elgamal_get_key_exchange_value;
 
-extern GroupElementMultiplier elgamal_multiply;
+extern GroupElementCombiner elgamal_combine;
+
+extern GroupElementUncombiner elgamal_uncombine;
 
 extern DecryptionShareGetter elgamal_get_decryption_share;
 
 extern GroupElementArraySizeGetter elgamal_get_group_element_array_size;
 
+extern MessageSizeGetter elgamal_get_message_size;
+
 extern PublicShareAdder elgamal_add_public_share;
 
 extern SharedKeyDeriver elgamal_derive_shared_key;
diff --git a/libcmix-crypto/elgamal/gcrypt/CMakeLists.txt b/libcmix-crypto/elgamal/gcrypt/CMakeLists.txt
index d8c19b8..6dfdc74 100644
--- a/libcmix-crypto/elgamal/gcrypt/CMakeLists.txt
+++ b/libcmix-crypto/elgamal/gcrypt/CMakeLists.txt
@@ -1,6 +1,6 @@
 include(get_target_name)
 
-get_target_name(target_name)
+get_target_name(target_name algo api)
 
 find_package(Gcrypt REQUIRED)
 
diff --git a/libcmix-crypto/elgamal/gcrypt/gcrypt_elgamal.c b/libcmix-crypto/elgamal/gcrypt/gcrypt_elgamal.c
index ec993a6..dff75b1 100644
--- a/libcmix-crypto/elgamal/gcrypt/gcrypt_elgamal.c
+++ b/libcmix-crypto/elgamal/gcrypt/gcrypt_elgamal.c
@@ -31,7 +31,7 @@ void print_sexp(gcry_sexp_t exp) {
 
 	char* str = (char *) malloc(sizeof(char)*required_size);
 
-	gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, str, 2000); //So we ignore the size here.
+	gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, str, required_size); //So we ignore the size here.
 	
 	printf("size = %zu\n", required_size);
 	for(size_t i = 0; i < required_size; i++)
@@ -113,11 +113,11 @@ struct KeyPair gcrypt_elgamal_create_keypair() {
 	};
 }
 
-void gcrypt_elgamal_delete_keypair(struct KeyPair* p) {
-	gcry_mpi_release((gcry_mpi_t) p->sec);
-	gcry_mpi_release((gcry_mpi_t) p->pub);
-	p->sec = NULL;
-	p->pub = NULL;
+void gcrypt_elgamal_delete_keypair(struct KeyPair* pair) {
+	gcry_mpi_release((gcry_mpi_t) pair->sec);
+	gcry_mpi_release((gcry_mpi_t) pair->pub);
+	pair->sec = NULL;
+	pair->pub = NULL;
 }
 
 void gcrypt_elgamal_element_to_array(unsigned char** buffer, size_t* len, void* key) {
@@ -145,6 +145,10 @@ void* gcrypt_elgamal_array_to_element(char const* buffer, size_t len, bool secur
 	return mpi;
 }
 
+GroupElement gcrypt_elgamal_message_to_element(char const* buffer, size_t len, bool secure) {
+	return gcrypt_elgamal_array_to_element(buffer, len, secure);
+}
+
 void gcrypt_elgamal_get_pub_key_hash(char** buffer, size_t* len, GroupElement const pub) {
 	gcry_sexp_t pubkey;
 	gcry_error_t error;
@@ -192,13 +196,24 @@ GroupElement gcrypt_elgamal_get_key_exchange_value(GroupElement group_el) {
 	return val;
 }
 
-GroupElement gcrypt_elgamal_multiply(GroupElement lh, GroupElement rh, bool secure) {
+GroupElement gcrypt_elgamal_invert(GroupElement const el);
+void gcrypt_elgamal_delete_group_element(GroupElement el);
+
+GroupElement gcrypt_elgamal_combine(GroupElement lh, GroupElement rh, bool secure) {
 	gcry_mpi_t ret = secure ? gcry_mpi_snew(0) : gcry_mpi_new(0);
 	TRACE(__FILE__, __LINE__, ret);
 	gcry_mpi_mulm(ret, (gcry_mpi_t) lh, (gcry_mpi_t) rh, p);
 	return ret;
 }
 
+GroupElement gcrypt_elgamal_uncombine(GroupElement lh, GroupElement rh, bool secure) {
+	(void) secure;
+	GroupElement inv_rh = gcrypt_elgamal_invert(rh);
+	GroupElement ret = gcrypt_elgamal_combine(lh, inv_rh, true);
+	gcrypt_elgamal_delete_group_element(inv_rh);
+	return ret;
+}
+
 GroupElement gcrypt_elgamal_get_decryption_share(GroupElement r, GroupElement e) {
 	gcry_mpi_t inv_d = gcry_mpi_snew(nr_bits);
 	gcry_mpi_powm(inv_d, (gcry_mpi_t)r, (gcry_mpi_t)e, p);
@@ -217,6 +232,10 @@ size_t gcrypt_elgamal_get_group_element_array_size() {
 	return nr_bytes;
 }
 
+size_t gcrypt_elgamal_get_message_size() {
+	return nr_bytes - 1;
+}
+
 void gcrypt_elgamal_delete_group_element(void* el) {
 	gcry_mpi_release((gcry_mpi_t) el);
 }
@@ -346,14 +365,17 @@ KeyPairDeleter elgamal_delete_keypair = &gcrypt_elgamal_delete_keypair;
 ElementToArray elgamal_element_to_array = &gcrypt_elgamal_element_to_array;
 BufferDeleter elgamal_free_buffer = &gcrypt_elgamal_free_buffer;
 ArrayToElement elgamal_array_to_element = &gcrypt_elgamal_array_to_element;
+MessageToElement elgamal_message_to_element = &gcrypt_elgamal_message_to_element;
 PubKeyHashGetter elgamal_get_pub_key_hash = &gcrypt_elgamal_get_pub_key_hash;
 PubKeyHashLengthGetter elgamal_get_pub_key_hash_length = &gcrypt_elgamal_get_pub_key_hash_length;
 GroupElementGetter elgamal_get_group_element = &gcrypt_elgamal_get_group_element;
 GroupElementDeleter elgamal_delete_group_element = &gcrypt_elgamal_delete_group_element;
 KeyExchangeValueGetter elgamal_get_key_exchange_value = &gcrypt_elgamal_get_key_exchange_value;
-GroupElementMultiplier elgamal_multiply = &gcrypt_elgamal_multiply;
+GroupElementCombiner elgamal_combine = &gcrypt_elgamal_combine;
+GroupElementUncombiner elgamal_uncombine = &gcrypt_elgamal_uncombine;
 DecryptionShareGetter elgamal_get_decryption_share = &gcrypt_elgamal_get_decryption_share;
 GroupElementArraySizeGetter elgamal_get_group_element_array_size = &gcrypt_elgamal_get_group_element_array_size;
+MessageSizeGetter elgamal_get_message_size = &gcrypt_elgamal_get_message_size;
 PublicShareAdder elgamal_add_public_share = &gcrypt_elgamal_add_public_share;
 SharedKeyDeriver elgamal_derive_shared_key = &gcrypt_elgamal_derive_shared_key;
 SharedKeyDeleter elgamal_delete_shared_key = &gcrypt_elgamal_delete_shared_key;
diff --git a/libcmix-crypto/elgamal/null/CMakeLists.txt b/libcmix-crypto/elgamal/null/CMakeLists.txt
index a866428..c017bdc 100644
--- a/libcmix-crypto/elgamal/null/CMakeLists.txt
+++ b/libcmix-crypto/elgamal/null/CMakeLists.txt
@@ -1,6 +1,6 @@
 include(get_target_name)
 
-get_target_name(target_name)
+get_target_name(target_name algo api)
 
 add_library(${target_name} SHARED
 	null_elgamal.c
diff --git a/libcmix-crypto/elgamal/null/null_elgamal.c b/libcmix-crypto/elgamal/null/null_elgamal.c
index 2b5c43b..c626e63 100644
--- a/libcmix-crypto/elgamal/null/null_elgamal.c
+++ b/libcmix-crypto/elgamal/null/null_elgamal.c
@@ -36,7 +36,7 @@ ArrayToElement elgamal_array_to_element = NULL;//&null_elgamal_array_to_element;
 GroupElementGetter elgamal_get_group_element = NULL;//&null_elgamal_get_group_element;
 GroupElementDeleter elgamal_delete_group_element = NULL;//&null_elgamal_delete_group_element;
 KeyExchangeValueGetter elgamal_get_key_exchange_value = NULL;//&null_elgamal_get_key_exchange_value;
-GroupElementMultiplier elgamal_multiply = NULL;//&null_elgamal_multiply;
+GroupElementCombiner elgamal_multiply = NULL;//&null_elgamal_multiply;
 DecryptionShareGetter elgamal_get_decryption_share = NULL;//&null_elgamal_get_decryption_share;
 GroupElementArraySizeGetter elgamal_get_group_element_array_size = NULL;//&null_elgamal_get_group_element_array_size;
 PublicShareAdder elgamal_add_public_share = NULL;//&null_elgamal_add_public_share;
diff --git a/libcmix-crypto/impl_macros.h b/libcmix-crypto/impl_macros.h
new file mode 100644
index 0000000..15d8ddf
--- /dev/null
+++ b/libcmix-crypto/impl_macros.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#define VAR_IN_(x, y) x ## _ ## y
+#define VAR_IN(x, y) VAR_IN_(x, y)
+#define VAR(y) VAR_IN(ALGORITHM, y)
+#define DEF_IN_(x, y, z) x ## _ ## y ## _ ## z
+#define DEF_IN(x, y, z) DEF_IN_(x, y, z)
+#define DEF(z) DEF_IN(API, ALGORITHM, z)
+
+#define LINK_IMPLEMENTATION \
+Initializer VAR(initialize) = &DEF(initialize); \
+KeyPairCreator VAR(create_keypair) = &DEF(create_keypair); \
+KeyPairDeleter VAR(delete_keypair) = &DEF(delete_keypair); \
+ElementToArray VAR(element_to_array) = &DEF(element_to_array); \
+BufferDeleter VAR(free_buffer) = &DEF(free_buffer); \
+ArrayToElement VAR(array_to_element) = &DEF(array_to_element); \
+MessageToElement VAR(message_to_element) = &DEF(message_to_element); \
+ElementToMessage VAR(element_to_message) = &DEF(element_to_message); \
+PubKeyHashGetter VAR(get_pub_key_hash) = &DEF(get_pub_key_hash); \
+PubKeyHashLengthGetter VAR(get_pub_key_hash_length) = &DEF(get_pub_key_hash_length); \
+GroupElementGetter VAR(get_group_element) = &DEF(get_group_element); \
+GroupElementDeleter VAR(delete_group_element) = &DEF(delete_group_element); \
+KeyExchangeValueGetter VAR(get_key_exchange_value) = &DEF(get_key_exchange_value); \
+GroupElementCombiner VAR(combine) = &DEF(combine); \
+GroupElementUncombiner VAR(uncombine) = &DEF(uncombine); \
+DecryptionShareGetter VAR(get_decryption_share) = &DEF(get_decryption_share); \
+GroupElementArraySizeGetter VAR(get_group_element_array_size) = &DEF(get_group_element_array_size); \
+MessageSizeGetter VAR(get_message_size) = &DEF(get_message_size); \
+PublicShareAdder VAR(add_public_share) = &DEF(add_public_share); \
+SharedKeyDeriver VAR(derive_shared_key) = &DEF(derive_shared_key); \
+SharedKeyDeleter VAR(delete_shared_key) = &DEF(delete_shared_key); \
+Encrypter VAR(encrypt) = &DEF(encrypt); \
+Inverter VAR(invert) = &DEF(invert); \
+UniformIntGetter VAR(get_uniform_int) = &DEF(get_uniform_int); \
+Deinitializer VAR(deinitialize) = &DEF(deinitialize);
+
+//before expanding LINK_IMPLEMENTATION in your crypto api implementation file you need to define the following functions
+
+/*
+void DEF(initialize)(void) {}
+struct KeyPair DEF(create_keypair)(void) {}
+void DEF(delete_keypair)(struct KeyPair* pair) {}
+void DEF(element_to_array)(unsigned char** buffer, size_t* len, GroupElement element) {}
+void DEF(free_buffer)(void* buffer) {}
+GroupElement DEF(array_to_element)(char const* buffer, size_t len, bool secure) {}
+GroupElement DEF(message_to_element)(char const* buffer, size_t len, bool secure) {}
+void DEF(element_to_message)(char** buffer, const GroupElement el);
+size_t DEF(get_pub_key_hash_length)(void) {}
+void DEF(get_pub_key_hash)(char** buffer, size_t* len, GroupElement const pub) {}
+GroupElement DEF(get_group_element)(bool secure) {}
+GroupElement DEF(get_key_exchange_value)(GroupElement group_el) {}
+GroupElement DEF(combine)(GroupElement lh, GroupElement rh, bool secure) {}
+GroupElement DEF(uncombine)(GroupElement lh, GroupElement rh, bool secure) {}
+GroupElement DEF(get_decryption_share)(GroupElement r, GroupElement e) {}
+size_t DEF(get_group_element_array_size)(void) {}
+size_t DEF(get_message_size)(void) {}
+void DEF(delete_group_element)(GroupElement element) {}
+void DEF(add_public_share)(GroupElement* el, char const* share, size_t in_len, GroupElement pubkey) {}
+GroupElement DEF(derive_shared_key)(struct KeyPair keypair, unsigned char const* other_pub, size_t pub_len, unsigned char const* value, size_t value_len, void* priv_value, bool swap) {}
+void DEF(delete_shared_key)(struct SharedKey* s) {}
+void DEF(encrypt)(GroupElement* random_element, GroupElement* message_element, GroupElement value, GroupElement key) }
+GroupElement DEF(invert)(GroupElement const x) {}
+unsigned int DEF(get_uniform_int)(unsigned int upper) {}
+void DEF(deinitialize)(void) {}
+*/
\ No newline at end of file
diff --git a/libcmix-network/accept.cpp b/libcmix-network/accept.cpp
index 1ec26fe..9806a67 100644
--- a/libcmix-network/accept.cpp
+++ b/libcmix-network/accept.cpp
@@ -36,12 +36,12 @@ void accept_connection(tcp::acceptor& acceptor, std::shared_ptr<ssl::context> ct
 {
 	if(!bool(ec))
 	{
-		socket->async_handshake(boost::asio::ssl::stream_base::server, [&acceptor, ctx, socket, f](boost::system::error_code const& ec) {
-			if(!bool(ec)) {
+		socket->async_handshake(boost::asio::ssl::stream_base::server, [&acceptor, ctx, socket, f](boost::system::error_code const& ec2) {
+			if(!bool(ec2)) {
 				f(std::unique_ptr<ssl::stream<tcp::socket>>(socket), ctx);
 			} else {
 				std::stringstream ss;
-				ss << ec.message();
+				ss << ec2.message();
 				delete socket;
 				throw std::runtime_error(ss.str());
 			}
diff --git a/libcmix-network/client.hpp b/libcmix-network/client.hpp
index 7b2b16f..ff32d2e 100644
--- a/libcmix-network/client.hpp
+++ b/libcmix-network/client.hpp
@@ -74,8 +74,8 @@ class BaseClient {
 			boost::asio::async_read(
 				*socket,
 				receive_buffer->prepare(size),
-				[this, message_handler](boost::system::error_code const& ec, size_t read_bytes) {
-					handle_receive_message(message_handler, ec, read_bytes);
+				[this, message_handler](boost::system::error_code const& ec2, size_t read_bytes2) {
+					handle_receive_message(message_handler, ec2, read_bytes2);
 				}
 			);
 		} else {
diff --git a/libcmix-network/connect.cpp b/libcmix-network/connect.cpp
index e80a6d4..4bebf9d 100644
--- a/libcmix-network/connect.cpp
+++ b/libcmix-network/connect.cpp
@@ -70,11 +70,11 @@ void async_connect_iteration(basic_socket<tcp, stream_socket_service<tcp>>& sock
 				
 				info->retry_timer.expires_from_now(boost::posix_time::seconds(seconds_to_wait));
 				
-				info->retry_timer.async_wait([&socket, info, on_connect](boost::system::error_code const& ec){
-					if(ec == boost::system::errc::operation_canceled) {
+				info->retry_timer.async_wait([&socket, info, on_connect](boost::system::error_code const& ec2){
+					if(ec2 == boost::system::errc::operation_canceled) {
 						return;
-					} else if(ec) {
-						BOOST_LOG_TRIVIAL(error) << "Something went wrong with the retry timer: " << ec.message();
+					} else if(ec2) {
+						BOOST_LOG_TRIVIAL(error) << "Something went wrong with the retry timer: " << ec2.message();
 					} else {
 						async_connect_iteration(socket, info, on_connect);
 					}
diff --git a/libcmix-network/server.cpp b/libcmix-network/server.cpp
index a931c1e..e254d5d 100644
--- a/libcmix-network/server.cpp
+++ b/libcmix-network/server.cpp
@@ -4,8 +4,7 @@ using namespace boost::asio::ip;
 using namespace boost::asio;
 
 Server::Server(io_service& io_service, const ListenSettings& listen_settings)
-: listen_settings(listen_settings)
-, v4_acceptor(io_service, address_v4::from_string(listen_settings.ipv4_inaddr), listen_settings.port)
+: v4_acceptor(io_service, address_v4::from_string(listen_settings.ipv4_inaddr), listen_settings.port)
 , v6_acceptor(io_service, address_v6::from_string(listen_settings.ipv6_inaddr), listen_settings.port)
 {
 	/*
diff --git a/libcmix-network/server.hpp b/libcmix-network/server.hpp
index 29559e7..878bb0b 100644
--- a/libcmix-network/server.hpp
+++ b/libcmix-network/server.hpp
@@ -31,7 +31,6 @@ class Server
 {
 	Server(boost::asio::io_service& io_service, ListenSettings const& listen_settings);
 
-	ListenSettings const& listen_settings;	
 	Acceptor v4_acceptor;
 	Acceptor v6_acceptor;
 	
diff --git a/libcmix/cmix.c b/libcmix/cmix.c
index a4fba6f..f697dc0 100644
--- a/libcmix/cmix.c
+++ b/libcmix/cmix.c
@@ -80,6 +80,7 @@ void element_to_buffer(struct CMixContext const* ctx, char* out_buffer, GroupEle
 	size_t len;
 	
 	ctx->api.element_to_array(&buffer, &len, element);
+	
 	size_t diff = el_size - len;
 	memcpy(out_buffer + diff, buffer, len);
 	ctx->api.free_buffer(buffer);
@@ -157,6 +158,11 @@ size_t get_group_element_array_size(struct CMixContext const* ctx) {
 	return ctx->api.get_group_element_array_size();
 }
 
+size_t get_message_size(struct CMixContext const* ctx)
+{
+	return ctx->api.get_message_size();
+}
+
 enum cmix_error set_network_key(struct CMixContext* ctx, char const* buffer) {
 	ctx->network_key = ctx->api.array_to_element(buffer, get_group_element_array_size(ctx), true);
 	return no_error;
@@ -193,8 +199,8 @@ enum cmix_error encrypt_r_and_multiply(struct CMixContext const* ctx, char** ran
 		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.multiply(enc_random_element, other_random_element, true);
-		GroupElement new_message_element = ctx->api.multiply(enc_message_element, other_message_element, 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);
@@ -223,8 +229,8 @@ enum cmix_error permute_and_multiply_encrypted_s(struct CMixContext const* ctx,
 		
 		ctx->api.encrypt(&random_s, &message_s, ctx->s[new_pos], ctx->network_key);
 		
-		GroupElement random_pirs = ctx->api.multiply(random_r, random_s, true);
-		GroupElement message_pirs = ctx->api.multiply(message_r, message_s, true);
+		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);
@@ -247,7 +253,7 @@ enum cmix_error permute_and_multiply_s(struct CMixContext* ctx, char** out_buffe
 		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.multiply(message_el, ctx->s[new_pos], 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]);
 		
@@ -264,7 +270,7 @@ enum cmix_error multiply_s(struct CMixContext const* ctx, char* out_buffer, char
 	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);
+	GroupElement mult = ctx->api.combine(message_el, ctx->s[ctx->permutation[index]], false);
 	
 	element_to_buffer(ctx, out_buffer, mult);
 	
@@ -290,7 +296,7 @@ enum cmix_error key_exchange_responder(struct CMixContext const* ctx, GroupEleme
 	GroupElement ex_val = ctx->api.get_key_exchange_value(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, true);
+	*shared_key = ctx->api.derive_shared_key(ctx->keypair, (unsigned char const*)pubkey, el_len, (unsigned char const*)value, el_len, priv_el, true);
 	
 	element_to_buffer(ctx, public_key_buffer, ctx->keypair.pub);
 	element_to_buffer(ctx, exchange_value_buffer, ex_val);
@@ -303,7 +309,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 const*)pubkey, el_len, (unsigned char const*)value, el_len, *priv_el, false);
 	
 	ctx->api.free_group_element(*priv_el);
 	*priv_el = NULL;
@@ -335,6 +341,7 @@ enum cmix_error precomputation_post_process_unsafe(struct CMixContext* ctx, char
 */
 
 size_t get_commitment_length(struct CMixContext const* ctx) {
+	(void) ctx;
 	return 1;
 }
 
@@ -358,6 +365,7 @@ enum cmix_error precomputation_post_process(struct CMixContext* ctx, char* commi
 }
 
 enum cmix_error commit_precomputation_ciphertext(struct CMixContext* ctx, char* commitment, const char** m_epirs) {
+	(void) m_epirs;
 	//ToDo: actually calculate commitment.
 	memset(commitment, 0, get_commitment_length(ctx));
 
@@ -365,17 +373,17 @@ enum cmix_error commit_precomputation_ciphertext(struct CMixContext* ctx, char*
 }
 
 enum cmix_error blind_message(struct CMixContext const* ctx, char* m_out, char const* message, GroupElement const* keys, size_t const nr_nodes) {
-	size_t len = get_group_element_array_size(ctx); 
+	size_t len = get_message_size(ctx); 
 	
 	GroupElement* intermediates = (GroupElement*) calloc(nr_nodes + 1, sizeof(GroupElement));
 	if(intermediates == NULL) {
 		return out_of_memory;
 	}
 	
-	intermediates[0] = ctx->api.array_to_element(message, len, true);
+	intermediates[0] = ctx->api.message_to_element(message, len, true);
 	
 	for(size_t i = 0; i < nr_nodes; ++i) {
-		intermediates[i+1] = ctx->api.multiply(intermediates[i], keys[i], false);
+		intermediates[i+1] = ctx->api.combine(intermediates[i], keys[i], false);
 	}
 	
 	element_to_buffer(ctx, m_out, intermediates[nr_nodes]);
@@ -395,8 +403,8 @@ enum cmix_error swap_k_for_r(struct CMixContext const* ctx, char** out_buffer, c
 		GroupElement mes = ctx->api.array_to_element(message[i], len, false);
 		GroupElement inv_key = ctx->api.invert(key[i]);
 		
-		GroupElement unblinded = ctx->api.multiply(mes, inv_key, false);
-		GroupElement blinded = ctx->api.multiply(unblinded, ctx->r[i], false);
+		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);
@@ -425,7 +433,7 @@ 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.multiply(ctx->decryption_shares[i], msg, 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);
@@ -440,20 +448,27 @@ enum cmix_error remove_pirs(struct CMixContext const* ctx, char** out_buffer, co
 
 	for(size_t i = 0; i < ctx->nr_participants; ++i) {
 		GroupElement g_pirs = ctx->api.array_to_element(pirs[i], len, false);
-		GroupElement inv_pirs = ctx->api.invert(g_pirs);
 		
-		GroupElement mult = ctx->api.multiply(ctx->PiMRS[i], inv_pirs, false);
+		GroupElement mult = ctx->api.uncombine(ctx->PiMRS[i], g_pirs, false);
 		
 		element_to_buffer(ctx, out_buffer[i], mult);
 		
 		ctx->api.free_group_element(g_pirs);
-		ctx->api.free_group_element(inv_pirs);
 		ctx->api.free_group_element(mult);
 	}
 	
 	return no_error;
 }
 
+enum cmix_error element_to_message(struct CMixContext const* ctx, unsigned char** buffer, char const* element_buffer) {
+	
+	GroupElement el = ctx->api.array_to_element(element_buffer, ctx->api.get_group_element_array_size(), true);
+	ctx->api.element_to_message(buffer, el);
+	ctx->api.free_group_element(el);
+	
+	return no_error;
+}
+
 enum cmix_error get_pub_key_hash(struct CMixContext const* ctx, char** buffer, size_t* len) {
 	ctx->api.get_pub_key_hash(buffer, len, ctx->keypair.pub);
 	
@@ -467,35 +482,34 @@ size_t get_pub_key_hash_length(struct CMixContext const* ctx)
 
 enum cmix_error create_message(struct CMixContext const* ctx, char* out_buffer, const char* dest, size_t dest_len, const char* payload, size_t payload_len)
 {
-	size_t el_arr_len = get_group_element_array_size(ctx);
+	size_t el_arr_len = get_message_size(ctx);
 	
-	memcpy(&out_buffer[1], dest, dest_len);
+	memcpy(out_buffer, dest, dest_len);
 	
-	size_t message_limit = el_arr_len - 1 -dest_len;
+	size_t message_limit = el_arr_len -dest_len;
 	
-	memcpy(&out_buffer[1] + dest_len, payload, (message_limit < payload_len ? message_limit : payload_len));
+	memcpy(out_buffer + dest_len, payload, (message_limit < payload_len ? message_limit : payload_len));
 	
 	return no_error;
 }
 
 enum cmix_error split_message(struct CMixContext const* ctx, char** dest_buffer, size_t* dest_len, char** payload_buffer, size_t* payload_len, char const* message)
 {
-	size_t el_arr_len = get_group_element_array_size(ctx);
+	size_t message_len = get_message_size(ctx);
 	*dest_len = get_pub_key_hash_length(ctx);
 	
 	*dest_buffer = (char*) calloc(*dest_len, sizeof(char));
 	if(*dest_buffer == NULL) {
 		return out_of_memory;
 	}
-	memcpy(*dest_buffer, &message[1], *dest_len);
+	memcpy(*dest_buffer, message, *dest_len);
 	
-	*payload_len = el_arr_len - 1 - *dest_len;
+	*payload_len = message_len - *dest_len;
 	*payload_buffer = (char*) calloc(*payload_len, sizeof(char));
 	if(*payload_buffer == NULL) {
 		return out_of_memory;
 	}
-	memcpy(*payload_buffer, &message[1 + *dest_len], *payload_len);
+	memcpy(*payload_buffer, &message[*dest_len], *payload_len);
 	
 	return no_error;
 }
-
diff --git a/libcmix/cmix.h b/libcmix/cmix.h
index 5c6a4c1..54df573 100644
--- a/libcmix/cmix.h
+++ b/libcmix/cmix.h
@@ -206,11 +206,18 @@ enum cmix_error generate_random_message(struct CMixContext* ctx, char* buffer);
 /*!
  * \brief get_group_element_array_size Get the minimum size required to store an array representation of a group element.
  * \param ctx The relevant context.
- * \return A cmix_error
+ * \return The group element array size
  */
 size_t get_group_element_array_size(struct CMixContext const* ctx);
 
 /*!
+ * \brief get_message_size How large a message can be.
+ * \param ctx The relevant context
+ * \return  The message size
+ */
+size_t get_message_size(struct CMixContext const* ctx);
+
+/*!
  * \brief encrypt_r Encrypts r with the network key
  * \param ctx The relevant context.
  * \param random_buffer An array of buffers for storing the random component of the elgamal encryption.
@@ -322,6 +329,15 @@ enum cmix_error decrypt_epirs(struct CMixContext const* ctx, char** out_buffer,
 enum cmix_error remove_pirs(struct CMixContext const* ctx, char** out_buffer, const char** pirs);
 
 /*!
+ * \brief element_to_message
+ * \param ctx
+ * \param buffer
+ * \param el
+ * \return 
+ */
+enum cmix_error element_to_message(struct CMixContext const* ctx, unsigned char** buffer, char const* el);
+
+/*!
  * \brief split_message Splits a message in its destination and payload components.
  * \param ctx The relevant context.
  * \param dest_buffer pointer to a char* storage that will be initialized by this function.
diff --git a/node/node.cpp b/node/node.cpp
index 2407138..cb25431 100644
--- a/node/node.cpp
+++ b/node/node.cpp
@@ -51,7 +51,7 @@ void Node::run() {
 	io_service.run();
 }
 
-void Node::accept_handler(std::unique_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>&& socket, std::shared_ptr<boost::asio::ssl::context> ctx)
+void Node::accept_handler(std::unique_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>&& socket, std::shared_ptr<boost::asio::ssl::context>)
 {
 	Purgatory::iterator it = purgatory.emplace(purgatory.end(), std::move(socket));
 	purgatory.back().on_done(
diff --git a/node/node_client.cpp b/node/node_client.cpp
index baf4251..dde0c56 100644
--- a/node/node_client.cpp
+++ b/node/node_client.cpp
@@ -53,7 +53,7 @@ void Node::handle_client_message(ClientConnections::key_type handle, cmix_proto:
 			BOOST_LOG_TRIVIAL(error) << "handle_client_message: CMixMessage contains unknown contents.";
 		}
 	}
-	clients.at(handle).async_receive([this, handle](cmix_proto::CMixMessage message){
-		handle_client_message(handle, message);
+	clients.at(handle).async_receive([this, handle](cmix_proto::CMixMessage message2){
+		handle_client_message(handle, message2);
 	});
 }
\ No newline at end of file
diff --git a/node/node_node.cpp b/node/node_node.cpp
index db1be1f..05ca490 100644
--- a/node/node_node.cpp
+++ b/node/node_node.cpp
@@ -177,7 +177,7 @@ void fill_realtime_post_message(CMixContext& ctx, cmix_proto::RealPost& realpost
 	
 	size_t len = get_group_element_array_size(&ctx);
 	std::vector<char*> mv(ctx.nr_participants, nullptr);
-	for(int i = 0; i < ctx.nr_participants; ++i) {
+	for(size_t i = 0; i < ctx.nr_participants; ++i) {
 		std::string* m = realpost.add_m_epirs();
 		m->resize(len);
 		mv[i] = &(*m)[0];
@@ -192,8 +192,8 @@ void fill_realtime_post_message(CMixContext& ctx, cmix_proto::RealPost& realpost
 	m->resize(get_commitment_length(&ctx));
 	
 	std::vector<const char*> mvs(ctx.nr_participants, nullptr);
-	for(int i = 0; i < ctx.nr_participants; ++i) {
-		mvs[i] = realmix.m(i).data();
+	for(size_t i = 0; i < ctx.nr_participants; ++i) {
+		mvs[i] = realmix.m(int(i)).data();
 	}
 	
 	get_pimrs_commitment(
@@ -432,12 +432,12 @@ void Node::handle_node_realpost(cmix_proto::RealPost const& realpost) {
 		fill_realtime_post_message(cmix_ctx, n_realpost, realpost);
 		
 		size_t len = get_group_element_array_size(&cmix_ctx);
-		std::vector<std::string> messages(cmix_ctx.nr_participants);
+		std::vector<std::string> message_strings(cmix_ctx.nr_participants);
 		std::vector<const char*> pirs(cmix_ctx.nr_participants, nullptr);
 		std::vector<char*> msgs(cmix_ctx.nr_participants, nullptr);
 		for(size_t i = 0; i < cmix_ctx.nr_participants; ++i) {
-			messages[i].resize(len);
-			msgs[i] = &messages[i][0];
+			message_strings[i].resize(len);
+			msgs[i] = &message_strings[i][0];
 			
 			pirs[i] = n_realpost.m_epirs(i).data();
 		}
@@ -448,23 +448,30 @@ void Node::handle_node_realpost(cmix_proto::RealPost const& realpost) {
 			pirs.data()
 		);
 		
+		//for (auto&& mes : msgs) {
+		//	std::cout << std::string(mes+32, 32) << std::endl;
+		//}
+		
 		
 		for(auto i = 0u; i < cmix_ctx.nr_participants; i++) {
 			{
 				std::stringstream ss;
-				for(auto&& c : messages[i]) {
-					ss << "\\" << std::setw(3) << std::setfill('0') << std::oct << (unsigned int) c;
+				for(int j = 32; j < 64; j++) {
+					ss << "\\" << std::setw(3) << std::setfill('0') << std::oct << (((unsigned int) msgs[i][j]) & 0xFF);
 				}
 				BOOST_LOG_TRIVIAL(trace) << ss.str();
 			}
 			
+			char* message;
+			element_to_message(&cmix_ctx, (unsigned char**) &message, msgs[i]);
+			
 			char* dest;
 			size_t dest_len;
 			
 			char* payload;
 			size_t payload_len;
 			
-			split_message(&cmix_ctx, &dest, &dest_len, &payload, &payload_len, messages[i].data());
+			split_message(&cmix_ctx, &dest, &dest_len, &payload, &payload_len, message);
 			
 			std::string dest_s = std::string(dest, dest_len);
 			
@@ -474,6 +481,7 @@ void Node::handle_node_realpost(cmix_proto::RealPost const& realpost) {
 			
 			free(dest);
 			free(payload);
+			free(message);
 		}
 		
 		if(performance) {
@@ -556,7 +564,7 @@ void Node::handle_node_message(cmix_proto::CMixMessage message)
 			BOOST_LOG_TRIVIAL(error) << "handle_node_message: CMixMessage contains unknown contents.";
 		}
 	}
-	prev_node.async_receive([this](cmix_proto::CMixMessage message) {
-		handle_node_message(message);
+	prev_node.async_receive([this](cmix_proto::CMixMessage message2) {
+		handle_node_message(message2);
 	});
 }
\ No newline at end of file
diff --git a/run.sh b/run.sh
index bf73f04..687c802 100755
--- a/run.sh
+++ b/run.sh
@@ -1,13 +1,15 @@
 #!/bin/bash
 
-build_dir=/home/dennis/projects/cmix/build-cmix-Desktop-Default
+build_dir=/home/dennis/projects/cmix/build-cmix-Desktop-Debug
 if [ $# == 0 ] ; then
 	tool=""
 elif [ $1 == "benchmark" ] ; then
 	tool="valgrind --tool=cachegrind"
 elif [ $1 == "valgrind" ] ; then
 	tool="valgrind --leak-check=yes --track-origins=yes"
-else 
+elif [ $1 == "gdb" ] ; then
+	tool="gdb -ex run --args"
+else
 	tool=""
 fi
 
@@ -18,15 +20,12 @@ tmux send-keys -t cmix:0 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool
 
 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 5 -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:0 "r" 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:1 "r" 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:2 "r" Enter
 
 tmux new-window -t cmix:4
 tmux send-keys -t cmix:4 "cd ${build_dir} && LSAN_OPTIONS=report_objects=1 $tool client/client --certdir ../certs -n node1.local:9200 node2.local:9201 node3.local:9202" Enter
diff --git a/scratchpad/scratchpad.c b/scratchpad/scratchpad.c
index 4e7f007..ba7cca9 100644
--- a/scratchpad/scratchpad.c
+++ b/scratchpad/scratchpad.c
@@ -9,34 +9,15 @@
 #include <string.h>
 #include <stddef.h>
 
+void crypto_add_sub_scratch();
 void crypto_api_scratch();
 void gcrypt_scratch();
 
 int main(int argc, char* argv[]) {
-	if (!gcry_check_version (GCRYPT_VERSION)) {
-		fprintf(stderr, "libgcrypt version mismatch\n");
-		exit(-1);
-	}
-
-	gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
-	gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
-	gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
-	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
-	
-	size_t parse_error_offset;
-	gcry_error_t error;
-	
-	char bytes[] = "a";
-	gcry_mpi_t x;// = gcry_mpi_snew(0);
-	error = gcry_mpi_scan(&x, GCRYMPI_FMT_USG, bytes, 1, &parse_error_offset);
-	
-	gcry_mpi_release(x);
+	(void) argc;
+	(void) argv;
 	
-	if(error) {
-		return -1;
-	}
-	
-	return 0;
+	crypto_add_sub_scratch();
 }
 
 void check(gcry_error_t error) {
@@ -121,6 +102,64 @@ void gcrypt_scratch() {
 	gcry_sexp_release(plain_sexpr);
 }
 
+void crypto_add_sub_scratch() {
+	struct Api api = get_implementation();
+	
+	gcry_ctx_t ctx;
+	gcry_error_t error = gcry_mpi_ec_new(&ctx, NULL, "Ed25519");
+	
+	GroupElement rel1 = api.get_group_element(false);
+	GroupElement rel2 = api.get_group_element(false);
+	
+	gcry_mpi_point_t red_add_raw = gcry_mpi_point_new(0);
+	gcry_mpi_ec_add(red_add_raw, rel1, rel2, ctx);
+	
+	GroupElement rel_add = api.combine(rel1, rel2, false);
+	GroupElement rel_sub = api.uncombine(rel_add, rel2, false);
+	
+	gcry_mpi_t xaddraw = gcry_mpi_new(0);
+	gcry_mpi_t yaddraw = gcry_mpi_new(0);
+	
+	gcry_mpi_ec_get_affine(xaddraw, yaddraw, red_add_raw, ctx);
+	
+	gcry_mpi_dump(xaddraw);
+	printf("\n");
+	gcry_mpi_dump(yaddraw);
+	printf("\n");
+	
+	gcry_mpi_t xaddapi = gcry_mpi_new(0);
+	gcry_mpi_t yaddapi = gcry_mpi_new(0);
+	
+	gcry_mpi_ec_get_affine(xaddapi, yaddapi, rel_add, ctx);
+	
+	gcry_mpi_dump(xaddapi);
+	printf("\n");
+	gcry_mpi_dump(yaddapi);
+	printf("\n");
+	
+	
+	gcry_mpi_t x1 = gcry_mpi_new(0);
+	gcry_mpi_t y1 = gcry_mpi_new(0);
+	
+	gcry_mpi_ec_get_affine(x1, y1, rel1, ctx);
+
+	gcry_mpi_dump(x1);
+	printf("\n");
+	gcry_mpi_dump(y1);
+	printf("\n");
+	
+	gcry_mpi_t x2 = gcry_mpi_new(0);
+	gcry_mpi_t y2 = gcry_mpi_new(0);
+	
+	gcry_mpi_ec_get_affine(x2, y2, rel_sub, ctx);
+	
+	gcry_mpi_dump(x2);
+	printf("\n");
+	gcry_mpi_dump(y2);
+	printf("\n");
+	
+}
+
 void crypto_api_scratch() {
 /*	struct Api api = get_implementation();
 
diff --git a/statsd/stats.cpp b/statsd/stats.cpp
index cd66193..e2a6a5d 100644
--- a/statsd/stats.cpp
+++ b/statsd/stats.cpp
@@ -65,7 +65,7 @@ void Stats::output(std::string file)
 			ofs << it->first;
 		}
 		ofs << std::endl;
-		for(int i = 0; i < table.second.begin()->second.size(); ++i) {
+		for(size_t i = 0; i < table.second.begin()->second.size(); ++i) {
 			for(auto it = table.second.begin(); it != table.second.end(); ++it) {
 				if(it != table.second.begin()) {
 					ofs << ", ";