byvalver (·𐑚𐑲𐑝𐑨𐑤𐑝𐑼)

O BANIDOR DE BYTES RUINS DE SHELLCODE

byvalver bane bytes ruins com extremo preconceito

### PRINCIPAIS FUNCIONALIDADES: O TUI oferece 9 opções principais de menu que cobrem toda a funcionalidade da CLI: 1. **Processar Arquivo Único** - Processa arquivos de shellcode individuais com feedback visual 2. **Processamento em Lote de Diretório** - Processa diretórios inteiros com acompanhamento de progresso ao vivo 3. **Configurar Opções de Processamento** - Alternar modo bifásico, geração PIC, ML, verbose, dry-run 4. **Definir Bad Bytes** - Entrada manual ou seleção de 13 perfis predefinidos 5. **Configurações de Formato de Saída** - Escolha entre 5 formatos de saída (raw, C, Python, PowerShell, hexstring) 6. **Configuração de Métricas de ML** - Configurar seleção de estratégia de ML e rastreamento de métricas 7. **Opções Avançadas** - Codificação XOR, timeouts, limites, configurações de validação 8. **Carregar/Salvar Configuração** - Gerenciamento de arquivos de configuração no estilo INI 9. **Sobre byvalver** - Informações de versão e ajuda ### NAVEGADOR VISUAL DE ARQUIVOS: - **Navegação de diretório** com teclas de seta ou teclas vi-style j/k - **Distinção arquivo/diretório** com indicadores [FILE] e [DIR] - **Exibição de tamanho de arquivo** com formatos legíveis (B, KB, MB, GB) - **Filtragem por extensão** (ex.: *.bin) - **Manuseio inteligente de caminhos** - Navega automaticamente para o diretório pai se um caminho de arquivo for fornecido - **Exibição ordenada** - Diretórios primeiro, depois ordem alfabética - **Modos de seleção múltipla**: - Modo de seleção de arquivo: Navegue em diretórios, selecione apenas arquivos - Modo de seleção de diretório: Selecione diretórios para processamento em lote - Ambos os modos: Selecione arquivos ou diretórios ### PROCESSAMENTO EM LOTE COM ATUALIZAÇÕES EM TEMPO REAL: A tela de processamento em lote fornece **feedback em tempo real**: - **Barra de progresso** mostrando arquivos processados (ex.: `[============== ] 52/100 files`) - **Exibição de configuração** mostrando configurações ativas: - Contagem de bad bytes e perfil usado - Opções de processamento (`Biphasic`, `PIC`, `XOR`, ML) - Formato de saída - **Estatísticas de arquivos ao vivo** com status codificado por cores: - Concluído: X / Y (arquivos tentados / total) - ✅ Sucesso (VERDE) - zero bad bytes restantes - ❌ Falha (VERMELHO) - erros ou bad bytes restantes - Porcentagem de taxa de sucesso - **Exibição do arquivo atual** em texto negrito - **Pré-visualização do próximo arquivo** em texto amarelo/escuro - **Tabela dinâmica de estatísticas de estratégia** mostrando: - **Todas as estratégias ativas** (sem limite de 10 estratégias) - **Nomes completos das estratégias** (até 50 caracteres, sem truncamento) - Contagens de sucesso/fracasso por estratégia - Porcentagens de taxa de sucesso - Codificados por cor de acordo com o desempenho (verde ≥80%, amarelo 50-79%, vermelho <50%) - Atualizações em tempo real a cada 50ms ### GERENCIAMENTO DE CONFIGURAÇÃO: Carregue e salve configurações no **formato 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

