PurpleI2P
/
i2pd-tools
mirror of https://github.com/PurpleI2P/i2pd-tools
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Merge pull request #35 from r4sas/winbuild 

building using mingw
pull/36/head
orignal 7 years ago committed by GitHub
parent
a8f62274d3 2ef31a9e04
commit
af8c31a809
3 changed files with 184 additions and 183 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      Makefile
  2. 3
      vanity.hpp
  3. 158
      vanitygen.cpp

22
Makefile
Unescape View File

@ -2,11 +2,25 @@ I2PD_PATH = i2pd
LIBI2PD_PATH = $(I2PD_PATH)/libi2pd LIBI2PD_PATH = $(I2PD_PATH)/libi2pd
LIBI2PD_CLIENT_PATH = $(I2PD_PATH)/libi2pd_client LIBI2PD_CLIENT_PATH = $(I2PD_PATH)/libi2pd_client
CXX = g++ 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) INCFLAGS = -I$(LIBI2PD_PATH) -I$(LIBI2PD_CLIENT_PATH) -I$(I2PD_PATH)
CXXFLAGS = $(FLAGS) $(INCFLAGS) CXXFLAGS = $(FLAGS)
LDFLAGS = -Wl,-rpath,/usr/local/lib 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) SOURCES = $(wildcard *.cpp)
OBJECTS = $(SOURCES:.cpp=.o) OBJECTS = $(SOURCES:.cpp=.o)
@ -42,7 +56,7 @@ $(I2PD_LIB):
$(MAKE) -C $(I2PD_PATH) mk_obj_dir $(I2PD_LIB) $(MAKE) -C $(I2PD_PATH) mk_obj_dir $(I2PD_LIB)
%.o: %.cpp libi2pd.a %.o: %.cpp libi2pd.a
$(CXX) -o $@ -c $(CXXFLAGS) $< $(INCFLAGS) $(CXX) -o $@ -c $(CXXFLAGS) $(INCFLAGS) $<
count: count:
wc *.c *.cc *.C *.cpp *.h *.hpp wc *.c *.cc *.C *.cpp *.h *.hpp

3
vanity.hpp
Unescape View File

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

158
vanitygen.cpp
Unescape View File

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

Write Preview
Loading…
Cancel
Save