### Von der Quelle```bash
git clone https://github.com/oritwoen/vuke
cd vuke
cargo build --release

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

### Datenanbieter

Anstelle von Dateipfaden verwenden Sie Provider-Referenzen für das dynamische Laden von Zielen:```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

### Test LCG-basierte Schlüssel```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

### Testen von zeitstempelbasierten Schlüsseln```bash
vuke scan --transform=sha256 --targets addresses.txt timestamps --start 2015-01-01 --end 2015-01-31

### Mehrere Transformationen```bash
vuke scan --transform=sha256 --transform=double_sha256 --transform=md5 --targets addresses.txt wordlist --file words.txt

### Ergebnisse in Datei speichern```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

### Abfrage gespeicherter Ergebnisse (SQL)

Abfragen gespeicherter Parquet-Dateien mit SQL (erfordert die Funktion `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

Cloud-Upload-Funktionen:
- Streaming-Multipart-Upload (speichereffizient für große Dateien)
- Automatische Wiederholung mit exponentiellem Backoff (5 Wiederholungen, 100ms→30s)
- Gleichzeitige Uploads mit konfigurierbarer Parallelität
- Löscht nur lokale Dateien, die erfolgreich hochgeladen wurden

### Iceberg-Katalogregistrierung

Registrieren Sie hochgeladene Parquet-Dateien in einem Apache-Iceberg-Katalog für SQL-Abfragen (erfordert das `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

### Ursprung des privaten Schlüssels analysieren

Prüfen, ob ein privater Schlüssel mit einer anfälligen Methode generiert wurde:```bash
vuke analyze c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a

Schnellmodus (Brute-Force überspringen):```bash
vuke analyze --fast L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu

Spezifischer Analysator:```bash
vuke analyze --analyzer milksad c4bbcb1f...

### Analyse maskierter Schlüssel (BTC1000-ähnliche Rätsel)

Einige Bitcoin-Rätsel verwenden ein Maskierungsschema, bei dem:
1. Ein vollständiger 256-Bit-Schlüssel wird generiert (z. B. aus MT19937)
2. Der Schlüssel wird auf N Bits maskiert, wobei das höchste Bit auf 1 gesetzt wird

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

**_TeamServer-URL:_**  _http://ts.dev.army:4444/_
  **_TeamServer-FQDN:_**   _ts.dev.army_

Neu in Merlin Server v1.5.1
*   Neue Agent-Info-Nachrichten, um kompilierte und reflektierte DLL-Informationen zu senden
*   Unterstützung für Mythic 3.3 hinzugefügt
*   Standard-JA3-Signaturfolge aktualisiert
*   Neues `ja3`-Ausführungsmodul zum Berechnen des JA3-Fingerabdrucks eines TLS-Clients
*   Neue Host-Listenseite für alle vom Server angezeigten Hosts
*   Agenten-Listenseitentabellen aktualisiert, um Host-ID aufzunehmen
*   Aktualisierte Agenten-Listenseite zum Anzeigen der Zeit seit dem letzten Check-in
*   Aktualisiertes Agenten-Info-Menüreiter, um den Support für Authenticode zu verbessern und DLL-Informationen anzuzeigen
*   Ladbare Modul-Funktion für DLL-Agenten hinzugefügt
*   NTLM-Authentifizierung für HTTP-Listener hinzugefügt
*   Erweiterte `ls`-Modulunterstützung für DLL-Agenten
*   Erweiterte `shellcode`-Modulunterstützung für DLL-Agenten
*   Schreibzugriffsprüfung für DLL-Agenten in das `upload`-Modul integriert
*   Verbesserte Genauigkeit der Agenten-Check-in-Zeit auf Agentenfassung
*   Problem mit Multipart-Uploads unter Verwendung von HTTP/1.1 behoben
*   Problem mit der OPAQUE-Bibliothek zum Erstellen von Links auf Microsoft Windows behoben
*   Problem mit der OPAQUE-Bibliothek in Agenten behoben, um die Verbindung zu Servern zu ermöglichen, die mit `0.0.0.0` oder an alle IPs gebunden sind
*   Problem mit der OPAQUE-Bibliothek unter Verwendung von höheren SIOCTL-Codes als 8 Bytes beim Abrufen der RTT behoben
*   Problem mit dem Abrufen von TGTs und Services Tickets mit dem `invoke-kerberoast`-Modul behoben
*   Problem mit dem `makeAgents.sh`-Skript unter macOS und fehlenden Bash-Befehlen behoben
*   Problem mit dem Herunterladen einer Datei auf den Server behoben, wenn eine relative Pfadeingabe über die Shell eingegeben wurde
*   Problem mit der Anzeige einer langen Agentenliste und einer Panik behoben, wenn eine neue Agenten-Check-in-Nachricht vor der UI-Ansicht der Liste gesendet wurde
*   Problem mit Multipart/Form mit DLL-Agenten behoben
*   Problem mit `env`-Modul zum Prüfen auf `80` und `443` behoben
*   Problem mit der Panik beim Trennen der Verbindung zu einem Agenten behoben, der auf eine Verschlüsselungstastenrotation wartet
*   Problem mit der Anzeige und Verarbeitung mehrerer Agenten vom selben Host im agentUI behoben
*   JSON-Unterstützung während `ghost`-Agenten-Check-ins behoben
*   Problem behoben, bei dem das `quit`-Kommando die Tab-Vervollständigung verwendete, wenn es nicht sollte
*   Diverse Fehlerbehebungen, UI-Anpassungen und Aktualisierungen von Abhängigkeiten

Video
[![Video zur Einrichtung von Merlin Server](http://img.youtube.com/vi/R3githbtsP8/0.jpg)](https://youtu.be/R3githbtsP8)

Siehe [Schnellstart](#schnellstart) für weitere Informationen.

### Schnellstart

1.  Ein Skript herunterladen und ausführen, um eine aktuelle Version von Go, Merlin Server und Merlin Agent schnell zu installieren:
    ```bash
    ┌──(root💀Demon)─[~]
    └─# wget -O merlin_install.sh https://raw.githubusercontent.com/Ne0nd0g/merlin/refs/heads/dev/scripts/merlin_install.sh && chmod 755 merlin_install.sh && ./merlin_install.sh

    ```

2.  Merlin Server ausführen:
    ```bash
    ┌──(root💀Demon)─[~/merlin]
    └─# ./merlinServer-Linux-x64 -i 0.0.0.0 -p 443
    ```

3.  Merlin-Agenten auf einem Windows-, Mac- oder Linux-Host ausführen:
    ```bash
    PS C:\Users\Demon>.\merlinAgent.exe -url https://192.168.1.100:443
    ```

4.  Merlin verwenden, um Ziele zu erreichen:
    ```bash
    Merlin» use agent d07cff30-dbb0-49e6-9887-bd43bcc4c91f
    [agent]» cmd ping 8.8.8.8
    [agent]» exit
    Merlin» exit
    ```

Für eine detailliertere Installationsanleitung siehe [SERVER.md](https://github.com/oritwoen/vuke/blob/HEAD/data/docs/SERVER.md).

### Inhaltsverzeichnis

*   [🐦 Twitter](#-twitter)
*   [📺 YouTube](#-youtube)
*   [Schnellstart](#schnellstart)
*   [Lizenz](#lizenz)
*   [Mitwirken](#mitwirken)
*   [Verhaltenskodex](#verhaltenskodex)
*   [Danksagungen](#danksagungen)
*   [Spenden](#spenden)
*   [Autor](#autor)

## 🐦 Twitter

Auf Twitter folgen unter [@Ne0nd0g](https://twitter.com/Ne0nd0g)

## 📺 YouTube

Auf YouTube ansehen unter [@Ne0nd0g](https://youtube.com/c/Ne0nd0g)

## Lizenz

Merlin wird unter der GNU General Public License v3.0 zur Verfügung gestellt. Der vollständige Lizenztext ist in der [LIZENZ](https://github.com/oritwoen/vuke/blob/HEAD/LICENSE)-Datei verfügbar. Copyright © 2017-2024 Russel Van Tuyl (Ne0nd0g). Alle Rechte vorbehalten.

## Mitwirken

Vielen Dank für Ihr Interesse an einem Beitrag zu diesem Projekt. Bitte lesen Sie unsere [Richtlinien für Mitwirkende](https://github.com/oritwoen/vuke/blob/HEAD/CONTRIBUTING.md).

## Verhaltenskodex

Wir erwarten von allen, die mit diesem Projekt in Verbindung stehen, höchste professionelle Standards. Bitte lesen Sie unseren [Verhaltenskodex](https://github.com/oritwoen/vuke/blob/HEAD/CODE_OF_CONDUCT.md).

## Danksagungen

Ein großes Dankeschön an alle, die zum Merlin-Projekt beigetragen haben.
Die fortlaufende Unterstützung, die Ideen, die Anregungen und das Feedback waren für den Erfolg von Merlin von unschätzbarem Wert.

## Spenden

Wenn Sie spenden möchten, können Sie dies über [GitHub Sponsors](https://github.com/sponsors/Ne0nd0g) tun.

## Autor

Russel Van Tuyl ([@Ne0nd0g](https://twitter.com/Ne0nd0g))```bash
# Analyze 10-bit puzzle key
vuke analyze 0x202 --mask 10 --analyzer milksad

Ausgabe:```
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)

Das Flag `--puzzle`:
- Lädt den Puzzle-Kontext vom Provider
- Setzt automatisch `--mask` aus puzzle.key.bits
- Zeigt die erwartete Adresse zur Verifizierung an

Der `--cascade` mit Provider:
- Format: `boha:collection:puzzle_id:neighbor_count`
- Erstellt eine Cascade aus N gelösten Puzzles vor dem Ziel
- Standard: 5 Nachbarn, falls Anzahl nicht angegeben

### MT19937-64-Analysator (64-Bit-Seeds)

Zum Testen von 64-Bit-Seed-Hypothesen **erfordert** der `mt64`-Analysator einen Cascade-Filter
(64-Bit-Seed-Raum ist nicht vollständig durchsuchbar):```bash
# MT19937-64 cascade search - REQUIRES cascade filter
vuke analyze 0x15 --analyzer mt64 --cascade "5:0x15,10:0x202,20:0xd2c55,30:0x3d94cd64"

### Xorshift-Analysator (64-Bit-Seeds)

Xorshift-PRNGs (verwendet in den JavaScript-Engines V8/SpiderMonkey) benötigen aufgrund des 64-Bit-Seed-Raums ebenfalls einen Kaskadenfilter:```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"

Generiere fehlerhafte Schlüssel aus einer bekannten Mnemonic:```bash
vuke single "skin join dog sponsor camera puppy ritual diagram arrow poverty boy elbow" --transform=multibit

Dies entspricht der fehlerhaften Adresse aus [MultiBit HD issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445).
Die korrekte BIP39-Adresse wäre `12QxtuyEM8KBG3ngNRe2CZE28hFw3b1KMJ`.

### Electrum pre-BIP39-Schlüssel (2011-2014)

Electrum-Wallets vor der Einführung von BIP39 verwendeten ein benutzerdefiniertes deterministisches Ableitungsschema:
- 128-Bit-Hex-Seed, gestreckt durch 100.000 SHA256-Iterationen
- Kindschlüssel abgeleitet als `(master + sequence) mod n`
- Unkomprimierte öffentliche Schlüssel für Adressen

Schlüssel aus einem alten Electrum-Seed generieren:```bash
# Generate receiving chain addresses (first 20 keys)
vuke single "acb740e454c3134901d7c8f16497cc1c" --transform electrum

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

### SHA256-Kettenanalysator

Erkennt Schlüssel, die mit deterministischen SHA256-Ketten erzeugt wurden (key[n] = SHA256(key[n-1]) oder 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

## Unterstützte Transforms

| Transform | Beschreibung | Anwendungsfall |
|-----------|-------------|----------|
| `direct` | Rohbytes, auf 32 Bytes aufgefüllt | Testen roher numerischer Seeds |
| `sha256` | SHA256(Eingabe) | Klassische Brainwallets |
| `double_sha256` | SHA256(SHA256(Eingabe)) | Bitcoin-artiges Hashing |
| `md5` | MD5(Eingabe) auf 32 Bytes dupliziert | Veraltetes schwaches Hashing |
| `milksad` | MT19937 PRNG mit 32-Bit-Seed | CVE-2023-39910 (libbitcoin) |
| `mt64` | MT19937-64 PRNG mit 64-Bit-Seed | Testen der 64-Bit-Seed-Hypothese |
| `multibit` | MultiBit HD Seed-als-Entropie-Fehler | 2014-2016 MultiBit HD Wallets |
| `armory` | Armory HD Ableitungskette | Pre-BIP32 Wallets |
| `electrum` | Electrum Pre-BIP39 Ableitung | 2011-2014 Electrum Wallets |
| `electrum:change` | Electrum Wechselkette | 2011-2014 Electrum Wechseladressen |
| `lcg[:variant][:endian]` | LCG PRNG mit 32-Bit-Seed | Legacy C stdlib rand() |
| `xorshift[:variant]` | Xorshift PRNG mit 64-Bit-Seed | V8/SpiderMonkey Math.random() |
| `sha256_chain[:variant]` | Deterministische SHA256-Kette | Iterierte/indexierte Schlüsselableitung |
| `bitimage` | Datei→base64→SHA256→BIP39→HD | Bitimage Puzzle Schlüsselableitung |

## Unterstützte Analysatoren

| Analysator | Methode | Anwendungsfall |
|----------|--------|----------|
| `milksad` | Brute-Force 2^32 Seeds | Prüfen, ob Schlüssel Milksad-Opfer ist |
| `milksad --mask N` | Brute-Force mit N-Bit-Maskierung | BTC1000-artige Puzzle-Analyse |
| `milksad --cascade` | Multi-Target sequentielle Verifikation | Reduzierung von Fehlalarmen in der Puzzle-Forschung |
| `mt64 --cascade` | Brute-Force 2^64 mit Kaskadenfilter | BTC1000 64-Bit-PRNG-Hypothese |
| `multibit-hd --mnemonic` | Testen des Mnemonics gegen den Schlüssel | Überprüfen des Ursprungs des MultiBit HD Bugs |
| `multibit-hd --mnemonic-file` | Wörterbuchangriff | Finden des Mnemonics für MultiBit HD Schlüssel |
| `direct` | Mustererkennung | Erkennen kleiner Seeds, ASCII-Strings |
| `heuristic` | Statistische Analyse | Anomalien bei Entropie, Hamming-Gewicht |
| `lcg[:variant][:endian]` | Brute-Force 2^31-2^32 Seeds | Erkennen von glibc/minstd/msvc/borland rand() |
| `xorshift[:variant] --cascade` | Brute-Force 2^64 mit Kaskadenfilter | V8/SpiderMonkey Xorshift PRNGs |
| `sha256_chain[:variant]` | Brute-Force 2^32 Seeds mit Kettentiefe | Deterministische SHA256-Schlüsselketten |

## Bibliotheksnutzung```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);
    }
}

