**OPCIÓN 2: COMPILAR DESDE EL CÓDIGO FUENTE**```bash
git clone https://github.com/umpolungfish/byvalver.git
cd byvalver
make
sudo make install
sudo make install-man  # Install man page

**USANDO PERFILES DE BAD-BYTES:**```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

**CARACTERÍSTICAS AVANZADAS:**```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

### SOPORTE MULTIARQUITECTURA

`byvalver` soporta múltiples arquitecturas mediante la opción `--arch`:

**x86 (Intel/AMD de 32 bits)** - Totalmente compatible con más de 150 estrategias```bash
byvalver --arch x86 --bad-bytes "00" x86_shellcode.bin output.bin

**ARM (32 bits)** - Soporte experimental con estrategias básicas```bash
byvalver --arch arm --bad-bytes "00" arm_shellcode.bin output.bin

**Notas:**
- El soporte para ARM/ARM64 se centra en instrucciones básicas (MOV, aritméticas, cargas/almacenamientos)
- Usa perfiles de bad-byte más simples para ARM (p. ej., solo byte nulo)
- Se muestran advertencias experimentales cuando se selecciona ARM/ARM64
- La detección básica de desajuste de arquitectura advierte si el shellcode parece ser de arquitectura incorrecta
- La detección automática de arquitectura está planificada para futuras versiones

### PROCESAMIENTO POR LOTES

Procesa directorios completos:```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/

### CARACTERÍSTICAS PRINCIPALES:

El TUI proporciona 9x opciones de menú principal que cubren toda la funcionalidad CLI:

1. **Procesar archivo único** - Procesar archivos de shellcode individuales con retroalimentación visual
2. **Procesar directorio por lotes** - Procesar directorios completos con seguimiento de progreso en vivo
3. **Configurar opciones de procesamiento** - Alternar modo bifásico, generación PIC, ML, verbose, dry-run
4. **Establecer bad bytes** - Entrada manual o selección entre 13 perfiles predefinidos
5. **Ajustes de formato de salida** - Elegir entre 5 formatos de salida (raw, C, Python, PowerShell, hexstring)
6. **Configuración de métricas ML** - Configurar la selección de estrategia ML y el seguimiento de métricas
7. **Opciones avanzadas** - Codificación XOR, timeouts, límites, ajustes de validación
8. **Cargar/Guardar configuración** - Gestión de archivos de configuración estilo INI
9. **Acerca de byvalver** - Información de versión y ayuda

### EXPLORADOR DE ARCHIVOS VISUAL:

- **Navegación de directorios** con teclas de flecha o teclas estilo vi j/k
- **Distinción archivo/directorio** con indicadores [FILE] y [DIR]
- **Visualización del tamaño de archivo** con formatos legibles (B, KB, MB, GB)
- **Filtrado por extensión** (p. ej., *.bin)
- **Manejo inteligente de rutas** - Navega automáticamente al directorio padre si se proporciona una ruta de archivo
- **Visualización ordenada** - Directorios primero, luego alfabético
- **Múltiples modos de selección**:
  - Modo de selección de archivos: Navegar en directorios, seleccionar solo archivos
  - Modo de selección de directorios: Seleccionar directorios para procesamiento por lotes
  - Modo ambos: Seleccionar archivos o directorios

### PROCESAMIENTO POR LOTES CON ACTUALIZACIONES EN VIVO:

La pantalla de procesamiento por lotes proporciona **retroalimentación en tiempo real**:

- **Barra de progreso** que muestra archivos procesados (p. ej., `[==============        ] 52/100 files`)
- **Visualización de configuración** que muestra los ajustes activos:
  - Cantidad de bad bytes y perfil utilizado
  - Opciones de procesamiento (`Biphasic`, `PIC`, `XOR`, ML)
  - Formato de salida
- **Estadísticas de archivos en vivo** con estado codificado por colores:
  - Completados: X / Y (archivos intentados / total)
  - ✅ Exitoso (VERDE) - cero bad bytes restantes
  - ❌ Fallido (ROJO) - errores o bad bytes restantes
  - Porcentaje de tasa de éxito
