**OPZIONE 2: COMPILA DAL SORGENTE**```bash
git clone https://github.com/umpolungfish/byvalver.git
cd byvalver
make
sudo make install
sudo make install-man  # Install man page

**UTILIZZO DEI PROFILI 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

**FUNZIONALITÀ AVANZATE:**```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

### SUPPORTO MULTI-ARCHITETTURA

`byvalver` supporta più architetture tramite il flag `--arch`:

**x86 (Intel/AMD a 32 bit)** - completamente supportato con oltre 150 strategie```bash
byvalver --arch x86 --bad-bytes "00" x86_shellcode.bin output.bin

**ARM (32-bit)** - Supporto sperimentale con strategie di base```bash
byvalver --arch arm --bad-bytes "00" arm_shellcode.bin output.bin

**Note:**
- Il supporto ARM/ARM64 si concentra sulle istruzioni core (MOV, aritmetica, load/store)
- Usa profili bad-byte più semplici per ARM (es., solo byte nulli)
- Gli avvisi sperimentali vengono mostrati quando si seleziona ARM/ARM64
- Il rilevamento di base della mancata corrispondenza dell'architettura avvisa se lo shellcode sembra essere dell'architettura sbagliata
- Il rilevamento automatico dell'architettura è previsto per versioni future

### ELABORAZIONE IN LOTTO

