Verificar tu ofuscación .NET en CI
Una compilación en verde no prueba que tu ensamblado .NET esté protegido. Nebula.NET 2.2.0 emite un informe de protección estable y versionado en cada compilación e incluye `nebula verify`, una barrera de CI que falla la compilación con un código de salida dedicado cuando el renombrado, el cifrado de cadenas, el control de flujo o la virtualización que pediste no se aplicaron de forma silenciosa.
Tu canalización de publicación está en verde. El paso de ofuscación se ejecutó, no imprimió ningún error y el paquete firmado está en tu almacén de artefactos. Entonces el código está protegido, ¿verdad?
Una compilación con éxito solo prueba que el ofuscador no se bloqueó. No dice nada sobre si la salida está realmente endurecida. Una regla keep con un glob de más, una función que no está habilitada en tu edición, una clave de configuración mal escrita o una entrada que ya había sido procesada producirán todas un código de salida limpio y un ensamblado completamente abierto. Este es el repliegue silencioso a ninguna protección y, como nada falla, sobrevive hasta producción.
Nebula.NET 2.2.0 cierra esa brecha con dos cosas que deberían estar en toda canalización: un informe de protección emitido en cada compilación y nebula verify, una barrera que falla la compilación cuando las transformaciones que pediste no se aplicaron.
El informe de protección
Cada compilación de Nebula.NET puede emitir un resumen legible por máquina de lo que realmente hizo. Es JSON plano con un esquema versionado y estable, así que puedes analizarlo, archivarlo y compararlo entre compilaciones sin temer que la siguiente versión reordene los campos.
Actívalo en tu nebula.json:
{
"obfuscate": true,
"rename": true,
"stringEncryption": true,
"controlFlow": true,
"report": {
"enabled": true,
"path": "artifacts/nebula-report.json"
}
}
O pídelo en la línea de comandos, que anula la configuración y resulta cómodo en CI:
nebula protect MyApp.dll --report artifacts/nebula-report.json
Aquí tienes un extracto real de un informe de una compilación Pro:
{
"schemaVersion": "1.0",
"tool": { "name": "Nebula.NET", "version": "2.2.0", "edition": "Pro" },
"input": { "assembly": "MyApp.dll", "mvid": "2f1c8e0a-7b44-4d2e-9a6b-1e5d0c3f9a21" },
"output": { "assembly": "MyApp.dll", "mvid": "b9d4e7c2-0a31-4f88-ae10-6c2f7b4d1e90" },
"summary": {
"typesTotal": 412,
"methodsTotal": 3187,
"renamedMembers": 3904,
"renameRatio": 0.97,
"residualPublicTypes": 12
},
"transforms": [
{ "name": "rename", "requested": true, "applied": true, "typesAffected": 400, "methodsAffected": 3090 },
{ "name": "stringEncryption", "requested": true, "applied": true, "stringsEncrypted": 1884 },
{ "name": "controlFlow", "requested": true, "applied": true, "methodsAffected": 2731 },
{ "name": "virtualization", "requested": false, "applied": false }
],
"residualPublicSurface": [
"MyApp.PluginContract",
"MyApp.PluginContract.IPlugin",
"MyApp.Api.HealthController"
]
}
Cómo leerlo
Unos pocos campos te cuentan casi todo:
transforms[].requestedfrente aapplied— la comparación más importante. Si pedistecontrolFlowyappliedesfalse, tu aplanamiento no ocurrió. Este es el campo sobre el que se apoyanebula verify.summary.renameRatio— la fracción de miembros elegibles que se renombraron. Una compilación de biblioteca saludable se sitúa en el rango alto de 0,9. Si cae a, digamos, 0,4, una regla keep está excluyendo mucho más de lo que pretendías.summary.residualPublicTypes/residualPublicSurface— la API pública que dejaste legible de forma deliberada, porque las personas que llaman se enlazan a ella. Debería ser una lista corta y conocida: tus contratos de plugin, tus puntos de entrada públicos. Si un tipo que esperabas ocultar aparece aquí, es alcanzable a través de tu superficie pública y se omitió a propósito, una señal para ajustar tus reglas keep.output.mvid— el Module Version ID del ensamblado producido. Como cambia en cada reescritura real, es una comprobación barata de manipulación y frescura: siinput.mvides igual aoutput.mvid, no se reescribió nada en absoluto.
En Pro y Enterprise, cada transformación lleva además un desglose por tipo (qué tipos se aplanaron, qué métodos se virtualizaron), para que puedas confirmar que tus métodos más sensibles en concreto quedaron cubiertos en lugar de fiarte de un recuento agregado. Todas las ediciones emiten el resumen y los resultados de transformación de nivel superior.
nebula verify — la barrera de CI
Leer el informe a ojo está bien una vez. En una canalización quieres que una máquina lo haga en cada compilación y detenga la línea cuando algo esté mal. Para eso está nebula verify.
Apúntalo al ensamblado de salida (o directamente al informe). Compara las transformaciones solicitadas con las aplicadas y termina con un código distinto de cero si alguna transformación solicitada no se aplicó:
nebula verify MyApp.dll --report artifacts/nebula-report.json
Los códigos de salida son estables y aptos para scripts:
| Código de salida | Significado |
|---|---|
0 | Todas las transformaciones solicitadas se aplicaron. Pasa. |
3 | Al menos una transformación solicitada no se aplicó. Falla. |
1 | Error de uso o de E/S (archivo ausente, informe ilegible). |
El código de salida 3 está dedicado al único fallo que de verdad te importa — «pediste protección y no la obtuviste» — así que puedes distinguir una regresión real de protección de una invocación rota.
También puedes exigir transformaciones concretas con independencia de lo que pidiera la configuración, útil cuando un perfil de compilación debe incluir una capa dada:
nebula verify MyApp.dll --require rename,stringEncryption,controlFlow
Conectarlo a una canalización
En un paso de CI basado en shell, la barrera es una sola línea: set -e y una salida distinta de cero hacen el resto:
# GitHub Actions
- name: Harden and verify
run: |
nebula protect src/bin/Release/net8.0/MyApp.dll \
--report artifacts/nebula-report.json
nebula verify src/bin/Release/net8.0/MyApp.dll \
--report artifacts/nebula-report.json
- name: Archive protection report
uses: actions/upload-artifact@v4
with:
name: nebula-report
path: artifacts/nebula-report.json
¿Prefieres MSBuild? Haz que la barrera forme parte del grafo de compilación para que una transformación omitida falle dotnet build:
<Target Name="VerifyProtection" AfterTargets="Nebula">
<Exec Command="nebula verify "$(TargetPath)" --report "$(OutDir)nebula-report.json"" />
</Target>
Como Exec falla el objetivo ante un código de salida distinto de cero, una salida 3 de verify detiene la compilación junto con el resto de tu canalización.
Archívalo y luego compáralo
El informe demuestra su valor con el tiempo. Sube nebula-report.json como artefacto de compilación en cada ejecución y obtendrás un historial de protección que puedes comparar:
# Falla si esta compilación renombró muchos menos miembros que la última en verde.
prev=$(jq '.summary.renameRatio' baseline-report.json)
curr=$(jq '.summary.renameRatio' artifacts/nebula-report.json)
awk -v p="$prev" -v c="$curr" 'BEGIN { exit !(c >= p - 0.05) }'
Una comparación entre compilaciones atrapa las regresiones lentas que verify por sí solo no puede: una regla keep que alguien amplió el mes pasado, un nuevo tipo público que agrandó en silencio tu superficie residual, una transformación que todavía se aplica pero ahora cubre el 60 % de los métodos en lugar del 95 %. Si la transformación se aplicó o no es una pregunta de sí o no; las proporciones son una tendencia, y las tendencias son donde la protección se erosiona en silencio.
Una barrera más: nebula doctor
La mayoría de los fallos de repliegue silencioso se remontan a una regla keep demasiado amplia. nebula doctor analiza tu configuración frente al ensamblado y señala las reglas que coinciden con mucho más de lo que probablemente deberían:
nebula doctor MyApp.dll
Te dirá, por ejemplo, que keep: MyApp.* está dejando legibles 400 de 412 tipos, algo que casi con seguridad no pretendías cuando solo querías preservar un contrato de plugin. Ejecútalo cuando renameRatio parezca bajo o residualPublicSurface sea más larga de lo que esperabas; convierte «¿por qué no se renombra esto?» en una respuesta directa.
Conclusión
La ofuscación que se ejecuta pero no se aplica es peor que ninguna ofuscación, porque se publica con una falsa sensación de seguridad. Nebula.NET 2.2.0 hace que ese fallo sea imposible de pasar por alto: emite el informe de protección en cada compilación para ver exactamente qué se aplicó, ejecuta nebula verify como barrera para que una transformación omitida falle la compilación con un código de salida dedicado, archiva y compara el informe para que la erosión lenta aparezca como tendencia, y ten a mano nebula doctor cuando una regla keep haga más de lo que pediste. Protege el software que tienes derecho a proteger, y demuestra, en cada compilación, que de verdad lo hiciste.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.