**OPTION 2 : CONSTRUIRE À PARTIR DE LA SOURCE**```bash
git clone https://github.com/umpolungfish/byvalver.git
cd byvalver
make
sudo make install
sudo make install-man  # Install man page

**UTILISATION DE PROFILS BAD-BYTE:**```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

**FONCTIONNALITÉS AVANCÉES:**```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

### SUPPORT MULTI-ARCHITECTURE

`byvalver` prend en charge plusieurs architectures via le drapeau `--arch` :

**x86 (32-bit Intel/AMD)** - Entièrement pris en charge avec plus de 150 stratégies```bash
byvalver --arch x86 --bad-bytes "00" x86_shellcode.bin output.bin

**ARM (32-bit)** - Support expérimental avec des stratégies de base```bash
byvalver --arch arm --bad-bytes "00" arm_shellcode.bin output.bin

**Notes:**
- ARM/ARM64 support focuses on core instructions (MOV, arithmetic, loads/stores)
- Utilisez des profils de bad-byte plus simples pour ARM (par exemple, uniquement le null-byte)
- Des avertissements expérimentaux sont affichés lorsque ARM/ARM64 est sélectionné
- Une détection de base de non-concordance d'architecture avertit si le shellcode semble être d'une mauvaise architecture
- La détection automatique d'architecture est prévue pour les futures versions

### TRAITEMENT PAR LOTS

Traitez des répertoires entiers :```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/

### CARACTÉRISTIQUES PRINCIPALES :

La TUI propose 9x options de menu principal couvrant toutes les fonctionnalités CLI :

1. **Traiter un seul fichier** - Traite des fichiers shellcode individuels avec retour visuel
2. **Traiter un répertoire par lots** - Traite des répertoires entiers avec suivi en direct de la progression
3. **Configurer les options de traitement** - Activer/désactiver le mode biphasique, la génération PIC, le ML, le mode verbeux, l'essai à blanc
4. **Définir les bad bytes** - Saisie manuelle ou sélection parmi 13 profils prédéfinis
5. **Paramètres du format de sortie** - Choisir parmi 5 formats de sortie (raw, C, Python, PowerShell, hexstring)
6. **Configuration des métriques ML** - Configurer la sélection de stratégie ML et le suivi des métriques
7. **Options avancées** - Codage XOR, délais d'attente, limites, paramètres de validation
8. **Charger/Sauvegarder la configuration** - Gestion des fichiers de configuration de type INI
9. **À propos de byvalver** - Informations sur la version et l'aide

### NAVIGATEUR DE FICHIERS VISUEL :

- **Navigation dans les répertoires** avec les touches fléchées ou les touches j/k de style vi
- **Distinction fichier/répertoire** avec les indicateurs [FILE] et [DIR]
- **Affichage de la taille des fichiers** avec des formats lisibles (B, KB, MB, GB)
- **Filtrage par extension** (p. ex., *.bin)
- **Gestion intelligente des chemins** - Navigue automatiquement vers le répertoire parent si un chemin de fichier est fourni
- **Affichage trié** - Répertoires en premier, puis par ordre alphabétique
- **Modes de sélection multiples** :
  - Mode sélection de fichier : Naviguer dans les répertoires, sélectionner uniquement les fichiers
  - Mode sélection de répertoire : Sélectionner les répertoires pour le traitement par lots
  - Mode les deux : Sélectionner soit des fichiers, soit des répertoires

### TRAITEMENT PAR LOTS AVEC MISES À JOUR EN DIRECT :

L'écran de traitement par lots fournit **un retour en temps réel** :

- **Barre de progression** montrant les fichiers traités (p. ex., `[==============        ] 52/100 fichiers`)
- **Affichage de la configuration** montrant les paramètres actifs :
  - Nombre de bad bytes et profil utilisé
  - Options de traitement (`Biphasic`, `PIC`, `XOR`, ML)
  - Format de sortie
- **Statistiques en direct des fichiers** avec statut codé par couleur :
  - Terminé : X / Y (fichiers tentés / total)
  - ✅ Réussi (VERT) - aucun bad byte restant
  - ❌ Échoué (ROUGE) - erreurs ou bad bytes restants
  - Pourcentage de taux de réussite
