byvalver — nimmt schädliche Bytes von Shellcode auf und verbannnt sie, wobei bereinigter Shellcode mit erhaltener Funktionalität zurückgegeben wird | Kitploit

Architektur	Reife	Strategien	Anmerkungen
x86 (32-Bit Intel/AMD)	Stabil v4.2	150+	Produktionserprobt, vollständige Abdeckung
x64 (64-Bit Intel/AMD)	Stabil v4.2	150+	Standardarchitektur, produktionserprobt
ARM (32-Bit)	Experimentell v0.1	7 Kern	Eingeschränkte Tests, nur Kernbefehle
ARM64 (AArch64)	Experimentell v0.1	Basis	Framework bereit, minimale Strategien

**VERWENDUNG VON BAD-BYTE-PROFILEN:**```bash
# HTTP contexts (removes null, newline, carriage return)
byvalver --profile http-newline input.bin output.bin

# SQL injection contexts
byvalver --profile sql-injection input.bin output.bin

# Alphanumeric-only shellcode (most restrictive)
byvalver --profile alphanumeric-only input.bin output.bin

**ERWEITERTE FUNKTIONEN:**```bash
# Add obfuscation layer before denullification
byvalver --biphasic input.bin output.bin

# Enable ML-powered strategy selection
byvalver --ml input.bin output.bin

# Generate XOR-encoded shellcode with decoder stub
byvalver --xor-encode DEADBEEF input.bin output.bin

# Output in different formats
byvalver --format c input.bin output.c      # C array
byvalver --format python input.bin output.py # Python bytes
byvalver --format hexstring input.bin output.hex # Hex string

### ARCHITEKTURÜBERGREIFENDE UNTERSTÜTZUNG

`byvalver` unterstützt mehrere Architekturen über das Flag `--arch`:

**x86 (32-Bit Intel/AMD)** - Vollständig unterstützt mit über 150 Strategien```bash
byvalver --arch x86 --bad-bytes "00" x86_shellcode.bin output.bin

**Hinweise:**
- Der ARM/ARM64-Support konzentriert sich auf Kernbefehle (MOV, Arithmetik, Laden/Speichern)
- Verwenden Sie einfachere Bad-Byte-Profile für ARM (z. B. nur Null-Byte)
- Experimentelle Warnungen werden angezeigt, wenn ARM/ARM64 ausgewählt ist
- Eine grundlegende Architektur-Fehlpaarungserkennung warnt, wenn der Shellcode die falsche Architektur zu haben scheint
- Die automatische Architekturerkennung ist für zukünftige Versionen geplant

### STAPELVERARBEITUNG

Verarbeiten Sie ganze Verzeichnisse:```bash
# Process all .bin files recursively
byvalver -r --pattern "*.bin" input_dir/ output_dir/

# Apply HTTP profile to all shellcode in directory
byvalver -r --profile http-newline input_dir/ output_dir/

### HAUPTFUNKTIONEN:

Das TUI bietet 9 Hauptmenüoptionen, die die gesamte CLI-Funktionalität abdecken:

1. **Einzelne Datei verarbeiten** - Verarbeitung einzelner Shellcode-Dateien mit visuellem Feedback
2. **Stapelverarbeitung eines Verzeichnisses** - Verarbeitung ganzer Verzeichnisse mit Live-Fortschrittsanzeige
3. **Verarbeitungsoptionen konfigurieren** - Biphasischen Modus, PIC-Erzeugung, ML, Ausführlich, Probelauf umschalten
4. **Bad Bytes festlegen** - Manuelle Eingabe oder Auswahl aus 13 vordefinierten Profilen
5. **Ausgabeformateinstellungen** - Auswahl aus 5 Ausgabeformaten (raw, C, Python, PowerShell, hexstring)
6. **ML-Metrikenkonfiguration** - Konfiguration der ML-Strategieauswahl und Metrikverfolgung
7. **Erweiterte Optionen** - XOR-Kodierung, Zeitüberschreitungen, Grenzwerte, Validierungseinstellungen
8. **Konfiguration laden/speichern** - INI-artige Verwaltung von Konfigurationsdateien
9. **Über byvalver** - Versions- und Hilfeinformation

### VISUELLER DATEIBROWSER:

- **Verzeichnisnavigation** mit Pfeiltasten oder vi-artigen j/k-Tasten
- **Datei/Verzeichnis-Unterscheidung** mit [FILE] und [DIR]-Indikatoren
- **Dateigrößenanzeige** in menschenlesbaren Formaten (B, KB, MB, GB)
- **Erweiterungsfilter** (z.B. *.bin)
- **Intelligente Pfadbehandlung** - Navigiert automatisch zum übergeordneten Verzeichnis, wenn ein Dateipfad angegeben wird
- **Sortierte Anzeige** - Zuerst Verzeichnisse, dann alphabetisch
- **Mehrere Auswahlmodi**:
  - Dateiauswahlmodus: Navigation in Verzeichnisse, Auswahl nur von Dateien
  - Verzeichnisauswahlmodus: Auswahl von Verzeichnissen für Stapelverarbeitung
  - Beide Modi: Auswahl von Dateien oder Verzeichnissen

### STAPELVERARBEITUNG MIT LIVE-AKTUALISIERUNGEN:

Der Stapelverarbeitungsbildschirm bietet **Echtzeit-Feedback**:

