vuke

脆弱なBitcoin鍵生成の分析と再現のための研究ツールです。

特徴

• モジュールアーキテクチャ - プラグイン可能なソースと変換
• 複数の入力ソース
  • 数値範囲（弱いシードのテスト）
  • ワードリスト（ブレインウォレット解析）
  • タイムスタンプ（時間ベースのPRNG悪用）
  • 標準入力ストリーム（パイプライン統合）
• 歴史的脆弱性変換
  • 直接（生バイトを鍵として）
  • SHA256（古典的ブレインウォレット）
  • ダブルSHA256（Bitcoinスタイルのハッシュ）
  • MD5（レガシーな弱いハッシュ）
  • SHA256チェーン（反復/インデックス指定による決定論的導出）
  • Milksad（MT19937 PRNG - CVE-2023-39910）
  • MultiBit HD（シードをエントロピーとして扱うバグ）
  • Electrum pre-BIP39（2011-2014年の決定論的導出）
  • Armory（レガシーHD導出）
• 鍵起源分析 - 脆弱な生成方法の逆検出
• 並列処理（Rayon経由）
• アドレスマッチング（既知のターゲットのスキャン用）
• ファイル出力（結果の保存用）
• クラウドストレージ - S3/R2/MinIOへの非同期アップロード
• Pure Rust実装

このプロジェクトの目的

このツールはセキュリティ研究のために設計されています。過去に脆弱な鍵がどのように生成されたかを理解することで、現代のウォレットセキュリティの向上に役立ちます。

このツールで再現可能な歴史的脆弱性：

インストール

Cargo```bash

cargo install vuke

### ソースから```bash
git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

Usage

パスフレーズから単一の鍵を生成する```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 - Bitcoinパズル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

標準入力からのパイプ```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回のリトライ、100ms→30s）
- 並行アップロード（並列度設定可能）
- 正常にアップロードされたローカルファイルのみ削除

### Iceberg catalog registration

アップロードされた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 (identity) と timestamp (day) でパーティション分割
• クラウドアップロードと共有される認証情報（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 analyzer

鍵が線形合同法を用いて生成されたかどうかを確認します:```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スタイルのパズル)

一部のBitcoinパズルは以下のようなマスキング方式を使用します：
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)

python
  - name: Use Python 3.12
    uses: actions/setup-python@v5
    with:
      python-version: "3.12"
  # TryHackMeセッション用に「充実した」環境を構築するため、多くのツールをインストールします。
  - name: Install APT Packages
    run: |
      sudo apt update
      sudo apt install -y \
      crunch \
      [...]```bash
# Analyze 10-bit puzzle key
vuke analyze 0x202 --mask 10 --analyzer milksad

Cascading filter (マルチパズル検証)

マスクされた鍵を分析する際、単一の小さなビット一致では偽陽性率が高くなります。カスケードフィルタは、複数の既知のパズル鍵に対して候補を検証します:```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)

The cascade format is bits:target,bits:target,... です。ここで：

• bits はマスク幅（1〜64）
• target は16進数（0x接頭辞付き）または10進数

確率分析：

• 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

`--puzzle` フラグ:
- プロバイダからパズルコンテキストを読み込みます
- puzzle.key.bits から `--mask` を自動設定します
- 検証用の期待されるアドレスを表示します

プロバイダを使用した `--cascade`:
- フォーマット: `boha:collection:puzzle_id:neighbor_count`
- ターゲットの前に解かれた N 個のパズルからカスケードを構築します
- デフォルト: カウント未指定の場合は 5 つの近傍

### MT19937-64 analyzer (64-bit seeds)

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 analyzer (64-bit seeds)

Xorshift PRNGs（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"

Supported variants:

• 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シードがエントロピーとして（16～32バイトを期待している）BitcoinJの DeterministicSeed コンストラクタに直接渡されるバグがありました。これにより、標準の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 issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) のバグのあるアドレスと一致します。
正しいBIP39アドレスは `12QxtuyEM8KBG3ngNRe2CZE28hFw3b1KMJ` です。

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

BIP39採用前のElectrumウォレットは、カスタムの決定論的派生スキームを使用していました：
- 128ビットの16進シードを100,000回のSHA256イテレーションでストレッチ
- 子キーは `(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 chain analyzer

決定論的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(input) | クラシックなブレインウォレット |
| `double_sha256` | SHA256(SHA256(input)) | Bitcoinスタイルのハッシュ |
| `md5` | MD5(input)を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[:variant][:endian]` | 32ビットシードのLCG PRNG | レガシーC標準ライブラリのrand() |
| `xorshift[:variant]` | 64ビットシードのXorshift PRNG | V8/SpiderMonkey Math.random() |
| `sha256_chain[:variant]` | 決定論的SHA256チェーン | 反復/インデックス付き鍵派生 |
| `bitimage` | File→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[:variant][:endian]` | 2^31-2^32シードの総当たり | glibc/minstd/msvc/borlandのrand()を検出 |
| `xorshift[:variant] --cascade` | カスケードフィルタ付き2^64総当たり | V8/SpiderMonkeyのxorshift PRNG |
| `sha256_chain[:variant]` | チェーン深さを考慮した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/HEAD/LICENSE)を参照してください。

## 参考資料

- [Milksad脆弱性](https://milksad.info/) - CVE-2023-39910
- [MultiBit HD Issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - シードをエントロピーとして使用するバグ
- [Brainwallet攻撃](https://eprint.iacr.org/2016/103.pdf) - 学術論文
- [Armoryドキュメント](https://btcarmory.com/) - レガシーHDウォレット
- [線形合同法](https://en.wikipedia.org/wiki/Linear_congruential_generator) - Wikipedia
- [Xorshift PRNGs](https://en.wikipedia.org/wiki/Xorshift) - Wikipedia
- [Electrum 1.x 鍵導出](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - BIP39以前のソースコード