352 lines
9.9 KiB
Markdown
352 lines
9.9 KiB
Markdown
# Bitcoin P2PK Bruteforce
|
||
|
||
Programma C++ ad alte prestazioni per la ricerca di chiavi private corrispondenti a indirizzi P2PK Bitcoin con UTXO non spesi.
|
||
|
||
## ⚠️ DISCLAIMER IMPORTANTE
|
||
|
||
**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**
|
||
|
||
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
|
||
|
||
## 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
|
||
|
||
- **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
|
||
|
||
```bash
|
||
sudo apt-get update
|
||
sudo apt-get install build-essential libsecp256k1-dev libgmp-dev git autoconf libtool pkg-config
|
||
```
|
||
|
||
Oppure usa il Makefile:
|
||
|
||
```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
|
||
make
|
||
```
|
||
|
||
Questo crea l'eseguibile `p2pk_bruteforce` con ottimizzazioni `-O3` e flags native.
|
||
|
||
### Compilazione con ottimizzazioni massime
|
||
|
||
```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
|
||
|
||
Prima di eseguire il bruteforce, devi estrarre le chiavi pubbliche target dal database dello scanner:
|
||
|
||
```bash
|
||
cd bruteforce
|
||
python3 extract_p2pk_utxo.py
|
||
```
|
||
|
||
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:
|
||
|
||
```
|
||
========================================
|
||
Bitcoin P2PK Bruteforce v1.0
|
||
SOLO PER SCOPI EDUCATIVI
|
||
========================================
|
||
|
||
[+] Inizializzazione secp256k1...
|
||
[+] Caricamento chiavi target da target_keys.txt...
|
||
[+] Caricate 12 chiavi pubbliche target
|
||
[+] Avvio 8 thread worker...
|
||
|
||
[+] Thread 0 avviato (seed: 1234567890)
|
||
[+] Thread 1 avviato (seed: 1234580235)
|
||
...
|
||
|
||
[INFO] Tentativi: 10000000 | Velocità: 125000.00 keys/sec | Tempo: 80s
|
||
[INFO] Tentativi: 20000000 | Velocità: 133000.00 keys/sec | Tempo: 150s
|
||
...
|
||
```
|
||
|
||
### 4. Se trova una chiave
|
||
|
||
Se il programma trova una corrispondenza, verrà stampata a schermo e salvata in `found_keys.txt`:
|
||
|
||
```
|
||
========================================
|
||
🎯 CHIAVE TROVATA! 🎯
|
||
========================================
|
||
Private Key: 000000000000000000000000000000000000000000000000123456789abcdef
|
||
Public Key: 04a1b2c3d4e5f6...
|
||
========================================
|
||
```
|
||
|
||
**NOTA**: È estremamente improbabile che questo accada mai.
|
||
|
||
## 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:
|
||
|
||
```bash
|
||
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
|
||
|
||
```bash
|
||
# Verifica installazione
|
||
ldconfig -p | grep secp256k1
|
||
|
||
# Se non trovata, installa:
|
||
make install-secp256k1
|
||
```
|
||
|
||
### Errore di compilazione: pthread
|
||
|
||
Assicurati di avere il flag `-pthread`:
|
||
|
||
```bash
|
||
g++ -pthread ... -o p2pk_bruteforce p2pk_bruteforce.cpp -lsecp256k1
|
||
```
|
||
|
||
### Velocità troppo bassa
|
||
|
||
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)
|
||
|
||
### Il programma non trova nulla
|
||
|
||
**Questo è normale.** La probabilità di trovare una chiave è praticamente zero.
|
||
|
||
Se vuoi testare il 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.
|
||
|
||
---
|
||
|
||
**⚠️ Ricorda**: Questo progetto dimostra l'impossibilità pratica del bruteforce su Bitcoin. La crittografia funziona.
|