update travis-ci stuff (#1006)

* enable osx in travis config
* fix brew commands, change comiler
* disable clang build with make on linux
* update README
* tabulation fix in Crypto.cpp

.travis.yml

@@ -2,34 +2,53 @@ language: cpp
 cache:
   apt: true
 os:
-  - linux
+- linux
-sudo: required
+- osx
 dist: trusty
+sudo: required
+compiler:
+- g++
+- clang++
+env:
+  global:
+  - MAKEFLAGS="-j 2"
+  matrix:
+  - BUILD_TYPE=make UPNP=ON MAKE_UPNP=yes
+  - BUILD_TYPE=make UPNP=OFF MAKE_UPNP=no
+  - BUILD_TYPE=cmake UPNP=ON MAKE_UPNP=yes
+  - BUILD_TYPE=cmake UPNP=OFF MAKE_UPNP=no
+matrix:
+  exclude:
+  - os: osx
+    env: BUILD_TYPE=cmake UPNP=ON MAKE_UPNP=yes
+  - os: osx
+    env: BUILD_TYPE=cmake UPNP=OFF MAKE_UPNP=no
+  - os: linux
+    compiler: clang++
+    env: BUILD_TYPE=make UPNP=ON MAKE_UPNP=yes
+  - os: linux
+    compiler: clang++
+    env: BUILD_TYPE=make UPNP=OFF MAKE_UPNP=no
 addons:
   apt:
     packages:
-      - build-essential
+    - build-essential
-      - cmake
+    - cmake
-      - g++
+    - g++
-      - clang
+    - clang
-      - libboost-chrono-dev
+    - libboost-chrono-dev
-      - libboost-date-time-dev
+    - libboost-date-time-dev
-      - libboost-filesystem-dev
+    - libboost-filesystem-dev
-      - libboost-program-options-dev
+    - libboost-program-options-dev
-      - libboost-system-dev
+    - libboost-system-dev
-      - libboost-thread-dev
+    - libboost-thread-dev
-      - libminiupnpc-dev
+    - libminiupnpc-dev
-      - libssl-dev
+    - libssl-dev
-compiler:
-  - gcc
-  - clang
 before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi
+- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install openssl miniupnpc ; fi
+- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libressl miniupnpc ; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew unlink boost openssl && brew link boost openssl -f ; fi
+- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew outdated boost || brew upgrade boost ; fi
-env:
-  matrix:
-    - BUILD_TYPE=Release UPNP=ON
-    - BUILD_TYPE=Release UPNP=OFF
 script:
-  - cd build && cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DWITH_UPNP=${UPNP} && make
+- if [[ "$TRAVIS_OS_NAME" == "linux" && "$BUILD_TYPE" == "cmake" ]]; then cd build && cmake -DCMAKE_BUILD_TYPE=Release -DWITH_UPNP=${UPNP} && make ; fi
+- if [[ "$TRAVIS_OS_NAME" == "linux" && "$BUILD_TYPE" == "make" ]]; then make USE_UPNP=${MAKE_UPNP} ; fi
+- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then make HOMEBREW=1 USE_UPNP=${MAKE_UPNP} ; fi

Makefile.homebrew

@@ -3,27 +3,30 @@ BREWROOT = /usr/local
 BOOSTROOT = ${BREWROOT}/opt/boost
 SSLROOT = ${BREWROOT}/opt/libressl
 UPNPROOT = ${BREWROOT}/opt/miniupnpc
-CXX = clang++
 CXXFLAGS = -g -Wall -std=c++11 -DMAC_OSX -Wno-overloaded-virtual
 INCFLAGS = -I${SSLROOT}/include -I${BOOSTROOT}/include 
 
+ifndef TRAVIS
+	CXX = clang++
+endif
+
 ifeq ($(USE_STATIC),yes)
-LDLIBS = -lz ${SSLROOT}/lib/libcrypto.a ${SSLROOT}/lib/libssl.a ${BOOSTROOT}/lib/libboost_system.a ${BOOSTROOT}/lib/libboost_date_time.a ${BOOSTROOT}/lib/libboost_filesystem.a ${BOOSTROOT}/lib/libboost_program_options.a -lpthread
+	LDLIBS = -lz ${SSLROOT}/lib/libcrypto.a ${SSLROOT}/lib/libssl.a ${BOOSTROOT}/lib/libboost_system.a ${BOOSTROOT}/lib/libboost_date_time.a ${BOOSTROOT}/lib/libboost_filesystem.a ${BOOSTROOT}/lib/libboost_program_options.a -lpthread
 else
-LDFLAGS = -L${SSLROOT}/lib -L${BOOSTROOT}/lib
+	LDFLAGS = -L${SSLROOT}/lib -L${BOOSTROOT}/lib
-LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
+	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
 endif
 
 ifeq ($(USE_UPNP),yes)
 	LDFLAGS += -ldl
 	CXXFLAGS += -DUSE_UPNP
-  INCFLAGS += -I${UPNPROOT}/include
+	INCFLAGS += -I${UPNPROOT}/include
-  ifeq ($(USE_STATIC),yes)
+	ifeq ($(USE_STATIC),yes)
-    LDLIBS += ${UPNPROOT}/lib/libminiupnpc.a
+		LDLIBS += ${UPNPROOT}/lib/libminiupnpc.a
-  else
+	else
-    LDFLAGS += -L${UPNPROOT}/lib
+		LDFLAGS += -L${UPNPROOT}/lib
-    LDLIBS += -lminiupnpc
+		LDLIBS += -lminiupnpc
-  endif  
+	endif
 endif
 
 # OSX Notes

Makefile.osx

@@ -5,29 +5,29 @@ INCFLAGS = -I/usr/local/include
 LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib
 
 ifeq ($(USE_STATIC),yes)
-LDLIBS = -lz /usr/local/lib/libcrypto.a /usr/local/lib/libssl.a /usr/local/lib/libboost_system.a /usr/local/lib/libboost_date_time.a /usr/local/lib/libboost_filesystem.a /usr/local/lib/libboost_program_options.a -lpthread
+	LDLIBS = -lz /usr/local/lib/libcrypto.a /usr/local/lib/libssl.a /usr/local/lib/libboost_system.a /usr/local/lib/libboost_date_time.a /usr/local/lib/libboost_filesystem.a /usr/local/lib/libboost_program_options.a -lpthread
 else
-LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
+	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
 endif
 
 ifeq ($(USE_UPNP),yes)
-  LDFLAGS += -ldl
+	LDFLAGS += -ldl
-  CXXFLAGS += -DUSE_UPNP
+	CXXFLAGS += -DUSE_UPNP
-ifeq ($(USE_STATIC),yes)
+	ifeq ($(USE_STATIC),yes)
-  LDLIBS += /usr/local/lib/libminiupnpc.a
+		LDLIBS += /usr/local/lib/libminiupnpc.a
-else
+	else
-  LDLIBS += -lminiupnpc
+		LDLIBS += -lminiupnpc
-endif
+	endif
 endif
 
 ifeq ($(USE_AESNI),1)
-  CXXFLAGS += -maes -DAESNI
+	CXXFLAGS += -maes -DAESNI
 else
-  CXXFLAGS += -msse
+	CXXFLAGS += -msse
 endif
 
 ifeq ($(USE_AVX),1)
-  CXXFLAGS += -mavx
+	CXXFLAGS += -mavx
 endif
 
 # Disabled, since it will be the default make rule. I think its better

README.md

@@ -54,9 +54,9 @@ Build instructions:
 
 **Supported systems:**
 
-* GNU/Linux x86/x64  - [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)  
+* GNU/Linux x86/x64		- [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
-* Windows        - [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)  
+* Windows				- [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)
-* Mac OS X
+* Mac OS X				- [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
 * FreeBSD
 * Android 
 * iOS

libi2pd/Crypto.cpp

@@ -14,20 +14,20 @@
 namespace i2p
 {
 namespace crypto
-{	
+{
 	const uint8_t elgp_[256]=
 	{
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34, 
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
-		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 
+		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
 		0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
 		0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
 		0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45, 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
  		0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
 		0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
-		0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D, 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 
+		0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D, 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05,
 		0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
 		0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
-		0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D, 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 
+		0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D, 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04,
 		0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
 		0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F,
 		0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9, 0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18,
@@ -36,7 +36,7 @@ namespace crypto
 	};
 
 	const int elgg_ = 2;
-	
+
 	const uint8_t dsap_[128]=
 	{
 		0x9c, 0x05, 0xb2, 0xaa, 0x96, 0x0d, 0x9b, 0x97, 0xb8, 0x93, 0x19, 0x63, 0xc9, 0xcc, 0x9e, 0x8c,
@@ -45,7 +45,7 @@ namespace crypto
 		0x76, 0x55, 0xc4, 0x96, 0x4a, 0xfa, 0xa2, 0xb3, 0x37, 0xe9, 0x6a, 0xd3, 0x16, 0xb9, 0xfb, 0x1c,
 		0xc5, 0x64, 0xb5, 0xae, 0xc5, 0xb6, 0x9a, 0x9f, 0xf6, 0xc3, 0xe4, 0x54, 0x87, 0x07, 0xfe, 0xf8,
 		0x50, 0x3d, 0x91, 0xdd, 0x86, 0x02, 0xe8, 0x67, 0xe6, 0xd3, 0x5d, 0x22, 0x35, 0xc1, 0x86, 0x9c,
-		0xe2, 0x47, 0x9c, 0x3b, 0x9d, 0x54, 0x01, 0xde, 0x04, 0xe0, 0x72, 0x7f, 0xb3, 0x3d, 0x65, 0x11, 
+		0xe2, 0x47, 0x9c, 0x3b, 0x9d, 0x54, 0x01, 0xde, 0x04, 0xe0, 0x72, 0x7f, 0xb3, 0x3d, 0x65, 0x11,
 		0x28, 0x5d, 0x4c, 0xf2, 0x95, 0x38, 0xd9, 0xe3, 0xb6, 0x05, 0x1f, 0x5b, 0x22, 0xcc, 0x1c, 0x93
 	};
 
@@ -63,27 +63,27 @@ namespace crypto
 		0x3c, 0x43, 0x1f, 0x46, 0x98, 0x59, 0x9d, 0xda, 0x02, 0x45, 0x18, 0x24, 0xff, 0x36, 0x97, 0x52,
 		0x59, 0x36, 0x47, 0xcc, 0x3d, 0xdc, 0x19, 0x7d, 0xe9, 0x85, 0xe4, 0x3d, 0x13, 0x6c, 0xdc, 0xfc,
 		0x6b, 0xd5, 0x40, 0x9c, 0xd2, 0xf4, 0x50, 0x82, 0x11, 0x42, 0xa5, 0xe6, 0xf8, 0xeb, 0x1c, 0x3a,
-		0xb5, 0xd0, 0x48, 0x4b, 0x81, 0x29, 0xfc, 0xf1, 0x7b, 0xce, 0x4f, 0x7f, 0x33, 0x32, 0x1c, 0x3c, 
+		0xb5, 0xd0, 0x48, 0x4b, 0x81, 0x29, 0xfc, 0xf1, 0x7b, 0xce, 0x4f, 0x7f, 0x33, 0x32, 0x1c, 0x3c,
-		0xb3, 0xdb, 0xb1, 0x4a, 0x90, 0x5e, 0x7b, 0x2b, 0x3e, 0x93, 0xbe, 0x47, 0x08, 0xcb, 0xcc, 0x82  
+		0xb3, 0xdb, 0xb1, 0x4a, 0x90, 0x5e, 0x7b, 0x2b, 0x3e, 0x93, 0xbe, 0x47, 0x08, 0xcb, 0xcc, 0x82
 	};
 
-	const int rsae_ = 65537;	
+	const int rsae_ = 65537;
-	
+
 	struct CryptoConstants
 	{
 		// DH/ElGamal
 		BIGNUM * elgp;
-		BIGNUM * elgg; 
+		BIGNUM * elgg;
 
 		// DSA
-		BIGNUM * dsap;		
+		BIGNUM * dsap;
 		BIGNUM * dsaq;
 		BIGNUM * dsag;
 
 		// RSA
 		BIGNUM * rsae;
-		
+
-		CryptoConstants (const uint8_t * elgp_, int elgg_, const uint8_t * dsap_, 
+		CryptoConstants (const uint8_t * elgp_, int elgg_, const uint8_t * dsap_,
 			const uint8_t * dsaq_, const uint8_t * dsag_, int rsae_)
 		{
 			elgp = BN_new ();
@@ -99,18 +99,18 @@ namespace crypto
 			rsae = BN_new ();
 			BN_set_word (rsae, rsae_);
 		}
-		
+
 		~CryptoConstants ()
 		{
 			BN_free (elgp);  BN_free (elgg); BN_free (dsap); BN_free (dsaq); BN_free (dsag); BN_free (rsae);
-		}	
+		}
-	};	
+	};
 
 	static const CryptoConstants& GetCryptoConstants ()
 	{
-		static CryptoConstants cryptoConstants (elgp_, elgg_, dsap_, dsaq_, dsag_, rsae_);		                                        
+		static CryptoConstants cryptoConstants (elgp_, elgg_, dsap_, dsaq_, dsag_, rsae_);
 		return cryptoConstants;
-	}	
+	}
 
 	bool bn2buf (const BIGNUM * bn, uint8_t * buf, size_t len)
 	{
@@ -119,34 +119,34 @@ namespace crypto
 		BN_bn2bin (bn, buf + offset);
 		memset (buf, 0, offset);
 		return true;
-	}	
+	}
 
 // RSA
-	#define rsae GetCryptoConstants ().rsae		
+	#define rsae GetCryptoConstants ().rsae
 	const BIGNUM * GetRSAE ()
 	{
 		return rsae;
-	}	
+	}
 
 // DSA
-	#define dsap GetCryptoConstants ().dsap	
+	#define dsap GetCryptoConstants ().dsap
 	#define dsaq GetCryptoConstants ().dsaq
-	#define dsag GetCryptoConstants ().dsag	
+	#define dsag GetCryptoConstants ().dsag
 	DSA * CreateDSA ()
 	{
 		DSA * dsa = DSA_new ();
-		DSA_set0_pqg (dsa, BN_dup (dsap), BN_dup (dsaq), BN_dup (dsag));	
+		DSA_set0_pqg (dsa, BN_dup (dsap), BN_dup (dsaq), BN_dup (dsag));
 		DSA_set0_key (dsa, NULL, NULL);
 		return dsa;
 	}
 
-// DH/ElGamal	
+// DH/ElGamal
 
 	const int ELGAMAL_SHORT_EXPONENT_NUM_BITS = 226;
 	const int ELGAMAL_SHORT_EXPONENT_NUM_BYTES = ELGAMAL_SHORT_EXPONENT_NUM_BITS/8+1;
 	const int ELGAMAL_FULL_EXPONENT_NUM_BITS = 2048;
 	const int ELGAMAL_FULL_EXPONENT_NUM_BYTES = ELGAMAL_FULL_EXPONENT_NUM_BITS/8;
-	
+
 	#define elgp GetCryptoConstants ().elgp
 	#define elgg GetCryptoConstants ().elgg
 
@@ -156,14 +156,14 @@ namespace crypto
 		if (len <= 0) return;
 		BN_CTX * ctx = BN_CTX_new ();
 		g_MontCtx = BN_MONT_CTX_new ();
-		BN_MONT_CTX_set (g_MontCtx, elgp, ctx);		
+		BN_MONT_CTX_set (g_MontCtx, elgp, ctx);
 		auto montCtx = BN_MONT_CTX_new ();
 		BN_MONT_CTX_copy (montCtx, g_MontCtx);
 		for (int i = 0; i < len; i++)
 		{
 			table[i][0] = BN_new ();
-			if (!i) 	
+			if (!i)
-				BN_to_montgomery (table[0][0], elgg, montCtx, ctx); 	
+				BN_to_montgomery (table[0][0], elgg, montCtx, ctx);
 			else
 				BN_mod_mul_montgomery (table[i][0], table[i-1][254], table[i-1][0], montCtx, ctx);
 			for (int j = 1; j < 255; j++)
@@ -174,7 +174,7 @@ namespace crypto
 		}
 		BN_MONT_CTX_free (montCtx);
 		BN_CTX_free (ctx);
-	}	 
+	}
 
 	static void DestroyElggTable (BIGNUM * table[][255], int len)
 	{
@@ -186,9 +186,9 @@ namespace crypto
 			}
 		BN_MONT_CTX_free (g_MontCtx);
 	}
