vuke

Исследовательский инструмент для анализа и воспроизведения уязвимой генерации ключей Bitcoin.

Особенности

• Модульная архитектура — подключаемые источники и преобразования
• Несколько источников ввода
  • Числовые диапазоны (тестирование слабых seed)
  • Списки слов (анализ brainwallet)
  • Метки времени (эксплуатация PRNG на основе времени)
  • Потоковый ввод stdin (интеграция в конвейеры)
• Преобразования исторических уязвимостей
  • Direct (сырые байты как ключ)
  • SHA256 (классический brainwallet)
  • Double SHA256 (хеширование в стиле Bitcoin)
  • MD5 (устаревшее слабое хеширование)
  • SHA256 chain (итерированная/индексированная детерминированная деривация)
  • Milksad (PRNG MT19937 — CVE-2023-39910)
  • MultiBit HD (ошибка seed-как-энтропия)
  • 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: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-based ключей```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 для анализа в масштабе ТБ (требуется функция 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)

Запрос сохраненных файлов Parquet с помощью SQL (требуется функция `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:
- Streaming multipart upload (memory-efficient for large files)
- Automatic retry with exponential backoff (5 retries, 100ms→30s)
- Concurrent uploads with configurable parallelism
- Only deletes local files that were successfully uploaded

### Iceberg catalog registration

Register uploaded Parquet files in an Apache Iceberg catalog for SQL querying (requires `storage-iceberg` feature):```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 (день)
• Учетные данные, передаваемые при загрузке в облако (переменные окружения 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-style puzzles)

Некоторые 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)

ВВОД:```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

Флаг `--puzzle`:
- Загружает контекст головоломки от провайдера
- Автоматически устанавливает `--mask` из puzzle.key.bits
- Отображает ожидаемый адрес для проверки

`--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 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 - Классический xorshift с 64-битным состоянием
• xorshift:128 - 128-битный xorshift (начальное значение seed задается как (seed, 0))
• xorshift:128plus - Xorshift128+ (используется в Math.random() в V8/SpiderMonkey)
• xorshift:xoroshiro - Xoroshiro128** (современный вариант)

Анализатор MultiBit HD (ошибка seed-as-entropy)

В MultiBit HD Beta 7 (2014-2016) была ошибка, при которой 64-байтовая seed-фраза BIP39 передавалась напрямую конструктору DeterministicSeed библиотеки BitcoinJ в качестве энтропии (ожидалось 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 issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445).
Правильный адрес BIP39 был бы `12QxtuyEM8KBG3ngNRe2C28ZEhFw3b1KMJ`.

### Ключи Electrum до BIP39 (2011-2014)

Кошельки Electrum до внедрения BIP39 использовали собственную детерминированную схему вывода:
- 128-битная шестнадцатеричная начальная фраза, растянутая с помощью 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 анализатор цепочек

Обнаружение ключей, сгенерированных с использованием детерминированных цепочек SHA256 (key[n] = SHA256(key[n-1]) or 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 or sha256_chain:iterated - Цепочечная деривация: key[n] = SHA256(key[n-1])
• sha256_chain:indexed or sha256_chain:indexed:be - Индексированная: SHA256(seed || n) с прямым порядком байт (big-endian)
• sha256_chain:indexed:le - Индексированная с обратным порядком байт (little-endian)
• 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(входные данные) | Классические brainwallet'ы |
| `double_sha256` | SHA256(SHA256(входные данные)) | Хеширование в стиле Bitcoin |
| `md5` | MD5(входные данные), дублированный до 32 байт | Устаревшее слабое хеширование |
| `milksad` | MT19937 PRNG с 32-битным сидом | CVE-2023-39910 (libbitcoin) |
| `mt64` | MT19937-64 PRNG с 64-битным сидом | Тестирование гипотезы 64-битного сида |
| `multibit` | Ошибка сида-как-энтропии MultiBit HD | Кошельки MultiBit HD 2014–2016 |
| `armory` | Цепочка деривации Armory HD | Кошельки до BIP32 |
| `electrum` | Деривация Electrum до BIP39 | Кошельки Electrum 2011–2014 |
| `electrum:change` | Цепочка сдачи Electrum | Адреса сдачи Electrum 2011–2014 |
| `lcg[:вариант][:порядок_байт]` | LCG PRNG с 32-битным сидом | Устаревшая stdlib rand() |
| `xorshift[:вариант]` | Xorshift PRNG с 64-битным сидом | 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 с каскадным фильтром | Гипотеза 64-битного PRNG для BTC1000 |
| `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 с каскадным фильтром | Xorshift PRNG V8/SpiderMonkey |
| `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

## Requirements

- Rust 1.70+

## Disclaimer

Этот инструмент предназначен **только для образовательных и исследовательских целей в области безопасности**. Не используйте его для доступа к кошелькам, которые вам не принадлежат. Авторы не несут ответственности за любое неправомерное использование.

## License

Лицензия MIT — подробнее см. [LICENSE](https://github.com/oritwoen/vuke/blob/HEAD/LICENSE).

## References

- [Уязвимость Milksad](https://milksad.info/) - CVE-2023-39910
- [Проблема MultiBit HD #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) - Википедия
- [Генераторы Xorshift](https://en.wikipedia.org/wiki/Xorshift) - Википедия
- [Вывод ключей Electrum 1.x](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - Исходный код до BIP39