vuke

Strumento di ricerca per analizzare e riprodurre la generazione vulnerabile di chiavi Bitcoin.

Caratteristiche

• Architettura modulare - sorgenti e trasformazioni componibili
• Molteplici sorgenti di input
  • Intervalli numerici (testa semi deboli)
  • Wordlist (analisi dei brainwallet)
  • Timestamp (sfruttamento di PRNG basati sul tempo)
  • Streaming da stdin (integrazione in pipeline)
• Trasformazioni di vulnerabilità storiche
  • Diretta (byte grezzi come chiave)
  • SHA256 (brainwallet classico)
  • Doppia SHA256 (hashing stile Bitcoin)
  • MD5 (hashing debole legacy)
  • Catena SHA256 (derivazione deterministica iterata/indicizzata)
  • Milksad (MT19937 PRNG - CVE-2023-39910)
  • MultiBit HD (bug del seme come entropia)
  • Electrum pre-BIP39 (derivazione deterministica 2011-2014)
  • Armory (derivazione HD legacy)
• Analisi dell'origine della chiave - rilevamento inverso di metodi di generazione vulnerabili
• Elaborazione parallela tramite Rayon
• Corrispondenza degli indirizzi per la scansione di target noti
• Output su file per salvare i risultati
• Archiviazione cloud - upload asincrono verso S3/R2/MinIO
• Implementazione in puro Rust

Perché Questo Progetto?

Questo strumento è progettato per la ricerca sulla sicurezza - comprendere come venivano generate le chiavi vulnerabili in passato aiuta a migliorare la sicurezza dei portafogli moderni.

Vulnerabilità storiche che questo strumento può riprodurre:

Installazione

Cargo```bash

cargo install vuke

### Dalla sorgente```bash
git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

Utilizzo

Genera una singola chiave dalla passphrase```bash

vuke single "correct horse battery staple" --transform sha256

Uscita:```
Passphrase: "correct horse battery staple"
Transform: sha256
Source: correct horse battery staple
---
Private Key (hex):     c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a
WIF (compressed):      L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu
---
P2PKH (compressed):   1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T
P2WPKH:               bc1qfnpg7ceg02y64qrskgz0drwp3y6hma3q6wvnzr

Scansiona la wordlist per indirizzi noti```bash

vuke scan --transform=sha256 --targets known_addresses.txt wordlist --file passwords.txt

### Provider di dati

Invece dei percorsi dei file, utilizza riferimenti ai provider per il caricamento dinamico del target:```bash
# Scan all unsolved b1000 puzzles
vuke scan --transform=milksad --targets boha:b1000:unsolved range --start 1 --end 1000000

# Scan specific collection with filter
vuke scan --transform=sha256 --targets boha:b1000:with-pubkey wordlist --file words.txt

# Available filters: all, unsolved, solved, with-pubkey
vuke scan --targets boha:hash_collision:unsolved wordlist --file words.txt

Sintassi del provider: provider:collection:filter o provider:collection:id

Collezioni disponibili (provider boha):

• b1000 - Puzzle Bitcoin 1000 (256 puzzle, 1-256 bit)
• gsmg - Puzzle GSMG
• bitaps - Puzzle Bitaps
• hash_collision - Puzzle collisione hash
• zden - Puzzle Zden
• bitimage - Puzzle Bitimage

Testa intervallo numerico (semi deboli)```bash

vuke generate --transform=milksad range --start 1 --end 1000000

### Test delle chiavi basate su LCG```bash
# Generate keys using glibc rand() (default big-endian)
vuke generate --transform=lcg:glibc range --start 1 --end 1000000

# Use MINSTD variant with big-endian byte order
vuke generate --transform=lcg:minstd:be range --start 1 --end 1000

# Test all LCG variants at once
vuke generate --transform=lcg range --start 1 --end 100

Test delle chiavi basate su xorshift```bash

Generate keys using all xorshift variants (requires cascade filter for analysis)

vuke generate --transform=xorshift range --start 1 --end 1000000

Use specific variant

vuke generate --transform=xorshift:64 range --start 1 --end 1000 vuke generate --transform=xorshift:128 range --start 1 --end 1000 vuke generate --transform=xorshift:128plus range --start 1 --end 1000 vuke generate --transform=xorshift:xoroshiro range --start 1 --end 1000

### Test delle chiavi basate su timestamp```bash
vuke scan --transform=sha256 --targets addresses.txt timestamps --start 2015-01-01 --end 2015-01-31

