# Bitcoin P2PK Research Suite

Suite completa di strumenti per ricerca educativa su transazioni Bitcoin Pay-to-Public-Key (P2PK) e sicurezza crittografica.

## ⚠️ Disclaimer Importante

**Questo progetto è ESCLUSIVAMENTE per scopi educativi e di ricerca.**

- Non utilizzare per attività illegali o tentativi di accesso non autorizzato
- La ricerca di chiavi private altrui è illegale
- Lo scopo è dimostrare la sicurezza crittografica di Bitcoin (ECDSA secp256k1)
- La probabilità di trovare chiavi per bruteforce è praticamente zero (1 su 2^256)

## Panoramica

Questo repository contiene due componenti principali:

1. **Scanner Python**: Analizza la blockchain Bitcoin per identificare e catalogare transazioni P2PK
2. **Bruteforce C++**: Dimostra l'impossibilità pratica di trovare chiavi private per bruteforce

## Quick Start

### 1. Scanner Python - Analisi Blockchain

Scansiona la blockchain Bitcoin per trovare transazioni P2PK e verificare UTXO.

```bash
# Installa dipendenze Python
python3 -m venv .venv
source .venv/bin/activate  # Linux/macOS
pip install -r requirements.txt

# Esegui lo scanner
cd databases
python3 scan_blockchain.py

# Genera report HTML
python3 view_db.py
```

**Output**:
- Database SQLite con tutte le transazioni P2PK trovate
- Report HTML interattivo con statistiche e ricerca
- Esportazione CSV dei dati

### 2. Bruteforce C++ - Dimostrazione Sicurezza

Dimostra l'impossibilità pratica del bruteforce su chiavi Bitcoin.

```bash
# Installa dipendenze C++
cd bruteforce
make install-deps

# Compila con ottimizzazioni massime
make

# Estrai chiavi P2PK non spese dal database
python3 extract_p2pk_utxo.py

# Esegui il bruteforce (dimostrazione)
./p2pk_bruteforce
```

**Performance**: ~50-100K keys/sec su hardware comune

## Documentazione Dettagliata

Ogni componente ha la sua documentazione specifica:

- **[Scanner Python](databases/README.md)**: Guida completa scanner blockchain
- **[Bruteforce C++](bruteforce/README.md)**: Guida completa programma bruteforce

## Componenti

### Scanner Python (Database)

**Scopo**: Analizzare la blockchain Bitcoin per identificare transazioni P2PK storiche.

**Caratteristiche**:
- Scansione blocchi Bitcoin via API mempool.space
- Salvataggio in database SQLite normalizzato
- Verifica UTXO in tempo reale (speso/non speso)
- Report HTML interattivo con statistiche
- Scansione incrementale (riprende da dove si ferma)
- Rate limiting intelligente per rispettare le API
- Esportazione dati in CSV

**Tecnologie**:
- Python 3.x
- SQLite3
- Requests (HTTP API)
- HTML/CSS/JavaScript (report)

**Blocchi interessanti**:
- Blocchi 1-10000: Era di Satoshi, quasi tutti P2PK
- Blocchi 10000-100000: Transizione verso P2PKH
- Blocchi 100000+: Prevalentemente P2PKH, P2SH, SegWit

### Bruteforce C++ (Ricerca Chiavi)

**Scopo**: Dimostrare l'impossibilità pratica del bruteforce su Bitcoin.

**Caratteristiche**:
- Ottimizzato per massima velocità (C++ con secp256k1)
- Multi-threading automatico (usa tutti i core CPU)
- Partizionamento spazio chiavi 2^256 tra thread
- Generazione chiavi casuali con seed robusti
- Statistiche in tempo reale (velocità, tentativi, tempo)
- Logging progresso in CSV
- Zero sovrapposizione tra thread (efficienza massima)
- Formato numeri leggibile (K, M, G, T)

**Tecnologie**:
- C++11
- libsecp256k1 (libreria Bitcoin Core)
- pthread (multi-threading)
- Makefile (build system)

**Ottimizzazioni**:
- Compilazione nativa (`-march=native -mtune=native`)
- Link-Time Optimization (`-flto`)
- Profile-Guided Optimization (opzionale)
- Partitioning dello spazio delle chiavi
- Seed XOR-based per zero correlazione

## Statistiche e Performance

### Scanner Python
- **Velocità**: ~1-5 blocchi/sec (dipende da delay API)
- **API calls**: ~3-5 per blocco
- **Database size**: ~100KB per 1000 blocchi P2PK
- **Rate limit**: Configurabile (default 1.0s tra blocchi)

### Bruteforce C++
- **Raspberry Pi 5 (4 core)**: ~50-60K keys/sec
- **CPU moderna (8 core)**: ~100-500K keys/sec
- **CPU high-end (16+ core)**: ~1M+ keys/sec
- **Efficienza threading**: Lineare (100% utilizzo core)

### Matematica della (Im)Probabilità