-	
+
 	static BIGNUM * ElggPow (const uint8_t * exp, int len, BIGNUM * table[][255], BN_CTX * ctx)
-	// exp is in Big Endian	
+	// exp is in Big Endian
 	{
 		if (len <= 0) return nullptr;
 		auto montCtx = BN_MONT_CTX_new ();
@@ -200,15 +200,15 @@ namespace crypto
 			{
 				if (exp[i])
 					BN_mod_mul_montgomery (res, res, table[len-1-i][exp[i]-1], montCtx, ctx);
-			}	
+			}
-			else if (exp[i]) 
+			else if (exp[i])
 				res = BN_dup (table[len-i-1][exp[i]-1]);
-		}	
+		}
 		if (res)
 			BN_from_montgomery (res, res, montCtx, ctx);
 		BN_MONT_CTX_free (montCtx);
 		return res;
-	}	
+	}
 
 	static BIGNUM * ElggPow (const BIGNUM * exp, BIGNUM * table[][255], BN_CTX * ctx)
 	{
@@ -218,64 +218,64 @@ namespace crypto
 		auto ret = ElggPow (buf, len, table, ctx);
 		delete[] buf;
 		return ret;
-	}	
+	}
+
+	static BIGNUM * (* g_ElggTable)[255] = nullptr;
 
