p2pk-bf/bruteforce

Bitcoin P2PK Bruteforce

Strumento di ricerca chiavi private Bitcoin P2PK compilato per massime performance su CPU (fino a 300K+ keys/sec).

⚠️ DISCLAIMER: Solo per scopi educativi e di ricerca. Non utilizzare per attività illegali.

---

Indice

• Requisiti
• Installazione Rapida
• Utilizzo
• Comandi Make
• Troubleshooting
• Note Tecniche

---

Requisiti

Sistema Operativo

• Linux: Ubuntu/Debian (consigliato)
• Architettura: x86_64 o ARM64

Hardware Minimo

• CPU: Multicore (consigliato 8+ core)
• RAM: 2GB minimo, 4GB+ consigliato
• Disco: 500MB per libreria locale

Software

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

---

Installazione Rapida

cd bruteforce

# Compila automaticamente (prima volta ~5 minuti)
make

# Esegui
./p2pk_bruteforce

Risultato atteso: ~300K keys/sec

Nota: La prima volta make compilerà automaticamente libsecp256k1 locale (~5 minuti). Le volte successive sarà istantaneo.

---

Versione GPU (CUDA)

Se hai una GPU NVIDIA con driver e CUDA Toolkit disponibili, la versione GPU usa la stessa strategia algoritmica di quella CPU (batch EC in coordinate Jacobiane + una sola inversione di campo per batch) ma su migliaia di thread paralleli invece che su una manciata di core.

cd bruteforce
make gpu-info    # verifica driver NVIDIA (nvidia-smi) e CUDA Toolkit (nvcc)
make gpu         # compila (default: sm_61 / Pascal — sovrascrivi con NVCC_ARCH per altre GPU)
./p2pk_bruteforce_gpu

Su una Quadro P4000 (Pascal, 2016) si osservano ~30M keys/sec, contro i ~300K-2M keys/sec della CPU. La moltiplicazione scalare (costosa) viene eseguita una sola volta per kernel launch e poi il punto base viene fatto avanzare con semplici addizioni EC ripiegate nella batch inversion, quindi il grosso del tempo è ora nell'aritmetica di campo; su GPU più recenti il margine di miglioramento è ancora ampio.

Nota (WSL2): il driver NVIDIA arriva dal sistema Windows host (basta che nvidia-smi funzioni già) — dentro WSL serve installare solo il CUDA Toolkit, mai un driver.

---

Utilizzo

1. Prepara il File Target

Crea target_keys.txt con le chiavi pubbliche P2PK (una per riga):

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

# File default (target_keys.txt)
./p2pk_bruteforce

# File custom
./p2pk_bruteforce mie_chiavi.txt

3. Output Esempio

========================================
  Bitcoin P2PK Bruteforce v1.0
  SOLO PER SCOPI EDUCATIVI
========================================

[+] Inizializzazione secp256k1...
[+] Bloom filter inizializzato: 64 MB
[+] Caricamento chiavi target da target_keys.txt...
[+] Caricate 2164 chiavi pubbliche target
[+] CPU rilevata: 11 thread disponibili
[+] Partizionamento spazio chiavi in 11 regioni
[+] Avvio 11 thread worker...

[+] Thread 0 avviato su core 0
    Privkey iniziale: 0000000000000000a3f2b1c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4
[+] Thread 1 avviato su core 1
    Privkey iniziale: 1745d1741745d174f1e2d3c4b5a69788c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4
...

[INFO] Tentativi: 3.30M | Velocità: 300.00K keys/sec | Tempo: 11s
[INFO] Tentativi: 6.60M | Velocità: 300.00K keys/sec | Tempo: 22s

4. Chiave Trovata (se succede)

========================================
🎯 CHIAVE TROVATA! 🎯
========================================
Private Key: a1b2c3d4e5f6...
Public Key:  04f9e8d7c6b5a4...
========================================

Salvata in: found_keys.txt

---

Comandi Make

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

# Prima compilazione
make

# Modifiche successive al codice
make clean
make

---

Troubleshooting

Errore: Directory secp256k1 non trovata

make clean-all
make

Velocità Bassa (<250K keys/sec)

# 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

Errori di Compilazione

# Reinstalla dipendenze
sudo apt-get install -y build-essential git autoconf libtool pkg-config libgmp-dev

# Pulizia completa e ricompilazione
make clean-all
make

Il Programma non Trova Nulla

Questo è normale! La probabilità di trovare una chiave è praticamente zero.

Test funzionamento:

1. Genera una chiave privata nota
2. Calcola la pubkey con Bitcoin Core
3. Aggiungi a target_keys.txt
4. Modifica codice per partire da quella chiave

---

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

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

-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
• SECP256k1 Specification
• Bloom Filters
• Elliptic Curve Cryptography

---

⚠️ Ricorda: Questo progetto dimostra l'impossibilità pratica del bruteforce su Bitcoin. La crittografia funziona.