Elabora intere directory:```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/

### FUNZIONALITÀ PRINCIPALI:

Il TUI offre 9 opzioni del menu principale che coprono tutte le funzionalità della CLI:

1. **Elabora file singolo** - Elabora singoli file shellcode con feedback visivo
2. **Elabora directory in batch** - Elabora intere directory con monitoraggio live dell'avanzamento
3. **Configura opzioni di elaborazione** - Attiva/disattiva modalità bifasica, generazione PIC, ML, verbose, dry-run
4. **Imposta Bad Bytes** - Inserimento manuale o selezione da 13 profili predefiniti
5. **Impostazioni formato di output** - Scegli tra 5 formati di output (raw, C, Python, PowerShell, hexstring)
6. **Configurazione metriche ML** - Configura la selezione delle strategie ML e il monitoraggio delle metriche
7. **Opzioni avanzate** - Codifica XOR, timeout, limiti, impostazioni di validazione
8. **Carica/Salva configurazione** - Gestione file di configurazione in stile INI
9. **Informazioni su byvalver** - Versione e informazioni di aiuto

### BROWSER FILE VISUALE:

- **Navigazione directory** con tasti freccia o tasti in stile vi j/k
- **Distinzione file/directory** con indicatori [FILE] e [DIR]
- **Visualizzazione dimensione file** con formati leggibili (B, KB, MB, GB)
- **Filtro per estensione** (es., *.bin)
- **Gestione intelligente dei percorsi** - Naviga automaticamente alla directory padre se viene fornito un percorso file
- **Visualizzazione ordinata** - Prima le directory, poi in ordine alfabetico
- **Modalità di selezione multiple**:
  - Modalità selezione file: Naviga nelle directory, seleziona solo file
  - Modalità selezione directory: Seleziona directory per l'elaborazione in batch
  - Modalità entrambi: Seleziona sia file che directory

### ELABORAZIONE BATCH CON AGGIORNAMENTI LIVE:

La schermata di elaborazione batch fornisce **feedback in tempo reale**:

- **Barra di avanzamento** che mostra i file elaborati (es., `[==============        ] 52/100 files`)
- **Visualizzazione configurazione** che mostra le impostazioni attive:
  - Numero di bad bytes e profilo utilizzato
  - Opzioni di elaborazione (`Biphasic`, `PIC`, `XOR`, ML)
  - Formato di output
- **Statistiche file live** con stato codificato a colori:
  - Completati: X / Y (file tentati / totale)
  - ✅ Riusciti (VERDE) - zero bad bytes rimanenti
  - ❌ Falliti (ROSSO) - errori o bad bytes rimanenti
  - Percentuale di successo
- **Visualizzazione file corrente** in grassetto
- **Anteprima file successivo** in testo giallo/attenuato
- **Tabella dinamica delle statistiche delle strategie** che mostra:
  - **Tutte le strategie attive** (nessun limite di 10 strategie)
  - **Nomi completi delle strategie** (fino a 50 caratteri, nessun troncamento)
  - Conteggi di successo/fallimento per strategia
  - Percentuali di successo
  - Codificate a colori in base alle prestazioni (verde ≥80%, giallo 50-79%, rosso <50%)
  - Aggiornamenti in tempo reale ogni 50ms

### GESTIONE CONFIGURAZIONE:

Carica e salva configurazioni in **formato stile 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'applicazione rileverà automaticamente se ncurses è disponibile e abiliterà il supporto TUI di conseguenza.

### OPZIONI DI COMPILAZIONE:

Il supporto TUI viene compilato in modo condizionale in base alla disponibilità di ncurses:

- Build predefinita: `make` - Include il supporto TUI se ncurses è disponibile
- Build TUI forzata: `make with-tui` - Compila con supporto TUI (fallisce se ncurses non è disponibile)
- Escludi TUI: `make no-tui` - Compila senza supporto TUI per un binario più piccolo

### ESEMPI DI FLUSSI DI LAVORO:

**ELABORAZIONE DI UN SINGOLO FILE:**
1. Avvia la TUI: `byvalver --menu`
2. Seleziona "1. Process Single File"
3. Sfoglia per selezionare il file di input usando il browser di file visivo
4. Sfoglia per selezionare la posizione del file di output
5. Avvia l'elaborazione e visualizza i risultati

**ELABORAZIONE BATCH:**
1. Avvia la TUI: `byvalver --menu`
2. Seleziona "2. Batch Process Directory"
3. Sfoglia per selezionare la directory di input contenente i file di shellcode
4. Sfoglia per selezionare la directory di output
5. Configura il pattern dei file (predefinito: `<file>.bin`) e l'opzione ricorsiva
6. Avvia l'elaborazione batch e osserva l'avanzamento in tempo reale con le statistiche delle strategie

**GESTIONE DELLA CONFIGURAZIONE:**
1. Configura tutte le opzioni nella TUI (byte vietati, formato di output, ML, ecc.)
2. Seleziona "8. Load/Save Configuration"
3. Salva la configurazione corrente in un file (es., `my_config.conf`)
4. In seguito: Carica il file di configurazione per ripristinare tutte le impostazioni

### NOTE SULLE PRESTAZIONI:

- **Elaborazione di un singolo file**: feedback visivo immediato, <1 secondo per shellcode tipici
- **Elaborazione batch**: 50ms di ritardo tra i file per aggiornamenti visivi
- **Directory grandi (100+ file)**: la scansione potrebbe richiedere 1-2 secondi
- **Inizializzazione delle strategie**: 2-5 secondi alla prima esecuzione (costo una tantum per sessione)

### COMPATIBILITÀ DEL TERMINALE:

La TUI è stata testata con:
- GNOME Terminal
- Konsole
- xterm
- iTerm2 (macOS)
- Windows Terminal (WSL)
- tmux/screen (funziona ma potrebbe avere limitazioni sui colori)

**Dimensione minima consigliata del terminale**: 80x24 caratteri (100x30 o superiore consigliata per la tabella completa delle strategie durante l'elaborazione batch)

Per la documentazione TUI completa, la risoluzione dei problemi e l'uso avanzato, consulta [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/TUI_README.md).

## ELIMINAZIONE MIRATA DEI BAD BYTE

### PANORAMICA

L'opzione `--bad-bytes` consente di specificare qualsiasi insieme di byte da eliminare dal proprio shellcode.

### DETTAGLI DI IMPLEMENTAZIONE

`byvalver` opera nel seguente modo:
1. Analizza l'elenco di byte esadecimali separati da virgole (es., `"00,0a,0d"`)
2. Utilizza una ricerca bitmap O(1) per identificare i byte vietati nelle istruzioni
3. Applica le stesse 153+ strategie di trasformazione usate per l'eliminazione dei byte nulli
4. Verifica che l'output non contenga i byte vietati specificati

### COMPORTAMENTO PREVISTO

- **Solo byte nulli** (`--bad-bytes "00"` o predefinito): alto tasso di successo (100% sul corpus di test)
- **Più byte vietati** (`--bad-bytes "00,0a,0d"`): il tasso di successo può variare significativamente in base a:
  - Quali byte specifici sono contrassegnati come vietati
  - La complessità dello shellcode di input
  - La frequenza dei byte vietati nello shellcode originale
  - L'eventuale esistenza di codifiche alternative efficaci per il set specifico di byte vietati

### RACCOMANDAZIONI

1. **Per uso in produzione:** attieniti alla modalità predefinita di eliminazione dei byte nulli
2. **Per la sperimentazione:** testa la funzionalità `--bad-bytes` con il tuo caso d'uso specifico e valida l'output
3. **Verifica sempre:** usa `verify_denulled.py --bad-bytes "XX,YY"` per confermare che tutti i byte vietati siano stati eliminati
4. **Aspettati variabilità:** alcuni shellcode potrebbero non essere completamente ripulibili con determinati set di byte vietati

### MIGLIORAMENTI FUTURI

La funzionalità generica dei bad byte fornisce una base per:
- Ottimizzazione delle strategie per pattern specifici di bad byte
- Scoperta automatica di nuove strategie mirate alle combinazioni comuni di bad byte
- Riaddestramento del modello ML con dati di addestramento diversificati sui bad byte
- Test e validazione estesi

> [!CAUTION]
> L'uso di `--bad-bytes` con più byte vietati aumenta significativamente la complessità del processo di trasformazione. Alcuni shellcode potrebbero diventare impossibili da trasformare se troppi byte vengono contrassegnati come vietati, poiché lo strumento potrebbe esaurire le codifiche alternative. Inizia con set di byte vietati piccoli (es., `"00,0a"`) ed espandili gradualmente testando l'output. Verifica sempre il risultato con `verify_denulled.py` prima della distribuzione.

## PROFILI BAD-BYTE

### PANORAMICA

Gli utenti possono anche scegliere **profili bad-byte** - set di byte preconfigurati per scenari di exploit comuni. Invece di specificare manualmente i valori esadecimali, usa i nomi dei profili che corrispondono al tuo contesto.

### PROFILI DISPONIBILI

| Profilo | Difficoltà | Byte vietati | Caso d'uso |
|---------|-----------|-----------|----------|
| `null-only` | ░░░░░ Banale | 1 | Overflow di buffer classici (predefinito) |
| `http-newline` | █░░░░ Bassa | 3 | Intestazioni `HTTP`, protocolli basati su linee |
| `http-whitespace` | █░░░░ Bassa | 5 | Parametri `HTTP`, command injection |
| `url-safe` | ███░░ Media | 23 | Parametri `URL`, richieste `GET` |
| `sql-injection` | ███░░ Media | 5 | Contesti di iniezione `SQL` |
| `xml-html` | ███░░ Media | 6 | Iniezione `XML`/`HTML`, `XSS` |
| `json-string` | ███░░ Media | 34 | Iniezione API `JSON` |
| `format-string` | ███░░ Media | 3 | Vulnerabilità di format string |
| `buffer-overflow` | ███░░ Media | 5 | Overflow di stack/heap con filtraggio |
| `command-injection` | ███░░ Media | 20 | Iniezione di comandi shell |
| `ldap-injection` | ███░░ Media | 5 | Query `LDAP` |
| `printable-only` | ████░ Alta | 161 | Protocolli basati su testo (solo ASCII stampabile) |
| `alphanumeric-only` | █████ Estrema | 194 | Shellcode solo alfanumerico (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, virgolette, punti e virgola):```bash
byvalver --profile sql-injection payload.bin sql_safe.bin

