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

building using mingw

pull/35/head
R4SAS 7 years ago
parent
a8f62274d3
commit
2ef31a9e04
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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      Makefile
  2. 17
      vanity.hpp
  3. 304
      vanitygen.cpp

22
Makefile
Unescape View File

@ -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
Unescape View File

@ -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; \

304
vanitygen.cpp
Unescape View File

@ -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,7 +6,7 @@ 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 @@ -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;
@ -85,14 +74,14 @@ static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char @@ -85,14 +74,14 @@ static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char
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;
}
}
@ -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 ^-^
@ -132,16 +122,14 @@ Orignal is sensei of crypto ;) @@ -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,53 +142,44 @@ Orignal is sensei of crypto ;) @@ -154,53 +142,44 @@ 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){
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;
}
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;
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;
}

Write Preview
Loading…
Cancel
Save