-	static BIGNUM * (* g_ElggTable)[255] = nullptr; 
-	
 // DH
-	
+
 	DHKeys::DHKeys ()
 	{
 		m_DH = DH_new ();
 		DH_set0_pqg (m_DH, BN_dup (elgp), NULL, BN_dup (elgg));
 		DH_set0_key (m_DH, NULL, NULL);
 	}
-	
+
 	DHKeys::~DHKeys ()
 	{
 		DH_free (m_DH);
-	}	
+	}
 
 	void DHKeys::GenerateKeys ()
 	{
-		BIGNUM * priv_key = NULL, * pub_key = NULL;	
+		BIGNUM * priv_key = NULL, * pub_key = NULL;
-#if !defined(__x86_64__) // use short exponent for non x64 
+#if !defined(__x86_64__) // use short exponent for non x64
 		priv_key = BN_new ();
 		BN_rand (priv_key, ELGAMAL_SHORT_EXPONENT_NUM_BITS, 0, 1);
-#endif		
+#endif
 		if (g_ElggTable)
-		{	
+		{
 #if defined(__x86_64__)
 			priv_key = BN_new ();
 			BN_rand (priv_key, ELGAMAL_FULL_EXPONENT_NUM_BITS, 0, 1);
-#endif			
+#endif
 			auto ctx = BN_CTX_new ();
 			pub_key = ElggPow (priv_key, g_ElggTable, ctx);
 			DH_set0_key (m_DH, pub_key, priv_key);
 			BN_CTX_free (ctx);
-		}	
+		}
 		else
 		{
 			DH_set0_key (m_DH, NULL, priv_key);
 			DH_generate_key (m_DH);
 			DH_get0_key (m_DH, (const BIGNUM **)&pub_key, (const BIGNUM **)&priv_key);
-		}	
+		}
 
 		bn2buf (pub_key, m_PublicKey, 256);