A aplicação detectará automaticamente se o ncurses está disponível e habilitará o suporte à TUI de acordo. ### OPÇÕES DE COMPILAÇÃO: O suporte à TUI é compilado condicionalmente com base na disponibilidade do ncurses: - Compilação padrão: `make` - Inclui TUI se ncurses estiver disponível - Forçar compilação com TUI: `make with-tui` - Compila com suporte à TUI (falha se ncurses não estiver disponível) - Excluir TUI: `make no-tui` - Compila sem suporte à TUI para um binário menor ### EXEMPLOS DE FLUXOS DE TRABALHO: **PROCESSAMENTO DE ARQUIVO ÚNICO:** 1. Inicie a TUI: `byvalver --menu` 2. Selecione "1. Process Single File" (Processar Arquivo Único) 3. Navegue até o arquivo de entrada usando o navegador visual de arquivos 4. Navegue até o local do arquivo de saída 5. Inicie o processamento e visualize os resultados **PROCESSAMENTO EM LOTE:** 1. Inicie a TUI: `byvalver --menu` 2. Selecione "2. Batch Process Directory" (Processar Diretório em Lote) 3. Navegue até o diretório de entrada contendo arquivos de shellcode 4. Navegue até o diretório de saída 5. Configure o padrão de arquivo (padrão: <file>.bin) e a opção recursiva 6. Inicie o processamento em lote e acompanhe o progresso ao vivo com estatísticas de estratégia **GERENCIAMENTO DE CONFIGURAÇÃO:** 1. Configure todas as opções na TUI (bad bytes, formato de saída, ML, etc.) 2. Selecione "8. Load/Save Configuration" (Carregar/Salvar Configuração) 3. Salve a configuração atual em um arquivo (ex.: `my_config.conf`) 4. Posteriormente: Carregue o arquivo de configuração para restaurar todas as configurações ### NOTAS DE DESEMPENHO: - **Processamento de arquivo único**: Feedback visual instantâneo, <1 segundo para shellcode típico - **Processamento em lote**: Atraso de 50ms entre arquivos para atualizações visuais - **Diretórios grandes (100+ arquivos)**: A varredura pode levar de 1 a 2 segundos - **Inicialização de estratégias**: 2 a 5 segundos na primeira execução (custo único por sessão) ### COMPATIBILIDADE DE TERMINAL: A TUI foi testada com: - GNOME Terminal - Konsole - xterm - iTerm2 (macOS) - Windows Terminal (WSL) - tmux/screen (funciona, mas pode ter limitações de cor) **Tamanho mínimo recomendado do terminal**: 80x24 caracteres (100x30 ou maior recomendado para a tabela completa de estratégias durante o processamento em lote) Para documentação completa da TUI, solução de problemas e uso avançado, consulte [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/TUI_README.md). ## ELIMINAÇÃO DIRECIONADA DE BYTES PROBLEMÁTICOS ### VISÃO GERAL A opção `--bad-bytes` permite especificar qualquer conjunto de bytes a serem eliminados do seu shellcode. ### DETALHES DA IMPLEMENTAÇÃO `byvalver` opera da seguinte forma: 1. Analisando a lista de bytes hexadecimais separados por vírgula (ex.: `"00,0a,0d"`) 2. Usando uma consulta de bitmap O(1) para identificar bytes problemáticos nas instruções 3. Aplicando as mesmas 153+ estratégias de transformação usadas para eliminação de byte nulo 4. Verificando se a saída não contém os bytes problemáticos especificados ### COMPORTAMENTO ESPERADO - **Apenas bytes nulos** (`--bad-bytes "00"` ou padrão): Alta taxa de sucesso (100% no corpus de teste) - **Múltiplos bytes problemáticos** (`--bad-bytes "00,0a,0d"`): A taxa de sucesso pode variar significativamente dependendo de: - Quais bytes específicos são marcados como problemáticos - Complexidade do shellcode de entrada - Frequência de bytes problemáticos no shellcode original - Se existem codificações alternativas eficazes para o conjunto específico de bytes problemáticos ### RECOMENDAÇÕES 1. **Para uso em produção:** Mantenha o modo padrão de eliminação de byte nulo 2. **Para experimentação:** Teste o recurso `--bad-bytes` com seu caso de uso específico e valide a saída 3. **Sempre verifique:** Use `verify_denulled.py --bad-bytes "XX,YY"` para confirmar se todos os bytes problemáticos foram eliminados 4. **Espere variabilidade:** Alguns shellcodes podem não ser totalmente limpos com certos conjuntos de bytes problemáticos ### MELHORIAS FUTURAS O recurso genérico de bytes problemáticos fornece uma base para: - Otimização de estratégias para padrões específicos de bytes problemáticos - Descoberta automatizada de novas estratégias direcionadas a combinações comuns de bytes problemáticos - Re-treinamento do modelo de ML com diversos dados de treinamento de bytes problemáticos - Testes e validação estendidos > [!CAUTION] > O uso de `--bad-bytes` com múltiplos bytes problemáticos aumenta significativamente a complexidade da tarefa de transformação. Alguns shellcodes podem se tornar impossíveis de transformar se muitos bytes forem marcados como problemáticos, pois a ferramenta pode ficar sem codificações alternativas. Comece com conjuntos pequenos de bytes problemáticos (ex.: `"00,0a"`) e expanda gradualmente enquanto testa a saída. Sempre verifique o resultado com `verify_denulled.py` antes da implantação. ## PERFIS DE BYTES PROBLEMÁTICOS ### VISÃO GERAL Os usuários também podem escolher **perfis de bytes problemáticos** - conjuntos pré-configurados de bytes para cenários comuns de exploração. Em vez de especificar manualmente valores hexadecimais, use nomes de perfil que correspondam ao seu contexto. ### PERFIS DISPONÍVEIS | Perfil | Dificuldade | Bytes Problemáticos | Caso de Uso | |---------|-----------|----------|-----------| | `null-only` | ░░░░░ Trivial | 1 | Buffer overflows clássicos (padrão) | | `http-newline` | █░░░░ Baixa | 3 | Cabeçalhos `HTTP`, protocolos baseados em linha | | `http-whitespace` | █░░░░ Baixa | 5 | Parâmetros `HTTP`, injeção de comandos | | `url-safe` | ███░░ Média | 23 | Parâmetros de `URL`, requisições `GET` | | `sql-injection` | ███░░ Média | 5 | Contextos de injeção `SQL` | | `xml-html` | ███░░ Média | 6 | Injeção `XML`/`HTML`, `XSS` | | `json-string` | ███░░ Média | 34 | Injeção em API `JSON` | | `format-string` | ███░░ Média | 3 | Vulnerabilidades de string de formato | | `buffer-overflow` | ███░░ Média | 5 | Buffer overflows de pilha/heap com filtragem | | `command-injection` | ███░░ Média | 20 | Injeção de comandos de shell | | `ldap-injection` | ███░░ Média | 5 | Consultas `LDAP` | | `printable-only` | ████░ Alta | 161 | Protocolos baseados em texto (apenas ASCII imprimível) | | `alphanumeric-only` | █████ Extrema | 194 | Shellcode apenas 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

