building using mingw

Makefile

@@ -2,11 +2,25 @@ I2PD_PATH = i2pd
 LIBI2PD_PATH = $(I2PD_PATH)/libi2pd
 LIBI2PD_CLIENT_PATH = $(I2PD_PATH)/libi2pd_client
 CXX = g++
-FLAGS = -g -Wall -std=c++11 -Wno-misleading-indentation
+FLAGS = -Wall -std=c++11 -Wno-misleading-indentation
+
+ifneq ($(UNAME),Darwin && $(UNAME),Linux)
+	FLAGS += -Os -D_MT -DWIN32 -D_WINDOWS -DWIN32_LEAN_AND_MEAN
+	BOOST_SUFFIX = -mt
+else
+	FLAGS += -g
+endif
+
 INCFLAGS = -I$(LIBI2PD_PATH) -I$(LIBI2PD_CLIENT_PATH) -I$(I2PD_PATH)
-CXXFLAGS = $(FLAGS) $(INCFLAGS)
+CXXFLAGS = $(FLAGS)
 LDFLAGS = -Wl,-rpath,/usr/local/lib
-LIBS = $(I2PD_PATH)/libi2pd.a -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lssl -lcrypto -lpthread -lrt -lz
+LIBS = $(I2PD_PATH)/libi2pd.a -lboost_system$(BOOST_SUFFIX) -lboost_date_time$(BOOST_SUFFIX) -lboost_filesystem$(BOOST_SUFFIX) -lboost_program_options$(BOOST_SUFFIX) -lssl -lcrypto -lpthread -lz
+
+ifeq ($(UNAME),Darwin || $(UNAME),Linux)
+	LIBS += -lrt
+else
+	LIBS += -lws2_32 -lwsock32 -lstdc++ -liphlpapi
+endif
 
 SOURCES = $(wildcard *.cpp)
 OBJECTS = $(SOURCES:.cpp=.o)
@@ -42,7 +56,7 @@ $(I2PD_LIB):
 	$(MAKE) -C $(I2PD_PATH) mk_obj_dir $(I2PD_LIB)
 
 %.o: %.cpp libi2pd.a
-	$(CXX) -o $@ -c $(CXXFLAGS) $< $(INCFLAGS)
+	$(CXX) -o $@ -c $(CXXFLAGS) $(INCFLAGS) $<
 
 count:
 	wc *.c *.cc *.C *.cpp *.h *.hpp

vanity.hpp

@@ -5,13 +5,16 @@
 #include <openssl/rand.h>
 #include "Crypto.h"
 #include "Identity.h"
+#include "I2PEndian.h"
 #include "common/key.hpp"
 #include <thread>
 #include <unistd.h>
 #include <vector>
+
 #ifdef _WIN32
 #include <windows.h>
 #endif
+
 // sha256
 #define Ch(x, y, z)		((x & (y ^ z)) ^ z)
 #define Maj(x, y, z)	((x & (y | z)) | (y & z))

vanitygen.cpp

@@ -1,5 +1,4 @@
 #include "vanity.hpp"
-#define CPU_ONLY
 
 static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
 {
@@ -7,7 +6,7 @@ static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
 implementation of orignal
 */
 	for (int i = 0; i < 16; i++)
-		W[i] = be32toh (((uint32_t *)(block))[i]);
+		W[i] = htobe32(((uint32_t *)(block))[i]);
 	for (int i = 16; i < 64; i++)
 		W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
 }
@@ -51,29 +50,19 @@ implementation of orignal
 	TransformBlock (state, W);
 }
 
-
-
-
-static bool check_prefix(const char * buf){
-unsigned short size_str=0;
-while(*buf)
+static bool check_prefix(const char * buf)
 {
- if(
- *buf < 48 
- || 
- (*buf > 57 && *buf < 65) 
- ||
- (*buf > 64 && *buf < 94) 
- || *buf > 125
- || size_str > 52
- )return false;
-size_str++;
-buf++;
-}
-return true;
+	unsigned short size_str=0;
+	while(*buf)
+	{
+		if(*buf < 48 || (*buf > 57 && *buf < 65) || (*buf > 64 && *buf < 94) || *buf > 125 || size_str > 52)
+			return false;
+		size_str++;
+		buf++;
+	}
+	return true;
 }
 
-
 static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char * outBuf, size_t outLen)
 {
 	size_t ret = 0, pos = 1;
@@ -105,15 +94,16 @@ static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char
 	return ret;
 }
 
