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