vuke

Outil de recherche pour analyser et reproduire la génération de clés Bitcoin vulnérables.

Fonctionnalités

• Architecture modulaire - sources et transformations enfichables
• Sources d'entrée multiples
  • Plages numériques (tester les seeds faibles)
  • Listes de mots (analyse de brainwallet)
  • Horodatages (exploitation de PRNG basé sur le temps)
  • Flux stdin (intégration pipeline)
• Transformations de vulnérabilités historiques
  • Direct (octets bruts comme clé)
  • SHA256 (brainwallet classique)
  • Double SHA256 (hachage de style Bitcoin)
  • MD5 (hachage faible hérité)
  • SHA256 chain (dérivation déterministe itérée/indexée)
  • Milksad (PRNG MT19937 - CVE-2023-39910)
  • MultiBit HD (bogue seed comme entropie)
  • Electrum pre-BIP39 (dérivation déterministe personnalisée 2011-2014)
  • Armory (dérivation HD héritée)
• Analyse de l'origine des clés - détection inversée des méthodes de génération vulnérables
• Traitement parallèle via Rayon
• Correspondance d'adresses pour scanner les cibles connues
• Sortie fichier pour enregistrer les résultats
• Stockage cloud - téléchargement asynchrone vers S3/R2/MinIO
• Implémentation en Rust pur

Pourquoi ce projet ?

Cet outil est conçu pour la recherche en sécurité - comprendre comment les clés vulnérables étaient générées dans le passé aide à améliorer la sécurité des portefeuilles modernes.

Vulnérabilités historiques que cet outil peut reproduire :

Installation

Cargo```bash

cargo install vuke

### Depuis la source```bash
git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

Utilisation

Générer une clé unique à partir d'une phrase de passe```bash

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

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

Analyser une wordlist pour les adresses connues```bash

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

### Fournisseurs de données

Au lieu de chemins de fichiers, utilisez des références de fournisseur pour le chargement dynamique des cibles :```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

Syntaxe du fournisseur : provider:collection:filter ou provider:collection:id

Collections disponibles (fournisseur boha) :

• b1000 - Puzzle Bitcoin 1000 (256 puzzles, 1-256 bits)
• gsmg - Puzzle GSMG
• bitaps - Puzzle Bitaps
• hash_collision - Puzzles de collision de hachage
• zden - Puzzles Zden
• bitimage - Puzzles Bitimage

Tester une plage numérique (graines faibles)```bash

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

### Test des clés 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 des clés basées sur 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

### Tester les clés basées sur l'horodatage```bash
vuke scan --transform=sha256 --targets addresses.txt timestamps --start 2015-01-01 --end 2015-01-31

