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 :

Vulnérabilité	Année	Impact
Brainwallets	2011-2015	SHA256(phrase de passe) facilement cassé
Weak PRNGs	2013-2023	Seeds prévisibles (horodatages, PID)
Milksad	2023	libbitcoin bx utilisait MT19937 avec des seeds de 32 bits
MultiBit HD	2014-2016	Seed BIP39 de 64 octets utilisée comme entropie
Electrum pre-BIP39	2011-2014	Dérivation déterministe personnalisée avec affaiblissement faible
Armory HD	2012-2016	Dérivation déterministe pré-BIP32
LCG PRNGs	1990s-2010s	glibc rand(), MINSTD, MSVC - seulement état 31-32 bits
Xorshift PRNGs	2003-present	V8/SpiderMonkey Math.random() - état 64-128 bits
SHA256 chains	2010s-present	Dérivation de clé déterministe à partir de seeds faibles

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