For detailed profile documentation, see [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md).


## FUNZIONALITÀ

### ALTO TASSO DI SUCCESSO NELL'ELIMINAZIONE DEI NULL-BYTE
<div align="center">
  <strong>Raggiunto il 100% di eliminazione dei null-byte su un corpus di test eterogeneo che rappresenta fonti di null comuni e complesse.</strong>
</div>

> Questo tasso di successo si applica specificamente all'eliminazione dei null-byte (`\x00`), che è stata ampiamente testata e ottimizzata.

### MOTORE DI TRASFORMAZIONE AVANZATO
Oltre 170 implementazioni di strategie che coprono praticamente tutte le fonti comuni di null-byte e i pattern generali di bad-byte (molte nuove famiglie di strategie aggiunte in v3.0, v3.6, v3.7, v3.8, v4.0 e v4.1):
- `CALL/POP` e caricamento immediato basato su stack
- Attraversamento del `PEB` con risoluzione API tramite hash
- Risoluzione API avanzata basata su hash con algoritmi complessi
- Attraversamento `PEB` multi-stadio per il caricamento di più DLL
- `SALC`, `XCHG` e azzeramento basato sui flag
- `LEA` per la sostituzione aritmetica
- Costruzione di valori tramite `Shift` e operazioni aritmetiche
- Costruzione di stringhe con `PUSH` multipli
- Costruzione di strutture Windows basata su stack
- Costruzione di stringhe basata su stack con pattern avanzati
- Riscrittura di `SIB` e displacement
- Gestione del displacement nei salti condizionali
- Rimappatura e concatenamento dei registri
- `SALC`+`REP STOSB` potenziati per l'inizializzazione dei buffer
- Trasformazioni avanzate delle operazioni su stringhe
- Catene di codifica di operazioni atomiche
- Codifica immediata basata su stack `FPU`
- Traduzione di byte basata su tabella `XLAT`
- Catene di preservazione dei flag `LAHF`/`SAHF`
- **NUOVO in v3.6**: offuscamento aritmetico `BCD` (`AAM`/`AAD`)
- **NUOVO in v3.6**: alternative ai frame di stack `ENTER`/`LEAVE`
- **NUOVO in v3.6**: conteggio bit `POPCNT`/`LZCNT`/`TZCNT` per costanti
- **NUOVO in v3.6**: caricamento immediato nei registri `SIMD` `XMM`
- **NUOVO in v3.6**: trasformazioni dei salti di test-zero `JECXZ`/`JRCXZ`
- **NUOVO in v3.7**: eliminazione dei bad-byte negli opcode dei salti condizionali (JE/JNE/JG/JL con opcode non validi)
- **NUOVO in v3.7**: opcode con bad-byte nel trasferimento registro-a-registro (alternative MOV/XCHG)
- **NUOVO in v3.7**: eliminazione dei bad-byte nel puntatore di frame di stack (alternative PUSH/POP EBP)
- **NUOVO in v3.7**: eliminazione dei bad-byte nei byte ModR/M e SIB (combinazioni di registri alternative)
- **NUOVO in v3.7**: bad-byte parziale negli immediati multi-byte (ottimizzazione tramite rotazione)
- **NUOVO in v3.7**: bad-byte negli immediati delle operazioni bitwise (AND/OR/XOR/TEST con registri)
- **NUOVO in v3.7**: sostituzione di opcode a un byte (alternative INC/DEC/PUSH/POP)
- **NUOVO in v3.7**: bad-byte nel prefisso delle istruzioni su stringhe (conversione da prefisso REP a loop)
- **NUOVO in v3.7**: bad-byte nel prefisso di dimensione operando (conversione da 16-bit a 32-bit)
- **NUOVO in v3.7**: rilevamento dei bad-byte nei registri di segmento (rilevamento prefissi FS/GS)
- **NUOVO in v3.8**: sistema di generazione SIB consapevole del profilo (elimina il byte SIB 0x20 hardcoded)
- **NUOVO in v3.8**: correzioni critiche per la gestione dei salti condizionali e l'ottimizzazione parziale dei registri
 - **NUOVO in v3.9**: inserimento polimorfo di NOP con più equivalenti NOP
 - **NUOVO in v3.9**: unfold di costanti per l'offuscamento di valori immediati
 - **NUOVO in v3.9**: offuscamento tramite rinomina dei registri con pattern XCHG
 - **NUOVO in v3.9**: offuscamento tramite stack spill per operazioni aritmetiche
 - **NUOVO in v3.9**: riordinamento delle istruzioni con inserimento di NOP
 - **NUOVO in v3.9**: strategia di auto-modifica a runtime (implementazione di base)
 - **NUOVO in v3.9**: generazione di istruzioni sovrapposte
  - **NUOVO in v4.0**: supporto cross-architettura ARM/ARM64 con selezione dinamica della modalità Capstone
  - **NUOVO in v4.0**: codifica immediata ARM con trasformazioni MVN
  - **NUOVO in v4.0**: strategie ARM MOV (originale, evitamento dei null basato su MVN)
  - **NUOVO in v4.0**: strategie aritmetiche ARM (ADD con trasformazioni SUB)
  - **NUOVO in v4.0**: strategie di memoria ARM (pass-through LDR/STR)
  - **NUOVO in v4.0**: strategie di branch ARM (pass-through B/BL)
  - **NUOVO in v4.1**: catene di accumulo flag SETcc (eliminazione dei salti condizionali)
  - **NUOVO in v4.1**: costruzione polimorfa di valori immediati (più varianti di codifica)
  - **NUOVO in v4.1**: ottimizzazione delle catene di dipendenza dei registri (pattern multi-istruzione)
  - **NUOVO in v4.1**: ottimizzazione dell'indirizzamento relativo a RIP (miglioramenti PIC x64)
  - **NUOVO in v4.1**: indirizzamento di memoria con displacement negativo (alternative di displacement)
  - **NUOVO in v4.1**: interlacing di NOP multi-byte (varianti NOP per offuscamento)
  - **NUOVO in v4.1**: costruzione di costanti tramite manipolazione di bit (BSWAP, BSF, POPCNT, BMI2)
  - **NUOVO in v4.2**: livello di compatibilità delle strategie x86/x64 (abilita 128+ strategie x86 su x64)
  - **NUOVO in v4.2**: strategie di immediati a 64 bit MOVABS (MOV REX.W con costruzione XOR/ADD)
  - **NUOVO in v4.2**: strategie SBB con immediato zero (trasformazione SBB AL/AX/EAX, 0)
  - **NUOVO in v4.2**: strategie TEST con immediati grandi (TEST EAX/RAX, imm32 con operandi registro)
  - **NUOVO in v4.2**: strategie per operazioni di memoria SSE (eliminazione dei null MOVUPS/MOVAPS/MOVDQU/MOVDQA)
  - **NUOVO in v4.2**: strategie LEA x64 con displacement (gestione di displacement grandi con prefissi REX)
  - **NUOVO in v4.2**: supporto esteso per i registri (utility di codifica registri R8-R15)
 - Supporto completo per `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH` e altro