- **Fortschrittsbalken** zeigt verarbeitete Dateien an (z.B. `[==============        ] 52/100 Dateien`)
- **Konfigurationsanzeige** mit aktiven Einstellungen:
  - Bad Bytes-Anzahl und verwendetes Profil
  - Verarbeitungsoptionen (`Biphasic`, `PIC`, `XOR`, ML)
  - Ausgabeformat
- **Live-Dateistatistiken** mit farbcodiertem Status:
  - Abgeschlossen: X / Y (versuchte Dateien / Gesamt)
  - ✅ Erfolgreich (GRÜN) - keine verbleibenden Bad Bytes
  - ❌ Fehlgeschlagen (ROT) - Fehler oder verbleibende Bad Bytes
  - Erfolgsquote in Prozent
- **Aktuelle Dateianzeige** in fettgedrucktem Text
- **Nächste Dateivorschau** in gelb/gedimmtem Text
- **Dynamische Strategiestatistik-Tabelle** mit:
  - **Allen aktiven Strategien** (keine 10-Strategie-Grenze)
  - **Vollständigen Strategienamen** (bis zu 50 Zeichen, keine Kürzung)
  - Erfolgs-/Fehleranzahlen pro Strategie
  - Erfolgsquoten in Prozent
  - Farbcodiert nach Leistung (grün ≥80%, gelb 50-79%, rot <50%)
  - Echtzeitaktualisierung alle 50ms

### KONFIGURATIONSVERWALTUNG:

