Respecter l'ordre entre ReadyToRun et l'obfuscation
Une compilation ReadyToRun est une image double : votre IL plus une copie native de celui-ci, compilée par crossgen à partir de l'état de l'IL au moment de la publication. Obfusquez après crossgen et cette copie native est un enregistrement propre et indépendant de tout décompilateur de votre logique d'origine ; elle invalide aussi l'image R2R, si bien que le runtime retombe silencieusement sur le JIT. Voici pourquoi l'ordre décide de tout, et comment brancher Nebula pour que crossgen compile un IL protégé.
La plupart des conseils de protection .NET traitent l’obfuscation et la publication comme deux étapes indépendantes que l’on peut mener dans n’importe quel ordre. Pour une compilation ordinaire dépendante du framework, c’est à peu près vrai. Pour une compilation ReadyToRun, ça ne l’est pas — et se tromper d’ordre produit un artefact livré qui fuite précisément la logique que vous avez obfusquée, tout en jetant silencieusement le gain de démarrage pour lequel vous aviez activé R2R.
La raison est structurelle, pas un bug : un assembly ReadyToRun n’est pas une représentation de votre code, il en est deux. L’obfuscation n’en touche jamais qu’une seule. Cet article explique laquelle, pourquoi la seconde copie est compilée à partir de l’état de la première au moment où crossgen s’est exécuté, et comment séquencer Nebula.NET pour que les deux copies finissent protégées.
Ce que produit réellement une compilation ReadyToRun
PublishReadyToRun=true exécute le compilateur crossgen2 pendant dotnet publish. Crossgen lit les assemblys managés et, pour chaque méthode, émet du code machine natif de façon anticipée, en l’incorporant dans l’assembly aux côtés d’un en-tête ReadyToRun. L’objectif est un démarrage plus rapide : le runtime peut exécuter le code natif précompilé au lieu de compiler la méthode avec le JIT au premier appel.
Le fait crucial — celui dont dépend toute la question de l’ordre — est que ReadyToRun n’est pas Native AOT. Il ne supprime pas votre IL. L’assembly publié reste un assembly .NET tout à fait ordinaire : métadonnées complètes, IL complet, corps de méthodes managés complets, plus une section de code natif qui duplique les méthodes chaudes. L’IL demeure parce qu’il est le repli faisant autorité. Si l’image R2R n’est pas valide pour le runtime courant — mauvaise architecture, désaccord de bulle de version, module modifié — le CLR écarte le code natif et compile au JIT à partir de l’IL. R2R est une optimisation superposée à votre assembly, jamais un substitut de celui-ci.
Ainsi, après une publication ReadyToRun, vous livrez deux encodages indépendants de chaque méthode précompilée :
- le corps de méthode IL, qu’un décompilateur retransforme en C# quasi original, et
- la compilation native de cette même méthode, qu’un désassembleur natif lit directement.
L’obfuscation est une transformation d’IL à IL. Elle réécrit le premier encodage. Elle ne peut pas toucher le second : le code natif lui est opaque. Le seul levier dont vous disposez sur la copie native, c’est l’état de l’IL au moment où crossgen l’a compilé.
Le piège de l’ordre
Imaginez la chaîne tentante : compiler, publier avec ReadyToRun, puis lancer l’obfuscateur sur le dossier de publication terminé, parce que c’est l’artefact que vous livrez. Cela semble juste — protéger la chose que vous distribuez. C’est exactement l’inverse.
Au moment où votre obfuscateur s’exécute, crossgen a déjà compilé le code natif à partir de votre IL propre et non obfusqué. Votre vérification de licence, votre routine de dérivation de clé, vos calculs de tarification : tout cela se trouve désormais dans la section native sous forme d’une implémentation en code machine fidèle et pleinement optimisée de l’algorithme d’origine. Votre obfuscateur aplatit alors la copie IL de cette méthode, chiffre ses chaînes, la virtualise peut-être. La copie IL est magnifiquement protégée. La copie native, compilée quelques minutes plus tôt, est un second enregistrement intact de la même logique qu’aucune transformation d’IL n’atteindra jamais. Un attaquant désassemble tout simplement la méthode native et lit le flux de contrôle que vous pensiez avoir caché.
Il y a un second échec, plus discret, empilé par-dessus. L’obfuscation réécrit le module : nouveaux jetons de métadonnées, nouveaux noms, nouveaux corps de méthodes, nouveau MVID. L’image ReadyToRun était liée au module antérieur à l’obfuscation. Muter l’assembly après crossgen invalide les contrôles d’intégrité et de version de l’en-tête R2R, si bien qu’au chargement le runtime rejette l’image native et compile l’IL au JIT. Vous avez payé le coût de taille de R2R, livré une copie native de votre logique non protégée et perdu le gain de démarrage. Trois mauvais résultats pour une seule erreur d’ordre.
Obfusquez avant crossgen
La règle découle directement du schéma : l’IL que crossgen compile doit déjà être obfusqué. Concrètement, l’obfuscation doit intervenir après que le compilateur C# produit vos assemblys et avant que dotnet publish exécute l’étape ReadyToRun. Il y a deux façons propres d’y parvenir.
CI en deux étapes. Compilez, obfusquez la sortie compilée, puis publiez avec ReadyToRun pointé sur les assemblys déjà protégés :
dotnet build -c Release -p:PublishReadyToRun=false
nebula --config nebula.config.json # rewrites the IL in place
dotnet publish -c Release --no-build \
-p:PublishReadyToRun=true -o out # crossgen now compiles protected IL
Le nebula.config.json conserve tout ce dont R2R et la réflexion ont besoin, et applique les transformations lourdes là où elles comptent :
{
"schemaVersion": 1,
"inputs": ["bin/Release/net8.0/MyApp.dll", "bin/Release/net8.0/MyApp.Core.dll"],
"outputDirectory": "bin/Release/net8.0",
"preservePublicApi": true,
"encryptStrings": true,
"controlFlowObfuscation": true,
"autoProtectLicensing": true
}
Comme crossgen lit les assemblys dans bin/Release/net8.0 au moment de la publication, le code natif qu’il émet est compilé à partir de l’IL aplati et aux chaînes chiffrées : les deux encodages concordent désormais, et tous deux sont protégés.
Un hook MSBuild, pour qu’un simple dotnet publish soit déjà correct. La seule chose qui compte est que l’Exec d’obfuscation s’exécute avant la compilation ReadyToRun du SDK, et non après :
<Target Name="NebulaProtect" AfterTargets="Build" BeforeTargets="Publish">
<Exec Command="nebula --config $(ProjectDir)nebula.config.json" />
</Target>
Quelle que soit l’option retenue, le principe est le même que celui qui régit Native AOT et la publication en fichier unique : la protection appartient à l’IL managé, entre la compilation et la publication. R2R ne fait qu’élever les enjeux, car ici l’étape de publication ne se contente pas d’empaqueter votre IL : elle compile une seconde copie indépendante de celui-ci.
À quoi ressemble chaque encodage
Prenons une méthode d’application de licence représentative :
public bool IsLicensed(string key)
{
if (!key.StartsWith("LIC-")) return false;
return ValidateSignature(key, "https://api.example.com/v1/activate");
}
Obfusquez l’IL avant crossgen et la copie IL se décompile en un dispatcher aplati, le préfixe et le endpoint étant extraits du magasin de chaînes chiffrées à l’exécution :
public bool a(string A_0)
{
int s = 0;
while (true) { switch (s) {
case 0: if (!A_0.StartsWith(Strings.Get(0x3f1))) { s = 9; break; } s = 4; break;
case 9: return false;
case 4: return b(A_0, Strings.Get(0x412));
/* ... */ } }
}
Fondamentalement, la méthode native que crossgen produit est désormais une compilation de ce dispatcher : la même structure de branches opaque, aucune URL littérale, rien à lire proprement. Notez que les littéraux de chaîne de .NET vivent dans le tas de métadonnées #US, non pas incorporés dans le code natif ; le chiffrement des chaînes protège donc les deux encodages via les métadonnées, indépendamment de R2R. C’est le flux de contrôle et la forme de l’algorithme que la copie native exposerait sinon, et ici elle expose la forme obfusquée.
Obfusquez après crossgen et la copie IL paraît identique à la version protégée ci-dessus — mais la section native est une traduction directe en code machine de l’original propre : une comparaison de préfixe reconnaissable, un appel vers la validation de signature, la structure de branches de votre vraie méthode, pleinement optimisée et parfaitement lisible pour quiconque désassemble l’image R2R. L’obfuscation de l’IL fut un vrai travail dépensé à protéger la copie que personne n’a besoin de lire.
Vérifier que la compilation R2R est réellement protégée
Deux contrôles rapides transforment la garantie d’ordre en preuve :
- L’image R2R est présente et valide. Après la publication protégée, confirmez que l’assembly porte toujours un en-tête ReadyToRun (les outils
crossgen2/r2rdumpdu SDK le dumperont). Si l’obfuscation avait été exécutée après crossgen, l’image serait absente ou rejetée au chargement et vous seriez silencieusement revenu au JIT — un en-tête valide est donc la preuve que l’ordre a tenu. - Les corps de méthodes natifs mappent vers des membres renommés. Dumpez la liste des méthodes R2R ; les entrypoints devraient correspondre aux identifiants renommés par Nebula (
a,b, …), parce qu’ils ont été compilés à partir des métadonnées obfusquées. Des noms d’origine qui affleurent dans la table des méthodes natives signifient que crossgen s’est exécuté en premier : un signal d’alerte.
Pour le côté IL, vérifiez comme pour n’importe quelle compilation protégée : ouvrez l’assembly livré dans Glass.NET ou le décompilateur de votre choix et confirmez que les méthodes sensibles reviennent sous forme de dispatchers aplatis plutôt que de C# propre, exactement comme décrit dans vérifier l’obfuscation en CI.
À retenir
ReadyToRun est une bonne optimisation de démarrage et vaut la peine d’être livrée. Mais elle change fondamentalement la question de l’obfuscation, car elle compile une seconde copie native de votre code à partir de l’IL qu’on lui remet. Obfusquez d’abord et cette copie hérite de votre protection ; obfusquez en dernier et elle devient un enregistrement propre et indépendant de tout décompilateur de la logique que vous tentiez de cacher, tandis que l’image R2R désaccordée est écartée au chargement, vous coûtant le seul bénéfice pour lequel vous l’aviez activée. Il n’y a pas de juste milieu ni de « on protégera le dossier de publication plus tard ». Crossgen doit compiler un IL protégé. Séquencez Nebula avant l’étape ReadyToRun, vérifiez que les méthodes natives portent la forme renommée, et les deux moitiés de l’image raconteront la même histoire protégée.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.