vuke

用于分析和重现存在漏洞的比特币密钥生成的研究工具。

功能特性

• 模块化架构 — 可插拔的数据源和转换器
• 多种输入源
  • 数值范围（测试弱种子）
  • 单词列表（脑钱包分析）
  • 时间戳（基于时间的 PRNG 漏洞利用）
  • 标准输入流（管道集成）
• 历史漏洞转换器
  • 直接（原始字节作为密钥）
  • SHA256（经典脑钱包）
  • 双重 SHA256（比特币风格哈希）
  • MD5（遗留弱哈希）
  • SHA256 链（迭代/索引确定性推导）
  • Milksad（MT19937 PRNG — CVE-2023-39910）
  • MultiBit HD（种子作为熵的漏洞）
  • Electrum 预 BIP39（2011-2014 确定性推导）
  • Armory（遗留 HD 推导）
• 密钥来源分析 — 反向检测存在漏洞的生成方法
• 并行处理（基于 Rayon）
• 地址匹配 — 扫描已知目标
• 文件输出 — 保存结果
• 云存储 — 异步上传至 S3/R2/MinIO
• 纯 Rust 实现

为什么创建这个项目？

本工具专为安全研究而设计——理解过去存在漏洞的密钥生成方式有助于改进现代钱包的安全性。

本工具可重现的历史漏洞：

安装

Cargo```bash

cargo install vuke

### 从源码处```bash
git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

用法

从密码短语生成单一密钥```bash

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

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

扫描已知地址的单词列表```bash

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

### 数据提供者

不要使用文件路径，而是使用提供者引用来动态加载目标：```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

提供者语法：provider:collection:filter 或 provider:collection:id

可用集合（boha 提供者）：

• b1000 - 比特币谜题1000（256个谜题，1-256位）
• gsmg - GSMG谜题
• bitaps - Bitaps谜题
• hash_collision - 哈希碰撞谜题
• zden - Zden谜题
• bitimage - Bitimage谜题

测试数值范围（弱种子）```bash

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

### 测试基于 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

测试基于 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

### 测试基于时间戳的密钥```bash
vuke scan --transform=sha256 --targets addresses.txt timestamps --start 2015-01-01 --end 2015-01-31

从文件中派生密钥 (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/

### 多重转换```bash
vuke scan --transform=sha256 --transform=double_sha256 --transform=md5 --targets addresses.txt wordlist --file words.txt

从stdin管道输入```bash

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

### 保存结果到文件```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

持久化存储（Parquet）

将结果以 Parquet 格式存储，以便进行 TB 级分析（需要 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

### 使用SQL查询存储的结果

使用SQL查询已存储的Parquet文件（需要`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

输出格式：table（默认）、json、csv

云上传（兼容S3）

将Parquet结果上传至兼容S3的存储（需要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

Cloud upload features:
- 流式多部分上传（对大文件内存高效）
- 自动指数退避重试（5次重试，100毫秒→30秒）
- 可配置并行度的并发上传
- 仅删除成功上传的本地文件

### Iceberg 目录注册

将上传的 Parquet 文件注册到 Apache Iceberg 目录中，以便进行 SQL 查询（需要 `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

Iceberg 目录功能：

• REST 目录协议（兼容 Apache Polaris、Nessie、Tabular 等）
• 自动创建包含模式和分区规范的表
• 按 transform（标识）和 timestamp（日）分区
• 与云上传共享凭据（CLOUD_/AWS_ 环境变量）

基准测试变换```bash

vuke bench --transform milksad

### 分析私钥来源

检查私钥是否可能由存在漏洞的方法生成：```bash
vuke analyze c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a

输出：``` 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)

快速模式（跳过暴力破解）：```bash
vuke analyze --fast L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu

JSON 输出:```bash vuke analyze --fast --json c4bbcb1f...

特定分析器：```bash
vuke analyze --analyzer milksad c4bbcb1f...

LCG 分析器

检查密钥是否使用线性同余生成器生成：```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

### 掩码密钥分析（BTC1000风格谜题）

一些比特币谜题使用一种掩码方案，其中：
1. 生成完整的256位密钥（例如，来自MT19937）
2. 密钥被掩码为N位，最高位强制为1

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

输出：``` 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)

ShellGen 是一个基于 Python 的工具，用于生成和执行 shellcode。它支持使用用户指定的 IP 地址和端口来分段传输 shellcode。此外，ShellGen 还允许通过 `--sc` 标志自包含生成各种 shellcode 函数。