Konfigurationen laden und speichern im **INI-artigen Format**:```ini
[general]
verbose = 0
quiet = 0
show_stats = 1

[processing]
use_biphasic = 0
use_pic_generation = 0
encode_shellcode = 0
xor_key = 0xDEADBEEF

[output]
output_format = raw

[bad_bytes]
bad_bytes = 00

[ml]
use_ml_strategist = 0
metrics_enabled = 0

[batch]
file_pattern = *.bin
recursive = 0
preserve_structure = 1

Die Anwendung erkennt automatisch, ob ncurses verfügbar ist, und aktiviert entsprechend die TUI-Unterstützung.

### BUILD OPTIONS:

Die TUI-Unterstützung wird abhängig von der Verfügbarkeit von ncurses bedingt kompiliert:

- Standard-Build: `make` - Enthält TUI, wenn ncurses verfügbar ist
- TUI erzwingen: `make with-tui` - Baut mit TUI-Unterstützung (schlägt fehl, wenn ncurses nicht verfügbar)
- TUI ausschließen: `make no-tui` - Baut ohne TUI-Unterstützung für eine kleinere Binärdatei

### BEISPIEL-ARBEITSABLÄUFE:

**EINZELDATEI-VERARBEITUNG:**
1. TUI starten: `byvalver --menu`
2. Wählen Sie "1. Process Single File"
3. Durchsuchen Sie mit dem visuellen Dateibrowser nach der Eingabedatei
4. Durchsuchen Sie nach dem Speicherort der Ausgabedatei
5. Starten Sie die Verarbeitung und sehen Sie die Ergebnisse

**STAPELVERARBEITUNG:**
1. TUI starten: `byvalver --menu`
2. Wählen Sie "2. Batch Process Directory"
3. Durchsuchen Sie mit dem visuellen Dateibrowser nach dem Eingabeverzeichnis mit Shellcode-Dateien
4. Durchsuchen Sie nach dem Ausgabeverzeichnis
5. Konfigurieren Sie das Dateimuster (Standard: <file>.bin) und die rekursive Option
6. Starten Sie die Stapelverarbeitung und verfolgen Sie den Live-Fortschritt mit Strategiestatistiken

**KONFIGURATIONSVERWALTUNG:**
1. Konfigurieren Sie alle Optionen in der TUI (Bad Bytes, Ausgabeformat, ML, usw.)
2. Wählen Sie "8. Load/Save Configuration"
3. Speichern Sie die aktuelle Konfiguration in einer Datei (z. B. `my_config.conf`)
4. Später: Laden Sie die Konfigurationsdatei, um alle Einstellungen wiederherzustellen

### LEISTUNGSHINWEISE:

- **Einzeldatei-Verarbeitung**: Sofortiges visuelles Feedback, <1 Sekunde für typischen Shellcode
- **Stapelverarbeitung**: 50 ms Verzögerung zwischen den Dateien für visuelle Updates
- **Große Verzeichnisse (100+ Dateien)**: Das Scannen kann 1-2 Sekunden dauern
- **Strategieinitialisierung**: 2-5 Sekunden beim ersten Lauf (einmalige Kosten pro Sitzung)

### TERMINALKOMPATIBILITÄT:

Die TUI wurde getestet mit:
- GNOME Terminal
- Konsole
- xterm
- iTerm2 (macOS)
- Windows Terminal (WSL)
- tmux/screen (funktioniert, kann aber Farbeinschränkungen haben)

**Minimale empfohlene Terminalgröße**: 80x24 Zeichen (100x30 oder größer empfohlen für die vollständige Strategietabelle während der Stapelverarbeitung)

Die vollständige TUI-Dokumentation, Fehlerbehebung und erweiterte Nutzung finden Sie unter [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/TUI_README.md).

## GEZIELTE BAD-BYTE-VERBANNUNG

### ÜBERBLICK

Mit der Option `--bad-bytes` können Sie beliebige Bytes angeben, die aus Ihrem Shellcode verbannt werden sollen.

### IMPLEMENTIERUNGSDETAILS

`byvalver` funktioniert wie folgt:
1. Parsen der durch Kommas getrennten Hex-Byte-Liste (z. B. `"00,0a,0d"`)
2. Verwendung einer O(1)-Bitmap-Suche, um Bad Bytes in Anweisungen zu identifizieren
3. Anwenden der gleichen 153+ Transformationsstrategien, die auch für die Null-Byte-Eliminierung verwendet werden
4. Überprüfen, dass die Ausgabe keine angegebenen Bad Bytes enthält

### ERWARTETES VERHALTEN

- **Nur Null-Bytes** (`--bad-bytes "00"` oder Standard): Hohe Erfolgsrate (100% im Testkorpus)
- **Mehrere Bad Bytes** (`--bad-bytes "00,0a,0d"`): Erfolgsrate kann je nach folgenden Faktoren stark variieren:
  - Welche spezifischen Bytes als schlecht markiert sind
  - Komplexität des eingegebenen Shellcodes
  - Häufigkeit von Bad Bytes im ursprünglichen Shellcode
  - Ob effektive alternative Kodierungen für den spezifischen Satz von Bad Bytes existieren

### EMPFEHLUNGEN

1. **Für den Produktionseinsatz**: Bleiben Sie beim Standardmodus der Null-Byte-Verbannung
2. **Für Experimente**: Testen Sie die `--bad-bytes`-Funktion mit Ihrem spezifischen Anwendungsfall und validieren Sie die Ausgabe
3. **Immer verifizieren**: Verwenden Sie `verify_denulled.py --bad-bytes "XX,YY"`, um zu bestätigen, dass alle Bad Bytes eliminiert wurden
4. **Erwarten Sie Variabilität**: Manche Shellcodes können mit bestimmten Bad-Byte-Sätzen möglicherweise nicht vollständig bereinigt werden

### ZUKÜNFTIGE VERBESSERUNGEN

Die generische Bad-Byte-Funktion bietet eine Grundlage für:
- Strategieoptimierung für spezifische Bad-Byte-Muster
- Automatisierte Entdeckung neuer Strategien, die auf gängige Bad-Byte-Kombinationen abzielen
- ML-Modell-Neutraining mit diversen Bad-Byte-Trainingsdaten
- Erweiterte Tests und Validierung

> [!CAUTION]
> Die Verwendung von `--bad-bytes` mit mehreren Bad Bytes erhöht die Komplexität der Transformationsaufgabe erheblich. Manche Shellcodes können unmöglich zu transformieren sein, wenn zu viele Bytes als schlecht markiert sind, da dem Tool möglicherweise alternative Kodierungen ausgehen. Beginnen Sie mit kleinen Bad-Byte-Sätzen (z. B. `"00,0a"`) und erweitern Sie diese schrittweise, während Sie die Ausgabe testen. Überprüfen Sie das Ergebnis vor der Bereitstellung immer mit `verify_denulled.py`.

## BAD-BYTE-PROFILE

### ÜBERBLICK

Benutzer können auch **Bad-Byte-Profile** auswählen – vorkonfigurierte Byte-Sets für gängige Exploit-Szenarien. Anstatt Hex-Werte manuell anzugeben, verwenden Sie Profilnamen, die zu Ihrem Kontext passen.

### VERFÜGBARE PROFILE

| Profil | Schwierigkeit | Bad Bytes | Anwendungsfall |
|--------|---------------|-----------|----------------|
| `null-only` | ░░░░░ Trivial | 1 | Klassische Buffer Overflows (Standard) |
| `http-newline` | █░░░░ Niedrig | 3 | `HTTP`-Header, zeilenbasierte Protokolle |
| `http-whitespace` | █░░░░ Niedrig | 5 | `HTTP`-Parameter, Command Injection |
| `url-safe` | ███░░ Mittel | 23 | `URL`-Parameter, `GET`-Anfragen |
| `sql-injection` | ███░░ Mittel | 5 | `SQL`-Injection-Kontexte |
| `xml-html` | ███░░ Mittel | 6 | `XML`/`HTML`-Injection, `XSS` |
| `json-string` | ███░░ Mittel | 34 | `JSON`-API-Injection |
| `format-string` | ███░░ Mittel | 3 | Format-String-Schwachstellen |
| `buffer-overflow` | ███░░ Mittel | 5 | Stack/Heap-Overflows mit Filterung |
| `command-injection` | ███░░ Mittel | 20 | Shell-Command-Injection |
| `ldap-injection` | ███░░ Mittel | 5 | `LDAP`-Abfragen |
| `printable-only` | ████░ Hoch | 161 | Textbasierte Protokolle (nur druckbares ASCII) |
| `alphanumeric-only` | █████ Extre m | 194 | Nur alphanumerischer Shellcode (0-9, A-Z, a-z) |

### VERWENDUNG```bash
# List all available profiles
byvalver --list-profiles

# Use a specific profile
byvalver --profile http-newline input.bin output.bin

# Combine with other options
byvalver --profile sql-injection --biphasic --format c input.bin output.c

Für eine detaillierte Profildokumentation siehe [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md).


## FUNKTIONEN

### HOHE ERFOLGSRATE BEI DER NULL-BYTES-BESEITIGUNG
<div align="center">
  <strong>100% Null-Bytes-Beseitigung wurde auf einem vielfältigen Testkorpus erreicht, der übliche und komplexe Null-Quellen repräsentiert.</strong>