Derivare chiavi da file (Bitimage)```bash

Generate key from a single file

vuke generate --transform=bitimage files --file image.jpg

Scan directory recursively

vuke generate --transform=bitimage files --dir ./images/

With custom derivation path and passphrase

vuke generate --transform=bitimage --bitimage-path "m/44'/0'/0'/0/0" --bitimage-passphrase "secret" files --file photo.png

Derive multiple addresses per file

vuke generate --transform=bitimage --bitimage-derive-count 10 files --dir ./data/

Brute-force passphrases from wordlist

vuke scan --transform=bitimage --bitimage-passphrase-wordlist passphrases.txt --targets addresses.txt files --dir ./images/

### Trasformazioni multiple```bash
vuke scan --transform=sha256 --transform=double_sha256 --transform=md5 --targets addresses.txt wordlist --file words.txt

Pipe da stdin```bash

cat passwords.txt | vuke generate --transform=sha256 stdin

### Salva i risultati in un file```bash
vuke generate --output results.csv range --start 1 --end 1000000
vuke generate --output results.txt --verbose range --start 1 --end 1000
vuke scan --output hits.txt --targets addresses.txt wordlist --file passwords.txt

Archiviazione persistente (Parquet)

Memorizza i risultati in formato Parquet per analisi su scala TB (richiede la funzionalità storage):```bash

Build with storage support

cargo build --release --features storage

Store generated keys to Parquet

vuke generate --storage ./results --transform milksad range --start 1 --end 1000000

Configure chunk rotation

vuke generate --storage ./results --chunk-records 500000 --chunk-bytes 50M range --start 1 --end 10000000

Configure compression (default: zstd level 3)

vuke generate --storage ./results --compression zstd --compression-level 9 range --start 1 --end 1000000

No compression (fastest writes)

vuke generate --storage ./results --compression none range --start 1 --end 1000000

Available algorithms: none, snappy, gzip, lz4, zstd

### Esegui query sui risultati memorizzati (SQL)

Esegui query sui file Parquet memorizzati usando SQL (richiede la funzionalità `storage-query`):```bash
# Build with query support
cargo build --release --features storage-query

# Count results by transform
vuke query ./results "SELECT transform, COUNT(*) FROM results GROUP BY transform"

# Find matches
vuke query ./results "SELECT * FROM results WHERE matched_target IS NOT NULL LIMIT 10"

# Export to JSON
vuke query ./results --format json "SELECT source, wif_compressed FROM results LIMIT 100"

# Export to CSV
vuke query ./results --format csv "SELECT address_p2pkh_compressed, wif_compressed FROM results" > export.csv

# Show schema
vuke query ./results --schema

Formati di output: table (default), json, csv

Caricamento su cloud (compatibile S3)

Carica i risultati Parquet su storage compatibile S3 (richiede la feature storage-cloud):```bash

Build with cloud upload support

cargo build --release --features storage-cloud

Set credentials (AWS S3)

export AWS_ACCESS_KEY_ID=your_key export AWS_SECRET_ACCESS_KEY=your_secret

Upload to AWS S3

vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket
--transform milksad range --start 1 --end 1000000

Upload to Cloudflare R2

vuke generate --storage ./results --cloud-upload
--cloud-endpoint https://account.r2.cloudflarestorage.com
--cloud-bucket my-r2-bucket
--transform milksad range --start 1 --end 1000000

Upload to MinIO (self-hosted)

vuke generate --storage ./results --cloud-upload
--cloud-endpoint http://localhost:9000
--cloud-bucket vuke-results
--transform milksad range --start 1 --end 1000000

Delete local files after successful upload

vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket
--cloud-delete-local
--transform milksad range --start 1 --end 1000000

Fail fast on upload errors (default: continue on failures)

vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket
--cloud-fail-fast
--transform milksad range --start 1 --end 1000000

Funzionalità di caricamento cloud:
- Caricamento multipart in streaming (efficiente in memoria per file di grandi dimensioni)
- Ritentativi automatici con backoff esponenziale (5 tentativi, 100ms→30s)
- Caricamenti concorrenti con parallelismo configurabile
- Elimina solo i file locali caricati con successo

### Registrazione del catalogo Iceberg

Registra i file Parquet caricati in un catalogo Apache Iceberg per query SQL (richiede la funzionalità `storage-iceberg`):```bash
# Build with Iceberg support
cargo build --release --features storage-iceberg

