dotnet-reverse

Especificaciones de Ingeniería Inversa .NET / C#

ACCIÓN REQUERIDA (Ejecutar inmediatamente después de leer)

1. AHORA: Usa DIE/file/cabecera CLR para confirmar que el objetivo es .NET administrado (si no, CAMBIA a ida-reverse/ / reverse-engineering/)
2. AHORA: Si se sospecha ofuscación → ejecuta de4dot para desempaquetar, generando *-clean.exe, conservando la muestra original
3. SIGUIENTE: dnSpyEx (o dnSpy MCP / ilspycmd) estático: navegación C# + vista IL para ver las decisiones clave
4. ACTUAR: Si se necesita texto plano/C2, depuración dinámica; si se necesita cambiar la lógica, parche IL prioritario sobre recompilación C#
5. Al final de cada fase, proporciona un menú de 3 a 6 opciones al usuario (incluyendo exportar informe)

Ámbito de aplicación

Usa esta habilidad preferentemente cuando la tarea pertenezca a los siguientes escenarios:

• Identificar e ingeniería inversa de artefactos compilados .NET / C# (PE administrado / .exe / .dll)
• Analizar la cadena de herramientas Sharp* del equipo rojo (Rubeus, SharpHound, SharpShell, etc.)
• Desofuscar shells como ConfuserEx / SmartAssembly / Babel / Eazfuscator / .NET Reactor, etc.
• Ingeniería inversa de la lógica de descifrado y C2 de .NET loader / info-stealer / RAT
• Parchear programas C# (cambiar decisiones, constantes, keygen)
• Analizar la capa administrada Mono/Unity anterior a IL2CPP (Nota: después de la compilación IL2CPP es nativo, ve a reverse-engineering/ + seed-014)

Si el objetivo es un binario puramente nativo (C/C++/Go/Rust compilado, sin CLR), usa en su lugar reverse-engineering/, ida-reverse/ o radare2/.

Principios fundamentales

