Semplifica build e ottimizza bruteforce P2PK
- Makefile: setup automatico libreria alla prima compilazione - Bruteforce: ottimizzazioni multi-threading con CPU affinity
This commit is contained in:
4
.gitignore
vendored
4
.gitignore
vendored
@@ -43,6 +43,10 @@ bruteforce/found_keys.txt
|
||||
bruteforce/progress.csv
|
||||
bruteforce/target_keys.txt
|
||||
|
||||
# libsecp256k1 compilata localmente
|
||||
bruteforce/secp256k1_build/
|
||||
bruteforce/secp256k1/
|
||||
|
||||
# ===================================
|
||||
# IDE & Editor
|
||||
# ===================================
|
||||
|
||||
@@ -12,13 +12,44 @@ SOURCE = p2pk_bruteforce.cpp
|
||||
INCLUDE_PATH = -I/usr/local/include -I/usr/include
|
||||
LIB_PATH = -L/usr/local/lib -L/usr/lib
|
||||
|
||||
all: $(TARGET)
|
||||
all: build-if-needed compile
|
||||
|
||||
$(TARGET): $(SOURCE)
|
||||
@echo "[+] Compilazione $(TARGET) con ottimizzazioni massime..."
|
||||
build-if-needed:
|
||||
@if [ ! -d "secp256k1" ]; then \
|
||||
echo "========================================"; \
|
||||
echo " PRIMA COMPILAZIONE: Setup Automatico"; \
|
||||
echo "========================================"; \
|
||||
echo ""; \
|
||||
echo "Compilazione libsecp256k1..."; \
|
||||
echo "Questo richiederà ~5 minuti (solo la prima volta)"; \
|
||||
echo ""; \
|
||||
$(MAKE) build-optimized-secp256k1; \
|
||||
fi
|
||||
|
||||
compile: build-if-needed
|
||||
@if [ -d "secp256k1" ]; then \
|
||||
echo "[+] Compilazione con libsecp256k1..."; \
|
||||
$(CC) $(CFLAGS) \
|
||||
-I./secp256k1/include \
|
||||
-L./secp256k1/lib \
|
||||
-Wl,-rpath,$(shell pwd)/secp256k1/lib \
|
||||
-o $(TARGET) $(SOURCE) $(LIBS); \
|
||||
echo "[+] Compilazione completata!"; \
|
||||
echo "[!] Performance attese: ~300K keys/sec"; \
|
||||
else \
|
||||
echo "[+] Compilazione standard..."; \
|
||||
$(CC) $(CFLAGS) $(INCLUDE_PATH) $(LIB_PATH) -o $(TARGET) $(SOURCE) $(LIBS); \
|
||||
echo "[+] Compilazione completata!"; \
|
||||
echo "[!] Performance attese: ~250K keys/sec"; \
|
||||
fi
|
||||
@echo "[!] Eseguibile: ./$(TARGET)"
|
||||
|
||||
standard: $(SOURCE)
|
||||
@echo "[+] Compilazione STANDARD (senza libreria ottimizzata)..."
|
||||
$(CC) $(CFLAGS) $(INCLUDE_PATH) $(LIB_PATH) -o $(TARGET) $(SOURCE) $(LIBS)
|
||||
@echo "[+] Compilazione completata!"
|
||||
@echo "[!] Eseguibile: ./$(TARGET)"
|
||||
@echo "[!] Performance attese: ~250K keys/sec"
|
||||
|
||||
optimized: $(SOURCE)
|
||||
@echo "[+] Compilazione con ottimizzazioni estreme (PGO)..."
|
||||
@@ -51,6 +82,11 @@ clean:
|
||||
rm -f *.o *.gcda *.gcno
|
||||
@echo "[+] Pulizia completata!"
|
||||
|
||||
clean-all: clean
|
||||
@echo "[+] Pulizia completa (include libreria secp256k1)..."
|
||||
rm -rf secp256k1_build secp256k1
|
||||
@echo "[+] Pulizia completa terminata!"
|
||||
|
||||
install-deps:
|
||||
@echo "[+] Installazione dipendenze..."
|
||||
@echo "[!] Questo installerà: build-essential, libsecp256k1-dev, libgmp-dev"
|
||||
@@ -67,25 +103,47 @@ install-secp256k1:
|
||||
sudo ldconfig
|
||||
@echo "[+] libsecp256k1 installata!"
|
||||
|
||||
build-optimized-secp256k1:
|
||||
@echo "[+] Compilazione libsecp256k1..."
|
||||
@./build_secp256k1.sh
|
||||
|
||||
with-optimized-lib: $(SOURCE)
|
||||
@echo "[+] Compilazione con libsecp256k1..."
|
||||
@if [ ! -d "secp256k1" ]; then \
|
||||
echo "[ERROR] Directory secp256k1 non trovata!"; \
|
||||
echo "[!] Esegui prima: make build-optimized-secp256k1"; \
|
||||
exit 1; \
|
||||
fi
|
||||
$(CC) $(CFLAGS) \
|
||||
-I./secp256k1/include \
|
||||
-L./secp256k1/lib \
|
||||
-Wl,-rpath,$(shell pwd)/secp256k1/lib \
|
||||
-o $(TARGET) $(SOURCE) $(LIBS)
|
||||
@echo "[+] Compilazione completata!"
|
||||
@echo "[!] Eseguibile: ./$(TARGET)"
|
||||
|
||||
help:
|
||||
@echo "==================================================="
|
||||
@echo " Bitcoin P2PK Bruteforce - Makefile"
|
||||
@echo "==================================================="
|
||||
@echo ""
|
||||
@echo "Target disponibili:"
|
||||
@echo " make - Compila il programma"
|
||||
@echo " make optimized - Compila con PGO step 1"
|
||||
@echo " make pgo-use - Compila con PGO step 2"
|
||||
@echo " make static - Compila versione statica"
|
||||
@echo " make debug - Compila versione debug"
|
||||
@echo " make test - Test rapido"
|
||||
@echo " make clean - Rimuove file compilati"
|
||||
@echo " make install-deps - Installa dipendenze"
|
||||
@echo " make install-secp256k1 - Compila secp256k1 da sorgente"
|
||||
@echo " make - Compila il programma"
|
||||
@echo " make build-optimized-secp256k1 - Compila libsecp256k1"
|
||||
@echo " make with-optimized-lib - Compila con libsecp256k1"
|
||||
@echo " make optimized - Compila con PGO step 1"
|
||||
@echo " make pgo-use - Compila con PGO step 2"
|
||||
@echo " make static - Compila versione statica"
|
||||
@echo " make debug - Compila versione debug"
|
||||
@echo " make test - Test rapido"
|
||||
@echo " make clean - Rimuove file compilati"
|
||||
@echo " make clean-all - Pulizia completa (include secp256k1)"
|
||||
@echo " make install-deps - Installa dipendenze"
|
||||
@echo " make install-secp256k1 - Compila secp256k1 da sorgente"
|
||||
@echo ""
|
||||
@echo "Uso:"
|
||||
@echo " ./$(TARGET) [file_chiavi.txt]"
|
||||
@echo ""
|
||||
@echo "==================================================="
|
||||
|
||||
.PHONY: all optimized pgo-use static debug test clean install-deps install-secp256k1 help
|
||||
.PHONY: all optimized pgo-use static debug test clean clean-all install-deps install-secp256k1 build-optimized-secp256k1 with-optimized-lib help
|
||||
|
||||
@@ -1,147 +1,88 @@
|
||||
# Bitcoin P2PK Bruteforce
|
||||
|
||||
Programma C++ ad alte prestazioni per la ricerca di chiavi private corrispondenti a indirizzi P2PK Bitcoin con UTXO non spesi.
|
||||
Strumento di ricerca chiavi private Bitcoin P2PK compilato per massime performance su CPU (fino a **300K+ keys/sec**).
|
||||
|
||||
## ⚠️ DISCLAIMER IMPORTANTE
|
||||
**⚠️ DISCLAIMER**: Solo per scopi educativi e di ricerca. Non utilizzare per attività illegali.
|
||||
|
||||
**Questo programma è SOLO per scopi educativi e di ricerca.**
|
||||
---
|
||||
|
||||
- **Probabilità di successo**: Praticamente zero (1 su 2^256)
|
||||
- **Scopo**: Dimostrare la sicurezza crittografica di Bitcoin
|
||||
- **Non utilizzare per attività illegali**
|
||||
- **La ricerca di chiavi private altrui è illegale**
|
||||
## Indice
|
||||
|
||||
Questo progetto serve a comprendere:
|
||||
- Come funziona la crittografia a curva ellittica (secp256k1)
|
||||
- Come vengono generate le chiavi pubbliche da quelle private
|
||||
- La vastità dello spazio delle chiavi (2^256 possibilità)
|
||||
- L'impossibilità pratica di trovare chiavi per bruteforce
|
||||
- [Requisiti](#requisiti)
|
||||
- [Installazione Rapida](#installazione-rapida)
|
||||
- [Utilizzo](#utilizzo)
|
||||
- [Comandi Make](#comandi-make)
|
||||
- [Troubleshooting](#troubleshooting)
|
||||
- [Note Tecniche](#note-tecniche)
|
||||
|
||||
## Caratteristiche
|
||||
|
||||
- **Alta efficienza**: Ottimizzato per massime prestazioni
|
||||
- **Multi-threading**: Utilizza tutti i core della CPU
|
||||
- **Libreria secp256k1**: La stessa usata da Bitcoin Core
|
||||
- **Chiavi non compresse**: Genera pubkey in formato P2PK classico (65 bytes)
|
||||
- **Ricerca incrementale**: Inizia da random, poi incrementa
|
||||
- **Logging**: Salva progresso e velocità in CSV
|
||||
- **Salvataggio automatico**: Se trova una corrispondenza
|
||||
---
|
||||
|
||||
## Requisiti
|
||||
|
||||
### Dipendenze
|
||||
### Sistema Operativo
|
||||
- **Linux**: Ubuntu/Debian (consigliato)
|
||||
- **Architettura**: x86_64 o ARM64
|
||||
|
||||
- **Compilatore**: GCC/G++ con supporto C++11
|
||||
- **libsecp256k1**: Libreria Bitcoin per operazioni su curva ellittica
|
||||
- **libgmp**: GNU Multiple Precision Arithmetic Library
|
||||
- **pthread**: Thread POSIX (incluso in Linux)
|
||||
|
||||
### Installazione dipendenze
|
||||
|
||||
#### Ubuntu/Debian
|
||||
### Hardware Minimo
|
||||
- **CPU**: Multicore (consigliato 8+ core)
|
||||
- **RAM**: 2GB minimo, 4GB+ consigliato
|
||||
- **Disco**: 500MB per libreria locale
|
||||
|
||||
### Software
|
||||
```bash
|
||||
sudo apt-get update
|
||||
sudo apt-get install build-essential libsecp256k1-dev libgmp-dev git autoconf libtool pkg-config
|
||||
sudo apt-get install -y build-essential git autoconf libtool pkg-config libgmp-dev
|
||||
```
|
||||
|
||||
Oppure usa il Makefile:
|
||||
---
|
||||
|
||||
## Installazione Rapida
|
||||
|
||||
```bash
|
||||
cd bruteforce
|
||||
make install-deps
|
||||
```
|
||||
|
||||
#### Compilare secp256k1 da sorgente (opzionale)
|
||||
|
||||
Se la versione nei repository è vecchia o mancante:
|
||||
|
||||
```bash
|
||||
make install-secp256k1
|
||||
```
|
||||
|
||||
Questo scarica, compila e installa l'ultima versione di libsecp256k1 da GitHub.
|
||||
|
||||
## Compilazione
|
||||
|
||||
### Compilazione standard
|
||||
|
||||
```bash
|
||||
cd bruteforce
|
||||
# Compila automaticamente (prima volta ~5 minuti)
|
||||
make
|
||||
|
||||
# Esegui
|
||||
./p2pk_bruteforce
|
||||
```
|
||||
|
||||
Questo crea l'eseguibile `p2pk_bruteforce` con ottimizzazioni `-O3` e flags native.
|
||||
**Risultato atteso**: ~300K keys/sec
|
||||
|
||||
### Compilazione con ottimizzazioni massime
|
||||
> **Nota**: La prima volta `make` compilerà automaticamente libsecp256k1 locale (~5 minuti). Le volte successive sarà istantaneo.
|
||||
|
||||
```bash
|
||||
make optimized
|
||||
```
|
||||
|
||||
Questo abilita Profile-Guided Optimization (PGO) in due step:
|
||||
1. Prima compilazione genera profilo di esecuzione
|
||||
2. Seconda compilazione usa il profilo per ottimizzare
|
||||
|
||||
### Altre opzioni di compilazione
|
||||
|
||||
```bash
|
||||
make static # Compilazione statica (portable)
|
||||
make debug # Compilazione con simboli debug
|
||||
make clean # Rimuove file compilati
|
||||
make help # Mostra tutti i comandi disponibili
|
||||
```
|
||||
---
|
||||
|
||||
## Utilizzo
|
||||
|
||||
### 1. Estrai le chiavi P2PK non spese
|
||||
### 1. Prepara il File Target
|
||||
|
||||
Prima di eseguire il bruteforce, devi estrarre le chiavi pubbliche target dal database dello scanner:
|
||||
Crea `target_keys.txt` con le chiavi pubbliche P2PK (una per riga):
|
||||
|
||||
```txt
|
||||
pubkey_hex
|
||||
04a1b2c3d4e5f6789... (130 caratteri hex)
|
||||
04f9e8d7c6b5a49321...
|
||||
...
|
||||
```
|
||||
|
||||
**Formato**:
|
||||
- Chiavi pubbliche **non compresse** (130 caratteri hex)
|
||||
- Prefisso `04` (opzionale)
|
||||
- Una chiave per riga
|
||||
|
||||
### 2. Esegui il Programma
|
||||
|
||||
```bash
|
||||
cd bruteforce
|
||||
python3 extract_p2pk_utxo.py
|
||||
# File default (target_keys.txt)
|
||||
./p2pk_bruteforce
|
||||
|
||||
# File custom
|
||||
./p2pk_bruteforce mie_chiavi.txt
|
||||
```
|
||||
|
||||
Questo script:
|
||||
- Legge il database SQLite (`../databases/bitcoin_p2pk_study.db`)
|
||||
- Estrae solo i P2PK con `is_unspent = 1`
|
||||
- Mostra statistiche (numero chiavi, valore totale, top 10)
|
||||
- Crea il file `target_keys.txt` con le pubkey (una per riga)
|
||||
|
||||
Output esempio:
|
||||
|
||||
```
|
||||
============================================================
|
||||
STATISTICHE DATABASE P2PK
|
||||
============================================================
|
||||
Totale P2PK: 150
|
||||
P2PK non spesi: 12
|
||||
P2PK spesi: 138
|
||||
------------------------------------------------------------
|
||||
Valore totale: 1234.56789012 BTC
|
||||
Valore non speso: 50.00000000 BTC
|
||||
Valore speso: 1184.56789012 BTC
|
||||
============================================================
|
||||
```
|
||||
|
||||
### 2. Esegui il bruteforce
|
||||
|
||||
```bash
|
||||
./p2pk_bruteforce [file_chiavi.txt]
|
||||
```
|
||||
|
||||
Se non specifichi il file, usa `target_keys.txt` di default.
|
||||
|
||||
### 3. Monitor del progresso
|
||||
|
||||
Il programma mostra:
|
||||
- Numero di tentativi effettuati
|
||||
- Velocità (keys/sec)
|
||||
- Tempo trascorso
|
||||
- Aggiornamenti ogni 1.000.000 di tentativi
|
||||
|
||||
Esempio output:
|
||||
### 3. Output Esempio
|
||||
|
||||
```
|
||||
========================================
|
||||
@@ -150,202 +91,179 @@ Esempio output:
|
||||
========================================
|
||||
|
||||
[+] Inizializzazione secp256k1...
|
||||
[+] Bloom filter inizializzato: 64 MB
|
||||
[+] Caricamento chiavi target da target_keys.txt...
|
||||
[+] Caricate 12 chiavi pubbliche target
|
||||
[+] Avvio 8 thread worker...
|
||||
[+] Caricate 2164 chiavi pubbliche target
|
||||
[+] CPU rilevata: 11 thread disponibili
|
||||
[+] Partizionamento spazio chiavi in 11 regioni
|
||||
[+] Avvio 11 thread worker...
|
||||
|
||||
[+] Thread 0 avviato (seed: 1234567890)
|
||||
[+] Thread 1 avviato (seed: 1234580235)
|
||||
[+] Thread 0 avviato su core 0
|
||||
Privkey iniziale: 0000000000000000a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4
|
||||
[+] Thread 1 avviato su core 1
|
||||
Privkey iniziale: 1745d1741745d174f1e2d3c4b5a69788c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4
|
||||
...
|
||||
|
||||
[INFO] Tentativi: 10000000 | Velocità: 125000.00 keys/sec | Tempo: 80s
|
||||
[INFO] Tentativi: 20000000 | Velocità: 133000.00 keys/sec | Tempo: 150s
|
||||
...
|
||||
[INFO] Tentativi: 3.30M | Velocità: 300.00K keys/sec | Tempo: 11s
|
||||
[INFO] Tentativi: 6.60M | Velocità: 300.00K keys/sec | Tempo: 22s
|
||||
```
|
||||
|
||||
### 4. Se trova una chiave
|
||||
|
||||
Se il programma trova una corrispondenza, verrà stampata a schermo e salvata in `found_keys.txt`:
|
||||
### 4. Chiave Trovata (se succede)
|
||||
|
||||
```
|
||||
========================================
|
||||
🎯 CHIAVE TROVATA! 🎯
|
||||
========================================
|
||||
Private Key: 000000000000000000000000000000000000000000000000123456789abcdef
|
||||
Public Key: 04a1b2c3d4e5f6...
|
||||
Private Key: a1b2c3d4e5f6...
|
||||
Public Key: 04f9e8d7c6b5a4...
|
||||
========================================
|
||||
```
|
||||
|
||||
**NOTA**: È estremamente improbabile che questo accada mai.
|
||||
**Salvata in**: `found_keys.txt`
|
||||
|
||||
## File generati
|
||||
---
|
||||
|
||||
- **`target_keys.txt`**: Chiavi pubbliche target (input)
|
||||
- **`found_keys.txt`**: Chiavi trovate (se succede)
|
||||
- **`progress.csv`**: Log del progresso con timestamp, tentativi, velocità
|
||||
- **`p2pk_bruteforce`**: Eseguibile compilato
|
||||
|
||||
## Configurazione avanzata
|
||||
|
||||
Puoi modificare i parametri nel file sorgente [`p2pk_bruteforce.cpp`](p2pk_bruteforce.cpp):
|
||||
|
||||
```cpp
|
||||
#define NUM_THREADS 8 // Numero di thread (default: 8)
|
||||
#define BATCH_SIZE 10000 // Batch prima di sincronizzare
|
||||
#define SAVE_INTERVAL 300 // Salva progresso ogni N secondi
|
||||
#define PROGRESS_INTERVAL 1000000 // Mostra progresso ogni N tentativi
|
||||
```
|
||||
|
||||
Dopo aver modificato, ricompila:
|
||||
## Comandi Make
|
||||
|
||||
```bash
|
||||
make # Compila (setup automatico prima volta)
|
||||
make clean # Rimuove eseguibili
|
||||
make clean-all # Pulizia completa (include secp256k1)
|
||||
make help # Mostra tutti i comandi
|
||||
```
|
||||
|
||||
### Workflow Consigliato
|
||||
|
||||
```bash
|
||||
# Prima compilazione
|
||||
make
|
||||
|
||||
# Modifiche successive al codice
|
||||
make clean
|
||||
make
|
||||
```
|
||||
|
||||
## Performance
|
||||
|
||||
### Velocità tipiche
|
||||
|
||||
- **CPU moderna (8 core)**: ~100.000 - 500.000 keys/sec
|
||||
- **CPU high-end (16+ core)**: ~1.000.000+ keys/sec
|
||||
- **Raspberry Pi 4**: ~10.000 - 50.000 keys/sec
|
||||
|
||||
### Ottimizzazioni
|
||||
|
||||
1. **Usa tutti i core**: Modifica `NUM_THREADS` al numero di core della CPU
|
||||
2. **Compilazione nativa**: Flag `-march=native -mtune=native`
|
||||
3. **Profile-Guided Optimization**: Usa `make optimized`
|
||||
4. **Batch size**: Aumenta `BATCH_SIZE` per ridurre lock contention
|
||||
5. **Riduci I/O**: Aumenta `PROGRESS_INTERVAL` per stampare meno frequentemente
|
||||
|
||||
## Matematica della probabilità
|
||||
|
||||
### Spazio delle chiavi
|
||||
|
||||
- **Chiavi private possibili**: 2^256 ≈ 1.16 × 10^77
|
||||
- **Velocità ipotetica**: 1.000.000 keys/sec
|
||||
- **Tempo per testare tutte**: 3.67 × 10^63 anni
|
||||
- **Età dell'universo**: 1.38 × 10^10 anni
|
||||
|
||||
### Probabilità di successo
|
||||
|
||||
Con **N** tentativi, la probabilità di trovare UNA specifica chiave è:
|
||||
|
||||
```
|
||||
P(successo) = N / 2^256
|
||||
```
|
||||
|
||||
Esempi:
|
||||
- **1 miliardo di tentativi** (10^9): P ≈ 8.6 × 10^-69 (praticamente zero)
|
||||
- **1 trilione al secondo per 1 anno**: P ≈ 2.7 × 10^-60 (ancora zero)
|
||||
- **Tutti i computer del mondo per 1 milione di anni**: P ≈ 10^-40 (sempre zero)
|
||||
|
||||
**Conclusione**: È più probabile:
|
||||
- Vincere la lotteria 10 volte consecutive
|
||||
- Essere colpiti da un fulmine ogni giorno per un anno
|
||||
- Trovare un atomo specifico nell'universo
|
||||
|
||||
## Sicurezza di Bitcoin
|
||||
|
||||
Questo progetto dimostra perché Bitcoin è sicuro:
|
||||
|
||||
1. **Spazio enorme**: 2^256 chiavi possibili
|
||||
2. **Impossibilità computazionale**: Anche con tutti i computer del mondo
|
||||
3. **Crescita esponenziale**: Aggiungere 1 bit raddoppia il tempo necessario
|
||||
4. **Crittografia provata**: secp256k1 è lo standard dell'industria
|
||||
---
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Errore: libsecp256k1 non trovata
|
||||
### Errore: Directory secp256k1 non trovata
|
||||
|
||||
```bash
|
||||
# Verifica installazione
|
||||
ldconfig -p | grep secp256k1
|
||||
|
||||
# Se non trovata, installa:
|
||||
make install-secp256k1
|
||||
make clean-all
|
||||
make
|
||||
```
|
||||
|
||||
### Errore di compilazione: pthread
|
||||
|
||||
Assicurati di avere il flag `-pthread`:
|
||||
### Velocità Bassa (<250K keys/sec)
|
||||
|
||||
```bash
|
||||
g++ -pthread ... -o p2pk_bruteforce p2pk_bruteforce.cpp -lsecp256k1
|
||||
# 1. Verifica libreria usata
|
||||
ldd ./p2pk_bruteforce | grep secp256k1
|
||||
# Deve mostrare: ./secp256k1/lib/libsecp256k1.so
|
||||
|
||||
# 2. Verifica carico CPU
|
||||
htop # Ogni core dovrebbe essere al 100%
|
||||
|
||||
# 3. Verifica frequency scaling
|
||||
lscpu | grep MHz
|
||||
# Se bassa, disabilita power saving
|
||||
```
|
||||
|
||||
### Velocità troppo bassa
|
||||
### Errori di Compilazione
|
||||
|
||||
1. Verifica che `NUM_THREADS` corrisponda ai core della CPU
|
||||
2. Chiudi altri programmi pesanti
|
||||
3. Usa compilazione ottimizzata: `make optimized`
|
||||
4. Verifica temperatura CPU (throttling termico)
|
||||
```bash
|
||||
# Reinstalla dipendenze
|
||||
sudo apt-get install -y build-essential git autoconf libtool pkg-config libgmp-dev
|
||||
|
||||
### Il programma non trova nulla
|
||||
# Pulizia completa e ricompilazione
|
||||
make clean-all
|
||||
make
|
||||
```
|
||||
|
||||
**Questo è normale.** La probabilità di trovare una chiave è praticamente zero.
|
||||
### Il Programma non Trova Nulla
|
||||
|
||||
Se vuoi testare il funzionamento:
|
||||
**Questo è normale!** La probabilità di trovare una chiave è praticamente zero.
|
||||
|
||||
**Test funzionamento**:
|
||||
1. Genera una chiave privata nota
|
||||
2. Calcola la pubkey con secp256k1
|
||||
3. Aggiungi la pubkey a `target_keys.txt`
|
||||
4. Esegui il bruteforce (ci vorranno comunque miliardi di tentativi)
|
||||
|
||||
## Struttura del codice
|
||||
|
||||
```
|
||||
bruteforce/
|
||||
├── p2pk_bruteforce.cpp # Codice sorgente principale
|
||||
├── Makefile # Compilazione
|
||||
├── extract_p2pk_utxo.py # Script estrazione chiavi
|
||||
├── README.md # Questa guida
|
||||
├── target_keys.txt # Chiavi target (generato)
|
||||
├── found_keys.txt # Chiavi trovate (se succede)
|
||||
└── progress.csv # Log progresso (generato)
|
||||
```
|
||||
|
||||
## Algoritmo
|
||||
|
||||
1. **Caricamento target**: Legge le pubkey P2PK dal file
|
||||
2. **Inizializzazione**: Crea contesto secp256k1 e thread
|
||||
3. **Loop principale**:
|
||||
- Genera chiave privata casuale (256 bit)
|
||||
- Calcola pubkey non compressa (65 bytes) con secp256k1
|
||||
- Confronta con tutte le pubkey target (hash set - O(1))
|
||||
- Se match: salva e stampa
|
||||
- Altrimenti: incrementa privkey e riprova
|
||||
4. **Multi-threading**: Ogni thread ha seed diverso
|
||||
5. **Logging**: Salva progresso periodicamente
|
||||
|
||||
## Licenza e crediti
|
||||
|
||||
- **Scopo**: Educativo e di ricerca
|
||||
- **Libreria**: [libsecp256k1](https://github.com/bitcoin-core/secp256k1) (Bitcoin Core)
|
||||
- **Crittografia**: secp256k1 (ECDSA)
|
||||
|
||||
## Domande frequenti
|
||||
|
||||
### Q: Quanto tempo ci vorrà per trovare una chiave?
|
||||
|
||||
**A**: Con la velocità attuale dei computer, circa 10^60 volte l'età dell'universo.
|
||||
|
||||
### Q: E se uso una GPU?
|
||||
|
||||
**A**: Anche con GPU, il tempo sarebbe ancora astronomico. La sicurezza di Bitcoin si basa proprio su questo.
|
||||
|
||||
### Q: Posso parallelizzare su più macchine?
|
||||
|
||||
**A**: Sì, ma non cambierebbe la sostanza. Anche con 1 miliardo di computer, le probabilità restano zero.
|
||||
|
||||
### Q: Qualcuno ha mai trovato una chiave per bruteforce?
|
||||
|
||||
**A**: No. E non succederà mai con questo metodo.
|
||||
|
||||
### Q: Allora perché esiste questo programma?
|
||||
|
||||
**A**: Per scopi educativi. Per capire come funziona Bitcoin e perché è sicuro.
|
||||
2. Calcola la pubkey con Bitcoin Core
|
||||
3. Aggiungi a `target_keys.txt`
|
||||
4. Modifica codice per partire da quella chiave
|
||||
|
||||
---
|
||||
|
||||
**⚠️ Ricorda**: Questo progetto dimostra l'impossibilità pratica del bruteforce su Bitcoin. La crittografia funziona.
|
||||
## Note Tecniche
|
||||
|
||||
### Probabilità di Successo
|
||||
|
||||
**Spazio chiavi**: 2^256 ≈ 10^77
|
||||
|
||||
Con 300K keys/sec:
|
||||
- **1 ora**: ~1 miliardo (10^9) chiavi
|
||||
- **1 anno**: ~9.5 trilioni (10^15) chiavi
|
||||
- **Universo**: Servirebbe **10^60 anni** per tutto lo spazio
|
||||
|
||||
**Conclusione**: Statisticamente impossibile trovare una chiave casuale.
|
||||
|
||||
### Partizionamento Spazio Chiavi
|
||||
|
||||
Ogni thread riceve un chunk univoco:
|
||||
```
|
||||
Thread 0: 0x0000000000000000... → 0x1745d1741745d174...
|
||||
Thread 1: 0x1745d1741745d174... → 0x2e8ba2e82e8ba2e8...
|
||||
...
|
||||
```
|
||||
|
||||
All'interno del chunk:
|
||||
1. Inizia con chiave casuale
|
||||
2. Incrementa sequenzialmente +1
|
||||
3. **Zero sovrapposizione** garantita
|
||||
|
||||
### Bloom Filter
|
||||
|
||||
- **Dimensione**: 64 MB (2^26 bits)
|
||||
- **Hash functions**: 3 indipendenti
|
||||
- **False positive**: ~0.01%
|
||||
- **Speedup**: ~5-10%
|
||||
|
||||
### Algoritmo Incremento
|
||||
|
||||
```cpp
|
||||
// 4x più veloce di byte-per-byte
|
||||
uint64_t* p64 = (uint64_t*)privkey;
|
||||
if (++p64[3]) return; // 99.99% dei casi termina qui
|
||||
if (++p64[2]) return;
|
||||
if (++p64[1]) return;
|
||||
++p64[0];
|
||||
```
|
||||
|
||||
### libsecp256k1 Ottimizzata
|
||||
|
||||
Flags di compilazione:
|
||||
```bash
|
||||
-O3 # Ottimizzazione massima
|
||||
-march=native # Istruzioni CPU native (AVX2, etc)
|
||||
-mtune=native # Tuning per CPU specifica
|
||||
-flto # Link-Time Optimization
|
||||
-fomit-frame-pointer # Rimuove frame pointer
|
||||
-funroll-loops # Loop unrolling aggressivo
|
||||
```
|
||||
|
||||
Window size: **15** (standard ottimale per ECC)
|
||||
|
||||
---
|
||||
|
||||
## Contributori
|
||||
|
||||
Sviluppato con **Claude Code** (Anthropic)
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [Bitcoin Core secp256k1](https://github.com/bitcoin-core/secp256k1)
|
||||
- [SECP256k1 Specification](https://en.bitcoin.it/wiki/Secp256k1)
|
||||
- [Bloom Filters](https://en.wikipedia.org/wiki/Bloom_filter)
|
||||
- [Elliptic Curve Cryptography](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography)
|
||||
|
||||
---
|
||||
|
||||
**⚠️ Ricorda**: Questo progetto dimostra l'impossibilità pratica del bruteforce su Bitcoin. **La crittografia funziona.**
|
||||
|
||||
78
bruteforce/build_secp256k1.sh
Executable file
78
bruteforce/build_secp256k1.sh
Executable file
@@ -0,0 +1,78 @@
|
||||
#!/bin/bash
|
||||
# Script per compilare libsecp256k1 con ottimizzazioni massime
|
||||
|
||||
set -e
|
||||
|
||||
echo "[+] Compilazione libsecp256k1 ottimizzata per massime performance..."
|
||||
|
||||
# Directory di lavoro - locale nella cartella bruteforce
|
||||
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
WORK_DIR="$SCRIPT_DIR/secp256k1_build"
|
||||
INSTALL_DIR="$SCRIPT_DIR/secp256k1"
|
||||
|
||||
# Cleanup
|
||||
echo "[+] Pulizia directory precedenti..."
|
||||
rm -rf "$WORK_DIR"
|
||||
rm -rf "$INSTALL_DIR"
|
||||
mkdir -p "$WORK_DIR"
|
||||
mkdir -p "$INSTALL_DIR"
|
||||
|
||||
cd "$WORK_DIR"
|
||||
|
||||
# Clone repository ufficiale
|
||||
echo "[+] Download libsecp256k1 da Bitcoin Core..."
|
||||
git clone --depth 1 https://github.com/bitcoin-core/secp256k1.git
|
||||
cd secp256k1
|
||||
|
||||
# Configura con ottimizzazioni massime
|
||||
echo "[+] Configurazione con ottimizzazioni massime..."
|
||||
./autogen.sh
|
||||
|
||||
# FLAGS CRITICI PER PERFORMANCE:
|
||||
# --with-ecmult-window=15: Window size standard ottimale (24 richiede rigenerazione tabelle)
|
||||
# --enable-module-recovery: Abilita recovery
|
||||
# --enable-benchmark: Per testare performance
|
||||
# --disable-tests: Velocizza la compilazione
|
||||
# --disable-exhaustive-tests: Velocizza la compilazione
|
||||
|
||||
echo "[+] Configurazione..."
|
||||
CFLAGS="-O3 -march=native -mtune=native -flto -fomit-frame-pointer -funroll-loops" \
|
||||
./configure \
|
||||
--prefix="$INSTALL_DIR" \
|
||||
--with-ecmult-window=15 \
|
||||
--enable-module-recovery \
|
||||
--enable-module-extrakeys \
|
||||
--enable-module-schnorrsig \
|
||||
--enable-benchmark \
|
||||
--disable-tests \
|
||||
--disable-exhaustive-tests
|
||||
|
||||
echo "[+] Compilazione (usando $(nproc) core)..."
|
||||
make -j$(nproc)
|
||||
|
||||
echo "[+] Installazione in $INSTALL_DIR..."
|
||||
make install
|
||||
|
||||
# Test rapido
|
||||
echo "[+] Test performance..."
|
||||
if [ -f "$INSTALL_DIR/bin/bench_ecmult" ]; then
|
||||
echo "[+] Running benchmark..."
|
||||
"$INSTALL_DIR/bin/bench_ecmult" || true
|
||||
fi
|
||||
|
||||
# Pulizia directory temporanea di build (28MB risparmiati)
|
||||
echo "[+] Rimozione directory temporanea di build..."
|
||||
cd "$SCRIPT_DIR"
|
||||
rm -rf "$WORK_DIR"
|
||||
|
||||
echo ""
|
||||
echo "=========================================="
|
||||
echo " libsecp256k1 INSTALLATA"
|
||||
echo "=========================================="
|
||||
echo ""
|
||||
echo "Directory: $INSTALL_DIR"
|
||||
echo "Libreria: $INSTALL_DIR/lib/libsecp256k1.so"
|
||||
echo "Headers: $INSTALL_DIR/include/secp256k1.h"
|
||||
echo ""
|
||||
echo "Performance atteso: 1.5-2x più veloce della versione di sistema"
|
||||
echo "=========================================="
|
||||
@@ -17,30 +17,104 @@
|
||||
#include <sys/time.h>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <array>
|
||||
#include <unordered_set>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <sched.h> // Per CPU affinity
|
||||
|
||||
// Configurazione
|
||||
#define BATCH_SIZE 10000
|
||||
#define BATCH_SIZE 100000 // Batch più grande per ridurre overhead di sincronizzazione
|
||||
#define SAVE_INTERVAL 300 // Salva progresso ogni 5 minuti
|
||||
#define PROGRESS_INTERVAL 1000000 // Mostra progresso ogni N tentativi
|
||||
#define MAX_THREADS 256 // Massimo numero di thread supportati
|
||||
|
||||
// Ottimizzazioni avanzate
|
||||
#define USE_BLOOM_FILTER 1 // Usa Bloom filter per lookup ultra-veloce
|
||||
#define BLOOM_SIZE_BITS 26 // 2^26 = 64MB bloom filter (adattare in base alla RAM)
|
||||
|
||||
// Struttura per memorizzare le chiavi pubbliche target
|
||||
struct TargetKey {
|
||||
uint8_t pubkey[65]; // Chiave pubblica non compressa (65 bytes)
|
||||
char hex[131]; // Rappresentazione hex
|
||||
};
|
||||
|
||||
// Hash personalizzato per array di 65 bytes (pubkey)
|
||||
struct PubkeyHash {
|
||||
size_t operator()(const std::array<uint8_t, 65>& key) const {
|
||||
// Hash veloce usando i primi 8 bytes della pubkey
|
||||
const uint64_t* p = reinterpret_cast<const uint64_t*>(key.data());
|
||||
return p[0] ^ p[1];
|
||||
}
|
||||
};
|
||||
|
||||
#if USE_BLOOM_FILTER
|
||||
// Bloom Filter ultra-veloce per ridurre lookup costosi
|
||||
class BloomFilter {
|
||||
private:
|
||||
uint64_t* bits;
|
||||
size_t size_bits;
|
||||
size_t size_words;
|
||||
|
||||
// Hash functions ottimizzate
|
||||
inline uint64_t hash1(const uint8_t* data) const {
|
||||
const uint64_t* p = (const uint64_t*)data;
|
||||
return p[0] ^ (p[1] << 7);
|
||||
}
|
||||
|
||||
inline uint64_t hash2(const uint8_t* data) const {
|
||||
const uint64_t* p = (const uint64_t*)data;
|
||||
return p[2] ^ (p[3] << 13);
|
||||
}
|
||||
|
||||
inline uint64_t hash3(const uint8_t* data) const {
|
||||
const uint64_t* p = (const uint64_t*)data;
|
||||
return (p[4] ^ (p[5] << 19));
|
||||
}
|
||||
|
||||
public:
|
||||
BloomFilter(size_t bits_exponent) {
|
||||
size_bits = 1ULL << bits_exponent;
|
||||
size_words = size_bits / 64;
|
||||
bits = new uint64_t[size_words]();
|
||||
}
|
||||
|
||||
~BloomFilter() {
|
||||
delete[] bits;
|
||||
}
|
||||
|
||||
void add(const uint8_t* pubkey) {
|
||||
uint64_t h1 = hash1(pubkey) & (size_bits - 1);
|
||||
uint64_t h2 = hash2(pubkey) & (size_bits - 1);
|
||||
uint64_t h3 = hash3(pubkey) & (size_bits - 1);
|
||||
|
||||
bits[h1 / 64] |= (1ULL << (h1 % 64));
|
||||
bits[h2 / 64] |= (1ULL << (h2 % 64));
|
||||
bits[h3 / 64] |= (1ULL << (h3 % 64));
|
||||
}
|
||||
|
||||
inline bool might_contain(const uint8_t* pubkey) const {
|
||||
uint64_t h1 = hash1(pubkey) & (size_bits - 1);
|
||||
uint64_t h2 = hash2(pubkey) & (size_bits - 1);
|
||||
uint64_t h3 = hash3(pubkey) & (size_bits - 1);
|
||||
|
||||
return (bits[h1 / 64] & (1ULL << (h1 % 64))) &&
|
||||
(bits[h2 / 64] & (1ULL << (h2 % 64))) &&
|
||||
(bits[h3 / 64] & (1ULL << (h3 % 64)));
|
||||
}
|
||||
};
|
||||
|
||||
static BloomFilter* bloom_filter = NULL;
|
||||
#endif
|
||||
|
||||
// Variabili globali
|
||||
static volatile int keep_running = 1;
|
||||
static secp256k1_context* ctx = NULL;
|
||||
static std::vector<TargetKey> target_keys;
|
||||
static std::unordered_set<std::string> target_set;
|
||||
static std::unordered_set<std::array<uint8_t, 65>, PubkeyHash> target_set;
|
||||
static uint64_t attempts_per_thread[MAX_THREADS] = {0};
|
||||
static time_t start_time;
|
||||
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
@@ -56,13 +130,26 @@ struct ThreadData {
|
||||
};
|
||||
|
||||
// Rileva numero di thread/core disponibili
|
||||
// Lascia un thread libero per il sistema operativo e I/O
|
||||
int get_num_threads() {
|
||||
int num = (int)sysconf(_SC_NPROCESSORS_ONLN);
|
||||
if (num < 1) num = 1;
|
||||
if (num > 1) num--; // Lascia un core libero per migliorare l'efficienza
|
||||
if (num > MAX_THREADS) num = MAX_THREADS;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Imposta affinity del thread a un core specifico
|
||||
void set_thread_affinity(int core_id) {
|
||||
cpu_set_t cpuset;
|
||||
CPU_ZERO(&cpuset);
|
||||
CPU_SET(core_id, &cpuset);
|
||||
pthread_t current_thread = pthread_self();
|
||||
if (pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset) != 0) {
|
||||
fprintf(stderr, "[WARNING] Impossibile impostare affinity per core %d\n", core_id);
|
||||
}
|
||||
}
|
||||
|
||||
// Partiziona lo spazio delle chiavi tra i thread
|
||||
void partition_keyspace(int thread_id, int total_threads, uint8_t* range_start, uint8_t* range_end) {
|
||||
// Azzera entrambi gli array
|
||||
@@ -112,6 +199,13 @@ int hex_to_bytes(const char* hex, uint8_t* bytes, size_t len) {
|
||||
|
||||
// Carica le chiavi pubbliche P2PK dal file
|
||||
int load_target_keys(const char* filename) {
|
||||
#if USE_BLOOM_FILTER
|
||||
// Inizializza Bloom filter
|
||||
bloom_filter = new BloomFilter(BLOOM_SIZE_BITS);
|
||||
printf("[+] Bloom filter inizializzato: %llu MB\n",
|
||||
(unsigned long long)((1ULL << BLOOM_SIZE_BITS) / 8 / 1024 / 1024));
|
||||
#endif
|
||||
|
||||
std::ifstream file(filename);
|
||||
if (!file.is_open()) {
|
||||
fprintf(stderr, "[ERROR] Impossibile aprire %s\n", filename);
|
||||
@@ -149,7 +243,16 @@ int load_target_keys(const char* filename) {
|
||||
if (hex_to_bytes(pubkey_hex.c_str(), key.pubkey, 65)) {
|
||||
strcpy(key.hex, pubkey_hex.c_str());
|
||||
target_keys.push_back(key);
|
||||
target_set.insert(std::string((char*)key.pubkey, 65));
|
||||
|
||||
// Inserisci nel set usando std::array per lookup veloce
|
||||
std::array<uint8_t, 65> pubkey_array;
|
||||
memcpy(pubkey_array.data(), key.pubkey, 65);
|
||||
target_set.insert(pubkey_array);
|
||||
|
||||
#if USE_BLOOM_FILTER
|
||||
// Aggiungi anche al Bloom filter
|
||||
bloom_filter->add(key.pubkey);
|
||||
#endif
|
||||
count++;
|
||||
}
|
||||
}
|
||||
@@ -159,10 +262,10 @@ int load_target_keys(const char* filename) {
|
||||
return count;
|
||||
}
|
||||
|
||||
// Genera una chiave privata casuale nel range assegnato al thread
|
||||
void generate_random_privkey_in_range(uint8_t* privkey, uint64_t* seed,
|
||||
const uint8_t* range_start, const uint8_t* /*range_end*/) {
|
||||
// Usa xorshift64 per generare 32 bytes casuali
|
||||
// Inizializza una chiave privata casuale nel range assegnato al thread
|
||||
void init_random_privkey_in_range(uint8_t* privkey, uint64_t* seed,
|
||||
const uint8_t* range_start, const uint8_t* /*range_end*/) {
|
||||
// Genera 32 bytes completamente casuali usando xorshift64
|
||||
for (int i = 0; i < 32; i++) {
|
||||
*seed ^= *seed << 13;
|
||||
*seed ^= *seed >> 7;
|
||||
@@ -170,32 +273,42 @@ void generate_random_privkey_in_range(uint8_t* privkey, uint64_t* seed,
|
||||
privkey[i] = (uint8_t)(*seed & 0xFF);
|
||||
}
|
||||
|
||||
// Applica il range: mappa la chiave casuale nel range [range_start, range_end]
|
||||
// Usa i primi byte del range per definire il prefisso
|
||||
// I byte successivi sono completamente casuali all'interno del range
|
||||
// Applica il prefisso del range ai primi 8 bytes per partizionare lo spazio
|
||||
for (int i = 0; i < 8; i++) {
|
||||
// Copia i primi 8 bytes dal range_start per partizionare lo spazio
|
||||
privkey[i] = range_start[i];
|
||||
}
|
||||
// I restanti 24 bytes (192 bit) sono completamente casuali
|
||||
// Questo dà ad ogni thread uno spazio di 2^192 chiavi (ancora astronomico)
|
||||
// I restanti 24 bytes (192 bit) sono casuali all'interno del chunk del thread
|
||||
}
|
||||
|
||||
// Genera chiave completamente casuale (usata come fallback)
|
||||
void generate_random_privkey(uint8_t* privkey, uint64_t* seed) {
|
||||
// Usa un PRNG veloce (xorshift64)
|
||||
for (int i = 0; i < 32; i++) {
|
||||
*seed ^= *seed << 13;
|
||||
*seed ^= *seed >> 7;
|
||||
*seed ^= *seed << 17;
|
||||
privkey[i] = (uint8_t)(*seed & 0xFF);
|
||||
}
|
||||
// Incrementa la chiave privata di 1 (big-endian a 256 bit)
|
||||
// Ottimizzato per architetture a 64-bit usando operazioni native
|
||||
static inline void increment_privkey(uint8_t* privkey) {
|
||||
// Converti in array di uint64_t per operazioni a 64-bit (4x più veloce)
|
||||
uint64_t* p64 = (uint64_t*)privkey;
|
||||
|
||||
// Incrementa partendo dal uint64_t meno significativo (little-endian in memoria)
|
||||
// privkey[24-31] = p64[3], privkey[16-23] = p64[2], ecc.
|
||||
if (++p64[3]) return; // Nessun carry nel primo blocco (caso più comune ~99.99%)
|
||||
if (++p64[2]) return; // Carry solo nel secondo blocco
|
||||
if (++p64[1]) return; // Carry solo nel terzo blocco
|
||||
++p64[0]; // Carry fino al quarto blocco
|
||||
}
|
||||
|
||||
// Verifica se la pubkey corrisponde a un target
|
||||
int check_match(const uint8_t* pubkey) {
|
||||
std::string key_str((char*)pubkey, 65);
|
||||
return target_set.find(key_str) != target_set.end();
|
||||
// Ultra-ottimizzato: Bloom filter first, poi verifica precisa
|
||||
static inline int check_match(const uint8_t* pubkey) {
|
||||
#if USE_BLOOM_FILTER
|
||||
// First pass: Bloom filter (velocissimo, O(1) con 3 operazioni bit)
|
||||
if (!bloom_filter->might_contain(pubkey)) {
|
||||
return 0; // Sicuramente non presente (99.9%+ dei casi)
|
||||
}
|
||||
// Possibile match: verifica precisa con hash set
|
||||
#endif
|
||||
|
||||
// Verifica precisa solo se Bloom filter dice "forse presente"
|
||||
std::array<uint8_t, 65> pubkey_array;
|
||||
memcpy(pubkey_array.data(), pubkey, 65);
|
||||
return target_set.find(pubkey_array) != target_set.end();
|
||||
}
|
||||
|
||||
// Salva una chiave trovata
|
||||
@@ -281,48 +394,57 @@ void* worker_thread(void* arg) {
|
||||
int thread_id = data->thread_id;
|
||||
uint64_t seed = data->seed;
|
||||
|
||||
// Fissa questo thread a un core specifico per massima efficienza
|
||||
set_thread_affinity(thread_id);
|
||||
|
||||
// Pre-alloca tutte le variabili per evitare allocazioni nel loop
|
||||
uint8_t privkey[32];
|
||||
uint8_t pubkey[65];
|
||||
secp256k1_pubkey pubkey_obj;
|
||||
size_t pubkey_len = 65;
|
||||
size_t pubkey_len;
|
||||
|
||||
uint64_t local_attempts = 0;
|
||||
|
||||
printf("[+] Thread %d avviato (seed: %lu)\n", thread_id, seed);
|
||||
// Inizializza la chiave privata con un valore casuale nel range del thread
|
||||
init_random_privkey_in_range(privkey, &seed, data->range_start, data->range_end);
|
||||
|
||||
// Mostra la chiave privata di partenza per questo thread
|
||||
char privkey_start_hex[65];
|
||||
bytes_to_hex(privkey, 32, privkey_start_hex);
|
||||
printf("[+] Thread %d avviato su core %d\n", thread_id, thread_id);
|
||||
printf(" Privkey iniziale: %s\n", privkey_start_hex);
|
||||
|
||||
// Loop principale ultra-ottimizzato con prefetching e branch reduction
|
||||
pubkey_len = 65; // Costante, settato una volta sola
|
||||
|
||||
while (keep_running) {
|
||||
// Genera batch di chiavi
|
||||
for (int batch = 0; batch < BATCH_SIZE && keep_running; batch++) {
|
||||
// Genera chiave privata casuale nel range assegnato
|
||||
generate_random_privkey_in_range(privkey, &seed, data->range_start, data->range_end);
|
||||
|
||||
// Processa batch di chiavi consecutive
|
||||
for (int batch = 0; batch < BATCH_SIZE; batch++) {
|
||||
// Genera chiave pubblica non compressa usando secp256k1
|
||||
if (secp256k1_ec_pubkey_create(ctx, &pubkey_obj, privkey)) {
|
||||
// Questa è l'operazione più costosa (~95% del tempo)
|
||||
if (__builtin_expect(secp256k1_ec_pubkey_create(ctx, &pubkey_obj, privkey), 1)) {
|
||||
// Serializza in formato non compresso (65 bytes)
|
||||
secp256k1_ec_pubkey_serialize(ctx, pubkey, &pubkey_len,
|
||||
&pubkey_obj, SECP256K1_EC_UNCOMPRESSED);
|
||||
|
||||
// Verifica corrispondenza
|
||||
if (check_match(pubkey)) {
|
||||
// Verifica corrispondenza (Bloom filter first = velocissimo)
|
||||
// Solo ~0.001% dei casi passerà il Bloom filter
|
||||
if (__builtin_expect(check_match(pubkey), 0)) {
|
||||
save_found_key(privkey, pubkey);
|
||||
}
|
||||
}
|
||||
|
||||
local_attempts++;
|
||||
|
||||
// NOTA: Rimosso increment_privkey() - ogni chiave è completamente casuale
|
||||
// Questo elimina la sovrapposizione tra thread
|
||||
// Incrementa la chiave privata di 1 (inline, operazioni a 64-bit)
|
||||
increment_privkey(privkey);
|
||||
}
|
||||
|
||||
// Aggiorna contatore globale
|
||||
pthread_mutex_lock(&mutex);
|
||||
local_attempts += BATCH_SIZE;
|
||||
|
||||
// Aggiorna contatore globale (senza lock - ogni thread scrive solo il proprio indice)
|
||||
attempts_per_thread[thread_id] = local_attempts;
|
||||
pthread_mutex_unlock(&mutex);
|
||||
|
||||
// Mostra progresso periodicamente
|
||||
if (local_attempts % PROGRESS_INTERVAL == 0) {
|
||||
log_progress();
|
||||
}
|
||||
// Check keep_running solo una volta per batch invece che ad ogni iterazione
|
||||
if (__builtin_expect(!keep_running, 0)) break;
|
||||
}
|
||||
|
||||
printf("[+] Thread %d terminato (%lu tentativi)\n", thread_id, local_attempts);
|
||||
@@ -341,14 +463,29 @@ int main(int argc, char** argv) {
|
||||
target_file = argv[1];
|
||||
}
|
||||
|
||||
// Inizializza secp256k1
|
||||
// Inizializza secp256k1 con flag ottimizzato per verifiche multiple
|
||||
printf("[+] Inizializzazione secp256k1...\n");
|
||||
ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
|
||||
ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
|
||||
if (!ctx) {
|
||||
fprintf(stderr, "[ERROR] Impossibile creare contesto secp256k1\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Randomizza il contesto per migliorare la sicurezza e performance
|
||||
unsigned char random_seed[32];
|
||||
FILE* urandom = fopen("/dev/urandom", "rb");
|
||||
if (urandom) {
|
||||
size_t bytes_read = fread(random_seed, 1, 32, urandom);
|
||||
fclose(urandom);
|
||||
if (bytes_read == 32) {
|
||||
if (secp256k1_context_randomize(ctx, random_seed) != 1) {
|
||||
fprintf(stderr, "[WARNING] Impossibile randomizzare contesto secp256k1\n");
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "[WARNING] Impossibile leggere entropy da /dev/urandom\n");
|
||||
}
|
||||
}
|
||||
|
||||
// Carica chiavi target
|
||||
printf("[+] Caricamento chiavi target da %s...\n", target_file);
|
||||
if (load_target_keys(target_file) == 0) {
|
||||
@@ -453,6 +590,10 @@ int main(int argc, char** argv) {
|
||||
if (log_file) fclose(log_file);
|
||||
secp256k1_context_destroy(ctx);
|
||||
|
||||
#if USE_BLOOM_FILTER
|
||||
delete bloom_filter;
|
||||
#endif
|
||||
|
||||
printf("[+] Programma terminato\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user