Il motore utilizza l'elaborazione multi-pass (offuscamento → rimozione dei null) con meccanismi di fallback robusti per i casi limite

**MIGLIORAMENTI CRITICI v3.8**: correzione multi-strategia per il profilo http-whitespace
- **Problema**: i bad-byte hardcoded hanno causato un tasso di fallimento del 79.1% (125/158 file falliti)
- **Cause principali individuate**:
  - Oltre 45 istanze del byte SIB 0x20 (SPAZIO) hardcoded in 15 file di strategie
  - Logica principale dei salti condizionali che utilizza offset di salto su bad-byte senza validazione
  - Ottimizzazione parziale dei registri che scrive direttamente i bad-byte
  - Bad-byte hardcoded aggiuntivi in 5 file di strategie ad alta priorità
- **Soluzioni implementate**:
  - Generazione SIB centralizzata e consapevole del profilo con fallback a 3 livelli (STANDARD → DISP8 → PUSHPOP)
  - Padding NOP dinamico per gli offset di salto dei salti condizionali per evitare i bad-byte
  - Costruzione intelligente dei byte per i valori parziali dei registri tramite decomposizione
  - Sostituzione sistematica dei byte hardcoded con alternative consapevoli del profilo
- **Impatto**: **79.1% di fallimenti → 35.4% di fallimenti** (tasso di successo: **20.9% → 64.6%**)
- **File corretti**: 102 file ora vengono elaborati con successo (+69 file, miglioramento di 3.09x)
- **Tassi di successo delle strategie**:
  - Ottimizzazione parziale dei registri: 25% → **100%** (12/12 trasformazioni)
  - mov_mem_disp_enhanced: 0% → **98.5%** (1605/1629 trasformazioni)
  - indirect_call_mem: 0% → **98.5%** (135/137 trasformazioni)
  - indirect_jmp_mem: 0% → **98.5%** (134/136 trasformazioni)