## 功能特性

- **生成 shellcode**：为多种平台（目前支持 Windows 和 Linux）创建 shellcode。
- **执行 shellcode**：在当前系统上执行 shellcode。
- **分段传输**：使用 `--staging` 标志生成能够回连到指定 IP 和端口的 shellcode，用于分段有效载荷。
- **自定义 shellcode**：使用 `--sc` 标志生成自定义的 shellcode 函数。
- **加密**：可以使用提供的密钥（`--key` 标志）通过 AES（CTR 模式）加密 shellcode，以增加隐蔽性。

## 安装

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

当分析掩码密钥时，单个小位匹配具有很高的误报率。级联过滤器会针对多个已知谜题密钥验证候选者：```bash

Verify seed against multiple puzzles with increasing bit widths

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

输出：```
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)

级联格式是 bits:target,bits:target,...，其中：

• bits 是掩码宽度（1-64）
• target 是十六进制（带 0x 前缀）或十进制

概率分析：

• 仅 P5：假阳性概率 1/16
• P5 + P10：1/16 × 1/512 = 1/8192
• P5 + P10 + P15：假阳性几乎不可能

基于提供者的分析

使用数据提供者自动配置拼图分析：```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

The `--puzzle` 标志：
- 从提供者加载谜题上下文
- 自动从 puzzle.key.bits 设置 `--mask`
- 显示预期地址以供验证

带有提供者的 `--cascade`：
- 格式：`boha:collection:puzzle_id:neighbor_count`
- 从目标之前的 N 个已解谜题构建级联
- 默认：如果未指定数量，则为 5 个邻居

### MT19937-64 分析器（64 位种子）

对于测试 64 位种子假设，`mt64` 分析器**需要**级联过滤器
（64 位种子空间无法穷举搜索）：```bash
# MT19937-64 cascade search - REQUIRES cascade filter
vuke analyze 0x15 --analyzer mt64 --cascade "5:0x15,10:0x202,20:0xd2c55,30:0x3d94cd64"

进度显示搜索速率和级联过滤器命中数：``` ⠋ Searched: 1200000 seeds | Rate: 850K/s | Elapsed: 1.4s | Cascade hits: 73

### Xorshift 分析器（64位种子）

Xorshift PRNG（用于 V8/SpiderMonkey JavaScript 引擎）由于64位种子空间也需要级联过滤器：```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"

支持的变体：

• xorshift:64 - 经典 64 位状态 xorshift
• xorshift:128 - 128 位状态 xorshift（种子初始化为 (seed, 0)）
• xorshift:128plus - Xorshift128+（用于 V8/SpiderMonkey 的 Math.random()）
• xorshift:xoroshiro - Xoroshiro128**（现代变体）

MultiBit HD 分析器（种子作为熵的漏洞）

MultiBit HD Beta 7（2014-2016）存在一个漏洞，即 64 字节的 BIP39 种子被直接作为熵传递给 BitcoinJ 的 DeterministicSeed 构造函数（期望 16-32 字节）。这创建了不兼容的密钥，无法使用标准 BIP39 工具恢复。```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

从已知助记词生成有缺陷的密钥：```bash
vuke single "skin join dog sponsor camera puppy ritual diagram arrow poverty boy elbow" --transform=multibit

输出（第一个密钥位于 m/0'/0/0）：``` P2PKH (compressed): 1LQ8XnNKqC7Vu7atH5k4X8qVCc9ug2q7WE