Dériver des clés à partir de fichiers (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/

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

Pipe depuis stdin```bash

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

### Enregistrer les résultats dans un fichier```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

Stockage persistant (Parquet)

Stockez les résultats au format Parquet pour une analyse TB-scale (nécessite la fonctionnalité 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

### Interroger les résultats stockés (SQL)

Interroger les fichiers Parquet stockés à l'aide de SQL (nécessite la fonctionnalité `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

Formats de sortie : table (par défaut), json, csv

Upload vers le cloud (compatible S3)

Téléchargez les résultats Parquet vers un stockage compatible S3 (nécessite la fonctionnalité 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

Fonctionnalités de téléversement cloud :
- Téléversement multipart en streaming (économe en mémoire pour les fichiers volumineux)
- Réessai automatique avec backoff exponentiel (5 tentatives, 100ms→30s)
- Téléversements concurrents avec parallélisme configurable
- Supprime uniquement les fichiers locaux qui ont été téléversés avec succès

### Enregistrement dans le catalogue Iceberg

Enregistrez les fichiers Parquet téléversés dans un catalogue Apache Iceberg pour l'interrogation SQL (nécessite la fonctionnalité `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

Fonctionnalités du catalogue Iceberg:

• Protocole de catalogue REST (compatible avec Apache Polaris, Nessie, Tabular, etc.)
• Création automatique de table avec schéma et spécification de partition
• Partitionné par transform (identity) et timestamp (jour)
• Identifiants partagés avec le téléchargement cloud (variables d'environnement CLOUD_/AWS_)

Transformations de benchmark```bash

vuke bench --transform milksad

### Analyser l'origine de la clé privée

Vérifier si une clé privée a pu être générée par une méthode vulnérable :```bash
vuke analyze c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a

Sortie:``` 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)

Mode rapide (ignorer la force brute):```bash
vuke analyze --fast L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu

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

Analyseur spécifique:```bash
vuke analyze --analyzer milksad c4bbcb1f...

Analyseur LCG

Vérifie si une clé a été générée à l'aide d'un générateur congruentiel linéaire :```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

### Analyse des clés masquées (énigmes de type BTC1000)

Certaines énigmes Bitcoin utilisent un schéma de masquage où :
1. Une clé complète de 256 bits est générée (par ex., à partir de MT19937)
2. La clé est masquée sur N bits avec le bit de poids fort forcé à 1

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

Sortie :``` 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)

(empty)```bash
# Analyze 10-bit puzzle key
vuke analyze 0x202 --mask 10 --analyzer milksad

Filtre en cascade (vérification multi-puzzle)

Lors de l'analyse de clés masquées, une correspondance sur un petit nombre de bits présente un taux élevé de faux positifs. Le filtre en cascade vérifie les candidats par rapport à plusieurs clés de puzzle connues :```bash

Verify seed against multiple puzzles with increasing bit widths

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

Sortie :```
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)

Le format en cascade est bits:target,bits:target,... où :

• bits est la largeur du masque (1-64)
• target est en hexadécimal (avec le préfixe 0x) ou en décimal

Analyse de probabilité :

• P5 seul : 1/16 de chance de faux positif
• P5 + P10 : 1/16 × 1/512 = 1/8192
• P5 + P10 + P15 : faux positif virtuellement impossible

Analyse basée sur les fournisseurs

Utilisez des fournisseurs de données pour configurer automatiquement l'analyse du 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

Le drapeau `--puzzle` :
- Charge le contexte du puzzle depuis le fournisseur
- Définit automatiquement `--mask` à partir de puzzle.key.bits
- Affiche l'adresse attendue pour vérification

Le `--cascade` avec fournisseur :
- Format : `boha:collection:puzzle_id:neighbor_count`
- Construit une cascade à partir de N puzzles résolus avant la cible
- Par défaut : 5 voisins si le nombre n'est pas spécifié

### Analyseur MT19937-64 (germes 64 bits)

Pour tester des hypothèses de germe 64 bits, l'analyseur `mt64` **nécessite** un filtre en cascade (l'espace des germes 64 bits n'est pas exhaustivement recherchable) :```bash
# MT19937-64 cascade search - REQUIRES cascade filter
vuke analyze 0x15 --analyzer mt64 --cascade "5:0x15,10:0x202,20:0xd2c55,30:0x3d94cd64"

La progression montre le taux de recherche et les résultats du filtre en cascade :``` ⠋ Searched: 1200000 seeds | Rate: 850K/s | Elapsed: 1.4s | Cascade hits: 73

### Analyseur Xorshift (graines 64-bit)

Les PRNG Xorshift (utilisés dans les moteurs JavaScript V8/SpiderMonkey) nécessitent également un filtre en cascade en raison de l'espace de graines 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 - Xorshift classique à état 64 bits
• xorshift:128 - Xorshift à état 128 bits (graine initialisée comme (seed, 0))
• xorshift:128plus - Xorshift128+ (utilisé dans Math.random() de V8/SpiderMonkey)
• xorshift:xoroshiro - Xoroshiro128** (variante moderne)

Analyseur MultiBit HD (bug graine-comme-entropie)

MultiBit HD Beta 7 (2014-2016) avait un bug où la graine BIP39 de 64 octets était passée directement au constructeur DeterministicSeed de BitcoinJ comme entropie (attendu 16‑32 octets). Cela créait des clés incompatibles qui ne peuvent pas être récupérées avec les outils 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

Générer des clés buggées à partir d'une mnémonique connue :```bash
vuke single "skin join dog sponsor camera puppy ritual diagram arrow poverty boy elbow" --transform=multibit

Sortie (première clé à m/0'/0/0):``` P2PKH (compressed): 1LQ8XnNKqC7Vu7atH5k4X8qVCc9ug2q7WE

Cela correspond à l'adresse défectueuse de [MultiBit HD issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445).
L'adresse BIP39 correcte serait `12QxtuyEM8KBG3ngNRe2CZE28hFw3b1KMJ`.

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

Les portefeuilles Electrum avant l'adoption de BIP39 utilisaient un schéma de dérivation déterministe personnalisé :
- Graine hexadécimale de 128 bits étirée via 100 000 itérations SHA256
- Clés enfants dérivées comme `(master + sequence) mod n`
- Clés publiques non compressées pour les adresses

Générer des clés à partir d'une ancienne graine Electrum :```bash
# Generate receiving chain addresses (first 20 keys)
vuke single "acb740e454c3134901d7c8f16497cc1c" --transform electrum

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

Sortie (adresse de réception 0):``` P2PKH (uncompressed): 1FJEEB8ihPMbzs2SkLmr37dHyRFzakqUmo

### Analyseur de chaîne SHA256

Détecter les clés générées à l'aide de chaînes SHA256 déterministes (key[n] = SHA256(key[n-1]) ou 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

Variantes prises en charge :

• sha256_chain ou sha256_chain:iterated - Dérivation en chaîne : key[n] = SHA256(key[n-1])
• sha256_chain:indexed ou sha256_chain:indexed:be - Indexé : SHA256(seed || n) en big-endian
• sha256_chain:indexed:le - Indexé avec ordre little-endian
• sha256_chain:counter - Indexé par chaîne : SHA256(seed || "n")

Transformation en chaîne SHA256

Générer des clés en utilisant la dérivation en chaîne 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

## Transformations prises en charge

| Transform | Description | Cas d'utilisation |
|-----------|-------------|-------------------|
| `direct` | Octets bruts complétés à 32 octets | Test des graines numériques brutes |
| `sha256` | SHA256(entrée) | Brainwallets classiques |
| `double_sha256` | SHA256(SHA256(entrée)) | Hachage de type Bitcoin |
| `md5` | MD5(entrée) dupliqué sur 32 octets | Hachage faible hérité |
| `milksad` | PRNG MT19937 avec graine de 32 bits | CVE-2023-39910 (libbitcoin) |
| `mt64` | PRNG MT19937-64 avec graine de 64 bits | Test d'hypothèse de graine 64 bits |
| `multibit` | Bogue graine-comme-entropie MultiBit HD | Portefeuilles MultiBit HD 2014-2016 |
| `armory` | Chaîne de dérivation HD Armory | Portefeuilles pré-BIP32 |
| `electrum` | Dérivation Electrum pré-BIP39 | Portefeuilles Electrum 2011-2014 |
| `electrum:change` | Chaîne de monnaie Electrum | Adresses de monnaie Electrum 2011-2014 |
| `lcg[:variant][:endian]` | PRNG LCG avec graine de 32 bits | rand() stdlib C hérité |
| `xorshift[:variant]` | PRNG Xorshift avec graine de 64 bits | V8/SpiderMonkey Math.random() |
| `sha256_chain[:variant]` | Chaîne SHA256 déterministe | Dérivation de clé itérée/indexée |
| `bitimage` | File→base64→SHA256→BIP39→HD | Dérivation de clé de puzzle Bitimage |

## Analyseurs pris en charge

| Analyseur | Méthode | Cas d'utilisation |
|-----------|---------|-------------------|
| `milksad` | Force brute sur 2^32 graines | Vérifier si la clé est victime de Milksad |
| `milksad --mask N` | Force brute avec masquage sur N bits | Analyse de puzzle de style BTC1000 |
| `milksad --cascade` | Vérification séquentielle multi-cibles | Réduire les faux positifs dans la recherche de puzzles |
| `mt64 --cascade` | Force brute 2^64 avec filtre en cascade | Hypothèse PRNG 64 bits BTC1000 |
| `multibit-hd --mnemonic` | Tester la mnémonique contre la clé | Vérifier l'origine du bogue MultiBit HD |
| `multibit-hd --mnemonic-file` | Attaque par dictionnaire | Trouver la mnémonique pour la clé MultiBit HD |
| `direct` | Détection de motifs | Détecter les petites graines, chaînes ASCII |
| `heuristic` | Analyse statistique | Anomalies d'entropie, poids de Hamming |
| `lcg[:variant][:endian]` | Force brute sur 2^31-2^32 graines | Détecter rand() glibc/minstd/msvc/borland |
| `xorshift[:variant] --cascade` | Force brute 2^64 avec filtre en cascade | V8/SpiderMonkey xorshift PRNGs |
| `sha256_chain[:variant]` | Force brute sur 2^32 graines avec profondeur de chaîne | Chaînes de clés SHA256 déterministes |

## Utilisation de la bibliothèque```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);
    }
}

Architecture```

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

## Prérequis

- Rust 1.70+

## Avertissement

Cet outil est destiné uniquement à des fins **éducatives et de recherche en sécurité**. Ne l'utilisez pas pour accéder à des portefeuilles qui ne vous appartiennent pas. Les auteurs ne sont pas responsables de toute utilisation abusive.

## Licence

Licence MIT - voir [LICENSE](https://github.com/oritwoen/vuke/blob/HEAD/LICENSE) pour plus de détails.

## Références

- [Vulnérabilité Milksad](https://milksad.info/) - CVE-2023-39910
- [Problème MultiBit HD #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - Bug Seed-as-entropy
- [Attaques Brainwallet](https://eprint.iacr.org/2016/103.pdf) - Article académique
- [Documentation d'Armory](https://btcarmory.com/) - Portefeuille HD Legacy
- [Générateur congruentiel linéaire](https://en.wikipedia.org/wiki/Linear_congruential_generator) - Wikipedia
- [Xorshift PRNGs](https://en.wikipedia.org/wiki/Xorshift) - Wikipedia
- [Dérivation de clé Electrum 1.x](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - Code source pré-BIP39