vuke

취약한 비트코인 키 생성을 분석하고 재현하기 위한 연구 도구입니다.

기능

• 모듈식 아키텍처 - 플러그 가능한 소스와 변환
• 다중 입력 소스
  • 숫자 범위 (취약한 시드 테스트)
  • 워드리스트 (브레인월렛 분석)
  • 타임스탬프 (시간 기반 PRNG 악용)
  • Stdin 스트리밍 (파이프라인 통합)
• 역사적 취약점 변환
  • 직접 (원시 바이트를 키로)
  • SHA256 (클래식 브레인월렛)
  • 이중 SHA256 (비트코인 스타일 해싱)
  • MD5 (레거시 취약 해싱)
  • SHA256 체인 (반복/인덱스 기반 결정론적 파생)
  • Milksad (MT19937 PRNG - CVE-2023-39910)
  • MultiBit HD (시드를 엔트로피로 사용하는 버그)
  • Electrum pre-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 syntax: provider:collection:filter or 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)

TB 규모 분석을 위해 결과를 Parquet 형식으로 저장합니다 (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

클라우드 업로드 기능:
- 스트리밍 멀티파트 업로드 (대용량 파일에 메모리 효율적)
- 지수 백오프를 사용한 자동 재시도 (5회, 100ms~30s)
- 구성 가능한 병렬 처리로 동시 업로드
- 성공적으로 업로드된 로컬 파일만 삭제

### Iceberg 카탈로그 등록

SQL 쿼리를 위해 업로드된 Parquet 파일을 Apache Iceberg 카탈로그에 등록합니다 (`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 catalog features:

• 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 분석기

키가 Linear Congruential Generator를 사용하여 생성되었는지 확인합니다:```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)

입력:```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은 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

The `--puzzle` flag:
- 공급자로부터 퍼즐 컨텍스트를 로드합니다.
- `puzzle.key.bits`에서 `--mask`를 자동 설정합니다.
- 확인을 위한 예상 주소를 표시합니다.

The `--cascade` with provider:
- 형식: `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 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"

지원되는 변형:

• 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

알려진 mnemonic으로부터 버그 있는 키 생성:```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 주소는 `12QxtuyEM8KBG3ngNRe2CZE28hFw3b1KMJ`입니다.

### Electrum pre-BIP39 키 (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

Output (receiving address 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(입력) | 클래식 브레인월렛 |
| `double_sha256` | SHA256(SHA256(입력)) | 비트코인 스타일 해싱 |
| `md5` | 32바이트로 복제된 MD5(입력) | 레거시 약한 해싱 |
| `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 pre-BIP39 파생 | 2011-2014 Electrum 월렛 |
| `electrum:change` | Electrum 변경 체인 | 2011-2014 Electrum 변경 주소 |
| `lcg[:variant][:endian]` | 32비트 시드의 LCG PRNG | 레거시 C stdlib rand() |
| `xorshift[:variant]` | 64비트 시드의 Xorshift PRNG | V8/SpiderMonkey Math.random() |
| `sha256_chain[:variant]` | 결정론적 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[: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 vulnerability](https://milksad.info/) - CVE-2023-39910
- [MultiBit HD issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - 시드-엔트로피 버그
- [Brainwallet attacks](https://eprint.iacr.org/2016/103.pdf) - 학술 논문
- [Armory documentation](https://btcarmory.com/) - 레거시 HD 지갑
- [Linear Congruential Generator](https://en.wikipedia.org/wiki/Linear_congruential_generator) - 위키백과
- [Xorshift PRNGs](https://en.wikipedia.org/wiki/Xorshift) - 위키백과
- [Electrum 1.x key derivation](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - BIP39 이전 소스 코드