</div>

> Diese Erfolgsrate gilt speziell für die Beseitigung von Null-Bytes (`\x00`), die umfassend getestet und optimiert wurde.

### FORTSCHRITTLICHE TRANSFORMATIONS-ENGINE
170+ Strategieimplementierungen, die praktisch alle gängigen Null-Bytes-Quellen und allgemeine Bad-Byte-Muster abdecken (mehrere neue Strategiefamilien in v3.0, v3.6, v3.7, v3.8, v4.0 und v4.1 hinzugefügt):
- `CALL/POP` und stack-basiertes sofortiges Laden
- `PEB`-Durchlauf mit gehashter API-Auflösung
- Fortschrittliche hash-basierte API-Auflösung mit komplexen Algorithmen
- Mehrstufiger `PEB`-Durchlauf zum Laden mehrerer DLLs
- `SALC`, `XCHG` und flag-basiertes Nullsetzen
- `LEA` für arithmetische Substitution
- `Shift` und arithmetische Werterstellung
- Mehrfach-`PUSH`-String-Erstellung
- Stack-basierte Strukturerstellung für Windows-Strukturen
- Stack-basierte String-Erstellung mit fortgeschrittenen Mustern
- `SIB`- und Displacement-Umschreibung
- Bedingte Sprungverschiebungsbehandlung
- Register-Neuzuordnung und Verkettung
- Verbessertes `SALC`+`REP STOSB` für Pufferinitialisierung
- Fortschrittliche Stringoperationstransformationen
- Atomare Operationskodierungsketten
- `FPU`-stack-basierte sofortige Kodierung
- `XLAT`-tabellenbasierte Byte-Übersetzung
- `LAHF`/`SAHF`-Flag-Bewahrungsketten
- **NEU in v3.6**: `BCD`-arithmetische Verschleierung (`AAM`/`AAD`)
- **NEU in v3.6**: `ENTER`/`LEAVE`-Stack-Frame-Alternativen
- **NEU in v3.6**: `POPCNT`/`LZCNT`/`TZCNT`-Bit-Zählen für Konstanten
- **NEU in v3.6**: `SIMD` `XMM`-Register-Sofortladung
- **NEU in v3.6**: `JECXZ`/`JRCXZ`-Nulltest-Sprungtransformationen
- **NEU in v3.7**: Beseitigung von Bad-Bytes in bedingten Sprung-Opcodes (JE/JNE/JG/JL mit schlechten Opcodes)
- **NEU in v3.7**: Register-zu-Register-Transfer mit Bad-Byte-Opcodes (MOV/XCHG-Alternativen)
- **NEU in v3.7**: Beseitigung von Bad-Bytes im Stack-Frame-Zeiger (PUSH/POP EBP-Alternativen)
- **NEU in v3.7**: Beseitigung von Bad-Bytes in ModR/M- und SIB-Bytes (alternative Registerkombinationen)
- **NEU in v3.7**: Partielle Bad-Bytes bei mehrbyteigen Immediate-Werten (Rotationsoptimierung)
- **NEU in v3.7**: Bitweise Operation Immediate Bad-Byte (AND/OR/XOR/TEST mit Registern)
- **NEU in v3.7**: Ein-Byte-Opcode-Substitution (INC/DEC/PUSH/POP-Alternativen)
- **NEU in v3.7**: String-Instruktions-Präfix Bad-Byte (REP-Präfix in Schleife umwandeln)
- **NEU in v3.7**: Operandengrößen-Präfix Bad-Byte (16-Bit- zu 32-Bit-Umwandlung)
- **NEU in v3.7**: Segmentregister-Bad-Byte-Erkennung (FS/GS-Präfixerkennung)
- **NEU in v3.8**: Profilbewusstes SIB-Generierungssystem (beseitigt hartcodierte 0x20 SIB-Bytes)
- **NEU in v3.8**: Kritische Korrekturen für bedingte Sprungbehandlung und partielle Registeroptimierung
 - **NEU in v3.9**: Polymorphes NOP-Einfügen mit mehreren NOP-Äquivalenten
 - **NEU in v3.9**: Konstanten-Entfaltung zur Verschleierung von Immediate-Werten
 - **NEU in v3.9**: Register-Umbenennungs-Verschleierung mit XCHG-Mustern
 - **NEU in v3.9**: Stack-Spill-Verschleierung für arithmetische Operationen
 - **NEU in v3.9**: Befehlsneuanordnung mit NOP-Einfügung
 - **NEU in v3.9**: Selbstmodifikationsstrategie zur Laufzeit (grundlegende Implementierung)
 - **NEU in v3.9**: Überlappende Instruktionen generieren
  - **NEU in v4.0**: ARM/ARM64-architekturübergreifende Unterstützung mit Capstone-dynamischer Modusauswahl
  - **NEU in v4.0**: ARM-Immediate-Codierung mit MVN-Transformationen
  - **NEU in v4.0**: ARM MOV-Strategien (Original, MVN-basierte Null-Vermeidung)
  - **NEU in v4.0**: ARM-Arithmetik-Strategien (ADD mit SUB-Transformationen)
  - **NEU in v4.0**: ARM-Speicherstrategien (LDR/STR-Passthrough)
  - **NEU in v4.0**: ARM-Sprungstrategien (B/BL-Passthrough)
  - **NEU in v4.1**: SETcc-Flag-Akkumulationsketten (Beseitigung bedingter Sprünge)
  - **NEU in v4.1**: Polymorphe Immediate-Wert-Konstruktion (mehrere Codierungsvarianten)
  - **NEU in v4.1**: Optimierung der Registerabhängigkeitskette (Mehrfach-Instruktions-Muster)
  - **NEU in v4.1**: RIP-relativierte Adressoptimierung (x64 PIC-Verbesserungen)
  - **NEU in v4.1**: Negative Displacement-Speicheradressierung (Displacement-Alternativen)
  - **NEU in v4.1**: Mehr-Byte-NOP-Interlacing (Verschleierungs-NOP-Varianten)
  - **NEU in v4.1**: Bitmanipulations-Konstanten-Konstruktion (BSWAP, BSF, POPCNT, BMI2)
  - **NEU in v4.2**: x86/x64-Strategie-Kompatibilitätsschicht (ermöglicht 128+ x86-Strategien auf x64)
  - **NEU in v4.2**: MOVABS 64-Bit-Immediate-Strategien (REX.W MOV mit XOR/ADD-Konstruktion)
  - **NEU in v4.2**: SBB-Immediate-Null-Strategien (SBB AL/AX/EAX, 0-Transformation)
  - **NEU in v4.2**: TEST Große-Immediate-Strategien (TEST EAX/RAX, imm32 mit Register-Operanden)
  - **NEU in v4.2**: SSE-Speicheroperations-Strategien (MOVUPS/MOVAPS/MOVDQU/MOVDQA Null-Beseitigung)
  - **NEU in v4.2**: LEA x64-Displacement-Strategien (große Displacement-Handhabung mit REX-Präfixen)
  - **NEU in v4.2**: Erweiterte Register-Unterstützung (R8-R15 Register-Codierungs-Dienstprogramme)
 - Umfassende Unterstützung für `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH` und mehr