-	}	
+	}
-	
+
 	void DHKeys::Agree (const uint8_t * pub, uint8_t * shared)
 	{
 		BIGNUM * pk = BN_bin2bn (pub, 256, NULL);
 		DH_compute_key (shared, pk, m_DH);
 		BN_free (pk);
-	}	
+	}
-	
+
 // ElGamal
 	void ElGamalEncrypt (const uint8_t * key, const uint8_t * data, uint8_t * encrypted, BN_CTX * ctx, bool zeroPadding)
 	{
 		BN_CTX_start (ctx);
-		// everything, but a, because a might come from table	
+		// everything, but a, because a might come from table
 		BIGNUM * k = BN_CTX_get (ctx);
 		BIGNUM * y = BN_CTX_get (ctx);
 		BIGNUM * b1 = BN_CTX_get (ctx);
@@ -285,13 +285,13 @@ namespace crypto
 		BN_rand (k, ELGAMAL_FULL_EXPONENT_NUM_BITS, -1, 1); // full exponent for x64
 #else
 		BN_rand (k, ELGAMAL_SHORT_EXPONENT_NUM_BITS, -1, 1); // short exponent of 226 bits
-#endif		
+#endif
 		// calculate a
-		BIGNUM * a;	
+		BIGNUM * a;
 		if (g_ElggTable)
 			a = ElggPow (k, g_ElggTable, ctx);
 		else
-		{	
+		{
 			a = BN_new ();
 			BN_mod_exp (a, elgg, k, elgp, ctx);
 		}
@@ -315,17 +315,17 @@ namespace crypto
 			bn2buf (a, encrypted + 1, 256);
 			encrypted[257] = 0;
 			bn2buf (b, encrypted + 258, 256);
-		}	
+		}
 		else
 		{
 			bn2buf (a, encrypted, 256);
 			bn2buf (b, encrypted + 256, 256);
-		}		
+		}
 		BN_free (a);
 		BN_CTX_end (ctx);
 	}
 
-	bool ElGamalDecrypt (const uint8_t * key, const uint8_t * encrypted, 
+	bool ElGamalDecrypt (const uint8_t * key, const uint8_t * encrypted,
 		uint8_t * data, BN_CTX * ctx, bool zeroPadding)
 	{
 		BN_CTX_start (ctx);
@@ -334,11 +334,11 @@ namespace crypto
 		BN_sub (x, elgp, x); BN_sub_word (x, 1); // x = elgp - x- 1
 		BN_bin2bn (zeroPadding ? encrypted + 1 : encrypted, 256, a);
 		BN_bin2bn (zeroPadding ? encrypted + 258 : encrypted + 256, 256, b);
-		// m = b*(a^x mod p) mod p		
+		// m = b*(a^x mod p) mod p
 		BN_mod_exp (x, a, x, elgp, ctx);
-		BN_mod_mul (b, b, x, elgp, ctx);	
+		BN_mod_mul (b, b, x, elgp, ctx);
 		uint8_t m[255];
-		bn2buf (b, m, 255); 
+		bn2buf (b, m, 255);
 		BN_CTX_end (ctx);
 		uint8_t hash[32];
 		SHA256 (m + 33, 222, hash);
@@ -346,14 +346,14 @@ namespace crypto
 		{
 			LogPrint (eLogError, "ElGamal decrypt hash doesn't match");
 			return false;
-		}	
+		}
 		memcpy (data, m + 33, 222);
 		return true;
-	}	
+	}
 
 	void GenerateElGamalKeyPair (uint8_t * priv, uint8_t * pub)
 	{
-#if defined(__x86_64__) || defined(__i386__) || defined(_MSC_VER)	
+#if defined(__x86_64__) || defined(__i386__) || defined(_MSC_VER)
 		RAND_bytes (priv, 256);
 #else
 		// lower 226 bits (28 bytes and 2 bits) only. short exponent
@@ -364,10 +364,10 @@ namespace crypto
 		priv[numZeroBytes] &= 0x03;
 #endif
 		BN_CTX * ctx = BN_CTX_new ();
-		BIGNUM * p = BN_new ();	
+		BIGNUM * p = BN_new ();
 		BN_bin2bn (priv, 256, p);
 		BN_mod_exp (p, elgg, p, elgp, ctx);
-		bn2buf (p, pub, 256); 
+		bn2buf (p, pub, 256);
 		BN_free (p);
 		BN_CTX_free (ctx);
 	}