- **Visualización del archivo actual** en texto en negrita
- **Vista previa del siguiente archivo** en texto amarillo/atenuado
- **Tabla dinámica de estadísticas de estrategia** que muestra:
  - **Todas las estrategias activas** (sin límite de 10 estrategias)
  - **Nombres completos de estrategia** (hasta 50 caracteres, sin truncamiento)
  - Conteos de éxito/fallo por estrategia
  - Porcentajes de tasa de éxito
  - Codificado por colores según rendimiento (verde ≥80%, amarillo 50-79%, rojo <50%)
  - Actualizaciones en tiempo real cada 50 ms

### GESTIÓN DE CONFIGURACIÓN:

Cargar y guardar configuraciones en **formato estilo 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

La aplicación detectará automáticamente si ncurses está disponible y habilitará el soporte TUI en consecuencia.

### OPCIONES DE COMPILACIÓN:

El soporte TUI se compila condicionalmente según la disponibilidad de ncurses:

- Compilación predeterminada: `make` - Incluye TUI si ncurses está disponible
- Forzar compilación TUI: `make with-tui` - Compila con soporte TUI (falla si ncurses no está disponible)
- Excluir TUI: `make no-tui` - Compila sin soporte TUI para un binario más pequeño

### EJEMPLOS DE FLUJOS DE TRABAJO:

**PROCESAMIENTO DE UN SOLO ARCHIVO:**
1. Iniciar TUI: `byvalver --menu`
2. Seleccionar "1. Process Single File"
3. Navegar hasta el archivo de entrada usando el navegador de archivos visual
4. Navegar hasta la ubicación del archivo de salida
5. Iniciar el procesamiento y ver los resultados

**PROCESAMIENTO POR LOTES:**
1. Iniciar TUI: `byvalver --menu`
2. Seleccionar "2. Batch Process Directory"
3. Navegar hasta el directorio de entrada que contiene los archivos de shellcode
4. Navegar hasta el directorio de salida
5. Configurar el patrón de archivo (predeterminado: <file>.bin) y la opción recursiva
6. Iniciar el procesamiento por lotes y observar el progreso en vivo con estadísticas de estrategias

**GESTIÓN DE CONFIGURACIÓN:**
1. Configurar todas las opciones en la TUI (bad bytes, formato de salida, ML, etc.)
2. Seleccionar "8. Load/Save Configuration"
3. Guardar la configuración actual en un archivo (p. ej., `my_config.conf`)
4. Después: Cargar el archivo de configuración para restaurar todos los ajustes

### NOTAS DE RENDIMIENTO:

- **Procesamiento de un solo archivo**: Retroalimentación visual instantánea, <1 segundo para shellcode típico
- **Procesamiento por lotes**: 50ms de retraso entre archivos para actualizaciones visuales
- **Directorios grandes (100+ archivos)**: El escaneo puede tardar 1-2 segundos
- **Inicialización de estrategias**: 2-5 segundos en la primera ejecución (costo único por sesión)

### COMPATIBILIDAD DE TERMINAL:

La TUI ha sido probada con:
- GNOME Terminal
- Konsole
- xterm
- iTerm2 (macOS)
- Windows Terminal (WSL)
- tmux/screen (funciona pero puede tener limitaciones de color)

**Tamaño mínimo de terminal recomendado**: 80x24 caracteres (100x30 o mayor recomendado para la tabla completa de estrategias durante el procesamiento por lotes)

Para documentación completa de la TUI, solución de problemas y uso avanzado, consulta [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/TUI_README.md).

## DESTIERRO DIRIGIDO DE BAD BYTES

### DESCRIPCIÓN GENERAL

La opción `--bad-bytes` te permite especificar cualquier conjunto de bytes a eliminar de tu shellcode.

### DETALLES DE IMPLEMENTACIÓN

`byvalver` funciona de la siguiente manera:
1. Analizando la lista de bytes hexadecimales separados por comas (p. ej., `"00,0a,0d"`)
2. Usando una búsqueda de mapa de bits O(1) para identificar bytes malos en las instrucciones
3. Aplicando las mismas 153+ estrategias de transformación utilizadas para la eliminación de bytes nulos
4. Verificando que la salida no contenga los bytes malos especificados

### COMPORTAMIENTO ESPERADO

- **Solo bytes nulos** (`--bad-bytes "00"` o predeterminado): Alta tasa de éxito (100% en el corpus de pruebas)
- **Múltiples bytes malos** (`--bad-bytes "00,0a,0d"`): La tasa de éxito puede variar significativamente según:
  - Qué bytes específicos están marcados como malos
  - La complejidad del shellcode de entrada
  - La frecuencia de bytes malos en el shellcode original
  - Si existen codificaciones alternativas efectivas para el conjunto específico de bytes malos