Die Engine verwendet eine mehrstufige Verarbeitung (Verschleierung → Entnullung) mit robusten Fallback-Mechanismen für Randfälle

**v3.8 KRITISCHE VERBESSERUNGEN**: Multi-Strategie-Korrektur für das http-whitespace-Profil
- **Problem**: Hartcodierte Bad-Bytes verursachten eine Ausfallrate von 79,1% (125/158 Dateien fehlgeschlagen)
- **Identifizierte Ursachen**:
  - 45+ Instanzen von hartcodierten SIB-Bytes 0x20 (LEERZEICHEN) in 15 Strategiedateien
  - Kernlogik bedingter Sprünge verwendet Bad-Byte-Skip-Offsets ohne Validierung
  - Partielle Registeroptimierung schreibt direkt Bad-Bytes
  - Zusätzliche hartcodierte Bad-Bytes in 5 Strategiedateien mit HOHER Priorität
- **Implementierte Lösungen**:
  - Zentrale profilbewusste SIB-Generierung mit 3-stufigem Fallback (STANDARD → DISP8 → PUSHPOP)
  - Dynamisches NOP-Padding für Skip-Offsets bedingter Sprünge, um Bad-Bytes zu vermeiden
  - Intelligente Byte-Konstruktion für partielle Registerwerte mittels Zerlegung
  - Systematischer Ersatz hartcodierter Bytes durch profilbewusste Alternativen
- **Auswirkung**: **79,1% Ausfall → 35,4% Ausfall** (Erfolgsrate: **20,9% → 64,6%**)
- **Behobene Dateien**: 102 Dateien werden nun erfolgreich verarbeitet (+69 Dateien, 3,09-fache Verbesserung)
- **Strategie-Erfolgsraten**:
  - Partielle Registeroptimierung: 25% → **100%** (12/12 Transformationen)
  - mov_mem_disp_enhanced: 0% → **98,5%** (1605/1629 Transformationen)
  - indirect_call_mem: 0% → **98,5%** (135/137 Transformationen)
  - indirect_jmp_mem: 0% → **98,5%** (134/136 Transformationen)
- **Leistung**: Null Overhead durch intelligentes Caching, <2% durchschnittlicher Größenzuwachs

### LEISTUNGSKENNZAHLEN

Reale Leistungsdaten aus der Verarbeitung von 184 verschiedenen Shellcode-Beispielen:```
📊 Batch Processing Statistics:

Success Rate:            184/184             █████████████████████████   100.00%
Files Processed:         184                 █████████████████████████   100.00%
Failed:                  0                   ░░░░░░░░░░░░░░░░░░░░░░░░░   00.00%
Skipped:                 0                   ░░░░░░░░░░░░░░░░░░░░░░░░░   00.00%

EINGABE:```
🏆 Top Performing Denullification Strategies:

