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. 17
      vanity.hpp
  3. 328
      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

17
vanity.hpp
Unescape View File

@ -5,22 +5,25 @@
#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))
#define SHR(x, n) (x >> n) #define SHR(x, n) (x >> n)
#define ROTR(x, n) ((x >> n) | (x << (32 - n))) #define ROTR(x, n) ((x >> n) | (x << (32 - n)))
#define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) #define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) #define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)) #define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10)) #define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
#define RND(a, b, c, d, e, f, g, h, k) \ #define RND(a, b, c, d, e, f, g, h, k) \
t0 = h + S1(e) + Ch(e, f, g) + k; \ t0 = h + S1(e) + Ch(e, f, g) + k; \

328
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,11 +6,11 @@ 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];
} }
static void inline TransformBlock (uint32_t state[8], const uint32_t W[64]) static void inline TransformBlock (uint32_t state[8], const uint32_t W[64])
{ {
/* /*
@ -37,8 +36,8 @@ implementation of orignal
RNDr(S, W, 52, 0x391c0cb3); RNDr(S, W, 53, 0x4ed8aa4a); RNDr(S, W, 54, 0x5b9cca4f); RNDr(S, W, 55, 0x682e6ff3); RNDr(S, W, 52, 0x391c0cb3); RNDr(S, W, 53, 0x4ed8aa4a); RNDr(S, W, 54, 0x5b9cca4f); RNDr(S, W, 55, 0x682e6ff3);
RNDr(S, W, 56, 0x748f82ee); RNDr(S, W, 57, 0x78a5636f); RNDr(S, W, 58, 0x84c87814); RNDr(S, W, 59, 0x8cc70208); RNDr(S, W, 56, 0x748f82ee); RNDr(S, W, 57, 0x78a5636f); RNDr(S, W, 58, 0x84c87814); RNDr(S, W, 59, 0x8cc70208);
RNDr(S, W, 60, 0x90befffa); RNDr(S, W, 61, 0xa4506ceb); RNDr(S, W, 62, 0xbef9a3f7); RNDr(S, W, 63, 0xc67178f2); RNDr(S, W, 60, 0x90befffa); RNDr(S, W, 61, 0xa4506ceb); RNDr(S, W, 62, 0xbef9a3f7); RNDr(S, W, 63, 0xc67178f2);
for (int i = 0; i < 8; i++) state[i] += S[i]; for (int i = 0; i < 8; i++) state[i] += S[i];
} }
void inline HashNextBlock (uint32_t state[8], const uint8_t * block) void inline HashNextBlock (uint32_t state[8], const uint8_t * block)
@ -51,51 +50,41 @@ 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;
int bits = 8, tmp = inBuf[0]; int bits = 8, tmp = inBuf[0];
while (ret < outLen && (bits > 0 || pos < len)) while (ret < outLen && (bits > 0 || pos < len))
{ {
if (bits < 5) if (bits < 5)
{ {
if (pos < len) if (pos < len)
{ {
tmp <<= 8; tmp <<= 8;
tmp |= inBuf[pos] & 0xFF; tmp |= inBuf[pos] & 0xFF;
pos++; pos++;
bits += 8; bits += 8;
} }
else // last byte else // last byte
{ {
tmp <<= (5 - bits); tmp <<= (5 - bits);
bits = 5; bits = 5;
} }
} }
bits -= 5; bits -= 5;
int ind = (tmp >> bits) & 0x1F; int ind = (tmp >> bits) & 0x1F;
outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2'); outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2');
@ -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 ^-^
@ -125,82 +115,71 @@ Orignal is sensei of crypto ;)
{ {
uint8_t b[391]; uint8_t b[391];
uint32_t ll; uint32_t ll;
} local; } local;
union union
{ {
uint8_t b[32]; uint8_t b[32];
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);
HashNextBlock (state, b + 192); HashNextBlock (state, b + 192);
HashNextBlock (state, b + 256); HashNextBlock (state, b + 256);
// pre-calculate last W // pre-calculate last W
uint32_t lastW[64]; uint32_t lastW[64];
CalculateW (lastBlock, lastW); CalculateW (lastBlock, lastW);
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); // apply last block
// apply last block 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);
// std::cout << addr << std::endl;
/* if(!NotThat(addr,prefix))
{
*/ ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len); std::cout << "Address found " << addr << " in " << id_thread << std::endl;
// std::cout << addr << std::endl; found=true;
if( !NotThat(addr,prefix) ){ FoundNonce=*nonce;
ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52); free(hash);
std::cout << "Address found " << addr << " in " << id_thread << std::endl; free(b);
found=true; return true;
FoundNonce=*nonce; }
free(hash);
free(b);
return true;
}
(*nonce)++;
hashescounter++;
if (found){
free(hash);
free(b);
break;
}
(*nonce)++;
hashescounter++;
if (found)
{
free(hash);
free(b);
break;
}
}//while }//while
} }
#endif
int main (int argc, char * argv[]) int main (int argc, char * argv[])
{ {
if ( argc < 3 ) if ( argc < 3 )
@ -208,126 +187,132 @@ 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; {
return 0; std::cout << "For a while only ED25519-SHA512" << std::endl;
} 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_ECDSA_SHA512_P521: case i2p::data::SIGNING_KEY_TYPE_DSA_SHA1:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048: case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072: case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096: case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512: case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST: case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl; case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST:
return 0; std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
break; return 0;
} break;
//TODO: for other types. }
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; //TODO: for other types.
case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519: 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; 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()];
keys.ToBuffer (KeyBuf, keys.GetFullLen ());
KeyBuf = new uint8_t[keys.GetFullLen()]; if(!count_cpu)
keys.ToBuffer (KeyBuf, keys.GetFullLen ()); {
#ifdef __linux__ #if defined(WIN32)
if(!count_cpu) SYSTEM_INFO siSysInfo;
count_cpu = sysconf(_SC_NPROCESSORS_ONLN); GetSystemInfo(&siSysInfo);
#elif _WIN32 count_cpu = siSysInfo.dwNumberOfProcessors;
if(!count_cpu){ #elif defined(_SC_NPROCESSORS_CONF)
SYSTEM_INFO sysinfo; count_cpu = sysconf(_SC_NPROCESSORS_CONF);
GetSystemInfo(&sysinfo); #elif defined(HW_NCPU)
count_cpu = sysinfo.dwNumberOfProcessors; 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; }
std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
unsigned short attempts = 0; unsigned short attempts = 0;
while(!found) while(!found)
{//while
{//stack(for destructors(vector/thread))
{//while std::vector<std::thread> threads(count_cpu);
{//stack(for destructors(vector/thread)) unsigned long long thoughtput = 0x4F4B5A37;
std::vector<std::thread> threads(count_cpu); for ( unsigned int j = count_cpu;j--;)
unsigned long long thoughtput = 0x4F4B5A37; {
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
}//for
for ( unsigned int j = count_cpu;j--;){ for(unsigned int j = 0; j < count_cpu;j++)
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput); threads[j].join();
thoughtput+=1000;
}//for
for(unsigned int j = 0; j < count_cpu;j++) if(FoundNonce == 0)
threads[j].join(); {
RAND_bytes( KeyBuf+MutateByte , 90 );
if(FoundNonce == 0){ std::cout << "Attempts #" << ++attempts << std::endl;
RAND_bytes( KeyBuf+MutateByte , 90 ); }
std::cout << "Attempts #" << ++attempts << std::endl;
} }//stack
}//while
}//stack memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
}//while std::cout << "Hashes: " << hashescounter << std::endl;
memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
std::cout << "Hashes: " << hashescounter << std::endl;
std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out); std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out);
if (f) if (f)
{ {
f.write ((char *)KeyBuf, keys.GetFullLen ()); f.write ((char *)KeyBuf, keys.GetFullLen ());
delete [] KeyBuf; delete [] KeyBuf;
} }
else else
std::cout << "Can't create file " << argv[1] << std::endl; std::cout << "Can't create file " << argv[1] << std::endl;
@ -336,4 +321,3 @@ while(!found)
return 0; return 0;
} }

Write Preview
Loading…
Cancel
Save