### RECOMENDACIONES

1. **Para uso en producción:** Mantente con el modo de eliminación de bytes nulos predeterminado
2. **Para experimentación:** Prueba la funcionalidad `--bad-bytes` con tu caso de uso específico y valida la salida
3. **Verifica siempre:** Usa `verify_denulled.py --bad-bytes "XX,YY"` para confirmar que todos los bytes malos fueron eliminados
4. **Espera variabilidad:** Algunos shellcode pueden no ser completamente limpiables con ciertos conjuntos de bytes malos

### MEJORAS FUTURAS

La funcionalidad genérica de bytes malos proporciona una base para:
- Optimización de estrategias para patrones específicos de bytes malos
- Descubrimiento automatizado de nuevas estrategias dirigidas a combinaciones comunes de bytes malos
- Reentrenamiento del modelo ML con datos de entrenamiento diversos de bytes malos
- Pruebas y validación extendidas

> [!CAUTION]
> El uso de `--bad-bytes` con múltiples bytes malos aumenta significativamente la complejidad de la tarea de transformación. Algunos shellcode pueden volverse imposibles de transformar si demasiados bytes están marcados como malos, ya que la herramienta puede quedarse sin codificaciones alternativas. Comienza con conjuntos pequeños de bytes malos (p. ej., `"00,0a"`) y expande gradualmente mientras pruebas la salida. Verifica siempre el resultado con `verify_denulled.py` antes del despliegue.

## PERFILES DE BYTES MALOS

### DESCRIPCIÓN GENERAL

Los usuarios también pueden elegir **perfiles de bytes malos** - conjuntos de bytes preconfigurados para escenarios de explotación comunes. En lugar de especificar manualmente valores hexadecimales, usa nombres de perfil que coincidan con tu contexto.

### PERFILES DISPONIBLES

| Perfil | Dificultad | Bytes Malos | Caso de Uso |
|---------|-----------|-----------|----------|
| `null-only` | ░░░░░ Trivial | 1 | Desbordamientos de búfer clásicos (predeterminado) |
| `http-newline` | █░░░░ Baja | 3 | Cabeceras `HTTP`, protocolos basados en líneas |
| `http-whitespace` | █░░░░ Baja | 5 | Parámetros `HTTP`, inyección de comandos |
| `url-safe` | ███░░ Media | 23 | Parámetros `URL`, solicitudes `GET` |
| `sql-injection` | ███░░ Media | 5 | Contextos de inyección `SQL` |
| `xml-html` | ███░░ Media | 6 | Inyección `XML`/`HTML`, `XSS` |
| `json-string` | ███░░ Media | 34 | Inyección de API `JSON` |
| `format-string` | ███░░ Media | 3 | Vulnerabilidades de cadena de formato |
| `buffer-overflow` | ███░░ Media | 5 | Desbordamientos de pila/montón con filtrado |
| `command-injection` | ███░░ Media | 20 | Inyección de comandos de shell |
| `ldap-injection` | ███░░ Media | 5 | Consultas `LDAP` |
| `printable-only` | ████░ Alta | 161 | Protocolos basados en texto (solo ASCII imprimible) |
| `alphanumeric-only` | █████ Extrema | 194 | Shellcode solo alfanumérico (0-9, A-Z, a-z) |

### USO```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** (elimina NULL, comillas, puntos y comas):```bash
byvalver --profile sql-injection payload.bin sql_safe.bin

Para documentación detallada de perfiles, consulte [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md).


## CARACTERÍSTICAS

### ALTA TASA DE ÉXITO EN LA ELIMINACIÓN DE BYTES NULOS
<div align="center">
  <strong>Se logró una eliminación de bytes nulos del 100% en un corpus de pruebas diverso que representa fuentes de nulos comunes y complejas.</strong>
</div>

> Esta tasa de éxito se aplica específicamente a la eliminación de bytes nulos (`\x00`), que ha sido ampliamente probada y optimizada.