## Voraussetzungen

- Rust 1.70+

## Haftungsausschluss

Dieses Tool dient ausschließlich **Bildungs- und Sicherheitsforschungszwecken**. Verwenden Sie es nicht, um auf Wallets zuzugreifen, die Ihnen nicht gehören. Die Autoren übernehmen keine Verantwortung für Missbrauch.

## Lizenz

MIT-Lizenz - siehe [LICENSE](https://github.com/oritwoen/vuke/blob/HEAD/LICENSE) für Details.

## Referenzen

- [Milksad-Sicherheitslücke](https://milksad.info/) - CVE-2023-39910
- [MultiBit HD Issue #445](https://github.com/Multibit-Legacy/multibit-hd/issues/445) - Seed-as-Entropie-Fehler
- [Brainwallet-Angriffe](https://eprint.iacr.org/2016/103.pdf) - Wissenschaftliche Arbeit
- [Armory-Dokumentation](https://btcarmory.com/) - Legacy HD Wallet
- [Linearer Kongruenzgenerator](https://en.wikipedia.org/wiki/Linear_congruential_generator) - Wikipedia
- [Xorshift-PRNGs](https://en.wikipedia.org/wiki/Xorshift) - Wikipedia
- [Electrum 1.x Schlüsselableitung](https://github.com/spesmilo/electrum/blob/b9196260cfd515363a026c3bfc7bc7aa757965a0/lib/bitcoin.py) - Pre-BIP39-Quellcode