vuke

Research tool for analyzing and reproducing vulnerable Bitcoin key generation.

Features

• Modular architecture - pluggable sources and transforms
• Multiple input sources
  • Numeric ranges (test weak seeds)
  • Wordlists (brainwallet analysis)
  • Timestamps (time-based PRNG exploitation)
  • Stdin streaming (pipeline integration)
• Historical vulnerability transforms
  • Direct (raw bytes as key)
  • SHA256 (classic brainwallet)
  • Double SHA256 (Bitcoin-style hashing)
  • MD5 (legacy weak hashing)
  • SHA256 chain (iterated/indexed deterministic derivation)
  • Milksad (MT19937 PRNG - CVE-2023-39910)
  • MultiBit HD (seed-as-entropy bug)
  • Electrum pre-BIP39 (2011-2014 deterministic derivation)
  • Armory (legacy HD derivation)
• Key origin analysis - reverse detection of vulnerable generation methods
• Parallel processing via Rayon
• Address matching for scanning known targets
• File output for saving results
• Cloud storage - async upload to S3/R2/MinIO
• Pure Rust implementation

Why This Project?

This tool is designed for security research - understanding how vulnerable keys were generated in the past helps improve modern wallet security.

Historical vulnerabilities this tool can reproduce:

Vulnerability	Year	Impact
Brainwallets	2011-2015	SHA256(passphrase) easily cracked
Weak PRNGs	2013-2023	Predictable seeds (timestamps, PIDs)
Milksad	2023	libbitcoin bx used MT19937 with 32-bit seeds
MultiBit HD	2014-2016	64-byte BIP39 seed used as entropy
Electrum pre-BIP39	2011-2014	Custom deterministic derivation with weak stretching
Armory HD	2012-2016	Pre-BIP32 deterministic derivation
LCG PRNGs	1990s-2010s	glibc rand(), MINSTD, MSVC - only 31-32 bit state
Xorshift PRNGs	2003-present	V8/SpiderMonkey Math.random() - 64-128 bit state
SHA256 chains	2010s-present	Deterministic key derivation from weak seeds

Installation

Cargo

cargo install vuke

From source

git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

Usage

Generate single key from passphrase

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

Output:

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

Scan wordlist for known addresses

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

Data Providers

Instead of file paths, use provider references for dynamic target loading:

# 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

Provider syntax: provider:collection:filter or provider:collection:id

Available collections (boha provider):

• b1000 - Bitcoin puzzle 1000 (256 puzzles, 1-256 bits)
• gsmg - GSMG puzzle
• bitaps - Bitaps puzzle
• hash_collision - Hash collision puzzles
• zden - Zden puzzles
• bitimage - Bitimage puzzles

Test numeric range (weak seeds)

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

Test LCG-based keys

# 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 xorshift-based keys

# 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 timestamp-based keys

vuke scan --transform=sha256 --targets addresses.txt timestamps --start 2015-01-01 --end 2015-01-31

Derive keys from files (Bitimage)

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

Multiple transforms

vuke scan --transform=sha256 --transform=double_sha256 --transform=md5 --targets addresses.txt wordlist --file words.txt

Pipe from stdin

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

Save results to file

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

Persistent storage (Parquet)

Store results in Parquet format for TB-scale analysis (requires storage feature):

# 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

Query stored results (SQL)

Query stored Parquet files using SQL (requires storage-query feature):

# 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