### MOTOR DE TRANSFORMACIÓN AVANZADO
Más de 170 implementaciones de estrategias que cubren prácticamente todas las fuentes comunes de bytes nulos y patrones generales de bytes problemáticos (se añadieron múltiples familias de estrategias nuevas en v3.0, v3.6, v3.7, v3.8, v4.0 y v4.1):
- `CALL/POP` y carga inmediata basada en pila
- Recorrido de `PEB` con resolución de API mediante hash
- Resolución avanzada de API basada en hash con algoritmos complejos
- Recorrido de `PEB` en varias etapas para la carga de múltiples DLL
- `SALC`, `XCHG` y puesta a cero basada en flags
- `LEA` para sustitución aritmética
- Construcción de valores mediante desplazamientos y aritmética
- Construcción de cadenas con múltiples `PUSH`
- Construcción de estructuras de Windows basada en pila
- Construcción de cadenas basada en pila con patrones avanzados
- Reescritura de `SIB` y desplazamientos
- Manejo de desplazamientos en saltos condicionales
- Reasignación y encadenamiento de registros
- `SALC`+`REP STOSB` mejorados para inicialización de buffers
- Transformaciones avanzadas de operaciones con cadenas
- Cadenas de codificación de operaciones atómicas
- Codificación inmediata basada en pila `FPU`
- Traducción de bytes basada en tabla `XLAT`
- Cadenas de preservación de flags `LAHF`/`SAHF`
- **NUEVO en v3.6**: Ofuscación aritmética `BCD` (`AAM`/`AAD`)
- **NUEVO en v3.6**: Alternativas de marco de pila `ENTER`/`LEAVE`
- **NUEVO en v3.6**: Conteo de bits `POPCNT`/`LZCNT`/`TZCNT` para constantes
- **NUEVO en v3.6**: Carga inmediata en registros `XMM` `SIMD`
- **NUEVO en v3.6**: Transformaciones de saltos de prueba de cero `JECXZ`/`JRCXZ`
- **NUEVO en v3.7**: Eliminación de bytes problemáticos en opcodes de saltos condicionales (JE/JNE/JG/JL con opcodes problemáticos)
- **NUEVO en v3.7**: Opcodes de transferencia registro a registro con bytes problemáticos (alternativas MOV/XCHG)
- **NUEVO en v3.7**: Eliminación de bytes problemáticos en punteros de marco de pila (alternativas PUSH/POP EBP)
- **NUEVO en v3.7**: Eliminación de bytes problemáticos en bytes ModR/M y SIB (combinaciones alternativas de registros)
- **NUEVO en v3.7**: Byte problemático parcial en inmediatos multi-byte (optimización por rotación)
- **NUEVO en v3.7**: Byte problemático en inmediatos de operaciones bit a bit (AND/OR/XOR/TEST con registros)
- **NUEVO en v3.7**: Sustitución de opcodes de un byte (alternativas INC/DEC/PUSH/POP)
- **NUEVO en v3.7**: Byte problemático en prefijos de instrucciones de cadenas (conversión de prefijo REP a bucle)
- **NUEVO en v3.7**: Byte problemático en prefijo de tamaño de operando (conversión de 16 bits a 32 bits)
- **NUEVO en v3.7**: Detección de bytes problemáticos en registros de segmento (detección de prefijos FS/GS)
- **NUEVO en v3.8**: Sistema de generación SIB consciente del perfil (elimina el byte SIB 0x20 hardcodeado)
- **NUEVO en v3.8**: Correcciones críticas para el manejo de saltos condicionales y la optimización parcial de registros
 - **NUEVO en v3.9**: Inserción de NOP polimórficos con múltiples equivalentes NOP
 - **NUEVO en v3.9**: Despliegue de constantes para ofuscar valores inmediatos
 - **NUEVO en v3.9**: Ofuscación por renombrado de registros con patrones XCHG
 - **NUEVO en v3.9**: Ofuscación por derrame de pila para operaciones aritméticas
 - **NUEVO en v3.9**: Reordenamiento de instrucciones con inserción de NOP
 - **NUEVO en v3.9**: Estrategia de automodificación en tiempo de ejecución (implementación básica)
 - **NUEVO en v3.9**: Generación de instrucciones superpuestas
  - **NUEVO en v4.0**: Soporte entre arquitecturas ARM/ARM64 con selección dinámica de modo de Capstone
  - **NUEVO en v4.0**: Codificación inmediata ARM con transformaciones MVN
  - **NUEVO en v4.0**: Estrategias MOV ARM (original, evitación de nulos basada en MVN)
  - **NUEVO en v4.0**: Estrategias aritméticas ARM (ADD con transformaciones SUB)
  - **NUEVO en v4.0**: Estrategias de memoria ARM (paso directo LDR/STR)
  - **NUEVO en v4.0**: Estrategias de bifurcación ARM (paso directo B/BL)
  - **NUEVO en v4.1**: Cadenas de acumulación de flags SETcc (eliminación de saltos condicionales)
  - **NUEVO en v4.1**: Construcción polimórfica de valores inmediatos (múltiples variantes de codificación)
  - **NUEVO en v4.1**: Optimización de cadenas de dependencia de registros (patrones multi-instrucción)
  - **NUEVO en v4.1**: Optimización de direccionamiento relativo a RIP (mejoras PIC x64)
  - **NUEVO en v4.1**: Direccionamiento de memoria con desplazamiento negativo (alternativas de desplazamiento)
  - **NUEVO en v4.1**: Entrelazado de NOP multi-byte (variantes de NOP para ofuscación)
  - **NUEVO en v4.1**: Construcción de constantes mediante manipulación de bits (BSWAP, BSF, POPCNT, BMI2)
  - **NUEVO en v4.2**: Capa de compatibilidad de estrategias x86/x64 (habilita más de 128 estrategias x86 en x64)
  - **NUEVO en v4.2**: Estrategias de inmediatos de 64 bits MOVABS (MOV REX.W con construcción XOR/ADD)
  - **NUEVO en v4.2**: Estrategias de cero inmediato SBB (transformación SBB AL/AX/EAX, 0)
  - **NUEVO en v4.2**: Estrategias de inmediatos grandes TEST (TEST EAX/RAX, imm32 con operandos de registro)
  - **NUEVO en v4.2**: Estrategias de operaciones de memoria SSE (eliminación de nulos MOVUPS/MOVAPS/MOVDQU/MOVDQA)
  - **NUEVO en v4.2**: Estrategias de desplazamiento LEA x64 (manejo de desplazamientos grandes con prefijos REX)
  - **NUEVO en v4.2**: Soporte de registros extendidos (utilidades de codificación de registros R8-R15)
 - Soporte integral para `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH` y más

