# 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](#requisiti)
- [Installazione Rapida](#installazione-rapida)
- [Utilizzo](#utilizzo)
- [Comandi Make](#comandi-make)
- [Troubleshooting](#troubleshooting)
- [Note Tecniche](#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
```bash
sudo apt-get update
sudo apt-get install -y build-essential git autoconf libtool pkg-config libgmp-dev
```

---

## Installazione Rapida

```bash
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.

```bash
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 ~15M keys/sec, contro i
~300K-2M keys/sec della CPU — ma la moltiplicazione scalare su GPU non è
ottimizzata quanto quella di libsecp256k1 (niente wNAF/tabelle precalcolate),
quindi il margine di ulteriore miglioramento è ancora ampio su GPU più
recenti.

> **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):

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

```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
```

---

## Troubleshooting

### Errore: Directory secp256k1 non trovata

```bash
make clean-all
make
```

### Velocità Bassa (<250K keys/sec)

```bash
# 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

```bash
# 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

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