# Set credentials
export CLOUD_ACCESS_KEY_ID=your_key
export CLOUD_SECRET_ACCESS_KEY=your_secret

# Generate, upload, and register in Iceberg catalog
vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket \
  --iceberg-catalog http://localhost:8181 \
  --transform milksad range --start 1 --end 1000000

# With custom namespace and table name
vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket \
  --iceberg-catalog http://localhost:8181 \
  --iceberg-namespace my_namespace \
  --iceberg-table my_results \
  --transform milksad range --start 1 --end 1000000

# Using environment variables
export ICEBERG_CATALOG=http://localhost:8181
export ICEBERG_NAMESPACE=vuke
export ICEBERG_TABLE=results
vuke generate --storage ./results --cloud-upload --cloud-bucket my-bucket \
  --transform milksad range --start 1 --end 1000000

Caratteristiche del catalogo Iceberg:

• Protocollo REST del catalogo (compatibile con Apache Polaris, Nessie, Tabular, ecc.)
• Creazione automatica delle tabelle con schema e specifica di partizione
• Partizionato per transform (identità) e timestamp (giorno)
• Credenziali condivise con il caricamento cloud (variabili d'ambiente CLOUD_/AWS_)

Trasformazioni di benchmark```bash

vuke bench --transform milksad

### Analizza l'origine della chiave privata

Verifica se una chiave privata potrebbe essere stata generata da un metodo vulnerabile:```bash
vuke analyze c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a

[No input content provided to translate.]``` Private Key: c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a Bit Length: 256 Hamming Weight: 144

Analysis: ✗ milksad: NOT_FOUND (checked 4294967296 seeds) ✗ direct: NOT_FOUND (no direct patterns detected) ? heuristic: UNKNOWN (entropy=5.00, hamming=144)

Modalità veloce (salta la forza bruta):```bash
vuke analyze --fast L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu

Output JSON:```bash vuke analyze --fast --json c4bbcb1f...

Analizzatore specifico:```bash
vuke analyze --analyzer milksad c4bbcb1f...

Analizzatore LCG

Controlla se una chiave è stata generata usando un generatore lineare congruenziale:```bash

Check all LCG variants

vuke analyze --analyzer lcg

Check specific variant and endianness

vuke analyze --analyzer lcg:glibc:le

With masking for puzzle analysis

vuke analyze --analyzer lcg:glibc --mask 5 0x15

### Analisi delle chiavi mascherate (puzzle stile BTC1000)

Alcuni puzzle Bitcoin utilizzano uno schema di mascheramento in cui:
1. Una chiave completa a 256 bit viene generata (ad esempio, da MT19937)
2. La chiave viene mascherata a N bit con il bit più alto forzato a 1

Formula: `masked_key = (full_key & (2^N - 1)) | 2^(N-1)````bash
# Analyze 5-bit puzzle key 0x15
vuke analyze 0x15 --mask 5 --analyzer milksad

• Estrazione dei Log: Recupera i log degli eventi di Windows, incluse le informazioni sugli accessi e sulle attività degli utenti.
• Analisi Forense: Supporta la creazione di timeline e l'analisi delle correlazioni per identificare percorsi di attacco comuni.``` Private Key: 0000000000000000000000000000000000000000000000000000000000000015 Bit Length: 5 Hamming Weight: 3

Analysis: ✓ milksad: CONFIRMED (seed=1610000002, full_key=7ed2...5055, masked=0x15, mask_bits=5, formula=(key & 0x1f) | 0x10)

Please provide the Markdown content to translate.```bash
# Analyze 10-bit puzzle key
vuke analyze 0x202 --mask 10 --analyzer milksad

Filtro a cascata (verifica multi-puzzle)

Quando si analizzano chiavi mascherate, una singola corrispondenza a pochi bit ha un alto tasso di falsi positivi. Il filtro a cascata verifica i candidati rispetto a più chiavi puzzle note:```bash

Verify seed against multiple puzzles with increasing bit widths

vuke analyze 0x16 --analyzer milksad --cascade "5:0x16,10:0x273,15:0x7a85"

[No content provided to translate.]```
Private Key: 0000000000000000000000000000000000000000000000000000000000000016
Bit Length:  5
Hamming Weight: 3
---
Analysis:
  ✓ milksad: CONFIRMED (seed=100 (0x00000064))
  P5: target=0x16, full_key=08961c8b18dbd0ab4337434767df7b69572fad6c4f00c186b03f43d88af70a26
  P10: target=0x273, full_key=5e413501b4371e2862271f1f3550bc2f4236b6abe29ec9350e166bd322c3e673
  P15: target=0x7a85, full_key=f133ff22f0aac1de185139938f664d10e4ac2de46be7d29f3c458e353a1efa85)

Il formato a cascata è bits:target,bits:target,... dove:

• bits è la larghezza della maschera (1-64)
• target è in esadecimale (con prefisso 0x) o decimale

Analisi delle probabilità:

• Solo P5: 1/16 probabilità di falso positivo
• P5 + P10: 1/16 × 1/512 = 1/8192
• P5 + P10 + P15: falso positivo virtualmente impossibile

Analisi basata su provider

Utilizza provider di dati per configurare automaticamente l'analisi dei puzzle:```bash

Auto-set mask from puzzle bits (puzzle #5 = 5 bits)

vuke analyze 0x15 --puzzle boha:b1000:5

Build cascade from solved neighbors (3 puzzles before #5)

vuke analyze 0x15 --cascade boha:b1000:5:3 --analyzer milksad

Verify key against entire collection

vuke analyze 0x01 --verify boha:b1000

JSON output for scripting

vuke analyze 0x01 --verify boha:b1000 --json

Il flag `--puzzle`:
- Carica il contesto del puzzle dal provider
- Imposta automaticamente `--mask` da puzzle.key.bits
- Mostra l'indirizzo previsto per verifica

Il `--cascade` con provider:
- Formato: `boha:collection:puzzle_id:neighbor_count`
- Costruisce una cascata da N puzzle risolti prima del target
- Default: 5 vicini se il conteggio non è specificato

### Analizzatore MT19937-64 (semi a 64 bit)

Per testare ipotesi di semi a 64 bit, l'analizzatore `mt64` **richiede** il filtro a cascata
(lo spazio dei semi a 64 bit non è ricercabile esaustivamente):```bash
# MT19937-64 cascade search - REQUIRES cascade filter
vuke analyze 0x15 --analyzer mt64 --cascade "5:0x15,10:0x202,20:0xd2c55,30:0x3d94cd64"

Progress mostra il tasso di ricerca e i risultati del filtro a cascata:``` ⠋ Searched: 1200000 seeds | Rate: 850K/s | Elapsed: 1.4s | Cascade hits: 73

### Xorshift analyzer (semi a 64 bit)

I PRNG Xorshift (utilizzati nei motori JavaScript V8/SpiderMonkey) richiedono anch'essi un filtro a cascata a causa dello spazio dei semi a 64 bit:```bash
# Test all xorshift variants
vuke analyze 0x15 --analyzer xorshift --cascade "5:0x15,10:0x202,20:0xd2c55"

# Test specific variant
vuke analyze 0x15 --analyzer xorshift:64 --cascade "5:0x15,10:0x202,20:0xd2c55"
vuke analyze 0x15 --analyzer xorshift:128plus --cascade "5:0x15,10:0x202,20:0xd2c55"

Supported variants:

• xorshift:64 - Classico xorshift a stato a 64 bit
• xorshift:128 - xorshift a stato a 128 bit (seed inizializzato come (seed, 0))
• xorshift:128plus - Xorshift128+ (usato in V8/SpiderMonkey Math.random())
• xorshift:xoroshiro - Xoroshiro128** (variante moderna)

Analizzatore MultiBit HD (bug del seed come entropia)

MultiBit HD Beta 7 (2014-2016) aveva un bug in cui il seed BIP39 di 64 byte veniva passato direttamente al costruttore DeterministicSeed di BitcoinJ come entropia (previsti 16-32 byte). Questo creava chiavi incompatibili che non possono essere recuperate con gli strumenti BIP39 standard.```bash

Check if a key was generated by the MultiBit HD bug

vuke analyze --analyzer multibit-hd --mnemonic "word1 word2 ... word12"

Test with a specific passphrase

vuke analyze --analyzer multibit-hd --mnemonic "word1 word2 ..." --passphrase "my passphrase"

Dictionary attack with mnemonic file

vuke analyze --analyzer multibit-hd --mnemonic-file candidates.txt

Genera chiavi errate da un mnemonico noto:```bash
vuke single "skin join dog sponsor camera puppy ritual diagram arrow poverty boy elbow" --transform=multibit

Output (prima chiave a m/0'/0/0):``` P2PKH (compressed): 1LQ8XnNKqC7Vu7atH5k4X8qVCc9ug2q7WE

Questo corrisponde all'indirizzo difettoso di [MultiBit HD issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445).
L'indirizzo BIP39 corretto sarebbe `12QxtuyEM8KBG3ngNRe2CZE28hFw3b1KMJ`.

### Chiavi Electrum pre-BIP39 (2011-2014)

I portafogli Electrum prima dell'adozione di BIP39 utilizzavano uno schema di derivazione deterministica personalizzato:
- Seed esadecimale a 128 bit esteso tramite 100.000 iterazioni SHA256
- Chiavi figlie derivate come `(master + sequence) mod n`
- Chiavi pubbliche non compresse per indirizzi

Genera chiavi da un vecchio seed Electrum:```bash
# Generate receiving chain addresses (first 20 keys)
vuke single "acb740e454c3134901d7c8f16497cc1c" --transform electrum

# Generate change chain addresses
vuke single "acb740e454c3134901d7c8f16497cc1c" --transform electrum:change

Output (indirizzo di ricezione 0):``` P2PKH (uncompressed): 1FJEEB8ihPMbzs2SkLmr37dHyRFzakqUmo

### SHA256 chain analyzer

Rileva chiavi generate utilizzando catene SHA256 deterministiche (key[n] = SHA256(key[n-1]) or SHA256(seed || n)):```bash
# Check with iterated chain (default): key[n] = SHA256(key[n-1])
vuke analyze <KEY> --analyzer sha256_chain --chain-depth 20

# Check indexed variant: key[n] = SHA256(seed || n as bytes)
vuke analyze <KEY> --analyzer sha256_chain:indexed --chain-depth 20

# With masking for puzzle analysis
vuke analyze 0x15 --mask 5 --analyzer sha256_chain --chain-depth 10

# With cascade filter for reduced false positives
vuke analyze 0x15 --analyzer sha256_chain --cascade "5:0x15,10:0x202" --chain-depth 10

Supported variants:

• sha256_chain or sha256_chain:iterated - Derivazione a catena: key[n] = SHA256(key[n-1])
• sha256_chain:indexed or sha256_chain:indexed:be - Indicizzata: SHA256(seed || n) con big-endian
• sha256_chain:indexed:le - Indicizzata con ordine di byte little-endian
• sha256_chain:counter - Indicizzata a stringa: SHA256(seed || "n")

Trasformazione della catena SHA256

Genera chiavi utilizzando la derivazione a catena SHA256:```bash

Generate iterated chain keys from numeric seeds

vuke generate --transform=sha256_chain range --start 1 --end 1000

Generate indexed chain with counter strings

vuke generate --transform=sha256_chain:counter --chain-depth 5 wordlist --file seeds.txt

Generate with specific chain depth

vuke generate --transform=sha256_chain:iterated --chain-depth 10 range --start 1 --end 100

## Trasformazioni Supportate

| Trasformazione | Descrizione | Caso d'Uso |
|-----------|-------------|----------|
| `direct` | Byte grezzi riempiti a 32 byte | Test di semi numerici grezzi |
| `sha256` | SHA256(input) | Brainwallet classici |
| `double_sha256` | SHA256(SHA256(input)) | Hashing stile Bitcoin |
| `md5` | MD5(input) duplicato a 32 byte | Hashing debole legacy |
| `milksad` | PRNG MT19937 con seed a 32 bit | CVE-2023-39910 (libbitcoin) |
| `mt64` | PRNG MT19937-64 con seed a 64 bit | Test di ipotesi di seed a 64 bit |
| `multibit` | Bug del seed come entropia di MultiBit HD | Portafogli MultiBit HD del 2014-2016 |
| `armory` | Catena di derivazione HD Armory | Portafogli pre-BIP32 |
| `electrum` | Derivazione Electrum pre-BIP39 | Portafogli Electrum del 2011-2014 |
| `electrum:change` | Catena di cambio Electrum | Indirizzi di cambio Electrum del 2011-2014 |
| `lcg[:variant][:endian]` | PRNG LCG con seed a 32 bit | rand() legacy della libreria C stdlib |
| `xorshift[:variant]` | PRNG Xorshift con seed a 64 bit | Math.random() di V8/SpiderMonkey |
| `sha256_chain[:variant]` | Catena SHA256 deterministica | Derivazione di chiave iterata/indicizzata |
| `bitimage` | File→base64→SHA256→BIP39→HD | Derivazione di chiave per puzzle Bitimage |

## Analizzatori Supportati

| Analizzatore | Metodo | Caso d'Uso |
|----------|--------|----------|
| `milksad` | Forza bruta di 2^32 semi | Controlla se la chiave è vittima di Milksad |
| `milksad --mask N` | Forza bruta con mascheramento a N bit | Analisi puzzle stile BTC1000 |
| `milksad --cascade` | Verifica sequenziale multi-target | Riduce i falsi positivi nella ricerca di puzzle |
| `mt64 --cascade` | Forza bruta di 2^64 con filtro a cascata | Ipotesi PRNG a 64 bit di BTC1000 |
| `multibit-hd --mnemonic` | Test del mnemonico contro la chiave | Verifica origine del bug MultiBit HD |
| `multibit-hd --mnemonic-file` | Attacco a dizionario | Trova il mnemonico per la chiave MultiBit HD |
| `direct` | Rilevamento di pattern | Rileva semi piccoli, stringhe ASCII |
| `heuristic` | Analisi statistica | Anomalie di entropia e peso di Hamming |
| `lcg[:variant][:endian]` | Forza bruta di 2^31-2^32 semi | Rileva rand() di glibc/minstd/msvc/borland |
| `xorshift[:variant] --cascade` | Forza bruta di 2^64 con filtro a cascata | PRNG xorshift di V8/SpiderMonkey |
| `sha256_chain[:variant]` | Forza bruta di 2^32 semi con profondità di catena | Catene di chiave SHA256 deterministiche |

## Utilizzo della Libreria```rust
use vuke::derive::KeyDeriver;
use vuke::transform::{Input, Transform, Sha256Transform};

fn main() {
    let deriver = KeyDeriver::new();
    let transform = Sha256Transform;

    let input = Input::from_string("test passphrase".to_string());
    let mut buffer = Vec::new();
    transform.apply_batch(&[input], &mut buffer);

    for (source, key) in buffer {
        let derived = deriver.derive(&key);
        println!("Source: {}", source);
        println!("WIF: {}", derived.wif_compressed);
        println!("Address: {}", derived.p2pkh_compressed);
    }
}

Architettura```

src/ ├── main.rs # CLI entry point (clap derive) ├── lib.rs # Library exports ├── derive.rs # Private key → address derivation ├── matcher.rs # Address matching against targets ├── network.rs # Bitcoin network handling ├── benchmark.rs # Performance testing ├── provider.rs # Data provider system (boha puzzles) ├── lcg.rs # LCG PRNG shared logic ├── xorshift.rs # Xorshift PRNG shared logic ├── mt64.rs # MT19937-64 PRNG shared logic ├── multibit.rs # MultiBit HD bug logic (PBKDF2, BIP32) ├── electrum.rs # Electrum pre-BIP39 deterministic derivation ├── sha256_chain.rs # SHA256 chain shared logic (iterated/indexed) ├── bitimage.rs # Bitimage puzzle derivation logic ├── analyze/ │ ├── mod.rs # Analyzer trait and types │ ├── key_parser.rs # Parse hex/WIF/decimal keys │ ├── output.rs # Plain text and JSON formatting │ ├── milksad.rs # MT19937 brute-force (GPU accelerated) │ ├── mt64.rs # MT19937-64 brute-force (requires cascade) │ ├── multibit.rs # MultiBit HD mnemonic verification │ ├── lcg.rs # LCG brute-force (glibc, minstd, msvc, borland) │ ├── xorshift.rs # Xorshift brute-force (requires cascade) │ ├── sha256_chain.rs # SHA256 chain brute-force (GPU accelerated) │ ├── direct.rs # Pattern detection │ └── heuristic.rs # Statistical analysis ├── source/ │ ├── mod.rs # Source trait and types │ ├── range.rs # Numeric range source │ ├── wordlist.rs # File-based wordlist │ ├── timestamps.rs # Date range → Unix timestamps │ ├── stdin.rs # Streaming from stdin │ └── files.rs # File/directory source for binary data ├── output/ │ ├── mod.rs # Output trait │ ├── console.rs # Console output (compact CSV + verbose YAML) │ ├── multi.rs # Multi-output dispatcher │ ├── storage.rs # Parquet backend bridge (feature: storage) │ └── query_format.rs # DuckDB result formatting (feature: storage-query) ├── transform/ │ ├── mod.rs # Transform trait and types │ ├── input.rs # Input value representation │ ├── direct.rs # Raw bytes transform │ ├── sha256.rs # SHA256 hashing │ ├── double_sha256.rs # Double SHA256 │ ├── md5.rs # MD5 hashing │ ├── milksad.rs # MT19937 PRNG (CVE-2023-39910) │ ├── mt64.rs # MT19937-64 PRNG transform │ ├── multibit.rs # MultiBit HD seed-as-entropy bug │ ├── electrum.rs # Electrum pre-BIP39 deterministic derivation │ ├── lcg.rs # LCG PRNG transform │ ├── xorshift.rs # Xorshift PRNG transform │ ├── sha256_chain.rs # SHA256 chain transform │ ├── bitimage.rs # File-derived HD keys (Bitimage puzzle) │ └── armory.rs # Armory HD derivation ├── gpu/ # WebGPU acceleration (feature: gpu) │ ├── mod.rs # Module exports │ ├── context.rs # GPU device initialization │ ├── error.rs # GPU error types │ ├── buffer.rs # GPU buffer utilities │ ├── hash.rs # SHA256/MD5 hash pipelines │ ├── mt19937.rs # MT19937 brute-force pipeline │ ├── sha256_chain.rs # SHA256 chain pipeline │ └── shaders/ # WGSL compute shaders │ ├── mt19937.wgsl │ ├── sha256.wgsl │ └── md5.wgsl └── storage/ # Persistent storage (feature: storage) ├── mod.rs # StorageBackend trait ├── schema.rs # Arrow schema definitions ├── parquet_backend.rs # Parquet file writer with auto-chunking ├── query.rs # DuckDB SQL executor (feature: storage-query) ├── cloud/ # S3-compatible upload (feature: storage-cloud) │ ├── mod.rs # CloudUploader trait │ ├── s3.rs # S3/R2/MinIO implementation │ ├── credentials.rs # Credential resolution │ ├── sync.rs # Batch upload with concurrency │ ├── progress.rs # Upload progress tracking │ └── error.rs # Cloud error types └── iceberg/ # Iceberg catalog (feature: storage-iceberg) ├── mod.rs # Iceberg integration entry ├── catalog.rs # REST catalog client ├── schema.rs # Iceberg schema mapping ├── partition.rs # Partition spec └── error.rs # Iceberg error types

## Requisiti

- Rust 1.70+

## Disclaimer

Questo strumento è destinato esclusivamente a **fini educativi e di ricerca sulla sicurezza**. Non utilizzarlo per accedere a wallet che non possiedi. Gli autori non sono responsabili per eventuali usi impropri.

## Licenza

Licenza MIT - consultare [LICENSE](https://github.com/oritwoen/vuke/blob/HEAD/LICENSE) per i dettagli.

## Riferimenti

- [Vulnerabilità Milksad](https://milksad.info/) - CVE-2023-39910
- [Issue #445 di MultiBit HD](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - Bug seed-come-entropia
- [Attacchi Brainwallet](https://eprint.iacr.org/2016/103.pdf) - Articolo accademico
- [Documentazione di Armory](https://btcarmory.com/) - Wallet HD legacy
- [Generatore Lineare Congruenziale](https://en.wikipedia.org/wiki/Linear_congruential_generator) - Wikipedia
- [PRNG Xorshift](https://en.wikipedia.org/wiki/Xorshift) - Wikipedia
- [Derivazione chiavi Electrum 1.x](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - Codice sorgente pre-BIP39