Some useful tools for I2P
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

241 lines
5.4 KiB

7 years ago
#include "vanity.hpp"
7 years ago
#define CPU_ONLY
7 years ago
7 years ago
static bool check_prefix(const char * buf){
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;
}
7 years ago
7 years ago
7 years ago
static 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;
pos++;
bits += 8;
}
else // last byte
{
tmp <<= (5 - bits);
bits = 5;
}
}
bits -= 5;
int ind = (tmp >> bits) & 0x1F;
outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2');
ret++;
}
outBuf[ret]='\0';
return ret;
}
7 years ago
static inline bool NotThat(const char * a, const char *b){
while(*b)
if(*a++!=*b++) return true;
return false;
}
7 years ago
7 years ago
#ifdef CPU_ONLY
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 ^-^
Orignal is sensei of crypto ;)
*/
std::cout << "Thread " << id_thread << " binded" << std::endl;
union{
uint8_t b[391];
uint32_t ll;
}local;
memcpy (local.b, buf, 391);
7 years ago
int len = strlen (prefix);
7 years ago
SHA256_CTX ctx, ctx1;
SHA256_Init(&ctx);
SHA256_Update(&ctx, local.b, MutateByte);
7 years ago
uint32_t * nonce = (uint32_t *)(local.b+MutateByte); // in nonce copy of MutateByte of b;
(*nonce)+=id_thread*throughput;
7 years ago
uint8_t hash[32];
char addr[53];
while(throughput-- and !found){
memcpy (&ctx1, &ctx, sizeof (SHA256_CTX));
SHA256_Update(&ctx1, local.b + MutateByte, 71);
SHA256_Final(hash, &ctx1);
ByteStreamToBase32 (hash, 32, addr, len);
7 years ago
7 years ago
if( !NotThat(addr,prefix) ){
ByteStreamToBase32 (hash, 32, addr, 52);
7 years ago
std::cout << "Address found " << addr << " in " << id_thread << std::endl;
7 years ago
found=true;
FoundNonce=*nonce;
7 years ago
return true;
}
(*nonce)++;
hashescounter++;
if (found) break;
7 years ago
}//while
7 years ago
}
7 years ago
7 years ago
#endif
7 years ago
int main (int argc, char * argv[])
{
7 years ago
if ( argc < 3 )
{
7 years ago
std::cout << "Usage: " << argv[0] << " filename generatestring <threads(default of system)> <signature type>" << std::endl;
7 years ago
return 0;
}
7 years ago
if(!check_prefix(argv[2])){
std::cout << "Not correct prefix" << std::endl;
return 0;
}
i2p::crypto::InitCrypto (false);
7 years ago
type = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519;
if ( argc > 3 ){
unsigned int tmp = atoi(argv[3]);
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 ) {
type = NameToSigType(std::string(argv[4]));
}
7 years ago
///////////////
//For while
if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519){
std::cout << "For a while only ED25519-SHA512" << std::endl;
return 0;
}
///////////////
7 years ago
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
7 years ago
auto keys = i2p::data::PrivateKeys::CreateRandomKeys (type);
7 years ago
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;
}
7 years ago
//TODO: for other types.
7 years ago
switch(type){
case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
7 years ago
7 years ago
break;
case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
7 years ago
MutateByte=320;
7 years ago
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:
7 years ago
7 years ago
break;
}
7 years ago
7 years ago
KeyBuf = new uint8_t[keys.GetFullLen()];
7 years ago
keys.ToBuffer (KeyBuf, keys.GetFullLen ());
7 years ago
if(!count_cpu)
count_cpu = sysconf(_SC_NPROCESSORS_ONLN);
7 years ago
7 years ago
std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
7 years ago
7 years ago
unsigned short attempts = 0;
while(!found)
{//while
{//stack(for destructors(vector/thread))
std::vector<std::thread> threads(count_cpu);
unsigned long long thoughtput = 0x4F4B5A37;
7 years ago
for ( unsigned int j = count_cpu;j--;){
threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
thoughtput+=1000;
7 years ago
}//for
7 years ago
7 years ago
for(unsigned int j = 0; j < count_cpu;j++)
threads[j].join();
7 years ago
if(FoundNonce == 0){
RAND_bytes( KeyBuf+MutateByte , 90 );
std::cout << "Attempts #" << ++attempts << std::endl;
}
7 years ago
7 years ago
}//stack
}//while
7 years ago
7 years ago
memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
7 years ago
std::cout << "Hashes: " << hashescounter << std::endl;
7 years ago
std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out);
if (f)
{
7 years ago
f.write ((char *)KeyBuf, keys.GetFullLen ());
7 years ago
delete [] KeyBuf;
}
else
std::cout << "Can't create file " << argv[1] << std::endl;
i2p::crypto::TerminateCrypto ();
return 0;
}
7 years ago