Para documentação detalhada de perfis, veja [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md). ## FUNCIONALIDADES ### ALTA TAXA DE SUCESSO NA ELIMINAÇÃO DE NULL-BYTES <div align="center"> <strong>Alcançou 100% de eliminação de null-bytes em um corpus de teste diverso representando fontes de null comuns e complexas.</strong> </div> > Esta taxa de sucesso aplica-se especificamente à eliminação de null-byte (`\x00`), que foi extensivamente testada e otimizada. ### MOTOR DE TRANSFORMAÇÃO AVANÇADO 170+ implementações de estratégias cobrindo virtualmente todas as fontes comuns de null-bytes e padrões gerais de bad-bytes (várias novas famílias de estratégias adicionadas nas v3.0, v3.6, v3.7, v3.8, v4.0 e v4.1): - Carregamento imediato baseado em `CALL/POP` e pilha - Travessia `PEB` com resolução de API por hash - Resolução de API avançada baseada em hash com algoritmos complexos - Travessia `PEB` em múltiplos estágios para carregamento de múltiplas DLLs - Zeração baseada em `SALC`, `XCHG` e flags - `LEA` para substituição aritmética - Construção de valor com `Shift` e aritmética - Construção de string com múltiplos `PUSH` - Construção de estruturas baseadas em pilha para estruturas Windows - Construção de string baseada em pilha com padrões avançados - Reescrita de `SIB` e deslocamento - Manipulação de deslocamento de saltos condicionais - Remapeamento e encadeamento de registradores - `SALC`+`REP STOSB` aprimorado para inicialização de buffer - Transformações avançadas de operações de string - Cadeias de codificação de operações atômicas - Codificação imediata baseada em pilha `FPU` - Tradução de bytes baseada em tabela `XLAT` - Cadeias de preservação de flags `LAHF`/`SAHF` - **NOVO na v3.6**: Ofuscação aritmética `BCD` (`AAM`/`AAD`) - **NOVO na v3.6**: Alternativas de quadro de pilha `ENTER`/`LEAVE` - **NOVO na v3.6**: Contagem de bits `POPCNT`/`LZCNT`/`TZCNT` para constantes - **NOVO na v3.6**: Carregamento imediato de registrador `XMM` `SIMD` - **NOVO na v3.6**: Transformações de salto de teste zero `JECXZ`/`JRCXZ` - **NOVO na v3.7**: Eliminação de bad-bytes de opcode de salto condicional (JE/JNE/JG/JL com opcodes ruins) - **NOVO na v3.7**: Opcodes de bad-bytes de transferência registrador-para-registrador (alternativas MOV/XCHG) - **NOVO na v3.7**: Eliminação de bad-bytes de ponteiro de quadro de pilha (alternativas PUSH/POP EBP) - **NOVO na v3.7**: Eliminação de bad-bytes de bytes ModR/M e SIB (combinações alternativas de registradores) - **NOVO na v3.7**: Bad-byte parcial imediato multi-byte (otimização de rotação) - **NOVO na v3.7**: Bad-byte imediato de operação bitwise (AND/OR/XOR/TEST com registradores) - **NOVO na v3.7**: Substituição de opcode de um byte (alternativas INC/DEC/PUSH/POP) - **NOVO na v3.7**: Bad-byte de prefixo de instrução de string (conversão de prefixo REP para loop) - **NOVO na v3.7**: Bad-byte de prefixo de tamanho de operando (conversão de 16 bits para 32 bits) - **NOVO na v3.7**: Detecção de bad-byte de registrador de segmento (detecção de prefixo FS/GS) - **NOVO na v3.8**: Sistema de geração SIB ciente de perfil (elimina byte SIB 0x20 codificado) - **NOVO na v3.8**: Correções críticas para manipulação de salto condicional e otimização de registrador parcial - **NOVO na v3.9**: Inserção polimórfica de NOP com múltiplos equivalentes de NOP - **NOVO na v3.9**: Desdobramento de constantes para ofuscação de valor imediato - **NOVO na v3.9**: Ofuscação de renomeação de registrador com padrões XCHG - **NOVO na v3.9**: Ofuscação de derramamento de pilha para operações aritméticas - **NOVO na v3.9**: Reordenação de instruções com inserção de NOP - **NOVO na v3.9**: Estratégia de automodificação em tempo de execução (implementação básica) - **NOVO na v3.9**: Geração de instruções sobrepostas - **NOVO na v4.0**: Suporte multiarquitetura ARM/ARM64 com seleção de modo dinâmico do Capstone - **NOVO na v4.0**: Codificação imediata ARM com transformações MVN - **NOVO na v4.0**: Estratégias MOV ARM (original, evitação de null baseada em MVN) - **NOVO na v4.0**: Estratégias aritméticas ARM (ADD com transformações SUB) - **NOVO na v4.0**: Estratégias de memória ARM (passagem LDR/STR) - **NOVO na v4.0**: Estratégias de ramificação ARM (passagem B/BL) - **NOVO na v4.1**: Cadeias de Acumulação de Flags SETcc (eliminação de salto condicional) - **NOVO na v4.1**: Construção de Valor Imediato Polimórfico (múltiplas variantes de codificação) - **NOVO na v4.1**: Otimização de Cadeia de Dependência de Registrador (padrões de múltiplas instruções) - **NOVO na v4.1**: Otimização de Endereçamento Relativo a RIP (melhorias PIC x64) - **NOVO na v4.1**: Endereçamento de Memória com Deslocamento Negativo (alternativas de deslocamento) - **NOVO na v4.1**: Intercalação de NOP Multi-Byte (variantes ofuscadas de NOP) - **NOVO na v4.1**: Construção de Constantes com Manipulação de Bits (BSWAP, BSF, POPCNT, BMI2) - **NOVO na v4.2**: Camada de Compatibilidade de Estratégias x86/x64 (permite 128+ estratégias x86 em x64) - **NOVO na v4.2**: Estratégias de Imediato de 64 bits MOVABS (MOV REX.W com construção XOR/ADD) - **NOVO na v4.2**: Estratégias de Zero Imediato SBB (transformação SBB AL/AX/EAX, 0) - **NOVO na v4.2**: Estratégias de Imediato Grande TEST (TEST EAX/RAX, imm32 com operandos de registrador) - **NOVO na v4.2**: Estratégias de Operação de Memória SSE (eliminação de null MOVUPS/MOVAPS/MOVDQU/MOVDQA) - **NOVO na v4.2**: Estratégias de Deslocamento LEA x64 (manipulação de grande deslocamento com prefixos REX) - **NOVO na v4.2**: Suporte Estendido a Registradores (utilitários de codificação de registradores R8-R15) - Suporte abrangente para `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH` e mais O motor emprega processamento de múltiplas passagens (ofuscação → desnulificação) com mecanismos robustos de fallback para casos extremos **MELHORIAS CRÍTICAS v3.8**: Correção Multi-Estratégia para o Perfil http-whitespace - **Problema**: Bad-bytes codificados causaram taxa de falha de 79.1% (125/158 arquivos falharam) - **Causas Raiz Identificadas**: - 45+ instâncias de byte SIB 0x20 (ESPAÇO) codificado em 15 arquivos de estratégia - Lógica central de salto condicional usando offsets de skip de bad bytes sem validação - Otimização de registrador parcial escrevendo bad bytes diretamente - Bad-bytes codificados adicionais em 5 arquivos de estratégia de ALTA prioridade - **Soluções Implementadas**: - Geração SIB centralizada ciente de perfil com fallback em 3 níveis (STANDARD → DISP8 → PUSHPOP) - Preenchimento NOP dinâmico para offsets de skip de salto condicional para evitar bad bytes - Construção inteligente de bytes para valores de registrador parcial usando decomposição - Substituição sistemática de bytes codificados por alternativas cientes de perfil - **Impacto**: **79.1% de falha → 35.4% de falha** (taxa de sucesso: **20.9% → 64.6%**) - **Arquivos Corrigidos**: 102 arquivos agora processam com sucesso (+69 arquivos, melhoria de 3.09x) - **Taxas de Sucesso das Estratégias**: - Otimização de Registrador Parcial: 25% → **100%** (12/12 transformações) - mov_mem_disp_enhanced: 0% → **98.5%** (1605/1629 transformações) - indirect_call_mem: 0% → **98.5%** (135/137 transformações) - indirect_jmp_mem: 0% → **98.5%** (134/136 transformações) - **Desempenho**: Zero overhead através de cache inteligente, aumento médio de tamanho <2% ### MÉTRICAS DE DESEMPENHO Dados de desempenho do mundo real do processamento de 184 amostras 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%