-static inline bool NotThat(const char * a, const char *b){
-while(*b)
- if(*a++!=*b++) return true;
-return false;
+static inline bool NotThat(const char * a, const char *b)
+{
+	while(*b)
+		if(*a++!=*b++)
+			return true;
+	return false;
 }
 
-
-#ifdef CPU_ONLY
-static inline bool thread_find(uint8_t * buf,const char * prefix,int id_thread,unsigned long long throughput){
+static inline bool thread_find(uint8_t * buf, const char * prefix, int id_thread, unsigned long long throughput)
+{
 /*
 Thanks to orignal ^-^
 For idea and example ^-^
@@ -132,16 +122,14 @@ Orignal is sensei of crypto ;)
 		uint32_t ll[8];
 	} hash;
 */
-	uint8_t * b = (uint8_t*)aligned_alloc(4,sizeof(uint8_t)*391);
-	uint32_t * hash = (uint32_t*)aligned_alloc(4,sizeof(uint32_t)*8);
+	uint8_t b[391];
+	uint32_t hash[8];
 
 	memcpy (b, buf, 391);
 
 	auto len = strlen (prefix);
 	// precalculate first 5 blocks (320 bytes)
-	uint32_t state[8] = 
-		{ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 
-		  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
+	uint32_t state[8] = { 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
 	HashNextBlock (state, b);
 	HashNextBlock (state, b + 64);
 	HashNextBlock (state, b + 128);
@@ -154,15 +142,12 @@ Orignal is sensei of crypto ;)
 
 	uint32_t * nonce = (uint32_t *)(b+320);
 	(*nonce) += id_thread*throughput;
-/*
 
-*/
 	char addr[53];
 	uint32_t state1[8];
 
-while(throughput-- and !found){
-
-
+	while(throughput-- and !found)
+	{
 		memcpy (state1, state, 32);
 		// calculate hash of block with nonce
 		HashNextBlock (state1, b + 320);
@@ -170,14 +155,11 @@ while(throughput-- and !found){
 		TransformBlock (state1, lastW);
 		// get final hash
 		for (int j = 8; j--;)
-		hash[j] = htobe32 (state1[j]);
-
-/*
-
-*/
+			hash[j] = htobe32(state1[j]);
 		ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len);
-//	std::cout << addr << std::endl;
-	if(	!NotThat(addr,prefix)	){
+		//	std::cout << addr << std::endl;
+		if(!NotThat(addr,prefix))
+		{
 			ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
 			std::cout << "Address found " << addr << " in " << id_thread << std::endl;
 			found=true;
@@ -189,18 +171,15 @@ while(throughput-- and !found){
 
 		(*nonce)++;
 		hashescounter++;
-	if (found){
+		if (found)
+		{
 			free(hash);
 			free(b);
 			break;
 		}
-
 	}//while
 }
 
-#endif
-
-
 int main (int argc, char * argv[])
 {
 	if ( argc < 3 )
@@ -208,34 +187,41 @@ int main (int argc, char * argv[])
 		std::cout << "Usage: " << argv[0] << " filename generatestring <threads(default of system)> <signature type>" << std::endl;
 		return 0;
 	}
-	if(!check_prefix(argv[2])){
+	if(!check_prefix(argv[2]))
+	{
 		std::cout << "Not correct prefix" << std::endl;
 		return 0;
 	}
 	i2p::crypto::InitCrypto (false);
 	type = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519;
-	if ( argc > 3 ){
+	if ( argc > 3 )
+	{
 		unsigned int tmp = atoi(argv[3]);
-		if(tmp > 255) {
+		if(tmp > 255)
+		{
 			std::cout << "Really more than 255 threads?:D Nope, sorry" << std::endl;
 			return 0;
 		}
 		count_cpu=atoi(argv[3]);
-	}if ( argc > 4 ) {
+	}
+	if ( argc > 4 )
+	{
 		type = NameToSigType(std::string(argv[4]));
 	}
 
 ///////////////
 //For while
-if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519){
+	if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519)
+	{
 		std::cout << "For a while only ED25519-SHA512" << std::endl;
 		return 0;
-}
+	}
 ///////////////
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	auto keys = i2p::data::PrivateKeys::CreateRandomKeys (type);
-			switch(type){
+	switch(type)
+	{
 		case i2p::data::SIGNING_KEY_TYPE_DSA_SHA1:
 		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
 		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
@@ -247,64 +233,62 @@ if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519){
 		return 0;
 		break;
 	}
+
 //TODO: for other types.
-			switch(type){
+	switch(type)
+	{
 		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-				
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
-
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
-
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
-
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
 			MutateByte=320;
 		break;
 		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256:
 		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256_TEST:
-
 		break;
 	}
 
-
 	KeyBuf = new uint8_t[keys.GetFullLen()];
 	keys.ToBuffer (KeyBuf, keys.GetFullLen ());
-#ifdef __linux__
+
 	if(!count_cpu)
-   count_cpu = sysconf(_SC_NPROCESSORS_ONLN);
-#elif _WIN32
-  if(!count_cpu){
-	SYSTEM_INFO sysinfo;
-	GetSystemInfo(&sysinfo);
-	count_cpu = sysinfo.dwNumberOfProcessors;
-	}
+	{
+#if defined(WIN32)
+		SYSTEM_INFO siSysInfo;
+		GetSystemInfo(&siSysInfo);
+		count_cpu = siSysInfo.dwNumberOfProcessors;
+#elif defined(_SC_NPROCESSORS_CONF)
+		count_cpu = sysconf(_SC_NPROCESSORS_CONF);
+#elif defined(HW_NCPU)
+		int req[] = { CTL_HW, HW_NCPU };
+		size_t len = sizeof(count_cpu);
+		v = sysctl(req, 2, &count_cpu, &len, NULL, 0);
 #else
-  if(!count_cpu)
 		count_cpu = 4;
 #endif
-   std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
-
+	}
 
-unsigned short attempts = 0;
-while(!found)
+	std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
 
-{//while
-{//stack(for destructors(vector/thread))
+	unsigned short attempts = 0;
+	while(!found)
+	{//while
+		{//stack(for destructors(vector/thread))
 
 			std::vector<std::thread> threads(count_cpu);
 			unsigned long long thoughtput = 0x4F4B5A37;
 
-  for ( unsigned int j = count_cpu;j--;){
+			for ( unsigned int j = count_cpu;j--;)
+			{
 				threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
 				thoughtput+=1000;
 			}//for
@@ -312,13 +296,14 @@ while(!found)
 			for(unsigned int j = 0; j < count_cpu;j++)
 				threads[j].join();
 
-  if(FoundNonce == 0){
+			if(FoundNonce == 0)
+			{
 				RAND_bytes( KeyBuf+MutateByte , 90 );
 				std::cout << "Attempts #" << ++attempts << std::endl;
 			}
 
-}//stack
-}//while
+		}//stack
+	}//while
 
 	memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
 	std::cout << "Hashes: " << hashescounter << std::endl;
@@ -336,4 +321,3 @@ while(!found)
 
 	return 0;
 }
-