- **Prestazioni**: overhead zero grazie alla cache intelligente, aumento medio delle dimensioni <2%

### METRICHE DI PRESTAZIONE

Dati di prestazione reali derivanti dall'elaborazione di 184 campioni di shellcode diversi:```
📊 Batch Processing Statistics:

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

Il contenuto da tradurre per il chunk 43 non è stato incluso nel messaggio. Non è presente alcun testo di input dopo "INPUT:".```
🏆 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%

### STRATO DI OFFUSCAZIONE
La modalità `--biphasic` aggiunge un'offuscazione anti-analisi prima della rimozione dei byte nulli:
- Appiattimento del flusso di controllo
- Pattern di dispatcher
- Riassegnazione dei registri
- Offuscamento dello stato
- Inserimento di codice morto
- Slitte NOP
- Sostituzione di istruzioni
- Operazioni equivalenti
- Manipolazione del frame di stack
- Occultamento della risoluzione delle API
- Codifica delle stringhe
- Codifica delle costanti
- Anti-debugging
- Tecniche di rilevamento VM

### SELEZIONE DELLA STRATEGIA CON ML

> **Maturità: Beta v2.0** — Addestrato su dataset di eliminazione dei byte nulli. Richiede un riaddestramento per casi d'uso generici di byte non validi.

**Architettura**:
- **Codifica one-hot delle istruzioni** (51 dimensioni) sostituisce gli ID di istruzione scalari
- **Finestra di contesto** con buffer scorrevole di 4 istruzioni (corrente + 3 precedenti)
- **Estrazione delle feature fissa** con layout stabile a 84 dimensioni per istruzione
- **Registro delle strategie stabile** che garantisce una mappatura coerente dell'output della NN
- **Backpropagazione completa** attraverso tutti i livelli (input→nascosto→output)
- **Calcolo corretto del gradiente** per la loss softmax + cross-entropia
- **Mascheramento dell'output** filtra le strategie non valide prima della softmax
- **Inizializzazione He/Xavier** per una corretta inizializzazione dei pesi
- Rete neurale feedforward a 3 strati (336→512→200)
- Apprendimento adattivo dal feedback di successo/fallimento
- Tiene traccia di previsioni, accuratezza e confidenza
- Fallback graduale all'ordinamento deterministico

> [!WARNING]
> La modalità ML è sperimentale e richiede ulteriore addestramento/validazione con la nuova architettura.

### ELABORAZIONE IN BATCH
- Attraversamento ricorsivo delle directory (`-r`)
- Pattern di file personalizzati (`--pattern "*.bin"`)
- Conservazione o appiattimento della struttura
- Modalità continua in caso di errore o rigorosa
- Compatibile con tutte le opzioni (biphasic, PIC, `XOR`, ecc.)
- **Output potenziato**:
  - Trasformazioni delle dimensioni per file con rapporti
  - Identificazione dettagliata dei byte non validi in caso di fallimento
  - Percentuali di successo/fallimento nel riepilogo
  - Elenco dei file falliti (primi 10 mostrati in linea)
  - Definizione rigorosa di successo: i file con byte non validi rimanenti vengono contrassegnati come falliti

**ESEMPIO DI OUTPUT DELL'ELABORAZIONE IN BATCH:**```
===== 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 DI VERIFICA
Strumenti Python per la validazione:
- `verify_denulled.py`: Garantisce zero byte dannosi (supporta `--bad-bytes` per la verifica personalizzata)
- `verify_functionality.py`: Controlla i pattern di esecuzione
- `verify_semantic.py`: Valida l'equivalenza