这与 [MultiBit HD 问题 #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) 中的错误地址匹配。
正确的 BIP39 地址应为 `12QxtuyEM8KBG3ngNRe2C28ZEhFw3b1KMJ`。

### Electrum 预 BIP39 密钥（2011-2014）

采用 BIP39 之前的 Electrum 钱包使用了自定义确定性派生方案：
- 通过 100,000 次 SHA256 迭代拉伸的 128 位十六进制种子
- 子密钥派生方式为 `(master + sequence) mod n`
- 地址使用未压缩公钥

从旧的 Electrum 种子生成密钥：```bash
# Generate receiving chain addresses (first 20 keys)
vuke single "acb740e454c3134901d7c8f16497cc1c" --transform electrum

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

输出 (接收地址0):``` P2PKH (uncompressed): 1FJEEB8ihPMbzs2SkLmr37dHyRFzakqUmo

### SHA256 链分析器

检测使用确定性 SHA256 链生成的密钥（key[n] = SHA256(key[n-1]) 或 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

支持的变体：

• sha256_chain 或 sha256_chain:iterated - 链派生：key[n] = SHA256(key[n-1])
• sha256_chain:indexed 或 sha256_chain:indexed:be - 索引：SHA256(seed || n) 使用大端序
• sha256_chain:indexed:le - 索引：使用小端字节序
• sha256_chain:counter - 字符串索引：SHA256(seed || "n")

SHA256链变换

使用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

## 支持的数据变换

| 变换 | 描述 | 使用场景 |
|-----------|-------------|----------|
| `direct` | 原始字节填充至 32 字节 | 测试原始数值种子 |
| `sha256` | SHA256(输入) | 经典脑钱包 |
| `double_sha256` | SHA256(SHA256(输入)) | 比特币风格哈希 |
| `md5` | MD5(输入) 复制至 32 字节 | 遗留弱哈希算法 |
| `milksad` | 基于 32 位种子的 MT19937 PRNG | CVE-2023-39910 (libbitcoin) |
| `mt64` | 基于 64 位种子的 MT19937-64 PRNG | 64 位种子假设检验 |
| `multibit` | MultiBit HD 将种子作为熵的错误 | 2014-2016 年 MultiBit HD 钱包 |
| `armory` | Armory HD 派生链 | BIP32 之前钱包 |
| `electrum` | Electrum 在 BIP39 之前的派生方式 | 2011-2014 年 Electrum 钱包 |
| `electrum:change` | Electrum 找零链 | 2011-2014 年 Electrum 找零地址 |
| `lcg[:变体][:字节序]` | 基于 32 位种子的 LCG PRNG | 遗留 C 标准库 rand() |
| `xorshift[:变体]` | 基于 64 位种子的 Xorshift PRNG | V8/SpiderMonkey Math.random() |
| `sha256_chain[:变体]` | 确定性 SHA256 链 | 迭代/索引密钥派生 |
| `bitimage` | 文件→base64→SHA256→BIP39→HD | Bitimage 谜题密钥派生 |

## 支持的分析器

| 分析器 | 方法 | 使用场景 |
|----------|--------|----------|
| `milksad` | 暴力破解 2^32 个种子 | 检查密钥是否属于 Milksad 受害者 |
| `milksad --mask N` | 带 N 位掩码的暴力破解 | BTC1000 风格谜题分析 |
| `milksad --cascade` | 多目标顺序验证 | 减少谜题研究中的误报 |
| `mt64 --cascade` | 暴力破解 2^64 并带有级联过滤器 | BTC1000 64 位 PRNG 假设 |
| `multibit-hd --mnemonic` | 针对密钥测试助记词 | 验证 MultiBit HD 漏洞来源 |
| `multibit-hd --mnemonic-file` | 字典攻击 | 为 MultiBit HD 密钥寻找助记词 |
| `direct` | 模式检测 | 检测小种子、ASCII 字符串 |
| `heuristic` | 统计分析 | 熵、汉明重量异常 |
| `lcg[:变体][:字节序]` | 暴力破解 2^31-2^32 个种子 | 检测 glibc/minstd/msvc/borland rand() |
| `xorshift[:变体] --cascade` | 暴力破解 2^64 并带有级联过滤器 | V8/SpiderMonkey xorshift PRNG |
| `sha256_chain[:变体]` | 暴力破解 2^32 个种子并指定链深度 | 确定性 SHA256 密钥链 |

## 库使用```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);
    }
}

架构```

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

## 要求

- Rust 1.70+

## 免责声明

此工具仅用于**教育和安全研究目的**。请勿用于访问您不拥有的钱包。作者不对任何滥用行为负责。

## 许可协议

MIT 许可协议 - 详见 [LICENSE](https://github.com/oritwoen/vuke/blob/main/LICENSE)。

## 参考

- [Milksad 漏洞](https://milksad.info/) - CVE-2023-39910
- [MultiBit HD 问题 #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - 将种子作为熵的漏洞
- [脑钱包攻击](https://eprint.iacr.org/2016/103.pdf) - 学术论文
- [Armory 文档](https://btcarmory.com/) - 旧版 HD 钱包
- [线性同余生成器](https://en.wikipedia.org/wiki/Linear_congruential_generator) - 维基百科
- [Xorshift 伪随机数生成器](https://en.wikipedia.org/wiki/Xorshift) - 维基百科
- [Electrum 1.x 密钥派生](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - BIP39 之前的源代码