@@ -385,15 +385,15 @@ namespace crypto
 		auto p = EC_POINT_new (curve);
 		EC_POINT_mul (curve, p, k, nullptr, nullptr, ctx);
 		BIGNUM * x = BN_CTX_get (ctx), * y = BN_CTX_get (ctx);
-		EC_POINT_get_affine_coordinates_GFp (curve, p, x, y, nullptr);	
+		EC_POINT_get_affine_coordinates_GFp (curve, p, x, y, nullptr);
 		encrypted[0] = 0;
 		bn2buf (x, encrypted + 1, len);
 		bn2buf (y, encrypted + 1 + len, len);
 		RAND_bytes (encrypted + 1 + 2*len, 256 - 2*len);
 		// ecryption key and iv
-		EC_POINT_mul (curve, p, nullptr, key, k, ctx); 
+		EC_POINT_mul (curve, p, nullptr, key, k, ctx);
 		EC_POINT_get_affine_coordinates_GFp (curve, p, x, y, nullptr);
-		uint8_t keyBuf[64], iv[64], shared[32]; 
+		uint8_t keyBuf[64], iv[64], shared[32];
 		bn2buf (x, keyBuf, len);
 		bn2buf (y, iv, len);
 		SHA256 (keyBuf, len, shared);
@@ -421,16 +421,16 @@ namespace crypto
 		int len = BN_num_bytes (q);
 		// point for shared secret
 		BIGNUM * x = BN_CTX_get (ctx), * y = BN_CTX_get (ctx);
-		BN_bin2bn (encrypted + 1, len, x);		
+		BN_bin2bn (encrypted + 1, len, x);
-		BN_bin2bn (encrypted + 1 + len, len, y);	
+		BN_bin2bn (encrypted + 1 + len, len, y);
 		auto p = EC_POINT_new (curve);
 		if (EC_POINT_set_affine_coordinates_GFp (curve, p, x, y, nullptr))
 		{
 			auto s = EC_POINT_new (curve);
-			EC_POINT_mul (curve, s, nullptr, p, key, ctx); 
+			EC_POINT_mul (curve, s, nullptr, p, key, ctx);
 			EC_POINT_get_affine_coordinates_GFp (curve, s, x, y, nullptr);
 			EC_POINT_free (s);
-			uint8_t keyBuf[64], iv[64], shared[32]; 
+			uint8_t keyBuf[64], iv[64], shared[32];
 			bn2buf (x, keyBuf, len);
 			bn2buf (y, iv, len);
 			SHA256 (keyBuf, len, shared);
@@ -442,21 +442,21 @@ namespace crypto
 			decryption.Decrypt (encrypted + 258, 256, m);
 			// verify and copy
 			uint8_t hash[32];
-			SHA256 (m + 33, 222, hash);		
+			SHA256 (m + 33, 222, hash);
 			if (!memcmp (m + 1, hash, 32))
-				memcpy (data, m + 33, 222);	
+				memcpy (data, m + 33, 222);
 			else
 			{
 				LogPrint (eLogError, "ECIES decrypt hash doesn't match");
 				ret = false;
-			}	
+			}
 		}
 		else
 		{
 			LogPrint (eLogError, "ECIES decrypt point is invalid");
 			ret = false;
 		}
-		
+
 		EC_POINT_free (p);
 		BN_CTX_end (ctx);
 		return ret;
@@ -468,7 +468,7 @@ namespace crypto
 		BIGNUM * q = BN_new ();
 		EC_GROUP_get_order(curve, q, ctx);
 		priv = BN_new ();
-		BN_rand_range (priv, q); 
+		BN_rand_range (priv, q);
 		pub = EC_POINT_new (curve);
 		EC_POINT_mul (curve, pub, priv, nullptr, nullptr, ctx);
 		BN_free (q);
@@ -477,17 +477,17 @@ namespace crypto
 
 // HMAC
 	const uint64_t IPAD = 0x3636363636363636;
-	const uint64_t OPAD = 0x5C5C5C5C5C5C5C5C; 			
+	const uint64_t OPAD = 0x5C5C5C5C5C5C5C5C;
 
-#if defined(__AVX__)	
+#if defined(__AVX__)
 	static const uint64_t ipads[] = { IPAD, IPAD, IPAD, IPAD };
 	static const uint64_t opads[] = { OPAD, OPAD, OPAD, OPAD };
 #endif
-	
+
 	void HMACMD5Digest (uint8_t * msg, size_t len, const MACKey& key, uint8_t * digest)
 	// key is 32 bytes
 	// digest is 16 bytes
-	// block size is 64 bytes	
+	// block size is 64 bytes
 	{
 		uint64_t buf[256];
 		uint64_t hash[12]; // 96 bytes
@@ -498,53 +498,53 @@ namespace crypto
 			"vmovups %[ipad], %%ymm1 \n"
 			"vmovups %%ymm1, 32(%[buf]) \n"
 			"vxorps %%ymm0, %%ymm1, %%ymm1 \n"
-			"vmovups %%ymm1, (%[buf]) \n"			
+			"vmovups %%ymm1, (%[buf]) \n"
 			"vmovups %[opad], %%ymm1 \n"
-			"vmovups %%ymm1, 32(%[hash]) \n"	
+			"vmovups %%ymm1, 32(%[hash]) \n"
 			"vxorps %%ymm0, %%ymm1, %%ymm1 \n"
 			"vmovups %%ymm1, (%[hash]) \n"
 			"vzeroall \n" // end of AVX
-		    "movups %%xmm0, 80(%[hash]) \n" // zero last 16 bytes
+			"movups %%xmm0, 80(%[hash]) \n" // zero last 16 bytes
-			: 
+			:
 			: [key]"m"(*(const uint8_t *)key), [ipad]"m"(*ipads), [opad]"m"(*opads),
-			  [buf]"r"(buf), [hash]"r"(hash)
+				[buf]"r"(buf), [hash]"r"(hash)
 			: "memory", "%xmm0"	// TODO: change to %ymm0 later
 		);
 #else
 		// ikeypad
