highperfocused/keyhunt
1
0
Fork 0
mirror of https://github.com/albertobsd/keyhunt.git synced 2025-03-17 21:31:49 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
keyhunt/keyhunt.c
Luis Alberto 62546d3599
Revert "Development"
2021-10-07 23:12:47 -05:00

2749 lines
80 KiB
C
Raw Permalink Blame History

/*
Develop by Luis Alberto
email: alberto.bsd@gmail.com
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <math.h>
#include <time.h>
#include <vector>
#include <inttypes.h>
#include "base58/libbase58.h"
#include "rmd160/rmd160.h"
#include "sha256/sha256.h"
#include "bloom/bloom.h"
#include "sha3/sha3.h"
#include "secp256k1/SECP256k1.h"
#include "secp256k1/Point.h"
#include "secp256k1/Int.h"
#include "secp256k1/IntGroup.h"
#include "secp256k1/Random.h"
#include "util.h"
#ifdef WIN32
#include <windows.h>
#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 SEARCH_UNCOMPRESS 0
#define SEARCH_COMPRESS 1
#define SEARCH_BOTH 2
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;
};
struct __attribute__((__packed__)) publickey {
uint8_t parity;
union {
uint8_t data8[32];
uint32_t data32[8];
uint64_t data64[4];
} X;
};
const char *version = "0.1.20210412 secp256k1";
const char *bloomnames[256] = {"bloom_0","bloom_1","bloom_2","bloom_3","bloom_4","bloom_5","bloom_6","bloom_7","bloom_8","bloom_9","bloom_10","bloom_11","bloom_12","bloom_13","bloom_14","bloom_15","bloom_16","bloom_17","bloom_18","bloom_19","bloom_20","bloom_21","bloom_22","bloom_23","bloom_24","bloom_25","bloom_26","bloom_27","bloom_28","bloom_29","bloom_30","bloom_31","bloom_32","bloom_33","bloom_34","bloom_35","bloom_36","bloom_37","bloom_38","bloom_39","bloom_40","bloom_41","bloom_42","bloom_43","bloom_44","bloom_45","bloom_46","bloom_47","bloom_48","bloom_49","bloom_50","bloom_51","bloom_52","bloom_53","bloom_54","bloom_55","bloom_56","bloom_57","bloom_58","bloom_59","bloom_60","bloom_61","bloom_62","bloom_63","bloom_64","bloom_65","bloom_66","bloom_67","bloom_68","bloom_69","bloom_70","bloom_71","bloom_72","bloom_73","bloom_74","bloom_75","bloom_76","bloom_77","bloom_78","bloom_79","bloom_80","bloom_81","bloom_82","bloom_83","bloom_84","bloom_85","bloom_86","bloom_87","bloom_88","bloom_89","bloom_90","bloom_91","bloom_92","bloom_93","bloom_94","bloom_95","bloom_96","bloom_97","bloom_98","bloom_99","bloom_100","bloom_101","bloom_102","bloom_103","bloom_104","bloom_105","bloom_106","bloom_107","bloom_108","bloom_109","bloom_110","bloom_111","bloom_112","bloom_113","bloom_114","bloom_115","bloom_116","bloom_117","bloom_118","bloom_119","bloom_120","bloom_121","bloom_122","bloom_123","bloom_124","bloom_125","bloom_126","bloom_127","bloom_128","bloom_129","bloom_130","bloom_131","bloom_132","bloom_133","bloom_134","bloom_135","bloom_136","bloom_137","bloom_138","bloom_139","bloom_140","bloom_141","bloom_142","bloom_143","bloom_144","bloom_145","bloom_146","bloom_147","bloom_148","bloom_149","bloom_150","bloom_151","bloom_152","bloom_153","bloom_154","bloom_155","bloom_156","bloom_157","bloom_158","bloom_159","bloom_160","bloom_161","bloom_162","bloom_163","bloom_164","bloom_165","bloom_166","bloom_167","bloom_168","bloom_169","bloom_170","bloom_171","bloom_172","bloom_173","bloom_174","bloom_175","bloom_176","bloom_177","bloom_178","bloom_179","bloom_180","bloom_181","bloom_182","bloom_183","bloom_184","bloom_185","bloom_186","bloom_187","bloom_188","bloom_189","bloom_190","bloom_191","bloom_192","bloom_193","bloom_194","bloom_195","bloom_196","bloom_197","bloom_198","bloom_199","bloom_200","bloom_201","bloom_202","bloom_203","bloom_204","bloom_205","bloom_206","bloom_207","bloom_208","bloom_209","bloom_210","bloom_211","bloom_212","bloom_213","bloom_214","bloom_215","bloom_216","bloom_217","bloom_218","bloom_219","bloom_220","bloom_221","bloom_222","bloom_223","bloom_224","bloom_225","bloom_226","bloom_227","bloom_228","bloom_229","bloom_230","bloom_231","bloom_232","bloom_233","bloom_234","bloom_235","bloom_236","bloom_237","bloom_238","bloom_239","bloom_240","bloom_241","bloom_242","bloom_243","bloom_244","bloom_245","bloom_246","bloom_247","bloom_248","bloom_249","bloom_250","bloom_251","bloom_252","bloom_253","bloom_254","bloom_255"};
std::vector<Point> Gn;
Point _2Gn;
std::vector<Point> GSn;
Point _2GSn;
std::vector<Point> GS2n;
Point _2GS2n;
int CPU_GRP_SIZE = 1024;
void init_generator();
int searchbinary(struct address_value *buffer,char *data,int64_t _N);
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 _N,uint64_t *r_value);
int bsgs_secondcheck(Int *start_range,uint32_t a,uint32_t k_index,Int *privatekey);
void *thread_process(void *vargp);
void *thread_process_bsgs(void *vargp);
void *thread_process_bsgs_random(void *vargp);
void *thread_bPload(void *vargp);
void *thread_bPloadFile(void *vargp);
void *thread_pub2rmd(void *vargp);
char *publickeytohashrmd160(char *pkey,int length);
char *pubkeytopubaddress(char *pkey,int length);
//char *pubkeytopubaddress_eth(char *pkey,int length);
int THREADOUTPUT = 0;
char *bit_range_str_min;
char *bit_range_str_max;
const char *modes[5] = {"xpoint","address","bsgs","rmd160","pub2rmd"};
const char *cryptos[3] = {"btc","eth","all"};
const char *publicsearch[3] = {"uncompress","compress","both"};
const char *default_filename = "addresses.txt";
pthread_t *tid = NULL;
pthread_mutex_t write_keys;
pthread_mutex_t write_random;
pthread_mutex_t bsgs_thread;
struct bloom dummybloom;
struct bloom bloom;
unsigned int *steps = NULL;
unsigned int *ends = NULL;
uint64_t N = 0;
uint64_t N_SECUENTIAL_MAX = 0xffffffff;
uint64_t DEBUGCOUNT = 0x100000;
Int OUTPUTSECONDS;
int FLAGDEBUG = 0;
int FLAGQUIET = 0;
int KFACTOR = 1;
int MAXLENGTHADDRESS = -1;
int NTHREADS = 1;
int FLAGSEARCH = 2;
int FLAGBITRANGE = 0;
int FLAGRANGE = 0;
int FLAGFILE = 0;
int FLAGVANITY = 0;
int FLAGMODE = MODE_ADDRESS;
int FLAGCRYPTO = 0;
int FLAGALREADYSORTED = 0;
int FLAGRAWDATA = 0;
int FLAGRANDOM = 0;
int FLAG_N = 0;
int FLAGPRECALCUTED_P_FILE = 0;
int FLAGPRECALCUTED_MP_FILE = 0;
int FLAGBLOOMFILTER = 0;
int len_vanity;
int bitrange;
char *vanity;
char *range_start;
char *range_end;
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;
struct bsgs_xvalue *bPtable;
struct address_value *addressTable;
struct bloom bloom_bP[256];
struct bloom bloom_bPx2nd; //Second Bloom filter check
uint64_t bloom_bP_totalbytes = 0;
char *precalculated_p_filename;
uint64_t bsgs_m = 4194304;
uint64_t bsgs_m2;
unsigned long int bsgs_aux;
uint32_t bsgs_point_number;
Int BSGS_GROUP_SIZE;
Int BSGS_CURRENT;
Int BSGS_R;
Int BSGS_AUX;
Int BSGS_N;
Int BSGS_M; //M is squareroot(N)
Int BSGS_M2;
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; //MP values this is m2 * P
std::vector<Point> BSGS_AMP,BSGS_AMP2;
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;
Secp256K1 *secp;
int main(int argc, char **argv) {
char buffer[1024];
char temporal[65];
char rawvalue[32];
struct tothread *tt; //tothread
Tokenizer t,tokenizerbsgs,tokenizer_xpoint; //tokenizer
char *filename,*precalculated_mp_filename,*hextemp,*aux,*aux2,*pointx_str,*pointy_str,*str_seconds,*str_total,*str_pretotal;
FILE *fd;
uint64_t j,total_precalculated,i,PERTHREAD,BASE,PERTHREAD_R,itemsbloom,itemsbloom2;
int readed,s,continue_flag,check_flag,r,lenaux,lendiff,c;
Int total,pretotal,debugcount_mpz,seconds;
struct bPload *temp;
secp = new Secp256K1();
secp->Init();
OUTPUTSECONDS.SetInt32(30);
ZERO.SetInt32(0);
ONE.SetInt32(1);
BSGS_GROUP_SIZE.SetInt32(CPU_GRP_SIZE);
rseed(clock() + time(NULL));
printf("[+] Version %s\n",version);
while ((c = getopt(argc, argv, "dehqRwzb:c:f:g:k:l:m:n:p:r:s:t:v:G:")) != -1) {
switch(c) {
case 'h':
printf("\nUsage:\n-h\t\tshow this help\n");
printf("-a file\t\tfile is a binary raw file with the aMP points precalculated. Just work with -m bsgs\n");
printf("-b bits\t\tFor some puzzles you only need some numbers of bits in the test keys.\n");
printf("\t\tThis option only is valid with the Random option -R\n");
printf("-c crypto\tSearch for specific crypo. < btc, eth, all > valid only w/ -m address \n");
printf("-e\t\tThe file is already Sorted descendent. This skip the sorting process.\n");
printf("\t\tYour file MUST be sordted if no you are going to lose collisions\n");
printf("-f file\t\tSpecify filename with addresses or xpoints or uncompressed public keys\n");
printf("-g count\tJust for the stats, mark as counted every debugcount keys \n");
printf("-k value\tUse this only with bsgs mode, k value is factor for M, more speed but more RAM use wisely\n");
printf("-l look\tWhat type of address/hash160 are you looking for < compress , uncompress , both>\n");
printf("-m mode\t\tmode of search for cryptos. ( bsgs , xpoint , rmd160 , address ) default: address (more slow)\n");
printf("-n uptoN\tCheck for N secuential numbers before the random chossen this only work with -R option\n");
printf("\t\tUse -n to set the N for the BSGS process. Bigger N more RAM needed\n");
printf("-p file\t\tfile is a binary raw file with the bP points precalculated. Just work with -m bsgs\n");
printf("-q\t\tset quiet the thread output\n");
printf("-r SR:EN\tStarRange:EndRange, the end range can be omited for search from start range to N-1 ECC value\n");
printf("-R\t\tRandom this is the default behaivor\n");
printf("-s ns\t\tNumber of seconds for the stats output, 0 to omit output.\n");
printf("-t tn\t\tThreads number, must be positive integer\n");
printf("-v va\t\tSearch for vanity Address, only with -m address\n");
printf("-w\t\tMark the input file as RAW data xpoint fixed 32 byte each point. Valid only with -m xpoint\n");
//printf("-z\t\tSave and load bloom bloomfilter from File\n");
printf("\t\tUse the hexcharstoraw tool to create a raw file from your current hexadecimal file\n");
printf("\nExample\n\n");
printf("%s -t 16 -r 00000001:FFFFFFFF -s 0\n\n",argv[0]);
printf("This line run the program with 16 threads from the range 00000001 to FFFFFFFF without stats output\n\n");
printf("Developed by AlbertoBSD\tTips BTC: 1ABSD1rMTmNZHJrJP8AJhDNG1XbQjWcRz7\n");
printf("Thanks to Iceland always helping and sharing his ideas, Tips to Iceland: bc1q39meky2mn5qjq704zz0nnkl0v7kj4uz6r529at\n\n");
exit(0);
break;
case 'a':
FLAGPRECALCUTED_MP_FILE = 1;
precalculated_mp_filename = 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();
MPZAUX.Set(&ONE);
MPZAUX.ShiftL(bitrange);
if(MPZAUX.IsGreater(&secp->order)) {
MPZAUX.Set(&secp->order);
}
bit_range_str_max = MPZAUX.GetBase16();
if(bit_range_str_min == NULL||bit_range_str_max == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
printf("[+] Min range: %s\n",bit_range_str_min);
printf("[+] Max range: %s\n",bit_range_str_max);
FLAGBITRANGE = 1;
}
else {
fprintf(stderr,"[E] invalid bits param: %s.\n",optarg);
}
break;
case 'c':
switch(indexOf(optarg,cryptos,3)) {
case 0: //btc
FLAGCRYPTO = CRYPTO_BTC;
printf("[+] Setting search for btc adddress.\n");
break;
case 1: //eth
FLAGCRYPTO = CRYPTO_ETH;
printf("[+] Setting search for eth adddress.\n");
break;
case 2: //all
FLAGCRYPTO = CRYPTO_ALL;
printf("[+] Setting search for all cryptocurrencies avaible [btc].\n");
break;
default:
FLAGCRYPTO = CRYPTO_NONE;
fprintf(stderr,"[E] Unknow crypto value %s\n",optarg);
break;
}
break;
case 'd':
FLAGDEBUG = 1;
break;
case 'e':
FLAGALREADYSORTED = 1;
break;
case 'f':
FLAGFILE = 1;
filename = optarg;
break;
case 'g':
DEBUGCOUNT = strtol(optarg,NULL,10);
if(DEBUGCOUNT == 0) {
DEBUGCOUNT = 0x100000;
fprintf(stderr,"[E] invalid -g option value: %s.\n",optarg);
}
break;
case 'k':
KFACTOR = (int)strtol(optarg,NULL,10);
if(KFACTOR <= 0) {
KFACTOR = 1;
}
printf("[+] Setting k factor to %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':
switch(indexOf(optarg,modes,5)) {
case MODE_XPOINT: //xpoint
FLAGMODE = MODE_XPOINT;
printf("[+] Setting mode xpoint\n");
break;
case MODE_ADDRESS: //address
FLAGMODE = MODE_ADDRESS;
printf("[+] Setting mode address\n");
break;
case MODE_BSGS:
FLAGMODE = MODE_BSGS;
printf("[+] Setting mode BSGS\n");
break;
case MODE_RMD160:
FLAGMODE = MODE_RMD160;
printf("[+] Setting mode rmd160\n");
break;
case MODE_PUB2RMD:
FLAGMODE = MODE_PUB2RMD;
printf("[+] Setting mode pub2rmd\n");
break;
default:
FLAGMODE = MODE_ADDRESS;
fprintf(stderr,"[+] Unknow mode value %s.\n",optarg);
break;
}
break;
case 'n':
FLAG_N = 1;
N_SECUENTIAL_MAX = strtol(optarg,NULL,10);
if(N_SECUENTIAL_MAX <= 0) {
FLAG_N = 0;
N_SECUENTIAL_MAX = 0xFFFFFFFF;
}
break;
case 'q':
FLAGQUIET = 1;
printf("[+] Set quiet thread output\n");
break;
case 'p':
FLAGPRECALCUTED_P_FILE = 1;
precalculated_p_filename = optarg;
break;
case 'R':
FLAGRANDOM = 1;
printf("[+] Setting random mode.\n");
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)) {
printf("[E] Invalid hexstring : %s\n",range_start);
}
else {
printf("[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 't':
NTHREADS = strtol(optarg,NULL,10);
if(NTHREADS <= 0) {
NTHREADS = 1;
}
printf((NTHREADS > 1) ? "[+] Setting %u threads\n": "[+] Setting %u thread\n",NTHREADS);
break;
case 'v':
FLAGVANITY = 1;
vanity = optarg;
len_vanity = strlen(optarg);
printf("[+] Added Vanity search : %s\n",vanity);
break;
case 'w':
printf("[+] Data marked as RAW\n");
FLAGRAWDATA = 1;
break;
case 'z':
printf("[+] Bloom filter marked to be saved\n");
FLAGBLOOMFILTER = 1;
break;
default:
printf("[E] Unknow opcion %c\n",c);
break;
}
}
init_generator();
if(DEBUGCOUNT > N_SECUENTIAL_MAX) {
DEBUGCOUNT = N_SECUENTIAL_MAX - 1;
}
if(FLAGFILE == 0) {
filename =(char*) default_filename;
}
printf("[+] Opening file %s\n",filename);
fd = fopen(filename,"rb");
if(fd == NULL) {
fprintf(stderr,"[E] Can't open file %s\n",filename);
exit(0);
}
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) {
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) {
aux =(char*) malloc(1000);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
}
switch(FLAGMODE) {
case MODE_ADDRESS:
while(!feof(fd)) {
hextemp = fgets(aux,998,fd);
if(hextemp == aux) {
trim(aux," \t\n\r");
r = strlen(aux);
if(r > 10) { //Any length for invalid Address?
if(r > MAXLENGTHADDRESS) {
MAXLENGTHADDRESS = r;
}
N++;
}
}
}
MAXLENGTHADDRESS = 32;
break;
case MODE_PUB2RMD:
case MODE_RMD160:
if(FLAGRAWDATA) {
while(!feof(fd)) {
if(fread(aux,1,20,fd) == 20) {
N++;
}
}
}
else {
while(!feof(fd)) {
hextemp = fgets(aux,998,fd);
if(hextemp == aux) {
trim(aux," \t\n\r");
r = strlen(aux);
if(r == 40) { //Any length for invalid Address?
N++;
}
}
}
}
MAXLENGTHADDRESS = 20;
break;
case MODE_XPOINT:
if(FLAGRAWDATA) {
while(!feof(fd)) {
if(fread(aux,1,32,fd) == 32) {
N++;
}
}
}
else {
while(!feof(fd)) {
hextemp = fgets(aux,998,fd);
if(hextemp == aux) {
trim(aux," \t\n\r");
r = strlen(aux);
if(r >= 32) { //Any length for invalid Address?
N++;
}
}
}
}
MAXLENGTHADDRESS = 32;
break;
}
free(aux);
if(N == 0) {
fprintf(stderr,"[E] There is no valid data in the file\n");
exit(0);
}
fseek(fd,0,SEEK_SET);
printf("[+] Allocating memory for %" PRIu64 " elements: %.2f MB\n",N,(double)(((double) sizeof(struct address_value)*N)/(double)1048576));
i = 0;
addressTable = (struct address_value*) malloc(sizeof(struct address_value)*N);
if(addressTable == NULL) {
fprintf(stderr,"[E] Can't alloc memory for %" PRIu64 " elements\n",N);
exit(0);
}
printf("[+] Initializing bloom filter for %" PRIu64 " elements.\n",N);
if(N <= 1000) {
if(bloom_init2(&bloom,1000,0.00001) == 1){
fprintf(stderr,"[E] error bloom_init for 10000 elements.\n");
exit(0);
}
}
else {
if(bloom_init2(&bloom,N,0.00001) == 1){
fprintf(stderr,"[E] error bloom_init for %" PRIu64 " elements.\n",N);
fprintf(stderr,"[+] man enough is enough stop it\n");
exit(0);
}
}
printf("[+] Loading data to the bloomfilter total: %.2f MB\n",(double)(((double) bloom.bytes)/(double)1048576));
i = 0;
switch (FLAGMODE) {
case MODE_ADDRESS:
aux =(char*) malloc(2*MAXLENGTHADDRESS);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
while(i < N) {
memset(aux,0,2*MAXLENGTHADDRESS);
memset((void *)&addressTable[i],0,sizeof(struct address_value));
hextemp = fgets(aux,2*MAXLENGTHADDRESS,fd);
if(hextemp == aux) {
trim(aux," \t\n\r");
bloom_add(&bloom, aux,MAXLENGTHADDRESS);
memcpy(addressTable[i].value,aux,20);
i++;
}
else {
trim(aux," \t\n\r");
fprintf(stderr,"[E] Omiting line : %s\n",aux);
}
}
break;
case MODE_XPOINT:
if(FLAGRAWDATA) {
aux = (char*)malloc(MAXLENGTHADDRESS);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
while(i < N) {
if(fread(aux,1,MAXLENGTHADDRESS,fd) == 32) {
memcpy(addressTable[i].value,aux,20);
bloom_add(&bloom, aux,MAXLENGTHADDRESS);
}
i++;
}
}
else {
aux = (char*) malloc(5*MAXLENGTHADDRESS);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
while(i < N) {
memset(aux,0,5*MAXLENGTHADDRESS);
hextemp = fgets(aux,(5*MAXLENGTHADDRESS) -2,fd);
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*/
memset(temporal,0,65);
memcpy(temporal,aux+2,64);
r = hexs2bin(temporal, (uint8_t*) rawvalue);
if(r) {
memcpy(addressTable[i].value,rawvalue,20);
bloom_add(&bloom,rawvalue,MAXLENGTHADDRESS);
}
else {
fprintf(stderr,"[E] error hexs2bin\n");
}
break;
default:
fprintf(stderr,"[E] Omiting line unknow length size %i: %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++;
}
}
break;
case MODE_PUB2RMD:
case MODE_RMD160:
if(FLAGRAWDATA) {
aux = (char*) malloc(MAXLENGTHADDRESS);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
while(i < N) {
if(fread(aux,1,MAXLENGTHADDRESS,fd) == 20) {
memcpy(addressTable[i].value,aux,20);
bloom_add(&bloom, aux,MAXLENGTHADDRESS);
}
i++;
}
}
else {
aux = (char*) malloc(3*MAXLENGTHADDRESS);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
while(i < N) {
memset(aux,0,3*MAXLENGTHADDRESS);
hextemp = fgets(aux,3*MAXLENGTHADDRESS,fd);
memset(addressTable[i].value,0,20);
if(hextemp == aux) {
trim(aux," \t\n\r");
lenaux = strlen(aux);
if(isValidHex(aux)) {
if(lenaux == 40) {
if(hexs2bin(aux,addressTable[i].value)) {
bloom_add(&bloom,addressTable[i].value,MAXLENGTHADDRESS);
}
else {
fprintf(stderr,"[E] error hexs2bin\n");
}
}
else {
fprintf(stderr,"[E] Ignoring invalid length line %s\n",aux);
}
}
else {
fprintf(stderr,"[E] Ignoring invalid hexvalue %s\n",aux);
}
}
else {
fprintf(stderr,"[E] Omiting line : %s\n",aux);
}
i++;
}
}
break;
}
free(aux);
fclose(fd);
printf("[+] Bloomfilter completed\n");
if(FLAGALREADYSORTED) {
printf("[+] File mark already sorted, skipping sort proccess\n");
printf("[+] %" PRIu64 " values were loaded\n",N);
_sort(addressTable,N);
}
else {
printf("[+] Sorting data ...");
_sort(addressTable,N);
printf(" done! %" PRIu64 " values were loaded and sorted\n",N);
}
}
if(FLAGMODE == MODE_BSGS) {
DEBUGCOUNT = N_SECUENTIAL_MAX ;
aux = (char*) malloc(1024);
if(aux == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
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(0);
}
bsgs_found = (int*) calloc(N,sizeof(int));
OriginalPointsBSGS.reserve(N);
OriginalPointsBSGScompressed = (bool*) malloc(N*sizeof(bool));
pointx_str = (char*) malloc(65);
pointy_str = (char*) malloc(65);
if(pointy_str == NULL || pointx_str == NULL || bsgs_found == NULL) {
fprintf(stderr,"[E] error malloc()\n");
exit(0);
}
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;
/* Somebody use this? To be removed 5/Nov */
/*
case 128: //Without the 04
memcpy(pointx_str,aux2,64);
memcpy(pointy_str,aux2+64,64);
if(isValidHex(pointx_str) && isValidHex(pointy_str)) {
mpz_init_set_str(OriginalPointsBSGS[i].x,pointx_str,16);
mpz_init_set_str(OriginalPointsBSGS[i].y,pointy_str,16);
//printf("Adding point ( %s , %s )\n",pointx_str,pointy_str);
i++;
}
else {
fprintf(stderr,"[E] Some invalid hexdata in the file: %s\n",aux2);
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 {
printf("[E] The file don't have any valid publickeys\n");
exit(0);
}
BSGS_N.SetInt32(0);
BSGS_M.SetInt32(0);
/*
hextemp = BSGS_N.GetBase10();
printf("[+] BSGS_N: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M.GetBase10();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
*/
BSGS_M.SetInt64(bsgs_m);
//printf("[+] bsgs_m: %"PRIu64"\n",bsgs_m);
/*
hextemp = BSGS_N.GetBase10();
printf("[+] BSGS_N: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M.GetBase10();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
*/
if(FLAG_N) { //Custom N by the -n param
BSGS_N.SetInt64(N_SECUENTIAL_MAX);
}
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(0);
}
/*
hextemp = BSGS_N.GetBase16();
printf("[+] BSGS_N: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M.GetBase16();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
*/
BSGS_AUX.Set(&BSGS_M);
BSGS_AUX.Mod(&BSGS_GROUP_SIZE);
if(!BSGS_AUX.IsZero()){
hextemp = BSGS_GROUP_SIZE.GetBase10();
fprintf(stderr,"[E] M value is not divisible by %s\n",hextemp);
exit(0);
}
bsgs_m = BSGS_M.GetInt64();
BSGS_N.Set(&BSGS_M);
BSGS_N.Mult(&BSGS_M);
DEBUGCOUNT = bsgs_m * bsgs_m;
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);
}
}
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);
/*
hextemp = BSGS_N.GetBase16();
printf("[+] BSGS_N: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M.GetBase16();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
*/
if(n_range_diff.IsLower(&BSGS_N) ) {
BSGS_N.Set(&n_range_diff);
if(BSGS_N.HasSqrt()) { //If the root is exact
BSGS_M.Set(&BSGS_N);
BSGS_M.ModSqrt();
/*
hextemp = BSGS_N.GetBase16();
printf("[+] BSGS_N: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M.GetBase16();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
*/
}
else {
fprintf(stderr,"[E] the range is small and doesn't have exact square root\n");
exit(0);
}
bsgs_m = BSGS_M.GetInt64();
BSGS_N.Set(&BSGS_M);
BSGS_N.Mult(&BSGS_M);
DEBUGCOUNT = bsgs_m * bsgs_m;
bsgs_m = BSGS_M.GetInt64();
DEBUGCOUNT = (uint64_t)((uint64_t)bsgs_m * (uint64_t)bsgs_m);
}
BSGS_M.Mult((uint64_t)KFACTOR);
BSGS_AUX.SetInt32(20);
BSGS_R.Set(&BSGS_M);
BSGS_R.Mod(&BSGS_AUX);
BSGS_M2.Set(&BSGS_M);
BSGS_M2.Div(&BSGS_AUX);
if(!BSGS_R.IsZero()) {
BSGS_M2.AddOne();
}
bsgs_m2 = BSGS_M2.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()) {
BSGS_N.Set(&BSGS_M);
BSGS_N.Mult(&BSGS_AUX);
}
bsgs_m = (uint64_t)((uint64_t) bsgs_m * (uint64_t)KFACTOR);
bsgs_aux = BSGS_AUX.GetInt64();
DEBUGCOUNT = (uint64_t)((uint64_t)bsgs_m * (uint64_t)bsgs_aux);
printf("[+] Setting N up to %" PRIu64 ".\n",DEBUGCOUNT);
itemsbloom = ((uint64_t)(bsgs_m/256)) > 10000 ? (uint64_t)(bsgs_m/256) : 10000;
itemsbloom2 = bsgs_m2 > 1000 ? bsgs_m : 10000;
if( FLAGBLOOMFILTER == 1 ) {
int continuebloom = 1;
int numberbloom = 0;
for(i=0; i< 256 && continuebloom; i++) {
if(bloom_loadcustom(&bloom_bP[i],(char*)bloomnames[i]) == 1){
continuebloom = 0;
}
else {
if(bloom_dummy(&dummybloom,itemsbloom,0.000001) == 0){
numberbloom++;
if(dummybloom.bytes != bloom_bP[i].bytes) {
continuebloom = 0;
}
}
else {
continuebloom = 0;
}
}
}
if(continuebloom == 1) {
if(bloom_loadcustom(&bloom_bPx2nd,(char*)"bPx2nd") == 1) {
continuebloom == 0;
}
else {
if(bloom_dummy(&dummybloom,itemsbloom2,0.000001) == 0){
if(dummybloom.bytes != bloom_bPx2nd.bytes) {
continuebloom = 0;
}
if(continuebloom == 0) {
bloom_free(&bloom_bPx2nd);
}
}
}
}
if(continuebloom == 0) {
fprintf(stderr,"[E] Some bloom file fail or missmatch size\n");
FLAGBLOOMFILTER = 0;
for(i=0; i < numberbloom ; i++) {
bloom_free(&bloom_bP[i]);
}
}
}
/*
if( FLAGBLOOMFILTER == 0) {
*/
for(i=0; i< 256; i++) {
if(bloom_init2(&bloom_bP[i],itemsbloom,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init [%" PRIu64 "]\n",i);
exit(0);
}
bloom_bP_totalbytes += bloom_bP[i].bytes;
if(FLAGDEBUG) bloom_print(&bloom_bP[i]);
}
printf("[+] Init 1st bloom filter for %lu elements : %.2f MB\n",bsgs_m,(float)((uint64_t)bloom_bP_totalbytes/(uint64_t)1048576));
if(bsgs_m2 > 1000) {
if(bloom_init2(&bloom_bPx2nd,bsgs_m2,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init for %lu elements\n",bsgs_m2);
exit(0);
}
}
else {
if(bloom_init2(&bloom_bPx2nd,1000,0.000001) == 1){
fprintf(stderr,"[E] error bloom_init for 1000 elements\n");
exit(0);
}
}
if(FLAGDEBUG) bloom_print(&bloom_bPx2nd);
printf("[+] Init 2nd bloom filter for %lu elements : %.2f MB\n",bsgs_m2,(double)((double)bloom_bPx2nd.bytes/(double)1048576));
//bloom_print(&bloom_bPx2nd);
/*
hextemp = BSGS_M.GetBase16();
printf("[+] BSGS_M: %s\n",hextemp);
free(hextemp);
hextemp = BSGS_M2.GetBase16();
printf("[+] BSGS_M2: %s\n",hextemp);
free(hextemp);
*/
BSGS_MP = secp->ComputePublicKey(&BSGS_M);
BSGS_MP2 = secp->ComputePublicKey(&BSGS_M2);
printf("[+] Allocating %.1f MB for %" PRIu64 " aMP Points\n",(double)(((double)(bsgs_aux*sizeof(Point)))/(double)1048576),bsgs_aux);
i = 0;
BSGS_AMP.reserve(bsgs_aux);
//printf("[+] Allocating %.1f MB for aMP Points (2nd)\n",(float)(((uint64_t)(bsgs_m2*sizeof(struct strPoint)))/(uint64_t)1048576));
BSGS_AMP2.reserve(bsgs_m2);
i= 0;
if(FLAGPRECALCUTED_MP_FILE) {
printf("[+] Reading aMP points from file %s\n",precalculated_mp_filename);
fd = fopen(precalculated_mp_filename,"rb");
if(fd != NULL) {
while(!feof(fd) && i < bsgs_aux ) {
if(fread(temporal,1,64,fd) == 64) {
BSGS_AMP[i].x.Set32Bytes((unsigned char*)temporal);
BSGS_AMP[i].x.Set32Bytes((unsigned char*)(temporal+32));
i++;
}
}
if(i < bsgs_aux) { //If the input file have less item than bsgs_m
printf("[+] Fixme file contains less items than the amount of items needed\n");
exit(0);
}
}
else {
fprintf(stderr,"[E] Can't open file %s falling back to the calculation mode\n",filename);
printf("[+] Precalculating %lu aMP points\n",bsgs_aux);
point_temp.Set(BSGS_MP);
for(i = 0; i < bsgs_aux; i++) {
BSGS_AMP[i] = secp->Negation(point_temp);
if(i == 0) {
printf("\n[+] point_temp vs BSGS_MP %s\n",point_temp.equals(BSGS_MP) ? "Si iguales":"No, diferentes");
}
if(point_temp.equals(BSGS_MP)) {
point_temp2 = secp->DoubleDirect(BSGS_MP);
}
else {
point_temp2 = secp->AddDirect(point_temp,BSGS_MP);
}
point_temp.Set(point_temp2);
}
}
}
else {
printf("[+] Precalculating %" PRIu64 " aMP points\n",bsgs_aux);
point_temp.Set(BSGS_MP);
for(i = 0; i < bsgs_aux; i++) {
BSGS_AMP[i] = secp->Negation(point_temp);
if(i == 0) {
point_temp2 = secp->DoubleDirect(BSGS_MP);
}
else {
point_temp2 = secp->AddDirect(point_temp,BSGS_MP);
}
point_temp.Set(point_temp2);
}
}
point_temp.Set(BSGS_MP2);
for(i = 0; i < 20; i++) {
BSGS_AMP2[i] = secp->Negation(point_temp);
if(i == 0) {
point_temp2 = secp->DoubleDirect(BSGS_MP2);
}
else {
point_temp2 = secp->AddDirect(point_temp,BSGS_MP2);
}
point_temp.Set(point_temp2);
}
printf("[+] Allocating %.2f MB for %" PRIu64 " bP Points\n",(double)((double)((uint64_t)bsgs_m2*(uint64_t)sizeof(struct bsgs_xvalue))/(double)1048576),bsgs_m2);
//printf("[+] Allocating %.2f MB for bP Points\n",(float)((uint64_t)((uint64_t)bsgs_m*(uint64_t)sizeof(struct bsgs_xvalue))/(uint64_t)1048576));
bPtable = (struct bsgs_xvalue*) calloc(bsgs_m2,sizeof(struct bsgs_xvalue));
if(bPtable == NULL) {
printf("[E] error malloc()\n");
exit(0);
}
i = 0;
j = 0;
BASE = 0;
PERTHREAD = bsgs_m /NTHREADS;
PERTHREAD_R = bsgs_m % NTHREADS;
temp = (struct bPload *) calloc(NTHREADS,sizeof(struct bPload));
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
if(FLAGPRECALCUTED_P_FILE) {
printf("[+] Reading %lu bP points from file %s\n",bsgs_m,precalculated_p_filename);
for(i = 0; i < NTHREADS; i++) {
temp[i].threadid = i;
temp[i].counter = 0;
if(i < NTHREADS -1) {
temp[i].from = BASE +1;
temp[i].to = BASE + PERTHREAD;
}
else {
temp[i].from = BASE + 1;
temp[i].to = BASE + PERTHREAD + PERTHREAD_R;
}
if(FLAGDEBUG) printf("[I] %lu to %lu\n",temp[i].from,temp[i].to);
s = pthread_create(&tid[i],NULL,thread_bPloadFile,(void *)&temp[i]);
BASE+=PERTHREAD;
}
}
else {
for(i = 0; i < NTHREADS; i++) {
temp[i].counter = 0;
if(i < NTHREADS -1) {
temp[i].from = BASE +1;
temp[i].to = BASE + PERTHREAD;
BASE+=PERTHREAD;
}
else {
temp[i].from = BASE + 1;
temp[i].to = BASE + PERTHREAD + PERTHREAD_R;
BASE+=(PERTHREAD + PERTHREAD_R);
}
if(FLAGDEBUG) printf("[I] %lu to %lu\n",temp[i].from,temp[i].to);
s = pthread_create(&tid[i],NULL,thread_bPload,(void *)&temp[i]);
}
}
total_precalculated = 0;
do {
sleep(1);
total_precalculated = 0;
for(i = 0; i < NTHREADS; i++) {
total_precalculated+=temp[i].counter;
}
printf("\r[+] processing %lu/%lu bP points : %i%%",total_precalculated,bsgs_m,(int) (((double)total_precalculated/(double)bsgs_m)*100));
fflush(stdout);
} while(total_precalculated < bsgs_m);
for(i = 0; i < NTHREADS; i++) {
pthread_join(tid[i], NULL);
}
printf("\n");
free(temp);
free(tid);
printf("[+] Sorting %lu elements... ",bsgs_m2);
bsgs_sort(bPtable,bsgs_m2);
printf("Done!\n");
i = 0;
steps = (unsigned int *) calloc(NTHREADS,sizeof(int));
ends = (unsigned int *) calloc(NTHREADS,sizeof(int));
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
DEBUGCOUNT = (uint64_t)((uint64_t)bsgs_m * (uint64_t)bsgs_aux);
for(i= 0;i < NTHREADS; i++) {
tt = (tothread*) malloc(sizeof(struct tothread));
tt->nt = i;
if(FLAGRANDOM) {
s = pthread_create(&tid[i],NULL,thread_process_bsgs_random,(void *)tt);
}
else {
s = pthread_create(&tid[i],NULL,thread_process_bsgs,(void *)tt);
}
if(s != 0) {
fprintf(stderr,"[E] pthread_create thread_process\n");
exit(0);
}
}
free(aux);
}
if(FLAGMODE != MODE_BSGS) {
steps = (unsigned int *) calloc(NTHREADS,sizeof(int));
ends = (unsigned int *) calloc(NTHREADS,sizeof(int));
tid = (pthread_t *) calloc(NTHREADS,sizeof(pthread_t));
for(i= 0;i < NTHREADS; i++) {
tt = (tothread*) malloc(sizeof(struct tothread));
tt->nt = i;
steps[i] = 0;
switch(FLAGMODE) {
case MODE_ADDRESS:
case MODE_XPOINT:
case MODE_RMD160:
s = pthread_create(&tid[i],NULL,thread_process,(void *)tt);
break;
case MODE_PUB2RMD:
s = pthread_create(&tid[i],NULL,thread_pub2rmd,(void *)tt);
break;
}
if(s != 0) {
fprintf(stderr,"[E] pthread_create thread_process\n");
exit(0);
}
}
}
continue_flag = 1;
total.SetInt32(0);
pretotal.SetInt32(0);
debugcount_mpz.SetInt64(DEBUGCOUNT);
seconds.SetInt32(0);
do {
sleep(1);
seconds.AddOne();
check_flag = 1;
for(i = 0; i <NTHREADS && check_flag; i++) {
check_flag &= ends[i];
}
if(check_flag) {
continue_flag = 0;
}
if(OUTPUTSECONDS.IsGreater(&ZERO) ){
MPZAUX.Set(&seconds);
MPZAUX.Mod(&OUTPUTSECONDS);
if(MPZAUX.IsZero()) {
total.SetInt32(0);
i = 0;
while(i < NTHREADS) {
pretotal.Set(&debugcount_mpz);
pretotal.Mult(steps[i]);
total.Add(&pretotal);
i++;
}
pretotal.Set(&total);
pretotal.Div(&seconds);
str_seconds = seconds.GetBase10();
str_pretotal = pretotal.GetBase10();
str_total = total.GetBase10();
pthread_mutex_lock(&bsgs_thread);
if(THREADOUTPUT == 1) {
sprintf(buffer,"\nTotal %s keys in %s seconds: %s keys/s\r",str_total,str_seconds,str_pretotal);
}
else {
sprintf(buffer,"\rTotal %s keys in %s seconds: %s keys/s\r",str_total,str_seconds,str_pretotal);
}
printf("%s",buffer);
fflush(stdout);
THREADOUTPUT = 0;
pthread_mutex_unlock(&bsgs_thread);
free(str_seconds);
free(str_pretotal);
free(str_total);
}
}
}while(continue_flag);
}
/*
char *pubkeytopubaddress_eth(char *pkey,int length) {
char *temp,*pubaddress = calloc(MAXLENGTHADDRESS,1);
char *digest = malloc(32);
if(digest == NULL || pubaddress == NULL) {
fprintf(stderr,"error malloc()\n");
exit(0);
}
pubaddress[0] = '0';
pubaddress[1] = 'x';
shake256(digest, 256,(const uint8_t* ) pkey, length);
temp = tohex(digest+12,20);
strcpy(pubaddress+2,temp);
free(temp);
free(digest);
return pubaddress;
}
*/
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;
if(pubaddress == NULL || digest == NULL) {
fprintf(stderr,"error malloc()\n");
exit(0);
}
//digest [000...0]
sha256(pkey, length, 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(digest, 21, digest+21);
//digest [0 +RMD160 20 bytes+SHA256 32 bytes+....0]
sha256(digest+21, 32, 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
}
char *publickeytohashrmd160(char *pkey,int length) {
char *hash160 = (char*) malloc(20);
char *digest = (char*) malloc(32);
if(hash160 == NULL || digest == NULL) {
fprintf(stderr,"error malloc()\n");
exit(0);
}
//digest [000...0]
sha256(pkey, length, digest);
//digest [SHA256 32 bytes]
RMD160Data((const unsigned char*)digest,32, hash160);
//hash160 [RMD160 20 bytes]
free(digest);
return hash160; // hash160 need to be free by te caller funtion
}
int searchbinary(struct address_value *buffer,char *data,int64_t _N) {
int64_t half,min,max,current;
int r = 0,rcmp;
min = 0;
current = 0;
max = _N;
half = _N;
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;
}
void *thread_process(void *vargp) {
struct tothread *tt;
Point pts[CPU_GRP_SIZE];
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 hLength = (CPU_GRP_SIZE / 2 - 1);
uint64_t i,j;
Point R,temporal;
uint64_t count = 0;
int r,thread_number,found,continue_flag = 1;
char *public_key_compressed,*public_key_uncompressed,hexstrpoint[65],rawvalue[32];
char *publickeyhashrmd160_compress,*publickeyhashrmd160_uncompress;
char *hextemp,*public_key_compressed_hex,*public_key_uncompressed_hex;
char *eth_address;
char *public_address_compressed,*public_address_uncompressed;
unsigned long longtemp;
FILE *keys,*vanityKeys;
Int key_mpz,mpz_bit_range_min,mpz_bit_range_max,mpz_bit_range_diff;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
found = 0;
grp->Set(dx);
do {
if(FLAGRANDOM){
key_mpz.Rand(&n_range_start,&n_range_end);
}
else {
if(n_range_start.IsLower(&n_range_end)){
pthread_mutex_lock(&write_random);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SECUENTIAL_MAX);
pthread_mutex_unlock(&write_random);
}
else {
continue_flag = 0;
}
}
if(continue_flag) {
count = 0;
do {
if(FLAGQUIET == 0){
hextemp = key_mpz.GetBase16();
printf("\rBase key: %s ",hextemp);
fflush(stdout);
free(hextemp);
THREADOUTPUT = 1;
}
key_mpz.Add((uint64_t)CPU_GRP_SIZE / 2);
startP = secp->ComputePublicKey(&key_mpz);
key_mpz.Sub((uint64_t)CPU_GRP_SIZE / 2);
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(FLAGMODE != MODE_XPOINT ) {
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(FLAGMODE != MODE_XPOINT ) {
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);
}
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(FLAGMODE != MODE_XPOINT ) {
pn.y.ModSub(&Gn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&Gn[i].y);
}
pts[0] = pn;
for(j = 0; j < CPU_GRP_SIZE;j++){
//temporal.Set(R);
switch(FLAGMODE) {
case MODE_ADDRESS:
case MODE_RMD160:
switch(FLAGSEARCH) {
case SEARCH_UNCOMPRESS:
public_key_uncompressed = secp->GetPublicKeyRaw(false,pts[j]);
break;
case SEARCH_COMPRESS:
public_key_compressed = secp->GetPublicKeyRaw(true,pts[j]);
break;
case SEARCH_BOTH:
public_key_uncompressed = secp->GetPublicKeyRaw(false,pts[j]);
public_key_compressed = secp->GetPublicKeyRaw(true,pts[j]);
break;
}
break;
}
switch(FLAGMODE) {
case MODE_ADDRESS:
switch(FLAGSEARCH) {
case SEARCH_UNCOMPRESS:
public_address_uncompressed = pubkeytopubaddress(public_key_uncompressed,65);
break;
case SEARCH_COMPRESS:
public_address_compressed = pubkeytopubaddress(public_key_compressed,33);
break;
case SEARCH_BOTH:
public_address_compressed = pubkeytopubaddress(public_key_compressed,33);
public_address_uncompressed = pubkeytopubaddress(public_key_uncompressed,65);
break;
}
if(FLAGVANITY) {
if(FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH == SEARCH_BOTH){
if(strncmp(public_address_uncompressed,vanity,len_vanity) == 0) {
hextemp = key_mpz.GetBase16();
vanityKeys = fopen("vanitykeys.txt","a+");
if(vanityKeys != NULL) {
fprintf(vanityKeys,"PrivKey: %s\nAddress uncompressed: %s\n",hextemp,public_address_uncompressed);
fclose(vanityKeys);
}
printf("\nVanity privKey: %s\nAddress uncompressed: %s\n",hextemp,public_address_uncompressed);
free(hextemp);
}
}
if(FLAGSEARCH == SEARCH_COMPRESS || FLAGSEARCH == SEARCH_BOTH){
if(strncmp(public_address_compressed,vanity,len_vanity) == 0) {
hextemp = key_mpz.GetBase16();
vanityKeys = fopen("vanitykeys.txt","a+");
if(vanityKeys != NULL) {
fprintf(vanityKeys,"PrivKey: %s\nAddress compressed: %s\n",hextemp,public_address_compressed);
fclose(vanityKeys);
}
printf("\nVanity privKey: %s\nAddress compressed: %s\n",hextemp,public_address_compressed);
free(hextemp);
}
}
}
if(FLAGSEARCH == SEARCH_COMPRESS || FLAGSEARCH == SEARCH_BOTH){
r = bloom_check(&bloom,public_address_compressed,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,public_address_compressed,N);
if(r) {
found++;
hextemp = key_mpz.GetBase16();
public_key_compressed_hex = tohex(public_key_compressed,33);
pthread_mutex_lock(&write_keys);
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_compressed_hex,public_address_compressed);
fclose(keys);
}
printf("\nHIT!! PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_compressed_hex,public_address_compressed);
pthread_mutex_unlock(&write_keys);
free(public_key_compressed_hex);
free(hextemp);
}
}
free(public_address_compressed);
}
if(FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH == SEARCH_BOTH){
r = bloom_check(&bloom,public_address_uncompressed,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,public_address_uncompressed,N);
if(r) {
found++;
hextemp = key_mpz.GetBase16();
public_key_uncompressed_hex = tohex(public_key_uncompressed,65);
pthread_mutex_lock(&write_keys);
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_uncompressed_hex,public_address_uncompressed);
fclose(keys);
}
printf("\nHIT!! PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_uncompressed_hex,public_address_uncompressed);
pthread_mutex_unlock(&write_keys);
free(public_key_uncompressed_hex);
free(hextemp);
}
}
free(public_address_uncompressed);
}
if( (FLAGCRYPTO & CRYPTO_ETH) != 0) {
/*
mpz_export((public_key_uncompressed+1),&longtemp,1,8,1,0,R.x);
mpz_export((public_key_uncompressed+33),&longtemp,1,8,1,0,R.y);
public_address_uncompressed = pubkeytopubaddress_eth(public_key_uncompressed+1,64);
//printf("Testing for %s\n",public_address_uncompressed);
r = bloom_check(&bloom,public_address_uncompressed,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,public_address_uncompressed,N);
if(r) {
hextemp = (char*) malloc(65);
mpz_get_str(hextemp,16,key_mpz);
public_key_uncompressed_hex = tohex(public_key_uncompressed+1,64);
pthread_mutex_lock(&write_keys);
keys = fopen("keys.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_uncompressed_hex,public_address_uncompressed);
fclose(keys);
}
printf("HIT!! PrivKey: %s\npubkey: %s\naddress: %s\n",hextemp,public_key_uncompressed_hex,public_address_uncompressed);
pthread_mutex_unlock(&write_keys);
free(public_key_uncompressed_hex);
free(hextemp);
}
free(public_address_uncompressed);
}
*/
}
break;
case MODE_RMD160:
switch(FLAGSEARCH) {
case SEARCH_UNCOMPRESS:
publickeyhashrmd160_uncompress = publickeytohashrmd160(public_key_uncompressed,65);
break;
case SEARCH_COMPRESS:
publickeyhashrmd160_compress = publickeytohashrmd160(public_key_compressed,33);
break;
case SEARCH_BOTH:
publickeyhashrmd160_compress = publickeytohashrmd160(public_key_compressed,33);
publickeyhashrmd160_uncompress = publickeytohashrmd160(public_key_uncompressed,65);
break;
}
if(FLAGSEARCH == SEARCH_COMPRESS || FLAGSEARCH == SEARCH_BOTH){
r = bloom_check(&bloom,publickeyhashrmd160_compress,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,publickeyhashrmd160_compress,N);
if(r) {
found++;
hextemp = key_mpz.GetBase16();
public_key_compressed_hex = tohex(public_key_compressed,33);
pthread_mutex_lock(&write_keys);
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\n",hextemp,public_key_compressed_hex);
fclose(keys);
}
printf("\nHIT!! PrivKey: %s\npubkey: %s\n",hextemp,public_key_compressed_hex);
pthread_mutex_unlock(&write_keys);
free(public_key_compressed_hex);
free(hextemp);
}
}
free(publickeyhashrmd160_compress);
}
if(FLAGSEARCH == SEARCH_UNCOMPRESS || FLAGSEARCH == SEARCH_BOTH){
r = bloom_check(&bloom,publickeyhashrmd160_uncompress,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,publickeyhashrmd160_uncompress,N);
if(r) {
found++;
hextemp = key_mpz.GetBase16();
public_key_uncompressed_hex = tohex(public_key_uncompressed,65);
pthread_mutex_lock(&write_keys);
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\n",hextemp,public_key_uncompressed_hex);
fclose(keys);
}
printf("\nHIT!! PrivKey: %s\npubkey: %s\n",hextemp,public_key_uncompressed_hex);
pthread_mutex_unlock(&write_keys);
free(public_key_uncompressed_hex);
free(hextemp);
}
}
free(publickeyhashrmd160_uncompress);
}
break;
case MODE_XPOINT:
pts[j].x.Get32Bytes((unsigned char *)rawvalue);
r = bloom_check(&bloom,rawvalue,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,rawvalue,N);
if(r) {
found++;
hextemp = key_mpz.GetBase16();
R = secp->ComputePublicKey(&key_mpz);
public_key_compressed = secp->GetPublicKeyHex(true,R);
printf("\nHIT!! PrivKey: %s\npubkey: %s\n",hextemp,public_key_compressed);
pthread_mutex_lock(&write_keys);
keys = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(keys != NULL) {
fprintf(keys,"PrivKey: %s\npubkey: %s\n",hextemp,public_key_compressed);
fclose(keys);
}
pthread_mutex_unlock(&write_keys);
free(public_key_compressed);
free(hextemp);
}
}
break;
}
if(FLAGMODE == MODE_ADDRESS || FLAGMODE == MODE_RMD160) {
switch(FLAGSEARCH) {
case SEARCH_UNCOMPRESS:
free(public_key_uncompressed);
break;
case SEARCH_COMPRESS:
free(public_key_compressed);
break;
case SEARCH_BOTH:
free(public_key_compressed);
free(public_key_uncompressed);
break;
}
}
count++;
if(count % DEBUGCOUNT == 0) {
steps[thread_number]++;
}
key_mpz.AddOne();
}
// 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;
}while(count <= N_SECUENTIAL_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;
char *hextemp;
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;
char *hextemp;
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 _N,uint64_t *r_value) {
char *temp_read;
int64_t min,max,half,current;
int r = 0,rcmp;
min = 0;
current = 0;
max = _N;
half = _N;
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;
}
void *thread_process_bsgs(void *vargp) {
FILE *filekey;
struct tothread *tt;
char xpoint_raw[32],*aux_c,*hextemp;
Int base_key,keyfound;
Point base_point,point_aux,point_aux2,point_found,BSGS_S,BSGS_Q,BSGS_Q_AMP;
uint32_t i,j,k,r,salir,thread_number,bloom_counter =0;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
pthread_mutex_lock(&bsgs_thread);
/* we need to set our base_key to the current BSGS_CURRENT value*/
base_key.Set(&BSGS_CURRENT);
BSGS_CURRENT.Add(&BSGS_N);
/*Then add BSGS_N to BSGS_CURRENT*/
/*
We do this in an atomic pthread_mutex operation to not affect others threads
so BSGS_CURRENT is never the same between threads
*/
pthread_mutex_unlock(&bsgs_thread);
/*
while base_key is less than n_range_end then:
*/
while(base_key.IsLower(&n_range_end) ) {
//gmp_printf("While cycle: base_key : %Zd < n_range_end: %Zd\n",base_key,n_range_end);
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread %s ",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
/*
Set base_point in to base_key * G
base_point = base_key * G
*/
// printf("[D] bsgs_point_number %u\n",bsgs_point_number);
base_point = secp->ComputePublicKey(&base_key);
/*
We are going to need -( base_point * G)
point_aux = -( base_point * G)
*/
point_aux = secp->Negation(base_point);
/*
hextemp = secp->GetPublicKeyHex(false,point_aux);
printf("point_aux %s\n",hextemp);
free(hextemp);
hextemp = secp->GetPublicKeyHex(false,base_point);
printf("base_point %s\n",hextemp);
free(hextemp);
*/
for(k = 0; k < bsgs_point_number ; k++) {
if(bsgs_found[k] == 0) {
/*reset main variabler before the do-while cicle*/
/* Main cycle
for every a in 0 to bsgs_m
*/
salir = 0;
i = 0;
BSGS_Q = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
BSGS_S.Set(BSGS_Q);
do {
/*
if(i == 52428 || i == 0 || i == 1) {
aux_c = secp->GetPublicKeyHex(false,BSGS_S);
hextemp = secp->GetPublicKeyHex(false,BSGS_AMP[i]);
printf("\r[d] Debug: %s : %u\n",aux_c,i);
printf("[d] Debug: BSGS_AMP %s : %u\n",hextemp,i);
free(aux_c);
free(hextemp);
}
*/
/* We need to test individually every point in BSGS_Q */
/*Extract BSGS_S.x into xpoint_raw*/
BSGS_S.x.Get32Bytes((unsigned char*)xpoint_raw);
/* Lookup for the xpoint_raw into the bloom filter*/
r = bloom_check(&bloom_bP[((unsigned char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
bloom_counter++;
/* Lookup for the xpoint_raw into the full sorted list*/
//r = bsgs_searchbinary(bPtable,xpoint_raw,bsgs_m,&j);
r = bsgs_secondcheck(&base_key,i,k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("\n[+] Thread Key found privkey %s\n",hextemp);
point_aux2 = secp->ComputePublicKey(&keyfound);
aux_c = secp->GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_aux2);
printf("[+] Publickey %s\n",aux_c);
pthread_mutex_lock(&write_keys);
filekey = fopen("KEYFOUNDKEYFOUND.txt","a");
if(filekey != NULL) {
fprintf(filekey,"Key found privkey %s\nPublickey %s\n",hextemp,aux_c);
fclose(filekey);
}
pthread_mutex_unlock(&write_keys);
free(hextemp);
free(aux_c);
bsgs_found[k] = 1;
salir = 1;
for(j = 0; j < bsgs_point_number && salir; j++) {
salir &= bsgs_found[j];
}
if(salir) {
printf("All points were found\n");
exit(0);
}
}
}
BSGS_Q_AMP = secp->AddDirect(BSGS_Q,BSGS_AMP[i]);
BSGS_S.Set(BSGS_Q_AMP);
i++;
}while( i < bsgs_aux && !bsgs_found[k]);
} //end if
}// End for
steps[thread_number]++;
pthread_mutex_lock(&bsgs_thread);
base_key.Set(&BSGS_CURRENT);
BSGS_CURRENT.Add(&BSGS_N);
pthread_mutex_unlock(&bsgs_thread);
if(FLAGDEBUG ) printf("%u of %" PRIu64 "\n",bloom_counter,(uint64_t)(bsgs_aux*bsgs_point_number));
bloom_counter = 0;
}
ends[thread_number] = 1;
return NULL;
}
void *thread_process_bsgs_random(void *vargp) {
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_aux2,point_found,BSGS_S,BSGS_Q,BSGS_Q_AMP;
uint32_t i,j,k,r,salir,thread_number,bloom_counter = 0;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
free(tt);
pthread_mutex_lock(&bsgs_thread);
/* | Start Range | End Range |
None | 1 | EC.N |
-b bit | Min bit value |Max bit value |
-r A:B | A | B |
*/
// set base_key = random(end_range - start range)
base_key.Rand(&n_range_start,&n_range_end);
pthread_mutex_unlock(&bsgs_thread);
/*
while base_key is less than n_range_end then:
*/
while(base_key.IsLower(&n_range_end)) {
//gmp_printf("While cycle: base_key : %Zd < n_range_end: %Zd\n",base_key,n_range_end);
if(FLAGQUIET == 0){
aux_c = base_key.GetBase16();
printf("\r[+] Thread %s",aux_c);
fflush(stdout);
free(aux_c);
THREADOUTPUT = 1;
}
/*
Set base_point in to base_key * G
base_point = base_key * G
*/
base_point = secp->ComputePublicKey(&base_key);
/*
We are going to need -( base_point * G)
point_aux = -( base_point * G)
*/
point_aux = secp->Negation(base_point);
/* We need to test individually every point in BSGS_Q */
for(k = 0; k < bsgs_point_number ; k++) {
if(bsgs_found[k] == 0) {
/*reset main variables before the do-while cicle*/
salir = 0;
i = 0;
/* Main cycle for every a in 0 to bsgs_aux
*/
BSGS_Q = secp->AddDirect(OriginalPointsBSGS[k],point_aux);
BSGS_S.Set(BSGS_Q);
do {
BSGS_S.x.Get32Bytes((unsigned char*)xpoint_raw);
r = bloom_check(&bloom_bP[((unsigned char)xpoint_raw[0])],xpoint_raw,32);
if(r) {
bloom_counter++;
/* Lookup for the xpoint_raw into the full sorted list*/
r = bsgs_secondcheck(&base_key,i,k,&keyfound);
if(r) {
hextemp = keyfound.GetBase16();
printf("\n[+] Thread Key found privkey %s\n",hextemp);
point_aux2 = secp->ComputePublicKey(&keyfound);
aux_c = secp->GetPublicKeyHex(OriginalPointsBSGScompressed[k],point_aux2);
printf("[+] Publickey %s\n",aux_c);
pthread_mutex_lock(&write_keys);
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);
pthread_mutex_unlock(&write_keys);
bsgs_found[k] = 1;
salir = 1;
for(j = 0; j < bsgs_point_number && salir; j++) {
salir &= bsgs_found[j];
}
if(salir) {
printf("All points were found\n");
exit(0);
}
}
}
BSGS_Q_AMP = secp->AddDirect(BSGS_AMP[i],BSGS_Q);
BSGS_S.Set(BSGS_Q_AMP);
i++;
} while( i < bsgs_aux && !bsgs_found[k]);
} //End if
} // End for with k bsgs_point_number
steps[thread_number]++;
pthread_mutex_lock(&bsgs_thread);
base_key.Rand(&n_range_start,&n_range_end);
pthread_mutex_unlock(&bsgs_thread);
if(FLAGDEBUG ) printf("%u of %" PRIu64 "\n",bloom_counter,(uint64_t)(bsgs_aux*bsgs_point_number));
bloom_counter = 0;
}
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.
This new and small bPtable is around ~ squareroot( K *squareroot(N))
*/
int bsgs_secondcheck(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;
Point base_point,point_aux;
Point BSGS_Q, BSGS_S,BSGS_Q_AMP;
char pubkey[131],xpoint_str[65],xpoint_raw[32],*hexvalue;
base_key.Set(&BSGS_M);
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 = secp->AddDirect(OriginalPointsBSGS[k_index],point_aux);
BSGS_Q.Set(BSGS_S);
do {
BSGS_S.x.Get32Bytes((unsigned char *)xpoint_raw);
r = bloom_check(&bloom_bPx2nd,xpoint_raw,32);
if(r) {
r = bsgs_searchbinary(bPtable,xpoint_raw,bsgs_m2,&j);
if(r) {
privatekey->Set(&BSGS_M2);
privatekey->Mult((uint64_t)i);
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 {
privatekey->Set(&BSGS_M2);
privatekey->Mult((uint64_t)i);
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;
}
}
}
}
BSGS_Q_AMP = secp->AddDirect(BSGS_Q,BSGS_AMP2[i]);
BSGS_S.Set(BSGS_Q_AMP);
i++;
}while(i < 20 && !found);
return found;
}
void *thread_bPloadFile(void *vargp) {
FILE *fd;
char rawvalue[32],*hextemp;
struct bPload *tt;
uint32_t j;
uint64_t i;
tt = (struct bPload *)vargp;
fd = fopen(precalculated_p_filename,"rb");
if(fd == NULL) {
fprintf(stderr,"Can't open file\n");
exit(0);
}
i = tt->from -1;
j = tt->from -1;
if(fseek(fd,(uint64_t)(i*32),SEEK_SET) != 0) {
fprintf(stderr,"Can't seek the file at index %" PRIu64 ", offset %" PRIu64 "\n",i,(uint64_t)(i*32));
exit(0);
}
do {
if(fread(rawvalue,1,32,fd) == 32) {
if(i < bsgs_m2) {
memcpy(bPtable[j].value,rawvalue+16,BSGS_XVALUE_RAM);
bPtable[j].index = j;
bloom_add(&bloom_bPx2nd, rawvalue, BSGS_BUFFERXPOINTLENGTH);
j++;
}
bloom_add(&bloom_bP[((uint8_t)rawvalue[0])], rawvalue ,BSGS_BUFFERXPOINTLENGTH);
i++;
tt->counter++;
}
else {
fprintf(stderr,"Can't read the file seen you have less items that the amount needed\n");
exit(0);
}
} while( i < tt->to );
pthread_exit(NULL);
}
void sleep_ms(int milliseconds) { // cross-platform sleep function
#ifdef WIN32
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 *thread_pub2rmd(void *vargp) {
FILE *fd;
Int key_mpz;
struct tothread *tt;
uint64_t i,limit,j;
char digest160[20];
char digest256[32];
char *temphex;
int thread_number,r;
int pub2rmd_continue = 1;
struct publickey pub;
limit = 0xFFFFFFFF;
tt = (struct tothread *)vargp;
thread_number = tt->nt;
do {
if(FLAGRANDOM){
key_mpz.Rand(&n_range_start,&n_range_diff);
}
else {
if(n_range_start.IsLower(&n_range_end)) {
pthread_mutex_lock(&write_random);
key_mpz.Set(&n_range_start);
n_range_start.Add(N_SECUENTIAL_MAX);
pthread_mutex_unlock(&write_random);
}
else {
pub2rmd_continue = 0;
}
}
if(pub2rmd_continue) {
key_mpz.Get32Bytes(pub.X.data8);
pub.parity = 0x02;
pub.X.data32[7] = 0;
if(FLAGQUIET == 0) {
temphex = tohex((char*)&pub,33);
printf("\r[+] Thread %s",temphex);
fflush(stdout);
THREADOUTPUT = 1;
}
for(i = 0 ; i < limit ; i++) {
pub.parity = 0x02;
sha256((char*)&pub, 33, digest256);
RMD160Data((const unsigned char*)digest256,32, digest160);
r = bloom_check(&bloom,digest160,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,digest160,N);
if(r) {
temphex = tohex((char*)&pub,33);
printf("\nHit: Publickey found %s\n",temphex);
fd = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(fd != NULL) {
pthread_mutex_lock(&write_keys);
fprintf(fd,"Publickey found %s\n",temphex);
fclose(fd);
pthread_mutex_unlock(&write_keys);
}
else {
fprintf(stderr,"\nPublickey found %s\nbut the file can't be open\n",temphex);
exit(0);
}
free(temphex);
}
}
pub.parity = 0x03;
sha256((char*)&pub, 33, digest256);
RMD160Data((const unsigned char*)digest256,32, digest160);
r = bloom_check(&bloom,digest160,MAXLENGTHADDRESS);
if(r) {
r = searchbinary(addressTable,digest160,N);
if(r) {
temphex = tohex((char*)&pub,33);
printf("\nHit: Publickey found %s\n",temphex);
fd = fopen("KEYFOUNDKEYFOUND.txt","a+");
if(fd != NULL) {
pthread_mutex_lock(&write_keys);
fprintf(fd,"Publickey found %s\n",temphex);
fclose(fd);
pthread_mutex_unlock(&write_keys);
}
else {
fprintf(stderr,"\nPublickey found %s\nbut the file can't be open\n",temphex);
exit(0);
}
free(temphex);
}
}
pub.X.data32[7]++;
if(pub.X.data32[7] % DEBUGCOUNT == 0) {
steps[thread_number]++;
}
} /* End for */
} /* End if */
} while(pub2rmd_continue);
ends[thread_number] = 1;
return NULL;
}
void init_generator() {
Point g = secp->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,secp->G);
Gn[i] = g;
}
_2Gn = secp->DoubleDirect(Gn[CPU_GRP_SIZE / 2 - 1]);
}
void *thread_bPload(void *vargp) {
char *hextemp,rawvalue[32];
struct bPload *tt;
uint64_t j_counter,i_counter;
uint64_t i,j,nbStep;
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;
Int dyn;
Int _s;
Int _p;
Point pp;
Point pn;
int hLength = (CPU_GRP_SIZE / 2 - 1);
tt = (struct bPload *)vargp;
Int km(tt->from);
if(FLAGDEBUG) printf("[D] thread %i from %" PRIu64 " to %" PRIu64 "\n",tt->threadid,tt->from,tt->to);
i_counter = tt->from -1;
j_counter = tt->from -1;
nbStep = (tt->to - (tt->from-1)) / CPU_GRP_SIZE;
if( ((tt->to - (tt->from-1)) % CPU_GRP_SIZE ) != 0) {
nbStep++;
}
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);
if(i_counter < bsgs_m2) {
memcpy(bPtable[j_counter].value,rawvalue+16,BSGS_XVALUE_RAM);
bPtable[j_counter].index = j_counter;
bloom_add(&bloom_bPx2nd, rawvalue, BSGS_BUFFERXPOINTLENGTH);
j_counter++;
}
if(i_counter < tt->to) {
bloom_add(&bloom_bP[((uint8_t)rawvalue[0])], rawvalue ,BSGS_BUFFERXPOINTLENGTH);
tt->counter++;
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;
pthread_exit(NULL);
}
Reference in New Issue View Git Blame Copy Permalink