## ARCHITETTURA

`byvalver` impiega un design modulare basato sul pattern strategia:
- Pass 1: (Opzionale) Offuscamento per anti-analisi
- Pass 2: Denullificazione per la rimozione dei byte nulli
- Livello ML per l'ottimizzazione delle strategie
- Sistema batch per l'elaborazione scalabile

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

## REQUISITI DI SISTEMA

- **SO**: Linux (Ubuntu/Debian/Fedora), macOS (con Homebrew), Windows (tramite WSL/MSYS2)
- **CPU**: x86/x64 con istruzioni moderne
- **RAM**: 1GB liberi
- **Disco**: 50MB liberi
- **Strumenti**: compilatore `C`, Make, Git (consigliato)

## DIPENDENZE

- **Core**: GCC/Clang, GNU Make, `Capstone` (v4.0+), `NASM` (v2.13+), xxd
- **Opzionali**: Clang-Format, Cppcheck, Valgrind
- **Addestramento ML**: librerie matematiche (incluse)

### COMANDI DI INSTALLAZIONE

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

### CORREZIONI DI BUILD PER macOS/HOMEBREW (MODIFICHE AL REPO)
Sono state apportate modifiche recenti per migliorare la compatibilità con macOS/Homebrew (in particolare su Apple silicon + prefisso Homebrew `/opt/homebrew`):
- Aggiornati `Makefile` e `makefile` per **usare `CPPFLAGS` durante la compilazione** e **`LDLIBS` durante il collegamento**, così che i flag Capstone individuati da `pkg-config` vengano rispettati.
- Normalizzato il percorso di inclusione di Capstone emesso da `pkg-config` di Homebrew da `.../include/capstone` a `.../include`, così che il `#include <capstone/capstone.h>` del progetto venga risolto correttamente.