El motor emplea procesamiento de múltiples pasadas (ofuscación → eliminación de nulos) con mecanismos robustos de respaldo para casos límite

**MEJORAS CRÍTICAS v3.8**: Corrección multi-estrategia para el perfil http-whitespace
- **Problema**: Los bytes problemáticos hardcodeados causaron una tasa de fallo del 79.1% (125/158 archivos fallaron)
- **Causas raíz identificadas**:
  - Más de 45 instancias del byte SIB 0x20 (ESPACIO) hardcodeado en 15 archivos de estrategia
  - Lógica central de saltos condicionales que usa offsets de salto de bytes problemáticos sin validación
  - Optimización parcial de registros que escribe bytes problemáticos directamente
  - Bytes problemáticos adicionales hardcodeados en 5 archivos de estrategia de prioridad ALTA
- **Soluciones implementadas**:
  - Generación SIB centralizada consciente del perfil con respaldo de 3 niveles (STANDARD → DISP8 → PUSHPOP)
  - Relleno NOP dinámico para offsets de salto en saltos condicionales para evitar bytes problemáticos
  - Construcción inteligente de bytes para valores de registros parciales mediante descomposición
  - Reemplazo sistemático de bytes hardcodeados por alternativas conscientes del perfil
- **Impacto**: **79.1% de fallos → 35.4% de fallos** (tasa de éxito: **20.9% → 64.6%**)
- **Archivos corregidos**: 102 archivos ahora se procesan correctamente (+69 archivos, mejora de 3.09x)
- **Tasas de éxito de estrategias**:
  - Optimización parcial de registros: 25% → **100%** (12/12 transformaciones)
  - mov_mem_disp_enhanced: 0% → **98.5%** (1605/1629 transformaciones)
  - indirect_call_mem: 0% → **98.5%** (135/137 transformaciones)
  - indirect_jmp_mem: 0% → **98.5%** (134/136 transformaciones)
- **Rendimiento**: Cero sobrecarga mediante caché inteligente, aumento de tamaño promedio <2%

### MÉTRICAS DE RENDIMIENTO

