Browse Source

building using mingw

pull/35/head
R4SAS 7 years ago
parent
commit
2ef31a9e04
  1. 22
      Makefile
  2. 17
      vanity.hpp
  3. 328
      vanitygen.cpp

22
Makefile

@ -2,11 +2,25 @@ I2PD_PATH = i2pd @@ -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): @@ -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

17
vanity.hpp

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

328
vanitygen.cpp

@ -1,5 +1,4 @@ @@ -1,5 +1,4 @@
#include "vanity.hpp"
#define CPU_ONLY
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]) @@ -7,11 +6,11 @@ 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];
}
static void inline TransformBlock (uint32_t state[8], const uint32_t W[64])
{
/*
@ -37,8 +36,8 @@ implementation of orignal @@ -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, 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);
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)
@ -51,51 +50,41 @@ implementation of orignal @@ -51,51 +50,41 @@ 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;
int bits = 8, tmp = inBuf[0];
while (ret < outLen && (bits > 0 || pos < len))
{
{
if (bits < 5)
{
if (pos < len)
{
tmp <<= 8;
tmp |= inBuf[pos] & 0xFF;
tmp |= inBuf[pos] & 0xFF;
pos++;
bits += 8;
bits += 8;
}
else // last byte
{
tmp <<= (5 - bits);
bits = 5;
bits = 5;
}
}
}
bits -= 5;
int ind = (tmp >> bits) & 0x1F;
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 @@ -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 ^-^
@ -125,82 +115,71 @@ Orignal is sensei of crypto ;) @@ -125,82 +115,71 @@ Orignal is sensei of crypto ;)
{
uint8_t b[391];
uint32_t ll;
} local;
} local;
union
{
uint8_t b[32];
uint32_t ll[8];
} hash;
} 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);
HashNextBlock (state, b + 192);
HashNextBlock (state, b + 256);
HashNextBlock (state, b + 256);
// pre-calculate last W
uint32_t lastW[64];
CalculateW (lastBlock, lastW);
CalculateW (lastBlock, lastW);
uint32_t * nonce = (uint32_t *)(b+320);
(*nonce) += id_thread*throughput;
/*
(*nonce) += id_thread*throughput;
*/
char addr[53];
uint32_t state1[8];
while(throughput-- and !found){
memcpy (state1, state, 32);
// calculate hash of block with nonce
HashNextBlock (state1, b + 320);
// apply last block
TransformBlock (state1, lastW);
// get final hash
for (int j = 8; 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);
std::cout << "Address found " << addr << " in " << id_thread << std::endl;
found=true;
FoundNonce=*nonce;
free(hash);
free(b);
return true;
}
(*nonce)++;
hashescounter++;
if (found){
free(hash);
free(b);
break;
}
while(throughput-- and !found)
{
memcpy (state1, state, 32);
// calculate hash of block with nonce
HashNextBlock (state1, b + 320);
// apply last block
TransformBlock (state1, lastW);
// get final hash
for (int j = 8; 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);
std::cout << "Address found " << addr << " in " << id_thread << std::endl;
found=true;
FoundNonce=*nonce;
free(hash);
free(b);
return true;
}
(*nonce)++;
hashescounter++;
if (found)
{
free(hash);
free(b);
break;
}
}//while
}
#endif
int main (int argc, char * argv[])
{
if ( argc < 3 )
@ -208,126 +187,132 @@ int main (int argc, char * argv[]) @@ -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;
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){
std::cout << "For a while only ED25519-SHA512" << std::endl;
return 0;
}
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){
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:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST:
std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
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:
auto keys = i2p::data::PrivateKeys::CreateRandomKeys (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:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST:
std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
return 0;
break;
}
break;
case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
//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;
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;
}
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 ());
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(!count_cpu)
{
#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;
count_cpu = 4;
#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;
while(!found)
unsigned short attempts = 0;
while(!found)
{//while
{//stack(for destructors(vector/thread))
{//while
{//stack(for destructors(vector/thread))
std::vector<std::thread> threads(count_cpu);
unsigned long long thoughtput = 0x4F4B5A37;
std::vector<std::thread> threads(count_cpu);
unsigned long long thoughtput = 0x4F4B5A37;
for ( unsigned int j = count_cpu;j--;)
{
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
}//for
for ( unsigned int j = count_cpu;j--;){
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
}//for
for(unsigned int j = 0; j < count_cpu;j++)
threads[j].join();
for(unsigned int j = 0; j < count_cpu;j++)
threads[j].join();
if(FoundNonce == 0){
RAND_bytes( KeyBuf+MutateByte , 90 );
std::cout << "Attempts #" << ++attempts << std::endl;
}
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;
memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
std::cout << "Hashes: " << hashescounter << std::endl;
std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out);
if (f)
{
f.write ((char *)KeyBuf, keys.GetFullLen ());
delete [] KeyBuf;
delete [] KeyBuf;
}
else
std::cout << "Can't create file " << argv[1] << std::endl;
@ -336,4 +321,3 @@ while(!found) @@ -336,4 +321,3 @@ while(!found)
return 0;
}

Loading…
Cancel
Save