> [!TIP] > Para processamento em lote de grandes coleções de shellcode, use `--no-continue-on-error` para identificar arquivos problemáticos antecipadamente e, em seguida, processe com sucesso usando `--pattern` para excluir falhas. A flag `--verbose` ajuda a acompanhar o progresso e identificar quais estratégias funcionam melhor para seu corpus específico de shellcode. Os arquivos só são considerados bem-sucedidos quando contêm **zero bytes ruins restantes** – o sucesso parcial é tratado como falha. ### OPÇÕES DE SAÍDA - Formatos: binário bruto, array em `C`, bytes em Python, string hexadecimal - Codificação `XOR` com stub de decodificação (`--xor-encode 0xDEADBEEF`) - Código independente de posição (`--pic`) - Criação automática de diretório de saída ### ESTATÍSTICAS Ao usar a flag `--stats`, o `byvalver` fornece análises detalhadas: **ESTATÍSTICAS DE USO DE ESTRATÉGIAS:** - Mostra quais estratégias de transformação foram aplicadas - Taxas de sucesso/fracasso para cada estratégia - Contagem de aplicações e tamanho médio de saída por estratégia **ANÁLISE DE COMPLEXIDADE DE ARQUIVOS:** - Arquivos mais complexos (por contagem de instruções) - Maiores/menores arquivos por tamanho de entrada - Arquivos com maiores taxas de expansão - Estatísticas de banimento de bytes ruins por arquivo **RESUMO DO PROCESSAMENTO EM LOTE:** - Porcentagens de sucesso/fracasso - Configuração detalhada de bytes ruins - Lista de arquivos com falha, com opções para salvar a lista completa **EXEMPLO DE SAÍDA:**``` ===== BATCH PROCESSING SUMMARY ===== Total files: 162 Successfully processed: 131 (80.9%) Failed: 31 (19.1%) Skipped: 0 Total input size: 35772920 bytes Total output size: 81609 bytes Average size ratio: 0.00x Bad bytes: 3 configured Configured set: 0x00, 0x0a, 0x0d ==================================== FAILED FILES (31): - ./winwin.bin - ./stairslide_secure.bin ... 📊 DETAILED STATISTICS ===================== STRATEGY USAGE STATISTICS: ┌─────────────────────────────────────────┬─────────┬─────────┬──────────────┬────────────────┐ │ Strategy Name │ Success │ Failure │ Applications │ Avg Output Size│ ├─────────────────────────────────────────┼─────────┼─────────┼──────────────┼────────────────┤ │ push_immediate_strategy │ 45 │ 3 │ 48 │ 12.34 │ │ mov_reg_mem_self │ 32 │ 1 │ 33 │ 8.21 │ │ ... │ ... │ ... │ ... │ ... │ └─────────────────────────────────────────┴─────────┴─────────┴──────────────┴────────────────┘ FILE COMPLEXITY ANALYSIS: Most Complex Files (by instruction count): - ./complex_payload.bin: 1245 instructions, 4096 -> 5201 bytes (1.27x) Largest Files (by input size): - ./large_payload.bin: 8192 bytes input, 10485 bytes output (1.28x) Smallest Files (by input size): - ./tiny_shellcode.bin: 64 bytes input, 89 bytes output (1.39x) Largest Expansion (by size ratio): - ./expanded.bin: 512 -> 1024 bytes (2.00x expansion)