-		buf[0] = key.GetLL ()[0] ^ IPAD; 
+		buf[0] = key.GetLL ()[0] ^ IPAD;
-		buf[1] = key.GetLL ()[1] ^ IPAD; 
+		buf[1] = key.GetLL ()[1] ^ IPAD;
-		buf[2] = key.GetLL ()[2] ^ IPAD; 
+		buf[2] = key.GetLL ()[2] ^ IPAD;
-		buf[3] = key.GetLL ()[3] ^ IPAD; 
+		buf[3] = key.GetLL ()[3] ^ IPAD;
 		buf[4] = IPAD;
 		buf[5] = IPAD;
 		buf[6] = IPAD;
 		buf[7] = IPAD;
-		// okeypad			
+		// okeypad
-		hash[0] = key.GetLL ()[0] ^ OPAD; 
+		hash[0] = key.GetLL ()[0] ^ OPAD;
-		hash[1] = key.GetLL ()[1] ^ OPAD; 
+		hash[1] = key.GetLL ()[1] ^ OPAD;
-		hash[2] = key.GetLL ()[2] ^ OPAD; 
+		hash[2] = key.GetLL ()[2] ^ OPAD;
-		hash[3] = key.GetLL ()[3] ^ OPAD; 
+		hash[3] = key.GetLL ()[3] ^ OPAD;
 		hash[4] = OPAD;
 		hash[5] = OPAD;
 		hash[6] = OPAD;
 		hash[7] = OPAD;
 		// fill last 16 bytes with zeros (first hash size assumed 32 bytes in I2P)
-		memset (hash + 10, 0, 16);		
+		memset (hash + 10, 0, 16);
 #endif
 
 		// concatenate with msg
 		memcpy (buf + 8, msg, len);
 		// calculate first hash
-		MD5((uint8_t *)buf, len + 64, (uint8_t *)(hash + 8));  // 16 bytes	
+		MD5((uint8_t *)buf, len + 64, (uint8_t *)(hash + 8));  // 16 bytes
-		
+
 		// calculate digest
 		MD5((uint8_t *)hash, 96, digest);
 	}
 
 // AES
 	#ifdef AESNI
-	
+
 	#define KeyExpansion256(round0,round1) \
 		"pshufd	$0xff, %%xmm2, %%xmm2 \n" \
 		"movaps	%%xmm1, %%xmm4 \n" \
@@ -566,7 +566,7 @@ namespace crypto
 		"pslldq	$4, %%xmm4 \n" \
 		"pxor %%xmm4, %%xmm3 \n" \
 		"pxor %%xmm2, %%xmm3 \n" \
-		"movaps	%%xmm3, "#round1"(%[sched]) \n" 
+		"movaps	%%xmm3, "#round1"(%[sched]) \n"
 
 	void ECBCryptoAESNI::ExpandKey (const AESKey& key)
 	{
@@ -591,7 +591,7 @@ namespace crypto
 			"aeskeygenassist $64, %%xmm3, %%xmm2 \n"
 			// key expansion final
 			"pshufd	$0xff, %%xmm2, %%xmm2 \n"
-			"movaps	%%xmm1, %%xmm4 \n" 
+			"movaps	%%xmm1, %%xmm4 \n"
 			"pslldq	$4, %%xmm4 \n"
 			"pxor %%xmm4, %%xmm1 \n"
 			"pslldq	$4, %%xmm4 \n"
@@ -622,17 +622,17 @@ namespace crypto
 		"aesenc	192(%["#sched"]), %%xmm0 \n" \
 		"aesenc	208(%["#sched"]), %%xmm0 \n" \
 		"aesenclast	224(%["#sched"]), %%xmm0 \n"
-		
+
 	void ECBEncryptionAESNI::Encrypt (const ChipherBlock * in, ChipherBlock * out)
 	{
 		__asm__
 		(
 			"movups	(%[in]), %%xmm0 \n"
 			EncryptAES256(sched)
-			"movups	%%xmm0, (%[out]) \n"	
+			"movups	%%xmm0, (%[out]) \n"
 			: : [sched]"r"(GetKeySchedule ()), [in]"r"(in), [out]"r"(out) : "%xmm0", "memory"
 		);
-	}		
+	}
 
 	#define DecryptAES256(sched) \
 		"pxor 224(%["#sched"]), %%xmm0 \n" \
@@ -650,22 +650,22 @@ namespace crypto
 		"aesdec	32(%["#sched"]), %%xmm0 \n" \
 		"aesdec	16(%["#sched"]), %%xmm0 \n" \
 		"aesdeclast (%["#sched"]), %%xmm0 \n"
-	
+
 	void ECBDecryptionAESNI::Decrypt (const ChipherBlock * in, ChipherBlock * out)
 	{
 		__asm__
 		(
 			"movups	(%[in]), %%xmm0 \n"
 			DecryptAES256(sched)
-			"movups	%%xmm0, (%[out]) \n"	
+			"movups	%%xmm0, (%[out]) \n"
 			: : [sched]"r"(GetKeySchedule ()), [in]"r"(in), [out]"r"(out) : "%xmm0", "memory"
-		);		
+		);
 	}
 
 	#define CallAESIMC(offset) \
 		"movaps "#offset"(%[shed]), %%xmm0 \n"	\
 		"aesimc %%xmm0, %%xmm0 \n" \
