Blog
Actualités et notes d'ingénierie
Annonces de versions, analyses détaillées du fonctionnement de nos outils et guides pratiques.
Comment Glass reconstruit une struct d'interop native
StructLayout et MarshalAs ne sont pas stockés comme des attributs personnalisés : ils vivent dans les tables de métadonnées ClassLayout et FieldMarshal. Voici comment Glass.NET lit ces tables et reconstruit le contrat d'octets natif exact que décrit une struct P/Invoke.
Lire l'article →Aucun article ne correspond à cette étiquette.
Comment Glass reconstruit une struct d'interop native
StructLayout et MarshalAs ne sont pas stockés comme des attributs personnalisés : ils vivent dans les tables de métadonnées ClassLayout et FieldMarshal. Voici comment Glass.NET lit ces tables et reconstruit le contrat d'octets natif exact que décrit une struct P/Invoke.
Lire →Le renommage traverse vos arbres d'expression
Une lambda comme c => c.Name ne se compile pas en corps de méthode lorsque son type est Expression<T> : elle se compile en appels de fabrique qui encodent l'accès à la propriété comme un jeton de métadonnées, pas comme une chaîne. Le renommage réécrit ce jeton avec le membre, si bien que l'arbre se résout toujours et que la lambda compilée s'exécute toujours. Le piège, c'est Member.Name : il renvoie le nom de métadonnées courant, de sorte que toute bibliothèque qui dérive une colonne, une clé JSON ou un message de validation à partir de x => x.Prop se met silencieusement à émettre le nom obfusqué. Voici l'IL exact, pourquoi le renommage atteint l'intérieur de l'arbre, et comment garder stable un contrat dérivé du nom.
Lire →Pourquoi la licence de ce client est-elle bloquée ?
Un ingénieur support reçoit un ticket disant qu'une licence « ne s'active pas », mais le client échoue en mode fermé et ne signale que « bloqué ». Voici un outil de diagnostic en lecture seule, bâti sur l'API d'administration de Keyright, qui rejoue tout le pipeline de vérification en mode explicatif et indique exactement quelle vérification a échoué — expiration, révocation, liaison de machine, un siège ou un droit absent — sans jamais exposer la clé.
Lire →Comment se décompile le P/Invoke généré par source
Les méthodes [DllImport] classiques n'ont pas de corps managé : un décompilateur les reconstruit depuis la table ImplMap. Une méthode [LibraryImport] est l'inverse : le stub de marshalling est du C# compilé réel, et Glass l'affiche en entier.
Lire →Pourquoi un nom de type stocké casse après le renommage
Une application à plugins qui résout "Acme.Exporters.PdfExporter, Acme.Exporters" avec Type.GetType et Activator.CreateInstance fonctionne en débogage et échoue en production dès que vous l'obfusquez. La cause est une incohérence entre un jeton de métadonnées et une simple chaîne, et la solution est un registre résistant au renommage qui ne conserve aucun nom.
Lire →Afficher l'expiration de licence dans le bon fuseau
Une licence expire à un instant unique sur la ligne du temps, mais « 30 novembre » est une date civile qui dépend de l'endroit où l'on se trouve. Confondez les deux et un client à Auckland verra « expirée » sur une clé qu'un client à Los Angeles affiche encore comme valide. Cet article construit l'affichage correct de l'expiration en .NET : stocker l'expiration comme un instant UTC, le projeter dans le fuseau horaire du lecteur avec DateTimeOffset et TimeZoneInfo, étiqueter le fuseau, et calculer les « jours restants » pour que les changements d'heure d'été ne fassent jamais durer un jour 23 ou 25 heures.
Lire →Ce qu'un décompilateur voit dans un binaire NativeAOT
Donnez à Glass une bibliothèque publiée avec NativeAOT et vous n'obtenez rien : ni C#, ni IL, pas même une liste de méthodes. Voici la raison au niveau du PE, quelles métadonnées survivent dans l'image native et pourquoi NativeAOT n'est pas l'obfuscateur que l'on imagine.
Lire →Empêcher un vidage mémoire de récupérer votre assembly
Le renommage et le chiffrement de chaînes sont annulés si un attaquant se contente de vider votre processus en cours sur le disque. Comment l'anti-dump de Nebula.NET relocalise et efface les en-têtes PE et de métadonnées en mémoire pour qu'une image extraite soit inutilisable : avec les offsets réels, du C#, un SVG du chemin d'extraction et les limites honnêtes.
Lire →Licencier une app Blazor Server par circuit
Dans Blazor Server, une portée DI vit pendant tout le circuit SignalR, pas par requête — si bien qu'une licence validée à la connexion d'un onglet reste la réponse trois jours plus tard, bien après l'expiration du bail. Voici comment cadrer les entitlements Keyright sur le circuit, les maintenir à jour pendant toute sa durée et basculer l'interface en mode dégradé quand elles changent.
Lire →Comment Glass lit les instanciations de méthodes génériques
Un appel de méthode générique se compile en un jeton MethodSpec accompagné d'un blob d'arguments de type distinct. Voici comment Glass.NET lit ce blob, substitue les marqueurs !!0 et décide quand le C# reconstitué a réellement besoin d'arguments de type explicites.
Lire →Masquer le flux de contrôle .NET par les exceptions
Un décompilateur reconstruit vos if/else à partir des instructions de branchement qu'il trouve dans l'IL. Faire passer une décision par une sentinelle levée puis capturée déplace cette arête dans la table des clauses de gestion des exceptions, où la décompilation structurée s'effondre. Voici l'IL réel, pourquoi il déjoue une lecture statique et le coût à l'exécution qui impose de l'employer avec parcimonie.
Lire →Vérifier les webhooks de facturation entrants en .NET
Votre serveur de licences fait confiance à un POST de votre prestataire de paiement, jusqu'à ce qu'un attaquant envoie le sien. Comment vérifier correctement les webhooks entrants signés par HMAC : signature sur les octets bruts, comparaison à temps constant, tolérance d'horodatage et défense anti-rejeu, puis réconcilier un remboursement avec la révocation de la licence.
Lire →Licenciez toutes les versions depuis une seule paire de clés
Faire tourner vos clés de signature à chaque version majeure est le piège : cela casse les builds plus anciens, impose une migration de masse et ne vous laisse aucun contrôle par client. Le meilleur modèle conserve une seule paire de clés pour toute la vie du produit et porte ce qu'une licence peut faire — quelles versions elle exécute, quelles fonctionnalités elle déverrouille, combien elle peut utiliser — dans des droits signés. Cet article montre les trois schémas avec du vrai code, comment les concessions restent inviolables en ligne comme hors ligne, et quand recourir plutôt à la couverture de versions complète.
Lire →Comment un décompilateur lit les valeurs d'attributs personnalisés
L'application d'un attribut n'est pas stockée sous forme de code source. C'est un blob binaire dans le tas #Blob : un prologue, les arguments positionnels sérialisés selon la signature du constructeur, puis une liste comptée de valeurs de champs et de propriétés nommés. Voici la disposition exacte des octets et comment Glass.NET la reconvertit en un attribut C#.
Lire →Comment l'arithmétique checked se décompile en C#
Un mot-clé checked ou unchecked ne survit jamais dans les métadonnées. La vérification de débordement est encodée par instruction sous la forme add.ovf, mul.ovf et conv.ovf.u1 : voici l'IL, les asymétries, et comment Glass.NET reconstruit la région checked minimale qui l'explique.
Lire →Comment les littéraux de chaîne bruts se décompilent en C#
Un littéral de chaîne brut, une chaîne verbatim et une chaîne ordinaire se compilent tous vers le même ldstr identique pointant vers le tas #US. Voici l'IL, les octets de la chaîne utilisateur qui se cachent derrière, et comment Glass.NET choisit la forme de guillemets à reconstruire.
Lire →Comment Glass reconstruit les expressions with des records
Une expression `with` ne laisse aucun mot-clé dans l'IL : c'est un appel virtuel à une méthode cachée `<Clone>$` suivie d'une série de setters init-only. Glass.NET relit cette forme exacte sous la forme `record with { … }`. Voici le parcours complet source → IL → C# reconstruit pour la mutation non destructive.
Lire →Récupérer le concepteur de ressources fortement typé avec Glass.NET
Un `Resources.Designer.cs` est du code de liaison généré par la machine : un `ResourceManager` paresseux, un champ de culture et une propriété typée par clé du `.resx` qui ne fait qu'appeler `GetString`. Rien de cette magie de mots-clés ne survit à la compilation : c'est de l'IL pur. Glass.NET lit l'empreinte des attributs et la forme de `GetString` pour vous rendre la classe de concepteur familière. Voici l'aller-retour complet code source → IL → C# reconstruit.
Lire →Instrumenter la vérification de licence avec OpenTelemetry
Vous instrumentez chaque appel à la base de données et chaque requête HTTP sortante de votre application, mais la seule dépendance qui décide si le logiciel a le droit de s'exécuter — le contrôle de licence — reste généralement invisible jusqu'à ce qu'un client ouvre un ticket. Ce guide pratique branche une vérification Keyright sur OpenTelemetry comme n'importe quelle dépendance critique : un Meter avec un compteur de vérifications, un histogramme de durée et une jauge d'expiration ; un span ActivitySource autour du rafraîchissement qui enregistre si la réponse est venue en ligne, du cache ou de la fenêtre de grâce ; les étiquettes à faible cardinalité qui font un tableau de bord et celles à haute cardinalité (la clé, le titulaire, l'id machine) qui ne doivent jamais devenir des valeurs d'étiquette ; et le câblage OTLP ainsi que les quatre alertes qui méritent un appel.
Lire →Restreindre une licence Keyright à un environnement
Le même fichier de licence a tendance à passer de la production vers le staging, sur le portable d'un développeur et dans la CI, jusqu'à ce que plus personne ne sache de quel environnement venait une validation et qu'une clé de staging fuitée déverrouille la production sans que personne ne le remarque. Voici un guide de migration : comparez les trois façons dont les équipes séparent les environnements — un produit par environnement, un simple fichier par environnement et un produit unique avec une entitlement env signée — puis migrez vers la dernière sur Keyright sans jour de bascule. Il couvre où l'application apprend son propre environnement (IHostEnvironment et le repli DOTNET_ENVIRONMENT / ASPNETCORE_ENVIRONMENT), une vérification de vingt lignes qui échoue en mode fermé face à un environnement inconnu, un déploiement rétrocompatible où une ancienne clé non restreinte continue de s'exécuter partout, et la limite honnête : l'environnement est déclaré par votre propre configuration, donc il s'agit d'hygiène et de télémétrie propre, pas d'un mur contre un opérateur qui règle la variable.
Lire →Préinstaller une licence Keyright depuis un installeur WiX/MSI
Les logiciels de bureau d'entreprise ne sont pas activés par la personne qui les exécute. Ils sont déployés silencieusement via une stratégie de groupe, Intune ou SCCM avec msiexec /qn, vers des machines dont les utilisateurs ne voient jamais de boîte de dialogue et ne peuvent souvent pas joindre votre service de licences. Ce guide pratique construit le déploiement dont la plupart des ISV finissent par avoir besoin : un MSI qui place une licence signée à l'échelle de la machine sous ProgramData afin que l'application soit déjà sous licence au premier lancement, plus l'alternative consistant à passer une clé d'activation comme propriété du MSI et à laisser l'application la réclamer une fois en ligne. Il couvre la rédaction en WiX v5, l'emplacement où le fichier doit résider pour que tous les utilisateurs Windows de la machine partagent un siège, l'action personnalisée différée qui écrit une clé que l'application récupérera, les options du SDK qui rendent ProgramData autoritaire et les lignes de commande msiexec qu'un administrateur colle dans son outil de déploiement.
Lire →Les chaînes de délégation permettent aux revendeurs d'émettre leurs propres clés
Vous signez un contrat de distribution et la première question d'intégration est « comment nos revendeurs émettent-ils des clés aux clients finaux ? ». Les deux réponses évidentes sont mauvaises : confier à chaque revendeur votre clé de signature racine et un seul portable volé contrefait tout votre catalogue, ou router chaque vente de revendeur via un appel en direct à votre service d'émission et vos partenaires ne peuvent plus vendre quand vous êtes hors ligne. Le modèle qui tient est une chaîne de délégation : donnez à chaque revendeur un certificat signé portant sa propre clé publique et une portée qu'il ne peut jamais dépasser, laissez-le signer les licences client final avec la moitié privée, et faites vérifier au client toute la chaîne hors ligne contre une unique clé racine épinglée. Cet article construit cette chaîne dans Keyright : le certificat de délégation et sa portée, comment un revendeur émet à l'intérieur, la vérification du SDK qui parcourt licence → délégué → racine, la règle selon laquelle la portée ne peut que se réduire, et pourquoi révoquer un seul certificat fait expirer en silence chaque clé qu'un revendeur compromis a jamais émise.
Lire →Construire un journal d'audit de licences inviolable par chaînage de hachage
Un guide pas à pas pour transformer la piste d'audit des licences de Keyright en un journal chaîné par hachage et inviolable : comment chaque entrée scelle la précédente, comment lire et vérifier la chaîne via l'API d'administration et la CLI, comment ancrer le hachage de tête pour qu'une suppression ne puisse se cacher, et le C# dont vous avez besoin pour prouver la piste en CI.
Lire →Réduire un assembly .NET après l'obfuscation
Le renommage laisse des chaînes et des blobs morts dans les heaps #Strings et #Blob. Comment Nebula compacte les heaps de métadonnées et renumérote les tokens, avec la disposition réelle des métadonnées, de l'IL, de la configuration et des mesures avant/après.
Lire →Masquer les calculs entiers qui verrouillent votre logiciel
Le renommage masque le nom d'une valeur ; la MBA masque ce qu'elle calcule. Ce guide approfondi montre comment Nebula réécrit a + b en enchevêtrements équivalents d'arithmétique et d'opérations binaires qui déjouent le repliement de constantes et l'exécution symbolique, avec du C# réel, de l'IL représentatif, les identités, la configuration et le coût honnête.
Lire →Obfusquer une tâche MSBuild personnalisée sans la casser
Une tâche MSBuild personnalisée est l'image miroir d'un générateur de code source. Le compilateur trouve un générateur par attribut, vous pouvez donc renommer toute la classe librement ; MSBuild trouve une tâche par la chaîne littérale du nom de type écrite dans un élément UsingTask, et lit ses paramètres à partir des noms de propriétés publiques, si bien que les deux forment un contrat externe rigide que le renommage ne doit pas toucher. Cet article examine ce que le moteur MSBuild réfléchit réellement lorsqu'il exécute votre tâche, trace la ligne exacte entre la petite surface figée et la logique précieuse qui se renomme sans encombre, et montre la configuration de Nebula ainsi que la compilation de vérification qui détecte le seul mode de défaillance qui soit silencieux.
Lire →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é.
Lire →L'obfuscation peut-elle cacher une chaîne de connexion .NET ?
Une chaîne de connexion, une clé d'API ou un secret de signature livré à l'intérieur de votre application .NET est récupérable en principe : le processus doit l'utiliser, donc le processus doit le détenir. Voici une comparaison honnête des trois endroits où un secret se cache dans un assemblage livré, ce que le chiffrement de chaînes et de ressources de Nebula.NET change exactement pour chacun, où se situe le plafond, et la stratification qui garde réellement un secret hors de portée d'un attaquant.
Lire →Pourquoi l'anti-ILDASM protège moins que vous ne le pensez
Pourquoi l'attribut [SuppressIldasm] n'arrête qu'un seul outil — et est purement ignoré sur le .NET moderne — plus ce que fait le vrai durcissement des métadonnées et des chaînes, avec C#, IL et configuration Nebula.
Lire →Comment allows ref struct se décompile en .NET
L'anti-contrainte allows ref struct de C# 13 ne produit aucun IL dans le corps de la méthode. Elle vit entièrement dans un bit de GenericParameterAttributes (AllowByRefLike, 0x20) sur un paramètre générique — voyez comment Glass.NET le relit.
Lire →Comment le mot-clé field de C# 14 se décompile
Le mot-clé field réutilise le même <Name>k__BackingField qu'émet une propriété automatique, donc les métadonnées sont identiques. La décision de restituer field vit entièrement dans l'IL de l'accesseur. Voici comment Glass.NET le relit.
Lire →Retrouver le modificateur file à la décompilation
Le modificateur file de C# 11 n'a ni attribut ni indicateur. Le compilateur l'encode en mutilant le nom du type en une forme imprononçable <File>F0__Type et en émettant le type comme interne à l'assembly. Un décompilateur qui imprime ce nom tel quel produit du code qui ne compile pas. Voici comment Glass.NET relit cette mutilation vers file class.
Lire →Ce que OverloadResolutionPriority fige dans un appel
L'attribut OverloadResolutionPriority oriente la résolution de surcharge, mais ne marque que la définition de la méthode, jamais l'appel. Voici comment Glass.NET lit les deux côtés.
Lire →Comment UnsafeAccessor se décompile en .NET
Une méthode UnsafeAccessor n'a aucun corps IL : le membre privé qu'elle atteint ne vit que comme une chaîne dans le blob d'un attribut personnalisé, liée par le JIT. Voici comment Glass.NET la reconstruit.
Lire →Comment les paramètres ref readonly se décompilent
ref readonly et in compilent vers des métadonnées de paramètre identiques octet pour octet : même flag [in], même modreq(InAttribute). La seule différence est un attribut personnalisé. Voici ce que lit Glass.NET.
Lire →Comment les littéraux de chaîne UTF-8 se décompilent en C#
Un littéral "abc"u8 n'est ni une chaîne ni un tableau d'octets : c'est un ReadOnlySpan<byte> sur un champ de données RVA statique. Voici l'IL, le terminateur nul caché et ce que Glass.NET reconstruit.
Lire →Résoudre les références depuis un lockfile NuGet dans Glass.NET
Un décompilateur ne vaut que les références qu'il peut résoudre. Pointez Glass.NET vers votre packages.lock.json et il charge les versions épinglées exactes — les types, classes de base et surcharges se résolvent alors selon ce qui a réellement été restauré, pas une supposition.
Lire →Provisionnement de licences en masse via l'API d'administration Keyright
Intégrer un contrat entreprise de 2000 postes un POST à la fois est lent et vous laisse deviner quand un lot meurt en cours de route. Voici comment provisionner en masse et relancer sans risque.
Lire →Contrôler les fonctionnalités à la compilation avec un générateur Roslyn
Arrêtez de disséminer des vérifications d'entitlements écrites à la main. Un générateur de source Roslyn émet les gardes pour vous, valide les noms d'entitlement contre un manifeste et fait échouer la compilation sur une faute de frappe.
Lire →Verrouillage optimiste pour l'activation concurrente de licences
Deux machines réclament le siège final à la même milliseconde. Un naïf lire-compter-écrire les laisse entrer toutes les deux et survend la licence. Voici comment la concurrence optimiste transforme la réclamation de siège en un compare-and-swap, et comment le SDK gère le 409.
Lire →Comparer les droits requis et accordés lors d'une mise à jour
Quand une nouvelle version exige des droits que la licence du client n'a jamais accordés, un simple « fonction verrouillée » est une impasse. Voici comment comparer requis et accordés pour dire exactement quoi acheter.
Lire →Rafraîchissement conditionnel de licence avec ETag
Un client Keyright rafraîchit son lease en cache sur une minuterie, et l'immense majorité de ces rafraîchissements répondent à la même question par la même réponse : rien n'a changé. Retélécharger le lease signé complet à chaque fois gaspille de la bande passante et refait une vérification de signature sans raison. HTTP possède déjà le bon outil pour « cette ressource a-t-elle changé depuis la dernière fois que je l'ai vue ? » : l'ETag et le GET conditionnel. Cet article montre comment le service émetteur marque chaque réponse de licence d'un validateur fort, comment le SDK envoie If-None-Match pour transformer un rafraîchissement en un économique 304 Not Modified, et les règles de correction qui empêchent un 304 de masquer une révocation.
Lire →Éviter une ruée de revalidation de licence avec du jitter
Quand des milliers de clients partagent un TTL de validation en cache ou se reconnectent tous après une panne, leurs appels de rafraîchissement se synchronisent en avalanche. Voici comment appliquer du jitter à la revalidation en arrière-plan du SDK pour ne pas DDoS votre propre service émetteur.
Lire →Sièges par utilisateur nommé contre par appareil dans Keyright
Un siège peut désigner une machine ou une personne, et les deux ne se comptent pas pareil. Voici comment lier, appliquer et réconcilier les sièges par appareil et par utilisateur nommé dans Keyright sans survendre ni bloquer des clients qui paient.
Lire →Activer une application de bureau en scannant un QR code
Saisir une clé de licence de 29 caractères sur une borne, un boîtier TV ou un poste verrouillé est source d'erreurs et pénible. Voici comment construire un flux d'activation par appairage d'appareils pour une application de bureau .NET avec Keyright : l'app affiche un QR code, l'utilisateur approuve sur son téléphone, et le bureau interroge une activation signée qu'il met en cache et valide hors ligne.
Lire →Comment les prédicats opaques contrarient les désobfuscateurs automatiques
Pourquoi les prédicats toujours-vrais et les branches factices mettent en échec les outils de type de4dot — avec du C# réel, de l'IL représentatif, le compromis performance/taille et le niveau Nebula concerné.
Lire →Le coût d'exécution du chiffrement de chaînes dans une boucle chaude
Les littéraux de chaîne chiffrés sont déchiffrés au point d'utilisation. Dans une boucle serrée, cela s'additionne. Voici comment mesurer le coût avec BenchmarkDotNet et cadrer le chiffrement de chaînes dans nebula.config.json.
Lire →Obfusquer un contrat JSON polymorphe en toute sécurité
La sérialisation polymorphe met l'identité du type sur le fil. TypeNameHandling de Newtonsoft incorpore le nom de type CLR, que l'obscurcissement renomme, cassant chaque document persisté. [JsonDerivedType] de System.Text.Json utilise un discriminateur de chaîne découplé du type, et se renomme donc librement. Voici exactement pourquoi, et comment obscurcir la hiérarchie en toute sécurité.
Lire →Obfusquer une Minimal API sans casser la liaison des paramètres
Les Minimal API ASP.NET Core lient les valeurs de route et de query aux paramètres du handler par leur nom réfléchi. Supprimez ou renommez ces noms et la liaison échoue en silence : id arrive à 0. Voici le correctif.
Lire →Obfusquer des grains Orleans sans casser le routage du cluster
Orleans route chaque appel de grain via des chaînes du manifeste du cluster : un GrainInterfaceType et un GrainType dérivés par défaut des noms de vos types .NET. Renommez un grain et l'identité se déplace, orphelinant l'état persisté et cassant les appels inter-silos. Voici comment découpler l'identité avec [Alias]/[GrainType] tout en obfusquant agressivement.
Lire →Obfusquer une application Quartz.NET sans casser le JobStore
Un JobStore persistant de Quartz.NET écrit en base le nom qualifié par assembly de chaque type IJob et le recharge par réflexion au déclenchement d'un trigger, souvent sur un déploiement ultérieur. Renommez ce type et le planificateur lève une JobPersistenceException. Voici la keep-list qui corrige cela.
Lire →Obfusquer un plugin Semantic Kernel en toute sécurité
Un plugin [KernelFunction] est un contrat découvert par réflexion, envoyé au LLM sous forme de schéma d'outil. Le nom de la fonction, les noms des paramètres et les descriptions sont porteurs ; le corps de la méthode est votre PI. Fixez les noms avec des attributs pour que les identifiants se renomment librement, puis laissez Nebula blinder l'implémentation.
Lire →Reconstruire contraintes génériques et variance depuis les métadonnées
Les contraintes de paramètres de type générique et la variance sont, tout comme la disposition des structures, des traits qu'un décompilateur ne peut pas récupérer à partir de la forme du code : ils vivent entièrement dans les métadonnées. Chaque paramètre générique porte une direction de variance et des indicateurs de contrainte spéciale dans la table GenericParam, et la table GenericParamConstraint énumère le type de base et les interfaces auxquels un paramètre est lié. La covariance (out) et la contravariance (in) sont des bits d'indicateur ; les contraintes class / struct / new() sont aussi des bits ; mais notnull et unmanaged sont encodés indirectement, par un modreq et un attribut plutôt que par un indicateur brut. Perdez la variance et une interface cesse d'être assignable comme elle l'était ; réémettez les contraintes dans le mauvais ordre et la sortie ne compile pas du tout. Cet article montre où vivent les données, comment Glass.NET lit les tables GenericParam et GenericParamConstraint, comment il trie les contraintes dans l'ordre exact qu'exige C#, et un exemple travaillé avec une interface covariante et une méthode à plusieurs contraintes.
Lire →Comment Glass suit le réacheminement de types et la table ExportedType
Quand un type passe de mscorlib à System.Runtime, l'assembly d'origine conserve un réacheminement : une ligne ExportedType avec l'indicateur de réacheminement pointant vers un nouvel AssemblyRef. Un réacheminement n'a aucun membre, donc un décompilateur ne doit pas le représenter comme un type : il doit suivre le réacheminement jusqu'à la vraie définition. Cet article parcourt où vit le réacheminement dans les métadonnées, comment Glass.NET résout une chaîne de réacheminements, comment il se dégrade proprement quand l'assembly cible manque et comment il réémet [assembly: TypeForwardedTo(...)] quand tu décompiles la façade elle-même.
Lire →Reconstruire le concepteur WinForms à la décompilation
Une app WinForms compilée n'a ni .Designer.cs ni .resx : le code du concepteur a été fusionné dans un seul type sous la forme d'InitializeComponent(), et les textes et images de l'interface vivent dans un flux .resources incorporé. Voici comment Glass.NET reconstruit un InitializeComponent() fidèle à partir du binaire, fait apparaître les valeurs du ComponentResourceManager et vous laisse exporter les ressources incorporées : tout en statique, tout gratuitement.
Lire →Lire la vue IL et naviguer dans les tokens de métadonnées dans Glass
Une explication approfondie sur le passage à la vue IL dans Glass, le décodage des tokens de métadonnées (0x06 MethodDef, 0x0A MemberRef, 0x70 UserString), la lecture de l'en-tête du corps d'une méthode et le clic sur un token pour sauter à sa définition.
Lire →Retrouver noms de variables et numéros de ligne depuis les PDB
Un décompilateur reconstruit du C# à partir de l'IL et des métadonnées, mais des noms comme V_0 et V_1 ont disparu. Voici comment Glass lit les PDB portables (intégrés, à côté du binaire ou récupérés via Source Link) pour restaurer les vrais noms de variables locales et de paramètres, annoter le code décompilé avec le fichier source et la ligne d'origine, et récupérer le code source réel, et comment il se dégrade proprement quand aucun symbole n'existe.
Lire →Appliquer les droits de licence dans les services gRPC
Un service gRPC n'a ni pipeline de filtres MVC ni attribut [Authorize] auquel accrocher une vérification de licence : le seul point qui voit chaque appel est l'Interceptor du serveur. Cet article écrit un LicensingInterceptor qui valide une licence Keyright une seule fois, mappe chaque méthode gRPC vers un droit requis et échoue fermé avec le bon statut : FailedPrecondition en l'absence de licence valide, PermissionDenied quand la licence n'a pas le droit, ResourceExhausted quand une limite numérique est épuisée. Plus un chemin chaud en cache qui ne fait jamais d'aller-retour vers le service émetteur, l'enregistrement par DI via AddGrpc et les variantes de streaming.
Lire →Node-locking des activations et survivre à la dérive d'empreinte
Une licence node-locked lie un siège à une machine. Le lien est une empreinte machine : un hachage stable et salé dérivé de signaux matériels et du système d'exploitation, jamais d'identifiants matériels bruts. Cette analyse montre comment le SDK Keyright calcule l'empreinte et l'envoie dans ActivateAsync, comment le service d'émission compte les empreintes distinctes comme des appareils actifs, et le vrai problème opérationnel de la dérive d'empreinte : un clone de VM, un disque réimagé, une carte réseau remplacée ou une extension de RAM modifient l'empreinte, la machine semble neuve et les sièges s'épuisent. Nous couvrons les empreintes multisignaux pondérées, la correspondance par tolérance, la désactivation et l'expiration de bail pour récupérer les sièges, et le verrouillage qui échoue en fermé.
Lire →Révoquer une clé de licence divulguée sur tous les clients
Une clé a été partagée, publiée sur un site de collage ou s'active depuis trois continents à la fois. Voici le mode d'emploi concret : comment la révoquer dans Keyright, ce que signifie la révocation côté serveur et — la partie que la plupart des équipes ratent — comment les clients SDK déployés l'apprennent vraiment et cessent de fonctionner.
Lire →Intégrer le SDK Keyright dans ASP.NET Core avec résilience
Les équipes qui instancient le client Keyright à la main tombent sur l'un des deux échecs classiques de HttpClient : épuisement des sockets dû à un client par appel, ou DNS périmé dû à un unique client statique conservé pour toujours. Cet article enregistre le client Keyright via IHttpClientFactory comme client typé pour que les message handlers soient mutualisés et renouvelés correctement, choisit les bons lifetimes de DI et ajoute un pipeline de résilience — timeout, nouvelle tentative avec jitter et un circuit breaker réglé pour un appel de licence — afin qu'un bref hoquet du service émetteur se dégrade avec élégance plutôt que d'échouer brutalement.
Lire →Mettre à niveau une licence sur place, d'essai à payant
Quand un client convertit un essai en abonnement payant ou passe de Standard à Pro, la chaîne de clé qu'il a déjà activée ne devrait pas changer. Voici comment mettre à niveau une licence côté serveur avec Keyright — en retirant l'indicateur d'essai, en prolongeant l'expiration, en ajoutant des entitlements — pour que l'application déployée avec le SDK adopte la nouvelle concession dès son prochain ValidateAsync, sans friction de réactivation, ainsi que comment régler le rythme de revalidation, garder l'appel de mise à niveau idempotent et auditer chaque changement d'entitlements.
Lire →Obfusquer une couche Dapper sans casser le mappage des colonnes
Dapper apparie les noms de colonne du jeu de résultats aux membres publics de votre POCO par nom, sans tenir compte de la casse, au moment de la matérialisation. Renommez ces membres avec un obfuscateur et Dapper cesse silencieusement d'apparier : aucune exception, juste une propriété laissée à null ou 0. Voici le tableau complet : comment le gestionnaire de types par défaut de Dapper lie précisément une colonne à un membre, pourquoi votre texte SQL est en général sûr mais les membres de votre POCO fragiles, les échappatoires par mappage personnalisé, et la keep-list précise de nebula.config.json qui épingle les POCO de résultat tout en renommant le reste de la couche de données.
Lire →Obfusquer une application MassTransit sans casser le routage
MassTransit dérive l'identité d'un message — son MessageUrn, comme urn:message:Contoso.Ordering.Contracts:OrderSubmitted — de l'espace de noms et du nom du type de contrat .NET, puis l'utilise pour nommer l'exchange ou le topic du broker et l'estampille dans l'en-tête messageType de l'enveloppe. Le producteur et les consommateurs, souvent déployés séparément, doivent s'accorder dessus. Si vous obfusquez après la compilation, renommer le type de contrat ou son espace de noms change le URN, de sorte que le producteur publie vers un exchange différent et estampille un messageType différent, et les consommateurs existants cessent de recevoir en silence. Cet article explique exactement comment le URN est construit à partir du type, pourquoi l'assembly de contrats de messages est la surface fragile, et comment épingler les espaces de noms, noms et propriétés des contrats avec une keep-list Nebula.NET tout en renommant consommateurs, sagas et internes.
Lire →Pourquoi protobuf-net survit au renommage
protobuf-net sérialise à partir des étiquettes numériques de [ProtoMember(N)], et non à partir des noms de membres — renommer un DTO protobuf-net est donc sans danger sur le fil, contrairement à System.Text.Json ou DataContract où les noms SONT le contrat. Voici pourquoi le renommage des propriétés est quasiment gratuit avec protobuf-net, et les quatre cas qui cassent encore : numérotation implicite des champs, noms de type dans ProtoInclude/AsReference, modèles par réflexion construits par nom de membre, et noms de ProtoEnum.
Lire →Obfusquer un client REST Refit sans le casser
Refit construit un client HTTP à partir d'une interface C#, mais la forme du câble provient des attributs — [Get("/users/{id}")], [Header], [Body], [Query] — et non du nom du type ou des méthodes de l'interface. Le nom de l'interface, ses méthodes et l'implémentation générée se renomment donc librement. Le seul vrai danger, ce sont les noms des paramètres, qui se lient par nom aux clés de chemin et de query ; [AliasAs] les découple pour que Nebula puisse tout renommer.
Lire →Obfusquer un service WCF sans casser le contrat sur le fil
Nebula renomme et chiffre les composants internes de votre service WCF pendant qu'une liste de conservation épingle par leur nom chaque [ServiceContract], [DataContract] et [DataMember] — pour que les noms des éléments SOAP, le WSDL et les clients existants restent compatibles octet pour octet.
Lire →Ce que CallerArgumentExpression incruste dans vos appels
Quand vous appelez ArgumentNullException.ThrowIfNull(x) ou un Guard.Against(x) maison, vous passez un argument. L'IL compilé en empile deux : votre valeur et un littéral de chaîne contenant le texte source exact de votre premier argument, car le paramètre porte [CallerArgumentExpression]. L'attribut vit dans les métadonnées du paramètre ; le texte capturé vit comme un simple ldstr à chaque appel. Un décompilateur naïf vous renvoie le second argument redondant. Cet article lit l'IL et le blob de l'attribut, explique pourquoi le littéral est là, et détaille comment Glass.NET détecte l'attribut, confronte le littéral à l'expression reconstruite, supprime l'argument synthétisé et reconstruit la déclaration de méthode avec l'attribut intact.
Lire →Comment les enums Flags se décompilent en valeurs nommées
Une combinaison de drapeaux comme Read | Write est repliée en un seul littéral entier avant même d'atteindre l'IL, si bien que le | que vous avez écrit disparaît. Cette analyse lit l'IL réel du code à drapeaux, explique les signaux de métadonnées de FlagsAttribute et des constantes nommées qui permettent à un décompilateur de décomposer un entier brut en une somme de membres nommés, et montre comment Glass.NET reconstruit les motifs | & ~ et HasFlag au lieu de vous laisser (Permissions)3.
Lire →Comment la disposition explicite des structs et les unions se décompilent
La disposition explicite des structs est l'une des rares fonctionnalités C# qu'un décompilateur ne peut pas récupérer à partir des formes du code, car elle ne laisse aucun code : elle vit entièrement dans les métadonnées. Le LayoutKind (Sequential/Explicit/Auto) est un flag sur la définition du type, Pack et Size se trouvent dans la table ClassLayout, et le décalage en octets de chaque champ se trouve dans la table FieldLayout. Lorsque deux champs partagent un décalage, vous avez une union à la C : des octets aliasés, un int qui voit les mêmes quatre octets qu'un float. Trompez-vous sur un seul décalage et le struct décompilé corrompt silencieusement chaque appel d'interop et de marshalling qui le touche. Cet article montre où vivent les données de disposition, comment Glass.NET lit les tables ClassLayout et FieldLayout et réémet [StructLayout(LayoutKind.Explicit, Pack = ..., Size = ...)] sur le type et [FieldOffset(n)] sur chaque champ, comment il reconnaît une union à partir de décalages qui se chevauchent, et pourquoi préserver les décalages exacts n'est pas négociable.
Lire →Comment les initialiseurs de module se décompilent en .NET
Une méthode marquée [ModuleInitializer] s'exécute avant tout le reste de l'assembly, mais ce n'est pas l'attribut que le runtime appelle. Le compilateur C# émet un constructeur statique sur le pseudo-type spécial <Module> qui appelle chaque initialiseur à son tour. Voici l'IL exact que génère le compilateur, les signaux de métadonnées qui marquent le cctor de <Module> et le distinguent d'un initialiseur de type ordinaire, et comment Glass.NET reconstruit le tout jusqu'aux méthodes [ModuleInitializer] que vous avez écrites.
Lire →Comment les opérateurs de plage et d'index C# se décompilent
Les opérateurs ^ et .. sont du pur sucre syntaxique. a[^1] se réduit à de l'arithmétique sur la longueur de la collection, a[1..^1] construit un System.Range à partir de deux valeurs System.Index et appelle RuntimeHelpers.GetSubArray, une plage de span devient Span<T>.Slice, et une plage de chaîne devient String.Substring. Un décompilateur naïf affiche les appels de constructeur bruts et l'arithmétique Longueur moins n ; Glass.NET reconnaît ces motifs et les replie vers ^ et .. — y compris le cas subtil où span.Slice(1, 2) et span[1..3] émettent un IL identique octet pour octet, de sorte que Glass doit choisir la lecture qui fait un aller-retour fidèle.
Lire →Comment Glass reconstruit une instruction switch C# à partir d'une table de sauts IL
Un switch C# sur une plage dense d'entiers ne se compile pas en une chaîne de comparaisons : il se compile en un seul opcode switch IL portant une table de cibles de branchement, indexée par la valeur du switch. Cet article détaille à quoi ressemble cette table de sauts, comment le compilateur normalise la valeur en soustrayant le cas minimum, pourquoi les switch épars deviennent des chaînes if/else de recherche binaire, et comment Glass.NET transforme l'enchevêtrement de gotos qui en résulte en un switch (x) { case 10: ... } propre.
Lire →Droits de licence contre feature flags
Un feature flag est un interrupteur opérationnel que vous contrôlez ; un droit de licence est une concession commerciale signée que le client a payée. Confondez-les et un client bascule un flag pour déverrouiller ce qu'il n'a jamais acheté. Cet article trace la frontière, montre les défaillances de la mauvaise approche, propose un tableau de décision et câble l'architecture combinée de Keyright : les droits comme barrière dure, les feature flags par-dessus pour le déploiement dans les limites de ce à quoi le client a droit.
Lire →Licencier à l'usage simultané avec des sièges flottants
L'activation par nœud lie une licence à une machine. La licence flottante la lie à l'usage simultané : vous achetez 25 sièges, et n'importe lesquelles de vos 400 installations peuvent s'exécuter à hauteur de 25 en même temps. Le mécanisme est un bail (lease) : un client réserve un siège, envoie des battements pour le conserver, puis le rend en quittant. Un client qui plante ne le rend jamais, donc son bail expire simplement et le siège revient au pool. Voici comment bâtir la licence à sièges concurrents sur une instance Keyright auto-hébergée, avec réservation par bail, comptage côté serveur, récupération par TTL et une gestion élégante du cas « tous les sièges occupés ».
Lire →Clés d'idempotence pour des opérations de licence résistantes aux relances
Une écriture de licence qui expire vous laisse aveugle : le siège a-t-il été consommé, ou non ? Si vous relancez, vous risquez de débiter deux fois un pool de crédits ou de brûler deux fois un siège ; si vous abandonnez, vous avez peut-être vendu une licence que vous n'avez jamais livrée. C'est le problème de la réponse perdue que rencontre tout client de licence en réseau, et la solution est une clé d'idempotence qui transforme un transport au-moins-une-fois en effets exactement-une-fois. Voici comment l'activation, le comptage, l'émission et la désactivation restent correctes face aux relances contre votre instance Keyright auto-hébergée.
Lire →Licencier une app .NET à identité machine éphémère
L'activation par nœud lie une licence à une empreinte machine stable, mais les conteneurs obtiennent une identité neuve à chaque redémarrage, si bien qu'une liaison naïve épuise les activations. Voici comment licencier une app .NET conteneurisée avec Keyright : en injectant une identité de déploiement stable, ou en louant des sièges concurrents pour des réplicas mis à l'échelle, et en échouant en mode fermé proprement au démarrage.
Lire →Webhooks d'événements de licence sortants de Keyright
Arrêtez d'interroger l'API de licences pour savoir ce qui a changé. Voici comment Keyright pousse des événements de cycle de vie signés — activée, révoquée, renouvelée, bientôt expirée — vers votre propre endpoint, et comment vérifier la signature, survivre à la livraison au-moins-une-fois et rejeter les rejeux côté réception.
Lire →Fenêtres de grâce pour une panne transitoire du serveur de licences
Une vérification de licence en ligne qui échoue sèchement dès que votre service émetteur Keyright est brièvement injoignable transforme un hoquet DNS ou un déploiement de routine en panne visible par vos clients. Cet article montre comment encaisser les pannes passagères avec une fenêtre de grâce configurable au-dessus d'un résultat de validation signé et mis en cache : en distinguant « service injoignable » (passager, on continue) de « licence révoquée » (définitif, on échoue fermé tout de suite), en bornant la grâce par les horodatages signés par le service lui-même pour que personne ne la prolonge en débranchant le réseau, en journalisant chaque exécution sur cache et en échouant fermé proprement une fois la fenêtre épuisée.
Lire →Obfusquer une fonction AWS Lambda .NET sans casser le handler
Le runtime .NET géré d'AWS Lambda localise votre code via une chaîne de handler de la forme Assembly::Namespace.Type::Method, qu'il résout par réflexion à chaque démarrage à froid. Si vous obfusquez après la compilation, le renommage sort le type ou la méthode du handler de sous cette chaîne : l'assembly est valide, mais Lambda n'arrive pas à résoudre le point d'entrée et l'invocation échoue avant même que votre code ne s'exécute. Cet article explique où vit la chaîne du handler, quels symboles le runtime géré et le sérialiseur Lambda résolvent par nom, comment épingler exactement ceux-ci avec une keep-list Nebula.NET tout en renommant le reste, et comment intégrer nebula protect à dotnet lambda package.
Lire →Obfusquer une app Azure Functions sans casser la découverte
Le worker isolé de .NET trouve vos fonctions via un fournisseur de métadonnées généré par source qui incruste le point d'entrée de chaque fonction dans l'assembly sous forme de chaîne littérale — "Namespace.Class.Method" — à la compilation. Obfusquez après cela et le renommage déplace la méthode hors de portée de la chaîne, de sorte que l'hôte Functions charge votre app puis ne trouve plus une seule fonction. Cet article explique exactement quels noms le modèle isolé résout à l'exécution, comment keep-lister les méthodes de trigger et les DTO de binding avec Nebula.NET, et comment chiffrer les chaînes et virtualiser la logique métier qui est la raison même d'exister de la fonction.
Lire →Obfusquer un outil global .NET sans casser les commandes
Un dotnet tool est un paquet NuGet contre lequel personne ne compile, vous pouvez donc renommer bien plus agressivement qu'une bibliothèque. Voici comment protéger la DLL à l'intérieur du paquet tout en gardant intacts le point d'entrée, les noms de commandes et `dotnet tool install`, avec Nebula.NET.
Lire →Obfusquer une application Hangfire sans casser les tâches
Hangfire sérialise dans son stockage chaque tâche mise en file, planifiée ou récurrente sous la forme du nom de type pleinement qualifié, du nom de méthode et des types de paramètres, puis la résout en un MethodInfo par réflexion lorsqu’un worker l’exécute — possiblement sur un déploiement ultérieur. Si vous obfusquez après la compilation, le renommage sort la classe de tâche ou sa méthode de sous ces chaînes stockées, de sorte que toutes les tâches en cours et récurrentes échouent à la désérialisation avec une erreur de type introuvable. Cet article explique exactement ce que Hangfire écrit dans son stockage, pourquoi les tâches récurrentes et les tâches différées longues sont le tranchant le plus affûté, et comment épingler les classes de tâches, les méthodes invoquées et leurs types de paramètres avec une keep-list Nebula.NET en renommant tout le reste.
Lire →Obfusquer une configuration fortement typée sans casser la liaison
Le lieur de configuration associe les clés d'appsettings.json et des variables d'environnement aux noms des propriétés publiques de votre POCO d'options par réflexion. Renommez ces propriétés lors d'une passe d'obfuscation et les valeurs liées deviennent silencieusement null ou leur valeur par défaut à l'exécution : aucune erreur de compilation, aucune exception, juste un comportement erroné. Cet article détaille comment `services.Configure<T>` résout les clés vers les setters des propriétés, ce que change le lieur généré par source de .NET 8+ et ce qu'il ne change pas, comment construire une keep-list dans nebula.config.json qui épingle les noms des propriétés publiques et le constructeur sans paramètre de vos classes d'options tout en renommant le reste, et comment confirmer dans Glass.NET que la surface d'options a survécu.
Lire →Obfusquer une application SignalR sans casser les méthodes de hub
SignalR dispatche chaque message temps réel en faisant correspondre une chaîne à une méthode. Un client appelle `connection.InvokeAsync("SendMessage", ...)` et enregistre `hubConnection.On("ReceiveMessage", ...)`, et le serveur résout ces chaînes vers des méthodes de hub par leur nom à l'exécution. Renommez une méthode de hub publique ou un membre d'une interface de client fortement typée et le dispatch échoue silencieusement : la connexion reste ouverte, mais le message n'arrive jamais. Cet article décortique comment le dispatcher de SignalR fait correspondre la chaîne cible de l'invocation à votre méthode de hub, pourquoi `[HubMethodName]` et `Hub<T>` changent quels noms sont critiques, comment construire une liste de conservation dans nebula.config.json qui épingle exactement la surface de méthodes visible sur le fil tout en renommant les corps du hub, les services internes et les détails internes des DTO, et comment confirmer dans Glass.NET que seuls les noms prévus ont survécu.
Lire →Comment le boxing et le unboxing se décompilent en C#
Une conversion implicite de int vers object est invisible en C#, mais elle alloue sur le tas, et l'IL le dit clairement avec un opcode box. Voici d'où viennent box, unbox.any et le préfixe constrained., pourquoi le code générique utilise constrained. pour éviter une allocation par boxing, et comment Glass.NET reconstruit du C# lisible pendant que l'IL révèle l'allocation que le code source dissimule.
Lire →Lire les instructions de haut niveau en C# décompilé
Un fichier d'instructions de niveau supérieur n'a aucune classe visible ni aucun Main visible, mais l'assembly, lui, en a. Le compilateur C# enveloppe vos instructions dans une classe interne nommée Program et dans une méthode d'entrée au nom imprononçable <Main>$, marquée par la directive .entrypoint. Voici exactement ce que le compilateur émet dans les cas synchrone et async, pourquoi le point d'entrée est la méthode que vous ne pouvez jamais écrire à la main, où sont passés vos global usings, et comment Glass.NET le relit comme le programme de niveau supérieur que vous avez écrit.
Lire →Décompiler .NET depuis la ligne de commande ou un assistant IA
Glass.NET 1.3.0 embarque une CLI headless et un serveur MCP. Reconstruisez un projet C# compilable ou un seul membre avec glass export, générez un SBOM, vérifiez l'authenticité d'un paquet NuGet, comparez deux builds et laissez un assistant IA lire du C# décompilé via un serveur Model Context Protocol avec glass mcp — le tout en analyse statique, le tout gratuit.
Lire →Mesurer l'usage par fonctionnalité avec plusieurs pools de crédits
Les vrais produits mesurent plus d'une chose — jetons d'IA, minutes de rendu, exports — et tout regrouper dans une seule réserve de crédits masque le coût et bloque des fonctionnalités sans rapport dès que l'une s'épuise. Voici comment modéliser plusieurs réserves de crédits indépendantes sur une même licence Keyright : la forme d'une réserve, la consommation idempotente par réserve qui échoue en mode fermé de façon isolée, l'ordre de consommation du quota inclus vers la recharge prépayée, les consommations atomiques sur plusieurs réserves pour une opération qui dépense deux compteurs à la fois, et la réconciliation par réserve qui fonctionne encore hors ligne.
Lire →Exécutez pour toujours les versions que vous avez payées
Une licence perpétuelle avec fenêtre de maintenance permet à un client d'exécuter à jamais toutes les versions publiées pendant que ses mises à jour étaient actives, mais pas les versions que vous publiez après son expiration. Voici comment modéliser cela dans une seule licence Keyright signée : une revendication maintenance-through, la date de publication de la build intégrée à votre assembly, et l'unique comparaison qui ne doit jamais échouer en fermé.
Lire →Licencier les fonctionnalités d'IA et les agents autonomes
Keyright 2.9.0 ajoute des entitlements d'IA et d'agents de première classe : nommez les modèles, endpoints et outils qu'un client peut appeler, bornez un agent autonome avec un budget de crédits et un lease, et appliquez le tout fail-closed et hors ligne depuis une licence signée, avec un POST /v1/consume mesuré pour l'usage en cours. Voici la forme de l'entitlement, le JSON signé, les helpers du SDK en C#, Node, Python et Java, et un scénario concret de refus-du-modèle-non-licencié.
Lire →Obfusquer une application .NET localisée sans casser les ressources
Une application localisée résout ses traductions par nom à l'exécution, et c'est précisément le type de recherche que l'obfuscation peut casser en silence. La surprise, c'est que les deux styles de localisation courants se comportent à l'opposé au renommage : un accesseur .resx classique généré par le concepteur est sûr parce que le nom de base de son ResourceManager est un littéral de chaîne déjà incorporé, tandis que IStringLocalizer<T> est fragile parce que la fabrique dérive le nom de base du nom complet du type marqueur : renommez ce type et la recherche échoue, l'assembly satellite n'est jamais consulté et le localiseur renvoie en silence la clé de ressource au lieu de la traduction. Cet article lit ce qu'émet chaque style, montre pourquoi l'un survit et l'autre non, et donne les règles de conservation précises de Nebula.NET pour que vos traductions continuent de se charger dans toutes les cultures.
Lire →Obfusquer une application WinUI 3 sans casser le XAML
WinUI 3 compile {x:Bind} en une classe de liaison générée dans votre propre assembly — un appel typé au getter par jeton de métadonnées plus une comparaison littérale de PropertyName —, de sorte que tout le view model se renomme proprement. Les défaillances qui subsistent sont les trois endroits où WinUI, ou votre propre code, passe encore par une chaîne : un chemin de {Binding} classique résolu par réflexion, une page localisée par Type.GetType à partir d'un nom construit, et un type que le Package.appxmanifest active par son nom littéral. Cet article lit le code de liaison généré, montre pourquoi {x:Bind} survit à un renommage complet alors que {Binding} revient vide, explique quels noms de propriétés de dépendance personnalisées sont réellement critiques, et donne la configuration Nebula qui aplatit l'application sans toucher à la surface résolue par chaînes.
Lire →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.
Lire →Comment une application Blazor WebAssembly se décompile
Une application Blazor WebAssembly envoie vos assemblies .NET au navigateur — empaquetées en webcil, mais avec l'IL complet. Voici comment les extraire de _framework, les lire dans un décompilateur et pourquoi votre C# côté client est aussi exposé que du JavaScript.
Lire →Lire des assemblages compilés en F# dans un décompilateur C#
F# compile vers le même IL que C#, donc un décompilateur C# affiche les assemblages F# en C#. Voici comment apparaissent les unions discriminées, les enregistrements, les modules et les fonctions curryfiées — et ce que vous disent les métadonnées CompilationMapping.
Lire →Comment P/Invoke et DllImport se décompilent
Les déclarations P/Invoke se compilent en méthodes pinvokeimpl avec un ImplMap. Voici comment un décompilateur reconstruit [DllImport], MarshalAs et les conventions d'appel — et comment lire exactement quelles fonctions natives une assembly inconnue appelle.
Lire →Pourquoi les assemblages ReadyToRun se décompilent toujours proprement
Les images ReadyToRun embarquent du code natif précompilé — et pourtant elles se décompilent en C# aussi facilement que n'importe quelle assembly, parce que l'IL est toujours là. Voici ce que R2R stocke réellement, comment le reconnaître et pourquoi un décompilateur ignore la partie native.
Lire →Conserver l'activation de licence au fil des mises à jour automatiques du bureau
Les auto-updaters qui installent chaque version dans un nouveau dossier perdent en silence votre activation mise en cache, forçant une réactivation à chaque mise à jour. Voici où stocker la licence signée pour qu'elle survive, selon l'updater.
Lire →Licencier un logiciel sur des agents de build éphémères en CI et cloud
Le verrouillage au nœud suppose des machines stables. Les runners de CI et les agents autoscalés naissent et sont détruits sans cesse, donc chaque exécution ressemble à une nouvelle machine et consomme un siège. Voici comment licencier du calcul éphémère sans épuiser votre décompte de sièges.
Lire →Obfusquer une application ClickOnce sans empêcher son démarrage
Les manifestes ClickOnce stockent un hachage de chaque fichier. Obfusquez après les avoir générés et l'application refuse de démarrer avec une erreur de validation. Voici l'ordre de build exact qui fait cohabiter obfuscation et ClickOnce.
Lire →Obfusquer du code qui génère du code à l'exécution
Quand votre application émet de l'IL à l'exécution — DynamicMethod, TypeBuilder, Expression.Compile — le renommage peut la casser d'une manière que le compilateur ne signale jamais. Voici exactement quels motifs de génération de code survivent à l'obfuscation et lesquels nécessitent des règles de conservation.
Lire →Obfusquer les assemblages d'un jeu Unity en toute sécurité
Comment obfusquer le C# d'un jeu Unity sans casser les scènes, les prefabs ni l'inspecteur — ce que protègent respectivement Mono et IL2CPP, et les keep-rules exactes qu'exigent la sérialisation et la réflexion de Unity.
Lire →Laisser les partenaires provisionner des clés de licence en toute sécurité
Vendre via des OEM et des revendeurs signifie que les partenaires émettent des clés à leurs clients — mais vous ne pouvez pas distribuer vos identifiants admin. Voici comment fonctionne le provisionnement cadré, attribué et plafonné, et comment garder chaque clé émise par un partenaire traçable et révocable.
Lire →Licences par cœur pour les logiciels serveur .NET
Les licences par cœur vivent ou meurent selon qu'on compte correctement les cœurs. Voici pourquoi Environment.ProcessorCount induit en erreur, comment lire les cœurs physiques et les quotas CPU de conteneur en .NET, et comment lier un droit de nombre de cœurs dans une licence signée.
Lire →Empêcher un attaquant d'extraire votre assembly .NET de la mémoire
L'obfuscation sur disque ne sert à rien une fois votre assembly chargée et ses chaînes déchiffrées en RAM — un vidage mémoire le capture. Voici comment la protection anti-dump corrompt le PE en mémoire pour qu'un vidage ne soit pas une assembly utilisable.
Lire →Déboguer un build .NET protégé en production
Dès que vous obfusquez, le débogage habituel devient plus dur : frames renommés, aucun pas-à-pas utile, des PDB que vous n'osez pas livrer. Mais un build protégé n'a pas à être une boîte noire. Voici le mode d'emploi côté ops : pourquoi ne pas livrer les PDB complets, comment remonter une trace de pile de production renommée avec la map amorcée que vous avez gardée, pourquoi le diagnostic passe d'abord par les logs, et comment garder messages d'exception et télémétrie utiles sans fuiter vos internes.
Lire →Décompiler une app .NET en fichier unique ou autonome avec Glass.NET
Vous avez publié une application .NET, vous glissez le .exe dans un décompilateur et rien de lisible n'en sort. Le problème n'est pas le décompilateur — c'est que dotnet publish possède plusieurs formats et que la plupart ne vous livrent pas d'assembly managé là où vous l'attendez. Voici où vit réellement votre IL dans un build autonome, en fichier unique, ReadyToRun ou Native AOT, et comment l'ouvrir dans Glass.NET.
Lire →Extraire et lire les ressources embarquées d'un assembly .NET avec Glass.NET
Une DLL porte plus que du code. Cuits dans le même fichier se trouvent des ressources .resources et des chaînes ResX embarquées, des chaînes localisées d'assemblys satellites, des fichiers entiers comme config, JSON, SQL et certificats, et des constantes de chaîne et d'octets. Voici comment tout trouver et lire dans Glass.NET — le décompilateur gratuit et purement statique qui n'exécute jamais l'assembly — et l'exporter sur disque pour l'inspecter hors de l'outil.
Lire →Voyez de quoi dépend un assembly .NET et ce qu'il appelle avec Glass.NET
Avant de distribuer une DLL tierce, vous voulez connaître sa surface externe : quels assemblys et paquets elle référence, pour quel framework elle est compilée, quelles bibliothèques natives elle appelle par P/Invoke, et où elle se connecte au réseau, au système de fichiers ou à un autre processus. Voici comment auditer tout cela de façon statique dans Glass.NET — le décompilateur gratuit qui lit le binaire et ne l'exécute jamais.
Lire →Comprendre du code .NET tiers inconnu avec Glass.NET
Vous dépendez d'une DLL dont vous n'avez pas le code source — un paquet abandonné, une bibliothèque interne dont l'auteur est parti, un SDK d'éditeur à la documentation maigre — et devez savoir comment elle fonctionne vraiment. Voici un flux d'investigation concret dans Glass.NET, le décompilateur .NET gratuit et purement statique qui n'exécute jamais l'assembly qu'il inspecte.
Lire →Protéger votre point d'activation contre les abus
Votre chemin critique d'activation — /v1/activate et /v1/validate — n'est pas authentifié, et c'est voulu : c'est le chemin que les applications de vos clients appellent avec une clé de licence, sans jeton d'administration. Vous le défendez donc avec de la logique de licence et des contrôles en périphérie, pas avec de l'authentification. Voici le manuel en couches : plafonds de postes et verrouillage machine comme régulateur naturel, détection des activations en double pour les clés partagées et les VM clonées, révocation d'une clé fuitée, une limite de débit ou un WAF sur votre propre proxy inverse devant /v1/*, et des journaux de licence structurés qui masquent la clé.
Lire →Exécuter Keyright auto-hébergé totalement isolé du réseau
Keyright auto-hébergé n'a besoin d'aucun internet sortant à l'exécution. Il vérifie sa propre auto-licence hors ligne contre la clé publique embarquée de Delta1 — sans appel maison, fail-closed en cas d'altération — et les applications de vos clients valident hors ligne entre les activations. Voici comment installer l'auto-licence sous forme de fichier, désactiver la recherche GeoIP, importer l'image dans votre registre privé, l'exécuter contre votre propre Postgres et gérer la licence à l'usage avec des blocs de crédit isolés.
Lire →Sauvegarder et restaurer une instance Keyright auto-hébergée
Keyright auto-hébergé est une application sans état dont tout l'état vit dans votre PostgreSQL ; la reprise après sinistre se résume donc à la sauvegarde de Postgres plus la protection de deux secrets que vous générez. Voici ce qu'il faut réellement sauvegarder, le secret qui fait la différence entre une restauration et une base de données morte, et un exercice de restauration qui remet un serveur de licences sur le chemin d'activation.
Lire →Mettre à niveau une instance Keyright auto-hébergée en toute sécurité
Mettre à niveau Keyright auto-hébergé est sans drame, car l'application est sans état et exécute ses propres migrations de schéma au démarrage — aucun SQL à la main. Mais vous voulez tout de même une procédure sûre : sauvegardez Postgres d'abord, testez hors production, épinglez le tag d'image et mettez à niveau un nœud à la fois derrière votre répartiteur de charge. Voici la séquence, y compris pourquoi le rollback consiste à restaurer la sauvegarde de la base, pas à rétrograder contre une base déjà migrée.
Lire →Choisir quoi exclure du renommage dans Nebula
Tout obfuscateur vous laisse exclure des noms du renommage, et le premier réflexe quand quelque chose casse est d'en exclure trop. Une keep-list est une frontière conçue et minimale, pas un fourre-tout pour tout ce qui a cassé. Voici la discipline : ce qui doit vraiment rester non renommé (API publique, cibles de réflexion, DTO sérialisés, classes d'options, scan de DI, XAML, points d'entrée d'un hôte), comment l'exprimer dans nebula.config.json, comment resserrer chaque entrée au strict minimum, et comment prouver le résultat dans Glass.NET.
Lire →Obfusquer une solution .NET multi-projets de façon cohérente
Une solution avec une douzaine de bibliothèques de classes et une application, ce n'est pas une douzaine de problèmes d'obfuscation : c'en est un seul. Protégez chaque projet isolément et vous dédoublez la protection des copies transitives, cassez InternalsVisibleTo entre vos propres assemblys et finissez avec un tas de maps de renommage qui ne concordent pas. Voici le mode d'emploi : décidez ce que vous livrez vraiment et ne protégez que cela, lancez une seule passe sur la sortie de publication, pilotez chaque assembly depuis un unique nebula.config.json partagé, renommez toute la solution pour que l'accès ami et les références croisées restent synchronisés, gardez une map amorcée par version, et câblez le tout dans la CI pour que chaque build livrée soit protégée à l'identique.
Lire →Obfusquer une app .NET bâtie sur AutoMapper et MediatR
Ces trois bibliothèques sont l'ossature d'un service ASP.NET Core moderne, et toutes trois résolvent des choses à l'exécution — par type et par nom de propriété — via la convention et le scan d'assemblys. Elles se comportent donc très différemment sous le renommage. AutoMapper apparie les membres par nom de propriété, donc les DTO renommés cessent silencieusement de mapper ; MediatR trouve les handlers par la forme de l'interface, donc il survit généralement intact ; FluentValidation découvre les validateurs par forme mais rapporte les erreurs par nom de propriété, donc la découverte tient pendant que vos chaînes PropertyName deviennent opaques. Voici exactement ce qui casse dans chacun, la règle keep minimale pour chacun, un nebula.config.json consolidé, et comment le prouver avec des tests d'intégration et Glass.NET.
Lire →Comparez deux versions d'un assembly .NET avec Glass.NET
Vous avez la v1.2.0 et la v1.3.0 d'une DLL et devez savoir exactement ce qui a changé — nouvelles API, une méthode modifiée en silence, un nouvel appel réseau — sans le code source et sans exécuter aucune des deux builds. Voici comment comparer deux versions d'un assembly dans Glass.NET, le décompilateur .NET gratuit et purement statique.
Lire →Exécuter Keyright auto-hébergé sur plusieurs nœuds
Votre serveur de licences se trouve sur le chemin d'activation de vos clients ; il ne devrait donc pas être un point de défaillance unique. Keyright auto-hébergé est un service ASP.NET Core sans état — tout l'état vit dans votre PostgreSQL — si bien que la haute disponibilité se résume à exécuter deux ou trois réplicas derrière un répartiteur de charge, sans affinité de session. Voici précisément comment.
Lire →Migrer des clés de licence maison vers Keyright
Un plan de migration pas à pas pour quitter un système de clés artisanal et passer à Keyright : inventoriez ce que vous avez, émettez des licences signées pour les clients existants, publiez un client qui lit les deux formats pendant une fenêtre de transition, puis retirez l'ancien chemin — le tout sans forcer un seul client à réactiver.
Lire →Protéger un Worker Service .NET sans interface
Un Worker Service .NET est le type d'application le plus facile à obfusquer agressivement et le plus facile à oublier d'obfusquer tout court. Il est livré sur le serveur d'un client sous forme de DLL, s'exécute sans interface comme service Windows ou unité systemd, et porte vos secrets d'intégration et votre logique métier avec presque aucune surface de réflexion à protéger — ce qui signifie que vous pouvez renommer presque tout. Cet article explique pourquoi un worker d'arrière-plan est une cible tentante de rétro-ingénierie, les quelques coutures du Generic Host qui lisent encore des noms (liaison des options, scan d'assembly, DTO sérialisés) et comment brancher Nebula.NET sur l'étape de publication pour que le binaire livré soit renommé, ses chaînes chiffrées et virtualisé là où ça compte.
Lire →Une alternative à SmartAssembly en 2026
SmartAssembly associe l'obfuscation .NET à des rapports automatiques d'erreurs et d'utilisation des fonctionnalités. Voici une comparaison honnête avec Nebula.NET : les forces de chacun, les cibles modernes qui comptent, et comment trancher sur votre propre binaire.
Lire →Votre obfuscation a-t-elle vraiment marché ? Vérifiez-le dans Glass.NET
Une compilation réussie ne prouve pas que votre code est protégé. Ouvrez l'assembly obfusqué dans Glass.NET — le décompilateur .NET gratuit et purement statique — et lisez-le comme le fera un attaquant : vérifiez que le renommage, le chiffrement des chaînes, le flux de contrôle et la virtualisation ont tenu, et que vous n'avez pas sur-protégé votre API publique.
Lire →Comment les arbres d'expressions C# se décompilent
Le même `x => x + 1` compile de deux façons complètement différentes selon le type auquel il est affecté. Comme délégué, c'est une méthode cachée et un ldftn ; comme Expression<Func<int, int>>, c'est un emboîtement d'appels à Expression.Parameter, Expression.Constant, Expression.Add et Expression.Lambda, avec les membres référencés par ldtoken. Voici exactement ce que le compilateur émet pour un arbre d'expressions — variables capturées sous forme de Constant d'une fermeture, égalité de chaînes avec son op_Equality, lambdas imbriquées enveloppées dans Quote — et comment un décompilateur replie les appels de fabrique vers la lambda que vous avez écrite.
Lire →Licencier une application .NET sous Linux et macOS
La plupart des conseils sur les licences sont écrits pour Windows, et le SDK Keyright le masque discrètement : les mêmes appels Validate() et ActivateAsync() fonctionnent sous Linux et macOS. Mais les trois choses dont dépend un SDK de licences — un dossier de données par utilisateur, une identité de machine stable, et une application relancée assez souvent pour rafraîchir son bail — sont toutes différentes hors de Windows. Le bail atterrit dans ~/.local/share, où une application Mac en bac à sable ou un service systemd avec ProtectHome= ne peut pas écrire. L'empreinte de la machine s'ancre sur /etc/machine-id ou sur l'IOPlatformUUID au lieu d'une valeur de registre, et une image de référence dont on a oublié d'effacer le machine-id transforme toute une flotte en une seule machine. Et un démon qui démarre une fois par trimestre ne reçoit jamais le rafraîchissement au démarrage sur lequel compte une application de bureau, si bien que son bail de 14 jours expire alors que le processus tourne toujours. Ce billet passe en revue où le SDK écrit sur chaque plateforme, de quoi l'empreinte est construite et les deux pièges du machine-id, une unité systemd avec StateDirectory= et LoadCredential= qui donne un chez-soi au SDK, la boucle de rafraîchissement du bail dont un service de longue durée a besoin, le mode de fichier que le bail mérite sur un hôte multi-utilisateur, et la boucle de vérification qui le prouve.
Lire →Obfusquer des types Newtonsoft.Json sans casser le JSON
Newtonsoft.Json lit votre DTO par les noms de ses membres via la réflexion — Customer devient "Customer" sur le fil parce que la propriété s'appelle littéralement Customer — donc à l'instant où un obfuscateur la renomme en a, le JSON produit par votre service devient { "a": … } et chaque consommateur et chaque document stocké casse, silencieusement, à l'exécution. Json.NET n'a pas de générateur de code à la compilation pour échapper à ce parcours par réflexion, donc épingler les noms avec [JsonProperty] n'est pas une optimisation, c'est tout le contrat. Et il cache un second piège, pire : TypeNameHandling écrit le nom qualifié par assembly de votre type dans le document sous la forme $type, de sorte que renommer un type casse chaque charge utile polymorphe qu'un autre build a jamais écrite — une panne qu'aucun attribut ne corrige. Cet article identifie à quels noms Json.NET se lie, pourquoi [JsonProperty] et [EnumMember] font des noms sur le fil des constantes que le renommeur ne peut pas toucher, pourquoi le constructeur de désérialisation est un second lien par nom, et pourquoi TypeNameHandling a besoin d'un ISerializationBinder stable plutôt que d'une règle de keep. Il se termine par le test d'aller-retour, exécuté sur le build protégé, qui transforme « la sérialisation a cassé » en un test en échec plutôt qu'en un e-mail d'un client.
Lire →Comment l'interpolation de chaînes C# se décompile
Une chaîne interpolée n'a pas d'IL propre : le compilateur choisit l'un de trois abaissements complètement différents selon votre framework cible, les types des trous et selon qu'une méthode a opté pour un gestionnaire. Voici exactement ce qu'émet `$"..."` sous forme de string.Concat, de string.Format et de la danse de DefaultInterpolatedStringHandler, ainsi que le cas du gestionnaire personnalisé où la chaîne n'est jamais construite, et où un décompilateur peut replier chaque forme vers `$"..."`.
Lire →Licencier une application Windows empaquetée en MSIX
MSIX est désormais la façon dont les applications de bureau Windows s'installent — via winget, via le déploiement en entreprise, via le Store — et il change discrètement trois choses dont dépend un SDK de licences. Les écritures dans %LocalAppData% sont redirigées vers un dossier propre au paquet que l'application ne voit jamais dans un chemin. Désinstaller le paquet supprime ce dossier, de sorte que le bail d'activation en cache, l'horloge d'essai locale et l'état de détection de manipulation de l'horloge disparaissent tandis que le poste reste lié sur le service de licences. Et le répertoire d'installation est en lecture seule, ce qui est exactement là où une licence de site embarquée devrait se trouver. Ce billet passe en revue ce que le SDK Keyright écrit et où cela atterrit sous une application empaquetée, pourquoi l'empreinte de la machine survit quand le cache ne survit pas, ce qu'un cycle de désinstallation/réinstallation fait au décompte des postes (rien, grâce à l'activation idempotente — sauf si le client avait l'intention de changer de machine), comment détecter l'identité du paquet et donner au SDK des chemins explicites, comment livrer une licence à l'intérieur du paquet, quand désactiver la virtualisation des écritures dans le manifeste, et la boucle de test qui le prouve.
Lire →Comment les types valeur nullables se décompilent en C#
int? ressemble à un type avec un null dedans, et dans l'IL ce n'est ni l'un ni l'autre : c'est le struct générique System.Nullable<int>, deux champs et aucun null nulle part, et chaque opération que le langage vous laisse écrire dessus est réécrite par le compilateur en appels sur ce struct. a + b sur deux valeurs int? devient une conjonction de HasValue, deux appels à GetValueOrDefault, un add et un newobj — ou un initobj pour le résultat null. a == b devient une comparaison de valeurs combinée par ET à une comparaison de HasValue. a == null devient un seul appel à HasValue. a ?? 5 devient une conditionnelle sur HasValue. Et boxer un int? fait quelque chose qu'aucun autre struct ne fait : l'instruction box produit soit un int boxé soit une référence null, de sorte que Nullable<T> n'existe jamais sur le tas. Ce billet lit chacun de ces abaissements en IL et suit un décompilateur qui les replie vers les opérateurs que l'auteur a écrits — pourquoi le motif HasValue et GetValueOrDefault doit être reconnu comme une unité, pourquoi int? vient du blob de signature plutôt que d'un attribut (contrairement à string?), comment unbox.any sur une référence null produit discrètement un Nullable vide, et ce qu'un décompilateur rate quand il rend l'abaissement au lieu du langage.
Lire →Lier une licence de site Keyright à un domaine
Une entreprise qui achète quatre cents postes ne veut pas quatre cents activations, et vous ne voulez pas que la clé qui les déverrouille tous parte sur le portable d'un prestataire. La réponse classique est une licence de site — une clé pour toute l'organisation — et la question que personne n'écrit est à quoi la clé est liée, si ce n'est à une machine. Ce billet construit une licence de site sur Keyright sous forme d'un droit signé qui nomme le domaine DNS du client, éventuellement épinglé par le SID de domaine Windows : d'où viennent ces deux identités (IPGlobalProperties.DomainName, pas Environment.UserDomainName, et SecurityIdentifier.AccountDomainSid), pourquoi la correspondance par suffixe est la bonne comparaison pour une forêt avec des domaines enfants, comment la porte échoue fermée sur un portable non joint, comment le client vous transmet les valeurs sans aller-retour avec l'informatique, et le modèle de menace honnête : un nom de domaine est une barrière de politique qu'un attaquant déterminé peut contourner en renommant une VM, un SID de domaine relève la barre jusqu'au clonage d'un contrôleur de domaine, et aucun des deux ne remplace un décompte de postes quand vous en avez vraiment besoin.
Lire →Pourquoi le renommage casse le code qui utilise dynamic
Un appel statique survit au renommage parce qu'il est résolu par jeton de métadonnées et que l'obfuscateur réécrit le jeton avec le membre. Un appel dynamic ne survit à rien : le compilateur C# abaisse settings.Timeout en un call site dont le binder reçoit la chaîne "Timeout", et à l'exécution Microsoft.CSharp parcourt le type réel du récepteur à la recherche d'un membre portant exactement ce nom. Renommez Timeout en a et le site demande toujours "Timeout", la recherche échoue, et l'application lève RuntimeBinderException sur une ligne qui compilait bien et passait tous les tests sur le build non protégé. Ce billet lit l'IL d'un site dynamic pour montrer où vit le nom (un ldstr alimentant Binder.GetMember et Binder.InvokeMember dans un conteneur caché <>o__), explique pourquoi le chiffrement des chaînes n'aide ni ne nuit, pourquoi aucun renommeur ne peut le corriger automatiquement en toute sécurité (le type du récepteur n'est pas connu avant l'exécution de l'appel), quelles opérations dynamic se lient par nom et lesquelles non (indexeurs via Item, opérateurs via les noms op_, clés d'ExpandoObject jamais), le schéma de double dispatch par dynamic qui casse silencieusement un visiteur entier, et les trois correctifs par ordre de préférence : remplacer dynamic par une interface, épingler uniquement les membres qu'un site atteint avec [Obfuscation(Exclude = true)], ou une entrée exclude dans nebula.config.json — plus le seul test qui l'attrape sur le build protégé.
Lire →Comment les initialiseurs de tableau se décompilent en C#
Écrivez int[] x = { 1, 2, 3, 4, 5 } et vous pourriez vous attendre à cinq instructions stelem, une par élément. Pour un petit tableau, c'est à peu près ce que vous obtenez, mais au-delà d'un seuil le compilateur C# cesse de stocker les éléments un par un et fait quelque chose de plus étrange : il alloue le tableau, puis appelle RuntimeHelpers.InitializeArray avec un handle vers un champ statique dont les octets sont le tableau entier empaqueté bout à bout, et ce champ n'a aucun initialiseur en IL — ses données vivent dans une section de données du PE, pointée par une ligne de métadonnées FieldRVA, typée comme une struct synthétique dans une classe cachée dont la seule propriété est sa longueur en octets. Un décompilateur ne peut pas lire le littéral depuis l'IL, parce que l'IL ne contient qu'un memcpy ; il doit reconnaître le motif InitializeArray, résoudre le jeton du champ, suivre le FieldRVA jusqu'aux octets bruts, prendre le type d'élément du newarr qui l'a précédé, et redécouper le blob little-endian en { 1, 2, 3, 4, 5 }. Cet article parcourt l'IL et les métadonnées d'un tableau initialisé par blob, montre ce que Glass.NET reconstruit, explique pourquoi un tableau de chaînes n'emprunte jamais ce chemin, et couvre le cas du ReadOnlySpan d'octets où il n'y a aucun tableau du tout — juste un handle de champ et un CreateSpan.
Lire →Comment une constante decimal se décompile en .NET
Tous les autres littéraux numériques en C# — 42, 3.14, 1_000_000L — atterrissent dans l'IL sous la forme d'une instruction ldc ou dans la table de métadonnées Constant, une valeur que le runtime charge directement. decimal ne le peut pas : c'est une struct de 128 bits, pas un primitif pour lequel le CLR dispose d'un opcode de chargement, si bien qu'un const decimal ou un paramètre decimal par défaut n'a aucun endroit natif où vivre, et le compilateur résout le problème par une astuce qui piège quiconque lit l'IL brut — il encode le nombre dans un [DecimalConstantAttribute] dont les cinq arguments de constructeur (échelle, signe et trois entiers 32 bits) épellent la valeur exacte. Cet article suit un décompilateur à travers cette reconstruction : pourquoi la table Constant refuse decimal, comment les arguments de l'attribut correspondent aux quatre int dont un decimal est construit, pourquoi un champ const decimal n'a d'initialiseur dans aucun constructeur, en quoi un paramètre decimal par défaut diffère d'un paramètre int par défaut, et pourquoi prendre l'attribut pour une annotation ordinaire transforme 3.14m en new decimal(314, 0, 0, false, 2) au lieu d'un littéral.
Lire →Ce qui trahit une méthode d'extension à la décompilation
Une méthode d'extension n'a aucune existence à l'exécution en tant qu'extension. C'est une méthode statique ordinaire dont le premier paramètre se trouve être marqué, et un appel à celle-ci — text.Trim().Count() — se compile en un appel statique ordinaire, Enumerable.Count(string.Trim(text)), sans syntaxe pointée, sans receveur, sans rien qui dise qu'il a un jour été écrit de façon fluide. La seule chose que le compilateur laisse derrière lui est un attribut [Extension] : sur la méthode, pour que le premier paramètre puisse être restitué avec this, et sur la classe statique qui la contient, pour qu'un outil sache seulement qu'il doit y regarder. Un décompilateur doit lire cet attribut, décider qu'un appel statique dont la cible le porte doit être imprimé comme un appel de membre sur son premier argument, et obtenir la bonne précédence pour qu'une chaîne de dix opérateurs LINQ revienne sous forme de chaîne et non d'imbrication de dix niveaux d'appels statiques. Cet article parcourt l'IL d'une méthode d'extension définie et d'un point d'appel, montre ce que Glass.NET reconstruit, explique pourquoi c'est l'attribut — et non l'appel — qui est la source de vérité, et couvre la forme plus récente des blocs d'extension de C# 14, dont les membres se compilent en les mêmes méthodes statiques sous une autre peau.
Lire →Comment les champs volatile se décompilent en .NET
Le mot-clé volatile n'a pas de runtime propre. Il se compile en deux éléments de métadonnées distincts qui résident à des endroits différents : un modificateur requis, modreq(IsVolatile), soudé dans la signature du champ, et un préfixe volatile. d'un octet apposé devant chaque ldfld et stfld qui touche le champ. Un décompilateur doit lire les deux, s'accorder avec lui-même sur celui qui fait autorité, puis ne pas confondre le résultat avec les deux choses qui semblent identiques en C# mais se compilent de façon complètement différente — Volatile.Read sur un champ ordinaire, qui est un simple appel sans préfixe ni modificateur, et Interlocked.Increment sur un champ volatile, qui prend le champ par adresse et porte donc le modificateur mais pas le préfixe. Cet article parcourt l'IL des trois cas, montre ce que Glass.NET reconstruit à partir de chacun, explique pourquoi le jeton de référence du champ doit lui-même porter le modreq sous peine que l'accès ne se résolve même pas, et couvre le seul cas que C# ne peut pas exprimer — un préfixe volatile. sans champ volatile derrière lui — ainsi que l'appel que Glass émet pour lui.
Lire →Quel statut HTTP un contrôle de licence en échec doit-il renvoyer ?
Quand une API sous licence décide qu'un appelant n'a pas le droit de s'exécuter, le pire qu'elle puisse faire est de renvoyer un 500 nu avec une stack trace, et le deuxième pire est un 200 avec { "ok": false } qu'aucun client ne remarquera jamais. Ce billet établit le contrat HTTP qu'une porte de licence doit réellement à ses appelants : pourquoi un échec de licence n'est pas un 401 (l'appelant est parfaitement authentifié — c'est la licence qui a expiré), quand le 403 est juste et quand le 402 Payment Required en dit plus, comment transporter la raison lisible par machine dans un corps application/problem+json conforme à la RFC 9457 avec des membres d'extension sur lesquels un client peut brancher, et le seul en-tête de réponse — jamais la clé — qui permet à une CLI ou à un service frère de réagir sans analyser de la prose. Il construit la porte sous forme d'un IEndpointFilter ASP.NET Core qui projette le LicenseStatus de Keyright sur des codes de statut via IProblemDetailsService, ajoute Retry-After quand le service de licences est brièvement injoignable et que la fenêtre de grâce est encore ouverte, et se termine par un test WebApplicationFactory qui vérifie le statut, le type de problème et que la clé signée n'apparaît jamais dans le corps.
Lire →Mapper l'état de la licence sur un health check ASP.NET Core
Un service .NET headless n'a pas de boîte « À propos » où afficher sa licence, si bien que le seul endroit où les opérateurs voient jamais l'état de la licence est le tableau de bord de supervision — ce qui signifie que la licence doit devenir un health check. La version naïve branche la licence directement sur la sonde de readiness : une clé expirée se met à renvoyer 503, l'orchestrateur retire l'instance de la rotation puis la tue, le remplaçant démarre avec la même clé expirée, et vous avez construit une boucle de redémarrage à partir d'un événement de facturation. Cet article lit ce que les trois valeurs de HealthStatus signifient réellement pour un orchestrateur, y mappe le LicenseStatus de Keyright de sorte qu'une clé valide mais proche de l'expiration soit Degraded plutôt qu'Unhealthy, tient l'état de la licence entièrement à l'écart de la sonde de liveness pour qu'une échéance ne déclenche jamais un kill, met la validation en cache pour qu'une sonde par seconde ne revérifie pas une signature à chaque fois, et expose le détail dont les opérateurs ont besoin via le dictionnaire de données du health check. Il se termine par la disposition des tags qui sépare l'endpoint de licence de la readiness et de la liveness, et par le test qui prouve qu'une clé expirée se dégrade sans faire tomber le processus.
Lire →Une clé de licence pour de nombreuses apps et offres groupées
Vous livrez un Designer, un Renderer et une CLI, et votre client veut une seule clé pour les trois, pas trois. Le raccourci évident — donner à chaque application le même slug de produit et laisser la signature faire le reste — est celui qui vend discrètement votre application la plus chère au prix de la moins chère, car une clé qui se vérifie pour la gamme de produits se vérifie dans chaque application de la gamme. Cet article lit ce que la revendication de produit d'une licence Keyright vérifie réellement (c'est une vérification d'audience, pas une vérification de fonctionnalité), expose les trois façons de licencier une suite, montre la faille de la conception à slug partagé avec la barrière exacte qui l'ouvre, et construit la version qui tient : un seul slug pour la gamme, l'appartenance par application sous forme de droits avec espace de noms, et une barrière dans chaque application qui demande « suis-je dans cette offre groupée ? » avant toute autre chose. Il se termine par le chemin de mise à niveau d'une clé mono-application vers une clé de suite, et la solution de repli à deux clients pour les équipes qui ont déjà livré un slug par application.
Lire →Journalisation structurée des contrôles de licence, sans la clé
Le contrôle de licence est l'unique événement qui décide si votre logiciel a le droit de s'exécuter, et il est presque toujours journalisé soit comme rien du tout, soit comme un désastre — un log.LogInformation("license: {License}", info) qui sérialise l'objet entier et imprime la clé signée, la signature et l'e-mail du licencié dans un fichier qui sera expédié vers un agrégateur de logs et partagé dans un ticket de support. Cet article construit la voie médiane : un seul événement structuré par vérification, émis via un LoggerMessage généré à la compilation pour que la règle de caviardage vive à un seul endroit, avec la clé réduite à une courte empreinte qui permet à un opérateur de corréler sans jamais transporter le secret. Il mappe le LicenseStatus de Keyright sur des niveaux de log de sorte qu'une licence invalide soit une Error sur laquelle alerter et une licence saine une Information discrète, attribue une plage d'EventId stable pour qu'un tableau de bord compte les échecs de licence sans comparaison de chaînes, enveloppe la vérification dans un scope de journalisation pour que chaque ligne en aval porte l'empreinte, garde l'événement hors du chemin chaud par requête, et se termine par le test — une assertion sur FakeLogger — qui prouve que la clé brute n'atteint jamais le sink.
Lire →Pourquoi la DI par scan d'assembly casse lors du renommage
Un grand nombre d'applications .NET n'écrivent jamais leurs enregistrements DI. Elles scannent un assembly au démarrage — avec Scrutor, ou une boucle de réflexion maison — et enregistrent chaque type dont le nom se termine par « Service », « Handler » ou « Repository ». Cette convention est une comparaison de chaîne sur le nom du type, et l'obfuscation par renommage change chacun de ces noms, si bien que le prédicat t.Name.EndsWith("Handler") ne correspond à rien, les services ne sont silencieusement jamais enregistrés, et l'application lève « Unable to resolve service for type ... » à la première requête — un échec à l'exécution avec un build vert, loin de la ligne qui l'a causé. Cet article sépare les deux façons dont un scan peut trouver un type : par son nom, qui ne survit pas au renommage, et par sa forme — assignable à une interface marqueur, décoré d'un attribut, dérivé d'une base — qui y survit, parce que ce sont des identités de jetons de métadonnées que le renommage réécrit de façon cohérente des deux côtés. Il montre les enregistrements Scrutor qui cassent et leurs équivalents qui survivent, explique pourquoi AsImplementedInterfaces ne pose pas de problème alors que le prédicat sur le nom en pose un, trace la ligne que trace Nebula, donne à la fois le refactoring recommandé et la règle d'exclusion pour quand vous ne pouvez pas refactorer, et se termine par un smoke test de démarrage qui fait échouer le build obfusqué rapidement plutôt qu'à la première requête.
Lire →Obfusquer un assembly .NET visible pour COM en toute sécurité
Un assembly .NET visible pour COM est consommé par du code qui ne sait pas qu'il s'agit de .NET — une macro VBA, un VBScript, un hôte C++ hérité — et ce consommateur s'y lie par un contrat fait de trois choses qui ne se trouvent pas là où un développeur C# garde l'API publique : un GUID sur la classe et l'interface, un DispId sur chaque membre, et un ProgID qui, par défaut, est le nom du type qualifié par l'espace de noms. Obfusquez-le comme vous obfusqueriez une bibliothèque et les GUID survivent (ce sont des constantes d'attribut), mais le ProgID se déplace à l'instant où vous renommez la classe, et un client à liaison tardive qui fait CreateObject("Acme.Widget") et appelle les membres par leur nom via IDispatch se brise à la fois sur le ProgID déplacé et sur les noms de membres renommés. Cet article lit ce qu'un client COM résout réellement à chaque étape — du ProgID au CLSID au membre IDispatch —, trace la frontière entre ce que Nebula renomme (l'implémentation, le moteur) et ce qui est épinglé (les GUID, les DispId, les noms de membres qu'utilise la liaison tardive, le ProgID), montre la disposition avec [ProgId] et interface explicite qui réduit la surface épinglée, fournit la configuration, et se termine par la vérification par enregistrement-et-appel dans un script à liaison tardive comme dans un client tlb à liaison précoce.
Lire →Obfusquer un module binaire PowerShell en toute sécurité
Un module binaire PowerShell est un assembly .NET ordinaire que PowerShell charge par réflexion, et c'est une chose singulière à obfusquer, car son contrat public ne se trouve pas là où les développeurs C# s'attendent à le voir. Le nom du cmdlet — Get-Widget — provient de l'attribut [Cmdlet], si bien que la classe qui l'implémente peut être renommée en n'importe quoi. Mais les noms de paramètres — -Name, -Force, -Path — sont littéralement les noms de vos propriétés publiques : renommez-les et chaque script, chaque complétion par tabulation et chaque page Get-Help se brise. Il en va de même pour les objets que le cmdlet écrit dans le pipeline, dont les noms de propriétés sont les en-têtes de colonnes de Format-Table et les cibles de Select-Object. Cet article lit exactement ce sur quoi le runtime PowerShell effectue sa réflexion lorsqu'il importe un module et lie les paramètres, trace la frontière entre ce que Nebula peut renommer (la classe du cmdlet, le moteur derrière elle) et ce qui est épinglé (propriétés de paramètres, propriétés de sortie, les attributs), montre la disposition « cmdlet mince, moteur épais » qui réduit la surface épinglée, fournit la configuration, et se termine par la vérification par import-et-invocation qui prouve réellement que le module protégé fonctionne.
Lire →Obfusquer des types System.Text.Json sans casser le JSON
System.Text.Json en mode réflexion lit votre DTO par les noms de ses propriétés — Order devient "order" sur le fil parce que la propriété s'appelle littéralement Order — ce qui signifie qu'à l'instant où un obfuscateur renomme cette propriété en a, le JSON produit par votre service devient { "a": …, "b": … } et chaque consommateur, chaque aller-retour casse, silencieusement, à l'exécution, là où aucune étape de build ne peut le détecter. Cet article identifie précisément quels noms le sérialiseur lie et lesquels il ne lie pas : pourquoi une auto-propriété nue est une mine, pourquoi [JsonPropertyName("order")] est le correctif qui fait du nom sur le fil une constante que le renommeur ne peut pas toucher, pourquoi un [JsonConstructor] paramétré associe les paramètres aux propriétés par nom, de sorte que les arguments du constructeur sont eux aussi épinglés, comment [JsonExtensionData] et l'attribut d'énumération [JsonStringEnumMemberName] se comportent, et pourquoi le JsonSerializerContext généré à la compilation change complètement la donne. Il montre la configuration Nebula qui préserve le contrat — attribuer les noms, laisser les membres se renommer — et le test d'aller-retour qui prouve qu'un build protégé désérialise toujours ce qu'il a sérialisé.
Lire →Comment les méthodes d'interface par défaut se décompilent
Une méthode d'interface par défaut enfreint la plus ancienne règle qu'un décompilateur connaisse au sujet des interfaces — qu'elles contiennent des signatures, pas des corps. Depuis C# 8, une interface peut livrer une implémentation fonctionnelle, et une classe qui implémente l'interface peut ne rien fournir du tout et obtenir malgré tout le comportement. Cela laisse trois énigmes à Glass.NET : une méthode d'instance virtuelle dotée d'un corps, posée dans une interface (ni abstraite, ni méthode de classe), une classe dont les métadonnées ne contiennent ni redéfinition ni MethodImpl mais qui se comporte comme si elle en avait une, et un site d'appel qui doit passer par le type d'interface parce que le membre est invisible sur la classe. Cet article lit l'IL des trois cas — le newslot virtual doté d'un corps, le MethodImpl absent, le callvirt contre l'interface — et montre comment Glass reconstruit l'implémentation par défaut, laisse la classe implémentante correctement vide, et conserve le transtypage vers l'interface que le langage exige réellement.
Lire →Comment les filtres d'exception se décompilent en C#
Un bloc catch avec un type est l'une des choses les plus simples que lit un décompilateur : une clause de gestionnaire avec un token de type, terminé. Un catch avec une clause when est l'une des plus épineuses, car c'est un type de région d'exception entièrement différent. Le filtre n'a pas de token de type ; le test de type se déplace dans un bloc d'IL séparé qui s'exécute pendant que la pile est encore en cours de déroulement, évalue la condition when, et se termine par un endfilter qui renvoie 1 pour exécuter le gestionnaire ou 0 pour continuer la recherche. Reconstruire catch (IOException e) when (e.HResult == 5) signifie reconnaître cette structure à deux blocs, remonter l'objet d'exception que le runtime a poussé sur la pile dans la variable e, extraire le test de type du filtre comme type du catch, et lire le reste comme l'expression when — puis savoir que les exceptions levées à l'intérieur du filtre sont avalées, ce qui est une garantie réelle du langage visible dans l'IL. Cet article lit l'IL exact qu'émet un catch filtré, parcourt le protocole d'endfilter et montre comment Glass.NET reconstruit la clause.
Lire →Comment l'instruction fixed se décompile en C#
Il n'y a pas d'instruction fixed en IL. Ce que le compilateur C# émet à la place est une variable locale avec le modificateur pinned dans sa signature, quelques instructions qui calculent un pointeur à partir de ce que vous avez épinglé — avec des gardes que vous n'avez jamais écrites — et un store qui vide la locale à la fin du bloc. Il n'y a pas de try/finally, parce qu'un épinglage est une propriété de la durée de vie d'une locale plutôt qu'une région de code. L'initialiseur est abaissé de quatre façons différentes selon ce que vous avez épinglé : un tableau reçoit un test null-ou-vide et un ldelema de l'élément zéro, une chaîne reçoit soit l'arithmétique héritée OffsetToStringData soit un appel à GetPinnableReference, un Span ou tout type doté d'une méthode GetPinnableReference reçoit cet appel sur son adresse, et &field ou &local reçoit un simple ldflda ou ldloca. Cet article lit l'IL réel de chaque forme, explique pourquoi un tableau vide donne un pointeur null plutôt qu'une exception, et montre comment Glass.NET s'ancre sur la locale épinglée pour replier la machinerie en la ligne fixed que vous avez écrite.
Lire →Comment les arguments optionnels et nommés se décompilent
Un paramètre optionnel n'a aucun coût à l'exécution au site d'appel que vous avez écrit — la valeur par défaut n'est pas stockée dans la méthode, elle est substituée par le compilateur dans chaque appelant. Donc en IL il n'y a aucun signe d'un argument par défaut, sauf à l'appel : un littéral poussé là où vous n'aviez rien écrit. La valeur par défaut elle-même vit loin de là, dans la table de métadonnées Constant attachée au paramètre, à côté d'un indicateur Optional ; un décompilateur qui lit la méthode doit aller l'y chercher pour afficher = 0 ou = null. Les arguments nommés sont plus étranges encore : ils disparaissent entièrement lorsqu'ils sont dans l'ordre, et lorsqu'ils sont dans le désordre le compilateur les réécrit en poussées positionnelles dans l'ordre — à moins que les évaluer dans le désordre ait des effets de bord, auquel cas il déverse d'abord chaque argument dans un temporaire pour préserver l'évaluation de gauche à droite, laissant un bloc de stockages qui ressemblent à du code que vous auriez écrit. Cet article lit l'IL et les métadonnées des deux, montre les lignes de la table Constant derrière une valeur par défaut, parcourt les temporaires de réordonnancement, et explique comment Glass.NET récupère les valeurs par défaut optionnelles et décide quand un argument nommé vaut la peine d'être affiché.
Lire →Décalage d'horloge dans la vérification de licence
Un client active une licence à 9 h 00, et votre application la rejette comme « pas encore valide ». Rien n'est falsifié, rien n'est expiré — l'horloge de son portable a quatre minutes de retard sur la machine qui a émis la clé, si bien que la revendication NotBefore se situe dans son futur. Cet article traite du problème de l'horloge honnête (et non de l'attaquant qui recule l'horloge, qui fait l'objet d'un autre article) : les quelques minutes de désaccord entre l'horloge de l'émetteur et celle du vérificateur qui transforment une licence correcte en échec injustifié au pire moment possible — juste après l'achat. Il lit les trois revendications temporelles d'une licence Keyright (IssuedAt, NotBefore, Expiry), montre la comparaison naïve qui casse, et construit la vérification tolérante au décalage : une petite tolérance symétrique sur NotBefore et Expiry, pourquoi cette tolérance est asymétrique dans son intention, et pourquoi le temps écoulé au sein d'une session doit provenir d'une horloge monotone, et non de l'horloge murale à laquelle vous venez de décider de ne pas entièrement vous fier.
Lire →Licencier une bibliothèque de composants .NET
Une bibliothèque de composants a deux publics et un seul d'entre eux est votre client. Le développeur qui achète votre moteur PDF ou votre contrôle de graphiques détient la licence ; les utilisateurs finaux qui exécutent les applications construites avec n'ont jamais entendu parler de vous, ne doivent jamais se voir demander une clé, et travaillent sur des machines que vous ne pouvez pas activer. Cela change où une licence est vérifiée et ce qui voyage à l'intérieur du binaire livré. Cet article construit la conception vers laquelle convergent la plupart des éditeurs de contrôles avec Keyright : une licence développeur perpétuelle, non liée à une machine, vérifiée au moment du build par une cible MSBuild dans votre package NuGet, incorporée dans l'assembly du client sous forme d'attribut signé, et vérifiée à nouveau à l'exécution, hors ligne, avec la clé publique de votre bibliothèque — avec un entitlement updates-until au lieu d'une expiration pour que l'application du client ne s'arrête jamais, une revendication d'audience pour qu'une licence extraite d'une application n'en déverrouille pas une autre, et un nom de titulaire signé dans chaque binaire qui l'utilise, à la manière d'un filigrane.
Lire →Vérifier une licence sur Native AOT
Native AOT et l'élagage (trimming) complet récompensent la seule chose qu'une vérification de licence devrait déjà être : une fonction pure sur des octets. Mais les commodités qui rendent un SDK agréable sur le JIT — un sérialiseur JSON par réflexion, le chargement d'une clé par son nom, l'extraction de l'algorithme de signature depuis une chaîne — sont exactement ce que l'élagueur supprime et ce pour quoi le compilateur AOT refuse de générer du code. Cet article prend une vérification hors ligne de Keyright et la rend AOT-propre de bout en bout : en intégrant la clé publique sous forme de ReadOnlySpan<byte> qui se compile en un pointeur vers la section de données sans aucune allocation, en l'important avec ImportSubjectPublicKeyInfo et en la vérifiant avec ECDsa.VerifyData — tous deux sûrs pour l'élagage — et en lisant la charge utile signée avec un Utf8JsonReader plutôt qu'un sérialiseur par réflexion, de sorte que l'ensemble du chemin ne porte aucun RequiresDynamicCode ni RequiresUnreferencedCode et ne produit aucun avertissement d'élagage. Il lit l'IL de l'optimisation span-sur-données-statiques, montre le seul appel à JsonSerializer qui aurait empoisonné la publication, et explique pourquoi un vérificateur de licence est la partie de votre application la plus facile à rendre AOT.
Lire →Des rappels de renouvellement qui n'importunent pas vos utilisateurs
Une bannière de compte à rebours est facile à rater de deux façons opposées : elle agace un client perpétuel qui n'a rien à renouveler, ou elle reste muette jusqu'à ce qu'un abonnement ait déjà expiré et que l'application soit retombée en fail-closed sur Free. Les deux bugs viennent de la même erreur : calculer le message à partir du fichier de licence brut au lieu du résultat validé. Cet article construit le rappel de renouvellement de la bonne manière, à partir du LicenseInfo de Keyright : en utilisant Kind pour distinguer une licence perpétuelle d'un abonnement et d'un essai, DaysRemaining et IsExpiringSoon pour décider quand parler, et le fait qu'un abonnement expiré se valide en Free — donc le rappel doit se déclencher tant que la licence est encore valide, pas après. Il lit la petite logique derrière Kind, montre pourquoi une licence perpétuelle a un ExpiryUtc nul et ne doit jamais afficher de compte à rebours, et câble une bannière qui relance le client qui expire en silence et laisse tous les autres tranquilles.
Lire →Obfusquer un assembly F# sans casser les unions
F# compile vers le même IL que C#, donc un renommeur peut l'obfusquer — mais F# s'appuie sur une couche de métadonnées émises par le compilateur dont C# n'a aucun équivalent, et un renommeur qui ne la comprend pas casse en silence des choses qui compilent quand même. Une union discriminée n'est pas un type somme pour le CLR ; c'est une classe abstraite avec une sous-classe imbriquée par cas, un entier Tag et un attribut [CompilationMapping(SourceConstructFlags.SumType)] que la réflexion de FSharp.Core lit pour retrouver les cas. Renommez les types de cas aveuglément, ou retirez cet attribut comme des « métadonnées inutilisées », et FSharpType.GetUnionCases ne renvoie rien, l'impression avec %A cesse de nommer vos cas, et tout sérialiseur conscient de F# perd la forme — le tout avec une compilation propre. Cet article lit l'IL qu'une union, un enregistrement et un module émettent réellement, montre exactement quels noms et attributs sont porteurs parce que FSharp.Core les observe à l'exécution, et configure Nebula pour renommer la logique tout en préservant le contrat de réflexion dont dépend F#.
Lire →Obfusquer les readonly structs et les ref returns en toute sécurité
Un readonly struct, un paramètre in et un retour ref readonly ne sont pas de simples commodités de code source — ils sont encodés dans les métadonnées sous forme de modificateurs personnalisés et d'attributs émis par le compilateur, que le compilateur C# relit pour décider si un site d'appel fait une copie défensive cachée, quelle surcharge l'emporte, et si une valeur peut même être passée par référence. Un modreq(InAttribute) sur un paramètre fait partie de sa signature, donc le supprimer change l'identité de la méthode et casse la liaison ; retirer IsReadOnlyAttribute d'un struct fait que chaque appel in vers lui se met à copier. Un obfuscateur qui traite tout cela comme des métadonnées décoratives à renommer ou à jeter produit des assemblies qui se chargent encore mais se comportent différemment, ou qui échouent à se lier contre des appelants qu'il ne contrôle pas. Cet article lit l'IL de chaque fonctionnalité, montre exactement quelles pièces relèvent de la signature et lesquelles sont des attributs, parcourt les trois façons dont un renommeur négligent les corrompt, et explique comment Nebula préserve les modreqs et les attributs bien connus du compilateur à l'identique tout en renommant tout ce qui vous appartient réellement.
Lire →Obfusquer un générateur de source Roslyn en toute sécurité
Un générateur de source est un objet étrange à obfusquer : c'est un assembly .NET Standard 2.0 que le compilateur charge par réflexion et exécute à l'intérieur du build de votre client, et c'est là que réside votre logique de compilation la plus précieuse — précisément le code que vous livrez et que vous préféreriez ne pas confier à un décompilateur. La bonne nouvelle, c'est que Roslyn découvre les générateurs par attribut, et non par nom, si bien que Nebula peut renommer le type du générateur et toute sa surface privée sans aucun effet sur la découverte. Les parties figées sont peu nombreuses et bien précises : l'attribut [Generator] doit survivre, le constructeur public sans paramètre doit rester public (le compilateur l'instancie avec Activator.CreateInstance), et la méthode d'interface qu'il appelle doit conserver son emplacement. Cet article lit ce sur quoi le GeneratorDriver réfléchit réellement, trace la frontière entre ce qui se renomme et ce qui est porteur, montre la configuration Nebula, et dissipe le contresens le plus fréquent — obfusquer le générateur n'obfusque pas le code qu'il émet.
Lire →Obfusquer les membres virtuels et d'interface en toute sécurité
Renommer une méthode privée est une modification locale. Renommer une méthode virtuelle ne l'est pas, parce que son nom fait partie de la façon dont le CLR câble la répartition des appels : un override réutilise son slot de base en faisant correspondre nom et signature au chargement du type, une implémentation d'interface implicite est trouvée de la même façon, et seule une implémentation explicite est liée par une ligne MethodImpl qui porte des jetons au lieu de texte. Ratez le regroupement et vous obtenez soit une TypeLoadException dès que le type se charge — soit, pire, rien du tout, pendant que l'override se détache silencieusement et que l'implémentation de base s'exécute à sa place. Cet article lit l'IL de chaque liaison, montre lesquelles sont par nom et lesquelles sont par table, parcourt les trois façons dont un renommeur naïf les casse, et explique comment Nebula regroupe une méthode virtuelle avec chaque override et chaque implémentation auxquels elle est connectée — à travers les types et les interfaces — pour que le slot entier soit renommé vers un seul nom ou conservé intact quand l'un de ses membres franchit la frontière vers un assembly que vous ne contrôlez pas.
Lire →Ce qu'un décompilateur récupère des types anonymes
Un type anonyme n'a pas de nom que vous ayez écrit, mais c'est une vraie classe dans les métadonnées — une classe générique que le compilateur synthétise, nommée quelque chose comme <>f__AnonymousType0`2, avec une propriété en lecture seule par membre, un constructeur qui les prend toutes, et des redéfinitions de Equals, GetHashCode et ToString. L'astuce qui la rend réutilisable est que la classe générée est générique sur les types de ses propriétés, de sorte que deux sites new { } avec les mêmes noms de propriétés dans le même ordre partagent un seul type sous-jacent instancié avec des arguments de type différents. Cet article lit la classe générée et le site d'appel newobj en IL, montre où vivent réellement les noms des propriétés (sur les propriétés du type généré, pas sur les paramètres de type <Name>j__TPar), parcourt le Equals structurel et le GetHashCode à combinaison de hachage que le compilateur écrit, et explique comment Glass.NET reconnaît le motif et le replie en new { Name = ..., Total = ... } au lieu de vous laisser un type générique imprononçable.
Lire →Comment Glass reconstruit boucles et conditions à partir de sauts
L'IL n'a pas de while, pas de for, pas de else — il a des blocs de base et des instructions de saut : br, brtrue, brfalse, switch. Une boucle for et une réécriture en goto-spaghetti de la même boucle peuvent compiler en un IL identique, si bien qu'un décompilateur ne peut pas relire la structure ; il doit la reconstruire. Cet article parcourt le pipeline réel qu'exécute Glass.NET : découper la méthode en blocs de base à chaque saut et à chaque cible de saut, construire un graphe de flot de contrôle, calculer les dominateurs pour trouver quel bloc gouverne lequel, détecter les boucles naturelles à partir des arêtes arrière vers le bloc qui les domine, et structurer les sauts avant en if/else — puis explique le cas difficile et honnête, le flot de contrôle irréductible, où aucune boucle propre n'existe et où un décompilateur doit soit dupliquer du code, soit se rabattre sur des étiquettes et des goto.
Lire →Comment foreach se décompile en C#
Il n'y a pas de foreach en IL. Le compilateur C# l'abaisse vers l'une de trois formes complètement différentes selon ce que vous itérez — un appel à GetEnumerator avec une boucle while et un try/finally caché qui dispose l'énumérateur, une version à énumérateur struct sans aucun dispose, ou, sur un tableau ou un span, une simple boucle for à index sans énumérateur en vue. Un décompilateur ne voit que le code abaissé et doit reconnaître quel motif il regarde pour réimprimer foreach au lieu de la machinerie. Cet article lit l'IL réel de chaque cas, montre pourquoi le Dispose vit dans un finally que la source n'a jamais écrit, pourquoi l'énumérateur struct le saute, et comment Glass.NET fait correspondre la forme — le trio GetEnumerator/MoveNext/get_Current, le try/finally, le test IDisposable — pour retrouver la boucle que vous avez réellement écrite.
Lire →Choisir un algorithme de signature pour les clés de licence
Une clé de licence est une charge utile signée, et l'algorithme de signature que vous choisissez n'est pas un détail interchangeable — il décide de la longueur de la clé que votre client doit taper, de la vitesse à laquelle chaque lancement la vérifie, et du risque qu'une seule erreur dans votre code d'émission fasse fuiter la clé privée. Les signatures RSA-2048 font 256 octets, ce qui transforme une clé tapable en un mur de base32 ; ECDSA P-256 en fait le tiers mais porte un nonce qui, réutilisé, livre votre clé à un attaquant ; Ed25519 fait 64 octets, est déterministe et n'a aucun nonce à rater. Cet article pèse les trois sur les axes qui comptent vraiment pour une licence hors ligne — taille de la signature et de la clé publique, coût de vérification au démarrage à froid, déterminisme et modes de défaillance, et à quoi ressemble chacun dans System.Security.Cryptography — et explique pourquoi Keyright signe avec Ed25519 par défaut.
Lire →Épingler votre clé publique de vérification de licence
Votre application vérifie une licence parce qu'une signature concorde avec une clé publique embarquée dans l'assembly. Mais cette clé, ce sont des données : une constante base64 que tout attaquant capable d'éditer votre DLL peut trouver et écraser par une clé qu'il contrôle, si bien que ses licences auto-signées se vérifient désormais et que la vôtre est oubliée. C'est la substitution d'ancre de confiance, et c'est l'attaque au plus fort effet de levier contre les licences offline-first. Cet article montre l'attaque au niveau de l'IL — le ldstr qui charge la clé, l'unique plage d'octets qu'un patch touche — puis en relève le coût : prendre l'empreinte de la clé contre une valeur entrelacée dans le flot de contrôle au lieu de la laisser seule, la vérifier à plusieurs endroits, porter plusieurs clés avec AdditionalPublicKeysBase64 pour qu'un seul remplacement ne suffise pas, et associer le contrôle côté client au strong-naming, à l'anti-tamper et au report-home afin qu'un build altéré soit à la fois plus difficile à produire et visible lorsqu'il circule.
Lire →Concevoir une clé de licence que des humains peuvent taper
Une licence Keyright, ce sont des octets signés, mais ce qu'un client lit sur une facture, tape dans une boîte de dialogue d'activation ou dicte au téléphone est une chaîne de caractères — et base64 est une chaîne exécrable pour ce travail. Elle est sensible à la casse, elle utilise + et / que les clients mail et les shells massacrent, et un seul caractère mal tapé produit un échec de signature sans la moindre indication de l'endroit de l'erreur. Cet article construit l'encodage de transport que Keyright utilise réellement : du base32 Crockford pour que l'alphabet survive à un appel téléphonique et à une touche Maj, des segments de cinq caractères pour que l'œil puisse suivre sa position, et un symbole de contrôle modulo 37 qui attrape chaque erreur d'un caractère et presque chaque transposition avant même de lancer la coûteuse vérification de signature. Il montre le vrai code d'encodage et de décodage en C#, la normalisation qui ramène une clé tapée n'importe comment vers des octets canoniques, et pourquoi le symbole de contrôle est une fonctionnalité d'ergonomie et jamais de sécurité.
Lire →Obfusquer les enums sans divulguer les noms
Renommez un enum et ses membres et un décompilateur imprime encore LicenseTier.Pro, pas a.b, car un enum est une classe scellée dont les membres sont des champs const littéraux publics, et dès que votre code appelle ToString() ou Enum.Parse le runtime lit ces noms de champ directement dans les métadonnées à l'exécution. Les renommer en a, b, c est légal et ne vous coûte rien sauf la seule chose que vous vouliez : un aller-retour par le nom casse, car "Pro" ne correspond plus à un champ appelé a. Cet article lit l'IL en lequel un enum se compile, montre où vivent les noms (la table Field et le heap #Strings, pas les valeurs), parcourt exactement ce qui casse au renommage — ToString, Enum.Parse, le formatage de [Flags], la sérialisation JSON par chaîne, Enum.GetNames — et comment Nebula cadre le traitement des enums pour que les valeurs qui pilotent votre logique soient protégées tandis que les noms dont dépend votre protocole restent intacts.
Lire →Obfusquer les génériques sans casser la réflexion
Un paramètre de type générique comme TResult est un nom dans les métadonnées — une ligne de la table GenericParam avec une chaîne dans #Strings — donc un renommeur peut le transformer en T0 et un décompilateur affichera fidèlement T0, ce qui est exactement le résultat inoffensif que vous voulez. Mais les génériques sont l'endroit où un renommage naïf casse discrètement des choses, parce que le CLR identifie une instanciation par position et par arité, pas par nom, alors que votre code de réflexion identifie un paramètre de type par son nom. Cet article lit ce qu'une méthode et une classe génériques compilent réellement — les tables GenericParam et GenericParamConstraint, le MethodSpec et le TypeSpec qui enregistrent une instanciation par index — montre pourquoi renommer le paramètre est gratuit mais renommer un type de contrainte ne l'est pas, et parcourt les appels de réflexion (Type.GetGenericArguments().Name, MakeGenericType, GetMethod sur un générique ouvert) qui relisent les noms et cassent quand un renommeur touche la mauvaise chose.
Lire →Comment Nebula réutilise un même nom pour plusieurs membres
Un renommeur naïf donne à chaque membre un nom court unique — a, b, c, d — et s'arrête là. Il laisse de la valeur sur la table, parce que .NET n'identifie pas un membre par son nom. Une méthode est identifiée par son nom joint à sa signature, un champ par son nom et son type déclarant, et le runtime lie chaque appel via un jeton de métadonnées résolu au chargement, pas en comparant des chaînes. Cela signifie que vous pouvez renommer des dizaines de méthodes sans rapport entre elles vers le seul nom a, tant que leurs signatures diffèrent, et l'assembly se charge, se vérifie et s'exécute toujours. Cet article lit les métadonnées MethodDef et le tas de chaînes pour montrer pourquoi le renommage par collision est légal, parcourt les règles exactes qui le bornent — conflits de signatures identiques, chaînes de redéfinitions virtuelles, implémentations d'interface explicites — et explique comment Nebula compacte les noms jusqu'à un minuscule ensemble réutilisé qui réduit le tas de chaînes et transforme la sortie d'un décompilateur en un mur illisible de membres au nom identique.
Lire →Comment les événements C# se décompilent en .NET
Une ligne de C# — public event EventHandler Changed; — devient quatre choses dans l'assembly : un champ délégué privé, un accesseur add_Changed et un accesseur remove_Changed, et une ligne de la table Event qui les relie via MethodSemantics. Les accesseurs ne sont pas non plus de simples affectations : depuis C# 4, le compilateur émet une boucle Interlocked.CompareExchange sans verrou autour de Delegate.Combine et Delegate.Remove, et les binaires plus anciens portent à la place une variante [MethodImpl(Synchronized)]. Un décompilateur doit reconnaître les deux formes pour replier les quatre pièces en une seule déclaration, conserver un add/remove explicite lorsque l'auteur en a écrit un, et restituer le site de levée ?.Invoke plutôt que la danse dup/brtrue en laquelle il se compile. Voici les métadonnées, l'IL, et ce qu'en fait Glass.NET.
Lire →Comment les opérateurs conditionnels null se décompilent
L'opérateur conditionnel null se lit comme un seul symbole bien net — order?.Customer?.Name — mais il n'existe aucune instruction ?. en IL. Le compilateur C# l'abaisse en contrôles de nullité et branchements ordinaires, et le détail qui fait qu'une chaîne se décompile proprement est que chaque maillon court-circuite vers la même cible partagée, et non vers un nid de cibles propres. Cet article lit le vrai IL d'une chaîne à deux maillons, montre pourquoi le premier récepteur est contrôlé par un simple brtrue tandis qu'un résultat intermédiaire est dupliqué par dup puis dépilé par pop, détaille l'élévation Nullable qui transforme s?.Length en int? avec un initobj du côté null et un Nullable..ctor de l'autre, couvre les abaissements de ?? et ??= qui partagent la même forme de court-circuit, et explique comment Glass.NET reconnaît le motif et replie les branchements en ?. et ?? au lieu de vous laisser un labyrinthe d'étiquettes.
Lire →Où les collections params cachent le tableau
Pendant vingt ans, un paramètre params signifiait une seule chose en IL : l'appelant construisait un newarr et le remplissait. C# 13 a généralisé params à n'importe quel type de collection, et le cas vedette — params ReadOnlySpan<T> — n'alloue strictement rien sur le tas. L'appelant empile les arguments dans un tampon inline-array généré par le compilateur et enveloppe un span autour ; params List<T> passe quant à lui par un collection builder. L'indice de décompilation se trouve entièrement sur le site d'appel, pas dans la signature. Voici ce que chaque forme émet, comment un décompilateur replie le tampon en un appel ordinaire, et pourquoi un params ReadOnlySpan<T> qui affiche un newarr est un chemin de repli froid qui mérite attention.
Lire →Comment un switch sur chaînes se décompile en C#
Un switch sur un entier se compile en une seule instruction switch IL. Un switch sur une chaîne ne le peut pas — il n'existe pas de table de saut pour du texte — alors dès que vous avez plus d'une poignée de cas, le compilateur C# le réécrit discrètement en un aiguillage à deux étages : hacher la chaîne avec un ComputeStringHash synthétisé, brancher selon le hachage vers un candidat, puis confirmer avec un String.Equals ordinal avant de sauter au bras. Ce billet lit l'IL réel d'un grand switch sur chaînes, montre l'assistant FNV <PrivateImplementationDetails>.ComputeStringHash et le second switch dense sur un index de cas, explique pourquoi le contrôle d'égalité n'est pas optionnel, et parcourt comment Glass.NET reconnaît toute la forme et la replie en switch (s) { case "...": } au lieu de vous laisser une page de constantes de hachage.
Lire →Mettre en cache la vérification de signature sans réponse périmée
Une licence Keyright signée se vérifie par un contrôle de signature RSA, et ce contrôle coûte de vraies microsecondes. Appelez Validate() à chaque requête et vous avez placé de la cryptographie à clé publique sur votre chemin critique sans aucune raison — la signature n'a pas changé depuis le démarrage. Mais vous ne pouvez pas non plus simplement mettre le résultat en cache pour toujours, car la réponse dépend du temps : un droit peut expirer à midi, un bail peut être récupéré, un renouvellement peut élargir le plan. Cet article sépare les deux moitiés d'un contrôle de licence — la vérification de signature coûteuse et cacheable, et l'évaluation bon marché, obligatoirement par appel, de la licence à l'instant présent — mesure ce que chacune coûte, et montre une mémoïsation à deux niveaux qui garde la crypto hors du chemin critique sans jamais renvoyer une réponse en retard d'une minute.
Lire →Les droits comme politiques d'autorisation ASP.NET Core
La plupart des applications vérifient la licence une fois au démarrage et dispersent des appels IsEnabled dans tout le code. Dans un service ASP.NET Core, c'est une erreur : vous disposez déjà d'un pipeline d'autorisation conçu pour répondre à « cet appelant a-t-il le droit de faire cela ? », et un droit sous licence est exactement cette question. Voici comment projeter les droits Keyright sur le système d'autorisation : une exigence qui nomme un droit, un handler qui lit la licence validée, un fournisseur de politiques qui les crée à la demande, et [Authorize(Policy = "ent:export")] sur les endpoints qui en ont besoin — le tout fail-closed, le tout hors ligne.
Lire →Activation de licence sans interface pour un outil CLI .NET
Un outil en ligne de commande n'a pas d'écran de paramètres, s'exécute souvent sur une machine devant laquelle personne n'est assis, et est piloté par des scripts qui ne lisent que des codes de sortie. Cela casse le scénario de licence des applications de bureau — coller une clé dans une boîte de dialogue, mettre en cache un bail, continuer. Voici comment licencier un outil dotnet ou une tâche de build avec Keyright sans interface : une sous-commande `license` qui active et rend compte, les six emplacements où le SDK cherche une licence et l'idiome CLI qui correspond à chacun, un verrouillage fermé par défaut qui n'invite jamais à saisir quoi que ce soit lorsque stdin n'est pas un terminal, et le problème des runners CI éphémères résolu avec un fichier de licence hors ligne transporté dans KEYRIGHT_LICENSE plutôt qu'un siège par job.
Lire →Pourquoi les machines à états async survivent au renommage
Décompilez un assembly obfusqué et la chose la plus effrayante que vous voyez est un MoveNext plein de flux de contrôle aplati et des champs nommés <>1__state. On suppose que le renommage a forcément cassé le code async. Ce n'est pas le cas — car chaque lien entre une méthode async, son type de machine à états généré et l'AsyncTaskMethodBuilder est un jeton de métadonnées, pas une recherche par nom, alors renommer le type et ses champs en a et b ne change rien que le runtime lise. Mais il y a une chose qu'un obfuscateur négligent peut réellement casser : MoveNext, SetStateMachine, Current et Dispose sont des méthodes d'interface, et les renommer sans réécrire le lien d'interface (le MethodImpl) laisse le builder appeler une méthode qui n'implémente plus IAsyncStateMachine. Ce billet lit l'abaissement réel d'une méthode async et d'un itérateur, montre quels noms sont libres et quel lien doit être préservé, et explique le compromis du durcissement des métadonnées : retirez l'attribut AsyncStateMachine pour une build de release et sachez que cela coûte le débogage pas-à-pas d'async, pas la correction.
Lire →Obfusquer les attributs personnalisés sans casser la réflexion
Un attribut personnalisé n'est pas un commentaire que le compilateur jette — c'est une ligne de la table de métadonnées CustomAttribute qui pointe, par jeton, vers un constructeur, et transporte un blob d'arguments positionnels et nommés. Cette structure décide précisément de ce que l'obfuscation peut toucher ou non. Renommez la classe d'attribut et le GetCustomAttribute<T>() basé sur le jeton continue de fonctionner, car les jetons se moquent des noms ; renommez-la et le GetCustomAttributes().First(a => a.GetType().Name == "FeatureGate") à clé textuelle casse, car il lisait un nom que vous venez de supprimer. Les arguments nommés sont la partie subtile : ils référencent un champ ou une propriété par son nom sous forme de chaîne dans le blob, de sorte qu'un renommeur qui déplace l'un sans l'autre produit un assembly qui lève TypeLoadException au chargement. Cet article lit les vraies métadonnées, montre quels motifs de réflexion survivent à un renommage et lesquels non, et explique comment Nebula garde les usages d'attributs cohérents tout en retirant les noms qu'un attaquant lirait.
Lire →Obfusquer un assembly dont les tests doivent encore réussir
Renommer les membres internes est là où l'obfuscation justifie son existence — mais [InternalsVisibleTo] transforme discrètement certains de ces membres internes en contrat. Un projet de tests, un assembly frère ou un mock généré atteint vos types internes par leur nom, et ce nom n'existe qu'à la compilation. Obfusquez le producteur seul et l'ami cesse de compiler ou, pire, un mock basé sur la réflexion échoue à l'exécution. Voici exactement ce que fait [InternalsVisibleTo] dans les métadonnées, pourquoi Nebula.NET préserve pour vous le cas mono-assembly, et comment garder un véritable assembly ami au vert en obfusquant la paire ensemble.
Lire →Obfusquer le code généré par générateur de source en toute sécurité
Les générateurs de source s'exécutent à l'intérieur du compilateur et émettent du C# ordinaire dans votre assembly, de sorte que l'IL qu'ils produisent est indiscernable du code que vous avez tapé. La conséquence utile pour l'obfuscation est que les générateurs résolvent les noms à la compilation : un contexte System.Text.Json capture "Name" sous forme de littéral de chaîne et atteint la propriété via un délégué, le binder de configuration bascule sur des clés littérales, et un GeneratedRegex n'est que pure identité de type. Renommez tout et le JSON, les options liées et la regex continuent de fonctionner — contrairement à leurs équivalents basés sur la réflexion. Ce que les générateurs laissent derrière eux, ce sont des littéraux : le motif de la regex, le modèle de message de journal, et un nameof() qui grave le nom original de votre méthode dans un EventId. Voici ce que chaque générateur émet, ce que Nebula.NET renomme en toute sécurité, et ce qu'il faut chiffrer ou exclure.
Lire →Vérifier une même clé de licence sur quatre runtimes
Une gamme de produits est rarement un seul langage — une application de bureau .NET, une CLI Node, un outil de données Python, un service JVM, le tout vendu comme un seul produit. La réponse paresseuse donne à chacun son propre système de licence et laisse le client jongler avec quatre clés. La bonne : un seul tenant signe une licence avec une clé privée RSA, chaque composant intègre la même clé publique, et quatre SDK vérifient hors ligne le format identique de licence et de bail signés. Ce billet montre le même flux initialiser-valider-restreindre en C#, JavaScript, Python et Java côte à côte, explique pourquoi l'empreinte machine est compatible octet pour octet entre tous pour qu'un siège couvre chaque composant sur une machine, et couvre les deux choses qui sont véritablement par composant — le cache local du bail et le chemin de résolution de la licence — ainsi que la façon dont une rotation de clé traverse toute la gamme d'un coup.
Lire →Comment les membres init-only et required se décompilent
init et required sont deux des mots-clés les plus petits d'apparence en C# et deux des plus faciles à perdre pour un décompilateur. Un accesseur init n'est qu'un accesseur set dont la signature porte un modificateur requis — modreq(IsExternalInit) — et un décompilateur qui ne regarde pas le modificateur l'affiche comme un set ordinaire, vous remettant discrètement un type dont les propriétés peuvent être réaffectées après construction. required est pire : ce sont trois attributs distincts travaillant ensemble — RequiredMemberAttribute sur chaque membre, RequiredMemberAttribute sur le type et CompilerFeatureRequired sur le type — plus un SetsRequiredMembers sur tout constructeur qui les satisfait, et un décompilateur qui les laisse tomber produit du code dont les appelants ne sont plus forcés d'affecter quoi que ce soit. Ce billet lit l'IL et les métadonnées des deux fonctionnalités, montre la forme exacte au niveau octet du modreq et des blobs d'attributs, parcourt la façon dont Glass.NET reconstruit init, required et [SetsRequiredMembers], et explique pourquoi sauter l'étape change silencieusement le contrat public d'un type.
Lire →Comment les surcharges d'opérateurs se décompilent en C#
Un opérateur défini par l'utilisateur est une méthode statique avec un nom réservé et l'indicateur specialname — op_Addition, op_Implicit, op_Equality — et le ramener à une déclaration d'opérateur ressemble à une recherche dans une table. Trois choses le rendent plus difficile que la table. Les conversions définies par l'utilisateur peuvent être surchargées sur le seul type de retour, ce qui est de l'IL légal et du C# illégal : deux méthodes op_Explicit aux paramètres identiques ne diffèrent que par ce qu'elles renvoient, de sorte qu'un décompilateur qui les émet comme méthodes ordinaires produit une source qui ne peut pas compiler. C# 11 a ajouté les opérateurs checked — op_CheckedAddition, op_CheckedExplicit — qui doivent être rendus avec le mot-clé checked et appariés à leur jumeau unchecked, sinon chaque site d'appel checked(a + b) se décompile en appel de méthode. Et op_True/op_False, op_Increment et les opérateurs d'affectation composée d'instance de C# 14 compilent chacun en motifs d'appel qu'il faut replier en syntaxe plutôt qu'afficher comme invocations. Ce billet lit l'IL de chacun, montre les sites d'appel qui guident la reconstruction, et parcourt la façon dont Glass.NET les retransforme en opérateurs tels que l'auteur les a écrits.
Lire →Comment les ref struct de C# 11 se décompilent en IL
Un champ ref est la première fois qu'un champ C# stocke une référence plutôt qu'une valeur, et il se compile en métadonnées que les décompilateurs antérieurs n'ont jamais eu à lire. La signature du champ porte un type d'élément byref — ELEMENT_TYPE_BYREF à l'intérieur d'une signature FIELD, ce qui était illégal avant .NET 7 — et les règles de sûreté ref qui l'empêchent de survivre à ce qu'il pointe sont encodées dans des modreq et des attributs, pas dans de l'IL exécutable. scoped est le plus bruyant d'entre eux : c'est un ScopedRefAttribute sur un paramètre, sans aucun effet à l'exécution, qu'un décompilateur affiche soit comme le mot-clé scoped, soit laisse tomber, changeant silencieusement le contrat de sûreté ref de la méthode. Ce billet lit les signatures brutes et les blobs d'attributs d'un champ ref, d'une ref struct qui en contient un, et d'un paramètre scoped ref, montre où vivent les règles d'échappement de ref dans les métadonnées, et parcourt comment Glass.NET reconstruit ref, ref readonly, scoped et la porte de sortie [UnscopedRef] pour que le code source décompilé compile avec la même sûreté que celle écrite par l'auteur.
Lire →Comment le nouveau lock de C# se décompile
Pendant vingt ans, lock (obj) s'est abaissé en Monitor.Enter/Exit avec un indicateur lockTaken. C# 13 a changé cela : un lock sur un System.Threading.Lock s'abaisse en EnterScope() et en un ref struct Scope disposé dans un finally — une forme IL complètement différente. Voici exactement ce que chaque forme génère, comment un décompilateur les distingue et les replie toutes deux en lock, et le seul indice de décompilation qui révèle un bogue silencieux : un Lock boxé en object qui retombe discrètement sur Monitor.
Lire →Détecter les activations en double quand une VM est clonée
Une empreinte de machine identifie une machine — et une VM clonée est, par construction, la même machine deux fois. La restauration d'instantané, les images maîtresses et les instances mises à l'échelle automatiquement reproduisent exactement les attributs matériels et système qu'un verrou par machine résume en un hachage, si bien que deux copies en cours d'exécution présentent une empreinte identique et que le verrouillage par machine ne peut pas les distinguer. La solution n'est pas une meilleure empreinte ; c'est une identité d'activation que le serveur possède plus un nonce d'instance par exécution que le client ne peut pas cloner utilement, de sorte que deux copies d'une activation se trahissent dès qu'elles appellent toutes deux la maison. Ce billet lit le SDK et la politique du serveur pour exactement cela : pourquoi l'empreinte est mise en échec, comment un enregistrement d'activation et un identifiant d'instance d'exécution séparent une migration légitime d'un clone en direct, et comment Keyright choisit entre « le plus récent gagne » et « marquer et retenir » sans verrouiller un client qui a simplement déménagé.
Lire →Expiration par droit avec Keyright
Une licence n'a généralement qu'une seule date d'expiration, mais les contrats réels en ont rarement une seule : un forfait de base se renouvelle chaque année, tandis qu'un module complémentaire d'essai dure 30 jours et qu'une fonctionnalité promotionnelle prend fin avec le trimestre. Imposer une seule date à toute la licence vous oblige soit à accorder trop, soit à réémettre sans cesse. Voici comment donner à chaque droit sa propre expiration au sein d'une seule licence Keyright signée : la forme de la charge utile, le SDK qui lit hors ligne une horloge par fonctionnalité, la façon de l'appliquer à la frontière de la capacité, et les règles de grâce qui empêchent un module expiré de mettre à terre toute l'application.
Lire →Désactiver une licence et la déplacer vers une nouvelle machine
Libérer un siège ressemble à la moitié facile du verrouillage par machine — le client clique sur « désactiver cet appareil » et le siège est de nouveau disponible. Mais une désactivation est une affirmation que le client fait sur son propre état, et le client est la seule partie à laquelle vous ne pouvez pas faire confiance. En ligne, le problème est l'ordre et les nouvelles tentatives : libérer sur le serveur avant ou après l'effacement local, et ce qui se passe quand l'un des deux échoue. Hors ligne, le problème est la preuve : une machine sans réseau doit remettre au client quelque chose qui convainc le serveur qu'un siège a vraiment été rendu. Et pour les machines mortes — le portable tombé dans le lac — le problème est l'abus : chaque libération forcée est une occasion de multiplier les sièges. Ce billet lit le SDK Keyright et la politique serveur pour les trois cas : la libération en ligne idempotente, le reçu de désactivation HMAC lié au secret d'instance de l'activation, pourquoi le TTL du bail borne ce qu'un client menteur peut gagner, et le délai de refroidissement des transferts et les limites glissantes qui empêchent « j'ai perdu ma machine » de devenir un générateur de sièges.
Lire →Déployer l'application des licences d'abord en mode audit
Le déploiement le plus effrayant de tout projet de licences est celui qui fait passer l'application de off à on. Jusque-là, la porte n'a jamais dit non à personne ; dès qu'elle le fait, chaque clé mal provisionnée, chaque horloge décalée d'un jour, chaque client qui a activé derrière un proxy que vous n'aviez pas prévu devient un ticket de support — tous en même temps, en production. Ce billet montre comment éviter la bascule brutale grâce au mode audit : une porte qui évalue la licence exactement comme elle le fera en mode application, enregistre la décision qu'elle aurait prise, puis laisse l'appel passer quand même. Vous l'exécutez sur toute votre base installée, vous lisez la population qui aurait été bloquée, vous corrigez les données, et seulement alors vous passez à l'application — par cohorte, piloté par un mode que la licence signée transporte pour qu'aucun client ne puisse l'éteindre. Avec un enregistrement de décision, une énumération de mode d'application que le payload signe, un déploiement par étapes, et les métriques qui vous disent qu'il est sûr de bloquer.
Lire →Obfusquer une application Avalonia sans casser les liaisons
Avalonia n'est pas WPF avec un autre logo, et la différence compte dès que vous l'obfusquez. Avalonia compile votre .axaml en IL au moment de la compilation, si bien qu'une liaison compilée est un accesseur de propriété typé qui référence le getter par jeton de métadonnées — il survit intact à un renommage complet — tandis qu'une liaison par réflexion est une chaîne que le runtime résout par nom et qui revient silencieusement vide. Ce qui casse en premier n'est ni l'un ni l'autre : c'est le ViewLocator du modèle MVVM par défaut, qui trouve une vue en prenant le nom du type du view model, en remplaçant « ViewModel » par « View » et en appelant Type.GetType — une convention qu'un renommage transforme en TextBlock « Not Found » ou en InvalidCastException. Ce billet lit ce que le compilateur XAML émet réellement pour une liaison compilée, montre pourquoi INotifyPropertyChanged correspond toujours après renommage, parcourt les deux types générés par Avalonia que le runtime localise avec Assembly.GetType par leurs noms littéraux, et donne la configuration Nebula et le mappage de vues par DataTemplate qui vous permettent d'aplatir toute l'application sans toucher aux parties qu'Avalonia résout par nom.
Lire →Obfusquer un service gRPC sans casser le protocole sur le fil
gRPC met deux sortes de noms dans votre assembly, et l'obfuscation doit les traiter comme des opposés. Les noms qui voyagent sur le fil — le chemin du service, le chemin de la méthode, les numéros de champ d'un message protobuf — sont un contrat dont dépend chaque pair, et les renommer casse l'interopérabilité aussi sûrement que changer une URL. Les noms qui ne quittent jamais le processus — vos noms de méthode C#, les noms de propriété de vos messages, vos enregistrements d'injection de dépendances — sont libres de disparaître. Le piège est que la sorte d'un nom donné dépend entièrement de si vous êtes parti contract-first avec protoc ou code-first avec protobuf-net.Grpc, car code-first dérive l'identité du fil de vos noms .NET par réflexion, transformant les noms libres en noms porteurs. Ce billet lit le code généré et les métadonnées pour montrer exactement où vit l'identité du fil dans chaque style, pourquoi les numéros de champ protobuf rendent les membres de message sûrs à renommer, et comment Nebula épingle la surface du contrat tout en renommant tout ce qui se trouve derrière.
Lire →Obfusquer un hôte de plugins sans casser les plugins
Un hôte de plugins a une personnalité double que l'obfuscation doit respecter à la lettre. L'assembly de contrat — les interfaces, les classes de base abstraites et les attributs contre lesquels les plugins tiers compilent — est une ABI publiée : renommez un de ses membres et tout plugin déjà livré contre les anciens noms échoue à se lier, exactement comme renommer une API publique casse ses appelants. Mais l'hôte qui charge ces plugins est votre code le plus précieux et ce que vous voulez le plus renommer. Les deux vivent dans une seule solution et une passe d'obfuscation ordinaire ne peut pas les distinguer. Ce billet lit les points de liaison exacts — les noms de type d'interface et de méthode qu'un AssemblyLoadContext résout au chargement, les noms de contrat [Export]/[Import] que MEF apparie, et les noms de type d'attribut qu'un hôte scanne —, montre pourquoi chacun est sur l'ABI et doit survivre, et comment Nebula épingle la surface du contrat par sa forme tout en aplatissant l'hôte derrière elle.
Lire →Obfusquer une application WinForms sans perdre les ressources
WinForms a un piège que WPF n'a pas : le concepteur relie chaque formulaire à un flux .resources incorporé dont le nom est dérivé du nom complet du type du formulaire, et relie les contrôles aux données par chaîne de nom de propriété. Renommez la mauvaise chose et vos icônes disparaissent ou un champ lié devient vide — à l'exécution, sans erreur de compilation. Voici exactement ce que le concepteur émet, pourquoi renommer un type Form casse ComponentResourceManager, et comment protéger une build WinForms avec Nebula.NET pour que les internes soient durcis tout en gardant le concepteur fonctionnel.
Lire →Comment les pointeurs de fonction se décompilent en C#
Un delegate* n'est pas un délégué — pas d'objet, pas de méthode Invoke, pas d'allocation. Il compile vers une adresse de code brute poussée sur la pile et une instruction calli qui appelle à travers elle. Un décompilateur n'a donc rien sur quoi s'appuyer : pas de nom de type, pas de méthode à suivre, juste un appel indirect et une signature autonome qu'il doit lire pour connaître les types d'arguments et la convention d'appel. Et la convention — managed, Cdecl, Stdcall, Thiscall — n'est pas un mot-clé dans l'IL ; elle est encodée comme des types modopt greffés sur la signature. Voici exactement comment un pointeur de fonction est posé, comment calli nomme sa propre signature, où vit réellement la convention non managée, et comment Glass.NET reconstruit le delegate* que vous avez écrit.
Lire →Comment les inline arrays et stackalloc de C# 12 se décompilent
Les inline arrays de C# 12 vous donnent un tampon de taille fixe, de type valeur, qui vit en ligne dans sa structure conteneur — ce que le C appelait `int buf[8]` — mais en IL c'est une structure à un seul champ décorée de [InlineArray(8)], accédée via des intrinsèques du runtime et Span<T> plutôt que par une quelconque instruction de tableau. stackalloc, quant à lui, compile en un localloc brut qu'un décompilateur naïf montre comme un pointeur et un tas d'opcodes stind. Trompez-vous sur l'un ou l'autre et le décompilateur émet de l'arithmétique de pointeurs unsafe là où la source avait un indexeur propre, ou invente un tableau jamais alloué. Voici exactement ce que le compilateur émet pour un type [InlineArray], comment l'accès aux éléments s'abaisse en un helper de PrivateImplementationDetails sur un Span, à quoi ressemblent localloc et le constructeur Span(void*, int) en IL, et comment Glass.NET les relit vers les déclarations d'inline array et les expressions stackalloc que vous avez réellement écrites.
Lire →Où vivent les types référence nullables dans les métadonnées
string et string? sont le même type pour le runtime — System.String, un seul TypeRef, aucune différence dans aucune signature. Le point d'interrogation n'existe qu'à la compilation, et le compilateur doit le faire passer dans l'assembly quelque part pour que les consommateurs de votre bibliothèque obtiennent les bons avertissements. Il le fait avec deux attributs intégrés, NullableAttribute et NullableContextAttribute, un vocabulaire de trois valeurs en octets, un aplatissement en préordre des arbres de types génériques en tableaux d'octets, et un schéma de compression agressif qui omet ce qui correspond au défaut englobant. Cet article lit ces octets directement depuis l'IL, montre l'encodage exact du blob pour les formes à un octet et à tableau, parcourt comment un décompilateur reconstruit ?, notnull et class? à partir d'eux, et explique pourquoi sauter cette étape change silencieusement le contrat public d'une bibliothèque.
Lire →Comment les membres d'interface statiques abstraits se décompilent
C# 11 a permis aux interfaces de déclarer des membres statiques abstraits, et la BCL s'en est servi pour bâtir la mathématique générique — écrivez Sum<T>(span) une fois et elle tourne sur int, double ou votre propre type. Mais la fonctionnalité s'appuie sur un recoin de la spécification ECMA que la plupart des décompilateurs n'avaient jamais eu à traiter : un appel constrained vers une méthode d'interface *statique*, résolu vers l'argument de type à l'exécution. Mal géré, le décompilateur émet un appel vers une méthode qui semble n'avoir aucun receveur, ou invente un cast qui n'existe pas. Voici exactement ce que le compilateur émet pour T.Zero et a + b sur une contrainte générique, pourquoi le préfixe constrained. sur un appel statique non virtuel est toute l'astuce, et comment Glass.NET le relit en les opérateurs et membres statiques que vous avez réellement écrits.
Lire →Chiffrer les ressources incorporées : les données que votre obfuscateur oublie
Vous avez renommé chaque type, chiffré chaque chaîne et virtualisé les méthodes chaudes — puis quelqu'un a ouvert votre assembly dans une visionneuse de ressources et a lu votre SQL incorporé, votre matériau de clés de licence et le texte intégral de vos messages d'erreur directement dans le blob .resources. Les ressources managées ne sont pas du code, donc la protection au niveau des méthodes ne les touche jamais ; elles se trouvent dans le manifeste sous forme de valeurs préfixées en longueur que n'importe qui peut extraire. Voici comment les ressources incorporées sont réellement stockées dans un PE, pourquoi le renommage les laisse intactes, et comment Nebula les chiffre au moment de la compilation et les déchiffre de façon transparente via un résolveur pour que vos appels à ResourceManager et GetManifestResourceStream continuent de fonctionner sans changement.
Lire →Battements de licence et recyclage des baux pour sièges concurrents
Une licence flottante vend N sièges partagés par une équipe, donc le serveur doit savoir combien sont utilisés *à cet instant*. C'est facile jusqu'à ce qu'un client meure de la mauvaise façon — un plantage, une VM supprimée, un câble réseau arraché — sans jamais rendre son siège. Comptez à la prise (checkout) et le siège est perdu pour toujours ; votre client paie pour dix et peut en exécuter six. La solution est de cesser de se fier au couple checkout/checkin et de traiter chaque siège comme un bail (lease) doté d'une durée de vie que le client doit entretenir par des battements (heartbeats). Voici le protocole bail-et-battement dans Keyright : le bail signé à TTL court, la boucle de renouvellement côté client, le récupérateur (reaper) qui récupère les sièges morts côté serveur, et les règles d'horloge et de grâce qui gardent le compte honnête sans punir un réseau instable.
Lire →Versionner la charge utile de licence sans casser les clients
Une licence signée est un ensemble de claims figés en octets, et dès que vous livrez un client qui les lit, cette disposition d'octets devient un contrat que vous ne pouvez pas changer unilatéralement. Puis le produit réclame un nouveau claim — un plafond de sièges, un verrou régional, une liste de fonctionnalités — et vous découvrez que la moitié de votre parc installé fait tourner un parseur qui ne l'a jamais vu. Cet article détaille comment les charges utiles de licence façon Keyright évoluent sans danger : une version de schéma couverte par la signature, un parsing en monde ouvert qui garde vérifiables les claims inconnus, une liste de claims critiques pour qu'un vieux client refuse ce qu'il ne peut pas appliquer au lieu de l'ignorer en silence, une négociation de schéma à l'activation pour que le côté émetteur n'émette jamais ce qu'un client ne sait pas lire, et les tests à fichiers de référence qui empêchent qu'un changement de format atteigne la production sans que personne ne le remarque.
Lire →Lier les licences à une personne, pas à une machine
La liaison à la machine répond à « quel est cet ordinateur ? » — mais beaucoup de produits se vendent au *siège*, pas à la boîte. Un développeur avec un portable, un poste de bureau et un runner de CI est un utilisateur payant, pas trois activations. La licence par utilisateur nommé inverse l'ancrage : la licence appartient à une identité, et les appareils pendent sous elle comme des feuilles, sous un plafond que vous contrôlez. Voici comment modéliser un droit d'identité signé dans Keyright, échanger une connexion contre un bail (lease) de courte durée limité à l'appareil, imposer une limite d'appareils sans fixer l'utilisateur à une seule boîte, et laisser un utilisateur retirer un appareil d'un siège plein — avec le vrai C# pour l'émettre, le lier et le vérifier.
Lire →Les fonctionnalités .NET qui trahissent vos membres renommés
Vous avez renommé chaque type et chaque méthode, puis ouvert le binaire obfusqué et retrouvé vos noms d'origine posés dans des littéraux de chaîne en clair. Le coupable n'est pas un bug de l'obfuscateur — c'est le compilateur. nameof(OrderService) grave le littéral "OrderService" dans l'IL à la compilation, bien avant que le renommage ne s'exécute, et [CallerMemberName] fait de même avec le nom d'origine de la méthode comme valeur de paramètre par défaut. Renommez le membre et le littéral dit toujours l'ancien nom, si bien qu'un décompilateur lit votre table de correspondance gratuitement et que toute réflexion qui attendait le nom d'exécution casse silencieusement. Voici exactement d'où viennent ces littéraux dans l'IL, pourquoi le renommage seul ne peut pas les toucher, et comment le chiffrement de chaînes et la gestion consciente du renommage de Nebula.NET colmatent la fuite.
Lire →Obfusquer une application ASP.NET Core sans la casser
ASP.NET Core trouve presque tout par son nom à l'exécution : les types de contrôleur par leur suffixe, les actions par le nom de méthode, les routes depuis les jetons [controller] et [action], les paramètres de query et de formulaire par les noms de paramètre, les propriétés JSON par les noms de propriété, les méthodes de hub par des chaînes, les classes d'options par les clés de configuration. Renommez n'importe lequel et l'application compile toujours, démarre toujours et renvoie 404 ou un DTO vide. Cet article cartographie chaque couture pilotée par réflexion d'une application ASP.NET Core — MVC, Minimal APIs, vues et tag helpers Razor, SignalR, le pattern options, services hébergés —, montre à quoi ressemblent réellement les métadonnées renommées, et construit un nebula.config.json qui renomme et durcit les services et le domaine tout en épinglant exactement la surface que le framework observe.
Lire →Obfusquer le code P/Invoke sans casser l'interopérabilité
Le renommage est l'épine dorsale de l'obfuscation, et il casse exactement là où votre code managé cesse d'être autonome : à la frontière avec le code natif. Une méthode [DllImport], un délégué que vous marshalez en pointeur de fonction, une structure que vous transférez à travers la frontière : chacun porte un nom ou une disposition dont quelque chose d'extérieur au CLR dépend, et renommez-le aveuglément et l'appel échoue à l'exécution avec un MarshalDirectiveException ou une structure silencieusement corrompue. C'est pourquoi l'interop native ne survit à l'obfuscation que lorsque l'outil comprend le marshaleur : quels noms sont porteurs, pourquoi EntryPoint découple le nom managé du natif, comment l'ordre des champs et StructLayout doivent être préservés, et comment Nebula renomme tout autour de la frontière en laissant la frontière elle-même intacte.
Lire →Stocker une licence activée côté client en toute sécurité
L'activation remet au client un bail signé ; puis arrive la question que personne ne prévoit : où le ranger ? Déposez-le dans un fichier en clair et un utilisateur modifie la date d'expiration ; chiffrez-le maladroitement et vous avez lié l'application à une seule machine par accident. Le cache sert à la disponibilité, pas à l'authenticité : c'est toujours la signature qui décide si un bail est réel, donc le stockage n'a que trois tâches : survivre à un redémarrage, résister à une modification occasionnelle et refuser un bail copié depuis une autre machine. Voici comment sceller un bail en cache avec DPAPI là où il existe, le lier à l'appareil avec un HMAC pour détecter un cache modifié ou transplanté, et pourquoi il ne faut jamais faire confiance à l'expiration en cache plutôt qu'à celle signée.
Lire →Comment le mot-clé dynamic se décompile
Une ligne de C# avec dynamic se compile en un call site mis en cache, un binder, un tableau de drapeaux d'information d'argument et une invocation à travers un champ délégué — une douzaine de membres d'échafaudage généré pour un seul appel de méthode. Voici ce que le compilateur émet réellement pour le dispatch dynamique, comment un décompilateur naïf vous montre la machinerie CallSite brute, et comment Glass.NET reconnaît le motif et vous rend la ligne que vous avez écrite.
Lire →Comment les fonctions locales se décompilent en C#
Une fonction locale n'est pas une lambda, et le compilateur le prouve dans l'IL. Il n'y a ni allocation de délégué ni classe de clôture : une fonction locale sans capture devient une simple méthode statique au nom manglé comme <Run>g__Add|0_0, et une fonction qui capture devient une méthode qui reçoit ses variables capturées par ref dans un struct d'affichage de type valeur, de sorte que rien n'atterrit sur le tas. Voici exactement ce que le compilateur C# émet pour les deux types, comment un décompileur qui ne reconnaît pas le motif vous rend la méthode manglée et le struct ref, et comment Glass.NET le replie en la fonction locale que vous avez écrite.
Lire →Relire un handler de chaîne interpolée jusqu'au source
Le C# moderne ne compile plus $"Hello {name}" en string.Format — il l'abaisse vers un DefaultInterpolatedStringHandler avec des appels AppendLiteral et AppendFormatted. Voici exactement à quoi cela ressemble en IL, comment Glass.NET fait correspondre la séquence à une chaîne interpolée avec son format et son alignement intacts, et le seul cas où, honnêtement, il ne le peut pas.
Lire →Où vivent les noms d'éléments de tuple dans les métadonnées
Un ValueTuple n'a pas de champ nommé count ni name — ce sont Item1 et Item2, et le système de types ne sait rien de vos noms. Les noms que vous avez écrits vivent dans un attribut [TupleElementNames] que le compilateur attache à la signature de méthode, au champ ou à la propriété, sous forme d'un tableau de chaînes avec des null aux positions sans nom. Un décompilateur qui ignore cet attribut vous rend Item1/Item2 ; un qui le lit restaure (int count, string name). Voici exactement comment les noms de tuple sont encodés, pourquoi ils survivent sur les signatures mais disparaissent sur les variables locales, et comment Glass.NET les remet en place.
Lire →Licencier des conteneurs et des services .NET à mise à l'échelle automatique avec Keyright
Le licensing lié à la machine suppose qu'il existe une machine : un hôte stable doté d'une empreinte à laquelle attribuer un siège. Un conteneur n'a rien de tout cela : l'image est identique sur toutes les répliques, l'hôte est éphémère, et un autoscaler crée et détruit des instances plus vite qu'aucun flux d'activation ne peut suivre. Voici comment licencier un service .NET mis à l'échelle horizontalement avec Keyright : activer une seule fois à la frontière du déploiement, livrer une licence signée à chaque réplique, valider hors ligne sans appel par instance, et décider d'emblée si un siège désigne un déploiement ou une instance en cours d'exécution.
Lire →Concevoir une barrière de licence qui échoue en mode fermé
Un simple appel à Validate() est la partie facile du licensing. La partie difficile, c'est l'architecture : où vit le contrôle dans votre app, à quelle fréquence il s'exécute, ce que vous mettez en cache entre deux exécutions et — la question qui décide si un bug bloque un client payant ou distribue votre logiciel gratuitement — quels échecs ferment et quels échecs ouvrent. Voici une barrière de licence à sûreté intégrée pour .NET bâtie sur Keyright, avec une table de décision statut par statut et un instantané en cache qui survit hors ligne.
Lire →Comment une licence décide quelles versions elle peut exécuter
Une licence perpétuelle, c'est pour toujours ; « un an de mises à jour », non — et les deux vivent dans la même clé. La couverture de versions, c'est la manière dont une licence déclare quelles versions elle a le droit d'exécuter, sous forme d'octrois signés de plage de versions et de fenêtre temporelle que la build vérifie localement, hors ligne, sans réactivation. Voici comment se façonne un octroi de couverture, comment la date d'éligibilité (et non celle d'installation) décide d'un correctif, comment le bloc signé voyage avec le bail et comment votre build l'applique sans un seul appel réseau sur le chemin critique.
Lire →Obfusquer une application EF Core sans casser la couche de données
EF Core mappe vos types CLR vers des tables par leurs noms. Renommez une entité ou une propriété avec un obfuscateur et, par défaut, le schéma attendu par EF se déplace avec eux : votre DbContext cherche désormais une table « a » avec une colonne « c », les migrations ne correspondent plus et l'accès aux propriétés par chaîne lève à l'exécution. La solution n'est pas d'exclure toute votre couche de données de l'obfuscation. C'est de comprendre exactement quels noms EF lit à l'exécution, de rendre votre mapping explicite pour découpler le schéma des noms CLR, puis de laisser Nebula.NET renommer librement les membres. Voici le tableau complet, avec les règles de renommage et les motifs EF qui rendent cela sûr.
Lire →Obfusquer un assembly multi-cible avec une seule configuration
Une bibliothèque qui cible net48;net8.0 se compile en deux assemblies différents, avec deux jeux de références différents et parfois deux jeux d'IL différents. N'en protéger qu'un seul revient à livrer un build non obfusqué. Voici comment Nebula.NET traite chaque framework cible comme sa propre passe d'obfuscation tout en partageant une seule politique — et les pièges par TFM qui vous mordent si vous ne le faites pas.
Lire →Resigner un assembly .NET après obfuscation
Le renommage réécrit votre assembly, ce qui invalide le nom fort et la signature Authenticode avec lesquels il a été compilé — une build protégée livrée non signée, ou pire avec une signature désormais cassée, ne se chargera pas ou échouera à la vérification. Nebula.NET resigne pour vous comme dernière étape du pipeline : une nouvelle signature de nom fort sur l'image obfusquée, les jetons de clé publique inter-assemblys réécrits pour que les assemblys interdépendants se résolvent encore, puis une signature Authenticode par-dessus. Voici l'ordre exact, comment fournir la clé à un serveur de build sans la committer, et ce que casse InternalsVisibleTo si vous l'oubliez.
Lire →Garder des noms obfusqués stables d'une version à l'autre
Par défaut, chaque exécution d'obfuscation renomme à partir de zéro : une méthode qui s'appelait "a" en 1.4.0 devient "q" en 1.4.1, et chaque map de désobfuscation archivée pourrit à l'instant où vous publiez. Le seedMapFile de Nebula.NET fige la sortie en place : les membres inchangés conservent le nom obfusqué qu'ils avaient à la version précédente, seul le nouveau code reçoit de nouveaux noms. Voici comment fonctionne la symbol map, pourquoi des noms stables rendent la symbolication des crashs et les diffs binaires traitables, et comment câbler l'obfuscation incrémentale dans la CI.
Lire →Tester le code qui vit derrière une vérification de licence
Vos fonctionnalités payantes sont derrière une barrière de licence — mais comment les tester sans service d'émission en ligne, sans vraie clé, sans dépendre de l'horloge ? Voici une stratégie à deux niveaux pour Keyright : une fine couture que vous simulez pour des tests unitaires rapides, et une poignée de fixtures committées, signées avec une clé de test, qui exercent le vrai chemin de vérification du SDK, entièrement hors ligne et de façon déterministe en CI.
Lire →Retransformer une DLL en projet compilable avec Glass.NET
Lire du C# décompilé dans une fenêtre est une chose ; obtenir un .csproj que vous pouvez ouvrir, grepper, refactoriser et compiler en est une autre. Voici comment l'export de projet de Glass.NET reconstruit un assembly entier — source, références, ressources —, ce qu'il gère proprement, où le code généré par le compilateur a besoin d'un coup de main, et comment le scripter depuis la CLI.
Lire →Faire tourner vos clés de signature de licence sans bloquer vos clients
Vos clés de licence et vos leases ne valent que ce que vaut la clé qui les signe. Voici comment faire tourner cette clé de signature vers une nouvelle sans interruption : confiance chevauchée avec AdditionalPublicKeysBase64, un déploiement par étapes, et comment les leases et les fichiers hors ligne rendent la transition sûre.
Lire →Savoir quand une build .NET protégée est attaquée
Les gardes anti-tamper et anti-debug réagissent sur la machine de l'utilisateur — mais vous n'apprenez jamais qu'ils se sont déclenchés. Le report-home de Nebula.NET (tamperReportUrl, Pro) POSTe un événement minimal à votre propre endpoint à l'instant où un garde se déclenche, de sorte qu'une attaque sur une build distribuée devienne un signal exploitable. Voici comment ça marche et comment construire le récepteur.
Lire →Pourquoi les signatures de licence exigent une signature canonique
Une signature est calculée sur des octets, pas sur des champs — donc si votre service émetteur et votre client sérialisent le payload de la licence ne serait-ce que légèrement différemment, la vérification échoue sur une licence parfaitement authentique. Voici comment canoniser un payload une seule fois (ordre des champs stable, formatage invariant des nombres et des dates, UTF-8, base64url) pour qu'une même signature se vérifie à l'identique en .NET, Node, Python et Java.
Lire →Décompiler les expressions de collection et les constructeurs primaires
Les expressions de collection et les constructeurs primaires ressemblent à des idées syntaxiques uniques, mais le compilateur les abaisse vers un IL très différent selon le type cible et selon qu'un paramètre est capturé ou non. Voici exactement ce qu'émettent `[1, 2, 3]`, les spreads et un constructeur primaire, et où un décompilateur peut replier le sucre face à où il ne peut montrer que la forme abaissée.
Lire →Obfusquer les applications .NET Native AOT et fichier unique
Publier en fichier unique ou avec Native AOT relève de l'empaquetage et de la compilation, pas de la protection. Voici ce que chaque mode fait réellement à votre code, pourquoi les applications en fichier unique livrent toujours de l'IL managé entièrement récupérable, ce que Native AOT masque et ne masque pas, et pourquoi l'obfuscation doit s'exécuter sur l'IL avant que le bundle ne soit construit ou que le compilateur AOT ne le supprime.
Lire →Durcir automatiquement vos vérifications de licence
La méthode qui vérifie votre licence est la cible de plus grande valeur de toute votre app — cassez-la et tout le reste est sans objet. Nebula.NET peut trouver les méthodes qui appellent votre SDK de licence et appliquer automatiquement la protection la plus forte que votre édition autorise exactement à ces méthodes, de sorte que la porte est durcie sans que vous la listiez à la main. Voici comment fonctionne l'auto-protection.
Lire →Quand await et yield partagent une machine à états
Une méthode async IAsyncEnumerable mêle await et yield return — le compilateur génère donc une seule machine à états qui est à la fois une machine à états async et un itérateur. Voici la forme vers laquelle elle est abaissée, comment le champ d'état pilote à la fois les reprises d'await et les points de yield, et comment un décompilateur reconnaît le motif pour reconstruire await foreach.
Lire →Décompiler le pattern matching et les expressions switch de C#
Une expression switch n'est pas une construction en IL : elle se réduit à une chaîne de tests de type, de tests de null et de branchements, se terminant par une SwitchExpressionException levée pour le cas non couvert. Voici exactement ce que le compilateur émet pour les motifs de type, de propriété, relationnels et logiques, et comment un décompilateur retrouve la forme d'un switch.
Lire →Comment une instruction using se décompile en C#
Une instruction using n'a pas d'IL propre — le compilateur l'abaisse en un try/finally qui appelle Dispose, et await using en un try/finally qui attend DisposeAsync. Voici exactement à quoi ressemble ce code généré, les subtilités du null-check et de l'énumérateur struct, et comment un décompilateur le replie en using.
Lire →Ce que l'obfuscation .NET coûte à l'exécution
Toute la protection .NET n'a pas le même coût à l'exécution. Le renommage est gratuit ; le chiffrement des chaînes et constantes ajoute un minuscule décodage par usage ; l'aplatissement du flux de contrôle ajoute une surcharge de répartition ; le chiffrement de méthode et la virtualisation sont lourds par appel. Voici le modèle de coût honnête de chaque transformation et comment cadrer la protection pour défendre ce qui compte sans ralentir un chemin chaud.
Lire →Que doit faire votre app quand le serveur de licences est en panne
Une vérification de licence qui échoue brutalement dès que le serveur est injoignable transforme votre panne — ou le Wi-Fi capricieux du client — en la leur. Voici comment concevoir des fenêtres de grâce, choisir fail-open vs fail-closed par niveau, et empêcher qu'une coupure réseau passagère ne verrouille des clients payants.
Lire →Obfuscation des références en .NET : masquer le graphe d'appels
Renommez tout et un décompilateur lira encore votre intention dans les appels que vous faites : File.ReadAllText, RSA.Create, votre propre CheckLicense. L'obfuscation des références (appels par proxy) achemine ces appels via des proxys générés pour que le site d'appel ne nomme plus sa cible. Voici comment cela fonctionne en IL, ce que cela déjoue et ce que cela coûte.
Lire →Comment tester l'intégration de licence de votre logiciel
Les bugs de licence partent en production parce que le seul chemin que quelqu'un exerce est « clé valide, serveur disponible, horloge correcte ». Voici comment mettre l'expiration, la révocation, la grâce hors ligne et les limites de postes sous test automatisé : injectez l'horloge, simulez le client de licence et pilotez chaque cas limite depuis xUnit pour que la CI attrape les blocages avant vos clients.
Lire →Publier une démo à durée limitée de votre app .NET
Parfois vous voulez une build qui cesse simplement de fonctionner après une date — une démo de conférence, une copie d'évaluation, une préversion qui ne doit pas tourner en production indéfiniment. Nebula.NET peut intégrer une expiration dans l'assembly lui-même, appliquée depuis un initialiseur de module avant l'exécution de votre code, avec la réaction de votre choix. Voici comment cela fonctionne et quand l'utiliser plutôt que la licence côté serveur.
Lire →Anatomie d'une clé de licence signée : pourquoi elle ne peut pas être falsifiée
Une bonne clé de licence n'est pas une chaîne aléatoire confrontée à une liste — c'est un payload de claims signé que l'app peut vérifier hors ligne avec une clé publique qu'elle distribue. Voici ce qui vit dans une clé signée, pourquoi la séparation privée/publique la rend infalsifiable, comment la vérification fonctionne sans serveur, et ce que la signature protège et ne protège pas.
Lire →Filigraner des assemblages .NET pour tracer qui a divulgué une build
L'obscurcissement empêche un lecteur de comprendre votre code ; il ne fait rien pour vous dire quel client l'a divulgué. Un filigrane par licencié, lui, le fait — un marqueur unique et discret cuit dans chaque build qui survit à la copie ordinaire et relie un assemblage divulgué au compte auquel il a été émis. Voici ce que doit être un bon filigrane, où il vit, et comment il complète l'obscurcissement et le licensing.
Lire →Cacher les constantes que les décompilateurs lisent en .NET
Le chiffrement des chaînes attire l'attention, mais les littéraux numériques de votre code — seuils, opcodes, nombres magiques, décalages — compilent en instructions ldc qu'un décompilateur lit instantanément. Voici comment les constantes numériques fuitent la logique, comment le chiffrement des constantes les remplace par des valeurs décodées à l'exécution, et où il s'insère aux côtés du chiffrement des chaînes et de la protection du flux de contrôle.
Lire →Ce qu'un décompilateur révèle dans les records C#
Un record est une classe plus un ensemble précis de membres générés par le compilateur — égalité par valeur, une méthode de clonage, un Deconstruct, un PrintMembers/ToString, des setters init-only. Un décompilateur reconnaît cette empreinte et reconstruit le mot-clé record. Voici exactement ce que le compilateur émet pour un record et comment le motif est relu.
Lire →Comment yield return devient une machine à états
Une méthode itérateur avec yield return n'a pas de représentation IL directe — le compilateur la réécrit en une classe générée qui implémente IEnumerator et reprend à l'intérieur d'un switch MoveNext. Voici la forme de cette machine à états, comment un décompilateur la reconnaît, et comment yield return et yield break sont récupérés du code généré.
Lire →Le patching à l'exécution que votre contrôle d'intégrité manque
Une anti-altération qui hache la DLL sur le disque détecte un fichier patché — mais pas une méthode réécrite en mémoire à l'exécution. Des bibliothèques comme Harmony détournent vos méthodes sans toucher au fichier, et c'est ainsi que fonctionnent les contournements de licence et les cheats modernes. Voici comment fonctionne le patching en mémoire et ce qui le détecte vraiment.
Lire →Comment la gestion de licences résiste à la manipulation de l'horloge
Les essais et les abonnements expirent à une date — mais l'horloge de l'appareil est contrôlée par l'attaquant, et la reculer est la plus vieille astuce pour ranimer une licence expirée. Voici pourquoi vous ne pouvez pas faire confiance à l'heure locale, et les techniques de point haut et d'heure serveur qui défendent l'expiration sans punir les utilisateurs honnêtes.
Lire →Concevoir une empreinte machine stable mais pas fragile
Le node-locking lie une licence à un appareil, ce qui signifie qu'il vous faut une empreinte assez unique pour identifier une machine et assez stable pour survivre à un ajout de RAM. Voici comment en construire une à partir de signaux matériels pondérés, l'apparier avec tolérance, la hacher pour la confidentialité, et gérer les cas de VM et de changement de matériel qui font trébucher les implémentations naïves.
Lire →Ce que l'anti-débogage peut et ne peut pas faire en .NET
Un débogueur, c'est ainsi qu'un attaquant observe vos chaînes déchiffrées et pose un point d'arrêt sur votre vérification de licence. Voici les moyens managés, natifs et basés sur le temps par lesquels une app .NET peut en détecter un — avec du vrai code — et une explication honnête de pourquoi l'anti-débogage est un ralentisseur, pas un mur.
Lire →Convertir un essai en licence payante sans réinstallation
Un utilisateur d'essai qui paie devrait devenir un utilisateur sous licence sur place : même installation, mêmes données, aucune clé à ressaisir. Voici comment fonctionne une conversion essai-vers-payant propre : mettre à niveau la clé sur place, rafraîchir les droits en cache, et concevoir l'expiration de l'essai pour que payer restaure simplement ce qui était là.
Lire →Ce que les lambdas et les closures donnent à la décompilation
Décompilez une méthode qui utilise une lambda et vous trouvez un type nommé <>c__DisplayClass avec vos variables locales en champs. Voici comment le compilateur C# transforme les closures en classes, pourquoi une lambda qui capture alloue et une qui ne capture pas n'alloue pas, et ce que le code généré révèle d'un bug de closure.
Lire →Ce qu'un décompilateur récupère sans PDB
Une DLL de release est livrée sans son PDB, et pourtant un décompilateur reconstruit du C# lisible. Voici la répartition : ce qui vit dans les métadonnées de l'assembly (et survit), ce qui vit uniquement dans le PDB (noms locaux, numéros de ligne), et comment un décompilateur comble le vide quand les symboles manquent.
Lire →Lire des stack traces .NET obscurcies
L'obscurcissement par renommage transforme vos stack traces de production en un mur de a, b, c — sauf si vous conservez la carte de renommage. Voici comment fonctionne la carte, comment restaurer une trace lisible à partir d'un plantage obscurci, et comment garder la carte en sécurité sans la distribuer.
Lire →Comment fonctionnent les tables de métadonnées .NET — et comment un décompilateur les lit
Chaque assemblage .NET embarque une petite base de données relationnelle de sa propre structure : les tables de métadonnées. Voici ce que contiennent réellement TypeDef, MethodDef et les index codés, comment un token de métadonnées adresse une ligne, et comment un décompilateur parcourt les tables pour reconvertir une DLL en types et méthodes.
Lire →Faire cesser de fonctionner une clé de licence, en ligne et hors ligne
Émettre une licence est facile ; faire cesser une licence après un remboursement, une fuite ou une rétrofacturation est la moitié la plus difficile. Voici comment fonctionne vraiment la révocation : le check-in en ligne qui échoue vers l'état bloqué, les listes de révocation signées qui atteignent les clients hors ligne, et comment borner la fenêtre d'exposition que vous ne pouvez jamais fermer totalement.
Lire →Ce que l'obfuscation casse : réflexion, sérialisation et ce qu'il faut exclure
La première fois que vous obfusquez une app qui marchait, elle peut casser de façons surprenantes : le JSON sort faux, la réflexion renvoie null, le data binding s'arrête. La cause est toujours la même : quelque chose a résolu par son nom un membre renommé. Voici exactement ce qui casse, pourquoi, et comment exclure les bonnes choses sans affaiblir la protection.
Lire →Automatiser la livraison de licences avec des webhooks de fulfillment
Une commande payée devrait générer une licence sans intervention humaine. Voici comment fonctionnent les webhooks de fulfillment de bout en bout : vérifier la signature sur le corps brut, rendre la livraison idempotente par commande, et mapper les événements de paiement, remboursement et annulation vers émettre, révoquer et renouveler.
Lire →Ce que async/await donne à la décompilation
Décompilez une méthode async et vous ne voyez pas async/await — vous voyez une structure générée par le compilateur avec un switch dans MoveNext(). Voici comment le compilateur C# transforme async en machine à états, comment lire le type <Méthode>d__N que montre un décompilateur, et comment un bon décompilateur reconstruit l'original.
Lire →Pourquoi un .NET renommé se lit encore comme du code source
Le renommage d'identifiants est la couche d'obfuscation la plus faible : un décompilateur sur du code seulement renommé montre encore votre logique, vos chaînes et vos constantes telles quelles. Voici ce que le renommage cache et ne cache pas, et les couches — chiffrement des chaînes, masquage des constantes, aplatissement du flux de contrôle et virtualisation — qui rendent vraiment le .NET difficile à lire.
Lire →Droits et feature flags, pilotés par la licence
Comment activer des fonctionnalités et imposer des limites numériques selon le niveau de licence : modèles de droits signés, lecture des flags et des limites hors ligne dans votre app, application à la frontière de chaque capacité, et modifier ce qu'un niveau débloque sans publier une nouvelle version.
Lire →