Datos de rendimiento reales del procesamiento de 184 muestras diversas de shellcode:```
📊 Batch Processing Statistics:

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

-sr string
    	Pares de SearchReplace separados por coma(s) (p. ej., "match:replace,match2:replace2") (por defecto "User-Agent:,Auto-Update:,__cfduid=,__cf_bm=,cf_clearance=,__utma=,__utmz=,_ga=,_gid=,_gat=,utm_source=,utm_content=,utm_medium=,utm_campaign=,utm_termination=,_gcl_au=,_gaexp=,_opt_awcid=,_opt_awmid=,_opt_awgid=,_opt_awkid=,_opt_utmk=,_opt_expid=")
-srhi
    	Cadena de entrada SearchReplace desde un archivo. Utilice -sr para especificar par(es)
-srhe string
    	Cadena de encabezado SearchReplace para reemplazar en todos los encabezados```
🏆 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%

### CAPA DE OFUSCACIÓN
El modo `--biphasic` añade ofuscación anti-análisis antes de la eliminación de bytes nulos:
- Aplanamiento del flujo de control
- Patrones de despacho
- Reasignación de registros
- Ofuscación de estado
- Inserción de código muerto
- Trineos NOP
- Sustitución de instrucciones
- Operaciones equivalentes
- Manipulación del marco de pila
- Ocultación de resolución de API
- Codificación de cadenas
- Codificación de constantes
- Anti-depuración
- Técnicas de detección de VM

### SELECCIÓN DE ESTRATEGIA IMPULSADA POR ML

> **Madurez: Beta v2.0** — Entrenado con conjuntos de datos de eliminación de bytes nulos. Requiere reentrenamiento para casos de uso genéricos de bytes malos.

**Arquitectura**:
- **Codificación one-hot de instrucciones** (51 dimensiones) reemplaza los identificadores escalares de instrucciones
- **Ventana de contexto** con búfer deslizante de 4 instrucciones (actual + 3 anteriores)
- **Extracción de características fija** con disposición estable de 84 dimensiones por instrucción
- **Registro de estrategias estable** que garantiza un mapeo de salida NN consistente
- **Retropropagación completa** a través de todas las capas (entrada→oculta→salida)
- **Cálculo correcto de gradientes** para la pérdida de softmax + entropía cruzada
- **Enmascaramiento de salida** filtra estrategias no válidas antes del softmax
- **Inicialización He/Xavier** para una correcta inicialización de pesos
- Red neuronal feedforward de 3 capas (336→512→200)
- Aprendizaje adaptativo a partir de la retroalimentación de éxito/fracaso
- Realiza seguimiento de predicciones, precisión y confianza
- Reversión elegante a la ordenación determinista

> [!WARNING]
> El modo ML es experimental y requiere más entrenamiento/validación con la nueva arquitectura.

### PROCESAMIENTO POR LOTES
- Recorrido recursivo de directorios (`-r`)
- Patrones de archivo personalizados (`--pattern "*.bin"`)
- Preservación o aplanamiento de la estructura
- Modos de continuar ante errores o estrictos
- Compatible con todas las opciones (biphasic, PIC, `XOR`, etc.)
- **Salida mejorada**:
  - Transformaciones de tamaño por archivo con proporciones
  - Identificación detallada de bytes malos en fallos
  - Porcentajes de éxito/fracaso en el resumen
  - Lista de archivos fallidos (primeros 10 mostrados en línea)
  - Definición estricta de éxito: los archivos con bytes malos restantes se marcan como fallidos

