/*

Develop by Alberto
email: [email protected]
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <vector>
#include <inttypes.h>
#include "base58/libbase58.h"
#include "rmd160/rmd160.h"
#include "oldbloom/oldbloom.h"
#include "bloom/bloom.h"
#include "sha3/sha3.h"
#include "util.h"

#include "secp256k1/SECP256k1.h"
#include "secp256k1/Point.h"
#include "secp256k1/Int.h"
#include "secp256k1/IntGroup.h"
#include "secp256k1/Random.h"

#include "hash/sha256.h"
#include "hash/ripemd160.h"

#if defined(_WIN64) && !defined(__CYGWIN__)

#include "getopt.h"
#include <windows.h>
#else
#include <unistd.h>
#include <pthread.h>
#include <sys/random.h>
#endif

#ifdef __unix__
#ifdef __CYGWIN__
#else
#include <linux/random.h>
#endif
#endif

#define CRYPTO_NONE 0
#define CRYPTO_BTC 1
#define CRYPTO_ETH 2
#define CRYPTO_ALL 3

#define MODE_XPOINT 0
#define MODE_ADDRESS 1
#define MODE_BSGS 2
#define MODE_RMD160 3
#define MODE_PUB2RMD 4
#define MODE_MINIKEYS 5
#define MODE_VANITY 6

#define SEARCH_UNCOMPRESS 0
#define SEARCH_COMPRESS 1
#define SEARCH_BOTH 2

uint32_t THREADBPWORKLOAD = 1048576;

struct checksumsha256 {
char data[32];
char backup[32];
};

struct bsgs_xvalue {
uint8_t value[6];
uint64_t index;
};

struct address_value {
uint8_t value[20];
};

struct tothread {
int nt; //Number thread
char *rs; //range start
char *rpt; //rng per thread
};

struct bPload {
uint32_t threadid;
uint64_t from;
uint64_t to;
uint64_t counter;
uint64_t workload;
uint32_t aux;
uint32_t finished;
};

#if defined(_WIN64) && !defined(__CYGWIN__)

#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma(
pack(pop))
PACK(struct publickey
{
uint8_t parity;
union {
uint8_t data8[32];
uint32_t data32[8];
uint64_t data64[4];
} X;
});
#else
struct __attribute__((__packed__)) publickey {
uint8_t parity;
union {
uint8_t data8[32];
uint32_t data32[8];
uint64_t data64[4];
} X;
};
#endif

const char *Ccoinbuffer_default =

"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

char *Ccoinbuffer = (char*) Ccoinbuffer_default;

char *str_baseminikey = NULL;
char *raw_baseminikey = NULL;
char *minikeyN = NULL;
int minikey_n_limit;

const char *version = "0.2.230519 Satoshi Quest";

#define CPU_GRP_SIZE 1024

std::vector<Point> Gn;
Point _2Gn;

std::vector<Point> GSn;
Point _2GSn;

void menu();
void init_generator();

int searchbinary(struct address_value *buffer,char *data,int64_t array_length);

void sleep_ms(int milliseconds);

void _sort(struct address_value *arr,int64_t N);

void _insertionsort(struct address_value *arr, int64_t n);
void _introsort(struct address_value *arr,uint32_t depthLimit, int64_t n);
void _swap(struct address_value *a,struct address_value *b);
int64_t _partition(struct address_value *arr, int64_t n);
void _myheapsort(struct address_value *arr, int64_t n);
void _heapify(struct address_value *arr, int64_t n, int64_t i);

void bsgs_sort(struct bsgs_xvalue *arr,int64_t n);

void bsgs_myheapsort(struct bsgs_xvalue *arr, int64_t n);
void bsgs_insertionsort(struct bsgs_xvalue *arr, int64_t n);
void bsgs_introsort(struct bsgs_xvalue *arr,uint32_t depthLimit, int64_t n);
void bsgs_swap(struct bsgs_xvalue *a,struct bsgs_xvalue *b);
void bsgs_heapify(struct bsgs_xvalue *arr, int64_t n, int64_t i);
int64_t bsgs_partition(struct bsgs_xvalue *arr, int64_t n);

int bsgs_searchbinary(struct bsgs_xvalue *arr,char *data,int64_t

array_length,uint64_t *r_value);
int bsgs_secondcheck(Int *start_range,uint32_t a,uint32_t k_index,Int *privatekey);
int bsgs_thirdcheck(Int *start_range,uint32_t a,uint32_t k_index,Int *privatekey);

void sha256sse_22(uint8_t *src0, uint8_t *src1, uint8_t *src2, uint8_t *src3,

uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dst3);
void sha256sse_23(uint8_t *src0, uint8_t *src1, uint8_t *src2, uint8_t *src3,
uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dst3);

bool vanityrmdmatch(unsigned char *rmdhash);

void writevanitykey(bool compress,Int *key);
int addvanity(char *target);
int minimum_same_bytes(unsigned char* A,unsigned char* B, int length);

void writekey(bool compressed,Int *key);

void writekeyeth(Int *key);

void checkpointer(void *ptr,const char *file,const char *function,const char

*name,int line);

bool isBase58(char c);

bool isValidBase58String(char *str);

bool readFileAddress(char *fileName);

bool readFileVanity(char *fileName);
bool forceReadFileAddress(char *fileName);
bool forceReadFileAddressEth(char *fileName);
bool forceReadFileXPoint(char *fileName);
bool processOneVanity();

bool initBloomFilter(struct bloom *bloom_arg,uint64_t items_bloom);

void writeFileIfNeeded(const char *fileName);

void calcualteindex(int i,Int *key);

#if defined(_WIN64) && !defined(__CYGWIN__)
DWORD WINAPI thread_process_vanity(LPVOID vargp);
DWORD WINAPI thread_process_minikeys(LPVOID vargp);
DWORD WINAPI thread_process(LPVOID vargp);
DWORD WINAPI thread_process_bsgs(LPVOID vargp);
DWORD WINAPI thread_process_bsgs_backward(LPVOID vargp);
DWORD WINAPI thread_process_bsgs_both(LPVOID vargp);
DWORD WINAPI thread_process_bsgs_random(LPVOID vargp);
DWORD WINAPI thread_process_bsgs_dance(LPVOID vargp);
DWORD WINAPI thread_bPload(LPVOID vargp);
DWORD WINAPI thread_bPload_2blooms(LPVOID vargp);
#else
void *thread_process_vanity(void *vargp);
void *thread_process_minikeys(void *vargp);
void *thread_process(void *vargp);
void *thread_process_bsgs(void *vargp);
void *thread_process_bsgs_backward(void *vargp);
void *thread_process_bsgs_both(void *vargp);
void *thread_process_bsgs_random(void *vargp);
void *thread_process_bsgs_dance(void *vargp);
void *thread_bPload(void *vargp);
void *thread_bPload_2blooms(void *vargp);
#endif

char *pubkeytopubaddress(char *pkey,int length);

void pubkeytopubaddress_dst(char *pkey,int length,char *dst);
void rmd160toaddress_dst(char *rmd,char *dst);
void set_minikey(char *buffer,char *rawbuffer,int length);
bool increment_minikey_index(char *buffer,char *rawbuffer,int index);
void increment_minikey_N(char *rawbuffer);

void KECCAK_256(uint8_t *source, size_t size,uint8_t *dst);

void generate_binaddress_eth(Point &publickey,unsigned char *dst_address);

int THREADOUTPUT = 0;
char *bit_range_str_min;
char *bit_range_str_max;

const char *bsgs_modes[5] = {"sequential","backward","both","random","dance"};

const char *modes[7] =
{"xpoint","address","bsgs","rmd160","pub2rmd","minikeys","vanity"};
const char *cryptos[3] = {"btc","eth","all"};
const char *publicsearch[3] = {"uncompress","compress","both"};
const char *default_fileName = "addresses.txt";

#if defined(_WIN64) && !defined(__CYGWIN__)

HANDLE* tid = NULL;
HANDLE write_keys;
HANDLE write_random;
HANDLE bsgs_thread;
HANDLE *bPload_mutex = NULL;
#else
pthread_t *tid = NULL;
pthread_mutex_t write_keys;
pthread_mutex_t write_random;
pthread_mutex_t bsgs_thread;
pthread_mutex_t *bPload_mutex = NULL;
#endif

uint64_t FINISHED_THREADS_COUNTER = 0;
uint64_t FINISHED_THREADS_BP = 0;
uint64_t THREADCYCLES = 0;
uint64_t THREADCOUNTER = 0;
uint64_t FINISHED_ITEMS = 0;
uint64_t OLDFINISHED_ITEMS = -1;

uint8_t byte_encode_crypto = 0x00; /* Bitcoin */

int vanity_rmd_targets = 0;
int vanity_rmd_total = 0;
int *vanity_rmd_limits = NULL;
uint8_t ***vanity_rmd_limit_values_A = NULL,***vanity_rmd_limit_values_B = NULL;
int vanity_rmd_minimun_bytes_check_length = 999999;
char **vanity_address_targets = NULL;
struct bloom *vanity_bloom = NULL;

struct bloom bloom;

uint64_t *steps = NULL;

unsigned int *ends = NULL;
uint64_t N = 0;

uint64_t N_SEQUENTIAL_MAX = 0x100000000;

uint64_t DEBUGCOUNT = 0x400;
uint64_t u64range;

Int OUTPUTSECONDS;

int FLAGSKIPCHECKSUM = 0;
int FLAGENDOMORPHISM = 0;

int FLAGBLOOMMULTIPLIER = 1;
int FLAGVANITY = 0;
int FLAGBASEMINIKEY = 0;
int FLAGBSGSMODE = 0;
int FLAGDEBUG = 0;
int FLAGQUIET = 0;
int FLAGMATRIX = 0;
int KFACTOR = 1;
int MAXLENGTHADDRESS = -1;
int NTHREADS = 1;

int FLAGSAVEREADFILE = 0;
int FLAGREADEDFILE1 = 0;
int FLAGREADEDFILE2 = 0;
int FLAGREADEDFILE3 = 0;
int FLAGREADEDFILE4 = 0;
int FLAGUPDATEFILE1 = 0;

int FLAGSTRIDE = 0;
int FLAGSEARCH = 2;
int FLAGBITRANGE = 0;
int FLAGRANGE = 0;
int FLAGFILE = 0;
int FLAGMODE = MODE_ADDRESS;
int FLAGCRYPTO = 0;
int FLAGRAWDATA = 0;
int FLAGRANDOM = 0;
int FLAG_N = 0;
int FLAGPRECALCUTED_P_FILE = 0;

int bitrange;
char *str_N;
char *range_start;
char *range_end;
char *str_stride;
Int stride;

uint64_t BSGS_XVALUE_RAM = 6;
uint64_t BSGS_BUFFERXPOINTLENGTH = 32;
uint64_t BSGS_BUFFERREGISTERLENGTH = 36;

/*
BSGS Variables
*/
int *bsgs_found;
std::vector<Point> OriginalPointsBSGS;
bool *OriginalPointsBSGScompressed;

uint64_t bytes;
char checksum[32],checksum_backup[32];
char buffer_bloom_file[1024];
struct bsgs_xvalue *bPtable;
struct address_value *addressTable;

struct oldbloom oldbloom_bP;

struct bloom *bloom_bP;

struct bloom *bloom_bPx2nd; //2nd Bloom filter check
struct bloom *bloom_bPx3rd; //3rd Bloom filter check

struct checksumsha256 *bloom_bP_checksums;

struct checksumsha256 *bloom_bPx2nd_checksums;
struct checksumsha256 *bloom_bPx3rd_checksums;

#if defined(_WIN64) && !defined(__CYGWIN__)

std::vector<HANDLE> bloom_bP_mutex;
std::vector<HANDLE> bloom_bPx2nd_mutex;
std::vector<HANDLE> bloom_bPx3rd_mutex;
#else
pthread_mutex_t *bloom_bP_mutex;
pthread_mutex_t *bloom_bPx2nd_mutex;
pthread_mutex_t *bloom_bPx3rd_mutex;
#endif

uint64_t bloom_bP_totalbytes = 0;
uint64_t bloom_bP2_totalbytes = 0;
uint64_t bloom_bP3_totalbytes = 0;
uint64_t bsgs_m = 4194304;
uint64_t bsgs_m2;
uint64_t bsgs_m3;
uint64_t bsgs_aux;
uint32_t bsgs_point_number;

const char *str_limits_prefixs[7] =