Strategy                                  Attempts    Success%    Confidence
--------                                  --------    --------    ----------
ret_immediate                                  134    █████████████░░░░░░░░░░░░   50.00%
MOVZX/MOVSX Null-Byte banishment              162    █████████████░░░░░░░░░░░░   50.00%
transform_mov_reg_mem_self                     774    █████████████░░░░░░░░░░░░   50.00%
cmp_mem_reg_null                                96    ████████████░░░░░░░░░░░░░   46.88%
cmp_mem_reg                                    264    ████████████░░░░░░░░░░░░░   46.97%
lea_disp_null                                 3900    ███████████░░░░░░░░░░░░░░   45.38%
transform_add_mem_reg8                        2012    ███████████░░░░░░░░░░░░░░   43.49%
Push Optimized                                4214    ███████░░░░░░░░░░░░░░░░░░   29.31%
ModRM Byte Null Bypass                          82    ██████░░░░░░░░░░░░░░░░░░░   25.61%
conservative_arithmetic                       5172    █████░░░░░░░░░░░░░░░░░░░░   21.37%
arithmetic_addsub_enhanced                    1722    ████░░░░░░░░░░░░░░░░░░░░░   18.12%
PUSH Immediate Null-Byte banishment          3066    ████░░░░░░░░░░░░░░░░░░░░░   16.54%
SIB Addressing                                9560    ████░░░░░░░░░░░░░░░░░░░░░   16.03%
generic_mem_null_disp_enhanced               22130    ███░░░░░░░░░░░░░░░░░░░░░░   15.52%
SALC-based Zero Comparison                    1654    ███░░░░░░░░░░░░░░░░░░░░░░   12.88%

### VERSCHLEIERUNGSEBENE
`--biphasic` fügt vor der Entnullung eine Anti-Analyse-Verschleierung hinzu:
- Kontrollflussabflachung
- Dispatcher-Muster
- Register-Neuzuweisung
- Zustandsverschleierung
- Toter-Code-Einfügung
- NOP-Schlitten
- Befehlsersetzung
- Äquivalente Operationen
- Stack-Frame-Manipulation
- API-Auflösungsverbergung
- Zeichenkettenkodierung
- Konstantenkodierung
- Anti-Debugging
- VM-Erkennungstechniken

### ML-GESTÜTZTE STRATEGIEAUSWAHL

> **Reifegrad: Beta v2.0** — Trainiert auf Nullbyte-Eliminationsdatensätzen. Benötigt erneutes Training für allgemeine Bad-Byte-Anwendungsfälle.

**Architektur**:
- **One-Hot-Befehlsdarstellung** (51 Dimensionen) ersetzt skalare Befehls-IDs
- **Kontextfenster** mit gleitendem Puffer von 4 Befehlen (aktueller + 3 vorherige)
- **Feste Merkmalsextraktion** mit stabilem 84-dimensionalen Layout pro Befehl
- **Stabiles Strategienverzeichnis**, das eine konsistente NN-Ausgabezuordnung gewährleistet
- **Vollständige Backpropagation** durch alle Schichten (Eingabe→verdeckt→Ausgabe)
- **Korrekte Gradientenberechnung** für Softmax + Kreuzentropieverlust
- **Ausgabemaskierung** filtert ungültige Strategien vor Softmax
- **He/Xavier-Initialisierung** für korrekte Gewichtsinitialisierung
- 3-schichtiges Feedforward-Neuronales Netz (336→512→200)
- Adaptives Lernen aus Erfolgs-/Fehlerrückmeldungen
- Verfolgt Vorhersagen, Genauigkeit und Konfidenz
- Anmutiger Fallback auf deterministische Reihenfolge

> [!WARNING]
> Der ML-Modus ist experimentell und erfordert weiteres Training/Validierung mit der neuen Architektur.

### STAPELVERARBEITUNG
- Rekursive Verzeichnisdurchsuchung (`-r`)
- Benutzerdefinierte Dateimuster (`--pattern "*.bin"`)
- Strukturerhaltung oder Abflachung
- Fortsetzen-bei-Fehler oder strikte Modi
- Kompatibel mit allen Optionen (biphasic, PIC, `XOR`, usw.)
- **Verbesserte Ausgabe**:
  - Dateibezogene Größenänderungen mit Verhältnissen
  - Detaillierte Bad-Byte-Identifikation bei Fehlern
  - Erfolgs-/Fehlerprozentsätze in der Zusammenfassung
  - Liste fehlgeschlagener Dateien (erste 10 inline angezeigt)
  - Strenge Erfolgsdefinition: Dateien mit verbleibenden Bad Bytes als fehlgeschlagen markiert

**BEISPIEL FÜR DIE STAPELVERARBEITUNGSAUSGABE:**```
===== BATCH PROCESSING SUMMARY =====
Total files:       8
Successfully processed: 1 (12.5%)
Failed:            7 (87.5%)
Skipped:           0

Total input size:  650 bytes
Total output size: 764 bytes
Average size ratio: 1.18x

Bad bytes:    5 configured
Configured set:    0x00, 0x09, 0x0a, 0x0d, 0x20

FAILED FILES (7):
  - shellcode1.bin
  - shellcode2.bin
  ...

### VERIFICATION SUITE
Python-Werkzeuge für die Validierung:
- `verify_denulled.py`: Stellt sicher, dass keine schlechten Bytes vorhanden sind (unterstützt `--bad-bytes` für benutzerdefinierte Überprüfung)
- `verify_functionality.py`: Überprüft Ausführungsmuster
- `verify_semantic.py`: Validiert die Äquivalenz

## ARCHITEKTUR

`byvalver` verwendet ein modulares Strategie-Muster-Design:
- Pass 1: (Optional) Verschleierung zur Anti-Analyse
- Pass 2: Entnullung zur Entfernung von Nullbytes
- ML-Ebene zur Strategieoptimierung
- Batch-System für skalierbare Verarbeitung

<div align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/9982/8d3a1e20481460fedecaecda6f87bc21355fbbb1f1ef58d7fef4427eda36a381.png" alt="Strategiekategorien-Taxonomie" width="700">
</div>

## SYSTEMANFORDERUNGEN

- **Betriebssystem**: Linux (Ubuntu/Debian/Fedora), macOS (mit Homebrew), Windows (über WSL/MSYS2)
- **CPU**: x86/x64 mit modernen Instruktionen
- **RAM**: 1 GB frei
- **Festplatte**: 50 MB frei
- **Werkzeuge**: `C`-Compiler, Make, Git (empfohlen)

## ABHÄNGIGKEITEN

- **Kern**: GCC/Clang, GNU Make, `Capstone` (v4.0+), `NASM` (v2.13+), xxd
- **Optional**: Clang-Format, Cppcheck, Valgrind
- **ML-Training**: Mathematische Bibliotheken (enthalten)

### INSTALLATIONSBEFEHLE

**Ubuntu/Debian:**```bash
sudo apt update
sudo apt install build-essential nasm xxd pkg-config libcapstone-dev clang-format cppcheck valgrind