**EJEMPLO DE SALIDA DEL PROCESAMIENTO POR LOTES:**```
===== 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 VERIFICACIÓN
Herramientas de Python para la validación:
- `verify_denulled.py`: Garantiza cero bytes no válidos (admite `--bad-bytes` para verificación personalizada)
- `verify_functionality.py`: Comprueba los patrones de ejecución
- `verify_semantic.py`: Valida la equivalencia

## ARQUITECTURA

`byvalver` emplea un diseño modular de patrón de estrategia:
- Pase 1: (Opcional) Ofuscación para anti-análisis
- Pase 2: Denullificación para la eliminación de bytes nulos
- Capa de ML para la optimización de estrategias
- Sistema por lotes para procesamiento escalable

<div align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/9982/8d3a1e20481460fedecaecda6f87bc21355fbbb1f1ef58d7fef4427eda36a381.png" alt="Taxonomía de categorías de estrategia" width="700">
</div>

## REQUISITOS DEL SISTEMA

- **SO**: Linux (Ubuntu/Debian/Fedora), macOS (con Homebrew), Windows (mediante WSL/MSYS2)
- **CPU**: x86/x64 con instrucciones modernas
- **RAM**: 1GB libre
- **Disco**: 50MB libres
- **Herramientas**: compilador de `C`, Make, Git (recomendado)

## DEPENDENCIAS

- **Núcleo**: GCC/Clang, GNU Make, `Capstone` (v4.0+), `NASM` (v2.13+), xxd
- **Opcional**: Clang-Format, Cppcheck, Valgrind
- **Entrenamiento de ML**: bibliotecas matemáticas (incluidas)

### COMANDOS DE INSTALACIÓN

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

### CORRECCIONES DE COMPILACIÓN PARA macOS/Homebrew (CAMBIOS EN EL REPOSITORIO)
Se realizaron cambios recientes para mejorar la compatibilidad con macOS/Homebrew (especialmente en Apple silicon + prefijo de Homebrew `/opt/homebrew`):
- Se actualizaron `Makefile` y `makefile` para **usar `CPPFLAGS` durante la compilación** y **`LDLIBS` durante el enlazado**, de modo que se respeten las opciones de Capstone descubiertas por `pkg-config`.
- Se normalizó la ruta de inclusión de Capstone emitida por `pkg-config` de Homebrew de `.../include/capstone` a `.../include` para que el `#include <capstone/capstone.h>` del proyecto se resuelva correctamente.

Resumen del diff (nivel alto):
- `$(CC) $(CFLAGS) -c ...` → `$(CC) $(CFLAGS) $(CPPFLAGS) -c ...`
- `$(CC) $(CFLAGS) -o ... $(LDFLAGS)` → `$(CC) $(CFLAGS) $(CPPFLAGS) -o ... $(LDFLAGS) $(LDLIBS)`
- `CAPSTONE_CFLAGS := pkg-config --cflags capstone` → normalizado a una ruta de inclusión compatible con `<capstone/capstone.h>`

### SOLUCIÓN DE PROBLEMAS (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

Ver configuración: `make info`

## INSTALACIÓN

Instalación global:```bash
sudo make install
sudo make install-man

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

- La entrada/salida puede ser archivos o directorios (procesamiento por lotes automático)

**OPCIONES CLAVE:**
- `-h, --help`: Ayuda
- `-v, --version`: Versión
- `-V, --verbose`: Detallado
- `-q, --quiet`: Silencioso
- `--bad-bytes BYTES`: bytes hex separados por comas para desterrar (predeterminado: "00")
- `--profile NAME`: Usa un perfil de bytes malos predefinido (p. ej., http-newline, sql-injection)
- `--list-profiles`: Lista todos los perfiles de bytes malos disponibles
- `--biphasic`: Ofuscar + denull
- `--pic`: Independiente de posición
- `--ml`: Selección de estrategia ML
- `--xor-encode KEY`: `XOR` con stub
- `--format FORMAT`: raw|c|python|hexstring
- `-r, --recursive`: Lote recursivo
- `--pattern PATTERN`: Comodín de archivo
- `--no-preserve-structure`: Aplanar salida
- `--no-continue-on-error`: Detenerse al encontrar un error
- `--menu`: Iniciar menú TUI interactivo

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

**RECOMENDACIÓN:** El modo ML necesita reentrenamiento con conjuntos de datos diversos de bytes malos antes de su uso en producción. Actualmente está optimizado solo para la eliminación de bytes nulos.

## GALERÍA DE AGENTES

`byvalver` incluye un **canal de agentes impulsado por IA** (`agents/`) que puede descubrir de forma autónoma lagunas en el registro de estrategias, proponer una técnica novedosa de eliminación de bytes malos, generar una implementación C completa e integrarla en el proyecto, todo con un solo comando.

El canal está construido sobre el framework multi-proveedor de agentes [AjintK](https://github.com/umpolungfish/byvalver/blob/main/AjintK) y admite **Anthropic**, **DeepSeek**, **Qwen**, **Mistral** y **Google** como backends de LLM.

### INICIO RÁPIDO```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

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

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