-		"movaps %%xmm0, "#offset"(%[shed]) \n" 
+		"movaps %%xmm0, "#offset"(%[shed]) \n"
 
 	void ECBDecryptionAESNI::SetKey (const AESKey& key)
 	{
@@ -690,7 +690,7 @@ namespace crypto
 		);
 	}
 
-#endif		
+#endif
 
 
 	void CBCEncryption::Encrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out)
@@ -698,31 +698,31 @@ namespace crypto
 #ifdef AESNI
 		__asm__
 		(
-		 	"movups	(%[iv]), %%xmm1 \n"
+			"movups	(%[iv]), %%xmm1 \n"
-		 	"1: \n"
+			"1: \n"
-		 	"movups	(%[in]), %%xmm0 \n"
+			"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
+			"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched)
+			EncryptAES256(sched)
-		 	"movaps	%%xmm0, %%xmm1 \n"	
+			"movaps	%%xmm0, %%xmm1 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
+			"movups	%%xmm0, (%[out]) \n"
-		 	"add $16, %[in] \n"
+			"add $16, %[in] \n"
-		 	"add $16, %[out] \n"
+			"add $16, %[out] \n"
-		 	"dec %[num] \n"
+			"dec %[num] \n"
-		 	"jnz 1b \n"	 	
+			"jnz 1b \n"
-		 	"movups	%%xmm1, (%[iv]) \n"
+			"movups	%%xmm1, (%[iv]) \n"
-			: 
+			:
-			: [iv]"r"((uint8_t *)m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()), 
+			: [iv]"r"((uint8_t *)m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()),
 			  [in]"r"(in), [out]"r"(out), [num]"r"(numBlocks)
 			: "%xmm0", "%xmm1", "cc", "memory"
-		); 
+		);
-#else		
+#else
 		for (int i = 0; i < numBlocks; i++)
 		{
 			*m_LastBlock.GetChipherBlock () ^= in[i];
 			m_ECBEncryption.Encrypt (m_LastBlock.GetChipherBlock (), m_LastBlock.GetChipherBlock ());
 			out[i] = *m_LastBlock.GetChipherBlock ();
 		}
-#endif		
+#endif
 	}
 
 	void CBCEncryption::Encrypt (const uint8_t * in, std::size_t len, uint8_t * out)
@@ -730,7 +730,7 @@ namespace crypto
 		// len/16
 		int numBlocks = len >> 4;
 		if (numBlocks > 0)
-			Encrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out); 
+			Encrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out);
 	}
 
 	void CBCEncryption::Encrypt (const uint8_t * in, uint8_t * out)
@@ -740,17 +740,17 @@ namespace crypto
 		(
 			"movups	(%[iv]), %%xmm1 \n"
 			"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
+			"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched)
+			EncryptAES256(sched)
 			"movups	%%xmm0, (%[out]) \n"
 			"movups	%%xmm0, (%[iv]) \n"
-			: 
+			:
-			: [iv]"r"((uint8_t *)m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()), 
+			: [iv]"r"((uint8_t *)m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()),
 			  [in]"r"(in), [out]"r"(out)
 			: "%xmm0", "%xmm1", "memory"
-		);		
+		);
 #else
-		Encrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out); 
+		Encrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out);
 #endif
 	}
 
@@ -760,23 +760,23 @@ namespace crypto
 		__asm__
 		(
 			"movups	(%[iv]), %%xmm1 \n"
-		 	"1: \n"
+			"1: \n"
-		 	"movups	(%[in]), %%xmm0 \n"
+			"movups	(%[in]), %%xmm0 \n"
 			"movaps %%xmm0, %%xmm2 \n"
-		 	DecryptAES256(sched)
+			DecryptAES256(sched)
 			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
+			"movups	%%xmm0, (%[out]) \n"
 			"movaps %%xmm2, %%xmm1 \n"
-		 	"add $16, %[in] \n"
+			"add $16, %[in] \n"
-		 	"add $16, %[out] \n"
+			"add $16, %[out] \n"
-		 	"dec %[num] \n"
+			"dec %[num] \n"
-		 	"jnz 1b \n"	 	
+			"jnz 1b \n"
-		 	"movups	%%xmm1, (%[iv]) \n"
+			"movups	%%xmm1, (%[iv]) \n"
-			: 
+			:
-			: [iv]"r"((uint8_t *)m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()), 
+			: [iv]"r"((uint8_t *)m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()),
 			  [in]"r"(in), [out]"r"(out), [num]"r"(numBlocks)
 			: "%xmm0", "%xmm1", "%xmm2", "cc", "memory"
-		); 
+		);
 #else
 		for (int i = 0; i < numBlocks; i++)
 		{
@@ -792,7 +792,7 @@ namespace crypto
 	{
 		int numBlocks = len >> 4;
 		if (numBlocks > 0)
-			Decrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out); 
+			Decrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out);
 	}
 
 	void CBCDecryption::Decrypt (const uint8_t * in, uint8_t * out)
@@ -801,18 +801,18 @@ namespace crypto
 		__asm__
 		(
 			"movups	(%[iv]), %%xmm1 \n"
-		 	"movups	(%[in]), %%xmm0 \n"
+			"movups	(%[in]), %%xmm0 \n"
 			"movups	%%xmm0, (%[iv]) \n"
-		 	DecryptAES256(sched)
+			DecryptAES256(sched)
 			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"	
+			"movups	%%xmm0, (%[out]) \n"
-			: 
+			:
-			: [iv]"r"((uint8_t *)m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()), 
+			: [iv]"r"((uint8_t *)m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()),
 			  [in]"r"(in), [out]"r"(out)
 			: "%xmm0", "%xmm1", "memory"
 		);
 #else
-		Decrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out); 
+		Decrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out);
 #endif
 	}
 