**Spazio delle chiavi**: 2^256 ≈ 1.16 × 10^77 chiavi possibili

**Con 1 milione di chiavi/sec**:
- 1 anno = 3.15 × 10^13 tentativi
- Probabilità successo = 2.7 × 10^-64 (praticamente zero)
- Tempo per testare tutto = 3.67 × 10^63 anni
- Età dell'universo = 1.38 × 10^10 anni

**Conclusione**: È più probabile vincere la lotteria 10 volte consecutive che trovare una chiave per caso.

## Workflow Completo

### Ricerca Educativa Tipica

1. **Scansione Blockchain** (Scanner Python):
   ```bash
   cd databases
   python3 scan_blockchain.py
   # Scansiona blocchi 1-10000 (ricchi di P2PK)
   ```

2. **Analisi Dati** (Visualizzatore):
   ```bash
   python3 view_db.py
   # Genera report HTML interattivo
   ```

3. **Estrazione Target** (Preparazione Bruteforce):
   ```bash
   cd ../bruteforce
   python3 extract_p2pk_utxo.py
   # Estrae P2PK non spesi dal database
   ```

4. **Dimostrazione Sicurezza** (Bruteforce):
   ```bash
   ./p2pk_bruteforce
   # Dimostra l'impossibilità pratica del bruteforce
   ```

## Scopo Educativo

Questo progetto insegna:

1. **Struttura Blockchain Bitcoin**:
   - Differenza tra P2PK, P2PKH, P2SH, SegWit
   - Formato transazioni e ScriptPubKey
   - Concetto di UTXO (Unspent Transaction Output)

2. **Crittografia Bitcoin**:
   - ECDSA su curva secp256k1
   - Generazione chiavi pubbliche da private
   - Spazio delle chiavi 2^256

3. **Sicurezza Crittografica**:
   - Perché il bruteforce è impossibile
   - Importanza dello spazio delle chiavi grande
   - Scalabilità esponenziale (ogni bit raddoppia il tempo)

4. **Ottimizzazione Software**:
   - Multi-threading efficiente
   - Partizionamento dati
   - Eliminazione race conditions
   - Profiling e misurazione performance

## Requisiti di Sistema

### Minimi
- **OS**: Linux, macOS, Windows (WSL)
- **RAM**: 512MB
- **Storage**: 100MB
- **CPU**: Single core
- **Python**: 3.7+
- **Compiler**: GCC 7+ o Clang 8+

### Raccomandati
- **OS**: Linux (migliore performance)
- **RAM**: 2GB+
- **Storage**: 1GB+
- **CPU**: Multi-core (4+)
- **Python**: 3.10+
- **Compiler**: GCC 11+ o Clang 14+

## Collaborazione Multi-Utente

### Scansione Distribuita

Più utenti possono collaborare per scansionare blocchi diversi:

1. **Utente A**: Scansiona blocchi 1-5000
2. **Utente B**: Scansiona blocchi 5001-10000
3. **Utente C**: Scansiona blocchi 10001-15000

```bash
# Sincronizza database via Git
git pull
python3 scan_blockchain.py  # Scansiona il tuo range
git add databases/*.db
git commit -m "Scansionati blocchi X-Y"
git push
```

### Best Practices
- Coordinarsi sui range di blocchi
- Usare delay ≥ 1.0s per non sovraccaricare API
- Fare pull prima di ogni nuova scansione
- Committare database dopo scansioni complete

## Risoluzione Problemi

### Scanner Python

**Errore: API timeout**
```bash
# Aumenta il delay tra richieste
# Nel prompt: delay = 2.0 secondi
```

**Errore: Database locked**
```bash
# Chiudi tutti gli script che usano il database
pkill -f scan_blockchain
```

### Bruteforce C++

**Errore: libsecp256k1 non trovata**
```bash
cd bruteforce
make install-secp256k1
```

**Velocità troppo bassa**
```bash
# Verifica numero thread
htop  # Controlla utilizzo CPU

# Ricompila con ottimizzazioni
make clean
make
```

## Crediti
- **Bitcoin**: [bitcoin.org](https://bitcoin.org)
- **API**: [mempool.space](https://mempool.space)
- **libsecp256k1**: [Bitcoin Core](https://github.com/bitcoin-core/secp256k1)
- **Documentazione**: [Bitcoin Wiki](https://en.bitcoin.it/wiki)

## Contributi
Sviluppato con assistenza di Claude Code (Anthropic).

## Link Utili

- [Bitcoin Whitepaper](https://bitcoin.org/bitcoin.pdf)
- [secp256k1 Documentation](https://github.com/bitcoin-core/secp256k1)
- [Mempool.space API](https://mempool.space/docs/api)
- [P2PK Transactions](https://en.bitcoin.it/wiki/Transaction)

---

**⚠️ Ricorda**: La sicurezza di Bitcoin si basa sull'impossibilità computazionale del bruteforce. Questo progetto lo dimostra in pratica.