## ESTRATÉGIAS DE OFUSCAÇÃO A passagem de ofuscação do `byvalver` (ativada via `--biphasic`) aplica técnicas de anti-análise: ### TÉCNICAS PRINCIPAIS DE OFUSCAÇÃO - **`MOV Register Exchange`**: Padrões `XCHG`/push-pop - **`MOV Immediate`**: Decomposição aritmética - **`Arithmetic Substitution`**: Equivalentes complexos - **`Memory Access`**: Indireção e `LEA` - **`Stack Operations`**: Manipulação manual do `ESP` - **`Conditional Jumps`**: `SETcc` e movimentos - **`Unconditional Jumps`**: Mecanismos indiretos - **`Calls`**: `PUSH` + `JMP` - **`Control Flow Flattening`**: Estados do despachante - **`Instruction Substitution`**: Operações equivalentes - **`Dead Code`**: Inserções inofensivas - **`Register Reassignment`**: Ocultação de fluxo de dados - **`Multiplication by One`**: Padrões `IMUL` - **`NOP Sleds`**: Preenchimento variável - **`Polymorphic NOP Insertion`**: Múltiplos equivalentes de NOP (XCHG EAX,EAX, LEA, MOV) - **`Constant Unfolding`**: Quebrar imediatos em operações aritméticas - **`Register Renaming`**: Substituição de registradores baseada em XCHG - **`Stack Spill Obfuscation`**: Operações aritméticas baseadas na pilha - **`Instruction Reordering`**: Embaralhamento de instruções com inserção de NOP - **`Runtime Self-Modification`**: Geração de código automodificante - **`Overlapping Instructions`**: Sequências de bytes com múltiplas interpretações - **`Jump Decoys`**: Alvos falsos - **`Relative Offsets`**: Saltos calculados - **`Switch-Based`**: Fluxo computado - **`Boolean Expressions`**: Equivalentes de De Morgan - **`Variable Encoding`**: Transformações reversíveis - **`Timing Variations`**: Atrasos - **`Register State`**: Manipulações complexas - **`Stack Frames`**: Gerenciamento personalizado - **`API Resolution`**: Hash complexo - **`String Encoding`**: Decodificação em tempo de execução - **`Constants`**: Geração de expressões - **`Debugger Detection`**: Verificações ofuscadas - **`VM Detection`**: Métodos ocultos As prioridades favorecem anti-análise (alta) sobre substituições simples (baixa). Veja [OBFUSCATION_STRATS](https://github.com/umpolungfish/byvalver/blob/main/docs/OBFUSCATION_STRATS.md) para documentação detalhada da estratégia. ## ESTRATÉGIAS DE DESNULIFICAÇÃO A passagem principal de desnulificação usa mais de 170 estratégias: ### ESTRATÉGIAS `MOV` - Passagem original - Decomposições `NEG`, `NOT`, `XOR`, `Shift`, `ADD/SUB` ### ARITMÉTICA - Original, `NEG`, `XOR`, `ADD/SUB` ### SALTOS/CONTROLE - Indiretos `CALL/JMP` - Deslocamento de memória genérico - Eliminação de deslocamento condicional ### AVANÇADO - Bypass de ModR/M - `TEST` preservando flags - Endereçamento `SIB` - Otimizações `PUSH` - Específico do Windows: `CALL/POP`, hash do `PEB`, `SALC`, aritmética `LEA`, `shifts`, strings de pilha, etc. ### RECURSOS MODERNOS x64 - **RIP-Relative Optimization**: Decomposição de deslocamento, cálculo duplo de RIP, métodos baseados em pilha - **Bit Manipulation**: Reordenação de bytes BSWAP, construção de potência de 2 com BSF/BSR, contagem de bits POPCNT, PEXT/PDEP BMI2 - **Flag Accumulation**: Eliminação de salto condicional baseada em SETcc com operações lineares de flags ### MELHORIA DE OFUSCAÇÃO - **Multi-Byte NOP Interlacing**: NOPs aritméticos, rotação de registradores, NOPs condicionais, operações FPU - **Register Dependency Chains**: Otimização de padrões multi-instrução, reordenação de instruções - **Negative Displacement Addressing**: Ajustes de registrador base, modos de endereçamento alternativos ### MEMÓRIA/DESLOCAMENTO - Tratamento de deslocamento nulo - Alternativas `LEA` As estratégias são priorizadas e selecionadas via ML ou ordem determinística O registro modular permite fácil adição de novas estratégias para lidar com padrões emergentes de shellcode. Veja [DENULL_STRATS](https://github.com/umpolungfish/byvalver/blob/main/docs/DENULL_STRATS.md) para documentação detalhada da estratégia. ## TREINAMENTO E VALIDAÇÃO DE ML ### TREINAMENTO Construir treinador: `make train` Executar: `./bin/train_model` - Dados: `./shellcodes/` - Saída: `./ml_models/byvalver_ml_model.bin` - Configuração: 10k amostras, 50 épocas, 20% validação, LR 0.001, batch 32 Modelo carregado automaticamente em tempo de execução com resolução de caminho. ### TESTANDO MODO ML```bash # Smoke test ./bin/byvalver --ml shellcodes/linux_x86/execve.bin output.bin # Check registry initialization ./bin/byvalver --ml test.bin output.bin 2>&1 | grep "ML Registry" # Expected: "ML Registry] Initialized with XXX strategies" # Batch processing with learning ./bin/byvalver --ml --batch shellcodes/linux_x86/*.bin output/ # View metrics cat ml_metrics.log

