dotnet-reverse

Normas de Trabalho para Engenharia Reversa .NET / C#

AÇÃO REQUERIDA (Execute Imediatamente Após Ler)

1. AGORA: Use DIE/file/cabeçalho CLR para confirmar que o alvo é .NET gerenciado (caso contrário, MUDAR para ida-reverse/ / reverse-engineering/)
2. AGORA: Se houver suspeita de ofuscação → primeiro aplique de4dot para desofuscar, gere *-clean.exe e mantenha a amostra original
3. PRÓXIMO: dnSpyEx (ou dnSpy MCP / ilspycmd) para análise estática: navegação C# + visualização IL para lógica crítica
4. AÇÃO: Quando precisar de texto limpo/C2, use depuração dinâmica; quando precisar alterar lógica, priorize patch IL em vez de recompilação C#
5. Ao final da fase, forneça ao usuário um menu de 3–6 próximos passos (incluindo exportação de relatório)

Escopo de Aplicação

Priorize este skill quando a tarefa se enquadrar nos seguintes cenários:

• Identificar e reverter engenharia de produtos compilados .NET / C# (PE gerenciado / .exe / .dll)
• Analisar a cadeia de ferramentas Sharp* da equipe vermelha (Rubeus, SharpHound, SharpShell, etc.)
• Desofuscar shells como ConfuserEx / SmartAssembly / Babel / Eazfuscator / .NET Reactor
• Reverter a lógica de descriptografia e C2 de loaders .NET / info-stealers / RATs
• Aplicar patches em programas C# (alterar decisões, constantes, keygen)
• Analisar a camada gerenciada Mono/Unity antes da compilação IL2CPP (nota: IL2CPP compila para nativo, use reverse-engineering/ + seed-014)

Se o alvo for um binário puramente nativo (C/C++/Go/Rust, sem CLR), use reverse-engineering/, ida-reverse/ ou radare2/.

Princípios Centrais