{"Mkeys/s","Gkeys/s","Tkeys/s","Pkeys/s","Ekeys/s","Zkeys/s","Ykeys/s"};
const char *str_limits[7] =
{"1000000","1000000000","1000000000000","1000000000000000","1000000000000000000","1
000000000000000000000","1000000000000000000000000"};
Int int_limits[7];

Int BSGS_GROUP_SIZE;
Int BSGS_CURRENT;
Int BSGS_R;
Int BSGS_AUX;
Int BSGS_N;
Int BSGS_N_double;
Int BSGS_M; //M is squareroot(N)
Int BSGS_M_double;
Int BSGS_M2; //M2 is M/32
Int BSGS_M2_double; //M2_double is M2 * 2
Int BSGS_M3; //M3 is M2/32
Int BSGS_M3_double; //M3_double is M3 * 2

Int ONE;
Int ZERO;
Int MPZAUX;

Point BSGS_P; //Original P is actually G, but this P value change

over time for calculations
Point BSGS_MP; //MP values this is m * P
Point BSGS_MP2; //MP2 values this is m2 * P
Point BSGS_MP3; //MP3 values this is m3 * P

Point BSGS_MP_double; //MP2 values this is m2 * P * 2

Point BSGS_MP2_double; //MP2 values this is m2 * P * 2
Point BSGS_MP3_double; //MP3 values this is m3 * P * 2

std::vector<Point> BSGS_AMP2;
std::vector<Point> BSGS_AMP3;
Point point_temp,point_temp2; //Temp value for some process

Int n_range_start;
Int n_range_end;
Int n_range_diff;
Int n_range_aux;

Int lambda,lambda2,beta,beta2;

Secp256K1 *secp;

int main(int argc, char **argv) {

char buffer[2048];
char rawvalue[32];
struct tothread *tt; //tothread
Tokenizer t,tokenizerbsgs; //tokenizer
char *fileName = NULL;
char *hextemp = NULL;
char *aux = NULL;
char *aux2 = NULL;
char *pointx_str = NULL;
char *pointy_str = NULL;
char *str_seconds = NULL;
char *str_total = NULL;
char *str_pretotal = NULL;
char *str_divpretotal = NULL;
char *bf_ptr = NULL;
char *bPload_threads_available;
FILE *fd,*fd_aux1,*fd_aux2,*fd_aux3;
uint64_t i,BASE,PERTHREAD_R,itemsbloom,itemsbloom2,itemsbloom3;
uint32_t finished;
int readed,continue_flag,check_flag,c,salir,index_value,j;
Int
total,pretotal,debugcount_mpz,seconds,div_pretotal,int_aux,int_r,int_q,int58;
struct bPload *bPload_temp_ptr;
size_t rsize;

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD s;
write_keys = CreateMutex(NULL, FALSE, NULL);
write_random = CreateMutex(NULL, FALSE, NULL);
bsgs_thread = CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&write_keys,NULL);
pthread_mutex_init(&write_random,NULL);
pthread_mutex_init(&bsgs_thread,NULL);
int s;
#endif

srand(time(NULL));

secp = new Secp256K1();

secp->Init();
OUTPUTSECONDS.SetInt32(30);
ZERO.SetInt32(0);
ONE.SetInt32(1);
BSGS_GROUP_SIZE.SetInt32(CPU_GRP_SIZE);
#if defined(_WIN64) && !defined(__CYGWIN__)
//Any windows secure random source goes here
rseed(clock() + time(NULL) + rand());
#else
unsigned long rseedvalue;
int bytes_read = getrandom(&rseedvalue, sizeof(unsigned long),
GRND_NONBLOCK);
if(bytes_read > 0) {
rseed(rseedvalue);
/*
In any case that seed is for a failsafe RNG, the default source on
linux is getrandom function
See https://www.2uo.de/myths-about-urandom/
*/
}
else {
/*
what year is??
WTF linux without RNG ?
*/
fprintf(stderr,"[E] Error getrandom() ?\n");
exit(EXIT_FAILURE);
rseed(clock() + time(NULL) + rand()*rand());
}
#endif

printf("[+] Version %s, developed by AlbertoBSD\n",version);

while ((c = getopt(argc, argv,

"deh6MqRSB:b:c:C:E:f:I:k:l:m:N:n:p:r:s:t:v:G:8:z:")) != -1) {
switch(c) {
case 'h':
menu();
break;
case '6':
FLAGSKIPCHECKSUM = 1;
fprintf(stderr,"[W] Skipping checksums on files\n");
break;
case 'B':
index_value = indexOf(optarg,bsgs_modes,5);
if(index_value >= 0 && index_value <= 4) {
FLAGBSGSMODE = index_value;
//printf("[+] BSGS mode %s\n",optarg);
}
else {
fprintf(stderr,"[W] Ignoring unknow bsgs mode %s\
n",optarg);
}
break;
case 'b':
bitrange = strtol(optarg,NULL,10);
if(bitrange > 0 && bitrange <=256 ) {
MPZAUX.Set(&ONE);
MPZAUX.ShiftL(bitrange-1);
bit_range_str_min = MPZAUX.GetBase16();
checkpointer((void
*)bit_range_str_min,__FILE__,"malloc","bit_range_str_min" ,__LINE__ -1);
 MPZAUX.Set(&ONE);
MPZAUX.ShiftL(bitrange);
if(MPZAUX.IsGreater(&secp->order)) {
MPZAUX.Set(&secp->order);
}
bit_range_str_max = MPZAUX.GetBase16();
checkpointer((void
*)bit_range_str_max,__FILE__,"malloc","bit_range_str_min" ,__LINE__ -1);
FLAGBITRANGE = 1;
}
else {
fprintf(stderr,"[E] invalid bits param: %s.\
n",optarg);
}
break;
case 'c':
index_value = indexOf(optarg,cryptos,3);
switch(index_value) {
case 0: //btc
FLAGCRYPTO = CRYPTO_BTC;
break;
case 1: //eth
FLAGCRYPTO = CRYPTO_ETH;
printf("[+] Setting search for ETH adddress.\
n");
break;
/*
case 2: //all
FLAGCRYPTO = CRYPTO_ALL;
break;
*/
default:
FLAGCRYPTO = CRYPTO_NONE;
fprintf(stderr,"[E] Unknow crypto value %s\
n",optarg);
exit(EXIT_FAILURE);
break;
}
break;
case 'C':
if(strlen(optarg) == 22) {
FLAGBASEMINIKEY = 1;
str_baseminikey = (char*) malloc(23);
checkpointer((void
*)str_baseminikey,__FILE__,"malloc","str_baseminikey" ,__LINE__ - 1);
raw_baseminikey = (char*) malloc(23);
checkpointer((void
*)raw_baseminikey,__FILE__,"malloc","raw_baseminikey" ,__LINE__ - 1);
strncpy(str_baseminikey,optarg,22);
for(i = 0; i< 21; i++) {
if(strchr(Ccoinbuffer,str_baseminikey[i+1]) !=
NULL) {
raw_baseminikey[i] = (int)
(strchr(Ccoinbuffer,str_baseminikey[i+1]) - Ccoinbuffer) % 58;
}
else {
fprintf(stderr,"[E] invalid character in
minikey\n");
exit(EXIT_FAILURE);
 }

}
}
else {
fprintf(stderr,"[E] Invalid Minikey length %li : %s\
n",strlen(optarg),optarg);
exit(EXIT_FAILURE);
}

break;
case 'd':
FLAGDEBUG = 1;
printf("[+] Flag DEBUG enabled\n");
break;
case 'e':
FLAGENDOMORPHISM = 1;
printf("[+] Endomorphism enabled\n");

lambda.SetBase16("5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72"
);

lambda2.SetBase16("ac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283ce
");

beta.SetBase16("7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee");

beta2.SetBase16("851695d49a83f8ef919bb86153cbcb16630fb68aed0a766a3ec693d68e6afa40")
;
break;
case 'f':
FLAGFILE = 1;
fileName = optarg;
break;
case 'I':
FLAGSTRIDE = 1;
str_stride = optarg;
break;
case 'k':
KFACTOR = (int)strtol(optarg,NULL,10);
if(KFACTOR <= 0) {
KFACTOR = 1;
}
printf("[+] K factor %i\n",KFACTOR);
break;

case 'l':
switch(indexOf(optarg,publicsearch,3)) {
case SEARCH_UNCOMPRESS:
FLAGSEARCH = SEARCH_UNCOMPRESS;
printf("[+] Search uncompress only\n");
break;
case SEARCH_COMPRESS:
FLAGSEARCH = SEARCH_COMPRESS;
printf("[+] Search compress only\n");
 break;
case SEARCH_BOTH:
FLAGSEARCH = SEARCH_BOTH;
printf("[+] Search both compress and
uncompress\n");
break;
}
break;
case 'M':
FLAGMATRIX = 1;
printf("[+] Matrix screen\n");
break;
case 'm':
switch(indexOf(optarg,modes,7)) {
case MODE_XPOINT: //xpoint
FLAGMODE = MODE_XPOINT;
printf("[+] Mode xpoint\n");
break;
case MODE_ADDRESS: //address
FLAGMODE = MODE_ADDRESS;
printf("[+] Mode address\n");
break;
case MODE_BSGS:
FLAGMODE = MODE_BSGS;
//printf("[+] Mode BSGS\n");
break;
case MODE_RMD160:
FLAGMODE = MODE_RMD160;
FLAGCRYPTO = CRYPTO_BTC;
printf("[+] Mode rmd160\n");
break;
case MODE_PUB2RMD:
FLAGMODE = MODE_PUB2RMD;
printf("[+] Mode pub2rmd was removed\n");
exit(0);
break;
case MODE_MINIKEYS:
FLAGMODE = MODE_MINIKEYS;
printf("[+] Mode minikeys\n");
break;
case MODE_VANITY:
FLAGMODE = MODE_VANITY;
printf("[+] Mode vanity\n");
if(vanity_bloom == NULL){
vanity_bloom = (struct bloom*)
calloc(1,sizeof(struct bloom));
checkpointer((void
*)vanity_bloom,__FILE__,"calloc","vanity_bloom" ,__LINE__ -1);
}
break;
default:
fprintf(stderr,"[E] Unknow mode value %s\
n",optarg);
exit(EXIT_FAILURE);
break;
}
break;
case 'n':
FLAG_N = 1;
 str_N = optarg;
break;
case 'q':
FLAGQUIET = 1;
printf("[+] Quiet thread output\n");
break;
case 'R':
printf("[+] Random mode\n");
FLAGRANDOM = 1;
FLAGBSGSMODE = 3;
break;
case 'r':
if(optarg != NULL) {
stringtokenizer(optarg,&t);
switch(t.n) {
case 1:
range_start = nextToken(&t);
if(isValidHex(range_start)) {
FLAGRANGE = 1;
range_end = secp-
>order.GetBase16();
}
else {
fprintf(stderr,"[E] Invalid
hexstring : %s.\n",range_start);
}
break;
case 2:
range_start = nextToken(&t);
range_end = nextToken(&t);
if(isValidHex(range_start) &&
isValidHex(range_end)) {
FLAGRANGE = 1;
}
else {
if(isValidHex(range_start)) {
fprintf(stderr,"[E] Invalid
hexstring : %s\n",range_start);
}
else {
fprintf(stderr,"[E] Invalid
hexstring : %s\n",range_end);
}
}
break;
default:
printf("[E] Unknow number of Range
Params: %i\n",t.n);
break;
}
}
break;
case 's':
OUTPUTSECONDS.SetBase10(optarg);
if(OUTPUTSECONDS.IsLower(&ZERO)) {
OUTPUTSECONDS.SetInt32(30);
}
if(OUTPUTSECONDS.IsZero()) {
printf("[+] Turn off stats output\n");
 }
else {
hextemp = OUTPUTSECONDS.GetBase10();
printf("[+] Stats output every %s seconds\
n",hextemp);
free(hextemp);
}
break;
case 'S':
FLAGSAVEREADFILE = 1;
break;
case 't':
NTHREADS = strtol(optarg,NULL,10);
if(NTHREADS <= 0) {
NTHREADS = 1;
}
printf((NTHREADS > 1) ? "[+] Threads : %u\n": "[+] Thread :
%u\n",NTHREADS);
break;
case 'v':
FLAGVANITY = 1;
if(vanity_bloom == NULL){
vanity_bloom = (struct bloom*) calloc(1,sizeof(struct
bloom));
checkpointer((void
*)vanity_bloom,__FILE__,"calloc","vanity_bloom" ,__LINE__ -1);
}
if(isValidBase58String(optarg)) {
if(addvanity(optarg) > 0) {
printf("[+] Added Vanity search : %s\
n",optarg);
}
else {
printf("[+] Vanity search \"%s\" was NOT Added\
n",optarg);
}
}
else {
fprintf(stderr,"[+] The string \"%s\" is not Valid
Base58\n",optarg);
}

break;
case '8':
if(strlen(optarg) == 58) {
Ccoinbuffer = optarg;
printf("[+] Base58 for Minikeys %s\n",Ccoinbuffer);
}
else {
fprintf(stderr,"[E] The base58 alphabet must be 58
characters long.\n");
exit(EXIT_FAILURE);
}
break;
case 'z':
FLAGBLOOMMULTIPLIER= strtol(optarg,NULL,10);
if(FLAGBLOOMMULTIPLIER <= 0) {
FLAGBLOOMMULTIPLIER = 1;
}
 printf("[+] Bloom Size Multiplier %i\
n",FLAGBLOOMMULTIPLIER);
break;
default:
fprintf(stderr,"[E] Unknow opcion -%c\n",c);
exit(EXIT_FAILURE);
break;
}
}

if( FLAGBSGSMODE == MODE_BSGS && FLAGENDOMORPHISM) {

fprintf(stderr,"[E] Endomorphism doesn't work with BSGS\n");
exit(EXIT_FAILURE);
}

if( FLAGBSGSMODE == MODE_BSGS && FLAGSTRIDE) {

fprintf(stderr,"[E] Stride doesn't work with BSGS\n");
exit(EXIT_FAILURE);
}
if(FLAGSTRIDE) {
if(str_stride[0] == '0' && str_stride[1] == 'x') {
stride.SetBase16(str_stride+2);
}
else{
stride.SetBase10(str_stride);
}
printf("[+] Stride : %s\n",stride.GetBase10());
}
else {
FLAGSTRIDE = 1;
stride.Set(&ONE);
}
init_generator();
if(FLAGMODE == MODE_BSGS ) {
printf("[+] Mode BSGS %s\n",bsgs_modes[FLAGBSGSMODE]);
}

if(FLAGFILE == 0) {
fileName =(char*) default_fileName;
}

if(FLAGMODE == MODE_ADDRESS && FLAGCRYPTO == CRYPTO_NONE) {//When none crypto

is defined the default search is for Bitcoin
FLAGCRYPTO = CRYPTO_BTC;
printf("[+] Setting search for btc adddress\n");
}
if(FLAGRANGE) {
n_range_start.SetBase16(range_start);
if(n_range_start.IsZero()) {
n_range_start.AddOne();
}
n_range_end.SetBase16(range_end);
if(n_range_start.IsEqual(&n_range_end) == false ) {
if( n_range_start.IsLower(&secp->order) &&
n_range_end.IsLowerOrEqual(&secp->order) ) {
if( n_range_start.IsGreater(&n_range_end)) {
fprintf(stderr,"[W] Opps, start range can't be great
than end range. Swapping them\n");
 n_range_aux.Set(&n_range_start);
n_range_start.Set(&n_range_end);
n_range_end.Set(&n_range_aux);
}
n_range_diff.Set(&n_range_end);
n_range_diff.Sub(&n_range_start);
}
else {
fprintf(stderr,"[E] Start and End range can't be great than
N\nFallback to random mode!\n");
FLAGRANGE = 0;
}
}
else {
fprintf(stderr,"[E] Start and End range can't be the same\
nFallback to random mode!\n");
FLAGRANGE = 0;
}
}
if(FLAGMODE != MODE_BSGS && FLAGMODE != MODE_MINIKEYS) {
BSGS_N.SetInt32(DEBUGCOUNT);
if(FLAGRANGE == 0 && FLAGBITRANGE == 0) {
n_range_start.SetInt32(1);
n_range_end.Set(&secp->order);
n_range_diff.Set(&n_range_end);
n_range_diff.Sub(&n_range_start);
}
else {
if(FLAGBITRANGE) {
n_range_start.SetBase16(bit_range_str_min);
n_range_end.SetBase16(bit_range_str_max);
n_range_diff.Set(&n_range_end);
n_range_diff.Sub(&n_range_start);
}
else {
if(FLAGRANGE == 0) {
fprintf(stderr,"[W] WTF!\n");
}
}
}
}
N = 0;

if(FLAGMODE != MODE_BSGS ) {
if(FLAG_N){
if(str_N[0] == '0' && str_N[1] == 'x') {
N_SEQUENTIAL_MAX =strtol(str_N,NULL,16);
}
else {
N_SEQUENTIAL_MAX =strtol(str_N,NULL,10);
}

if(N_SEQUENTIAL_MAX < 1024) {

fprintf(stderr,"[I] n value need to be equal or great than
1024, back to defaults\n");
FLAG_N = 0;
N_SEQUENTIAL_MAX = 0x100000000;
}
if(N_SEQUENTIAL_MAX % 1024 != 0) {
 fprintf(stderr,"[I] n value need to be multiplier of 1024\
n");
FLAG_N = 0;
N_SEQUENTIAL_MAX = 0x100000000;
}
}
printf("[+] N = %p\n",(void*)N_SEQUENTIAL_MAX);
if(FLAGMODE == MODE_MINIKEYS) {
BSGS_N.SetInt32(DEBUGCOUNT);
if(FLAGBASEMINIKEY) {
printf("[+] Base Minikey : %s\n",str_baseminikey);
}
minikeyN = (char*) malloc(22);
checkpointer((void
*)minikeyN,__FILE__,"malloc","minikeyN" ,__LINE__ -1);
i =0;
int58.SetInt32(58);
int_aux.SetInt64(N_SEQUENTIAL_MAX);
int_aux.Mult(253);
/* We get approximately one valid mini key for each 256
candidates mini keys since this is only statistics we multiply N_SEQUENTIAL_MAX by
253 to ensure not missed one one candidate minikey between threads... in this
approach we repeat from 1 to 3 candidates in each N_SEQUENTIAL_MAX cycle IF YOU
FOUND some other workaround please let me know */
i = 20;
salir = 0;
do {
if(!int_aux.IsZero()) {
int_r.Set(&int_aux);
int_r.Mod(&int58);
int_q.Set(&int_aux);
minikeyN[i] = (uint8_t)int_r.GetInt64();
int_q.Sub(&int_r);
int_q.Div(&int58);
int_aux.Set(&int_q);
i--;
}
else {
salir =1;
}
}while(!salir && i > 0);
minikey_n_limit = 21 -i;
}
else {
if(FLAGBITRANGE) { // Bit Range
printf("[+] Bit Range %i\n",bitrange);
}
else {
printf("[+] Range \n");
}
}
if(FLAGMODE != MODE_MINIKEYS) {
hextemp = n_range_start.GetBase16();
printf("[+] -- from : 0x%s\n",hextemp);
free(hextemp);
hextemp = n_range_end.GetBase16();
printf("[+] -- to : 0x%s\n",hextemp);
free(hextemp);
}
 switch(FLAGMODE) {
case MODE_MINIKEYS:
case MODE_RMD160:
case MODE_ADDRESS:
case MODE_XPOINT:
if(!readFileAddress(fileName)) {
fprintf(stderr,"[E] Unenexpected error\n");
exit(EXIT_FAILURE);
}
break;
case MODE_VANITY:
if(!readFileVanity(fileName)) {
fprintf(stderr,"[E] Unenexpected error\n");
exit(EXIT_FAILURE);
}
break;
}

if(FLAGMODE != MODE_VANITY && !FLAGREADEDFILE1) {

printf("[+] Sorting data ...");
_sort(addressTable,N);
printf(" done! %" PRIu64 " values were loaded and sorted\n",N);
writeFileIfNeeded(fileName);
}
}

if(FLAGMODE == MODE_BSGS ) {
printf("[+] Opening file %s\n",fileName);
fd = fopen(fileName,"rb");
if(fd == NULL) {
fprintf(stderr,"[E] Can't open file %s\n",fileName);
exit(EXIT_FAILURE);
}
aux = (char*) malloc(1024);
checkpointer((void *)aux,__FILE__,"malloc","aux" ,__LINE__ - 1);
while(!feof(fd)) {
if(fgets(aux,1022,fd) == aux) {
trim(aux," \t\n\r");
if(strlen(aux) >= 128) { //Length of a full address in
hexadecimal without 04
N++;
}else {
if(strlen(aux) >= 66) {
N++;
}
}
}
}
if(N == 0) {
fprintf(stderr,"[E] There is no valid data in the file\n");
exit(EXIT_FAILURE);
}
bsgs_found = (int*) calloc(N,sizeof(int));
checkpointer((void
*)bsgs_found,__FILE__,"calloc","bsgs_found" ,__LINE__ -1 );
OriginalPointsBSGS.reserve(N);
OriginalPointsBSGScompressed = (bool*) malloc(N*sizeof(bool));
checkpointer((void
*)OriginalPointsBSGScompressed,__FILE__,"malloc","OriginalPointsBSGScompressed" ,__
LINE__ -1 );
pointx_str = (char*) malloc(65);
checkpointer((void
*)pointx_str,__FILE__,"malloc","pointx_str" ,__LINE__ -1 );
pointy_str = (char*) malloc(65);
checkpointer((void
*)pointy_str,__FILE__,"malloc","pointy_str" ,__LINE__ -1 );
fseek(fd,0,SEEK_SET);
i = 0;
while(!feof(fd)) {
if(fgets(aux,1022,fd) == aux) {
trim(aux," \t\n\r");
if(strlen(aux) >= 66) {
stringtokenizer(aux,&tokenizerbsgs);
aux2 = nextToken(&tokenizerbsgs);
memset(pointx_str,0,65);
memset(pointy_str,0,65);
switch(strlen(aux2)) {
case 66: //Compress

if(secp-
>ParsePublicKeyHex(aux2,OriginalPointsBSGS[i],OriginalPointsBSGScompressed[i]))
{
i++;
}
else {
N--;
}

break;
case 130: //With the 04

if(secp-
>ParsePublicKeyHex(aux2,OriginalPointsBSGS[i],OriginalPointsBSGScompressed[i]))
{
i++;
}
else {
N--;
}

break;
default:
printf("Invalid length: %s\n",aux2);
N--;
break;
}
freetokenizer(&tokenizerbsgs);
}
}
}
fclose(fd);
bsgs_point_number = N;
if(bsgs_point_number > 0) {
printf("[+] Added %u points from file\n",bsgs_point_number);
}
else {
fprintf(stderr,"[E] The file don't have any valid publickeys\n");
 exit(EXIT_FAILURE);
}
BSGS_N.SetInt32(0);
BSGS_M.SetInt32(0);

BSGS_M.SetInt64(bsgs_m);

if(FLAG_N) { //Custom N by the -n param

/* Here we need to validate if the given string is a valid

hexadecimal number or a base 10 number*/

/* Now the conversion*/

if(str_N[0] == '0' && str_N[1] == 'x' ) { /*We expected a
hexadecimal value after 0x -> str_N +2 */
BSGS_N.SetBase16((char*)(str_N+2));
}
else {
BSGS_N.SetBase10(str_N);
}

}
else { //Default N
BSGS_N.SetInt64((uint64_t)0x100000000000);
}

if(BSGS_N.HasSqrt()) { //If the root is exact

BSGS_M.Set(&BSGS_N);
BSGS_M.ModSqrt();
}
else {
fprintf(stderr,"[E] -n param doesn't have exact square root\n");
exit(EXIT_FAILURE);
}

BSGS_AUX.Set(&BSGS_M);
BSGS_AUX.Mod(&BSGS_GROUP_SIZE);

if(!BSGS_AUX.IsZero()){ //If M is not divisible by BSGS_GROUP_SIZE

(1024)
hextemp = BSGS_GROUP_SIZE.GetBase10();
fprintf(stderr,"[E] M value is not divisible by %s\n",hextemp);
exit(EXIT_FAILURE);
}

bsgs_m = BSGS_M.GetInt64();

if(FLAGRANGE || FLAGBITRANGE) {
if(FLAGBITRANGE) { // Bit Range
n_range_start.SetBase16(bit_range_str_min);
n_range_end.SetBase16(bit_range_str_max);

n_range_diff.Set(&n_range_end);
n_range_diff.Sub(&n_range_start);
printf("[+] Bit Range %i\n",bitrange);
printf("[+] -- from : 0x%s\n",bit_range_str_min);
printf("[+] -- to : 0x%s\n",bit_range_str_max);
 }
else {
printf("[+] Range \n");
printf("[+] -- from : 0x%s\n",range_start);
printf("[+] -- to : 0x%s\n",range_end);
}
}
else { //Random start

n_range_start.SetInt32(1);
n_range_end.Set(&secp->order);
n_range_diff.Rand(&n_range_start,&n_range_end);
n_range_start.Set(&n_range_diff);
}
BSGS_CURRENT.Set(&n_range_start);

if(n_range_diff.IsLower(&BSGS_N) ) {
fprintf(stderr,"[E] the given range is small\n");
exit(EXIT_FAILURE);
}

/*
M 2199023255552
109951162777.6
M2 109951162778
5497558138.9
M3 5497558139
*/

BSGS_M.Mult((uint64_t)KFACTOR);
BSGS_AUX.SetInt32(32);
BSGS_R.Set(&BSGS_M);
BSGS_R.Mod(&BSGS_AUX);
BSGS_M2.Set(&BSGS_M);
BSGS_M2.Div(&BSGS_AUX);

if(!BSGS_R.IsZero()) { /* If BSGS_M modulo 32 is not 0*/

BSGS_M2.AddOne();
}

BSGS_M_double.SetInt32(2);
BSGS_M_double.Mult(&BSGS_M);

BSGS_M2_double.SetInt32(2);
BSGS_M2_double.Mult(&BSGS_M2);

BSGS_R.Set(&BSGS_M2);
BSGS_R.Mod(&BSGS_AUX);

BSGS_M3.Set(&BSGS_M2);
BSGS_M3.Div(&BSGS_AUX);

if(!BSGS_R.IsZero()) { /* If BSGS_M2 modulo 32 is not 0*/

BSGS_M3.AddOne();
}

BSGS_M3_double.SetInt32(2);
BSGS_M3_double.Mult(&BSGS_M3);

bsgs_m2 = BSGS_M2.GetInt64();
bsgs_m3 = BSGS_M3.GetInt64();

BSGS_AUX.Set(&BSGS_N);
BSGS_AUX.Div(&BSGS_M);

BSGS_R.Set(&BSGS_N);
BSGS_R.Mod(&BSGS_M);

if(!BSGS_R.IsZero()) { /* if BSGS_N modulo BSGS_M is not 0*/

BSGS_N.Set(&BSGS_M);
BSGS_N.Mult(&BSGS_AUX);
}

bsgs_m = BSGS_M.GetInt64();
bsgs_aux = BSGS_AUX.GetInt64();

BSGS_N_double.SetInt32(2);
BSGS_N_double.Mult(&BSGS_N);

hextemp = BSGS_N.GetBase16();
printf("[+] N = 0x%s\n",hextemp);
free(hextemp);
if(((uint64_t)(bsgs_m/256)) > 10000) {
itemsbloom = (uint64_t)(bsgs_m / 256);
if(bsgs_m % 256 != 0 ) {
itemsbloom++;
}
}
else{
itemsbloom = 1000;
}

if(((uint64_t)(bsgs_m2/256)) > 1000) {

itemsbloom2 = (uint64_t)(bsgs_m2 / 256);
if(bsgs_m2 % 256 != 0) {
itemsbloom2++;
}
}
else {
itemsbloom2 = 1000;
}

if(((uint64_t)(bsgs_m3/256)) > 1000) {

itemsbloom3 = (uint64_t)(bsgs_m3/256);
if(bsgs_m3 % 256 != 0 ) {
itemsbloom3++;
}
}
else {
itemsbloom3 = 1000;
}

printf("[+] Bloom filter for %" PRIu64 " elements ",bsgs_m);

bloom_bP = (struct bloom*)calloc(256,sizeof(struct bloom));
 checkpointer((void *)bloom_bP,__FILE__,"calloc","bloom_bP" ,__LINE__ -1
);
bloom_bP_checksums = (struct checksumsha256*)calloc(256,sizeof(struct
checksumsha256));
checkpointer((void
*)bloom_bP_checksums,__FILE__,"calloc","bloom_bP_checksums" ,__LINE__ -1 );

#if defined(_WIN64) && !defined(__CYGWIN__)

bloom_bP_mutex = (HANDLE*) calloc(256,sizeof(HANDLE));

#else
bloom_bP_mutex = (pthread_mutex_t*)
calloc(256,sizeof(pthread_mutex_t));
#endif
checkpointer((void
*)bloom_bP_mutex,__FILE__,"calloc","bloom_bP_mutex" ,__LINE__ -1 );

fflush(stdout);
bloom_bP_totalbytes = 0;
for(i=0; i< 256; i++) {
#if defined(_WIN64) && !defined(__CYGWIN__)
bloom_bP_mutex[i] = CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&bloom_bP_mutex[i],NULL);
#endif
if(bloom_init2(&bloom_bP[i],itemsbloom,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init _ [%" PRIu64 "]\n",i);
exit(EXIT_FAILURE);
}
bloom_bP_totalbytes += bloom_bP[i].bytes;
//if(FLAGDEBUG) bloom_print(&bloom_bP[i]);
}
printf(": %.2f
MB\n",(float)((float)(uint64_t)bloom_bP_totalbytes/(float)(uint64_t)1048576));

printf("[+] Bloom filter for %" PRIu64 " elements ",bsgs_m2);

#if defined(_WIN64) && !defined(__CYGWIN__)

bloom_bPx2nd_mutex = (HANDLE*) calloc(256,sizeof(HANDLE));
#else
bloom_bPx2nd_mutex = (pthread_mutex_t*)
calloc(256,sizeof(pthread_mutex_t));
#endif
checkpointer((void
*)bloom_bPx2nd_mutex,__FILE__,"calloc","bloom_bPx2nd_mutex" ,__LINE__ -1 );
bloom_bPx2nd = (struct bloom*)calloc(256,sizeof(struct bloom));
checkpointer((void
*)bloom_bPx2nd,__FILE__,"calloc","bloom_bPx2nd" ,__LINE__ -1 );
bloom_bPx2nd_checksums = (struct checksumsha256*)
calloc(256,sizeof(struct checksumsha256));
checkpointer((void
*)bloom_bPx2nd_checksums,__FILE__,"calloc","bloom_bPx2nd_checksums" ,__LINE__ -1 );
bloom_bP2_totalbytes = 0;
for(i=0; i< 256; i++) {
#if defined(_WIN64) && !defined(__CYGWIN__)
bloom_bPx2nd_mutex[i] = CreateMutex(NULL, FALSE, NULL);
#else
 pthread_mutex_init(&bloom_bPx2nd_mutex[i],NULL);
#endif
if(bloom_init2(&bloom_bPx2nd[i],itemsbloom2,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init _ [%" PRIu64 "]\n",i);
exit(EXIT_FAILURE);
}
bloom_bP2_totalbytes += bloom_bPx2nd[i].bytes;
//if(FLAGDEBUG) bloom_print(&bloom_bPx2nd[i]);
}
printf(": %.2f
MB\n",(float)((float)(uint64_t)bloom_bP2_totalbytes/(float)(uint64_t)1048576));

#if defined(_WIN64) && !defined(__CYGWIN__)

bloom_bPx3rd_mutex = (HANDLE*) calloc(256,sizeof(HANDLE));
#else
bloom_bPx3rd_mutex = (pthread_mutex_t*)
calloc(256,sizeof(pthread_mutex_t));
#endif
checkpointer((void
*)bloom_bPx3rd_mutex,__FILE__,"calloc","bloom_bPx3rd_mutex" ,__LINE__ -1 );
bloom_bPx3rd = (struct bloom*)calloc(256,sizeof(struct bloom));
checkpointer((void
*)bloom_bPx3rd,__FILE__,"calloc","bloom_bPx3rd" ,__LINE__ -1 );
bloom_bPx3rd_checksums = (struct checksumsha256*)
calloc(256,sizeof(struct checksumsha256));
checkpointer((void
*)bloom_bPx3rd_checksums,__FILE__,"calloc","bloom_bPx3rd_checksums" ,__LINE__ -1 );

printf("[+] Bloom filter for %" PRIu64 " elements ",bsgs_m3);

bloom_bP3_totalbytes = 0;
for(i=0; i< 256; i++) {
#if defined(_WIN64) && !defined(__CYGWIN__)
bloom_bPx3rd_mutex[i] = CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&bloom_bPx3rd_mutex[i],NULL);
#endif
if(bloom_init2(&bloom_bPx3rd[i],itemsbloom3,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init [%" PRIu64 "]\n",i);
exit(EXIT_FAILURE);
}
bloom_bP3_totalbytes += bloom_bPx3rd[i].bytes;
//if(FLAGDEBUG) bloom_print(&bloom_bPx3rd[i]);
}
printf(": %.2f
MB\n",(float)((float)(uint64_t)bloom_bP3_totalbytes/(float)(uint64_t)1048576));
//if(FLAGDEBUG) printf("[D] bloom_bP3_totalbytes : %" PRIu64 "\
n",bloom_bP3_totalbytes);

BSGS_MP = secp->ComputePublicKey(&BSGS_M);
BSGS_MP_double = secp->ComputePublicKey(&BSGS_M_double);
BSGS_MP2 = secp->ComputePublicKey(&BSGS_M2);
BSGS_MP2_double = secp->ComputePublicKey(&BSGS_M2_double);
BSGS_MP3 = secp->ComputePublicKey(&BSGS_M3);
BSGS_MP3_double = secp->ComputePublicKey(&BSGS_M3_double);
 BSGS_AMP2.reserve(32);
BSGS_AMP3.reserve(32);
GSn.reserve(CPU_GRP_SIZE/2);

i= 0;

/* New aMP table just to keep the same code of JLP */

/* Auxiliar Points to speed up calculations for the main bloom filter
check */
Point bsP = secp->Negation(BSGS_MP_double);
Point g = bsP;
GSn[0] = g;

g = secp->DoubleDirect(g);
GSn[1] = g;

for(int i = 2; i < CPU_GRP_SIZE / 2; i++) {

g = secp->AddDirect(g,bsP);
GSn[i] = g;
}

/* For next center point */

_2GSn = secp->DoubleDirect(GSn[CPU_GRP_SIZE / 2 - 1]);

i = 0;
point_temp.Set(BSGS_MP2);
BSGS_AMP2[0] = secp->Negation(point_temp);
BSGS_AMP2[0].Reduce();
point_temp.Set(BSGS_MP2_double);
point_temp = secp->Negation(point_temp);
point_temp.Reduce();

for(i = 1; i < 32; i++) {

BSGS_AMP2[i] = secp->AddDirect(BSGS_AMP2[i-1],point_temp);
BSGS_AMP2[i].Reduce();
}

i = 0;
point_temp.Set(BSGS_MP3);
BSGS_AMP3[0] = secp->Negation(point_temp);
BSGS_AMP3[0].Reduce();
point_temp.Set(BSGS_MP3_double);
point_temp = secp->Negation(point_temp);
point_temp.Reduce();

for(i = 1; i < 32; i++) {

BSGS_AMP3[i] = secp->AddDirect(BSGS_AMP3[i-1],point_temp);
BSGS_AMP3[i].Reduce();
}

bytes = (uint64_t)bsgs_m3 * (uint64_t) sizeof(struct bsgs_xvalue);

printf("[+] Allocating %.2f MB for %" PRIu64 " bP Points\n",(double)
(bytes/1048576),bsgs_m3);

bPtable = (struct bsgs_xvalue*) malloc(bytes);

checkpointer((void *)bPtable,__FILE__,"malloc","bPtable" ,__LINE__ -
1 );
memset(bPtable,0,bytes);
 if(FLAGSAVEREADFILE) {
/*Reading file for 1st bloom filter */

snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_4_%" PRIu64
".blm",bsgs_m);
fd_aux1 = fopen(buffer_bloom_file,"rb");
if(fd_aux1 != NULL) {
printf("[+] Reading bloom filter from file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
bf_ptr = (char*) bloom_bP[i].bf; /*We need to save
the current bf pointer*/
readed = fread(&bloom_bP[i],sizeof(struct
bloom),1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
bloom_bP[i].bf = (uint8_t*)bf_ptr; /* Restoring the
bf pointer*/
readed =
fread(bloom_bP[i].bf,bloom_bP[i].bytes,1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed = fread(&bloom_bP_checksums[i],sizeof(struct
checksumsha256),1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
if(FLAGSKIPCHECKSUM == 0) {

sha256((uint8_t*)bloom_bP[i].bf,bloom_bP[i].bytes,(uint8_t*)rawvalue);

if(memcmp(bloom_bP_checksums[i].data,rawvalue,32) != 0 ||
memcmp(bloom_bP_checksums[i].backup,rawvalue,32) != 0 ) { /* Verification */
fprintf(stderr,"[E] Error checksum file
mismatch! %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
if(i % 64 == 0 ) {
printf(".");
fflush(stdout);
}
}
printf(" Done!\n");
fclose(fd_aux1);
memset(buffer_bloom_file,0,1024);
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_3_%" PRIu64
".blm",bsgs_m);
fd_aux1 = fopen(buffer_bloom_file,"rb");
 if(fd_aux1 != NULL) {
printf("[W] Unused file detected %s you can delete it
without worry\n",buffer_bloom_file);
fclose(fd_aux1);
}
FLAGREADEDFILE1 = 1;
}
else { /*Checking for old file keyhunt_bsgs_3_ */
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_3_%" PRIu64
".blm",bsgs_m);
fd_aux1 = fopen(buffer_bloom_file,"rb");
if(fd_aux1 != NULL) {
printf("[+] Reading bloom filter from file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
bf_ptr = (char*) bloom_bP[i].bf; /*We need to
save the current bf pointer*/
readed = fread(&oldbloom_bP,sizeof(struct
oldbloom),1,fd_aux1);

/*
if(FLAGDEBUG) {
printf("old Bloom filter %i\n",i);
oldbloom_print(&oldbloom_bP);
}
*/

if(readed != 1) {
fprintf(stderr,"[E] Error reading the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
memcpy(&bloom_bP[i],&oldbloom_bP,sizeof(struct
bloom));//We only need to copy the part data to the new bloom size, not from the
old size
bloom_bP[i].bf = (uint8_t*)bf_ptr; /* Restoring
the bf pointer*/

readed =
fread(bloom_bP[i].bf,bloom_bP[i].bytes,1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}

memcpy(bloom_bP_checksums[i].data,oldbloom_bP.checksum,32);

memcpy(bloom_bP_checksums[i].backup,oldbloom_bP.checksum_backup,32);
memset(rawvalue,0,32);
if(FLAGSKIPCHECKSUM == 0) {

sha256((uint8_t*)bloom_bP[i].bf,bloom_bP[i].bytes,(uint8_t*)rawvalue);

if(memcmp(bloom_bP_checksums[i].data,rawvalue,32) != 0 ||
memcmp(bloom_bP_checksums[i].backup,rawvalue,32) != 0 ) { /* Verification */
fprintf(stderr,"[E] Error checksum
file mismatch! %s\n",buffer_bloom_file);
 exit(EXIT_FAILURE);
}
}
if(i % 32 == 0 ) {
printf(".");
fflush(stdout);
}
}
printf(" Done!\n");
fclose(fd_aux1);
FLAGUPDATEFILE1 = 1; /* Flag to migrate the data
to the new File keyhunt_bsgs_4_ */
FLAGREADEDFILE1 = 1;

}
else {
FLAGREADEDFILE1 = 0;
//Flag to make the new file
}
}

/*Reading file for 2nd bloom filter */

snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_6_%" PRIu64
".blm",bsgs_m2);
fd_aux2 = fopen(buffer_bloom_file,"rb");
if(fd_aux2 != NULL) {
printf("[+] Reading bloom filter from file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
bf_ptr = (char*) bloom_bPx2nd[i].bf; /*We need to
save the current bf pointer*/
readed = fread(&bloom_bPx2nd[i],sizeof(struct
bloom),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
bloom_bPx2nd[i].bf = (uint8_t*)bf_ptr; /* Restoring
the bf pointer*/
readed =
fread(bloom_bPx2nd[i].bf,bloom_bPx2nd[i].bytes,1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fread(&bloom_bPx2nd_checksums[i],sizeof(struct checksumsha256),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
memset(rawvalue,0,32);
if(FLAGSKIPCHECKSUM == 0) {
 sha256((uint8_t*)bloom_bPx2nd[i].bf,bloom_bPx2nd[i].bytes,
(uint8_t*)rawvalue);

if(memcmp(bloom_bPx2nd_checksums[i].data,rawvalue,32) != 0 ||
memcmp(bloom_bPx2nd_checksums[i].backup,rawvalue,32) != 0 ){ /*
Verification */
fprintf(stderr,"[E] Error checksum file
mismatch! %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
if(i % 64 == 0) {
printf(".");
fflush(stdout);
}
}
fclose(fd_aux2);
printf(" Done!\n");
memset(buffer_bloom_file,0,1024);
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_5_%" PRIu64
".blm",bsgs_m2);
fd_aux2 = fopen(buffer_bloom_file,"rb");
if(fd_aux2 != NULL) {
printf("[W] Unused file detected %s you can delete it
without worry\n",buffer_bloom_file);
fclose(fd_aux2);
}
memset(buffer_bloom_file,0,1024);
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_1_%" PRIu64
".blm",bsgs_m2);
fd_aux2 = fopen(buffer_bloom_file,"rb");
if(fd_aux2 != NULL) {
printf("[W] Unused file detected %s you can delete it
without worry\n",buffer_bloom_file);
fclose(fd_aux2);
}
FLAGREADEDFILE2 = 1;
}
else {
FLAGREADEDFILE2 = 0;
}

/*Reading file for bPtable */

snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_2_%" PRIu64
".tbl",bsgs_m3);
fd_aux3 = fopen(buffer_bloom_file,"rb");
if(fd_aux3 != NULL) {
printf("[+] Reading bP Table from file
%s .",buffer_bloom_file);
fflush(stdout);
rsize = fread(bPtable,bytes,1,fd_aux3);
if(rsize != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
rsize = fread(checksum,32,1,fd_aux3);
if(rsize != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
if(FLAGSKIPCHECKSUM == 0) {
sha256((uint8_t*)bPtable,bytes,
(uint8_t*)checksum_backup);
if(memcmp(checksum,checksum_backup,32) != 0) {
fprintf(stderr,"[E] Error checksum file
mismatch! %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
printf("... Done!\n");
fclose(fd_aux3);
FLAGREADEDFILE3 = 1;
}
else {
FLAGREADEDFILE3 = 0;
}

/*Reading file for 3rd bloom filter */

snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_7_%" PRIu64
".blm",bsgs_m3);
fd_aux2 = fopen(buffer_bloom_file,"rb");
if(fd_aux2 != NULL) {
printf("[+] Reading bloom filter from file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
bf_ptr = (char*) bloom_bPx3rd[i].bf; /*We need to
save the current bf pointer*/
readed = fread(&bloom_bPx3rd[i],sizeof(struct
bloom),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
bloom_bPx3rd[i].bf = (uint8_t*)bf_ptr; /* Restoring
the bf pointer*/
readed =
fread(bloom_bPx3rd[i].bf,bloom_bPx3rd[i].bytes,1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fread(&bloom_bPx3rd_checksums[i],sizeof(struct checksumsha256),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error reading the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
memset(rawvalue,0,32);
if(FLAGSKIPCHECKSUM == 0) {

sha256((uint8_t*)bloom_bPx3rd[i].bf,bloom_bPx3rd[i].bytes,
(uint8_t*)rawvalue);

if(memcmp(bloom_bPx3rd_checksums[i].data,rawvalue,32) != 0 ||
memcmp(bloom_bPx3rd_checksums[i].backup,rawvalue,32) != 0 ){ /*
Verification */
fprintf(stderr,"[E] Error checksum file
mismatch! %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
if(i % 64 == 0) {
printf(".");
fflush(stdout);
}
}
fclose(fd_aux2);
printf(" Done!\n");
FLAGREADEDFILE4 = 1;
}
else {
FLAGREADEDFILE4 = 0;
}

if(!FLAGREADEDFILE1 || !FLAGREADEDFILE2 || !FLAGREADEDFILE3 || !

FLAGREADEDFILE4) {
if(FLAGREADEDFILE1 == 1) {
/*
We need just to make File 2 to File 4 this is
- Second bloom filter 5%
- third bloom fitler 0.25 %
- bp Table 0.25 %
*/
printf("[I] We need to recalculate some files, don't worry
this is only 3%% of the previous work\n");
FINISHED_THREADS_COUNTER = 0;
FINISHED_THREADS_BP = 0;
FINISHED_ITEMS = 0;
salir = 0;
BASE = 0;
THREADCOUNTER = 0;
if(THREADBPWORKLOAD >= bsgs_m2) {
THREADBPWORKLOAD = bsgs_m2;
}
THREADCYCLES = bsgs_m2 / THREADBPWORKLOAD;
PERTHREAD_R = bsgs_m2 % THREADBPWORKLOAD;
if(PERTHREAD_R != 0) {
THREADCYCLES++;
}

printf("\r[+] processing %lu/%lu bP points : %i%%\

r",FINISHED_ITEMS,bsgs_m,(int) (((double)FINISHED_ITEMS/(double)bsgs_m)*100));
fflush(stdout);

#if defined(_WIN64) && !defined(__CYGWIN__)

tid = (HANDLE*)calloc(NTHREADS, sizeof(HANDLE));
checkpointer((void *)tid,__FILE__,"calloc","tid" ,__LINE__
-1 );
 bPload_mutex = (HANDLE*) calloc(NTHREADS,sizeof(HANDLE));
#else
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
bPload_mutex = (pthread_mutex_t*)
calloc(NTHREADS,sizeof(pthread_mutex_t));
#endif
checkpointer((void
*)bPload_mutex,__FILE__,"calloc","bPload_mutex" ,__LINE__ -1 );
bPload_temp_ptr = (struct bPload*)
calloc(NTHREADS,sizeof(struct bPload));
checkpointer((void
*)bPload_temp_ptr,__FILE__,"calloc","bPload_temp_ptr" ,__LINE__ -1 );
bPload_threads_available = (char*)
calloc(NTHREADS,sizeof(char));
checkpointer((void
*)bPload_threads_available,__FILE__,"calloc","bPload_threads_available" ,__LINE__ -
1 );

memset(bPload_threads_available,1,NTHREADS);

for(j = 0; j < NTHREADS; j++) {

#if defined(_WIN64) && !defined(__CYGWIN__)
bPload_mutex[j] = CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&bPload_mutex[j],NULL);
#endif
}

do {
for(j = 0; j < NTHREADS && !salir; j++) {

if(bPload_threads_available[j] && !salir) {

bPload_threads_available[j] = 0;
bPload_temp_ptr[j].from = BASE;
bPload_temp_ptr[j].threadid = j;
bPload_temp_ptr[j].finished = 0;
if( THREADCOUNTER < THREADCYCLES-1) {
bPload_temp_ptr[j].to = BASE +
THREADBPWORKLOAD;
bPload_temp_ptr[j].workload =
THREADBPWORKLOAD;
}
else {
bPload_temp_ptr[j].to = BASE +
THREADBPWORKLOAD + PERTHREAD_R;
bPload_temp_ptr[j].workload =
THREADBPWORKLOAD + PERTHREAD_R;
salir = 1;
}
#if defined(_WIN64) && !defined(__CYGWIN__)
tid[j] = CreateThread(NULL, 0,
thread_bPload_2blooms, (void*) &bPload_temp_ptr[j], 0, &s);
#else
s =
pthread_create(&tid[j],NULL,thread_bPload_2blooms,(void*) &bPload_temp_ptr[j]);
pthread_detach(tid[j]);
#endif
BASE+=THREADBPWORKLOAD;
THREADCOUNTER++;
 }
}

if(OLDFINISHED_ITEMS != FINISHED_ITEMS) {
printf("\r[+] processing %lu/%lu bP points : %i
%%\r",FINISHED_ITEMS,bsgs_m2,(int) (((double)FINISHED_ITEMS/(double)bsgs_m2)*100));
fflush(stdout);
OLDFINISHED_ITEMS = FINISHED_ITEMS;
}

for(j = 0 ; j < NTHREADS ; j++) {

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bPload_mutex[j], INFINITE);
finished = bPload_temp_ptr[j].finished;
ReleaseMutex(bPload_mutex[j]);
#else
pthread_mutex_lock(&bPload_mutex[j]);
finished = bPload_temp_ptr[j].finished;
pthread_mutex_unlock(&bPload_mutex[j]);
#endif
if(finished) {
bPload_temp_ptr[j].finished = 0;
bPload_threads_available[j] = 1;
FINISHED_ITEMS +=
bPload_temp_ptr[j].workload;
FINISHED_THREADS_COUNTER++;
}
}
}while(FINISHED_THREADS_COUNTER < THREADCYCLES);
printf("\r[+] processing %lu/%lu bP points : 100%% \
n",bsgs_m2,bsgs_m2);

free(tid);
free(bPload_mutex);
free(bPload_temp_ptr);
free(bPload_threads_available);
}
else{
/* We need just to do all the files
- first bllom filter 100%
- Second bloom filter 5%
- third bloom fitler 0.25 %
- bp Table 0.25 %
*/
FINISHED_THREADS_COUNTER = 0;
FINISHED_THREADS_BP = 0;
FINISHED_ITEMS = 0;
salir = 0;
BASE = 0;
THREADCOUNTER = 0;
if(THREADBPWORKLOAD >= bsgs_m) {
THREADBPWORKLOAD = bsgs_m;
}
THREADCYCLES = bsgs_m / THREADBPWORKLOAD;
PERTHREAD_R = bsgs_m % THREADBPWORKLOAD;
//if(FLAGDEBUG) printf("[D] THREADCYCLES: %lu\
n",THREADCYCLES);
if(PERTHREAD_R != 0) {
 THREADCYCLES++;
//if(FLAGDEBUG) printf("[D] PERTHREAD_R: %lu\
n",PERTHREAD_R);
}

printf("\r[+] processing %lu/%lu bP points : %i%%\

r",FINISHED_ITEMS,bsgs_m,(int) (((double)FINISHED_ITEMS/(double)bsgs_m)*100));
fflush(stdout);

#if defined(_WIN64) && !defined(__CYGWIN__)

tid = (HANDLE*)calloc(NTHREADS, sizeof(HANDLE));
bPload_mutex = (HANDLE*) calloc(NTHREADS,sizeof(HANDLE));
#else
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
bPload_mutex = (pthread_mutex_t*)
calloc(NTHREADS,sizeof(pthread_mutex_t));
#endif
checkpointer((void *)tid,__FILE__,"calloc","tid" ,__LINE__
-1 );
checkpointer((void
*)bPload_mutex,__FILE__,"calloc","bPload_mutex" ,__LINE__ -1 );

bPload_temp_ptr = (struct bPload*)

calloc(NTHREADS,sizeof(struct bPload));
checkpointer((void
*)bPload_temp_ptr,__FILE__,"calloc","bPload_temp_ptr" ,__LINE__ -1 );
bPload_threads_available = (char*)
calloc(NTHREADS,sizeof(char));
checkpointer((void
*)bPload_threads_available,__FILE__,"calloc","bPload_threads_available" ,__LINE__ -
1 );

memset(bPload_threads_available,1,NTHREADS);

for(j = 0; j < NTHREADS; j++) {

#if defined(_WIN64) && !defined(__CYGWIN__)
bPload_mutex = CreateMutex(NULL, FALSE, NULL);
#else
pthread_mutex_init(&bPload_mutex[j],NULL);
#endif
}

do {
for(j = 0; j < NTHREADS && !salir; j++) {

if(bPload_threads_available[j] && !salir) {

bPload_threads_available[j] = 0;
bPload_temp_ptr[j].from = BASE;
bPload_temp_ptr[j].threadid = j;
bPload_temp_ptr[j].finished = 0;
if( THREADCOUNTER < THREADCYCLES-1) {
bPload_temp_ptr[j].to = BASE +
THREADBPWORKLOAD;
bPload_temp_ptr[j].workload =
THREADBPWORKLOAD;
}
else {
bPload_temp_ptr[j].to = BASE +
THREADBPWORKLOAD + PERTHREAD_R;
bPload_temp_ptr[j].workload =
THREADBPWORKLOAD + PERTHREAD_R;
salir = 1;
//if(FLAGDEBUG) printf("[D] Salir
OK\n");
}
//if(FLAGDEBUG) printf("[I] %lu to %lu\
n",bPload_temp_ptr[i].from,bPload_temp_ptr[i].to);
#if defined(_WIN64) && !defined(__CYGWIN__)
tid[j] = CreateThread(NULL, 0,
thread_bPload, (void*) &bPload_temp_ptr[j], 0, &s);
#else
s =
pthread_create(&tid[j],NULL,thread_bPload,(void*) &bPload_temp_ptr[j]);
pthread_detach(tid[j]);
#endif
BASE+=THREADBPWORKLOAD;
THREADCOUNTER++;
}
}
if(OLDFINISHED_ITEMS != FINISHED_ITEMS) {
printf("\r[+] processing %lu/%lu bP points : %i
%%\r",FINISHED_ITEMS,bsgs_m,(int) (((double)FINISHED_ITEMS/(double)bsgs_m)*100));
fflush(stdout);
OLDFINISHED_ITEMS = FINISHED_ITEMS;
}

for(j = 0 ; j < NTHREADS ; j++) {

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bPload_mutex[j], INFINITE);
finished = bPload_temp_ptr[j].finished;
ReleaseMutex(bPload_mutex[j]);
#else
pthread_mutex_lock(&bPload_mutex[j]);
finished = bPload_temp_ptr[j].finished;
pthread_mutex_unlock(&bPload_mutex[j]);
#endif
if(finished) {
bPload_temp_ptr[j].finished = 0;
bPload_threads_available[j] = 1;
FINISHED_ITEMS +=
bPload_temp_ptr[j].workload;
FINISHED_THREADS_COUNTER++;
}
}

}while(FINISHED_THREADS_COUNTER < THREADCYCLES);

printf("\r[+] processing %lu/%lu bP points : 100%% \
n",bsgs_m,bsgs_m);

free(tid);
free(bPload_mutex);
free(bPload_temp_ptr);
free(bPload_threads_available);
}
}
 if(!FLAGREADEDFILE1 || !FLAGREADEDFILE2 || !FLAGREADEDFILE4) {
printf("[+] Making checkums .. ");
fflush(stdout);
}
if(!FLAGREADEDFILE1) {
for(i = 0; i < 256 ; i++) {
sha256((uint8_t*)bloom_bP[i].bf, bloom_bP[i].bytes,
(uint8_t*) bloom_bP_checksums[i].data);

memcpy(bloom_bP_checksums[i].backup,bloom_bP_checksums[i].data,32);
}
printf(".");
}
if(!FLAGREADEDFILE2) {
for(i = 0; i < 256 ; i++) {
sha256((uint8_t*)bloom_bPx2nd[i].bf, bloom_bPx2nd[i].bytes,
(uint8_t*) bloom_bPx2nd_checksums[i].data);

memcpy(bloom_bPx2nd_checksums[i].backup,bloom_bPx2nd_checksums[i].data,32);
}
printf(".");
}
if(!FLAGREADEDFILE4) {
for(i = 0; i < 256 ; i++) {
sha256((uint8_t*)bloom_bPx3rd[i].bf, bloom_bPx3rd[i].bytes,
(uint8_t*) bloom_bPx3rd_checksums[i].data);

memcpy(bloom_bPx3rd_checksums[i].backup,bloom_bPx3rd_checksums[i].data,32);
}
printf(".");
}
if(!FLAGREADEDFILE1 || !FLAGREADEDFILE2 || !FLAGREADEDFILE4) {
printf(" done\n");
fflush(stdout);
}
if(!FLAGREADEDFILE3) {
printf("[+] Sorting %lu elements... ",bsgs_m3);
fflush(stdout);
bsgs_sort(bPtable,bsgs_m3);
sha256((uint8_t*)bPtable, bytes,(uint8_t*) checksum);
memcpy(checksum_backup,checksum,32);
printf("Done!\n");
fflush(stdout);
}
if(FLAGSAVEREADFILE || FLAGUPDATEFILE1 ) {
if(!FLAGREADEDFILE1 || FLAGUPDATEFILE1) {
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_4_%" PRIu64
".blm",bsgs_m);

if(FLAGUPDATEFILE1) {
printf("[W] Updating old file into a new one\n");
}

/* Writing file for 1st bloom filter */

fd_aux1 = fopen(buffer_bloom_file,"wb");
if(fd_aux1 != NULL) {
printf("[+] Writing bloom filter to file %s
",buffer_bloom_file);
 fflush(stdout);
for(i = 0; i < 256;i++) {
readed = fwrite(&bloom_bP[i],sizeof(struct
bloom),1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s please delete it\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(bloom_bP[i].bf,bloom_bP[i].bytes,1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s please delete it\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(&bloom_bP_checksums[i],sizeof(struct checksumsha256),1,fd_aux1);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s please delete it\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
if(i % 64 == 0) {
printf(".");
fflush(stdout);
}
}
printf(" Done!\n");
fclose(fd_aux1);
}
else {
fprintf(stderr,"[E] Error can't create the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
if(!FLAGREADEDFILE2 ) {

snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_6_%" PRIu64
".blm",bsgs_m2);

/* Writing file for 2nd bloom filter */

fd_aux2 = fopen(buffer_bloom_file,"wb");
if(fd_aux2 != NULL) {
printf("[+] Writing bloom filter to file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
readed = fwrite(&bloom_bPx2nd[i],sizeof(struct
bloom),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(bloom_bPx2nd[i].bf,bloom_bPx2nd[i].bytes,1,fd_aux2);
if(readed != 1) {
 fprintf(stderr,"[E] Error writing the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(&bloom_bPx2nd_checksums[i],sizeof(struct checksumsha256),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s please delete it\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
if(i % 64 == 0) {
printf(".");
fflush(stdout);
}
}
printf(" Done!\n");
fclose(fd_aux2);
}
else {
fprintf(stderr,"[E] Error can't create the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}

if(!FLAGREADEDFILE3) {
/* Writing file for bPtable */
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_2_%" PRIu64
".tbl",bsgs_m3);
fd_aux3 = fopen(buffer_bloom_file,"wb");
if(fd_aux3 != NULL) {
printf("[+] Writing bP Table to file %s ..
",buffer_bloom_file);
fflush(stdout);
readed = fwrite(bPtable,bytes,1,fd_aux3);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed = fwrite(checksum,32,1,fd_aux3);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
printf("Done!\n");
fclose(fd_aux3);
}
else {
fprintf(stderr,"[E] Error can't create the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
if(!FLAGREADEDFILE4) {
snprintf(buffer_bloom_file,1024,"keyhunt_bsgs_7_%" PRIu64
".blm",bsgs_m3);
 /* Writing file for 3rd bloom filter */
fd_aux2 = fopen(buffer_bloom_file,"wb");
if(fd_aux2 != NULL) {
printf("[+] Writing bloom filter to file %s
",buffer_bloom_file);
fflush(stdout);
for(i = 0; i < 256;i++) {
readed = fwrite(&bloom_bPx3rd[i],sizeof(struct
bloom),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(bloom_bPx3rd[i].bf,bloom_bPx3rd[i].bytes,1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
readed =
fwrite(&bloom_bPx3rd_checksums[i],sizeof(struct checksumsha256),1,fd_aux2);
if(readed != 1) {
fprintf(stderr,"[E] Error writing the
file %s please delete it\n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
if(i % 64 == 0) {
printf(".");
fflush(stdout);
}
}
printf(" Done!\n");
fclose(fd_aux2);
}
else {
fprintf(stderr,"[E] Error can't create the file %s\
n",buffer_bloom_file);
exit(EXIT_FAILURE);
}
}
}

i = 0;

steps = (uint64_t *) calloc(NTHREADS,sizeof(uint64_t));

checkpointer((void *)steps,__FILE__,"calloc","steps" ,__LINE__ -1 );
ends = (unsigned int *) calloc(NTHREADS,sizeof(int));
checkpointer((void *)ends,__FILE__,"calloc","ends" ,__LINE__ -1 );
#if defined(_WIN64) && !defined(__CYGWIN__)
tid = (HANDLE*)calloc(NTHREADS, sizeof(HANDLE));
#else
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
#endif
checkpointer((void *)tid,__FILE__,"calloc","tid" ,__LINE__ -1 );
 for(j= 0;j < NTHREADS; j++) {
tt = (tothread*) malloc(sizeof(struct tothread));
checkpointer((void *)tt,__FILE__,"malloc","tt" ,__LINE__ -1 );
tt->nt = j;
steps[j] = 0;
s = 0;
switch(FLAGBSGSMODE) {
#if defined(_WIN64) && !defined(__CYGWIN__)
case 0:
tid[j] = CreateThread(NULL, 0, thread_process_bsgs,
(void*)tt, 0, &s);
break;
case 1:
tid[j] = CreateThread(NULL, 0,
thread_process_bsgs_backward, (void*)tt, 0, &s);
break;
case 2:
tid[j] = CreateThread(NULL, 0,
thread_process_bsgs_both, (void*)tt, 0, &s);
break;
case 3:
tid[j] = CreateThread(NULL, 0,
thread_process_bsgs_random, (void*)tt, 0, &s);
break;
case 4:
tid[j] = CreateThread(NULL, 0,
thread_process_bsgs_dance, (void*)tt, 0, &s);
break;
}
#else
case 0:
s = pthread_create(&tid[j],NULL,thread_process_bsgs,
(void *)tt);
break;
case 1:
s =
pthread_create(&tid[j],NULL,thread_process_bsgs_backward,(void *)tt);
break;
case 2:
s =
pthread_create(&tid[j],NULL,thread_process_bsgs_both,(void *)tt);
break;
case 3:
s =
pthread_create(&tid[j],NULL,thread_process_bsgs_random,(void *)tt);
break;
case 4:
s =
pthread_create(&tid[j],NULL,thread_process_bsgs_dance,(void *)tt);
break;
#endif
}
#if defined(_WIN64) && !defined(__CYGWIN__)
if (tid[j] == NULL) {
#else
if(s != 0) {
#endif
fprintf(stderr,"[E] thread thread_process\n");
exit(EXIT_FAILURE);
 }
}
free(aux);
}
if(FLAGMODE != MODE_BSGS) {
steps = (uint64_t *) calloc(NTHREADS,sizeof(uint64_t));
checkpointer((void *)steps,__FILE__,"calloc","steps" ,__LINE__ -1 );
ends = (unsigned int *) calloc(NTHREADS,sizeof(int));
checkpointer((void *)ends,__FILE__,"calloc","ends" ,__LINE__ -1 );
#if defined(_WIN64) && !defined(__CYGWIN__)
tid = (HANDLE*)calloc(NTHREADS, sizeof(HANDLE));
#else
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
#endif
checkpointer((void *)tid,__FILE__,"calloc","tid" ,__LINE__ -1 );
for(j= 0;j < NTHREADS; j++) {
tt = (tothread*) malloc(sizeof(struct tothread));
checkpointer((void *)tt,__FILE__,"malloc","tt" ,__LINE__ -1 );
tt->nt = j;
steps[j] = 0;
s = 0;
switch(FLAGMODE) {
#if defined(_WIN64) && !defined(__CYGWIN__)
case MODE_ADDRESS:
case MODE_XPOINT:
case MODE_RMD160:
tid[j] = CreateThread(NULL, 0, thread_process,
(void*)tt, 0, &s);
break;
case MODE_MINIKEYS:
tid[j] = CreateThread(NULL, 0,
thread_process_minikeys, (void*)tt, 0, &s);
break;
case MODE_VANITY:
tid[j] = CreateThread(NULL, 0, thread_process_vanity,
(void*)tt, 0, &s);
break;
#else
case MODE_ADDRESS:
case MODE_XPOINT:
case MODE_RMD160:
s = pthread_create(&tid[j],NULL,thread_process,(void
*)tt);
break;
case MODE_MINIKEYS:
s =
pthread_create(&tid[j],NULL,thread_process_minikeys,(void *)tt);
break;
case MODE_VANITY:
s =
pthread_create(&tid[j],NULL,thread_process_vanity,(void *)tt);
break;
#endif
}
if(s != 0) {
fprintf(stderr,"[E] pthread_create thread_process\n");
exit(EXIT_FAILURE);
}
}
 }

for(j =0; j < 7; j++) {

int_limits[j].SetBase10((char*)str_limits[j]);
}

continue_flag = 1;
total.SetInt32(0);
pretotal.SetInt32(0);
debugcount_mpz.Set(&BSGS_N);
seconds.SetInt32(0);
do {
sleep_ms(1000);
seconds.AddOne();
check_flag = 1;
for(j = 0; j <NTHREADS && check_flag; j++) {
check_flag &= ends[j];
}
if(check_flag) {
continue_flag = 0;
}
if(OUTPUTSECONDS.IsGreater(&ZERO) ){
MPZAUX.Set(&seconds);
MPZAUX.Mod(&OUTPUTSECONDS);
if(MPZAUX.IsZero()) {
total.SetInt32(0);
for(j = 0; j < NTHREADS; j++) {
pretotal.Set(&debugcount_mpz);
pretotal.Mult(steps[j]);
total.Add(&pretotal);
}

if(FLAGENDOMORPHISM) {
if(FLAGMODE == MODE_XPOINT) {
total.Mult(3);
}
else {
total.Mult(6);
}
}
else {
if(FLAGSEARCH == SEARCH_COMPRESS) {
total.Mult(2);
}
}

#ifdef _WIN64
WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif
pretotal.Set(&total);
pretotal.Div(&seconds);
str_seconds = seconds.GetBase10();
str_pretotal = pretotal.GetBase10();
str_total = total.GetBase10();

if(pretotal.IsLower(&int_limits[0])) {
 if(FLAGMATRIX) {
sprintf(buffer,"[+] Total %s keys in %s
seconds: %s keys/s\n",str_total,str_seconds,str_pretotal);
}
else {
sprintf(buffer,"\r[+] Total %s keys in %s
seconds: %s keys/s\r",str_total,str_seconds,str_pretotal);
}
}
else {
i = 0;
salir = 0;
while( i < 6 && !salir) {
if(pretotal.IsLower(&int_limits[i+1])) {
salir = 1;
}
else {
i++;
}
}

div_pretotal.Set(&pretotal);
div_pretotal.Div(&int_limits[salir ? i : i-1]);
str_divpretotal = div_pretotal.GetBase10();
if(FLAGMATRIX) {
sprintf(buffer,"[+] Total %s keys in %s
seconds: ~%s %s (%s keys/s)\
n",str_total,str_seconds,str_divpretotal,str_limits_prefixs[salir ? i : i-
1],str_pretotal);
}
else {
if(THREADOUTPUT == 1) {
sprintf(buffer,"\r[+] Total %s keys in %s
seconds: ~%s %s (%s keys/s)\
r",str_total,str_seconds,str_divpretotal,str_limits_prefixs[salir ? i : i-
1],str_pretotal);
}
else {
sprintf(buffer,"\r[+] Total %s keys in %s
seconds: ~%s %s (%s keys/s)\
r",str_total,str_seconds,str_divpretotal,str_limits_prefixs[salir ? i : i-
1],str_pretotal);
}
}
free(str_divpretotal);

}
printf("%s",buffer);
fflush(stdout);
THREADOUTPUT = 0;
#ifdef _WIN64
ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif

free(str_seconds);
free(str_pretotal);
free(str_total);
 }
}
}while(continue_flag);
printf("\nEnd\n");
#ifdef _WIN64
CloseHandle(write_keys);
CloseHandle(write_random);
CloseHandle(bsgs_thread);
#endif
}

void pubkeytopubaddress_dst(char *pkey,int length,char *dst) {

char digest[60];
size_t pubaddress_size = 40;
sha256((uint8_t*)pkey, length,(uint8_t*) digest);
RMD160Data((const unsigned char*)digest,32, digest+1);
digest[0] = 0;
sha256((uint8_t*)digest, 21,(uint8_t*) digest+21);
sha256((uint8_t*)digest+21, 32,(uint8_t*) digest+21);
if(!b58enc(dst,&pubaddress_size,digest,25)){
fprintf(stderr,"error b58enc\n");
}
}

void rmd160toaddress_dst(char *rmd,char *dst){

char digest[60];
size_t pubaddress_size = 40;
digest[0] = byte_encode_crypto;
memcpy(digest+1,rmd,20);
sha256((uint8_t*)digest, 21,(uint8_t*) digest+21);
sha256((uint8_t*)digest+21, 32,(uint8_t*) digest+21);
if(!b58enc(dst,&pubaddress_size,digest,25)){
fprintf(stderr,"error b58enc\n");
}
}

char *pubkeytopubaddress(char *pkey,int length) {

char *pubaddress = (char*) calloc(MAXLENGTHADDRESS+10,1);
char *digest = (char*) calloc(60,1);
size_t pubaddress_size = MAXLENGTHADDRESS+10;
checkpointer((void *)pubaddress,__FILE__,"malloc","pubaddress" ,__LINE__ -
1 );
checkpointer((void *)digest,__FILE__,"malloc","digest" ,__LINE__ -1 );
//digest [000...0]
sha256((uint8_t*)pkey, length,(uint8_t*) digest);
//digest [SHA256 32 bytes+000....0]
RMD160Data((const unsigned char*)digest,32, digest+1);
//digest [? +RMD160 20 bytes+????000....0]
digest[0] = 0;
//digest [0 +RMD160 20 bytes+????000....0]
sha256((uint8_t*)digest, 21,(uint8_t*) digest+21);
//digest [0 +RMD160 20 bytes+SHA256 32 bytes+....0]
sha256((uint8_t*)digest+21, 32,(uint8_t*) digest+21);
//digest [0 +RMD160 20 bytes+SHA256 32 bytes+....0]
if(!b58enc(pubaddress,&pubaddress_size,digest,25)){
fprintf(stderr,"error b58enc\n");
}
free(digest);
 return pubaddress; // pubaddress need to be free by te caller funtion
}

int searchbinary(struct address_value *buffer,char *data,int64_t array_length) {

int64_t half,min,max,current;
int r = 0,rcmp;
min = 0;
current = 0;
max = array_length;
half = array_length;
while(!r && half >= 1) {
half = (max - min)/2;
rcmp = memcmp(data,buffer[current+half].value,20);
if(rcmp == 0) {
r = 1; //Found!!
}
else {
if(rcmp < 0) { //data < temp_read
max = (max-half);
}
else { // data > temp_read
min = (min+half);
}
current = min;
}
}
return r;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_minikeys(LPVOID vargp) {
#else
void *thread_process_minikeys(void *vargp) {
#endif
FILE *keys;
Point publickey[4];
Int key_mpz[4];
struct tothread *tt;
uint64_t count;
char publickeyhashrmd160_uncompress[4][20];
char public_key_uncompressed_hex[131];
char address[4][40],minikey[4][24],minikeys[8]
[24],buffer_b58[21],minikey2check[24],rawvalue[4][32];
char *hextemp,*rawbuffer;
int r,thread_number,continue_flag = 1,k,j,count_valid;
Int counter;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
rawbuffer = (char*) &counter.bits64;
count_valid = 0;
for(k = 0; k < 4; k++) {
minikey[k][0] = 'S';
minikey[k][22] = '?';
minikey[k][23] = 0x00;
}
minikey2check[0] = 'S';
minikey2check[22] = '?';
minikey2check[23] = 0x00;
 do {
if(FLAGRANDOM) {
counter.Rand(256);
for(k = 0; k < 21; k++) {
buffer_b58[k] =(uint8_t)((uint8_t) rawbuffer[k] % 58);
}
}
else {
if(FLAGBASEMINIKEY) {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_random, INFINITE);
memcpy(buffer_b58,raw_baseminikey,21);
increment_minikey_N(raw_baseminikey);
ReleaseMutex(write_random);
#else
pthread_mutex_lock(&write_random);
memcpy(buffer_b58,raw_baseminikey,21);
increment_minikey_N(raw_baseminikey);
pthread_mutex_unlock(&write_random);
#endif
}
else {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_random, INFINITE);
#else
pthread_mutex_lock(&write_random);
#endif
if(raw_baseminikey == NULL){
raw_baseminikey = (char *) malloc(22);
checkpointer((void
*)raw_baseminikey,__FILE__,"malloc","raw_baseminikey" ,__LINE__ -1 );
counter.Rand(256);
for(k = 0; k < 21; k++) {
raw_baseminikey[k] =(uint8_t)((uint8_t)
rawbuffer[k] % 58);
}
memcpy(buffer_b58,raw_baseminikey,21);
increment_minikey_N(raw_baseminikey);

}
else {
memcpy(buffer_b58,raw_baseminikey,21);
increment_minikey_N(raw_baseminikey);
}
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_random);
#else
pthread_mutex_unlock(&write_random);
#endif

}
}
set_minikey(minikey2check+1,buffer_b58,21);
if(continue_flag) {
count = 0;
if(FLAGMATRIX) {
printf("[+] Base minikey: %s \n",minikey2check);
fflush(stdout);
 }
else {
if(!FLAGQUIET) {
printf("\r[+] Base minikey: %s \
r",minikey2check);
fflush(stdout);
}
}
do {
for(j = 0;j<256; j++) {

if(count_valid > 0) {
for(k = 0; k < count_valid ; k++) {
memcpy(minikeys[k],minikeys[4+k],22);
}
}
do {

increment_minikey_index(minikey2check+1,buffer_b58,20);
memcpy(minikey[0]+1,minikey2check+1,21);

increment_minikey_index(minikey2check+1,buffer_b58,20);
memcpy(minikey[1]+1,minikey2check+1,21);

increment_minikey_index(minikey2check+1,buffer_b58,20);
memcpy(minikey[2]+1,minikey2check+1,21);

increment_minikey_index(minikey2check+1,buffer_b58,20);
memcpy(minikey[3]+1,minikey2check+1,21);

sha256sse_23((uint8_t*)minikey[0],
(uint8_t*)minikey[1],(uint8_t*)minikey[2],(uint8_t*)minikey[3],
(uint8_t*)rawvalue[0],(uint8_t*)rawvalue[1],(uint8_t*)rawvalue[2],
(uint8_t*)rawvalue[3]);
for(k = 0; k < 4; k++){
if(rawvalue[k][0] == 0x00) {

memcpy(minikeys[count_valid],minikey[k],22);
count_valid++;
}
}
}while(count_valid < 4);
count_valid-=4;
sha256sse_22((uint8_t*)minikeys[0],
(uint8_t*)minikeys[1],(uint8_t*)minikeys[2],(uint8_t*)minikeys[3],
(uint8_t*)rawvalue[0],(uint8_t*)rawvalue[1],(uint8_t*)rawvalue[2],
(uint8_t*)rawvalue[3]);

for(k = 0; k < 4; k++) {

key_mpz[k].Set32Bytes((uint8_t*)rawvalue[k]);
publickey[k] = secp-
>ComputePublicKey(&key_mpz[k]);
}

secp-
>GetHash160(P2PKH,false,publickey[0],publickey[1],publickey[2],publickey[3],
(uint8_t*)publickeyhashrmd160_uncompress[0],
(uint8_t*)publickeyhashrmd160_uncompress[1],
(uint8_t*)publickeyhashrmd160_uncompress[2],
(uint8_t*)publickeyhashrmd160_uncompress[3]);

for(k = 0; k < 4; k++) {

r =
bloom_check(&bloom,publickeyhashrmd160_uncompress[k],20);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_uncompress[k],N);
if(r) {
/* hit */
hextemp = key_mpz[k].GetBase16();
secp-
>GetPublicKeyHex(false,publickey[k],public_key_uncompressed_hex);
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_keys,
INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif

keys =
fopen("KEYFOUNDKEYFOUND.txt","a+");

rmd160toaddress_dst(publickeyhashrmd160_uncompress[k],address[k]);
minikeys[k][22] = '\0';
if(keys != NULL) {
fprintf(keys,"Private Key:
%s\npubkey: %s\nminikey: %s\naddress: %s\
n",hextemp,public_key_uncompressed_hex,minikeys[k],address[k]);
fclose(keys);
}
printf("\nHIT!! Private Key: %s\
npubkey: %s\nminikey: %s\naddress: %s\
n",hextemp,public_key_uncompressed_hex,minikeys[k],address[k]);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif

free(hextemp);
}
}
}
}
steps[thread_number]++;
count+=1024;
}while(count < N_SEQUENTIAL_MAX && continue_flag);
}
}while(continue_flag);
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process(LPVOID vargp) {
#else
void *thread_process(void *vargp) {
#endif
 struct tothread *tt;
Point pts[CPU_GRP_SIZE];
Point endomorphism_beta[CPU_GRP_SIZE];
Point endomorphism_beta2[CPU_GRP_SIZE];
Point endomorphism_negeted_point[4];

Int dx[CPU_GRP_SIZE / 2 + 1];

IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);
Point startP;
Int dy;
Int dyn;
Int _s;
Int _p;
Point pp;
Point pn;
int i,l,pp_offset,pn_offset,hLength = (CPU_GRP_SIZE / 2 - 1);
uint64_t j,count;
Point R,temporal,publickey;
int r,thread_number,continue_flag = 1,k;
char *hextemp = NULL;

char publickeyhashrmd160[20];
char publickeyhashrmd160_uncompress[4][20];
char rawvalue[32];

char publickeyhashrmd160_endomorphism[12][4][20];

bool calculate_y = FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH ==

SEARCH_BOTH || FLAGCRYPTO == CRYPTO_ETH;
Int key_mpz,keyfound,temp_stride;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
grp->Set(dx);

do {
if(FLAGRANDOM){
key_mpz.Rand(&n_range_start,&n_range_end);
}
else {
if(n_range_start.IsLower(&n_range_end)) {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_random, INFINITE);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SEQUENTIAL_MAX);
ReleaseMutex(write_random);
#else
pthread_mutex_lock(&write_random);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SEQUENTIAL_MAX);
pthread_mutex_unlock(&write_random);
#endif
}
else {
continue_flag = 0;
}
}
if(continue_flag) {
count = 0;
 if(FLAGMATRIX) {
hextemp = key_mpz.GetBase16();
printf("Base key: %s thread %i\
n",hextemp,thread_number);
fflush(stdout);
free(hextemp);
}
else {
if(FLAGQUIET == 0){
hextemp = key_mpz.GetBase16();
printf("\rBase key: %s \r",hextemp);
fflush(stdout);
free(hextemp);
THREADOUTPUT = 1;
}
}
do {
temp_stride.SetInt32(CPU_GRP_SIZE / 2);
temp_stride.Mult(&stride);
key_mpz.Add(&temp_stride);
startP = secp->ComputePublicKey(&key_mpz);
key_mpz.Sub(&temp_stride);

for(i = 0; i < hLength; i++) {

dx[i].ModSub(&Gn[i].x,&startP.x);
}

dx[i].ModSub(&Gn[i].x,&startP.x); // For the first point

dx[i + 1].ModSub(&_2Gn.x,&startP.x); // For the next center
point
grp->ModInv();

pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&Gn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&Gn[i].x); // rx = pow2(s) -
p1.x - p2.x;

if(calculate_y) {
pp.y.ModSub(&Gn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&Gn[i].y); // ry = - p2.y
- s*(ret.x-p2.x);
}

// P = startP - i*G , if (x,y) = i*G then (x,-y) = -

i*G
 dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x); // rx = pow2(s) -
p1.x - p2.x;

if(calculate_y) {
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y); // ry = - p2.y
- s*(ret.x-p2.x);
}

pp_offset = CPU_GRP_SIZE / 2 + (i + 1);

pn_offset = CPU_GRP_SIZE / 2 - (i + 1);

pts[pp_offset] = pp;
pts[pn_offset] = pn;

if(FLAGENDOMORPHISM) {
/*
Q = (x,y)
For any point Q
Q*lambda = (x*beta mod p ,y)
Q*lambda is a Scalar Multiplication
x*beta is just a Multiplication (Very
fast)
*/

if( calculate_y ) {

endomorphism_beta[pp_offset].y.Set(&pp.y);

endomorphism_beta[pn_offset].y.Set(&pn.y);

endomorphism_beta2[pp_offset].y.Set(&pp.y);

endomorphism_beta2[pn_offset].y.Set(&pn.y);
}
endomorphism_beta[pp_offset].x.ModMulK1(&pp.x,
&beta);
endomorphism_beta[pn_offset].x.ModMulK1(&pn.x,
&beta);
endomorphism_beta2[pp_offset].x.ModMulK1(&pp.x,
&beta2);
endomorphism_beta2[pn_offset].x.ModMulK1(&pn.x,
&beta2);
}
}
/*
Half point for endomorphism because
pts[CPU_GRP_SIZE / 2] was not calcualte in the previous cycle
*/
 if(FLAGENDOMORPHISM) {
if( calculate_y ) {

endomorphism_beta[CPU_GRP_SIZE /
2].y.Set(&pts[CPU_GRP_SIZE / 2].y);
endomorphism_beta2[CPU_GRP_SIZE /
2].y.Set(&pts[CPU_GRP_SIZE / 2].y);
}
endomorphism_beta[CPU_GRP_SIZE /
2].x.ModMulK1(&pts[CPU_GRP_SIZE / 2].x, &beta);
endomorphism_beta2[CPU_GRP_SIZE /
2].x.ModMulK1(&pts[CPU_GRP_SIZE / 2].x, &beta2);
}

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x);

if(calculate_y) {
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y);
}

pts[0] = pn;

/*
First point for endomorphism because pts[0] was not
calcualte previously
*/
if(FLAGENDOMORPHISM) {
if( calculate_y ) {
endomorphism_beta[0].y.Set(&pn.y);
endomorphism_beta2[0].y.Set(&pn.y);
}
endomorphism_beta[0].x.ModMulK1(&pn.x, &beta);
endomorphism_beta2[0].x.ModMulK1(&pn.x, &beta2);
}

for(j = 0; j < CPU_GRP_SIZE/4;j++){

switch(FLAGMODE) {
case MODE_RMD160:
case MODE_ADDRESS:
if(FLAGCRYPTO == CRYPTO_BTC){

if(FLAGSEARCH == SEARCH_COMPRESS ||
FLAGSEARCH == SEARCH_BOTH ){
if(FLAGENDOMORPHISM) {
secp-
>GetHash160_fromX(P2PKH,0x02,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[0][0],
(uint8_t*)publickeyhashrmd160_endomorphism[0][1],
(uint8_t*)publickeyhashrmd160_endomorphism[0][2],
(uint8_t*)publickeyhashrmd160_endomorphism[0][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[1][0],
(uint8_t*)publickeyhashrmd160_endomorphism[1][1],
(uint8_t*)publickeyhashrmd160_endomorphism[1][2],
(uint8_t*)publickeyhashrmd160_endomorphism[1][3]);

secp-
>GetHash160_fromX(P2PKH,0x02,&endomorphism_beta[(j*4)].x,&endomorphism_beta[(j*4)+1
].x,&endomorphism_beta[(j*4)+2].x,&endomorphism_beta[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[2][0],
(uint8_t*)publickeyhashrmd160_endomorphism[2][1],
(uint8_t*)publickeyhashrmd160_endomorphism[2][2],
(uint8_t*)publickeyhashrmd160_endomorphism[2][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&endomorphism_beta[(j*4)].x,&endomorphism_beta[(j*4)+1
].x,&endomorphism_beta[(j*4)+2].x,&endomorphism_beta[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[3][0],
(uint8_t*)publickeyhashrmd160_endomorphism[3][1],
(uint8_t*)publickeyhashrmd160_endomorphism[3][2],
(uint8_t*)publickeyhashrmd160_endomorphism[3][3]);

secp-
>GetHash160_fromX(P2PKH,0x02,&endomorphism_beta2[(j*4)].x,&endomorphism_beta2[(j*4)
+1].x,&endomorphism_beta2[(j*4)+2].x,&endomorphism_beta2[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[4][0],
(uint8_t*)publickeyhashrmd160_endomorphism[4][1],
(uint8_t*)publickeyhashrmd160_endomorphism[4][2],
(uint8_t*)publickeyhashrmd160_endomorphism[4][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&endomorphism_beta2[(j*4)].x,&endomorphism_beta2[(j*4)
+1].x,&endomorphism_beta2[(j*4)+2].x,&endomorphism_beta2[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[5][0],
(uint8_t*)publickeyhashrmd160_endomorphism[5][1],
(uint8_t*)publickeyhashrmd160_endomorphism[5][2],
(uint8_t*)publickeyhashrmd160_endomorphism[5][3]);
}
else {
secp-
>GetHash160_fromX(P2PKH,0x02,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[0][0],
(uint8_t*)publickeyhashrmd160_endomorphism[0][1],
(uint8_t*)publickeyhashrmd160_endomorphism[0][2],
(uint8_t*)publickeyhashrmd160_endomorphism[0][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[1][0],
(uint8_t*)publickeyhashrmd160_endomorphism[1][1],
(uint8_t*)publickeyhashrmd160_endomorphism[1][2],
(uint8_t*)publickeyhashrmd160_endomorphism[1][3]);
}

}
if(FLAGSEARCH == SEARCH_UNCOMPRESS
|| FLAGSEARCH == SEARCH_BOTH){
 if(FLAGENDOMORPHISM) {
for(l = 0; l < 4; l++)
{

endomorphism_negeted_point[l] = secp->Negation(pts[(j*4)+l]);
}
secp-
>GetHash160(P2PKH,false, pts[(j*4)], pts[(j*4)+1], pts[(j*4)+2], pts[(j*4)+3],
(uint8_t*)publickeyhashrmd160_endomorphism[6][0],
(uint8_t*)publickeyhashrmd160_endomorphism[6][1],
(uint8_t*)publickeyhashrmd160_endomorphism[6][2],
(uint8_t*)publickeyhashrmd160_endomorphism[6][3]);
secp-
>GetHash160(P2PKH,false,endomorphism_negeted_point[0] ,endomorphism_negeted_point[1
],endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[7][0],
(uint8_t*)publickeyhashrmd160_endomorphism[7][1],
(uint8_t*)publickeyhashrmd160_endomorphism[7][2],
(uint8_t*)publickeyhashrmd160_endomorphism[7][3]);
for(l = 0; l < 4; l++)
{

endomorphism_negeted_point[l] = secp->Negation(endomorphism_beta[(j*4)+l]);
}
secp-
>GetHash160(P2PKH,false,endomorphism_beta[(j*4)], endomorphism_beta[(j*4)+1],
endomorphism_beta[(j*4)+2], endomorphism_beta[(j*4)+3] ,
(uint8_t*)publickeyhashrmd160_endomorphism[8][0],
(uint8_t*)publickeyhashrmd160_endomorphism[8][1],
(uint8_t*)publickeyhashrmd160_endomorphism[8][2],
(uint8_t*)publickeyhashrmd160_endomorphism[8][3]);
secp-
>GetHash160(P2PKH,false,endomorphism_negeted_point[0],endomorphism_negeted_point[1]
,endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[9][0],
(uint8_t*)publickeyhashrmd160_endomorphism[9][1],
(uint8_t*)publickeyhashrmd160_endomorphism[9][2],
(uint8_t*)publickeyhashrmd160_endomorphism[9][3]);

for(l = 0; l < 4; l++)

{

endomorphism_negeted_point[l] = secp->Negation(endomorphism_beta2[(j*4)+l]);
}
secp-
>GetHash160(P2PKH,false, endomorphism_beta2[(j*4)], endomorphism_beta2[(j*4)+1] ,
endomorphism_beta2[(j*4)+2] , endomorphism_beta2[(j*4)+3] ,
(uint8_t*)publickeyhashrmd160_endomorphism[10][0],
(uint8_t*)publickeyhashrmd160_endomorphism[10][1],
(uint8_t*)publickeyhashrmd160_endomorphism[10][2],
(uint8_t*)publickeyhashrmd160_endomorphism[10][3]);
secp-
>GetHash160(P2PKH,false, endomorphism_negeted_point[0],
endomorphism_negeted_point[1],
endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[11][0],
(uint8_t*)publickeyhashrmd160_endomorphism[11][1],
(uint8_t*)publickeyhashrmd160_endomorphism[11][2],
(uint8_t*)publickeyhashrmd160_endomorphism[11][3]);
 }
else {
secp-
>GetHash160(P2PKH,false,pts[(j*4)],pts[(j*4)+1],pts[(j*4)+2],pts[(j*4)+3],
(uint8_t*)publickeyhashrmd160_uncompress[0],
(uint8_t*)publickeyhashrmd160_uncompress[1],
(uint8_t*)publickeyhashrmd160_uncompress[2],
(uint8_t*)publickeyhashrmd160_uncompress[3]);

}
}
}

else if(FLAGCRYPTO == CRYPTO_ETH){

if(FLAGENDOMORPHISM) {
for(k = 0; k < 4;k++) {

endomorphism_negeted_point[k] = secp->Negation(pts[(j*4)+k]);

generate_binaddress_eth(pts[(4*j)+k],
(uint8_t*)publickeyhashrmd160_endomorphism[0][k]);

generate_binaddress_eth(endomorphism_negeted_point[k],
(uint8_t*)publickeyhashrmd160_endomorphism[1][k]);

endomorphism_negeted_point[k] = secp->Negation(endomorphism_beta[(j*4)+k]);

generate_binaddress_eth(endomorphism_beta[(4*j)+k],
(uint8_t*)publickeyhashrmd160_endomorphism[2][k]);

generate_binaddress_eth(endomorphism_negeted_point[k],
(uint8_t*)publickeyhashrmd160_endomorphism[3][k]);

endomorphism_negeted_point[k] = secp->Negation(endomorphism_beta2[(j*4)+k]);

generate_binaddress_eth(endomorphism_beta[(4*j)+k],
(uint8_t*)publickeyhashrmd160_endomorphism[4][k]);

generate_binaddress_eth(endomorphism_negeted_point[k],
(uint8_t*)publickeyhashrmd160_endomorphism[5][k]);
}
}
else {
for(k = 0; k < 4;k++) {

generate_binaddress_eth(pts[(4*j)+k],
(uint8_t*)publickeyhashrmd160_uncompress[k]);
}
}

}
break;
}

switch(FLAGMODE) {
case MODE_RMD160:
case MODE_ADDRESS:
 if( FLAGCRYPTO == CRYPTO_BTC) {

for(k = 0; k < 4;k++) {

if(FLAGSEARCH ==
SEARCH_COMPRESS || FLAGSEARCH == SEARCH_BOTH){
if(FLAGENDOMORPHISM)
{
for(l = 0;l < 6;
l++) {
r =
bloom_check(&bloom,publickeyhashrmd160_endomorphism[l][k],MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_endomorphism[l][k],N);
if(r)
{

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

publickey = secp->ComputePublicKey(&keyfound);

switch(l) {

case 0: //Original point, prefix 02

if(publickey.y.IsOdd()) { //if the current publickey is odd that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 02

break;

case 1: //Original point, prefix 03

if(publickey.y.IsEven()) { //if the current publickey is even

that means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 03

break;
 case 2: //Beta point, prefix 02

keyfound.ModMulK1order(&lambda);

if(publickey.y.IsOdd()) { //if the current publickey is odd that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 02

break;

case 3: //Beta point, prefix 03

keyfound.ModMulK1order(&lambda);

if(publickey.y.IsEven()) { //if the current publickey is even

that means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 02

break;

case 4: //Beta^2 point, prefix 02

keyfound.ModMulK1order(&lambda2);

if(publickey.y.IsOdd()) { //if the current publickey is odd that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 02

break;

case 5: //Beta^2 point, prefix 03

keyfound.ModMulK1order(&lambda2);
 if(publickey.y.IsEven()) { //if the current publickey is even
that means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);

// else we dont need to chage the current keyfound because it already

have prefix 02

break;

writekey(true,&keyfound);
}
}
}
}
else {
for(l = 0;l < 2;
l++) {
r =
bloom_check(&bloom,publickeyhashrmd160_endomorphism[l][k],MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_endomorphism[l][k],N);
if(r)
{

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

publickey = secp->ComputePublicKey(&keyfound);

secp->GetHash160(P2PKH,true,publickey,(uint8_t*)publickeyhashrmd160);

if(memcmp(publickeyhashrmd160_endomorphism[l][k],publickeyhashrmd160,20) !=
0) {

keyfound.Neg();

keyfound.Add(&secp->order);

writekey(true,&keyfound);
}
}
}
}
}
 if(FLAGSEARCH ==
SEARCH_UNCOMPRESS || FLAGSEARCH == SEARCH_BOTH) {
if(FLAGENDOMORPHISM)
{
for(l = 6;l < 12;
l++) { //We check the array from 6 to 12(excluded) because we save the
uncompressed information there
r =
bloom_check(&bloom,publickeyhashrmd160_endomorphism[l][k],MAXLENGTHADDRESS);
//Check in Bloom filter
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_endomorphism[l][k],N);
//Check in Array using Binary search
if(r)
{

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

switch(l) {

case 6:

case 7:

publickey = secp->ComputePublicKey(&keyfound);

secp->GetHash160(P2PKH,false,publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);

break;

case 8:

case 9:

keyfound.ModMulK1order(&lambda);

publickey = secp->ComputePublicKey(&keyfound);

secp->GetHash160(P2PKH,false,publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){
 keyfound.Neg();

keyfound.Add(&secp->order);

break;

case 10:

case 11:

keyfound.ModMulK1order(&lambda2);

publickey = secp->ComputePublicKey(&keyfound);

secp->GetHash160(P2PKH,false,publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);

break;

writekey(false,&keyfound);
}
}
}
}
else {
r =
bloom_check(&bloom,publickeyhashrmd160_uncompress[k],MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_uncompress[k],N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

writekey(false,&keyfound);
}
}
}
}
}
}
else if( FLAGCRYPTO == CRYPTO_ETH) {
 if(FLAGENDOMORPHISM) {
for(k = 0; k < 4;k++) {
for(l = 0;l < 6; l++)
{
r =
bloom_check(&bloom,publickeyhashrmd160_endomorphism[l][k],MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_endomorphism[l][k],N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

switch(l) {

case 0:

case 1:

publickey = secp->ComputePublicKey(&keyfound);

generate_binaddress_eth(publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);

break;

case 2:

case 3:

keyfound.ModMulK1order(&lambda);

publickey = secp->ComputePublicKey(&keyfound);

generate_binaddress_eth(publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);

}
 break;

case 4:

case 5:

keyfound.ModMulK1order(&lambda2);

publickey = secp->ComputePublicKey(&keyfound);

generate_binaddress_eth(publickey,
(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);

break;
}

writekeyeth(&keyfound);

}
}
}
}
}
else {
for(k = 0; k < 4;k++) {
r =
bloom_check(&bloom,publickeyhashrmd160_uncompress[k],MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,publickeyhashrmd160_uncompress[k],N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

writekeyeth(&keyfound);
}
}
}
}
}
break;
case MODE_XPOINT:
for(k = 0; k < 4;k++) {
if(FLAGENDOMORPHISM) {
pts[(4*j)
+k].x.Get32Bytes((unsigned char *)rawvalue);
r =
bloom_check(&bloom,rawvalue,MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,rawvalue,N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

writekey(false,&keyfound);
}
}

endomorphism_beta[(j*4)+k].x.Get32Bytes((unsigned char *)rawvalue);

r =
bloom_check(&bloom,rawvalue,MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,rawvalue,N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

keyfound.ModMulK1order(&lambda);

writekey(false,&keyfound);
}
}

endomorphism_beta2[(j*4)+k].x.Get32Bytes((unsigned char *)rawvalue);

r =
bloom_check(&bloom,rawvalue,MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,rawvalue,N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

keyfound.ModMulK1order(&lambda2);

writekey(false,&keyfound);
}
 }
}
else {
pts[(4*j)
+k].x.Get32Bytes((unsigned char *)rawvalue);
r =
bloom_check(&bloom,rawvalue,MAXLENGTHADDRESS);
if(r) {
r =
searchbinary(addressTable,rawvalue,N);
if(r) {

keyfound.SetInt32(k);

keyfound.Mult(&stride);

keyfound.Add(&key_mpz);

writekey(false,&keyfound);
}
}
}
}
break;
}
count+=4;
temp_stride.SetInt32(4);
temp_stride.Mult(&stride);
key_mpz.Add(&temp_stride);
}
/*
if(FLAGDEBUG) {
printf("\n[D] thread_process %i\n",__LINE__ -1 );
fflush(stdout);
}
*/

steps[thread_number]++;

// Next start point (startP + GRP_SIZE*G)

pp = startP;
dy.ModSub(&_2Gn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2Gn.x);

//The Y value for the next start point always need to be

calculated
pp.y.ModSub(&_2Gn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2Gn.y);
startP = pp;
}while(count < N_SEQUENTIAL_MAX && continue_flag);
}
 } while(continue_flag);
ends[thread_number] = 1;
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_vanity(LPVOID vargp) {
#else
void *thread_process_vanity(void *vargp) {
#endif
struct tothread *tt;
Point pts[CPU_GRP_SIZE];
Point endomorphism_beta[CPU_GRP_SIZE];
Point endomorphism_beta2[CPU_GRP_SIZE];
Point endomorphism_negeted_point[4];

Int dx[CPU_GRP_SIZE / 2 + 1];

IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);

Point startP;
Int dy;
Int dyn;
Int _s;
Int _p;
Point pp; //point positive
Point pn; //point negative
int l,pp_offset,pn_offset,i,hLength = (CPU_GRP_SIZE / 2 - 1);
uint64_t j,count;
Point R,temporal,publickey;
int thread_number,continue_flag = 1,k;
char *hextemp = NULL;
char publickeyhashrmd160[20];
char publickeyhashrmd160_uncompress[4][20];

char publickeyhashrmd160_endomorphism[12][4][20];

Int key_mpz,temp_stride,keyfound;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
grp->Set(dx);

//if FLAGENDOMORPHISM == 1 and only compress search is enabled then there is

no need to calculate the Y value value

bool calculate_y = FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH ==

SEARCH_BOTH;

/*
if(FLAGDEBUG && thread_number == 0) {
printf("[D] vanity_rmd_targets = %i fillllll\
n",vanity_rmd_targets);
printf("[D] vanity_rmd_total = %i\n",vanity_rmd_total);
for(i =0; i < vanity_rmd_targets;i++) {
printf("[D] vanity_rmd_limits[%li] = %i\
n",i,vanity_rmd_limits[i]);
 }
printf("[D] vanity_rmd_minimun_bytes_check_length = %i\
n",vanity_rmd_minimun_bytes_check_length);
}
*/

do {
if(FLAGRANDOM){
key_mpz.Rand(&n_range_start,&n_range_end);
}
else {
if(n_range_start.IsLower(&n_range_end)) {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_random, INFINITE);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SEQUENTIAL_MAX);
ReleaseMutex(write_random);
#else
pthread_mutex_lock(&write_random);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SEQUENTIAL_MAX);
pthread_mutex_unlock(&write_random);
#endif
}
else {
continue_flag = 0;
}
}
if(continue_flag) {
count = 0;
if(FLAGMATRIX) {
hextemp = key_mpz.GetBase16();
printf("Base key: %s thread %i\
n",hextemp,thread_number);
fflush(stdout);
free(hextemp);
}
else {
if(FLAGQUIET == 0) {
hextemp = key_mpz.GetBase16();
printf("\rBase key: %s \r",hextemp);
fflush(stdout);
free(hextemp);
THREADOUTPUT = 1;
}
}
do {
temp_stride.SetInt32(CPU_GRP_SIZE / 2);
temp_stride.Mult(&stride);
key_mpz.Add(&temp_stride);
startP = secp->ComputePublicKey(&key_mpz);
key_mpz.Sub(&temp_stride);

for(i = 0; i < hLength; i++) {

dx[i].ModSub(&Gn[i].x,&startP.x);
}

dx[i].ModSub(&Gn[i].x,&startP.x); // For the first point

 dx[i + 1].ModSub(&_2Gn.x,&startP.x); // For the next center
point
grp->ModInv();

pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&Gn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&Gn[i].x); // rx = pow2(s) -
p1.x - p2.x;

if(calculate_y) {
pp.y.ModSub(&Gn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&Gn[i].y); // ry = - p2.y
- s*(ret.x-p2.x);
}

// P = startP - i*G , if (x,y) = i*G then (x,-y) = -

i*G
dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x); // rx = pow2(s) -
p1.x - p2.x;

if( calculate_y ) {
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y); // ry = - p2.y
- s*(ret.x-p2.x);
}
pp_offset = CPU_GRP_SIZE / 2 + (i + 1);
pn_offset = CPU_GRP_SIZE / 2 - (i + 1);

pts[pp_offset] = pp;
pts[pn_offset] = pn;

if(FLAGENDOMORPHISM) {
/*
Q = (x,y)
For any point Q
 Q*lambda = (x*beta mod p ,y)
Q*lambda is a Scalar Multiplication
x*beta is just a Multiplication (Very
fast)
*/

if( calculate_y ) {

endomorphism_beta[pp_offset].y.Set(&pp.y);

endomorphism_beta[pn_offset].y.Set(&pn.y);

endomorphism_beta2[pp_offset].y.Set(&pp.y);

endomorphism_beta2[pn_offset].y.Set(&pn.y);
}
endomorphism_beta[pp_offset].x.ModMulK1(&pp.x,
&beta);
endomorphism_beta[pn_offset].x.ModMulK1(&pn.x,
&beta);
endomorphism_beta2[pp_offset].x.ModMulK1(&pp.x,
&beta2);
endomorphism_beta2[pn_offset].x.ModMulK1(&pn.x,
&beta2);
}
}
/*
Half point for endomorphism because
pts[CPU_GRP_SIZE / 2] was not calcualte in the previous cycle
*/
if(FLAGENDOMORPHISM) {
if( calculate_y ) {

endomorphism_beta[CPU_GRP_SIZE /
2].y.Set(&pts[CPU_GRP_SIZE / 2].y);
endomorphism_beta2[CPU_GRP_SIZE /
2].y.Set(&pts[CPU_GRP_SIZE / 2].y);
}
endomorphism_beta[CPU_GRP_SIZE /
2].x.ModMulK1(&pts[CPU_GRP_SIZE / 2].x, &beta);
endomorphism_beta2[CPU_GRP_SIZE /
2].x.ModMulK1(&pts[CPU_GRP_SIZE / 2].x, &beta2);
}

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x);

if(calculate_y ) {
pn.y.ModSub(&Gn[i].x,&pn.x);
 pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y);
}
pts[0] = pn;

/*
First point for endomorphism because pts[0] was not
calcualte previously
*/
if(FLAGENDOMORPHISM) {
if( calculate_y ) {
endomorphism_beta[0].y.Set(&pn.y);
endomorphism_beta2[0].y.Set(&pn.y);
}
endomorphism_beta[0].x.ModMulK1(&pn.x, &beta);
endomorphism_beta2[0].x.ModMulK1(&pn.x, &beta2);
}

for(j = 0; j < CPU_GRP_SIZE/4;j++) {

if(FLAGSEARCH == SEARCH_COMPRESS || FLAGSEARCH ==
SEARCH_BOTH ){
if(FLAGENDOMORPHISM) {
secp-
>GetHash160_fromX(P2PKH,0x02,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[0][0],
(uint8_t*)publickeyhashrmd160_endomorphism[0][1],
(uint8_t*)publickeyhashrmd160_endomorphism[0][2],
(uint8_t*)publickeyhashrmd160_endomorphism[0][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[1][0],
(uint8_t*)publickeyhashrmd160_endomorphism[1][1],
(uint8_t*)publickeyhashrmd160_endomorphism[1][2],
(uint8_t*)publickeyhashrmd160_endomorphism[1][3]);

secp-
>GetHash160_fromX(P2PKH,0x02,&endomorphism_beta[(j*4)].x,&endomorphism_beta[(j*4)+1
].x,&endomorphism_beta[(j*4)+2].x,&endomorphism_beta[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[2][0],
(uint8_t*)publickeyhashrmd160_endomorphism[2][1],
(uint8_t*)publickeyhashrmd160_endomorphism[2][2],
(uint8_t*)publickeyhashrmd160_endomorphism[2][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&endomorphism_beta[(j*4)].x,&endomorphism_beta[(j*4)+1
].x,&endomorphism_beta[(j*4)+2].x,&endomorphism_beta[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[3][0],
(uint8_t*)publickeyhashrmd160_endomorphism[3][1],
(uint8_t*)publickeyhashrmd160_endomorphism[3][2],
(uint8_t*)publickeyhashrmd160_endomorphism[3][3]);

secp-
>GetHash160_fromX(P2PKH,0x02,&endomorphism_beta2[(j*4)].x,&endomorphism_beta2[(j*4)
+1].x,&endomorphism_beta2[(j*4)+2].x,&endomorphism_beta2[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[4][0],
(uint8_t*)publickeyhashrmd160_endomorphism[4][1],
(uint8_t*)publickeyhashrmd160_endomorphism[4][2],
(uint8_t*)publickeyhashrmd160_endomorphism[4][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&endomorphism_beta2[(j*4)].x,&endomorphism_beta2[(j*4)
+1].x,&endomorphism_beta2[(j*4)+2].x,&endomorphism_beta2[(j*4)+3].x,
(uint8_t*)publickeyhashrmd160_endomorphism[5][0],
(uint8_t*)publickeyhashrmd160_endomorphism[5][1],
(uint8_t*)publickeyhashrmd160_endomorphism[5][2],
(uint8_t*)publickeyhashrmd160_endomorphism[5][3]);

}
else {
secp-
>GetHash160_fromX(P2PKH,0x02,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[0][0],
(uint8_t*)publickeyhashrmd160_endomorphism[0][1],
(uint8_t*)publickeyhashrmd160_endomorphism[0][2],
(uint8_t*)publickeyhashrmd160_endomorphism[0][3]);
secp-
>GetHash160_fromX(P2PKH,0x03,&pts[(j*4)].x,&pts[(j*4)+1].x,&pts[(j*4)+2].x,&pts[(j*
4)+3].x,(uint8_t*)publickeyhashrmd160_endomorphism[1][0],
(uint8_t*)publickeyhashrmd160_endomorphism[1][1],
(uint8_t*)publickeyhashrmd160_endomorphism[1][2],
(uint8_t*)publickeyhashrmd160_endomorphism[1][3]);
}
}
if(FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH ==
SEARCH_BOTH) {
if(FLAGENDOMORPHISM) {
for(l = 0; l < 4; l++) {
endomorphism_negeted_point[l] =
secp->Negation(pts[(j*4)+l]);
}
secp->GetHash160(P2PKH,false, pts[(j*4)],
pts[(j*4)+1], pts[(j*4)+2], pts[(j*4)+3],
(uint8_t*)publickeyhashrmd160_endomorphism[6][0],
(uint8_t*)publickeyhashrmd160_endomorphism[6][1],
(uint8_t*)publickeyhashrmd160_endomorphism[6][2],
(uint8_t*)publickeyhashrmd160_endomorphism[6][3]);
secp-
>GetHash160(P2PKH,false,endomorphism_negeted_point[0] ,endomorphism_negeted_point[1
],endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[7][0],
(uint8_t*)publickeyhashrmd160_endomorphism[7][1],
(uint8_t*)publickeyhashrmd160_endomorphism[7][2],
(uint8_t*)publickeyhashrmd160_endomorphism[7][3]);
for(l = 0; l < 4; l++) {
endomorphism_negeted_point[l] =
secp->Negation(endomorphism_beta[(j*4)+l]);
}
secp-
>GetHash160(P2PKH,false,endomorphism_beta[(j*4)], endomorphism_beta[(j*4)+1],
endomorphism_beta[(j*4)+2], endomorphism_beta[(j*4)+3] ,
(uint8_t*)publickeyhashrmd160_endomorphism[8][0],
(uint8_t*)publickeyhashrmd160_endomorphism[8][1],
(uint8_t*)publickeyhashrmd160_endomorphism[8][2],
(uint8_t*)publickeyhashrmd160_endomorphism[8][3]);
secp-
>GetHash160(P2PKH,false,endomorphism_negeted_point[0],endomorphism_negeted_point[1]
,endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[9][0],
(uint8_t*)publickeyhashrmd160_endomorphism[9][1],
(uint8_t*)publickeyhashrmd160_endomorphism[9][2],
(uint8_t*)publickeyhashrmd160_endomorphism[9][3]);

for(l = 0; l < 4; l++) {

endomorphism_negeted_point[l] =
secp->Negation(endomorphism_beta2[(j*4)+l]);
}
secp->GetHash160(P2PKH,false,
endomorphism_beta2[(j*4)], endomorphism_beta2[(j*4)+1] ,
endomorphism_beta2[(j*4)+2] , endomorphism_beta2[(j*4)+3] ,
(uint8_t*)publickeyhashrmd160_endomorphism[10][0],
(uint8_t*)publickeyhashrmd160_endomorphism[10][1],
(uint8_t*)publickeyhashrmd160_endomorphism[10][2],
(uint8_t*)publickeyhashrmd160_endomorphism[10][3]);
secp->GetHash160(P2PKH,false,
endomorphism_negeted_point[0], endomorphism_negeted_point[1],
endomorphism_negeted_point[2],endomorphism_negeted_point[3],
(uint8_t*)publickeyhashrmd160_endomorphism[11][0],
(uint8_t*)publickeyhashrmd160_endomorphism[11][1],
(uint8_t*)publickeyhashrmd160_endomorphism[11][2],
(uint8_t*)publickeyhashrmd160_endomorphism[11][3]);
}
else {
secp-
>GetHash160(P2PKH,false,pts[(j*4)],pts[(j*4)+1],pts[(j*4)+2],pts[(j*4)+3],
(uint8_t*)publickeyhashrmd160_uncompress[0],
(uint8_t*)publickeyhashrmd160_uncompress[1],
(uint8_t*)publickeyhashrmd160_uncompress[2],
(uint8_t*)publickeyhashrmd160_uncompress[3]);

}
}
for(k = 0; k < 4;k++) {
if(FLAGSEARCH == SEARCH_COMPRESS || FLAGSEARCH
== SEARCH_BOTH ){
if(FLAGENDOMORPHISM) {
for(l = 0;l < 6; l++) {

if(vanityrmdmatch((uint8_t*)publickeyhashrmd160_endomorphism[l][k])) {
// Here the given
publickeyhashrmd160 match againts one of the vanity targets
// We need to check
which of the cases is it.

keyfound.SetInt32(k);
keyfound.Mult(&stride);
keyfound.Add(&key_mpz);
publickey = secp-
>ComputePublicKey(&keyfound);

switch(l) {
case 0:
//Original point, prefix 02

if(publickey.y.IsOdd()) { //if the current publickey is odd that means,

we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
 }
// else we
dont need to chage the current keyfound because it already have prefix 02
break;
case 1:
//Original point, prefix 03

if(publickey.y.IsEven()) { //if the current publickey is even that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
}
// else we
dont need to chage the current keyfound because it already have prefix 03
break;
case 2: //Beta
point, prefix 02

keyfound.ModMulK1order(&lambda);

if(publickey.y.IsOdd()) { //if the current publickey is odd that means,

we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
}
// else we
dont need to chage the current keyfound because it already have prefix 02
break;
case 3: //Beta
point, prefix 03

keyfound.ModMulK1order(&lambda);

if(publickey.y.IsEven()) { //if the current publickey is even that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
}
// else we
dont need to chage the current keyfound because it already have prefix 02
break;
case 4:
//Beta^2 point, prefix 02

keyfound.ModMulK1order(&lambda2);

if(publickey.y.IsOdd()) { //if the current publickey is odd that means,

we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
}
 // else we
dont need to chage the current keyfound because it already have prefix 02
break;
case 5:
//Beta^2 point, prefix 03

keyfound.ModMulK1order(&lambda2);

if(publickey.y.IsEven()) { //if the current publickey is even that

means, we need to negate the keyfound to get the correct key

keyfound.Neg();

keyfound.Add(&secp->order);
}
// else we
dont need to chage the current keyfound because it already have prefix 02
break;
}

writevanitykey(true,&keyfound);
}
}
}
else {
for(l = 0;l < 2; l++) {

if(vanityrmdmatch((uint8_t*)publickeyhashrmd160_endomorphism[l][k])) {
keyfound.SetInt32(k);
keyfound.Mult(&stride);
keyfound.Add(&key_mpz);

publickey = secp-
>ComputePublicKey(&keyfound);
secp-
>GetHash160(P2PKH,true,publickey,(uint8_t*)publickeyhashrmd160);

if(memcmp(publickeyhashrmd160_endomorphism[l][k],publickeyhashrmd160,20) !=
0){
keyfound.Neg();

keyfound.Add(&secp->order);
//if(FLAGDEBUG)
printf("[D] Key need to be negated\n");
}

writevanitykey(true,&keyfound);
}
}

}
}
if(FLAGSEARCH == SEARCH_UNCOMPRESS ||
FLAGSEARCH == SEARCH_BOTH) {
if(FLAGENDOMORPHISM) {
for(l = 6;l < 12; l++) {

if(vanityrmdmatch((uint8_t*)publickeyhashrmd160_endomorphism[l][k])) {
// Here the given
publickeyhashrmd160 match againts one of the vanity targets
// We need to check
which of the cases is it.

//rmd160toaddress_dst(publickeyhashrmd160_endomorphism[l][k],address);
keyfound.SetInt32(k);
keyfound.Mult(&stride);
keyfound.Add(&key_mpz);

switch(l) {
case 6:
case 7:
publickey =
secp->ComputePublicKey(&keyfound);
secp-
>GetHash160(P2PKH,false,publickey,(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);
}
break;
case 8:
case 9:

keyfound.ModMulK1order(&lambda);
publickey =
secp->ComputePublicKey(&keyfound);
secp-
>GetHash160(P2PKH,false,publickey,(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);
}
break;
case 10:
case 11:

keyfound.ModMulK1order(&lambda2);
publickey =
secp->ComputePublicKey(&keyfound);
secp-
>GetHash160(P2PKH,false,publickey,(uint8_t*)publickeyhashrmd160_uncompress[0]);

if(memcmp(publickeyhashrmd160_endomorphism[l]
[k],publickeyhashrmd160_uncompress[0],20) != 0){

keyfound.Neg();

keyfound.Add(&secp->order);
 }
break;
}

writevanitykey(false,&keyfound);
}
}

}
else {

if(vanityrmdmatch((uint8_t*)publickeyhashrmd160_uncompress[k])) {
keyfound.SetInt32(k);
keyfound.Mult(&stride);
keyfound.Add(&key_mpz);

writevanitykey(false,&keyfound);
}
}
}

count+=4;
temp_stride.SetInt32(4);
temp_stride.Mult(&stride);
key_mpz.Add(&temp_stride);
}
steps[thread_number]++;

// Next start point (startP + GRP_SIZE*G)

pp = startP;
dy.ModSub(&_2Gn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2Gn.x);

//The Y value for the next start point always need to be

calculated
pp.y.ModSub(&_2Gn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2Gn.y);
startP = pp;
}while(count < N_SEQUENTIAL_MAX && continue_flag);
}
} while(continue_flag);
ends[thread_number] = 1;
return NULL;
}

void _swap(struct address_value *a,struct address_value *b){

struct address_value t;
t = *a;
*a = *b;
*b = t;
}

void _sort(struct address_value *arr,int64_t n) {

uint32_t depthLimit = ((uint32_t) ceil(log(n))) * 2;
_introsort(arr,depthLimit,n);
}

void _introsort(struct address_value *arr,uint32_t depthLimit, int64_t n) {

int64_t p;
if(n > 1) {
if(n <= 16) {
_insertionsort(arr,n);
}
else {
if(depthLimit == 0) {
_myheapsort(arr,n);
}
else {
p = _partition(arr,n);
if(p > 0) _introsort(arr , depthLimit-1 , p);
if(p < n) _introsort(&arr[p+1],depthLimit-1,n-(p+1));
}
}
}
}

void _insertionsort(struct address_value *arr, int64_t n) {

int64_t j;
int64_t i;
struct address_value key;
for(i = 1; i < n ; i++ ) {
key = arr[i];
j= i-1;
while(j >= 0 && memcmp(arr[j].value,key.value,20) > 0) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = key;
}
}

int64_t _partition(struct address_value *arr, int64_t n) {

struct address_value pivot;
int64_t r,left,right;
r = n/2;
pivot = arr[r];
left = 0;
right = n-1;
do {
while(left < right && memcmp(arr[left].value,pivot.value,20) <= 0 )
{
left++;
}
while(right >= left && memcmp(arr[right].value,pivot.value,20) > 0)
{
right--;
}
if(left < right) {
if(left == r || right == r) {
 if(left == r) {
r = right;
}
if(right == r) {
r = left;
}
}
_swap(&arr[right],&arr[left]);
}
}while(left < right);
if(right != r) {
_swap(&arr[right],&arr[r]);
}
return right;
}

void _heapify(struct address_value *arr, int64_t n, int64_t i) {

int64_t largest = i;
int64_t l = 2 * i + 1;
int64_t r = 2 * i + 2;
if (l < n && memcmp(arr[l].value,arr[largest].value,20) > 0)
largest = l;
if (r < n && memcmp(arr[r].value,arr[largest].value,20) > 0)
largest = r;
if (largest != i) {
_swap(&arr[i],&arr[largest]);
_heapify(arr, n, largest);
}
}

void _myheapsort(struct address_value *arr, int64_t n) {

int64_t i;
for ( i = (n / 2) - 1; i >= 0; i--) {
_heapify(arr, n, i);
}
for ( i = n - 1; i > 0; i--) {
_swap(&arr[0] , &arr[i]);
_heapify(arr, i, 0);
}
}

/* OK */
void bsgs_swap(struct bsgs_xvalue *a,struct bsgs_xvalue *b){
struct bsgs_xvalue t;
t = *a;
*a = *b;
*b = t;
}

/* OK */
void bsgs_sort(struct bsgs_xvalue *arr,int64_t n) {
uint32_t depthLimit = ((uint32_t) ceil(log(n))) * 2;
bsgs_introsort(arr,depthLimit,n);
}

/* OK */
void bsgs_introsort(struct bsgs_xvalue *arr,uint32_t depthLimit, int64_t n) {
int64_t p;
if(n > 1) {
 if(n <= 16) {
bsgs_insertionsort(arr,n);
}
else {
if(depthLimit == 0) {
bsgs_myheapsort(arr,n);
}
else {
p = bsgs_partition(arr,n);
if(p > 0) bsgs_introsort(arr , depthLimit-1 , p);
if(p < n) bsgs_introsort(&arr[p+1],depthLimit-1,n-(p+1));
}
}
}
}

/* OK */
void bsgs_insertionsort(struct bsgs_xvalue *arr, int64_t n) {
int64_t j;
int64_t i;
struct bsgs_xvalue key;
for(i = 1; i < n ; i++ ) {
key = arr[i];
j= i-1;
while(j >= 0 && memcmp(arr[j].value,key.value,BSGS_XVALUE_RAM) > 0) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = key;
}
}

int64_t bsgs_partition(struct bsgs_xvalue *arr, int64_t n) {

struct bsgs_xvalue pivot;
int64_t r,left,right;
r = n/2;
pivot = arr[r];
left = 0;
right = n-1;
do {
while(left < right &&
memcmp(arr[left].value,pivot.value,BSGS_XVALUE_RAM) <= 0 ) {
left++;
}
while(right >= left &&
memcmp(arr[right].value,pivot.value,BSGS_XVALUE_RAM) > 0) {
right--;
}
if(left < right) {
if(left == r || right == r) {
if(left == r) {
r = right;
}
if(right == r) {
r = left;
}
}
bsgs_swap(&arr[right],&arr[left]);
}
 }while(left < right);
if(right != r) {
bsgs_swap(&arr[right],&arr[r]);
}
return right;
}

void bsgs_heapify(struct bsgs_xvalue *arr, int64_t n, int64_t i) {

int64_t largest = i;
int64_t l = 2 * i + 1;
int64_t r = 2 * i + 2;
if (l < n && memcmp(arr[l].value,arr[largest].value,BSGS_XVALUE_RAM) > 0)
largest = l;
if (r < n && memcmp(arr[r].value,arr[largest].value,BSGS_XVALUE_RAM) > 0)
largest = r;
if (largest != i) {
bsgs_swap(&arr[i],&arr[largest]);
bsgs_heapify(arr, n, largest);
}
}

void bsgs_myheapsort(struct bsgs_xvalue *arr, int64_t n) {

int64_t i;
for ( i = (n / 2) - 1; i >= 0; i--) {
bsgs_heapify(arr, n, i);
}
for ( i = n - 1; i > 0; i--) {
bsgs_swap(&arr[0] , &arr[i]);
bsgs_heapify(arr, i, 0);
}
}

int bsgs_searchbinary(struct bsgs_xvalue *buffer,char *data,int64_t

array_length,uint64_t *r_value) {
int64_t min,max,half,current;
int r = 0,rcmp;
min = 0;
current = 0;
max = array_length;
half = array_length;
while(!r && half >= 1) {
half = (max - min)/2;
rcmp = memcmp(data+16,buffer[current+half].value,BSGS_XVALUE_RAM);
if(rcmp == 0) {
*r_value = buffer[current+half].index;
r = 1;
}
else {
if(rcmp < 0) {
max = (max-half);
}
else {
min = (min+half);
}
current = min;
}
}
return r;
}
#if defined(_WIN64) && !defined(__CYGWIN__)
DWORD WINAPI thread_process_bsgs(LPVOID vargp) {
#else
void *thread_process_bsgs(void *vargp) {
#endif
// File-related variables
FILE* filekey;
struct tothread* tt;

// Character variables
char xpoint_raw[32], *aux_c, *hextemp;

// Integer variables
Int base_key, keyfound;
IntGroup* grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);
Int dx[CPU_GRP_SIZE / 2 + 1];
Int dy, dyn, _s, _p, km, intaux;

// Point variables
Point base_point, point_aux, point_found;
Point startP;
Point pp, pn;
Point pts[CPU_GRP_SIZE];

// Unsigned integer variables

uint32_t k, l, r, salir, thread_number, cycles;

// Other variables
int hLength = (CPU_GRP_SIZE / 2 - 1);
grp->Set(dx);

tt = (struct tothread *)vargp;

thread_number = tt->nt;
free(tt);

cycles = bsgs_aux / 1024;

if(bsgs_aux % 1024 != 0) {
cycles++;
}

intaux.Set(&BSGS_M_double);
intaux.Mult(CPU_GRP_SIZE/2);
intaux.Add(&BSGS_M);

do {
/*
We do this in an atomic pthread_mutex operation to not affect others
threads
so BSGS_CURRENT is never the same between threads
*/
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif

base_key.Set(&BSGS_CURRENT); /* we need to set our base_key to the

current BSGS_CURRENT value*/
 BSGS_CURRENT.Add(&BSGS_N_double); /*Then add 2*BSGS_N to
BSGS_CURRENT*/
/*
BSGS_CURRENT.Add(&BSGS_N); //Then add BSGS_N to BSGS_CURRENT
BSGS_CURRENT.Add(&BSGS_N); //Then add BSGS_N to BSGS_CURRENT
*/

#if defined(_WIN64) && !defined(__CYGWIN__)

ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif

if(base_key.IsGreaterOrEqual(&n_range_end))
break;

if(FLAGMATRIX) {
aux_c = base_key.GetBase16();
printf("[+] Thread 0x%s \n",aux_c);
fflush(stdout);
free(aux_c);
}
else {
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread 0x%s \r",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
}
base_point = secp->ComputePublicKey(&base_key);
km.Set(&base_key);
km.Neg();
km.Add(&secp->order);
km.Sub(&intaux);
point_aux = secp->ComputePublicKey(&km);
for(k = 0; k < bsgs_point_number ; k++) {
if(bsgs_found[k] == 0) {
startP = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
uint32_t j = 0;
while( j < cycles && bsgs_found[k]== 0 ) {
int i;
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&GSn[i].x,&startP.x);
}
dx[i].ModSub(&GSn[i].x,&startP.x); // For the first
point
dx[i+1].ModSub(&_2GSn.x,&startP.x); // For the next
center point
// Grouped ModInv
grp->ModInv();
/*
We use the fact that P + i*G and P - i*G has the same
deltax, so the same inverse
We compute key in the positive and negative way from
the center of the group
*/
// center point
 pts[CPU_GRP_SIZE / 2] = startP;
for(i = 0; i<hLength; i++) {
pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;
#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif
// P = startP - i*G , if (x,y) = i*G then (x,-
y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
}
// First point (startP - (GRP_SZIE/2)*G)
pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif
pts[0] = pn;
for(int i = 0; i<CPU_GRP_SIZE && bsgs_found[k]== 0;
i++) {
pts[i].x.Get32Bytes((unsigned
char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned
char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
r = bsgs_secondcheck(&base_key,((j*1024)
+ i),k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("[+] Thread Key found
privkey %s \n",hextemp);
point_found = secp-
>ComputePublicKey(&keyfound);
aux_c = secp-
>GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_found);
printf("[+] Publickey %s\n",aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_keys,
INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif

filekey =
fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key found
privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
free(hextemp);
free(aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif
bsgs_found[k] = 1;
salir = 1;
for(l = 0; l < bsgs_point_number &&
salir; l++) {
salir &= bsgs_found[l];
}
if(salir) {
printf("All points were
found\n");
exit(EXIT_FAILURE);
}
} //End if second check
}//End if first check
}// For for pts variable
// Next start point (startP += (bsSize*GRP_SIZE).G)
 pp = startP;
dy.ModSub(&_2GSn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2GSn.x);

pp.y.ModSub(&_2GSn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2GSn.y);
startP = pp;

j++;
} // end while
}// End if
}
steps[thread_number]+=2;
}while(1);
ends[thread_number] = 1;
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_bsgs_random(LPVOID vargp) {
#else
void *thread_process_bsgs_random(void *vargp) {
#endif

FILE *filekey;
struct tothread *tt;
char xpoint_raw[32],*aux_c,*hextemp;
Int base_key,keyfound,n_range_random;
Point base_point,point_aux,point_found;
uint32_t l,k,r,salir,thread_number,cycles;

IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);

Point startP;

int hLength = (CPU_GRP_SIZE / 2 - 1);

Int dx[CPU_GRP_SIZE / 2 + 1];

Point pts[CPU_GRP_SIZE];

Int dy;
Int dyn;
Int _s;
Int _p;
Int km,intaux;
Point pp;
Point pn;
grp->Set(dx);

tt = (struct tothread *)vargp;

thread_number = tt->nt;
free(tt);
 cycles = bsgs_aux / 1024;
if(bsgs_aux % 1024 != 0) {
cycles++;
}

intaux.Set(&BSGS_M_double);
intaux.Mult(CPU_GRP_SIZE/2);
intaux.Add(&BSGS_M);

do {

/* | Start Range | End Range |

None | 1 | EC.N |
-b bit | Min bit value | Max bit value |
-r A:B | A | B |
*/
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif

base_key.Rand(&n_range_start,&n_range_end);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif

if(FLAGMATRIX) {
aux_c = base_key.GetBase16();
printf("[+] Thread 0x%s \n",aux_c);
fflush(stdout);
free(aux_c);
}
else{
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread 0x%s \r",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
}
base_point = secp->ComputePublicKey(&base_key);

km.Set(&base_key);
km.Neg();

km.Add(&secp->order);
km.Sub(&intaux);
point_aux = secp->ComputePublicKey(&km);

/* We need to test individually every point in BSGS_Q */

for(k = 0; k < bsgs_point_number ; k++) {
 if(bsgs_found[k] == 0) {
startP = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
uint32_t j = 0;
while( j < cycles && bsgs_found[k]== 0 ) {

int i;
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&GSn[i].x,&startP.x);
}
dx[i].ModSub(&GSn[i].x,&startP.x); // For the first
point
dx[i+1].ModSub(&_2GSn.x,&startP.x); // For the next
center point

// Grouped ModInv
grp->ModInv();

/*
We use the fact that P + i*G and P - i*G has the same
deltax, so the same inverse
We compute key in the positive and negative way from
the center of the group
*/

// center point
pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G then (x,-

y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
 pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif

pts[0] = pn;

for(int i = 0; i<CPU_GRP_SIZE && bsgs_found[k]== 0;

i++) {
pts[i].x.Get32Bytes((unsigned
char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned
char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
r = bsgs_secondcheck(&base_key,((j*1024)
+ i),k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("[+] Thread Key found
privkey %s \n",hextemp);
point_found = secp-
>ComputePublicKey(&keyfound);
aux_c = secp-
>GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_found);
printf("[+] Publickey %s\n",aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_keys,
INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif

filekey =
fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key found
privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
free(hextemp);
free(aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif

bsgs_found[k] = 1;
salir = 1;
for(l = 0; l < bsgs_point_number &&
salir; l++) {
salir &= bsgs_found[l];
}
if(salir) {
printf("All points were
found\n");
exit(EXIT_FAILURE);
}
} //End if second check
}//End if first check

}// For for pts variable

// Next start point (startP += (bsSize*GRP_SIZE).G)

pp = startP;
dy.ModSub(&_2GSn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2GSn.x);

pp.y.ModSub(&_2GSn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2GSn.y);
startP = pp;

j++;

} //End While
} //End if
} // End for with k bsgs_point_number
 steps[thread_number]+=2;
}while(1);
ends[thread_number] = 1;
return NULL;
}

/*
The bsgs_secondcheck function is made to perform a second BSGS search in a
Range of less size.
This funtion is made with the especific purpouse to USE a smaller bPtable in
RAM.
*/
int bsgs_secondcheck(Int *start_range,uint32_t a,uint32_t k_index,Int *privatekey)
{
int i = 0,found = 0,r = 0;
Int base_key;
Point base_point,point_aux;
Point BSGS_Q, BSGS_S,BSGS_Q_AMP;
char xpoint_raw[32];

base_key.Set(&BSGS_M_double);
base_key.Mult((uint64_t) a);
base_key.Add(start_range);

base_point = secp->ComputePublicKey(&base_key);
point_aux = secp->Negation(base_point);

/*
BSGS_S = Q - base_key
Q is the target Key
base_key is the Start range + a*BSGS_M
*/
BSGS_S = secp->AddDirect(OriginalPointsBSGS[k_index],point_aux);
BSGS_Q.Set(BSGS_S);
do {
BSGS_Q_AMP = secp->AddDirect(BSGS_Q,BSGS_AMP2[i]);
BSGS_S.Set(BSGS_Q_AMP);
BSGS_S.x.Get32Bytes((unsigned char *) xpoint_raw);
r = bloom_check(&bloom_bPx2nd[(uint8_t) xpoint_raw[0]],xpoint_raw,32);
if(r) {
found = bsgs_thirdcheck(&base_key,i,k_index,privatekey);
}
i++;
}while(i < 32 && !found);
return found;
}

int bsgs_thirdcheck(Int *start_range,uint32_t a,uint32_t k_index,Int *privatekey)

{
uint64_t j = 0;
int i = 0,found = 0,r = 0;
Int base_key,calculatedkey;
Point base_point,point_aux;
Point BSGS_Q, BSGS_S,BSGS_Q_AMP;
char xpoint_raw[32];

base_key.SetInt32(a);
 base_key.Mult(&BSGS_M2_double);
base_key.Add(start_range);

base_point = secp->ComputePublicKey(&base_key);
point_aux = secp->Negation(base_point);

BSGS_S = secp->AddDirect(OriginalPointsBSGS[k_index],point_aux);
BSGS_Q.Set(BSGS_S);

do {
BSGS_Q_AMP = secp->AddDirect(BSGS_Q,BSGS_AMP3[i]);
BSGS_S.Set(BSGS_Q_AMP);
BSGS_S.x.Get32Bytes((unsigned char *)xpoint_raw);
r = bloom_check(&bloom_bPx3rd[(uint8_t)xpoint_raw[0]],xpoint_raw,32);
if(r) {
r = bsgs_searchbinary(bPtable,xpoint_raw,bsgs_m3,&j);
if(r) {
calcualteindex(i,&calculatedkey);
privatekey->Set(&calculatedkey);
privatekey->Add((uint64_t)(j+1));
privatekey->Add(&base_key);
point_aux = secp->ComputePublicKey(privatekey);
if(point_aux.x.IsEqual(&OriginalPointsBSGS[k_index].x))
{
found = 1;
}
else {
calcualteindex(i,&calculatedkey);
privatekey->Set(&calculatedkey);
privatekey->Sub((uint64_t)(j+1));
privatekey->Add(&base_key);
point_aux = secp->ComputePublicKey(privatekey);

if(point_aux.x.IsEqual(&OriginalPointsBSGS[k_index].x)) {
found = 1;
}
}
}
}
else {
/*
For some reason the AddDirect don't return 000000... value
when the publickeys are the negated values from each other
Why JLP?
This is is an special case
*/
if(BSGS_Q.x.IsEqual(&BSGS_AMP3[i].x)) {
calcualteindex(i,&calculatedkey);
privatekey->Set(&calculatedkey);
privatekey->Add(&base_key);
found = 1;
}
}
i++;
}while(i < 32 && !found);
return found;
}

void sleep_ms(int milliseconds) { // cross-platform sleep function

#if defined(_WIN64) && !defined(__CYGWIN__)
Sleep(milliseconds);
#elif _POSIX_C_SOURCE >= 199309L
struct timespec ts;
ts.tv_sec = milliseconds / 1000;
ts.tv_nsec = (milliseconds % 1000) * 1000000;
nanosleep(&ts, NULL);
#else
if (milliseconds >= 1000)
sleep(milliseconds / 1000);
usleep((milliseconds % 1000) * 1000);
#endif
}

void init_generator() {
Point G = secp->ComputePublicKey(&stride);
Point g;
g.Set(G);
Gn.reserve(CPU_GRP_SIZE / 2);
Gn[0] = g;
g = secp->DoubleDirect(g);
Gn[1] = g;
for(int i = 2; i < CPU_GRP_SIZE / 2; i++) {
g = secp->AddDirect(g,G);
Gn[i] = g;
}
_2Gn = secp->DoubleDirect(Gn[CPU_GRP_SIZE / 2 - 1]);
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_bPload(LPVOID vargp) {
#else
void *thread_bPload(void *vargp) {
#endif

char rawvalue[32];
struct bPload *tt;
uint64_t i_counter,j,nbStep,to;

IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);

Point startP;
Int dx[CPU_GRP_SIZE / 2 + 1];
Point pts[CPU_GRP_SIZE];
Int dy,dyn,_s,_p;
Point pp,pn;

int i,bloom_bP_index,hLength = (CPU_GRP_SIZE / 2 - 1) ,threadid;

tt = (struct bPload *)vargp;
Int km((uint64_t)(tt->from + 1));
threadid = tt->threadid;
//if(FLAGDEBUG) printf("[D] thread %i from %" PRIu64 " to %" PRIu64 "\
n",threadid,tt->from,tt->to);

i_counter = tt->from;

nbStep = (tt->to - tt->from) / CPU_GRP_SIZE;

if( ((tt->to - tt->from) % CPU_GRP_SIZE ) != 0) {

 nbStep++;
}
//if(FLAGDEBUG) printf("[D] thread %i nbStep %" PRIu64 "\n",threadid,nbStep);
to = tt->to;

km.Add((uint64_t)(CPU_GRP_SIZE / 2));
startP = secp->ComputePublicKey(&km);
grp->Set(dx);
for(uint64_t s=0;s<nbStep;s++) {
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&Gn[i].x,&startP.x);
}
dx[i].ModSub(&Gn[i].x,&startP.x); // For the first point
dx[i + 1].ModSub(&_2Gn.x,&startP.x);// For the next center point
// Grouped ModInv
grp->ModInv();

// We use the fact that P + i*G and P - i*G has the same deltax, so the
same inverse
// We compute key in the positive and negative way from the center of
the group
// center point

pts[CPU_GRP_SIZE / 2] = startP; //Center point

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&Gn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-
p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&Gn[i].x); // rx = pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&Gn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&Gn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G then (x,-y) = -i*G

dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-
p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x); // rx = pow2(s) - p1.x - p2.x;
#if 0
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
}

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x);

#if 0
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y);
#endif

pts[0] = pn;
for(j=0;j<CPU_GRP_SIZE;j++) {
pts[j].x.Get32Bytes((unsigned char*)rawvalue);
bloom_bP_index = (uint8_t)rawvalue[0];
/*
if(FLAGDEBUG){
tohex_dst(rawvalue,32,hexraw);
printf("%i : %s : %i\n",i_counter,hexraw,bloom_bP_index);
}
*/
if(i_counter < bsgs_m3) {
if(!FLAGREADEDFILE3) {

memcpy(bPtable[i_counter].value,rawvalue+16,BSGS_XVALUE_RAM);
bPtable[i_counter].index = i_counter;
}
if(!FLAGREADEDFILE4) {
#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bloom_bPx3rd_mutex[bloom_bP_index], INFINITE);
bloom_add(&bloom_bPx3rd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);
ReleaseMutex(bloom_bPx3rd_mutex[bloom_bP_index]);
#else

pthread_mutex_lock(&bloom_bPx3rd_mutex[bloom_bP_index]);
bloom_add(&bloom_bPx3rd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);

pthread_mutex_unlock(&bloom_bPx3rd_mutex[bloom_bP_index]);
#endif
}
}
if(i_counter < bsgs_m2 && !FLAGREADEDFILE2) {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bloom_bPx2nd_mutex[bloom_bP_index],
INFINITE);
bloom_add(&bloom_bPx2nd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);
ReleaseMutex(bloom_bPx2nd_mutex[bloom_bP_index]);
#else
pthread_mutex_lock(&bloom_bPx2nd_mutex[bloom_bP_index]);
bloom_add(&bloom_bPx2nd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);
pthread_mutex_unlock(&bloom_bPx2nd_mutex[bloom_bP_index]);
#endif
}
if(i_counter < to && !FLAGREADEDFILE1 ) {
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bloom_bP_mutex[bloom_bP_index],
INFINITE);
bloom_add(&bloom_bP[bloom_bP_index],
rawvalue ,BSGS_BUFFERXPOINTLENGTH);
ReleaseMutex(bloom_bP_mutex[bloom_bP_index);
#else
pthread_mutex_lock(&bloom_bP_mutex[bloom_bP_index]);
bloom_add(&bloom_bP[bloom_bP_index],
rawvalue ,BSGS_BUFFERXPOINTLENGTH);
pthread_mutex_unlock(&bloom_bP_mutex[bloom_bP_index]);
#endif
}
i_counter++;
}
// Next start point (startP + GRP_SIZE*G)
pp = startP;
dy.ModSub(&_2Gn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2Gn.x);

pp.y.ModSub(&_2Gn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2Gn.y);
startP = pp;
}
delete grp;
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bPload_mutex[threadid], INFINITE);
tt->finished = 1;
ReleaseMutex(bPload_mutex[threadid]);
#else
pthread_mutex_lock(&bPload_mutex[threadid]);
tt->finished = 1;
pthread_mutex_unlock(&bPload_mutex[threadid]);
pthread_exit(NULL);
#endif
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_bPload_2blooms(LPVOID vargp) {
#else
void *thread_bPload_2blooms(void *vargp) {
#endif
char rawvalue[32];
struct bPload *tt;
uint64_t i_counter,j,nbStep; //,to;
IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);
Point startP;
Int dx[CPU_GRP_SIZE / 2 + 1];
Point pts[CPU_GRP_SIZE];
Int dy,dyn,_s,_p;
Point pp,pn;
int i,bloom_bP_index,hLength = (CPU_GRP_SIZE / 2 - 1) ,threadid;
tt = (struct bPload *)vargp;
Int km((uint64_t)(tt->from +1 ));
threadid = tt->threadid;

i_counter = tt->from;

nbStep = (tt->to - (tt->from)) / CPU_GRP_SIZE;

if( ((tt->to - (tt->from)) % CPU_GRP_SIZE ) != 0) {

nbStep++;
}
//if(FLAGDEBUG) printf("[D] thread %i nbStep %" PRIu64 "\n",threadid,nbStep);
//to = tt->to;

km.Add((uint64_t)(CPU_GRP_SIZE / 2));
startP = secp->ComputePublicKey(&km);
grp->Set(dx);
for(uint64_t s=0;s<nbStep;s++) {
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&Gn[i].x,&startP.x);
}
dx[i].ModSub(&Gn[i].x,&startP.x); // For the first point
dx[i + 1].ModSub(&_2Gn.x,&startP.x);// For the next center point
// Grouped ModInv
grp->ModInv();

// We use the fact that P + i*G and P - i*G has the same deltax, so the
same inverse
// We compute key in the positive and negative way from the center of
the group
// center point

pts[CPU_GRP_SIZE / 2] = startP; //Center point

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&Gn[i].y,&pp.y);
 _s.ModMulK1(&dy,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-
p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&Gn[i].x); // rx = pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&Gn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&Gn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G then (x,-y) = -i*G

dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-
p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x); // rx = pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
}

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&Gn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&Gn[i].x);

#if 0
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y);
#endif

pts[0] = pn;
for(j=0;j<CPU_GRP_SIZE;j++) {
 pts[j].x.Get32Bytes((unsigned char*)rawvalue);
bloom_bP_index = (uint8_t)rawvalue[0];
if(i_counter < bsgs_m3) {
if(!FLAGREADEDFILE3) {

memcpy(bPtable[i_counter].value,rawvalue+16,BSGS_XVALUE_RAM);
bPtable[i_counter].index = i_counter;
}
if(!FLAGREADEDFILE4) {
#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bloom_bPx3rd_mutex[bloom_bP_index], INFINITE);
bloom_add(&bloom_bPx3rd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);
ReleaseMutex(bloom_bPx3rd_mutex[bloom_bP_index]);
#else

pthread_mutex_lock(&bloom_bPx3rd_mutex[bloom_bP_index]);
bloom_add(&bloom_bPx3rd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);

pthread_mutex_unlock(&bloom_bPx3rd_mutex[bloom_bP_index]);
#endif
}
}
if(i_counter < bsgs_m2 && !FLAGREADEDFILE2) {
#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bloom_bPx2nd_mutex[bloom_bP_index], INFINITE);
bloom_add(&bloom_bPx2nd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);
ReleaseMutex(bloom_bPx2nd_mutex[bloom_bP_index]);
#else

pthread_mutex_lock(&bloom_bPx2nd_mutex[bloom_bP_index]);
bloom_add(&bloom_bPx2nd[bloom_bP_index], rawvalue,
BSGS_BUFFERXPOINTLENGTH);

pthread_mutex_unlock(&bloom_bPx2nd_mutex[bloom_bP_index]);
#endif
}
i_counter++;
}
// Next start point (startP + GRP_SIZE*G)
pp = startP;
dy.ModSub(&_2Gn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2Gn.x);

pp.y.ModSub(&_2Gn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2Gn.y);
startP = pp;
}
 delete grp;
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bPload_mutex[threadid], INFINITE);
tt->finished = 1;
ReleaseMutex(bPload_mutex[threadid]);
#else
pthread_mutex_lock(&bPload_mutex[threadid]);
tt->finished = 1;
pthread_mutex_unlock(&bPload_mutex[threadid]);
pthread_exit(NULL);
#endif
return NULL;
}

/* This function perform the KECCAK Opetation*/

void KECCAK_256(uint8_t *source, size_t size,uint8_t *dst) {
SHA3_256_CTX ctx;
SHA3_256_Init(&ctx);
SHA3_256_Update(&ctx,source,size);
KECCAK_256_Final(dst,&ctx);
}

/* This function takes in two parameters:

publickey: a reference to a Point object representing a public key.

dst_address: a pointer to an unsigned char array where the generated binary address
will be stored.
The function is designed to generate a binary address for Ethereum using the given
public key.
It first extracts the x and y coordinates of the public key as 32-byte arrays, and
concatenates them
to form a 64-byte array called bin_publickey. Then, it applies the KECCAK-256
hashing algorithm to
bin_publickey to generate the binary address, which is stored in dst_address. */

void generate_binaddress_eth(Point &publickey,unsigned char *dst_address) {

unsigned char bin_publickey[64];
publickey.x.Get32Bytes(bin_publickey);
publickey.y.Get32Bytes(bin_publickey+32);
KECCAK_256(bin_publickey, 64, bin_publickey);
memcpy(dst_address,bin_publickey+12,20);
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_bsgs_dance(LPVOID vargp) {
#else
void *thread_process_bsgs_dance(void *vargp) {
#endif

Point pts[CPU_GRP_SIZE];
Int dx[CPU_GRP_SIZE / 2 + 1];
Point pp,pn,startP,base_point,point_aux,point_found;
FILE *filekey;
struct tothread *tt;
char xpoint_raw[32],*aux_c,*hextemp;
Int base_key,keyfound,dy,dyn,_s,_p,km,intaux;
IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);
uint32_t k,l,r,salir,thread_number,entrar,cycles;
int hLength = (CPU_GRP_SIZE / 2 - 1);
 grp->Set(dx);

tt = (struct tothread *)vargp;

thread_number = tt->nt;
free(tt);

cycles = bsgs_aux / 1024;

if(bsgs_aux % 1024 != 0) {
cycles++;
}

intaux.Set(&BSGS_M_double);
intaux.Mult(CPU_GRP_SIZE/2);
intaux.Add(&BSGS_M);

entrar = 1;

/*
while base_key is less than n_range_end then:
*/
do {
r = rand() % 3;
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif
switch(r) {
case 0: //TOP
if(n_range_end.IsGreater(&BSGS_CURRENT)) {
/*
n_range_end.Sub(&BSGS_N);
n_range_end.Sub(&BSGS_N);
*/
n_range_end.Sub(&BSGS_N_double);
if(n_range_end.IsLower(&BSGS_CURRENT)) {
base_key.Set(&BSGS_CURRENT);
}
else {
base_key.Set(&n_range_end);
}
}
else {
entrar = 0;
}
break;
case 1: //BOTTOM
if(BSGS_CURRENT.IsLower(&n_range_end)) {
base_key.Set(&BSGS_CURRENT);
//BSGS_N_double
BSGS_CURRENT.Add(&BSGS_N_double);
/*
BSGS_CURRENT.Add(&BSGS_N);
BSGS_CURRENT.Add(&BSGS_N);
*/
}
else {
 entrar = 0;
}
break;
case 2: //random - middle
base_key.Rand(&BSGS_CURRENT,&n_range_end);
break;
}
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif

if(entrar == 0)
break;

if(FLAGMATRIX) {
aux_c = base_key.GetBase16();
printf("[+] Thread 0x%s \n",aux_c);
fflush(stdout);
free(aux_c);
}
else {
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread 0x%s \r",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
}

base_point = secp->ComputePublicKey(&base_key);

km.Set(&base_key);
km.Neg();

km.Add(&secp->order);
km.Sub(&intaux);
point_aux = secp->ComputePublicKey(&km);

for(k = 0; k < bsgs_point_number ; k++) {

if(bsgs_found[k] == 0) {
startP = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
uint32_t j = 0;
while( j < cycles && bsgs_found[k]== 0 ) {

int i;

for(i = 0; i < hLength; i++) {

dx[i].ModSub(&GSn[i].x,&startP.x);
}
dx[i].ModSub(&GSn[i].x,&startP.x); // For the first
point
dx[i+1].ModSub(&_2GSn.x,&startP.x); // For the next
center point

// Grouped ModInv
grp->ModInv();
 /*
We use the fact that P + i*G and P - i*G has the same
deltax, so the same inverse
We compute key in the positive and negative way from
the center of the group
*/

// center point
pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G then (x,-

y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
 }

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif

pts[0] = pn;

for(int i = 0; i<CPU_GRP_SIZE && bsgs_found[k]== 0;

i++) {
pts[i].x.Get32Bytes((unsigned
char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned
char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
r = bsgs_secondcheck(&base_key,((j*1024)
+ i),k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("[+] Thread Key found
privkey %s \n",hextemp);
point_found = secp-
>ComputePublicKey(&keyfound);
aux_c = secp-
>GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_found);
printf("[+] Publickey %s\n",aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_keys,
INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif

filekey =
fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key found
privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
free(hextemp);
free(aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif

bsgs_found[k] = 1;
salir = 1;
for(l = 0; l < bsgs_point_number &&
salir; l++) {
salir &= bsgs_found[l];
}
if(salir) {
printf("All points were
found\n");
exit(EXIT_FAILURE);
}
} //End if second check
}//End if first check

}// For for pts variable

// Next start point (startP += (bsSize*GRP_SIZE).G)

pp = startP;
dy.ModSub(&_2GSn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2GSn.x);

pp.y.ModSub(&_2GSn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2GSn.y);
startP = pp;

j++;
}//while all the aMP points
}// End if
}
steps[thread_number]+=2;
}while(1);
ends[thread_number] = 1;
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_bsgs_backward(LPVOID vargp) {
#else
void *thread_process_bsgs_backward(void *vargp) {
#endif
FILE *filekey;
struct tothread *tt;
char xpoint_raw[32],*aux_c,*hextemp;
Int base_key,keyfound;
Point base_point,point_aux,point_found;
uint32_t k,l,r,salir,thread_number,entrar,cycles;
 IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);
Point startP;

int hLength = (CPU_GRP_SIZE / 2 - 1);

Int dx[CPU_GRP_SIZE / 2 + 1];

Point pts[CPU_GRP_SIZE];

Int dy;
Int dyn;
Int _s;
Int _p;
Int km,intaux;
Point pp;
Point pn;
grp->Set(dx);

tt = (struct tothread *)vargp;

thread_number = tt->nt;
free(tt);

cycles = bsgs_aux / 1024;

if(bsgs_aux % 1024 != 0) {
cycles++;
}

intaux.Set(&BSGS_M_double);
intaux.Mult(CPU_GRP_SIZE/2);
intaux.Add(&BSGS_M);

entrar = 1;
/*
while base_key is less than n_range_end then:
*/
do {

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif
if(n_range_end.IsGreater(&n_range_start)) {
n_range_end.Sub(&BSGS_N_double);
if(n_range_end.IsLower(&n_range_start)) {
base_key.Set(&n_range_start);
}
else {
base_key.Set(&n_range_end);
}
}
else {
entrar = 0;
}
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif
if(entrar == 0)
 break;

if(FLAGMATRIX) {
aux_c = base_key.GetBase16();
printf("[+] Thread 0x%s \n",aux_c);
fflush(stdout);
free(aux_c);
}
else {
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread 0x%s \r",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
}

base_point = secp->ComputePublicKey(&base_key);

km.Set(&base_key);
km.Neg();

km.Add(&secp->order);
km.Sub(&intaux);
point_aux = secp->ComputePublicKey(&km);

for(k = 0; k < bsgs_point_number ; k++) {

if(bsgs_found[k] == 0) {
startP = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
uint32_t j = 0;
while( j < cycles && bsgs_found[k]== 0 ) {
int i;
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&GSn[i].x,&startP.x);
}
dx[i].ModSub(&GSn[i].x,&startP.x); // For the first
point
dx[i+1].ModSub(&_2GSn.x,&startP.x); // For the next
center point

// Grouped ModInv
grp->ModInv();

/*
We use the fact that P + i*G and P - i*G has the same
deltax, so the same inverse
We compute key in the positive and negative way from
the center of the group
*/

// center point
pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;
 // P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G then (x,-

y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-
p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;

// First point (startP - (GRP_SZIE/2)*G)

pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif

pts[0] = pn;

for(int i = 0; i<CPU_GRP_SIZE && bsgs_found[k]== 0;

i++) {
pts[i].x.Get32Bytes((unsigned
char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned
char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
r = bsgs_secondcheck(&base_key,((j*1024)
+ i),k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("[+] Thread Key found
privkey %s \n",hextemp);
point_found = secp-
>ComputePublicKey(&keyfound);
aux_c = secp-
>GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_found);
printf("[+] Publickey %s\n",aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(write_keys,
INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif

filekey =
fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key found
privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
free(hextemp);
free(aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif

bsgs_found[k] = 1;
salir = 1;
for(l = 0; l < bsgs_point_number &&
salir; l++) {
salir &= bsgs_found[l];
}
if(salir) {
printf("All points were
found\n");
exit(EXIT_FAILURE);
}
} //End if second check
 }//End if first check

}// For for pts variable

// Next start point (startP += (bsSize*GRP_SIZE).G)

pp = startP;
dy.ModSub(&_2GSn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2GSn.x);

pp.y.ModSub(&_2GSn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2GSn.y);
startP = pp;
j++;
}//while all the aMP points
}// End if
}
steps[thread_number]+=2;
}while(1);
ends[thread_number] = 1;
return NULL;
}

#if defined(_WIN64) && !defined(__CYGWIN__)

DWORD WINAPI thread_process_bsgs_both(LPVOID vargp) {
#else
void *thread_process_bsgs_both(void *vargp) {
#endif
FILE *filekey;
struct tothread *tt;
char xpoint_raw[32],*aux_c,*hextemp;
Int base_key,keyfound;
Point base_point,point_aux,point_found;
uint32_t k,l,r,salir,thread_number,entrar,cycles;

IntGroup *grp = new IntGroup(CPU_GRP_SIZE / 2 + 1);

Point startP;

int hLength = (CPU_GRP_SIZE / 2 - 1);

Int dx[CPU_GRP_SIZE / 2 + 1];

Point pts[CPU_GRP_SIZE];

Int dy;
Int dyn;
Int _s;
Int _p;
Int km,intaux;
Point pp;
Point pn;
grp->Set(dx);
 tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);

cycles = bsgs_aux / 1024;

if(bsgs_aux % 1024 != 0) {
cycles++;
}
intaux.Set(&BSGS_M_double);
intaux.Mult(CPU_GRP_SIZE/2);
intaux.Add(&BSGS_M);

entrar = 1;

/*
while BSGS_CURRENT is less than n_range_end
*/
do {

r = rand() % 2;
#if defined(_WIN64) && !defined(__CYGWIN__)
WaitForSingleObject(bsgs_thread, INFINITE);
#else
pthread_mutex_lock(&bsgs_thread);
#endif
switch(r) {
case 0: //TOP
if(n_range_end.IsGreater(&BSGS_CURRENT)) {
n_range_end.Sub(&BSGS_N_double);
/*
n_range_end.Sub(&BSGS_N);
n_range_end.Sub(&BSGS_N);
*/
if(n_range_end.IsLower(&BSGS_CURRENT)) {
base_key.Set(&BSGS_CURRENT);
}
else {
base_key.Set(&n_range_end);
}
}
else {
entrar = 0;
}
break;
case 1: //BOTTOM
if(BSGS_CURRENT.IsLower(&n_range_end)) {
base_key.Set(&BSGS_CURRENT);
//BSGS_N_double
BSGS_CURRENT.Add(&BSGS_N_double);
/*
BSGS_CURRENT.Add(&BSGS_N);
BSGS_CURRENT.Add(&BSGS_N);
*/
}
else {
entrar = 0;
}
 break;
}
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(bsgs_thread);
#else
pthread_mutex_unlock(&bsgs_thread);
#endif

if(entrar == 0)
break;

if(FLAGMATRIX) {
aux_c = base_key.GetBase16();
printf("[+] Thread 0x%s \n",aux_c);
fflush(stdout);
free(aux_c);
}
else {
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread 0x%s \r",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
}

base_point = secp->ComputePublicKey(&base_key);

km.Set(&base_key);
km.Neg();

km.Add(&secp->order);
km.Sub(&intaux);
point_aux = secp->ComputePublicKey(&km);

for(k = 0; k < bsgs_point_number ; k++) {

if(bsgs_found[k] == 0) {
startP = secp-
>AddDirect(OriginalPointsBSGS[k],point_aux);
uint32_t j = 0;
while( j < cycles && bsgs_found[k]== 0 ) {
int i;
for(i = 0; i < hLength; i++) {
dx[i].ModSub(&GSn[i].x,&startP.x);
}
dx[i].ModSub(&GSn[i].x,&startP.x); // For the
first point
dx[i+1].ModSub(&_2GSn.x,&startP.x); // For the
next center point

// Grouped ModInv
grp->ModInv();

/*
We use the fact that P + i*G and P - i*G has
the same deltax, so the same inverse
We compute key in the positive and negative way
from the center of the group
*/

// center point
pts[CPU_GRP_SIZE / 2] = startP;

for(i = 0; i<hLength; i++) {

pp = startP;
pn = startP;

// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);

_s.ModMulK1(&dy,&dx[i]); // s =
(p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p =
pow2(s)

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

// P = startP - i*G , if (x,y) = i*G

then (x,-y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]); // s =
(p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p =
pow2(s)

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx =
pow2(s) - p1.x - p2.x;

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif

pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;

pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;

// First point (startP - (GRP_SZIE/2)*G)

 pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);

_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);

pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);

#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif

pts[0] = pn;

for(int i = 0; i<CPU_GRP_SIZE &&

bsgs_found[k]== 0; i++) {
pts[i].x.Get32Bytes((unsigned
char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned
char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
r = bsgs_secondcheck(&base_key,
((j*1024) + i),k,&keyfound);
if(r) {
hextemp =
keyfound.GetBase16();
printf("[+] Thread Key found
privkey %s \n",hextemp);
point_found = secp-
>ComputePublicKey(&keyfound);
aux_c = secp-
>GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_found);
printf("[+] Publickey %s\
n",aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(write_keys, INFINITE);
#else

pthread_mutex_lock(&write_keys);
#endif

filekey =
fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key
found privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
free(hextemp);
free(aux_c);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else

pthread_mutex_unlock(&write_keys);
#endif

bsgs_found[k] = 1;
salir = 1;
for(l = 0; l <
bsgs_point_number && salir; l++) {
salir &= bsgs_found[l];
}
if(salir) {
printf("All points were
found\n");
exit(EXIT_FAILURE);
}
} //End if second check
}//End if first check

}// For for pts variable

// Next start point (startP +=

(bsSize*GRP_SIZE).G)

pp = startP;
dy.ModSub(&_2GSn.y,&pp.y);

_s.ModMulK1(&dy,&dx[i + 1]);
_p.ModSquareK1(&_s);

pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&_2GSn.x);

pp.y.ModSub(&_2GSn.x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&_2GSn.y);
startP = pp;

j++;
}//while all the aMP points
}// End if
}
steps[thread_number]+=2;
}while(1);
ends[thread_number] = 1;
return NULL;
}

/* This function takes in three parameters:

buffer: a pointer to a char array where the minikey will be stored.

rawbuffer: a pointer to a char array that contains the raw data.
length: an integer representing the length of the raw data.
The function is designed to convert the raw data using a lookup table (Ccoinbuffer)
and store the result in the buffer.
*/
void set_minikey(char *buffer,char *rawbuffer,int length) {
 for(int i = 0; i < length; i++) {
buffer[i] = Ccoinbuffer[(uint8_t)rawbuffer[i]];
}
}

/* This function takes in three parameters:

buffer: a pointer to a char array where the minikey will be stored.

rawbuffer: a pointer to a char array that contains the raw data.
index: an integer representing the index of the raw data array to be incremented.
The function is designed to increment the value at the specified index in the raw
data array,
and update the corresponding value in the buffer using a lookup table
(Ccoinbuffer).
If the value at the specified index exceeds 57, it is reset to 0x00 and the
function recursively
calls itself to increment the value at the previous index, unless the index is
already 0, in which
case the function returns false. The function returns true otherwise.
*/

bool increment_minikey_index(char *buffer,char *rawbuffer,int index) {

if(rawbuffer[index] < 57){
rawbuffer[index]++;
buffer[index] = Ccoinbuffer[(uint8_t)rawbuffer[index]];
}
else {
rawbuffer[index] = 0x00;
buffer[index] = Ccoinbuffer[0];
if(index>0) {
return increment_minikey_index(buffer,rawbuffer,index-1);
}
else {
return false;
}
}
return true;
}

/* This function takes in a single parameter:

rawbuffer: a pointer to a char array that contains the raw data.

The function is designed to increment the values in the raw data array
using a lookup table (minikeyN), while also handling carry-over to the
previous element in the array if necessary. The maximum number of iterations
is limited by minikey_n_limit.

*/
void increment_minikey_N(char *rawbuffer) {
int i = 20,j = 0;
while( i > 0 && j < minikey_n_limit) {
rawbuffer[i] = rawbuffer[i] + minikeyN[i];
if(rawbuffer[i] > 57) { // Handling carry-over if value exceeds
57
rawbuffer[i] = rawbuffer[i] % 58;
rawbuffer[i-1]++;
}
i--;
 j++;
}
}

#define BUFFMINIKEY(buff,src) \
(buff)[ 0] = (uint32_t)src[ 0] << 24 | (uint32_t)src[ 1] << 16 | (uint32_t)src[ 2]
<< 8 | (uint32_t)src[ 3]; \
(buff)[ 1] = (uint32_t)src[ 4] << 24 | (uint32_t)src[ 5] << 16 | (uint32_t)src[ 6]
<< 8 | (uint32_t)src[ 7]; \
(buff)[ 2] = (uint32_t)src[ 8] << 24 | (uint32_t)src[ 9] << 16 | (uint32_t)src[10]
<< 8 | (uint32_t)src[11]; \
(buff)[ 3] = (uint32_t)src[12] << 24 | (uint32_t)src[13] << 16 | (uint32_t)src[14]
<< 8 | (uint32_t)src[15]; \
(buff)[ 4] = (uint32_t)src[16] << 24 | (uint32_t)src[17] << 16 | (uint32_t)src[18]
<< 8 | (uint32_t)src[19]; \
(buff)[ 5] = (uint32_t)src[20] << 24 | (uint32_t)src[21] << 16 | 0x8000; \
(buff)[ 6] = 0; \
(buff)[ 7] = 0; \
(buff)[ 8] = 0; \
(buff)[ 9] = 0; \
(buff)[10] = 0; \
(buff)[11] = 0; \
(buff)[12] = 0; \
(buff)[13] = 0; \
(buff)[14] = 0; \
(buff)[15] = 0xB0; //176 bits => 22 BYTES

void sha256sse_22(uint8_t *src0, uint8_t *src1, uint8_t *src2, uint8_t *src3,

uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dst3){
uint32_t b0[16];
uint32_t b1[16];
uint32_t b2[16];
uint32_t b3[16];
BUFFMINIKEY(b0, src0);
BUFFMINIKEY(b1, src1);
BUFFMINIKEY(b2, src2);
BUFFMINIKEY(b3, src3);
sha256sse_1B(b0, b1, b2, b3, dst0, dst1, dst2, dst3);
}

#define BUFFMINIKEYCHECK(buff,src) \
(buff)[ 0] = (uint32_t)src[ 0] << 24 | (uint32_t)src[ 1] << 16 | (uint32_t)src[ 2]
<< 8 | (uint32_t)src[ 3]; \
(buff)[ 1] = (uint32_t)src[ 4] << 24 | (uint32_t)src[ 5] << 16 | (uint32_t)src[ 6]
<< 8 | (uint32_t)src[ 7]; \
(buff)[ 2] = (uint32_t)src[ 8] << 24 | (uint32_t)src[ 9] << 16 | (uint32_t)src[10]
<< 8 | (uint32_t)src[11]; \
(buff)[ 3] = (uint32_t)src[12] << 24 | (uint32_t)src[13] << 16 | (uint32_t)src[14]
<< 8 | (uint32_t)src[15]; \
(buff)[ 4] = (uint32_t)src[16] << 24 | (uint32_t)src[17] << 16 | (uint32_t)src[18]
<< 8 | (uint32_t)src[19]; \
(buff)[ 5] = (uint32_t)src[20] << 24 | (uint32_t)src[21] << 16 | (uint32_t)src[22]
<< 8 | 0x80; \
(buff)[ 6] = 0; \
(buff)[ 7] = 0; \
(buff)[ 8] = 0; \
(buff)[ 9] = 0; \
(buff)[10] = 0; \
(buff)[11] = 0; \
(buff)[12] = 0; \
(buff)[13] = 0; \
(buff)[14] = 0; \
(buff)[15] = 0xB8; //184 bits => 23 BYTES

void sha256sse_23(uint8_t *src0, uint8_t *src1, uint8_t *src2, uint8_t *src3,

uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dst3){
uint32_t b0[16];
uint32_t b1[16];
uint32_t b2[16];
uint32_t b3[16];
BUFFMINIKEYCHECK(b0, src0);
BUFFMINIKEYCHECK(b1, src1);
BUFFMINIKEYCHECK(b2, src2);
BUFFMINIKEYCHECK(b3, src3);
sha256sse_1B(b0, b1, b2, b3, dst0, dst1, dst2, dst3);
}

void menu() {
printf("\nUsage:\n");
printf("-h show this help\n");
printf("-B Mode BSGS now have some modes <sequential, backward, both,
random, dance>\n");
printf("-b bits For some puzzles you only need some numbers of bits in
the test keys.\n");
printf("-c crypto Search for specific crypto. <btc, eth> valid only w/ -m
address\n");
printf("-C mini Set the minikey Base only 22 character minikeys, ex:
SRPqx8QiwnW4WNWnTVa2W5\n");
printf("-8 alpha Set the bas58 alphabet for minikeys\n");
printf("-e Enable endomorphism search (Only for address, rmd160 and
vanity)\n");
printf("-f file Specify file name with addresses or xpoints or
uncompressed public keys\n");
printf("-I stride Stride for xpoint, rmd160 and address, this option don't
work with bsgs\n");
printf("-k value Use this only with bsgs mode, k value is factor for M,
more speed but more RAM use wisely\n");
printf("-l look What type of address/hash160 are you looking for
<compress, uncompress, both> Only for rmd160 and address\n");
printf("-m mode mode of search for cryptos. (bsgs, xpoint, rmd160,
address, vanity) default: address\n");
printf("-M Matrix screen, feel like a h4x0r, but performance will
dropped\n");
printf("-n number Check for N sequential numbers before the random chosen,
this only works with -R option\n");
printf(" Use -n to set the N for the BSGS process. Bigger N more
RAM needed\n");
printf("-q Quiet the thread output\n");
printf("-r SR:EN StarRange:EndRange, the end range can be omitted for
search from start range to N-1 ECC value\n");
printf("-R Random, this is the default behavior\n");
printf("-s ns Number of seconds for the stats output, 0 to omit
output.\n");
printf("-S S is for SAVING in files BSGS data (Bloom filters and
bPtable)\n");
 printf("-6 to skip sha256 Checksum on data files");
printf("-t tn Threads number, must be a positive integer\n");
printf("-v value Search for vanity Address, only with -m vanity\n");
printf("-z value Bloom size multiplier, only address,rmd160,vanity,
xpoint, value >= 1\n");
printf("\nExample:\n\n");
printf("./keyhunt -m rmd160 -f tests/unsolvedpuzzles.rmd -b 66 -l compress -R
-q -t 8\n\n");
printf("This line runs the program with 8 threads from the range
20000000000000000 to 40000000000000000 without stats output\n\n");
printf("Developed by AlbertoBSD\tTips BTC:
1Coffee1jV4gB5gaXfHgSHDz9xx9QSECVW\n");
printf("Thanks to Iceland always helping and sharing his ideas.\nTips to
Iceland: bc1q39meky2mn5qjq704zz0nnkl0v7kj4uz6r529at\n\n");
exit(EXIT_FAILURE);
}

bool vanityrmdmatch(unsigned char *rmdhash) {

bool r = false;
int i,j,cmpA,cmpB,result;
result =
bloom_check(vanity_bloom,rmdhash,vanity_rmd_minimun_bytes_check_length);
switch(result) {
case -1:
fprintf(stderr,"[E] Bloom is not initialized\n");
exit(EXIT_FAILURE);
break;
case 1:
for(i = 0; i < vanity_rmd_targets && !r;i++) {
for(j = 0; j < vanity_rmd_limits[i] && !r; j++) {
cmpA = memcmp(vanity_rmd_limit_values_A[i]
[j],rmdhash,20);
cmpB = memcmp(vanity_rmd_limit_values_B[i]
[j],rmdhash,20);
if(cmpA <= 0 && cmpB >= 0) {
//if(FLAGDEBUG ) printf("\n\n[D] cmpA = %i,
cmpB = %i \n\n",cmpA,cmpB);
r = true;
}
}
}
break;
default:
r = false;
break;
}
return r;
}

void writevanitykey(bool compressed,Int *key) {

Point publickey;
FILE *keys;
char *hextemp,*hexrmd,public_key_hex[131],address[50],rmdhash[20];
hextemp = key->GetBase16();
publickey = secp->ComputePublicKey(key);
secp->GetPublicKeyHex(compressed,publickey,public_key_hex);

secp->GetHash160(P2PKH,compressed,publickey,(uint8_t*)rmdhash);
hexrmd = tohex(rmdhash,20);
 rmd160toaddress_dst(rmdhash,address);

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(write_keys, INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif
keys = fopen("VANITYKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"Vanity Private Key: %s\npubkey: %s\nAddress %s\nrmd160
%s\n",hextemp,public_key_hex,address,hexrmd);
fclose(keys);
}
printf("\nVanity Private Key: %s\npubkey: %s\nAddress %s\nrmd160 %s\
n",hextemp,public_key_hex,address,hexrmd);

#if defined(_WIN64) && !defined(__CYGWIN__)

ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif
free(hextemp);
free(hexrmd);
}

int addvanity(char *target) {

unsigned char raw_value_A[50],raw_value_B[50];
char target_copy[50];
int stringsize,targetsize,j,r = 0;
size_t raw_value_length;
int values_A_size = 0,values_B_size = 0,minimun_bytes;
raw_value_length = 50;
targetsize = strlen(target);
stringsize = targetsize;
memset(raw_value_A,0,50);
memset(target_copy,0,50);
if(targetsize >= 30 ) {
return 0;
}
memcpy(target_copy,target,targetsize);
j = 0;
vanity_address_targets = (char**) realloc(vanity_address_targets,
(vanity_rmd_targets+1) * sizeof(char*));
vanity_address_targets[vanity_rmd_targets] = NULL;
checkpointer((void
*)vanity_address_targets,__FILE__,"realloc","vanity_address_targets" ,__LINE__ -
1 );
vanity_rmd_limits = (int*) realloc(vanity_rmd_limits,(vanity_rmd_targets+1) *
sizeof(int));
vanity_rmd_limits[vanity_rmd_targets] = 0;
checkpointer((void *)vanity_rmd_limits,__FILE__,"realloc","vanity_rmd_limits"
,__LINE__ -1 );
vanity_rmd_limit_values_A = (uint8_t***)realloc(vanity_rmd_limit_values_A,
(vanity_rmd_targets+1) * sizeof(unsigned char *));
checkpointer((void
*)vanity_rmd_limit_values_A,__FILE__,"realloc","vanity_rmd_limit_values_A" ,__LINE_
_ -1 );
vanity_rmd_limit_values_A[vanity_rmd_targets] = NULL;
 vanity_rmd_limit_values_B = (uint8_t***)realloc(vanity_rmd_limit_values_B,
(vanity_rmd_targets+1) * sizeof(unsigned char *));
checkpointer((void
*)vanity_rmd_limit_values_B,__FILE__,"realloc","vanity_rmd_limit_values_B" ,__LINE_
_ -1 );
vanity_rmd_limit_values_B[vanity_rmd_targets] = NULL;
do {
raw_value_length = 50;
b58tobin(raw_value_A,&raw_value_length,target_copy,stringsize);
if(raw_value_length < 25) {
target_copy[stringsize] = '1';
stringsize++;
}
if(raw_value_length == 25) {
b58tobin(raw_value_A,&raw_value_length,target_copy,stringsize);

vanity_rmd_limit_values_A[vanity_rmd_targets] =
(uint8_t**)realloc(vanity_rmd_limit_values_A[vanity_rmd_targets],(j+1) *
sizeof(unsigned char *));
checkpointer((void
*)vanity_rmd_limit_values_A[vanity_rmd_targets],__FILE__,"realloc","vanity_rmd_limi
t_values_A" ,__LINE__ -1 );
vanity_rmd_limit_values_A[vanity_rmd_targets][j] =
(uint8_t*)calloc(20,1);
checkpointer((void
*)vanity_rmd_limit_values_A[vanity_rmd_targets]
[j],__FILE__,"realloc","vanity_rmd_limit_values_A" ,__LINE__ -1 );

memcpy(vanity_rmd_limit_values_A[vanity_rmd_targets]
[j] ,raw_value_A +1,20);

j++;
values_A_size = j;
target_copy[stringsize] = '1';
stringsize++;
}
}while(raw_value_length <= 25);

stringsize = targetsize;
memset(raw_value_B,0,50);
memset(target_copy,0,50);
memcpy(target_copy,target,targetsize);

j = 0;
do {
raw_value_length = 50;
b58tobin(raw_value_B,&raw_value_length,target_copy,stringsize);
if(raw_value_length < 25) {
target_copy[stringsize] = 'z';
stringsize++;
}
if(raw_value_length == 25) {

b58tobin(raw_value_B,&raw_value_length,target_copy,stringsize);
vanity_rmd_limit_values_B[vanity_rmd_targets] =
(uint8_t**)realloc(vanity_rmd_limit_values_B[vanity_rmd_targets],(j+1) *
sizeof(unsigned char *));
checkpointer((void
*)vanity_rmd_limit_values_B[vanity_rmd_targets],__FILE__,"realloc","vanity_rmd_limi
t_values_B" ,__LINE__ -1 );
checkpointer((void
*)vanity_rmd_limit_values_B[vanity_rmd_targets],__FILE__,"realloc","vanity_rmd_limi
t_values_B" ,__LINE__ -1 );
vanity_rmd_limit_values_B[vanity_rmd_targets][j] =
(uint8_t*)calloc(20,1);
checkpointer((void
*)vanity_rmd_limit_values_B[vanity_rmd_targets]
[j],__FILE__,"calloc","vanity_rmd_limit_values_B" ,__LINE__ -1 );
memcpy(vanity_rmd_limit_values_B[vanity_rmd_targets]
[j],raw_value_B+1,20);

j++;
values_B_size = j;

target_copy[stringsize] = 'z';
stringsize++;
}
}while(raw_value_length <= 25);

if(values_A_size >= 1 && values_B_size >= 1) {

if(values_A_size != values_B_size) {
if(values_A_size > values_B_size)
r = values_B_size;
else
r = values_A_size;
}
else {
r = values_A_size;
}
for(j = 0; j < r; j++) {
minimun_bytes =
minimum_same_bytes(vanity_rmd_limit_values_A[vanity_rmd_targets]
[j],vanity_rmd_limit_values_B[vanity_rmd_targets][j],20);
if(minimun_bytes < vanity_rmd_minimun_bytes_check_length) {
vanity_rmd_minimun_bytes_check_length = minimun_bytes;
}
}
vanity_address_targets[vanity_rmd_targets] = (char*)
calloc(targetsize+1,sizeof(char));
checkpointer((void
*)vanity_address_targets[vanity_rmd_targets],__FILE__,"calloc","vanity_address_targ
ets" ,__LINE__ -1 );
memcpy(vanity_address_targets[vanity_rmd_targets],target,targetsize+1);
// +1 to copy the null character
vanity_rmd_limits[vanity_rmd_targets] = r;
vanity_rmd_total+=r;
vanity_rmd_targets++;
}
else {
for(j = 0; j < values_A_size;j++) {
free(vanity_rmd_limit_values_A[vanity_rmd_targets][j]);
}
free(vanity_rmd_limit_values_A[vanity_rmd_targets]);
vanity_rmd_limit_values_A[vanity_rmd_targets] = NULL;

for(j = 0; j < values_B_size;j++) {

free(vanity_rmd_limit_values_B[vanity_rmd_targets][j]);
}
 free(vanity_rmd_limit_values_B[vanity_rmd_targets]);
vanity_rmd_limit_values_B[vanity_rmd_targets] = NULL;
r = 0;
}
return r;
}

/*
A and B are binary o string data pointers
length the max lenght to check.

Caller must by sure that the pointer are valid and have at least length bytes
readebles witout causing overflow
*/
int minimum_same_bytes(unsigned char* A,unsigned char* B, int length) {
int minBytes = 0; // Assume initially that all bytes are the same
if(A == NULL || B == NULL) { // In case of some NULL pointer
return 0;
}
for (int i = 0; i < length; i++) {
if (A[i] != B[i]) {
break; // Exit the loop since we found a mismatch
}
minBytes++; // Update the minimum number of bytes where data is the same
}

return minBytes;
}

void checkpointer(void *ptr,const char *file,const char *function,const char

*name,int line) {
if(ptr == NULL) {
fprintf(stderr,"[E] error in file %s, %s pointer %s on line %i\
n",file,function,name,line);
exit(EXIT_FAILURE);
}
}

void writekey(bool compressed,Int *key) {

Point publickey;
FILE *keys;
char *hextemp,*hexrmd,public_key_hex[132],address[50],rmdhash[20];
memset(address,0,50);
memset(public_key_hex,0,132);
hextemp = key->GetBase16();
publickey = secp->ComputePublicKey(key);
secp->GetPublicKeyHex(compressed,publickey,public_key_hex);
secp->GetHash160(P2PKH,compressed,publickey,(uint8_t*)rmdhash);
hexrmd = tohex(rmdhash,20);
rmd160toaddress_dst(rmdhash,address);

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(write_keys, INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
 fprintf(keys,"Private Key: %s\npubkey: %s\nAddress %s\nrmd160 %s\
n",hextemp,public_key_hex,address,hexrmd);
fclose(keys);
}
printf("\nHit! Private Key: %s\npubkey: %s\nAddress %s\nrmd160 %s\
n",hextemp,public_key_hex,address,hexrmd);

#if defined(_WIN64) && !defined(__CYGWIN__)

ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif
free(hextemp);
free(hexrmd);
}

void writekeyeth(Int *key) {

Point publickey;
FILE *keys;
char *hextemp,address[43],hash[20];
hextemp = key->GetBase16();
publickey = secp->ComputePublicKey(key);
generate_binaddress_eth(publickey,(unsigned char*)hash);
address[0] = '0';
address[1] = 'x';
tohex_dst(hash,20,address+2);

#if defined(_WIN64) && !defined(__CYGWIN__)

WaitForSingleObject(write_keys, INFINITE);
#else
pthread_mutex_lock(&write_keys);
#endif
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"Private Key: %s\naddress: %s\n",hextemp,address);
fclose(keys);
}
printf("\n Hit!!!! Private Key: %s\naddress: %s\n",hextemp,address);
#if defined(_WIN64) && !defined(__CYGWIN__)
ReleaseMutex(write_keys);
#else
pthread_mutex_unlock(&write_keys);
#endif
free(hextemp);
}

bool isBase58(char c) {
// Define the base58 set
const char base58Set[] =
"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
// Check if the character is in the base58 set
return strchr(base58Set, c) != NULL;
}

bool isValidBase58String(char *str) {

int len = strlen(str);
bool continuar = true;
for (int i = 0; i < len && continuar; i++) {
continuar = isBase58(str[i]);
 }
return continuar;
}

bool processOneVanity() {
int i,k;
if(vanity_rmd_targets == 0) {
fprintf(stderr,"[E] There aren't any vanity targets\n");
return false;
}

if(!initBloomFilter(vanity_bloom, vanity_rmd_total))
return false;

for(i = 0; i < vanity_rmd_targets;i++) {

for(k = 0; k < vanity_rmd_limits[i]; k++) {
bloom_add(vanity_bloom, vanity_rmd_limit_values_A[i]
[k] ,vanity_rmd_minimun_bytes_check_length);
}
}
return true;
}

bool readFileVanity(char *fileName) {

FILE *fileDescriptor;
int i,k,len;
char aux[100],*hextemp;

fileDescriptor = fopen(fileName,"r");
if(fileDescriptor == NULL) {
if(vanity_rmd_targets == 0) {
fprintf(stderr,"[E] There aren't any vanity targets\n");
return false;
}
}
else {
while(!feof(fileDescriptor)) {
hextemp = fgets(aux,100,fileDescriptor);
if(hextemp == aux) {
trim(aux," \t\n\r");
len = strlen(aux);
if(len > 0 && len < 36){
if(isValidBase58String(aux)) {
addvanity(aux);
}
else {
fprintf(stderr,"[E] the string \"%s\" is not
valid Base58, omiting it\n",aux);
}
}
}
}
fclose(fileDescriptor);
}

N = vanity_rmd_total;
if(!initBloomFilter(vanity_bloom,N))
return false;
 for(i = 0; i < vanity_rmd_targets ; i++) {
for(k = 0; k < vanity_rmd_limits[i]; k++) {
bloom_add(vanity_bloom, vanity_rmd_limit_values_A[i]
[k] ,vanity_rmd_minimun_bytes_check_length);
}
}
return true;
}

bool readFileAddress(char *fileName) {

FILE *fileDescriptor;
char fileBloomName[30]; /* Actually it is Bloom and Table but just to keep
the variable name short*/
uint8_t checksum[32],hexPrefix[9];
char dataChecksum[32],bloomChecksum[32];
size_t bytesRead;
uint64_t dataSize;
/*
if the FLAGSAVEREADFILE is Set to 1 we need to the checksum and check
if we have that information already saved
*/
if(FLAGSAVEREADFILE) { /* if the flag is set to REAd and SAVE the file
firs we need to check it the file exist*/
if(!sha256_file((const char*)fileName,checksum)){
fprintf(stderr,"[E] sha256_file error line %i\n",__LINE__ - 1);
return false;
}
tohex_dst((char*)checksum,4,(char*)hexPrefix); // we save the prefix
(last fourt bytes) hexadecimal value
snprintf(fileBloomName,30,"data_%s.dat",hexPrefix);
fileDescriptor = fopen(fileBloomName,"rb");
if(fileDescriptor != NULL) {
printf("[+] Reading file %s\n",fileBloomName);

//read bloom checksum (expected value to be checked)

//read bloom filter structure
//read bloom filter data
//calculate checksum of the current readed data
//Compare checksums
//read data checksum (expected value to be checked)
//read data size
//read data
//compare the expected datachecksum againts the current data
checksum
//compare the expected bloom checksum againts the current bloom
checksum

//read bloom checksum (expected value to be checked)

bytesRead = fread(bloomChecksum,1,32,fileDescriptor);
if(bytesRead != 32) {
fprintf(stderr,"[E] Errore reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}

//read bloom filter structure

 bytesRead = fread(&bloom,1,sizeof(struct bloom),fileDescriptor);
if(bytesRead != sizeof(struct bloom)) {
fprintf(stderr,"[E] Error reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}

printf("[+] Bloom filter for %" PRIu64 " elements.\

n",bloom.entries);

bloom.bf = (uint8_t*) malloc(bloom.bytes);

if(bloom.bf == NULL) {
fprintf(stderr,"[E] Error allocating memory, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}

//read bloom filter data

bytesRead = fread(bloom.bf,1,bloom.bytes,fileDescriptor);
if(bytesRead != bloom.bytes) {
fprintf(stderr,"[E] Error reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}
if(FLAGSKIPCHECKSUM == 0){

//calculate checksum of the current readed data

sha256((uint8_t*)bloom.bf,bloom.bytes,(uint8_t*)checksum);

//Compare checksums
/*
if(FLAGDEBUG) {
hextemp = tohex((char*)checksum,32);
printf("[D] Current Bloom checksum %s\n",hextemp);
free(hextemp);
}
*/
if(memcmp(checksum,bloomChecksum,32) != 0) {
fprintf(stderr,"[E] Error checksum mismatch, code
line %i\n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}
}

/*
if(FLAGDEBUG) {
hextemp = tohex((char*)bloom.bf,32);
printf("[D] first 32 bytes of the bloom : %s\n",hextemp);
bloom_print(&bloom);
printf("[D] bloom.bf points to %p\n",bloom.bf);
}
*/

bytesRead = fread(dataChecksum,1,32,fileDescriptor);
if(bytesRead != 32) {
 fprintf(stderr,"[E] Errore reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}

bytesRead = fread(&dataSize,1,sizeof(uint64_t),fileDescriptor);
if(bytesRead != sizeof(uint64_t)) {
fprintf(stderr,"[E] Errore reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}
N = dataSize / sizeof(struct address_value);

printf("[+] Allocating memory for %" PRIu64 " elements: %.2f MB\
n",N,(double)(((double) sizeof(struct address_value)*N)/(double)1048576));

addressTable = (struct address_value*) malloc(dataSize);

if(addressTable == NULL) {
fprintf(stderr,"[E] Error allocating memory, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}

bytesRead = fread(addressTable,1,dataSize,fileDescriptor);
if(bytesRead != dataSize) {
fprintf(stderr,"[E] Error reading file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}
if(FLAGSKIPCHECKSUM == 0) {

sha256((uint8_t*)addressTable,dataSize,(uint8_t*)checksum);
if(memcmp(checksum,dataChecksum,32) != 0) {
fprintf(stderr,"[E] Error checksum mismatch, code
line %i\n",__LINE__ - 2);
fclose(fileDescriptor);
return false;
}
}
//printf("[D] bloom.bf points to %p\n",bloom.bf);
FLAGREADEDFILE1 = 1; /* We mark the file as readed*/
fclose(fileDescriptor);
MAXLENGTHADDRESS = sizeof(struct address_value);
}
}
if(FLAGVANITY) {
processOneVanity();
}
if(!FLAGREADEDFILE1) {
/*
if the data_ file doesn't exist we need read it first:
*/
switch(FLAGMODE) {
case MODE_ADDRESS:
if(FLAGCRYPTO == CRYPTO_BTC) {
 return forceReadFileAddress(fileName);
}
if(FLAGCRYPTO == CRYPTO_ETH) {
return forceReadFileAddressEth(fileName);
}
break;
case MODE_MINIKEYS:
case MODE_RMD160:
return forceReadFileAddress(fileName);
break;
case MODE_XPOINT:
return forceReadFileXPoint(fileName);
break;
default:
return false;
break;
}
}
return true;
}

bool forceReadFileAddress(char *fileName) {

/* Here we read the original file as usual */
FILE *fileDescriptor;
bool validAddress;
uint64_t numberItems,i;
size_t r,raw_value_length;
uint8_t rawvalue[50];
char aux[100],*hextemp;
fileDescriptor = fopen(fileName,"r");
if(fileDescriptor == NULL) {
fprintf(stderr,"[E] Error opening the file %s, line %i\
n",fileName,__LINE__ - 2);
return false;
}

/*Count lines in the file*/

numberItems = 0;
while(!feof(fileDescriptor)) {
hextemp = fgets(aux,100,fileDescriptor);
trim(aux," \t\n\r");
if(hextemp == aux) {
r = strlen(aux);
if(r > 20) {
numberItems++;
}
}
}
fseek(fileDescriptor,0,SEEK_SET);
MAXLENGTHADDRESS = 20; /*20 bytes beacuase we only need the data in
binary*/

printf("[+] Allocating memory for %" PRIu64 " elements: %.2f MB\
n",numberItems,(double)(((double) sizeof(struct
address_value)*numberItems)/(double)1048576));
addressTable = (struct address_value*) malloc(sizeof(struct
address_value)*numberItems);
checkpointer((void *)addressTable,__FILE__,"malloc","addressTable" ,__LINE__
-1 );
 if(!initBloomFilter(&bloom,numberItems))
return false;

i = 0;
while(i < numberItems) {
validAddress = false;
memset(aux,0,100);
memset(addressTable[i].value,0,sizeof(struct address_value));
hextemp = fgets(aux,100,fileDescriptor);
trim(aux," \t\n\r");
r = strlen(aux);
if(r > 0 && r <= 40) {
if(r<40 && isValidBase58String(aux)) { //Address
raw_value_length = 25;
b58tobin(rawvalue,&raw_value_length,aux,r);
if(raw_value_length == 25) {
//hextemp = tohex((char*)rawvalue+1,20);
bloom_add(&bloom, rawvalue+1 ,sizeof(struct
address_value));
memcpy(addressTable[i].value,rawvalue+1,sizeof(struct
address_value));
i++;
validAddress = true;
}
}
if(r == 40 && isValidHex(aux)) { //RMD
hexs2bin(aux,rawvalue);
bloom_add(&bloom, rawvalue ,sizeof(struct address_value));
memcpy(addressTable[i].value,rawvalue,sizeof(struct
address_value));
i++;
validAddress = true;
}
}
if(!validAddress) {
fprintf(stderr,"[I] Ommiting invalid line %s\n",aux);
numberItems--;
}
}
N = numberItems;
return true;
}

bool forceReadFileAddressEth(char *fileName) {

/* Here we read the original file as usual */
FILE *fileDescriptor;
bool validAddress;
uint64_t numberItems,i;
size_t r;
uint8_t rawvalue[50];
char aux[100],*hextemp;
fileDescriptor = fopen(fileName,"r");
if(fileDescriptor == NULL) {
fprintf(stderr,"[E] Error opening the file %s, line %i\
n",fileName,__LINE__ - 2);
return false;
}
/*Count lines in the file*/
 numberItems = 0;
while(!feof(fileDescriptor)) {
hextemp = fgets(aux,100,fileDescriptor);
trim(aux," \t\n\r");
if(hextemp == aux) {
r = strlen(aux);
if(r >= 40) {
numberItems++;
}
}
}
fseek(fileDescriptor,0,SEEK_SET);

MAXLENGTHADDRESS = 20; /*20 bytes beacuase we only need the data in

binary*/
N = numberItems;

printf("[+] Allocating memory for %" PRIu64 " elements: %.2f MB\
n",numberItems,(double)(((double) sizeof(struct
address_value)*numberItems)/(double)1048576));
addressTable = (struct address_value*) malloc(sizeof(struct
address_value)*numberItems);
checkpointer((void *)addressTable,__FILE__,"malloc","addressTable" ,__LINE__
-1 );

if(!initBloomFilter(&bloom,N))
return false;

i = 0;
while(i < numberItems) {
validAddress = false;
memset(aux,0,100);
memset(addressTable[i].value,0,sizeof(struct address_value));
hextemp = fgets(aux,100,fileDescriptor);
trim(aux," \t\n\r");
r = strlen(aux);
if(r >= 40 && r <= 42){
switch(r) {
case 40:
if(isValidHex(aux)){
hexs2bin(aux,rawvalue);
bloom_add(&bloom, rawvalue ,sizeof(struct
address_value));

memcpy(addressTable[i].value,rawvalue,sizeof(struct address_value));

i++;
validAddress = true;
}
break;
case 42:
if(isValidHex(aux+2)){
hexs2bin(aux+2,rawvalue);
bloom_add(&bloom, rawvalue ,sizeof(struct
address_value));

memcpy(addressTable[i].value,rawvalue,sizeof(struct address_value));
 i++;
validAddress = true;
}
break;
}
}
if(!validAddress) {
fprintf(stderr,"[I] Ommiting invalid line %s\n",aux);
numberItems--;
}
}

fclose(fileDescriptor);
return true;
}

bool forceReadFileXPoint(char *fileName) {

/* Here we read the original file as usual */
FILE *fileDescriptor;
uint64_t numberItems,i;
size_t r,lenaux;
uint8_t rawvalue[100];
char aux[1000],*hextemp;
Tokenizer tokenizer_xpoint; //tokenizer
fileDescriptor = fopen(fileName,"r");
if(fileDescriptor == NULL) {
fprintf(stderr,"[E] Error opening the file %s, line %i\
n",fileName,__LINE__ - 2);
return false;
}
/*Count lines in the file*/
numberItems = 0;
while(!feof(fileDescriptor)) {
hextemp = fgets(aux,1000,fileDescriptor);
trim(aux," \t\n\r");
if(hextemp == aux) {
r = strlen(aux);
if(r >= 40) {
numberItems++;
}
}
}
fseek(fileDescriptor,0,SEEK_SET);

MAXLENGTHADDRESS = 20; /*20 bytes beacuase we only need the data in

binary*/

printf("[+] Allocating memory for %" PRIu64 " elements: %.2f MB\
n",numberItems,(double)(((double) sizeof(struct
address_value)*numberItems)/(double)1048576));
addressTable = (struct address_value*) malloc(sizeof(struct
address_value)*numberItems);
checkpointer((void *)addressTable,__FILE__,"malloc","addressTable" ,__LINE__
- 1);

N = numberItems;
 if(!initBloomFilter(&bloom,N))
return false;

i= 0;
while(i < N) {
memset(aux,0,1000);
hextemp = fgets(aux,1000,fileDescriptor);
memset((void *)&addressTable[i],0,sizeof(struct address_value));
if(hextemp == aux) {
trim(aux," \t\n\r");
stringtokenizer(aux,&tokenizer_xpoint);
hextemp = nextToken(&tokenizer_xpoint);
lenaux = strlen(hextemp);
if(isValidHex(hextemp)) {
switch(lenaux) {
case 64: /*X value*/
r = hexs2bin(aux,(uint8_t*) rawvalue);
if(r) {

memcpy(addressTable[i].value,rawvalue,20);

bloom_add(&bloom,rawvalue,MAXLENGTHADDRESS);
}
else {
fprintf(stderr,"[E] error hexs2bin\n");
}
break;
case 66: /*Compress publickey*/
r = hexs2bin(aux+2, (uint8_t*)rawvalue);
if(r) {

memcpy(addressTable[i].value,rawvalue,20);

bloom_add(&bloom,rawvalue,MAXLENGTHADDRESS);
}
else {
fprintf(stderr,"[E] error hexs2bin\n");
}
break;
case 130: /* Uncompress publickey length*/
r = hexs2bin(aux, (uint8_t*) rawvalue);
if(r) {

memcpy(addressTable[i].value,rawvalue+2,20);

bloom_add(&bloom,rawvalue,MAXLENGTHADDRESS);
}
else {
fprintf(stderr,"[E] error hexs2bin\n");
}
break;
default:
fprintf(stderr,"[E] Omiting line unknow length
size %li: %s\n",lenaux,aux);
break;
}
}
else {
fprintf(stderr,"[E] Ignoring invalid hexvalue %s\n",aux);
 }
freetokenizer(&tokenizer_xpoint);
}
else {
fprintf(stderr,"[E] Omiting line : %s\n",aux);
N--;
}
i++;
}
fclose(fileDescriptor);
return true;
}

/*
I write this as a function because i have the same segment of code in 3
different functions
*/

bool initBloomFilter(struct bloom *bloom_arg,uint64_t items_bloom) {

bool r = true;
printf("[+] Bloom filter for %" PRIu64 " elements.\n",items_bloom);
if(items_bloom <= 10000) {
if(bloom_init2(bloom_arg,10000,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init for 10000 elements.\n");
r = false;
}
}
else {
if(bloom_init2(bloom_arg,FLAGBLOOMMULTIPLIER*items_bloom,0.000001)
== 1){
fprintf(stderr,"[E] error bloom_init for %" PRIu64 " elements.\
n",items_bloom);
r = false;
}
}
printf("[+] Loading data to the bloomfilter total: %.2f MB\n",(double)
(((double) bloom_arg->bytes)/(double)1048576));
return r;
}

void writeFileIfNeeded(const char *fileName) {

//printf("[D] FLAGSAVEREADFILE %i, FLAGREADEDFILE1 %i\
n",FLAGSAVEREADFILE,FLAGREADEDFILE1);
if(FLAGSAVEREADFILE && !FLAGREADEDFILE1) {
FILE *fileDescriptor;
char fileBloomName[30];
uint8_t checksum[32],hexPrefix[9];
char dataChecksum[32],bloomChecksum[32];
size_t bytesWrite;
uint64_t dataSize;
if(!sha256_file((const char*)fileName,checksum)){
fprintf(stderr,"[E] sha256_file error line %i\n",__LINE__ - 1);
exit(EXIT_FAILURE);
}
tohex_dst((char*)checksum,4,(char*)hexPrefix); // we save the prefix
(last fourt bytes) hexadecimal value
snprintf(fileBloomName,30,"data_%s.dat",hexPrefix);
fileDescriptor = fopen(fileBloomName,"wb");
 dataSize = N * (sizeof(struct address_value));
printf("[D] size data %li\n",dataSize);
if(fileDescriptor != NULL) {
printf("[+] Writing file %s ",fileBloomName);

//calculate bloom checksum

//write bloom checksum (expected value to be checked)
//write bloom filter structure
//write bloom filter data

//calculate dataChecksum
//write data checksum (expected value to be checked)
//write data size
//write data

sha256((uint8_t*)bloom.bf,bloom.bytes,(uint8_t*)bloomChecksum);
printf(".");
bytesWrite = fwrite(bloomChecksum,1,32,fileDescriptor);
if(bytesWrite != 32) {
fprintf(stderr,"[E] Errore writing file, code line %i\
n",__LINE__ - 2);
exit(EXIT_FAILURE);
}
printf(".");

bytesWrite = fwrite(&bloom,1,sizeof(struct
bloom),fileDescriptor);
if(bytesWrite != sizeof(struct bloom)) {
fprintf(stderr,"[E] Error writing file, code line %i\
n",__LINE__ - 2);
exit(EXIT_FAILURE);
}
printf(".");

bytesWrite = fwrite(bloom.bf,1,bloom.bytes,fileDescriptor);
if(bytesWrite != bloom.bytes) {
fprintf(stderr,"[E] Error writing file, code line %i\
n",__LINE__ - 2);
fclose(fileDescriptor);
exit(EXIT_FAILURE);
}
printf(".");

/*
if(FLAGDEBUG) {
hextemp = tohex((char*)bloom.bf,32);
printf("\n[D] first 32 bytes bloom : %s\n",hextemp);
bloom_print(&bloom);
free(hextemp);
}
*/
 sha256((uint8_t*)addressTable,dataSize,(uint8_t*)dataChecksum);
printf(".");

bytesWrite = fwrite(dataChecksum,1,32,fileDescriptor);
if(bytesWrite != 32) {
fprintf(stderr,"[E] Errore writing file, code line %i\
n",__LINE__ - 2);
exit(EXIT_FAILURE);
}
printf(".");

bytesWrite = fwrite(&dataSize,1,sizeof(uint64_t),fileDescriptor);
if(bytesWrite != sizeof(uint64_t)) {
fprintf(stderr,"[E] Errore writing file, code line %i\
n",__LINE__ - 2);
exit(EXIT_FAILURE);
}
printf(".");

bytesWrite = fwrite(addressTable,1,dataSize,fileDescriptor);
if(bytesWrite != dataSize) {
fprintf(stderr,"[E] Error writing file, code line %i\
n",__LINE__ - 2);
exit(EXIT_FAILURE);
}
printf(".");

FLAGREADEDFILE1 = 1;
fclose(fileDescriptor);
printf("\n");
}
}
}

void calcualteindex(int i,Int *key) {

if(i == 0) {
key->Set(&BSGS_M3);
}
else {
key->SetInt32(i);
key->Mult(&BSGS_M3_double);
key->Add(&BSGS_M3);
}
}