- **Affichage du fichier en cours** en gras
- **Aperçu du fichier suivant** en texte jaune/atténué
- **Tableau dynamique des statistiques de stratégie** montrant :
  - **Toutes les stratégies actives** (pas de limite de 10 stratégies)
  - **Noms complets des stratégies** (jusqu'à 50 caractères, sans troncature)
  - Comptes de succès/échec par stratégie
  - Pourcentages de taux de réussite
  - Codé par couleur selon la performance (vert ≥80%, jaune 50-79%, rouge <50%)
  - Mises à jour en temps réel toutes les 50 ms

### GESTION DE LA CONFIGURATION :

Charger et sauvegarder les configurations au **format de type INI** :```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

L'application détectera automatiquement si ncurses est disponible et activera le support TUI en conséquence.

### OPTIONS DE CONSTRUCTION :

Le support TUI est compilé conditionnellement en fonction de la disponibilité de ncurses :

- Construction par défaut : `make` - Inclut TUI si ncurses est disponible
- Forcer la construction TUI : `make with-tui` - Construit avec le support TUI (échoue si ncurses n'est pas disponible)
- Exclure TUI : `make no-tui` - Construit sans support TUI pour un binaire plus petit

### EXEMPLES DE FLUX DE TRAVAIL :

**TRAITEMENT D'UN SEUL FICHIER :**
1. Lancer TUI : `byvalver --menu`
2. Sélectionner "1. Process Single File"
3. Parcourir pour le fichier d'entrée à l'aide du navigateur de fichiers visuel
4. Parcourir pour l'emplacement du fichier de sortie
5. Démarrer le traitement et visualiser les résultats

**TRAITEMENT PAR LOTS :**
1. Lancer TUI : `byvalver --menu`
2. Sélectionner "2. Batch Process Directory"
3. Parcourir pour le répertoire d'entrée contenant les fichiers de shellcode
4. Parcourir pour le répertoire de sortie
5. Configurer le motif de fichier (par défaut : <file>.bin) et l'option récursive
6. Démarrer le traitement par lots et regarder la progression en direct avec les statistiques de stratégies

**GESTION DE CONFIGURATION :**
1. Configurer toutes les options dans le TUI (octets interdits, format de sortie, ML, etc.)
2. Sélectionner "8. Load/Save Configuration"
3. Sauvegarder la configuration actuelle dans un fichier (par exemple, `my_config.conf`)
4. Plus tard : Charger le fichier de configuration pour restaurer tous les paramètres

### NOTES DE PERFORMANCE :

- **Traitement d'un seul fichier** : Retour visuel instantané, <1 seconde pour un shellcode typique
- **Traitement par lots** : Délai de 50 ms entre les fichiers pour les mises à jour visuelles
- **Grands répertoires (100+ fichiers)** : L'analyse peut prendre 1 à 2 secondes
- **Initialisation des stratégies** : 2 à 5 secondes lors de la première exécution (coût unique par session)

### COMPATIBILITÉ TERMINAL :

Le TUI a été testé avec :
- GNOME Terminal
- Konsole
- xterm
- iTerm2 (macOS)
- Windows Terminal (WSL)
- tmux/screen (fonctionne mais peut avoir des limitations de couleurs)

**Taille minimale recommandée du terminal** : 80x24 caractères (100x30 ou plus recommandé pour la table complète des stratégies lors du traitement par lots)

Pour la documentation complète du TUI, le dépannage et l'utilisation avancée, voir [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/HEAD/TUI_README.md).

## BANISSEMENT CIBLÉ DES OCTETS INTERDITS

### APERÇU

L'option `--bad-bytes` vous permet de spécifier n'importe quel ensemble d'octets à bannir de votre shellcode.

### DÉTAILS D'IMPLÉMENTATION

`byvalver` fonctionne en :
1. Analysant la liste d'octets hexadécimaux séparés par des virgules (par exemple, `"00,0a,0d"`)
2. Utilisant une recherche bitmap O(1) pour identifier les octets interdits dans les instructions
3. Appliquant les mêmes 153+ stratégies de transformation utilisées pour l'élimination des octets nuls
4. Vérifiant que la sortie ne contient pas les octets interdits spécifiés

### COMPORTEMENT ATTENDU

- **Octets nuls seulement** (`--bad-bytes "00"` ou par défaut) : Taux de succès élevé (100 % sur le corpus de test)
- **Plusieurs octets interdits** (`--bad-bytes "00,0a,0d"`) : Le taux de succès peut varier considérablement selon :
  - Quels octets spécifiques sont marqués comme interdits
  - La complexité du shellcode d'entrée
  - La fréquence des octets interdits dans le shellcode d'origine
  - Si des encodages alternatifs efficaces existent pour l'ensemble spécifique d'octets interdits

### RECOMMANDATIONS

1. **Pour une utilisation en production :** Restez avec le mode de bannissement des octets nuls par défaut
2. **Pour l'expérimentation :** Testez la fonctionnalité `--bad-bytes` avec votre cas d'utilisation spécifique et validez la sortie
3. **Vérifiez toujours :** Utilisez `verify_denulled.py --bad-bytes "XX,YY"` pour confirmer que tous les octets interdits ont été éliminés
4. **Attendez-vous à de la variabilité :** Certains shellcodes peuvent ne pas être entièrement nettoyables avec certains ensembles d'octets interdits

### AMÉLIORATIONS FUTURES

La fonctionnalité générique d'octets interdits fournit une base pour :
- Optimisation des stratégies pour des motifs spécifiques d'octets interdits
- Découverte automatisée de nouvelles stratégies ciblant les combinaisons courantes d'octets interdits
- Réentraînement du modèle ML avec des données d'entraînement diverses d'octets interdits
- Tests et validation étendus

> [!CAUTION]
> L'utilisation de `--bad-bytes` avec plusieurs octets interdits augmente considérablement la complexité de la tâche de transformation. Certains shellcodes peuvent devenir impossibles à transformer si trop d'octets sont marqués comme interdits, car l'outil peut manquer d'encodages alternatifs. Commencez par de petits ensembles d'octets interdits (par exemple, `"00,0a"`) et élargissez progressivement tout en testant la sortie. Vérifiez toujours le résultat avec `verify_denulled.py` avant le déploiement.

## PROFILS D'OCTETS INTERDITS

### APERÇU

Les utilisateurs peuvent également choisir **des profils d'octets interdits** - des ensembles d'octets préconfigurés pour des scénarios d'exploitation courants. Au lieu de spécifier manuellement des valeurs hexadécimales, utilisez des noms de profils qui correspondent à votre contexte.

### PROFILS DISPONIBLES

| Profile | Difficulty | Bad Bytes | Use Case |
|---------|-----------|----------|-----------|
| `null-only` | ░░░░░ Trivial | 1 | Débordements de tampon classiques (par défaut) |
| `http-newline` | █░░░░ Faible | 3 | En-têtes `HTTP`, protocoles basés sur les lignes |
| `http-whitespace` | █░░░░ Faible | 5 | Paramètres `HTTP`, injection de commandes |
| `url-safe` | ███░░ Moyen | 23 | Paramètres `URL`, requêtes `GET` |
| `sql-injection` | ███░░ Moyen | 5 | Contextes d'injection `SQL` |
| `xml-html` | ███░░ Moyen | 6 | Injection `XML`/`HTML`, `XSS` |
| `json-string` | ███░░ Moyen | 34 | Injection d'API `JSON` |
| `format-string` | ███░░ Moyen | 3 | Vulnérabilités de chaîne de format |
| `buffer-overflow` | ███░░ Moyen | 5 | Débordements de pile/tas avec filtrage |
| `command-injection` | ███░░ Moyen | 20 | Injection de commandes shell |
| `ldap-injection` | ███░░ Moyen | 5 | Requêtes `LDAP` |
| `printable-only` | ████░ Élevé | 161 | Protocoles textuels (ASCII imprimable uniquement) |
| `alphanumeric-only` | █████ Extrême | 194 | Shellcode uniquement alphanumérique (0-9, A-Z, a-z) |

### UTILISATION```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

**SQL Injection** (élimine NULL, guillemets, points-virgules):```bash
byvalver --profile sql-injection payload.bin sql_safe.bin

Pour une documentation détaillée des profils, voir [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/HEAD/docs/BAD_BYTE_PROFILES.md).


## FONCTIONNALITÉS

### TAUX DE SUCCÈS ÉLEVÉ DE LA SUPPRESSION DES NULL-BYTE
<div align="center">
  <strong>A atteint une suppression à 100% des null-byte sur un corpus de test diversifié représentant des sources nulles communes et complexes.</strong>
</div>

> Ce taux de succès s'applique spécifiquement à l'élimination des null-byte (`\x00`), qui a été largement testée et optimisée.

### MOTEUR DE TRANSFORMATION AVANCÉ
170+ implémentations de stratégies couvrant pratiquement toutes les sources de null-byte courantes et les motifs de bad-byte généraux (plusieurs nouvelles familles de stratégies ajoutées dans v3.0, v3.6, v3.7, v3.8, v4.0 et v4.1) :
- `CALL/POP` et chargement immédiat basé sur la pile
- Parcours du `PEB` avec résolution d'API par hachage
- Résolution d'API avancée basée sur le hachage avec algorithmes complexes
- Parcours multi-étapes du `PEB` pour le chargement de plusieurs DLL
- `SALC`, `XCHG` et mise à zéro basée sur les drapeaux
- `LEA` pour substitution arithmétique
- `Shift` et construction de valeur arithmétique
- Construction de chaîne multi-`PUSH`
- Construction de structure basée sur la pile pour les structures Windows
- Construction de chaîne basée sur la pile avec motifs avancés
- Réécriture `SIB` et de déplacement
- Gestion du déplacement des sauts conditionnels
- Remappage et chaînage de registres
- `SALC`+`REP STOSB` amélioré pour l'initialisation de tampon
- Transformations avancées d'opérations sur chaînes
- Chaînes de codage d'opérations atomiques
- Codage immédiat basé sur la pile FPU
- Traduction d'octets basée sur table `XLAT`
- Chaînes de conservation de drapeaux `LAHF`/`SAHF`
- **NOUVEAU dans v3.6** : Obfuscation arithmétique `BCD` (`AAM`/`AAD`)
- **NOUVEAU dans v3.6** : Alternatives de cadre de pile `ENTER`/`LEAVE`
- **NOUVEAU dans v3.6** : Comptage de bits `POPCNT`/`LZCNT`/`TZCNT` pour les constantes
- **NOUVEAU dans v3.6** : Chargement immédiat de registres `SIMD` `XMM`
- **NOUVEAU dans v3.6** : Transformations de saut de test zéro `JECXZ`/`JRCXZ`
- **NOUVEAU dans v3.7** : Élimination de bad-byte d'opcode de saut conditionnel (JE/JNE/JG/JL avec mauvais opcodes)
- **NOUVEAU dans v3.7** : Opcodes de transfert registre à registre de bad-byte (alternatives MOV/XCHG)
- **NOUVEAU dans v3.7** : Élimination de bad-byte de pointeur de cadre de pile (alternatives PUSH/POP EBP)
- **NOUVEAU dans v3.7** : Élimination de bad-byte d'octet ModR/M et SIB (combinaisons de registres alternatives)
- **NOUVEAU dans v3.7** : Bad-byte partiel immédiat multi-octet (optimisation de rotation)
- **NOUVEAU dans v3.7** : Bad-byte immédiat d'opération bit à bit (AND/OR/XOR/TEST avec registres)
- **NOUVEAU dans v3.7** : Substitution d'opcode d'un octet (alternatives INC/DEC/PUSH/POP)
- **NOUVEAU dans v3.7** : Bad-byte de préfixe d'instruction chaîne (conversion de préfixe REP en boucle)
- **NOUVEAU dans v3.7** : Bad-byte de préfixe de taille d'opérande (conversion 16-bit à 32-bit)
- **NOUVEAU dans v3.7** : Détection de bad-byte de registre de segment (détection de préfixe FS/GS)
- **NOUVEAU dans v3.8** : Système de génération SIB conscient des profils (élimine l'octet SIB codé en dur 0x20)
- **NOUVEAU dans v3.8** : Corrections critiques pour la gestion des sauts conditionnels et l'optimisation partielle des registres
 - **NOUVEAU dans v3.9** : Insertion de NOP polymorphe avec plusieurs équivalents NOP
 - **NOUVEAU dans v3.9** : Dépliage de constante pour l'obfuscation de valeur immédiate
 - **NOUVEAU dans v3.9** : Obfuscation de renommage de registre avec motifs XCHG
 - **NOUVEAU dans v3.9** : Obfuscation de débordement de pile pour les opérations arithmétiques
 - **NOUVEAU dans v3.9** : Réorganisation d'instructions avec insertion de NOP
 - **NOUVEAU dans v3.9** : Stratégie d'auto-modification à l'exécution (implémentation de base)
 - **NOUVEAU dans v3.9** : Génération d'instructions qui se chevauchent
  - **NOUVEAU dans v4.0** : Support multi-architecture ARM/ARM64 avec sélection de mode dynamique Capstone
  - **NOUVEAU dans v4.0** : Encodage immédiat ARM avec transformations MVN
  - **NOUVEAU dans v4.0** : Stratégies ARM MOV (originale, évitement de null basé sur MVN)
  - **NOUVEAU dans v4.0** : Stratégies arithmétiques ARM (ADD avec transformations SUB)
  - **NOUVEAU dans v4.0** : Stratégies mémoire ARM (passage à travers LDR/STR)
  - **NOUVEAU dans v4.0** : Stratégies de branchement ARM (passage à travers B/BL)
  - **NOUVEAU dans v4.1** : Chaînes d'accumulation de drapeaux SETcc (élimination de saut conditionnel)
  - **NOUVEAU dans v4.1** : Construction polymorphe de valeur immédiate (variantes d'encodage multiples)
  - **NOUVEAU dans v4.1** : Optimisation de chaîne de dépendance de registre (motifs multi-instructions)
  - **NOUVEAU dans v4.1** : Optimisation d'adressage relatif à RIP (améliorations PIC x64)
  - **NOUVEAU dans v4.1** : Adressage mémoire à déplacement négatif (alternatives de déplacement)
  - **NOUVEAU dans v4.1** : Entrelacement NOP multi-octet (variantes d'obfuscation NOP)
  - **NOUVEAU dans v4.1** : Construction de constante par manipulation de bits (BSWAP, BSF, POPCNT, BMI2)
  - **NOUVEAU dans v4.2** : Couche de compatibilité de stratégies x86/x64 (permet 128+ stratégies x86 sur x64)
  - **NOUVEAU dans v4.2** : Stratégies immédiates 64-bit MOVABS (MOV REX.W avec construction XOR/ADD)
  - **NOUVEAU dans v4.2** : Stratégies de zéro immédiat SBB (SBB AL/AX/EAX, transformation 0)
  - **NOUVEAU dans v4.2** : Stratégies de TEST immédiat large (TEST EAX/RAX, imm32 avec opérandes registre)
  - **NOUVEAU dans v4.2** : Stratégies d'opération mémoire SSE (élimination de null MOVUPS/MOVAPS/MOVDQU/MOVDQA)
  - **NOUVEAU dans v4.2** : Stratégies de déplacement LEA x64 (gestion de grand déplacement avec préfixes REX)
  - **NOUVEAU dans v4.2** : Support de registre étendu (utilitaires d'encodage de registre R8-R15)
 - Support complet pour `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH`, et plus encore

Le moteur utilise un traitement multi-passes (obfuscation → dénullification) avec des mécanismes de repli robustes pour les cas limites

**AMÉLIORATIONS CRITIQUES v3.8** : Correction multi-stratégie pour le profil http-whitespace
- **Problème** : Les bad-bytes codés en dur ont causé un taux d'échec de 79.1% (125/158 fichiers ont échoué)
- **Causes racines identifiées** :
  - 45+ instances d'octet SIB codé en dur 0x20 (SPACE) dans 15 fichiers de stratégie
  - Logique centrale de saut conditionnel utilisant des décalages de saut de bad-byte sans validation
  - Optimisation partielle de registre écrivant directement des bad-bytes
  - Bad-bytes codés en dur supplémentaires dans 5 fichiers de stratégie de priorité ÉLEVÉE
- **Solutions mises en œuvre** :
  - Génération SIB centralisée consciente des profils avec repli à 3 niveaux (STANDARD → DISP8 → PUSHPOP)
  - Remplissage NOP dynamique pour les décalages de saut conditionnel afin d'éviter les bad-bytes
  - Construction intelligente d'octets pour les valeurs de registre partielles par décomposition
  - Remplacement systématique des octets codés en dur par des alternatives conscientes des profils
- **Impact** : **79.1% échec → 35.4% échec** (taux de succès : **20.9% → 64.6%**)
- **Fichiers corrigés** : 102 fichiers traitent maintenant avec succès (+69 fichiers, amélioration de 3.09x)
- **Taux de succès des stratégies** :
  - Optimisation partielle de registre : 25% → **100%** (12/12 transformations)
  - mov_mem_disp_enhanced : 0% → **98.5%** (1605/1629 transformations)
  - indirect_call_mem : 0% → **98.5%** (135/137 transformations)
  - indirect_jmp_mem : 0% → **98.5%** (134/136 transformations)
- **Performances** : Aucun surcoût grâce à un mise en cache intelligente, augmentation de taille moyenne <2%

### MÉTRIQUES DE PERFORMANCE

Données de performance réelles issues du traitement de 184 échantillons de shellcode divers :```
📊 Batch Processing Statistics:

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

[No input content provided to translate.]```
🏆 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%

sudo apt update
sudo apt install python3 python3-pip git curl wget -y

sudo dnf update
sudo dnf install python3 python3-pip git curl wget -y

sudo pacman -Syu
sudo pacman -S python python-pip git curl wget

### COUCHE D'OBFUSCATION
Le mode `--biphasic` ajoute une obfuscation anti-analyse avant le dénullement :
- Aplatissement du flux de contrôle
- Motifs de répartition
- Réaffectation des registres
- Obscurcissement d'état
- Insertion de code mort
- Traînées de NOP
- Substitution d'instructions
- Opérations équivalentes
- Manipulation de la pile d'appels
- Masquage de la résolution d'API
- Encodage de chaînes
- Encodage de constantes
- Anti-débogage
- Techniques de détection de VM

### SÉLECTION DE STRATÉGIE ALIMENTÉE PAR ML

> **Maturité : Beta v2.0** — Entraîné sur des jeux de données d'élimination d'octets nuls. Nécessite un réentraînement pour les cas d'utilisation génériques de mauvais octets.

**Architecture** :
- **Encodage one-hot des instructions** (51 dimensions) remplace les identifiants scalaires d'instructions
- **Fenêtre de contexte** avec tampon glissant de 4 instructions (actuelle + 3 précédentes)
- **Extraction de caractéristiques fixe** avec une disposition stable à 84 dimensions par instruction
- **Registre de stratégies stable** garantissant un mappage de sortie du NN cohérent
- **Rétropropagation complète** à travers toutes les couches (entrée→cachée→sortie)
- **Calcul correct des gradients** pour la perte softmax + cross-entropie
- **Masquage de sortie** filtre les stratégies invalides avant softmax
- **Initialisation He/Xavier** pour une initialisation correcte des poids
- Réseau de neurones feedforward à 3 couches (336→512→200)
- Apprentissage adaptatif à partir des retours succès/échec
- Suit les prédictions, la précision et la confiance
- Retour gracieux à un ordre déterministe

> [!WARNING]
> Le mode ML est expérimental et nécessite une formation/validation supplémentaire avec la nouvelle architecture.

### TRAITEMENT PAR LOTS
- Parcours récursif de répertoires (`-r`)
- Motifs de fichiers personnalisés (`--pattern "*.bin"`)
- Préservation ou aplatissement de la structure
- Modes continuer-sur-erreur ou strict
- Compatible avec toutes les options (biphasic, PIC, `XOR`, etc.)
- **Sortie améliorée** :
  - Transformations de taille par fichier avec ratios
  - Identification détaillée des mauvais octets en cas d'échec
  - Pourcentages de succès/échec dans le résumé
  - Liste des fichiers en échec (les 10 premiers affichés en ligne)
  - Définition stricte du succès : les fichiers avec des mauvais octets restants sont marqués comme échoués

**EXEMPLE DE SORTIE DU TRAITEMENT PAR LOTS :**```
===== 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
  ...

### SUITE DE VÉRIFICATION
Outils Python pour la validation :
- `verify_denulled.py` : garantit zéro octet indésirable (prend en charge `--bad-bytes` pour une vérification personnalisée)
- `verify_functionality.py` : vérifie les motifs d'exécution
- `verify_semantic.py` : valide l'équivalence

## ARCHITECTURE

`byvalver` utilise une conception modulaire basée sur le modèle de stratégie :
- Passe 1 : (Optionnel) Obfuscation pour anti-analyse
- Passe 2 : Dénullification pour la suppression des octets nuls
- Couche ML pour l'optimisation des stratégies
- Système par lots pour un traitement évolutif

<div align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/9982/8d3a1e20481460fedecaecda6f87bc21355fbbb1f1ef58d7fef4427eda36a381.png" alt="Taxonomie des catégories de stratégies" width="700">
</div>

## EXIGENCES SYSTÈME

- **OS** : Linux (Ubuntu/Debian/Fedora), macOS (avec Homebrew), Windows (via WSL/MSYS2)
- **CPU** : x86/x64 avec instructions modernes
- **RAM** : 1 Go libre
- **Disque** : 50 Mo libre
- **Outils** : compilateur `C`, Make, Git (recommandé)

## DÉPENDANCES

- **Cœur** : GCC/Clang, GNU Make, `Capstone` (v4.0+), `NASM` (v2.13+), xxd
- **Optionnel** : Clang-Format, Cppcheck, Valgrind
- **Entraînement ML** : Bibliothèques mathématiques (incluses)

### COMMANDES D'INSTALLATION

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

### CORRECTIFS DE CONSTRUCTION macOS/Homebrew (CHANGEMENTS DU DÉPÔT)
Des modifications récentes ont été apportées pour améliorer la compatibilité macOS/Homebrew (notamment sur Apple Silicon + le préfixe Homebrew `/opt/homebrew`) :
- Mise à jour du `Makefile` et du `makefile` pour **utiliser `CPPFLAGS` lors de la compilation** et **`LDLIBS` lors de l'édition de liens**, afin que les indicateurs Capstone découverts par `pkg-config` soient respectés.
- Normalisation du chemin d'inclusion de Capstone émis par `pkg-config` de Homebrew, passant de `.../include/capstone` à `.../include` pour que le `#include <capstone/capstone.h>` du projet soit résolu correctement.

Résumé des différences (haut niveau) :
- `$(CC) $(CFLAGS) -c ...` → `$(CC) $(CFLAGS) $(CPPFLAGS) -c ...`
- `$(CC) $(CFLAGS) -o ... $(LDFLAGS)` → `$(CC) $(CFLAGS) $(CPPFLAGS) -o ... $(LDFLAGS) $(LDLIBS)`
- `CAPSTONE_CFLAGS := pkg-config --cflags capstone` → normalized to an include path compatible with `<capstone/capstone.h>`

### DÉPANNAGE (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

View config: `make info`

## INSTALLATION

Installation globale :```bash
sudo make install
sudo make install-man

Depuis GitHub :```bash
curl -sSL https://raw.githubusercontent.com/umpolungfish/byvalver/main/install.sh | bash

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

**KEY OPTIONS:**
- `-h, --help`: Aide
- `-v, --version`: Version
- `-V, --verbose`: Verbeux
- `-q, --quiet`: Silencieux
- `--bad-bytes BYTES`: Octets hexadécimaux séparés par des virgules à bannir (par défaut : "00")
- `--profile NAME`: Utiliser un profil d'octets interdits prédéfini (ex. : http-newline, sql-injection)
- `--list-profiles`: Lister tous les profils d'octets interdits disponibles
- `--biphasic`: Obscurcir + denull
- `--pic`: Indépendant de la position
- `--ml`: Sélection de stratégie ML
- `--xor-encode KEY`: `XOR` avec stub
- `--format FORMAT`: raw|c|python|hexstring
- `-r, --recursive`: Traitement par lots récursif
- `--pattern PATTERN`: Glob de fichiers
- `--no-preserve-structure`: Aplatir la sortie
- `--no-continue-on-error`: S'arrêter en cas d'erreur
- `--menu`: Lancer le menu TUI interactif

**EXAMPLES:**```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

**RECOMMANDATION :** Le mode ML nécessite un réentraînement avec des ensembles de données de bad-byte diversifiés avant l'utilisation en production. Actuellement optimisé uniquement pour le bannissement des null-byte.

## MÉNAGERIE D'AGENTS

`byvalver` est livré avec un **pipeline d'agents alimenté par l'IA** (`agents/`) qui peut découvrir de manière autonome les lacunes dans le registre de stratégies, proposer une nouvelle technique d'élimination des bad-byte, générer une implémentation C complète et l'intégrer dans le projet — le tout en une seule commande.

Le pipeline est construit sur le framework d'agents multi-fournisseurs [AjintK](https://github.com/umpolungfish/byvalver/blob/HEAD/AjintK/) et prend en charge **Anthropic**, **DeepSeek**, **Qwen**, **Mistral** et **Google** comme backends LLM.

### DÉMARRAGE RAPIDE```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

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

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