Vérifier votre obfuscation .NET en CI
Une compilation au vert ne prouve pas que votre assembly .NET est protégé. Nebula.NET 2.2.0 émet un rapport de protection stable et versionné à chaque compilation et fournit `nebula verify`, une barrière de CI qui fait échouer la compilation avec un code de sortie dédié lorsque le renommage, le chiffrement de chaînes, le contrôle de flux ou la virtualisation demandés ne se sont pas appliqués silencieusement.
Votre pipeline de publication est au vert. L’étape d’obfuscation s’est exécutée, n’a imprimé aucune erreur et le paquet signé se trouve dans votre dépôt d’artefacts. Le code est donc protégé, non ?
Une compilation réussie prouve seulement que l’obfuscateur n’a pas planté. Elle ne dit rien sur le durcissement réel de la sortie. Une règle keep avec un glob de trop, une fonctionnalité non activée dans votre édition, une clé de configuration mal orthographiée ou une entrée déjà traitée produiront toutes un code de sortie propre et un assembly grand ouvert. C’est le repli silencieux vers aucune protection et, comme rien n’échoue, il survit jusqu’en production.
Nebula.NET 2.2.0 comble cette lacune avec deux choses qui ont leur place dans tout pipeline : un rapport de protection émis à chaque compilation et nebula verify, une barrière qui fait échouer la compilation quand les transformations demandées ne se sont pas appliquées.
Le rapport de protection
Chaque compilation de Nebula.NET peut émettre un résumé lisible par machine de ce qu’elle a réellement fait. C’est du JSON brut avec un schéma versionné et stable, vous pouvez donc l’analyser, l’archiver et le comparer d’une compilation à l’autre sans craindre que la prochaine version réorganise les champs.
Activez-le dans votre nebula.json :
{
"obfuscate": true,
"rename": true,
"stringEncryption": true,
"controlFlow": true,
"report": {
"enabled": true,
"path": "artifacts/nebula-report.json"
}
}
Ou demandez-le en ligne de commande, ce qui remplace la configuration et s’avère pratique en CI :
nebula protect MyApp.dll --report artifacts/nebula-report.json
Voici un extrait réel d’un rapport pour une compilation 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"
]
}
Comment le lire
Une poignée de champs vous disent presque tout :
transforms[].requestedface àapplied— la comparaison la plus importante. Si vous avez demandécontrolFlowet queappliedvautfalse, votre aplatissement n’a pas eu lieu. C’est le champ sur lequel s’appuienebula verify.summary.renameRatio— la fraction de membres éligibles qui ont été renommés. Une compilation de bibliothèque saine se situe dans le haut des 0,9. Si elle tombe à, disons, 0,4, une règle keep exclut bien plus que vous ne le vouliez.summary.residualPublicTypes/residualPublicSurface— l’API publique que vous avez délibérément laissée lisible, parce que les appelants s’y lient. Ce devrait être une liste courte et familière : vos contrats de plugin, vos points d’entrée publics. Si un type que vous attendiez caché apparaît ici, c’est qu’il est atteignable via votre surface publique et a été ignoré à dessein — un signal pour resserrer vos règles keep.output.mvid— le Module Version ID de l’assembly produit. Comme il change à chaque réécriture réelle, c’est un contrôle d’altération et de fraîcheur bon marché : siinput.mvidégaleoutput.mvid, rien n’a été réécrit du tout.
En Pro et Enterprise, chaque transformation porte en plus une ventilation par type (quels types ont été aplatis, quelles méthodes ont été virtualisées), pour que vous puissiez confirmer que vos méthodes les plus sensibles en particulier ont été couvertes au lieu de vous fier à un décompte agrégé. Toutes les éditions émettent le résumé et les résultats de transformation de premier niveau.
nebula verify — la barrière de CI
Lire le rapport à l’œil, c’est bien une fois. Dans un pipeline, vous voulez qu’une machine le fasse à chaque compilation et arrête la chaîne dès que quelque chose cloche. C’est à cela que sert nebula verify.
Pointez-le vers l’assembly de sortie (ou directement vers le rapport). Il compare les transformations demandées à celles appliquées et se termine avec un code non nul si une transformation demandée ne s’est pas appliquée :
nebula verify MyApp.dll --report artifacts/nebula-report.json
Les codes de sortie sont stables et scriptables :
| Code de sortie | Signification |
|---|---|
0 | Toutes les transformations demandées ont été appliquées. Réussite. |
3 | Au moins une transformation demandée ne s’est pas appliquée. Échec. |
1 | Erreur d’utilisation ou d’E/S (fichier manquant, rapport illisible). |
Le code de sortie 3 est dédié au seul échec qui vous importe vraiment — « vous avez demandé de la protection et ne l’avez pas obtenue » — afin de distinguer une vraie régression de protection d’une invocation cassée.
Vous pouvez aussi exiger des transformations précises indépendamment de ce que la configuration a demandé, utile lorsqu’un profil de compilation doit inclure une couche donnée :
nebula verify MyApp.dll --require rename,stringEncryption,controlFlow
Le brancher dans un pipeline
Dans une étape de CI basée sur le shell, la barrière tient en une ligne : set -e et une sortie non nulle font le reste :
# 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
Vous préférez MSBuild ? Faites de la barrière une partie du graphe de compilation pour qu’une transformation ignorée fasse échouer dotnet build :
<Target Name="VerifyProtection" AfterTargets="Nebula">
<Exec Command="nebula verify "$(TargetPath)" --report "$(OutDir)nebula-report.json"" />
</Target>
Comme Exec fait échouer la cible sur un code de sortie non nul, une sortie 3 de verify arrête la compilation avec le reste de votre pipeline.
Archivez-le, puis comparez-le
Le rapport prouve sa valeur avec le temps. Téléversez nebula-report.json comme artefact de compilation à chaque exécution et vous obtenez un historique de protection que vous pouvez comparer :
# Échoue si cette compilation a renommé bien moins de membres que la dernière au vert.
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) }'
Une comparaison d’une compilation à l’autre attrape les régressions lentes que verify seul ne peut pas : une règle keep que quelqu’un a élargie le mois dernier, un nouveau type public qui a silencieusement agrandi votre surface résiduelle, une transformation qui s’applique encore mais couvre désormais 60 % des méthodes au lieu de 95 %. Que la transformation se soit appliquée ou non est une question de oui ou non ; les ratios sont une tendance, et les tendances sont là où la protection s’érode en silence.
Une barrière de plus : nebula doctor
La plupart des échecs de repli silencieux remontent à une règle keep trop large. nebula doctor analyse votre configuration face à l’assembly et signale les règles qui correspondent à bien plus qu’elles ne le devraient probablement :
nebula doctor MyApp.dll
Il vous dira, par exemple, que keep: MyApp.* maintient 400 types sur 412 lisibles — presque certainement pas ce que vous vouliez quand vous ne souhaitiez préserver qu’un contrat de plugin. Exécutez-le quand renameRatio paraît bas ou que residualPublicSurface est plus longue que prévu ; il transforme « pourquoi ceci n’est-il pas renommé ? » en une réponse directe.
À retenir
Une obfuscation qui s’exécute mais ne s’applique pas est pire qu’aucune obfuscation, car elle est livrée avec un faux sentiment de sécurité. Nebula.NET 2.2.0 rend cet échec impossible à manquer : émettez le rapport de protection à chaque compilation pour voir exactement ce qui s’est appliqué, exécutez nebula verify comme barrière pour qu’une transformation ignorée fasse échouer la compilation sur un code de sortie dédié, archivez et comparez le rapport pour que l’érosion lente apparaisse comme une tendance, et gardez nebula doctor sous la main quand une règle keep en fait plus que demandé. Protégez le logiciel que vous avez le droit de protéger — et prouvez, à chaque compilation, que vous l’avez réellement fait.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.