davide/p2pk-bf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Semplifica build e ottimizza bruteforce P2PK

Browse Source 
- Makefile: setup automatico libreria alla prima compilazione
- Bruteforce: ottimizzazioni multi-threading con CPU affinity
This commit is contained in:
Davide Grilli
2026-01-23 20:05:02 +01:00
parent 7f2fdf250a
commit 60cabb03d4
5 changed files with 529 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

456
bruteforce/README.md
View File

@@ -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.**