O pipeline foi validado com **DeepSeek** (`deepseek-chat`) e **Anthropic** (`claude-sonnet-4-6`). Em uma execução típica, descobre 340+ estratégias, propõe uma técnica (ex.: re-codificação do prefixo VEX para instruções SSE/AVX), gera ~200 linhas de C e produz uma compilação limpa — totalmente sem supervisão. Consulte [docs/AGENT_MENAGERIE.md](https://github.com/umpolungfish/byvalver/blob/main/docs/AGENT_MENAGERIE.md) para detalhes da arquitetura e extensão do pipeline com novos agentes. ## DESENVOLVIMENTO - `C` moderno com modularidade - Suíte de testes: `bash tests/run_tests.sh` (veja [tests/README.md](https://github.com/umpolungfish/byvalver/blob/main/tests/README.md)) - Estilo de código: Clang-Format (config: [.clang-format](https://github.com/umpolungfish/byvalver/blob/main/.clang-format)), execute `make format` - Análise: Cppcheck, Valgrind - Docker: `docker build -t byvalver .` (veja [Dockerfile](https://github.com/umpolungfish/byvalver/blob/main/Dockerfile)) - Contribuição: Veja [CONTRIBUTING.md](https://github.com/umpolungfish/byvalver/blob/main/CONTRIBUTING.md) - Roteiro: Veja [ROADMAP.md](https://github.com/umpolungfish/byvalver/blob/main/ROADMAP.md) ## DOCUMENTAÇÃO A documentação completa está disponível no diretório [docs/](https://github.com/umpolungfish/byvalver/blob/main/docs): | Document | Descrição | |---|---| | [docs/USAGE.md](https://github.com/umpolungfish/byvalver/blob/main/docs/USAGE.md) | Guia de uso abrangente com exemplos | | [docs/BUILD.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BUILD.md) | Instruções de compilação e notas específicas de plataforma | | [docs/TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/docs/TUI_README.md) | Documentação interativa do TUI | | [docs/DENULL_STRATS.md](https://github.com/umpolungfish/byvalver/blob/main/docs/DENULL_STRATS.md) | Catálogo de estratégias de denulificação | | [docs/OBFUSCATION_STRATS.md](https://github.com/umpolungfish/byvalver/blob/main/docs/OBFUSCATION_STRATS.md) | Documentação de técnicas de ofuscação | | [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md) | Referência de perfis de bytes ruins | | [docs/BADBYTEELIM_STRATS.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BADBYTEELIM_STRATS.md) | Estratégias de eliminação estendidas | | [docs/STRATEGY_HIERARCHY.md](https://github.com/umpolungfish/byvalver/blob/main/docs/STRATEGY_HIERARCHY.md) | Organização e prioridade de estratégias | | [docs/ADVANCED_STRATEGIES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/ADVANCED_STRATEGIES.md) | Técnicas avançadas de transformação | | [docs/WHITEPAPER.md](https://github.com/umpolungfish/byvalver/blob/main/docs/WHITEPAPER.md) | Whitepaper técnico | | [docs/AGENT_MENAGERIE.md](https://github.com/umpolungfish/byvalver/blob/main/docs/AGENT_MENAGERIE.md) | Pipeline de agentes: geração automática de técnicas | ## SOLUÇÃO DE PROBLEMAS - Dependências: Verifique `Capstone`/`NASM`/xxd - Compilações: Verifique PATH_MAX, cabeçalhos - ML: Certifique-se do caminho do modelo - Nulos: Confirme o formato de entrada, dependências Para problemas persistentes, use o modo verbose e verifique os logs Se a eliminação de bytes ruins falhar em shellcode específico, considere adicionar estratégias direcionadas ao registro. ## LICENÇA `byvalver` é disponibilizado livremente sobre a Terra sob a [UNLICENSE](https://github.com/umpolungfish/byvalver/blob/main/UNLICENSE). </DOCUMENT>

Arquitetura	Maturidade	Estratégias	Observações
x86 (32-bit Intel/AMD)	Estável v4.2	150+	Testado em produção, cobertura total
x64 (64-bit Intel/AMD)	Estável v4.2	150+	Arquitetura padrão, testado em produção
ARM (32-bit)	Experimental v0.1	7 essenciais	Testes limitados, apenas instruções básicas
ARM64 (AArch64)	Experimental v0.1	Básicas	Estrutura pronta, estratégias mínimas

byvalver

Mais Populares

byvalver (·𐑚𐑲𐑝𐑨𐑤𐑝𐑼)

Índice

Visão Geral

BANIMENTO DE BYTES RUINS EM AÇÃO

INÍCIO RÁPIDO

INSTALAÇÃO

Uso Básico

banish null bytes and newlines

VERIFICAÇÃO

Check for remaining bad bytes

Verify functional equivalence

TUI INTERATIVA

CONFIGURAÇÃO DE BYTE INVÁLIDO:

NAVEGAÇÃO:

REQUISITOS:

Ubuntu/Debian

CentOS/RHEL/Fedora

macOS (with Homebrew)

EXEMPLOS DE PERFIL

Visualizar resultados

Uso

Contribuindo

CAMADA DE OFUSCAÇÃO

SELEÇÃO DE ESTRATÉGIA COM ML

PROCESSAMENTO EM LOTE

Suíte de Verificação

Arquitetura

Requisitos de Sistema

Dependências

Comandos de Instalação

CORREÇÕES DE BUILD NO macOS/Homebrew (ALTERAÇÕES NO REPO)

SOLUÇÃO DE PROBLEMAS (macOS)```bash

Verify xxd is available (macOS usually ships /usr/bin/xxd)

Verify Capstone is discoverable via pkg-config

Clean rebuild

INSTALAÇÃO

Default: banish null bytes only (well-tested, recommended)

v3.0 NEW: List available bad-byte profiles

v3.0 NEW: Use predefined profile for HTTP contexts (eliminates 0x00, 0x0A, 0x0D)

v3.0 NEW: Use profile for SQL injection contexts

v3.0 NEW: Use profile for URL-safe shellcode

v3.0 NEW: Manual bad-byte specification (experimental - not extensively tested)

Combined with other features

Batch processing with profile

Launch interactive TUI mode

MENAGERIE DE AGENTES

INÍCIO RÁPIDO```bash

Requires API key for your chosen provider

--- Specialized Generators ---

1. General Technique Generator (discover → propose → generate → implement)

2. Obfuscation Technique Generator (specifically for anti-analysis/evasion)

3. Bad-Byte Removal Generator (targeting restricted byte elimination)

4. Profile-Specific Strategy Generator (targeting a specific bad-byte profile)

--- Common Options ---

Dry-run: discover and propose only, no files written

Target a specific architecture

Use a different provider / model

REQUISITOS```bash

Install Python dependencies (uses AjintK framework)

Or with uv (faster)