• Identifique antes de agir: Confirme se é um programa .NET gerenciado (cabeçalho CLR no PE + fluxos #~ / #Strings + _CorExeMain do mscoree) antes de decidir usar dnSpy em vez de IDA
• IL antes de C#: O decompilador C# do dnSpyEx pode perder ou distorcer informações (máquinas de estado geradas pelo compilador, async/await, yield). Decisões críticas e patches devem ser feitos no Editor IL; a visualização C# serve apenas para navegação rápida
• de4dot primeiro: Ao encontrar um ofuscador, execute de4dot para desofuscar antes de fazer análise estática; caso contrário, strings e fluxo de controle estarão todos embaralhados
• Integração com MCP: Se o ambiente tiver dnSpy MCP registrado (ferramentas dnspy_*), priorize a interface MCP para decompile / inspeção IL, evitando alternar de GUI
• Saída baseada em evidências: O produto da desofuscação, configuração/C2/key extraídos e diff de patch devem ser salvos em disco

Mapeamento de Ferramentas

Capacidade	Preferida	Observações
Decompilação + depuração + patch	dnSpyEx	A melhor, única GUI com editor IL; o dnSpy antigo está descontinuado, use o branch Ex
Decompilação leve CLI / headless	ILSpy (ilspycmd)	Ideal para lote, script, Linux/macOS
Desofuscação	de4dot	Solução padrão para ConfuserEx, SmartAssembly e outros shells populares
Identificação de ofuscadores	Detect It Easy (DIE) / file	Primeiro identifique o tipo de shell para decidir os parâmetros do de4dot
Manipulação programática de IL	dnlib	Escreva scripts C# para modificar metadados em lote ou descriptografar strings
Operação direta por IA	dnSpy MCP	Ferramentas como dnspy_decompile / dnspy_inspect_il

Pré-requisito: Windows com dnSpyEx + de4dot instalados (choco ou release); Linux/macOS com ilspycmd + dotnet runtime. Consulte references/sharp-tools.md para a matriz de instalação.

Fluxo de Trabalho em Seis Etapas

1. Identificar (.NET)

Confirme se o alvo é um programa gerenciado; não analise um PE nativo como se fosse .NET:

# Windows
file target.exe                       # "PE32 executable ... for MS Windows" não é suficiente
# Chave: verificar se há CLR
powershell -c "[System.Reflection.AssemblyName]::GetAssemblyName('target.exe')"
# Ou
Arraste para o dnSpyEx — se abrir, é gerenciado

# Genérico
strings target.exe | grep -iE "mscoree|_CorExeMain|mscorlib|System\\."

Marcadores de identificação .NET:

• PE header Data Directory[14] (CLR Runtime Header) diferente de zero
• Importação de mscoree.dll / entrada _CorExeMain
• Fluxos de metadados #~, #Strings, #US, #GUID, #Blob
• Strings mscorlib / System.Private.CoreLib

Exceção NativeAOT: Compilado para nativo, sem cabeçalho CLR, mas contém strings System.Private.CoreLib e metadados de tipo reestruturados — estes devem usar reverse-engineering/ (IDA/r2); este skill apenas fornece dicas de identificação.

2. Detectar (ofuscador)

# Identificação rápida com DIE
diec target.exe                        # Detect It Easy CLI
# Ou arraste para o dnSpyEx e veja se há muitos nomes de classe ilegíveis / fluxo de controle deformado

Ofuscadores comuns → Estratégia de desofuscação (consulte references/obfuscators.md):

Ofuscador	Características	Processamento com de4dot
ConfuserEx (1.0.0 / 2.x)	<module> anti-tamper, fluxo de controle deformado, criptografia de strings	de4dot target.exe geralmente identifica automaticamente
SmartAssembly	Codificação circular/string, compressão de recursos	de4dot target.exe
Babel.NET	Criptografia de corpo de método, fluxo de controle	de4dot target.exe
Eazfuscator.NET	Criptografia de strings/recursos	de4dot, algumas versões podem exigir intervenção manual
.NET Reactor	anti-tamper + necrobit	de4dot, versões mais novas podem falhar e exigir trabalho manual

3. Desofuscar

# de4dot identifica automaticamente a maioria dos shells
de4dot target.exe -o target-clean.exe

# Especificar tipo (quando a identificação automática falhar)
de4dot --type cfze target.exe          # ConfuserEx
de4dot --type sa target.exe            # SmartAssembly

# Ofuscação em múltiplas camadas / de4dot reporta "unknown"
de4dot --detect target.exe             # Veja o que ele identifica
# Pode ser necessário aplicar patch anti-tamper antes do de4dot (consulte references/obfuscators.md)

Produto: target-clean.exe, use-o para análise posterior. Mantenha a amostra original para comparação.

4. Análise Estática

Carregue a amostra desofuscada no dnSpyEx:

• Visualização C#: Navegação rápida pela estrutura de classes, assinaturas de métodos, strings (para localização)
• Visualização IL: Decisões críticas, lógica de criptografia, máquinas de estado devem ser vistas em IL (clique direito → Edit IL ou visualização IL)
• Encontre a entrada: Main / Startup / Inicializador de módulo (Module .cctor)
• Encontre a lógica crítica: pesquise por flag, password, verify, check, encrypt, http, Config

Localizar string → referência reversa → encontrar o método que a usa → visualização IL para ver a lógica de decisão

5. Depuração Dinâmica

Depurador do dnSpyEx: anexar a processo / iniciar depuração, definir breakpoints em métodos críticos, observar em tempo de execução:

• Strings descriptografadas (muitos ofuscadores só descriptografam strings em tempo de execução)
• Endereços C2, resultados de descriptografia de configuração
• Fluxo de controle orientado a exceções (anti-debug costuma usar try/catch para esconder o caminho real)

A depuração dinâmica .NET é muito mais amigável que a nativa — é possível ver diretamente valores de objetos e conteúdo de strings. Prefira depuração dinâmica em vez de análise estática exaustiva.

6. Patch (conforme necessário)

dnSpyEx → clique direito no método → Edit Method (C#) ou Edit IL
  - Alterar decisão: ldc.i4.0 → ldc.i4.1 (false→true)
  - Alterar constante: editar string/número diretamente
  - Remover verificação: nop em todo o bloco
File → Save Module → Substituir o arquivo original

Confiabilidade do patch IL > patch C#: A recompilação C# pode falhar (referências ausentes, sintaxe incorreta), enquanto a edição IL raramente causa distorção. Consulte references/common-workflow.md para detalhes.

Roteamento de Cenários de Acionamento

Este skill é ativado quando o usuário menciona:

• "Engenharia reversa de binários .NET / C#" / "Decompilação de programa C#"
• "Análise com dnSpy" / "Patch com dnSpyEx"
• "Desofuscação de ConfuserEx / SmartAssembly / Babel"
• "Análise de ferramentas Sharp*" (Rubeus / SharpHound / SharpShell)
• "Reversão de malware .NET / loader / info-stealer"
• "Patch / keygen / alteração de decisão em programa C#"

Quando Sair

• Jogos Unity compilados com IL2CPP → reverse-engineering/ + seed-014_unity-il2cpp-reverse.md (IL2CPP é nativo, não usa dnSpy)
• Produtos NativeAOT → reverse-engineering/ (idem, nativo)
• PE puramente nativo (sem CLR) → reverse-engineering/ / ida-reverse/
• Necessidade de migração de símbolos/funções em lote para outra versão → binary-diff/
• Necessidade de desenhar caminho de ataque / gráfico de cadeia de chamadas → diagram-generator/

Contexto de Roteamento

Entrada upstream: skills/SKILL.md (controlador central), routing.md Saídas downstream:

• IL2CPP / NativeAOT (nativo) → reverse-engineering/
• Análise profunda de segmentos nativos .so/.dll → ida-reverse/ / radare2/
• Necessidade de operação direta por IA no dnSpy → registrar e integrar dnSpy MCP (consulte references/sharp-tools.md)

Módulos relacionados no mesmo nível:

• reverse-engineering/languages-compiled.md (introdução ao .NET redireciona para este módulo)
• apk-reverse/ (reversão Android Xamarin/MAUI pode retornar a este módulo para a camada C#)

Documentos de Referência

• references/obfuscators.md — Detalhamento de desofuscação para ConfuserEx / SmartAssembly / Babel / Eazfuscator / .NET Reactor + bypass anti-tamper
• references/common-workflow.md — Fluxo de trabalho completo, confiabilidade de patch IL, extração de descriptografia de strings, identificação de máquinas de estado
• references/sharp-tools.md — Análise de ferramentas Sharp* da equipe vermelha, matriz de instalação, integração dnSpy MCP, índice de recursos da comunidade

Checklist de Conclusão de Tarefa

• Confirmou a identidade CLR / gerenciado (ou já MUDOU para fora deste skill)?
• Amostras ofuscadas foram desofuscadas com de4dot / equivalente antes de análise profunda?
• A lógica crítica foi verificada com visualização IL (em vez de apenas pseudocódigo C#)?
• Os artefatos (amostra limpa / configuração / diff de patch) foram salvos em disco e são reproduzíveis?
• Forneceu um menu de próximos passos ou ponto de saída do relatório?