p2pk-bf/bruteforce

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

sudo apt-get update
sudo apt-get install build-essential libsecp256k1-dev libgmp-dev git autoconf libtool pkg-config

Oppure usa il Makefile:

cd bruteforce
make install-deps

Compilare secp256k1 da sorgente (opzionale)

Se la versione nei repository è vecchia o mancante:

make install-secp256k1

Questo scarica, compila e installa l'ultima versione di libsecp256k1 da GitHub.

Compilazione

Compilazione standard

cd bruteforce
make

Questo crea l'eseguibile p2pk_bruteforce con ottimizzazioni -O3 e flags native.

Compilazione con ottimizzazioni massime

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

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:

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

./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:

#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:

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

# Verifica installazione
ldconfig -p | grep secp256k1

# Se non trovata, installa:
make install-secp256k1

Errore di compilazione: pthread

Assicurati di avere il flag -pthread:

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 (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.