### macOS/Homebrew BUILD-FIXES (REPO-ÄNDERUNGEN)
Kürzlich wurden Änderungen vorgenommen, um die macOS/Homebrew-Kompatibilität zu verbessern (insbesondere auf Apple Silicon + Homebrew-Präfix `/opt/homebrew`):
- Aktualisiert `Makefile` und `makefile`, um **`CPPFLAGS` während der Kompilierung** und **`LDLIBS` während des Linkens zu verwenden**, sodass die von `pkg-config` gefundenen Capstone-Flags berücksichtigt werden.
- Normalisiert den von Homebrews `pkg-config` ausgegebenen Capstone-Include-Pfad von `.../include/capstone` zu `.../include`, sodass das `#include <capstone/capstone.h>` des Projekts korrekt aufgelöst wird.

Diff-Zusammenfassung (allgemein):
- `$(CC) $(CFLAGS) -c ...` → `$(CC) $(CFLAGS) $(CPPFLAGS) -c ...`
- `$(CC) $(CFLAGS) -o ... $(LDFLAGS)` → `$(CC) $(CFLAGS) $(CPPFLAGS) -o ... $(LDFLAGS) $(LDLIBS)`
- `CAPSTONE_CFLAGS := pkg-config --cflags capstone` → normalisiert auf einen Include-Pfad, der mit `<capstone/capstone.h>` kompatibel ist.

### FEHLERBEHEBUNG (macOS)```bash
# Verify xxd is available (macOS usually ships /usr/bin/xxd)
command -v xxd

# Verify Capstone is discoverable via pkg-config
pkg-config --cflags capstone
pkg-config --libs capstone

# Clean rebuild
make clean
make

- Input/output can be files or directories (auto-batch)

**SCHLÜSSELOPTIONEN:**
- `-h, --help`: Hilfe
- `-v, --version`: Version
- `-V, --verbose`: Ausführlich
- `-q, --quiet`: Leise
- `--bad-bytes BYTES`: Kommagetrennte Hex-Bytes zum Verbannen (Standard: "00")
- `--profile NAME`: Vordefiniertes Bad-Byte-Profil verwenden (z.B. http-newline, sql-injection)
- `--list-profiles`: Alle verfügbaren Bad-Byte-Profile auflisten
- `--biphasic`: Verschleiern + Entnullen
- `--pic`: Positionsunabhängig
- `--ml`: ML-Strategieauswahl
- `--xor-encode KEY`: `XOR` mit Stub
- `--format FORMAT`: raw|c|python|hexstring
- `-r, --recursive`: Rekursiver Batch
- `--pattern PATTERN`: Dateiglob
- `--no-preserve-structure`: Ausgabe glätten
- `--no-continue-on-error`: Bei Fehler anhalten
- `--menu`: Interaktives TUI-Menü starten

**BEISPIELE:**```bash
# Default: banish null bytes only (well-tested, recommended)
byvalver shellcode.bin clean.bin

# v3.0 NEW: List available bad-byte profiles
byvalver --list-profiles

# v3.0 NEW: Use predefined profile for HTTP contexts (eliminates 0x00, 0x0A, 0x0D)
byvalver --profile http-newline shellcode.bin clean.bin

# v3.0 NEW: Use profile for SQL injection contexts
byvalver --profile sql-injection shellcode.bin clean.bin

# v3.0 NEW: Use profile for URL-safe shellcode
byvalver --profile url-safe shellcode.bin clean.bin

# v3.0 NEW: Manual bad-byte specification (experimental - not extensively tested)
byvalver --bad-bytes "00,0a,0d" shellcode.bin clean.bin

# Combined with other features
byvalver --profile http-newline --biphasic --ml input.bin output.bin

# Batch processing with profile
byvalver -r --profile http-whitespace --pattern "*.bin" shellcodes/ output/

# Launch interactive TUI mode
byvalver --menu

**EMPFEHLUNG:** Der ML-Modus benötigt ein erneutes Training mit verschiedenen Bad-Byte-Datensätzen vor dem produktiven Einsatz. Derzeit nur für die Beseitigung von Null-Bytes optimiert.

## AGENTENMENAGERIE

`byvalver` wird mit einer **KI-gestützten Agenten-Pipeline** (`agents/`) ausgeliefert, die autonom Lücken im Strategieverzeichnis finden, eine neuartige Technik zur Beseitigung von Bad-Bytes vorschlagen, eine vollständige C-Implementierung generieren und diese in das Projekt einbinden kann – alles mit einem einzigen Befehl.

Die Pipeline basiert auf dem [AjintK](https://github.com/umpolungfish/byvalver/blob/main/AjintK) Multi-Provider-Agenten-Framework und unterstützt **Anthropic**, **DeepSeek**, **Qwen**, **Mistral** und **Google** als LLM-Backends.

### SCHNELLSTART```bash
# Requires API key for your chosen provider
export ANTHROPIC_API_KEY="..."   # or DEEPSEEK_API_KEY, QWEN_API_KEY, etc.

