diff --git a/bruteforce/p2pk_bruteforce.cpp b/bruteforce/p2pk_bruteforce.cpp index dca5b92..210fa45 100644 --- a/bruteforce/p2pk_bruteforce.cpp +++ b/bruteforce/p2pk_bruteforce.cpp @@ -3,11 +3,14 @@ * Versione CPU ottimizzata per massime prestazioni * * OTTIMIZZAZIONI IMPLEMENTATE: - * - Batch EC point addition (genera N chiavi con 1 moltiplicazione + N addizioni) - * - Zero-copy: niente serializzazione fino al match - * - Hash diretto su secp256k1_pubkey raw data + * - Batch EC point addition in coordinate Jacobiane (1 moltiplicazione scalare + * + N addizioni EC affine+affine, tutte con Z1=1) invece di N chiamate a + * secp256k1_ec_pubkey_combine + * - Batch modular inversion (trucco di Montgomery): 1 sola inversione di campo + * per batch di N chiavi invece di N inversioni separate + * - Zero-copy: matching diretto sui byte grezzi X||Y, niente oggetti + * secp256k1_pubkey nel loop caldo * - SIMD-friendly Bloom filter - * - Precomputed lookup tables * - Cache-aligned memory * - CPU prefetching hints * @@ -22,9 +25,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include @@ -41,12 +46,14 @@ // CONFIGURAZIONE OTTIMIZZATA // ============================================================================ -#define EC_BATCH_SIZE 256 // Genera 256 chiavi consecutive con EC addition (+25% speed) -#define SYNC_BATCH 100000 // Sincronizza contatori ogni 100K chiavi +#define EC_BATCH_SIZE 256 // Genera 256 chiavi consecutive con EC addition +#define EC_BATCH_MULT (EC_BATCH_SIZE - 1) // Multipli di G precalcolati necessari (2G..256G) +#define SYNC_BATCH 50000 // Sincronizza contatori ogni 50K chiavi (aggiornamento terminale fluido) #define MAX_THREADS 256 #define BLOOM_SIZE_BITS 26 // 64MB Bloom filter #define USE_BLOOM_FILTER 1 #define USE_EC_BATCH 1 // Abilita batch EC point addition +#define PROGRESS_INTERVAL_SEC 2 // Intervallo di aggiornamento statistiche a terminale // ============================================================================ // STRUTTURE DATI OTTIMIZZATE @@ -58,18 +65,17 @@ struct TargetKey { char hex[131]; }; -// Hash ottimizzato per raw secp256k1_pubkey data (64 bytes) -struct PubkeyRawHash { - size_t operator()(const secp256k1_pubkey& key) const { - const uint64_t* p = reinterpret_cast(key.data); - // XOR rapido dei primi 64 bit +// Hash ottimizzato per chiave grezza X||Y (64 byte, formato non compresso senza il prefisso 04) +struct RawKeyHash { + size_t operator()(const std::array& key) const { + const uint64_t* p = reinterpret_cast(key.data()); return p[0] ^ p[1] ^ p[2]; } }; -struct PubkeyRawEqual { - bool operator()(const secp256k1_pubkey& a, const secp256k1_pubkey& b) const { - return memcmp(a.data, b.data, 64) == 0; +struct RawKeyEqual { + bool operator()(const std::array& a, const std::array& b) const { + return memcmp(a.data(), b.data(), 64) == 0; } }; @@ -82,7 +88,7 @@ private: size_t size_words; size_t mask; - // Hash functions ottimizzate - usa direttamente i 64 bytes interni + // Hash functions ottimizzate - usa direttamente i 64 bytes della chiave grezza X||Y inline uint64_t hash1(const uint8_t* data) const { const uint64_t* p = (const uint64_t*)data; return p[0] ^ (p[1] << 7); @@ -117,8 +123,8 @@ public: free(bits); } - void add(const secp256k1_pubkey* pubkey) { - const uint8_t* data = pubkey->data; + // data: 64 byte grezzi X||Y (chiave pubblica non compressa senza prefisso 04) + void add(const uint8_t* data) { uint64_t h1 = hash1(data) & mask; uint64_t h2 = hash2(data) & mask; uint64_t h3 = hash3(data) & mask; @@ -129,8 +135,7 @@ public: } // Verifica ultra-veloce con prefetching - inline bool might_contain(const secp256k1_pubkey* pubkey) const { - const uint8_t* data = pubkey->data; + inline bool might_contain(const uint8_t* data) const { uint64_t h1 = hash1(data) & mask; uint64_t h2 = hash2(data) & mask; uint64_t h3 = hash3(data) & mask; @@ -156,7 +161,7 @@ static BloomFilter* bloom_filter = NULL; static volatile int keep_running = 1; static secp256k1_context* ctx = NULL; static std::vector target_keys; -static std::unordered_map target_map; +static std::unordered_map, int, RawKeyHash, RawKeyEqual> target_map; static uint64_t attempts_per_thread[MAX_THREADS] = {0}; static time_t start_time; static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -164,8 +169,13 @@ static FILE* log_file = NULL; static int num_threads = 0; #if USE_EC_BATCH -// Precomputed: G, 2G, 3G, ..., 256G per batch EC addition -static secp256k1_pubkey precomputed_G[EC_BATCH_SIZE]; +// Primo campo di secp256k1: p = 2^256 - 2^32 - 977 +static mpz_t field_p; + +// Multipli precalcolati del generatore: precomp_g[i] = (i+1)*G, per i = 0..EC_BATCH_MULT-1 +// (coordinate affini, condivisi in sola lettura tra i thread dopo l'inizializzazione) +static mpz_t precomp_gx[EC_BATCH_MULT]; +static mpz_t precomp_gy[EC_BATCH_MULT]; #endif // ============================================================================ @@ -273,15 +283,21 @@ int load_target_keys(const char* filename) { TargetKey key; if (hex_to_bytes(pubkey_hex.c_str(), key.pubkey, 65)) { strcpy(key.hex, pubkey_hex.c_str()); - target_keys.push_back(key); - // Converti in secp256k1_pubkey per lookup diretto + // Valida che sia un punto valido sulla curva (scarta chiavi corrotte) secp256k1_pubkey pubkey_obj; if (secp256k1_ec_pubkey_parse(ctx, &pubkey_obj, key.pubkey, 65)) { - target_map[pubkey_obj] = count; + target_keys.push_back(key); + + // Chiave di lookup: X||Y grezzi (64 byte), senza il prefisso 04. + // È lo stesso formato prodotto dal loop di generazione, quindi il + // confronto è un memcmp diretto, senza passare da secp256k1_pubkey. + std::array raw; + memcpy(raw.data(), key.pubkey + 1, 64); + target_map[raw] = count; #if USE_BLOOM_FILTER - bloom_filter->add(&pubkey_obj); + bloom_filter->add(raw.data()); #endif count++; } @@ -294,29 +310,132 @@ int load_target_keys(const char* filename) { return count; } +// ============================================================================ +// ARITMETICA DI CAMPO (GMP) PER BATCH EC POINT ADDITION +// ============================================================================ + +#if USE_EC_BATCH + +// Converte un intero mod p in 32 byte big-endian (con zero-padding) +static inline void mpz_to_be32(const mpz_t x, uint8_t out[32]) { + memset(out, 0, 32); + size_t count = 0; + mpz_export(out, &count, 1, 1, 1, 0, x); + if (count > 0 && count < 32) { + memmove(out + (32 - count), out, count); + memset(out, 0, 32 - count); + } +} + +// Converte 32 byte big-endian in un intero GMP +static inline void be32_to_mpz(mpz_t x, const uint8_t in[32]) { + mpz_import(x, 32, 1, 1, 1, 0, in); +} + +// Buffer di scratch riutilizzabili per l'addizione EC (evita alloc/dealloc per ogni chiave) +struct EcScratch { + mpz_t H, HH, HHH, r, t1, t2; + + void init() { + mpz_inits(H, HH, HHH, r, t1, t2, (mpz_ptr)0); + } + void clear_all() { + mpz_clears(H, HH, HHH, r, t1, t2, (mpz_ptr)0); + } +}; + +// Addizione di due punti affini (a=0, curva secp256k1), risultato in Jacobiane. +// Formule "madd" specializzate per Z1=1 (il primo punto è sempre P0, appena +// generato con una singola moltiplicazione scalare via libsecp256k1): +// H = x2 - x1 +// HH = H^2 +// HHH = H*HH +// r = y2 - y1 +// X3 = r^2 - HHH - 2*x1*HH +// Y3 = r*(x1*HH - X3) - y1*HHH +// Z3 = H +// +// NOTA: se H == 0 (x1 == x2 mod p, evento con probabilità ~2^-256 per punti +// indipendenti) il risultato non è definito da queste formule; in quel caso +// impostiamo Z3 = 0 per marcare il punto come "da ignorare" nel batch. +static inline void ec_add_affine_affine(const mpz_t x1, const mpz_t y1, + const mpz_t x2, const mpz_t y2, + mpz_t X3, mpz_t Y3, mpz_t Z3, + EcScratch& s) { + mpz_sub(s.H, x2, x1); + mpz_mod(s.H, s.H, field_p); + + if (mpz_sgn(s.H) == 0) { + mpz_set_ui(Z3, 0); + return; + } + + mpz_mul(s.HH, s.H, s.H); + mpz_mod(s.HH, s.HH, field_p); + + mpz_mul(s.HHH, s.H, s.HH); + mpz_mod(s.HHH, s.HHH, field_p); + + mpz_sub(s.r, y2, y1); + mpz_mod(s.r, s.r, field_p); + + // X3 = r^2 - HHH - 2*x1*HH + mpz_mul(X3, s.r, s.r); + mpz_sub(X3, X3, s.HHH); + mpz_mul(s.t1, x1, s.HH); + mpz_mul_2exp(s.t1, s.t1, 1); + mpz_sub(X3, X3, s.t1); + mpz_mod(X3, X3, field_p); + + // Y3 = r*(x1*HH - X3) - y1*HHH + mpz_mul(s.t1, x1, s.HH); + mpz_sub(s.t1, s.t1, X3); + mpz_mul(Y3, s.r, s.t1); + mpz_mul(s.t2, y1, s.HHH); + mpz_sub(Y3, Y3, s.t2); + mpz_mod(Y3, Y3, field_p); + + mpz_set(Z3, s.H); +} + +// La batch inversion vera e propria (trucco di Montgomery: 1 sola mpz_invert +// per l'intero batch, saltando gli eventuali punti non validi) è inline in +// worker_thread, perché deve intrecciarsi con il vettore `valid[]`. + +#endif // USE_EC_BATCH + // ============================================================================ // PRECOMPUTE EC GENERATOR MULTIPLES // ============================================================================ #if USE_EC_BATCH void precompute_generator_multiples() { - printf("[+] Precomputing EC generator multiples (1G, 2G, ..., %dG)...\n", EC_BATCH_SIZE); + printf("[+] Precomputing EC generator multiples (2G, ..., %dG)...\n", EC_BATCH_SIZE); uint8_t privkey[32]; - for (int i = 0; i < EC_BATCH_SIZE; i++) { + for (int i = 0; i < EC_BATCH_MULT; i++) { memset(privkey, 0, 32); - // Imposta il valore (i+1) come privkey - // Per i=0: privkey=1, per i=255: privkey=256 (0x0100) - uint16_t value = i + 1; - privkey[31] = (uint8_t)(value & 0xFF); // byte basso - privkey[30] = (uint8_t)((value >> 8) & 0xFF); // byte alto + // precomp_g[i] = (i+1)*G, per i=0..EC_BATCH_MULT-1 -> valori 1..EC_BATCH_MULT + uint32_t value = (uint32_t)(i + 1); + privkey[31] = (uint8_t)(value & 0xFF); + privkey[30] = (uint8_t)((value >> 8) & 0xFF); - if (!secp256k1_ec_pubkey_create(ctx, &precomputed_G[i], privkey)) { - fprintf(stderr, "[ERROR] Failed to precompute %dG\n", i+1); + secp256k1_pubkey pk; + if (!secp256k1_ec_pubkey_create(ctx, &pk, privkey)) { + fprintf(stderr, "[ERROR] Failed to precompute %dG\n", i + 1); exit(1); } + + unsigned char buf[65]; + size_t outlen = 65; + secp256k1_ec_pubkey_serialize(ctx, buf, &outlen, &pk, SECP256K1_EC_UNCOMPRESSED); + + mpz_init(precomp_gx[i]); + mpz_init(precomp_gy[i]); + be32_to_mpz(precomp_gx[i], buf + 1); + be32_to_mpz(precomp_gy[i], buf + 33); } printf("[+] Precomputation complete!\n"); @@ -368,20 +487,40 @@ static inline void add_to_privkey(uint8_t* privkey, uint64_t n) { } } +// Somma un piccolo intero a un array di 32 byte interpretato come intero +// big-endian standard (byte[31] = LSB), lo stesso formato che secp256k1 si +// aspetta per una private key. NON intercambiabile con add_to_privkey/ +// increment_privkey sopra: quelle due, per velocità, trattano l'array come +// 4 word a 64 bit in ordine nativo (little-endian sulle CPU x86), quindi +// avanzano la ricerca in un ordine "rimescolato" ma comunque bigettivo sullo +// spazio delle chiavi — va benissimo per iterare, ma NON per ricostruire lo +// scalare esatto corrispondente a un punto EC calcolato con aritmetica reale +// (come batch[i] = P0 + (i+1)*G). Per quello serve questa versione corretta. +static inline void add_small_be256(uint8_t* be, uint32_t n) { + for (int i = 31; i >= 0 && n; i--) { + uint32_t sum = be[i] + (n & 0xFF); + be[i] = (uint8_t)sum; + n = (n >> 8) + (sum >> 8); + } +} + // ============================================================================ // MATCH CHECKING OTTIMIZZATO // ============================================================================ -static inline int check_match_fast(const secp256k1_pubkey* pubkey) { +// data: 64 byte grezzi X||Y (chiave pubblica non compressa senza prefisso 04) +static inline int check_match_fast_raw(const uint8_t* data) { #if USE_BLOOM_FILTER // Prima passa: Bloom filter - if (!bloom_filter->might_contain(pubkey)) { + if (!bloom_filter->might_contain(data)) { return -1; // Sicuramente non presente } #endif - // Lookup diretto nella hash map (zero copy!) - auto it = target_map.find(*pubkey); + std::array key; + memcpy(key.data(), data, 64); + + auto it = target_map.find(key); if (it != target_map.end()) { return it->second; // Indice nella lista target_keys } @@ -438,33 +577,56 @@ void format_number(uint64_t num, char* buffer) { } } +// Velocità istantanea: somma dei tentativi di tutti i thread nella finestra +// trascorsa dall'ultima chiamata (non media cumulata dall'avvio), così il +// numero mostrato riflette il ritmo REALE corrente anche su run lunghe. void log_progress() { pthread_mutex_lock(&mutex); + static uint64_t last_total = 0; + static struct timeval last_tv = {0, 0}; + + struct timeval now_tv; + gettimeofday(&now_tv, NULL); + if (last_tv.tv_sec == 0 && last_tv.tv_usec == 0) { + // Prima chiamata: usa l'avvio dei thread come inizio finestra, non "adesso" + // (altrimenti la finestra sarebbe ~0s e il rate esploderebbe verso l'infinito) + last_tv.tv_sec = start_time; + last_tv.tv_usec = 0; + } + time_t now = time(NULL); - double elapsed = difftime(now, start_time); - if (elapsed < 1) elapsed = 1; + double elapsed_total = difftime(now, start_time); + if (elapsed_total < 1) elapsed_total = 1; uint64_t total = 0; for (int i = 0; i < num_threads; i++) { total += attempts_per_thread[i]; } - double rate = total / elapsed; + double window_sec = (now_tv.tv_sec - last_tv.tv_sec) + + (now_tv.tv_usec - last_tv.tv_usec) / 1e6; + if (window_sec < 0.001) window_sec = 0.001; + + uint64_t delta = total - last_total; + double instant_rate = delta / window_sec; char total_str[32]; char rate_str[32]; format_number(total, total_str); - format_number((uint64_t)rate, rate_str); + format_number((uint64_t)instant_rate, rate_str); - printf("[INFO] Tentativi: %s | Velocità: %s keys/sec | Tempo: %.0fs\n", - total_str, rate_str, elapsed); + printf("[INFO] Tentativi totali: %s | Velocità: %s keys/sec (tutti i core) | Tempo: %.0fs\n", + total_str, rate_str, elapsed_total); if (log_file) { - fprintf(log_file, "%ld,%lu,%.2f\n", now, total, rate); + fprintf(log_file, "%ld,%lu,%.2f\n", now, total, instant_rate); fflush(log_file); } + last_total = total; + last_tv = now_tv; + pthread_mutex_unlock(&mutex); } @@ -481,7 +643,6 @@ void* worker_thread(void* arg) { // Pre-alloca buffer uint8_t privkey[32]; - secp256k1_pubkey pubkey_batch[EC_BATCH_SIZE]; uint64_t local_attempts = 0; init_random_privkey_in_range(privkey, &seed, data->range_start, data->range_end); @@ -492,41 +653,113 @@ void* worker_thread(void* arg) { printf(" Privkey iniziale: %s\n", privkey_start_hex); // ======================================================================== - // LOOP PRINCIPALE CON EC BATCH PROCESSING + // LOOP PRINCIPALE CON EC BATCH PROCESSING (Jacobian + batch inversion) // ======================================================================== #if USE_EC_BATCH - // VERSIONE CON BATCH EC POINT ADDITION + // Buffer persistenti per thread: X/Y/Z Jacobiani dei punti P0 + iG (i=1..EC_BATCH_MULT) + mpz_t x0, y0; + mpz_t Xj[EC_BATCH_MULT], Yj[EC_BATCH_MULT], Zj[EC_BATCH_MULT]; + mpz_t invZ[EC_BATCH_MULT], prefix[EC_BATCH_MULT]; + mpz_t inv_tmp, zinv2, zinv3, ax, ay; + EcScratch scratch; + + mpz_inits(x0, y0, inv_tmp, zinv2, zinv3, ax, ay, (mpz_ptr)0); + for (int i = 0; i < EC_BATCH_MULT; i++) { + mpz_inits(Xj[i], Yj[i], Zj[i], invZ[i], prefix[i], (mpz_ptr)0); + } + scratch.init(); + + uint8_t rawkey[64]; + uint8_t found_privkey[32]; + while (keep_running) { - // Step 1: Genera la prima pubkey del batch (P = privkey * G) - if (!secp256k1_ec_pubkey_create(ctx, &pubkey_batch[0], privkey)) { + secp256k1_pubkey pubkey0; + if (!secp256k1_ec_pubkey_create(ctx, &pubkey0, privkey)) { increment_privkey(privkey); continue; } - // Step 2: Check prima chiave - int match_idx = check_match_fast(&pubkey_batch[0]); + unsigned char buf65[65]; + size_t outlen = 65; + secp256k1_ec_pubkey_serialize(ctx, buf65, &outlen, &pubkey0, SECP256K1_EC_UNCOMPRESSED); + + be32_to_mpz(x0, buf65 + 1); + be32_to_mpz(y0, buf65 + 33); + + // Chiave 0 del batch: è P0 stesso, nessuna conversione affine necessaria + int match_idx = check_match_fast_raw(buf65 + 1); if (__builtin_expect(match_idx >= 0, 0)) { save_found_key(privkey, match_idx); } - // Step 3: Genera le restanti (EC_BATCH_SIZE - 1) chiavi usando EC addition - // P1 = P + G, P2 = P + 2G, P3 = P + 3G, ... - // Questo è MOLTO più veloce di fare EC_BATCH_SIZE moltiplicazioni! - uint8_t temp_privkey[32]; - memcpy(temp_privkey, privkey, 32); + // Genera le restanti EC_BATCH_MULT chiavi: batch[i] = P0 + (i+1)*G, in Jacobiane + int valid_count = 0; + bool valid[EC_BATCH_MULT]; + for (int i = 0; i < EC_BATCH_MULT; i++) { + ec_add_affine_affine(x0, y0, precomp_gx[i], precomp_gy[i], + Xj[i], Yj[i], Zj[i], scratch); + valid[i] = (mpz_sgn(Zj[i]) != 0); + if (valid[i]) valid_count++; + } - for (int i = 1; i < EC_BATCH_SIZE && keep_running; i++) { - increment_privkey(temp_privkey); + // Batch inversion (trucco di Montgomery): una sola mpz_invert per l'intero batch + if (valid_count > 0) { + int last = -1; + for (int i = 0; i < EC_BATCH_MULT; i++) { + if (!valid[i]) continue; + if (last < 0) { + mpz_set(prefix[i], Zj[i]); + } else { + mpz_mul(prefix[i], prefix[last], Zj[i]); + mpz_mod(prefix[i], prefix[i], field_p); + } + last = i; + } - // EC point addition: pubkey_batch[i] = pubkey_batch[0] + precomputed_G[i-1] - // Usa EC pubkey combine (somma di due punti) - const secp256k1_pubkey* pubkeys_to_add[2] = {&pubkey_batch[0], &precomputed_G[i]}; + mpz_invert(inv_tmp, prefix[last], field_p); // inv_tmp = 1 / prodotto totale - if (secp256k1_ec_pubkey_combine(ctx, &pubkey_batch[i], pubkeys_to_add, 2)) { - match_idx = check_match_fast(&pubkey_batch[i]); + for (int i = last; i >= 0; i--) { + if (!valid[i]) continue; + + int prev = -1; + for (int j = i - 1; j >= 0; j--) { + if (valid[j]) { prev = j; break; } + } + + if (prev >= 0) { + mpz_mul(invZ[i], inv_tmp, prefix[prev]); + mpz_mod(invZ[i], invZ[i], field_p); + } else { + mpz_set(invZ[i], inv_tmp); + } + + mpz_mul(inv_tmp, inv_tmp, Zj[i]); + mpz_mod(inv_tmp, inv_tmp, field_p); + } + + // Converte ogni punto Jacobiano in affine e verifica il match + for (int i = 0; i < EC_BATCH_MULT && keep_running; i++) { + if (!valid[i]) continue; + + mpz_mul(zinv2, invZ[i], invZ[i]); + mpz_mod(zinv2, zinv2, field_p); + mpz_mul(zinv3, zinv2, invZ[i]); + mpz_mod(zinv3, zinv3, field_p); + + mpz_mul(ax, Xj[i], zinv2); + mpz_mod(ax, ax, field_p); + mpz_mul(ay, Yj[i], zinv3); + mpz_mod(ay, ay, field_p); + + mpz_to_be32(ax, rawkey); + mpz_to_be32(ay, rawkey + 32); + + match_idx = check_match_fast_raw(rawkey); if (__builtin_expect(match_idx >= 0, 0)) { - save_found_key(temp_privkey, match_idx); + memcpy(found_privkey, privkey, 32); + add_small_be256(found_privkey, (uint32_t)(i + 1)); // batch[i] = privkey + (i+1) + save_found_key(found_privkey, match_idx); } } } @@ -535,10 +768,17 @@ void* worker_thread(void* arg) { add_to_privkey(privkey, EC_BATCH_SIZE); // Aggiorna contatore globale periodicamente - if ((local_attempts & (SYNC_BATCH - 1)) == 0) { + // (modulo, non maschera bitwise: SYNC_BATCH non è una potenza di due) + if (local_attempts % SYNC_BATCH < EC_BATCH_SIZE) { attempts_per_thread[thread_id] = local_attempts; } } + + scratch.clear_all(); + mpz_clears(x0, y0, inv_tmp, zinv2, zinv3, ax, ay, (mpz_ptr)0); + for (int i = 0; i < EC_BATCH_MULT; i++) { + mpz_clears(Xj[i], Yj[i], Zj[i], invZ[i], prefix[i], (mpz_ptr)0); + } #else // VERSIONE STANDARD (fallback senza batch) while (keep_running) { @@ -546,7 +786,10 @@ void* worker_thread(void* arg) { for (int batch = 0; batch < SYNC_BATCH; batch++) { if (__builtin_expect(secp256k1_ec_pubkey_create(ctx, &pubkey_obj, privkey), 1)) { - int match_idx = check_match_fast(&pubkey_obj); + unsigned char buf65[65]; + size_t outlen = 65; + secp256k1_ec_pubkey_serialize(ctx, buf65, &outlen, &pubkey_obj, SECP256K1_EC_UNCOMPRESSED); + int match_idx = check_match_fast_raw(buf65 + 1); if (__builtin_expect(match_idx >= 0, 0)) { save_found_key(privkey, match_idx); } @@ -602,8 +845,12 @@ int main(int argc, char** argv) { } } - // Precompute EC multiples #if USE_EC_BATCH + // Inizializza il primo campo di secp256k1: p = 2^256 - 2^32 - 977 + mpz_init_set_str(field_p, + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16); + + // Precompute EC multiples precompute_generator_multiples(); #endif @@ -662,7 +909,7 @@ int main(int argc, char** argv) { // Loop principale while (keep_running) { - sleep(10); + sleep(PROGRESS_INTERVAL_SEC); log_progress(); }