Riepilogo del diff (di alto livello):
- `$(CC) $(CFLAGS) -c ...` → `$(CC) $(CFLAGS) $(CPPFLAGS) -c ...`
- `$(CC) $(CFLAGS) -o ... $(LDFLAGS)` → `$(CC) $(CFLAGS) $(CPPFLAGS) -o ... $(LDFLAGS) $(LDLIBS)`
- `CAPSTONE_CFLAGS := pkg-config --cflags capstone` → normalizzato in un percorso di inclusione compatibile con `<capstone/capstone.h>`

### RISOLUZIONE DEI PROBLEMI (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

Visualizza configurazione: `make info`

## INSTALLAZIONE

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

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

Input/output può essere file o directory (auto-batch)

**OPZIONI PRINCIPALI:**
- `-h, --help`: Aiuto
- `-v, --version`: Versione
- `-V, --verbose`: Dettagliato
- `-q, --quiet`: Silenzioso
- `--bad-bytes BYTES`: Byte esadecimali separati da virgola da escludere (default: "00")
- `--profile NAME`: Usa un profilo predefinito di byte da escludere (es., http-newline, sql-injection)
- `--list-profiles`: Elenca tutti i profili di byte da escludere disponibili
- `--biphasic`: Offusca + denull
- `--pic`: Indipendente dalla posizione
- `--ml`: Selezione strategia ML
- `--xor-encode KEY`: `XOR` con stub
- `--format FORMAT`: raw|c|python|hexstring
- `-r, --recursive`: Batch ricorsivo
- `--pattern PATTERN`: Glob dei file
- `--no-preserve-structure`: Appiattisci l'output
- `--no-continue-on-error`: Interrompi su errore
- `--menu`: Avvia il menu TUI interattivo

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

**RACCOMANDAZIONE:** La modalità ML necessita di un riaddestramento con dataset di byte non validi eterogenei prima dell'uso in produzione. Attualmente ottimizzata solo per l'eliminazione dei byte nulli.

## MENAGERIE DI AGENTI

`byvalver` include una **pipeline di agenti basata su IA** (`agents/`) in grado di scoprire autonomamente lacune nel registro delle strategie, proporre una nuova tecnica di eliminazione dei byte non validi, generare un'implementazione C completa e integrarla nel progetto — il tutto con un singolo comando.

La pipeline è costruita sul framework multi-provider per agenti [AjintK](https://github.com/umpolungfish/byvalver/blob/main/AjintK) e supporta **Anthropic**, **DeepSeek**, **Qwen**, **Mistral** e **Google** come backend LLM.

### AVVIO RAPIDO```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

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

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