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

Merge remote-tracking branch 'purple/master'

pull/48/head
Jeff Becker 7 years ago
parent
a148516d60 088581be32
commit
39e24b97e1
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
3 changed files with 200 additions and 176 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. 30
      Makefile
  2. 19
      vanity.hpp
  3. 327
      vanitygen.cpp

30
Makefile
Unescape View File

@ -1,12 +1,31 @@ @@ -1,12 +1,31 @@
UNAME = $(shell uname -s)
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
ifeq ($(UNAME),Linux)
FLAGS += -g
else
# Win32
FLAGS += -Os -D_MT -DWIN32 -D_WINDOWS -DWIN32_LEAN_AND_MEAN
BOOST_SUFFIX = -mt
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 -lz
ifeq ($(UNAME),Linux)
LIBS += -lrt -lpthread
else
# Win32
LIBS += -lws2_32 -lwsock32 -lgdi32 -liphlpapi -lstdc++ -lpthread
LDFLAGS += -Wl,-Bstatic -static-libgcc -static-libstdc++
endif
SOURCES = $(wildcard *.cpp)
OBJECTS = $(SOURCES:.cpp=.o)
@ -45,7 +64,7 @@ $(I2PD_LIB): @@ -45,7 +64,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
@ -57,7 +76,8 @@ clean-obj: @@ -57,7 +76,8 @@ clean-obj:
rm -f $(OBJECTS)
clean-bin:
rm -f keyinfo keygen famtool regaddr routerinfo i2pbase64
rm -f keyinfo keygen famtool regaddr routerinfo i2pbase64 vain
clean: clean-i2pd clean-obj clean-bin

19
vanity.hpp
Unescape View File

@ -5,20 +5,25 @@ @@ -5,20 +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; \

327
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,11 +6,16 @@ static void inline CalculateW (const uint8_t block[64], uint32_t W[64]) @@ -7,11 +6,16 @@ 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]);
#ifdef _WIN32
W[i] = htobe32(((uint32_t *)(block))[i]);
#else
W[i] = be32toh(((uint32_t *)(block))[i]);
#endif
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 +41,8 @@ implementation of orignal @@ -37,8 +41,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 +55,41 @@ implementation of orignal @@ -51,51 +55,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 +99,16 @@ static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char @@ -105,15 +99,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 +120,72 @@ Orignal is sensei of crypto ;) @@ -125,82 +120,72 @@ 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
return true;
}
#endif
int main (int argc, char * argv[])
{
if ( argc < 3 )
@ -208,117 +193,132 @@ int main (int argc, char * argv[]) @@ -208,117 +193,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 ());
if(!count_cpu)
count_cpu = sysconf(_SC_NPROCESSORS_ONLN);
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
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)
{//while
{//stack(for destructors(vector/thread))
unsigned short attempts = 0;
while(!found)
std::vector<std::thread> threads(count_cpu);
unsigned long long thoughtput = 0x4F4B5A37;
{//while
{//stack(for destructors(vector/thread))
for ( unsigned int j = count_cpu;j--;)
{
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
}//for
std::vector<std::thread> threads(count_cpu);
unsigned long long thoughtput = 0x4F4B5A37;
for(unsigned int j = 0; j < count_cpu;j++)
threads[j].join();
for ( unsigned int j = count_cpu;j--;){
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
}//for
if(FoundNonce == 0)
{
RAND_bytes( KeyBuf+MutateByte , 90 );
std::cout << "Attempts #" << ++attempts << std::endl;
}
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;
}
}//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;
@ -327,4 +327,3 @@ while(!found) @@ -327,4 +327,3 @@ while(!found)
return 0;
}

Write Preview
Loading…
Cancel
Save