# --- Specialized Generators ---

# 1. General Technique Generator (discover → propose → generate → implement)
python3 run_technique_generator.py

# 2. Obfuscation Technique Generator (specifically for anti-analysis/evasion)
python3 run_obfuscation_generator.py

# 3. Bad-Byte Removal Generator (targeting restricted byte elimination)
python3 run_badbyte_generator.py

# 4. Profile-Specific Strategy Generator (targeting a specific bad-byte profile)
python3 run_profile_generator.py --profile alphanumeric-only

# --- Common Options ---

# Dry-run: discover and propose only, no files written
python3 run_technique_generator.py --dry-run

# Target a specific architecture
python3 run_technique_generator.py --arch x64

# Use a different provider / model
python3 run_technique_generator.py --provider deepseek --model deepseek-chat

Stufe	Agent	Beschreibung
1	`StrategyDiscoveryAgent`	Scannt `src/`, extrahiert alle 340+ Strategienamen und -kategorien, fordert das LLM auf, Abdeckungslücken zusammenzufassen
2	`TechniqueProposalAgent`	Schlägt auf Basis des Katalogs eine wirklich neuartige Technik mit Begründung, Zielanweisung und Ansatz vor
3	`CodeGenerationAgent`	Generiert eine vollständige `.h`- und `.c`-Implementierung, die mit `strategy_t` konform ist, unter Verwendung von `strategy.h`/`utils.h`/`mov_strategies.c` als Referenz
4	`ImplementationAgent`	Schreibt Dateien nach `src/`, patcht `strategy_registry.c` (include → forward decl → register call), führt `make` aus

### ANFORDERUNGEN```bash
# Install Python dependencies (uses AjintK framework)
pip install anthropic tenacity httpx pyyaml

# Or with uv (faster)
uv pip install -r AjintK/requirements.txt

Dokument	Beschreibung
docs/USAGE.md	Umfassende Anleitung zur Nutzung mit Beispielen
docs/BUILD.md	Bauanleitung und plattformspezifische Hinweise
docs/TUI_README.md	Interaktive TUI-Dokumentation
docs/DENULL_STRATS.md	Katalog der Denullifikationsstrategien
docs/OBFUSCATION_STRATS.md	Dokumentation der Verschleierungstechniken
docs/BAD_BYTE_PROFILES.md	Referenz der Bad-Byte-Profile
docs/BADBYTEELIM_STRATS.md	Erweiterte Eliminierungsstrategien
docs/STRATEGY_HIERARCHY.md	Organisation und Priorität der Strategien
docs/ADVANCED_STRATEGIES.md	Fortgeschrittene Transformationstechniken
docs/WHITEPAPER.md	Technisches Whitepaper
docs/AGENT_MENAGERIE.md	Agenten-Pipeline: automatische Technikgenerierung

byvalver

Beliebteste

byvalver (·𐑚𐑲𐑝𐑨𐑤𐑝𐑼)

Inhaltsverzeichnis

Übersicht

BAD-BYTE-VERTREIBUNG IN AKTION

SCHNELLSTART

INSTALLATION

Grundlegende Verwendung

banish null bytes and newlines

ÜBERPRÜFUNG

Check for remaining bad bytes

Verify functional equivalence

INTERAKTIVE TUI

KONFIGURATION DER VERBOTENEN BYTES:

NAVIGATION:

ANFORDERUNGEN:

Ubuntu/Debian

CentOS/RHEL/Fedora

macOS (with Homebrew)

PROFILBEISPIELE

AUSGABEOPTIONEN

STATISTIKEN

Bad bytes: 3 configured Configured set: 0x00, 0x0a, 0x0d

📊 DETAILED STATISTICS

Core build deps

xxd is typically already present at /usr/bin/xxd on macOS.

If it isn't available for some reason, install Vim (xxd is bundled with it):

ERSTELLEN

VERWENDUNG```bash

VERSCHLEIERUNGSSTRATEGIEN

KERN-VERSCHLEIERUNGSTECHNIKEN

DENULLIFIKATIONSSTRATEGIEN

MOV-STRATEGIEN

ARITHMETIK

SPRÜNGE/KONTROLLFLUSS

FORTGESCHRITTEN

MODERNE x64-FUNKTIONEN

VERSCHLEIERUNGSVERBESSERUNG

SPEICHERVERSCHIEBUNG

ML-TRAINING & VALIDIERUNG

TRAINING

TESTEN DES ML-MODUS```bash

Smoke test

Check registry initialization

Expected: "ML Registry] Initialized with XXX strategies"

Batch processing with learning

View metrics

PIPELINE-STUFEN

OPTIONS```

DEVELOPMENT

DOCUMENTATION

TROUBLESHOOTING

LICENSE

`MOV`-STRATEGIEN