• Identificar antes de actuar: Confirma que es un programa .NET administrado (cabecera PE CLR + flujos #~ / #Strings + mscoree _CorExeMain), luego decide usar dnSpy en lugar de IDA
• IL antes que C#: El descompilador C# de dnSpyEx puede perder/distorsionar información (máquinas de estado generadas por el compilador, async/await, yield). Las decisiones clave y los parches deben realizarse en el editor IL; la vista C# solo se usa para navegación rápida
• de4dot primero: Ante un ofuscador, ejecuta primero de4dot para desempaquetar antes del análisis estático, de lo contrario las cadenas y el flujo de control estarán desordenados
• Integración MCP: Si el entorno tiene registrado dnSpy MCP (herramientas dnspy_*), prioriza la interfaz MCP para decompile / inspección IL, evitando cambiar de GUI constantemente
• Salida basada en evidencia: Los artefactos desofuscados, configuraciones/C2/key extraídos y los diffs de parches deben guardarse en disco

Mapa de herramientas

Capacidad	Opción preferida	Notas
Decompilación + depuración + parche	dnSpyEx	El mejor, única GUI con editor IL; el viejo dnSpy está descontinuado, usa la rama Ex
Decompilación CLI ligera / headless	ILSpy (ilspycmd)	Adecuado para lotes, scripting, Linux/macOS
Desofuscación	de4dot	Solución por defecto para ConfuserEx, SmartAssembly y otros shells principales
Identificación de ofuscador	Detect It Easy (DIE) / file	Primero determina el tipo de shell antes de decidir los parámetros de de4dot
Manipulación programática de IL	dnlib	Escribe scripts C# para modificar metadatos por lotes / descifradores de cadenas
Operación directa por IA	dnSpy MCP	Herramientas como dnspy_decompile / dnspy_inspect_il, etc.

Requisitos previos: Host Windows con dnSpyEx + de4dot instalados (choco o release); Linux/macOS usa ilspycmd + dotnet runtime. Consulta references/sharp-tools.md para la matriz de instalación.

Flujo de trabajo en seis fases

1. Identificar (.NET)

Confirma que el objetivo es un programa administrado, no analices un PE nativo como .NET:

# Windows
file target.exe                       # "PE32 executable ... for MS Windows" no es suficiente
# Clave: comprueba si tiene CLR
powershell -c "[System.Reflection.AssemblyName]::GetAssemblyName('target.exe')"
# o
arrastra directamente a dnSpyEx — si se abre, es administrado

# General
strings target.exe | grep -iE "mscoree|_CorExeMain|mscorlib|System\\."

Indicadores de identificación .NET:

• Data Directory[14] (CLR Runtime Header) de la cabecera PE no es cero
• Importación de mscoree.dll / entrada _CorExeMain
• Flujos de metadatos #~, #Strings, #US, #GUID, #Blob
• Cadenas mscorlib / System.Private.CoreLib

Excepción NativeAOT: Compilado a nativo, sin cabecera CLR, pero tiene cadenas System.Private.CoreLib y metadatos de tipo reestructurados — estos van a reverse-engineering/ (IDA/r2), esta habilidad solo proporciona una indicación de identificación.

2. Detectar (ofuscador)

# Identificación rápida con DIE
diec target.exe                        # Detect It Easy CLI
# o arrastra a dnSpyEx, mira si hay muchos nombres de clase basura / flujo de control deformado

Ofuscadores comunes → Estrategia de desempaquetado (consulta references/obfuscators.md para más detalles):

Ofuscador	Características	Procesamiento con de4dot
ConfuserEx (1.0.0 / 2.x)	<module> anti-tamper, flujo de control deformado, cifrado de cadenas	de4dot target.exe normalmente lo identifica automáticamente
SmartAssembly	circular/string encoding, compresión de recursos	de4dot target.exe
Babel.NET	Cifrado de cuerpos de método, flujo de control	de4dot target.exe
Eazfuscator.NET	Cifrado de cadenas/recursos	de4dot, algunas versiones pueden requerir intervención manual
.NET Reactor	anti-tamper + necrobit	de4dot, versiones nuevas pueden fallar y requerir intervención manual

3. Desofuscar

# de4dot identifica automáticamente la mayoría de los shells por defecto
de4dot target.exe -o target-clean.exe

# Especificar tipo (cuando la identificación automática falla)
de4dot --type cfze target.exe          # ConfuserEx
de4dot --type sa target.exe            # SmartAssembly

# Ofuscación múltiple / de4dot reporta unknown
de4dot --detect target.exe             # Mira a qué lo identifica
# Puede ser necesario parchear anti-tamper primero y luego ejecutar de4dot (consulta references/obfuscators.md)

Salida: target-clean.exe. Usa este para el análisis posterior. Conserva la muestra original para comparación.

4. Analizar estáticamente

Carga la muestra desempaquetada en dnSpyEx:

• Vista C#: Navegación rápida por la estructura de clases, firmas de métodos, cadenas (para localizar)
• Vista IL: Las decisiones clave, la lógica de cifrado y las máquinas de estado deben verse en IL (clic derecho → Edit IL o vista IL)
• Busca la entrada: Main / Startup / inicializador de módulo (Module .cctor)
• Busca lógica clave: busca flag, password, verify, check, encrypt, http, Config

Localizar cadena → Referencia inversa → Encontrar el método que la usa → Vista IL para ver la lógica de decisión

5. Depurar dinámicamente

Depurador de dnSpyEx: Adjuntar a proceso / Iniciar depuración, establecer puntos de interrupción en métodos clave, observar en tiempo de ejecución:

• Cadenas de texto plano descifradas (muchos ofuscadores descifran las cadenas solo en tiempo de ejecución)
• Direcciones C2, resultados de descifrado de configuración
• Flujo de control impulsado por excepciones (común en anti-debug usando try/catch para ocultar la ruta real)

La depuración dinámica de .NET es mucho más amigable que la nativa — se pueden ver directamente los valores de los objetos y el contenido de las cadenas. Prioriza la depuración dinámica sobre el análisis estático cuando sea posible.

6. Parchear (según sea necesario)

dnSpyEx → Clic derecho en método → Edit Method (C#) o Edit IL
  - Cambiar decisión: ldc.i4.0 → ldc.i4.1 (false→true)
  - Cambiar constante: editar directamente cadena/número
  - Eliminar verificación: nop en todo el bloque
File → Save Module → Reemplazar archivo original

Fiabilidad del parche IL > parche C#: La recompilación C# puede fallar (falta de referencias, sintaxis incorrecta), la edición IL casi nunca distorsiona. Consulta references/common-workflow.md para más detalles.

Enrutamiento de escenarios de activación

Cuando el usuario diga estas cosas, entra en esta habilidad:

• "Ingeniería inversa de binarios .NET / C#" / "Decompilación de programa C#"
• "Análisis con dnSpy" / "Parche con dnSpyEx"
• "Desofuscación / Desempaquetado de ConfuserEx / SmartAssembly / Babel"
• "Análisis de herramientas Sharp*" (Rubeus / SharpHound / SharpShell)
• "Ingeniería inversa de malware / loader / info-stealer .NET"
• "Parche / keygen / modificación de decisión de programa C#"

Cuándo salir

• Juegos Unity compilados con IL2CPP → reverse-engineering/ + seed-014_unity-il2cpp-reverse.md (IL2CPP es nativo, no usa dnSpy)
• Artefactos NativeAOT → reverse-engineering/ (ídem, nativo)
• PE puramente nativo (sin CLR) → reverse-engineering/ / ida-reverse/
• Necesidad de migración masiva de símbolos/funciones a otra versión → binary-diff/
• Necesidad de dibujar ruta de ataque / gráfico de cadena de llamadas → diagram-generator/

Contexto de enrutamiento

Entrada ascendente: skills/SKILL.md (controlador general), routing.md Salida descendente:

• IL2CPP / NativeAOT (nativo) → reverse-engineering/
• Análisis profundo de segmentos .so/.dll nativos → ida-reverse/ / radare2/
• Necesidad de que la IA opere directamente dnSpy → Registrar e integrar dnSpy MCP (consulta references/sharp-tools.md)

Módulos relacionados del mismo nivel:

• reverse-engineering/languages-compiled.md (Introducción a .NET que redirige a este módulo)
• apk-reverse/ (La ingeniería inversa de Android en Xamarin/MAUI puede volver a este módulo para ver la capa C#)

Documentación de referencia

• references/obfuscators.md — Detalles de desofuscación de ConfuserEx / SmartAssembly / Babel / Eazfuscator / .NET Reactor + evasión de anti-tamper
• references/common-workflow.md — Flujo de trabajo completo, fiabilidad del parche IL, extracción de descifradores de cadenas, identificación de máquinas de estado
• references/sharp-tools.md — Análisis de herramientas Sharp* del equipo rojo, matriz de instalación de herramientas, integración con dnSpy MCP, índice de recursos de la comunidad

Lista de verificación de finalización de tarea

• ¿Se ha confirmado la identidad CLR / administrada (o se ha CAMBIADO fuera de esta habilidad)?
• ¿Se ha desofuscado la muestra ofuscada con de4dot / equivalente antes del análisis profundo?
• ¿Se ha verificado la lógica clave con la vista IL (en lugar de solo mirar el pseudocódigo C#)?
• ¿Los artefactos (muestra limpia / configuración / diff de parche) se han guardado en disco y son reproducibles?
• ¿Se ha proporcionado un menú de siguientes pasos o un punto de salida de informe?