@@ -821,7 +821,7 @@ namespace crypto
 #ifdef AESNI
 		__asm__
 		(
-            // encrypt IV 
+			// encrypt IV
 			"movups	(%[in]), %%xmm0 \n"
 			EncryptAES256(sched_iv)
 			"movaps %%xmm0, %%xmm1 \n"
@@ -831,16 +831,16 @@ namespace crypto
 			// encrypt data, IV is xmm1
 			"1: \n"
 			"add $16, %[in] \n"
-		    "add $16, %[out] \n"
+			"add $16, %[out] \n"
-		 	"movups	(%[in]), %%xmm0 \n"
+			"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
+			"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched_l)
+			EncryptAES256(sched_l)
-		 	"movaps	%%xmm0, %%xmm1 \n"	
+			"movaps	%%xmm0, %%xmm1 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
+			"movups	%%xmm0, (%[out]) \n"
-		 	"dec %[num] \n"
+			"dec %[num] \n"
-		 	"jnz 1b \n"	 	
+			"jnz 1b \n"
-			: 
+			:
-			: [sched_iv]"r"(m_IVEncryption.GetKeySchedule ()), [sched_l]"r"(m_LayerEncryption.GetKeySchedule ()), 
+			: [sched_iv]"r"(m_IVEncryption.GetKeySchedule ()), [sched_l]"r"(m_LayerEncryption.GetKeySchedule ()),
 			  [in]"r"(in), [out]"r"(out), [num]"r"(63) // 63 blocks = 1008 bytes
 			: "%xmm0", "%xmm1", "cc", "memory"
 		);
@@ -857,7 +857,7 @@ namespace crypto
 #ifdef AESNI
 		__asm__
 		(
-            // decrypt IV 
+			// decrypt IV
 			"movups	(%[in]), %%xmm0 \n"
 			DecryptAES256(sched_iv)
 			"movaps %%xmm0, %%xmm1 \n"
@@ -867,27 +867,27 @@ namespace crypto
 			// decrypt data, IV is xmm1
 			"1: \n"
 			"add $16, %[in] \n"
-		    "add $16, %[out] \n"
+			"add $16, %[out] \n"
 			"movups	(%[in]), %%xmm0 \n"
 			"movaps %%xmm0, %%xmm2 \n"
-		 	DecryptAES256(sched_l)
+			DecryptAES256(sched_l)
 			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
+			"movups	%%xmm0, (%[out]) \n"
 			"movaps %%xmm2, %%xmm1 \n"
-		 	"dec %[num] \n"
+			"dec %[num] \n"
-		 	"jnz 1b \n"	 	
+			"jnz 1b \n"
-			: 
+			:
-			: [sched_iv]"r"(m_IVDecryption.GetKeySchedule ()), [sched_l]"r"(m_LayerDecryption.GetKeySchedule ()), 
+			: [sched_iv]"r"(m_IVDecryption.GetKeySchedule ()), [sched_l]"r"(m_LayerDecryption.GetKeySchedule ()),
-			  [in]"r"(in), [out]"r"(out), [num]"r"(63) // 63 blocks = 1008 bytes
+				[in]"r"(in), [out]"r"(out), [num]"r"(63) // 63 blocks = 1008 bytes
 			: "%xmm0", "%xmm1", "%xmm2", "cc", "memory"
 		);
 #else
 		m_IVDecryption.Decrypt ((const ChipherBlock *)in, (ChipherBlock *)out); // iv
-		m_LayerDecryption.SetIV (out);	
+		m_LayerDecryption.SetIV (out);
 		m_LayerDecryption.Decrypt (in + 16, i2p::tunnel::TUNNEL_DATA_ENCRYPTED_SIZE, out + 16); // data
 		m_IVDecryption.Decrypt ((ChipherBlock *)out, (ChipherBlock *)out); // double iv
 #endif
-	}	
+	}
 
 /*	std::vector <std::unique_ptr<std::mutex> >  m_OpenSSLMutexes;
 	static void OpensslLockingCallback(int mode, int type, const char * file, int line)
@@ -898,45 +898,44 @@ namespace crypto
 				m_OpenSSLMutexes[type]->lock ();
 			else
 				m_OpenSSLMutexes[type]->unlock ();
-		}	
+		}
 	}*/
-	
+
 
 	void InitCrypto (bool precomputation)
 	{
 		SSL_library_init ();
 /*		auto numLocks = CRYPTO_num_locks();
 		for (int i = 0; i < numLocks; i++)
-		     m_OpenSSLMutexes.emplace_back (new std::mutex);
+			m_OpenSSLMutexes.emplace_back (new std::mutex);
 		CRYPTO_set_locking_callback (OpensslLockingCallback);*/
 		if (precomputation)
-		{	
+		{
 #if defined(__x86_64__)
 			g_ElggTable = new BIGNUM * [ELGAMAL_FULL_EXPONENT_NUM_BYTES][255];
 			PrecalculateElggTable (g_ElggTable, ELGAMAL_FULL_EXPONENT_NUM_BYTES);
-#else			
+#else
 			g_ElggTable = new BIGNUM * [ELGAMAL_SHORT_EXPONENT_NUM_BYTES][255];
 			PrecalculateElggTable (g_ElggTable, ELGAMAL_SHORT_EXPONENT_NUM_BYTES);
-#endif		
+#endif
-		}	
+		}
 	}
-	
+
 	void TerminateCrypto ()
 	{
 		if (g_ElggTable)
-		{		
+		{
 			DestroyElggTable (g_ElggTable,
-#if defined(__x86_64__)				                  
+#if defined(__x86_64__)
 				ELGAMAL_FULL_EXPONENT_NUM_BYTES
 #else
-				ELGAMAL_SHORT_EXPONENT_NUM_BYTES	
+				ELGAMAL_SHORT_EXPONENT_NUM_BYTES
-#endif	
+#endif
-			);   
+			);
 			delete[] g_ElggTable; g_ElggTable = nullptr;
-		}	
+		}
 /*		CRYPTO_set_locking_callback (nullptr);
 		m_OpenSSLMutexes.clear ();*/
-	}	
+	}
 }
 }
-