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.
La plupart des conseils sur l”obfuscation des types sérialisés sont une mise en garde : ne renommez pas vos DTO, les noms sont le contrat. C”est exact pour System.Text.Json, Newtonsoft.Json et DataContract/WCF : le nom du membre (ou un attribut qui le répète) est littéralement la clé écrite sur le fil, donc renommer OrderId en a change ce que lit l”autre extrémité. protobuf-net est l”heureuse exception, et la raison mérite d”être comprise car elle inverse le conseil habituel : pour les DTO protobuf-net, le renommage des propriétés et des champs est quasiment gratuit, et vous n”avez à réfléchir qu”à une courte liste d”exceptions.
Le fil transporte des nombres, pas des noms
protobuf-net implémente le format de fil des Protocol Buffers de Google. Chaque champ sur le fil est une paire clé/valeur, et la clé est un varint construit à partir d”un numéro de champ et d”un type de fil, et non d”une chaîne. Le numéro de champ provient du N que vous avez écrit dans [ProtoMember(N)] :
[ProtoContract]
public sealed class OrderLine
{
[ProtoMember(1)] public int OrderId { get; set; }
[ProtoMember(2)] public string Sku { get; set; } = "";
[ProtoMember(3)] public decimal UnitPrice { get; set; }
}
À la sérialisation, les octets disent « champ 1, varint » puis « champ 2, délimité par la longueur », etc. La chaîne "OrderId" n”apparaît nulle part dans la sortie. C”est toute l”astuce : le nom est une étiquette de compilation, et le numéro d”étiquette est le contrat d”exécution.
Pourquoi cela rend le renommage sûr
Comme le nom n”atteint jamais le fil, un obfuscateur est libre de le réécrire. Après que Nebula a renommé le type, un décompilateur voit quelque chose comme :
[ProtoContract]
public sealed class b
{
[ProtoMember(1)] public int a { get; set; }
[ProtoMember(2)] public string c { get; set; } = "";
[ProtoMember(3)] public decimal d { get; set; }
}
Les numéros [ProtoMember(N)] restent intacts — ce sont des données dans le blob de l”attribut, pas des identifiants — donc les octets sérialisés sont identiques octet pour octet à ceux de la compilation non obfusquée. Un ancien client qui possède encore le OrderLine d”origine lit parfaitement la sortie du serveur renommé, et inversement, car les deux extrémités s”accordent sur le fait que le champ 3 est le prix unitaire. Le nom lisible n”existait que pour votre arborescence de code source, et l”obfuscation est précisément la transformation qui jette cette arborescence.
C”est un véritable avantage sur les sérialiseurs basés sur les noms. Avec System.Text.Json, renommer UnitPrice en d change soit la clé JSON en "d" (cassant tous les consommateurs), soit vous oblige à épingler chaque propriété avec [JsonPropertyName("UnitPrice")] — moment où vous avez réintroduit la chaîne même que vous tentiez de cacher. protobuf-net n”a besoin de rien de tout cela. Utilisez une numérotation explicite avec [ProtoMember(N)] et le renommage est gratuit.
Les quatre choses qui cassent encore
La liberté ci-dessus tient précisément parce que l”étiquette est explicite et le nom absent. Chaque exception ci-dessous est un cas où ce n”est plus vrai : soit l”étiquette dépend du nom, soit le nom se glisse sur le fil ou dans une recherche par réflexion.
1. Numérotation implicite des champs
protobuf-net peut attribuer les étiquettes à votre place :
[ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
public sealed class Customer // DANGER au renommage
{
public int Id { get; set; } // étiquette 1 implicite
public string Name { get; set; } // étiquette 2 implicite
public string Region { get; set; } // étiquette 3 implicite
}
Avec ImplicitFields.AllPublic (ou AllFields), il n”y a pas de numéros explicites. protobuf-net dérive les étiquettes en énumérant les membres et en les ordonnant alphabétiquement par nom, puis en les numérotant à partir de 1. Renommez Name en a et Region en b et l”ordre alphabétique change, donc les étiquettes qui étaient Id=1, Name=2, Region=3 deviennent silencieusement autre chose : tous les champs se décalent et le format de fil casse face à toute donnée sérialisée auparavant. Réordonner les membres à la main produit la même chose.
Le correctif est de ne dépendre de la numérotation implicite pour rien de ce que vous obfusquez. Soit vous convertissez le type en [ProtoMember(N)] explicite (la démarche recommandée — elle est sûre à la fois au renommage et au versionnage), soit vous mettez le type en keep-list pour que ses membres conservent leurs noms.
2. ProtoInclude, AsReference et gestion des types dynamiques
L”héritage et le suivi des références peuvent mettre en jeu un nom de type :
[ProtoContract]
[ProtoInclude(10, typeof(ExpressShipment))]
public abstract class Shipment { [ProtoMember(1)] public string Tracking { get; set; } = ""; }
La forme [ProtoInclude(10, typeof(ExpressShipment))] repose sur l”étiquette (champ 10) et est donc sûre au renommage : le sous-type est identifié par le numéro 10, pas par "ExpressShipment". Mais deux fonctionnalités voisines ne sont pas sûres par défaut : la sérialisation de graphes avec AsReference et DynamicType peuvent incorporer le nom CLR du type qualifié par l”assembly pour que le lecteur puisse réhydrater le type exact. Si vous renommez le type, cette chaîne incorporée ne correspond plus. Préférez [ProtoInclude(N, typeof(T))] basé sur l”étiquette à DynamicType, et si vous devez sérialiser AsReference entre processus, mettez les types concernés en keep-list.
3. Un modèle d”exécution construit par nom de membre
Si vous configurez protobuf-net de façon impérative plutôt qu”avec des attributs, vous nommez peut-être les membres sous forme de chaînes :
RuntimeTypeModel.Default
.Add(typeof(Customer), applyDefaultBehaviour: false)
.Add(1, "Id")
.Add(2, "Name") // recherche par chaîne — casse après renommage
.Add(3, "Region");
.Add(2, "Name") résout "Name" par réflexion au démarrage. Après que Nebula a renommé la propriété en a, la chaîne "Name" ne correspond plus à aucun membre et le modèle ne se construit pas (ou saute le champ en silence). C”est le seul cas réellement incompatible avec le renommage, donc ces types vont dans la keep-list — ou, mieux, migrez l”enregistrement vers la surcharge fortement typée .Add(2, nameof(Customer.Name)) puis mettez-le en keep-list, car nameof reste une chaîne de compilation gravée dans l”IL.
4. Noms de ProtoEnum
Les valeurs d”énumération se sérialisent par leur valeur numérique, donc renommer les membres d”énumération est normalement sans danger. L”exception est un aller-retour de nom explicite :
[ProtoContract]
public enum Priority
{
[ProtoEnum(Name = "LOW")] Low = 0,
[ProtoEnum(Name = "HIGH")] High = 2,
}
[ProtoEnum(Name = "...")] est un littéral de chaîne dans l”attribut, donc renommer le membre d”énumération ne l”affecte pas — mais cela reste une chaîne lisible dans vos métadonnées, et si un outil compare sur ce nom, mieux vaut le laisser tranquille. Les énumérations simples sans [ProtoEnum(Name=)] ne demandent aucun traitement particulier.
La keep-list : étroite par conception
Mettez tout en renommage complet, puis n”exemptez que les types précis qui relèvent des cas 1–3 ci-dessus. Un nebula.config.json réaliste :
{
"input": "bin/Release/net8.0/Acme.Orders.dll",
"output": "dist/Acme.Orders.dll",
"rename": { "enabled": true, "scope": "all" },
"strings": { "encrypt": true },
"controlFlow": { "flatten": "sensitive" },
"keep": [
{
"type": "Acme.Orders.Dtos.Customer",
"members": "names",
"reason": "ImplicitFields.AllPublic — tags derive from member names/order"
},
{
"type": "Acme.Orders.Model.*",
"members": "names",
"reason": "RuntimeTypeModel built with .Add(n, \"MemberName\") by string"
}
]
}
"members": "names" préserve les noms de membres de ces types tout en laissant Nebula appliquer le chiffrement de chaînes et les transformations de flux de contrôle aux corps de leurs méthodes — vous ne protégez que les noms dont le sérialiseur a besoin, sans exempter le type en entier. Protégez ensuite l”assembly :
nebula protect --config nebula.config.json
Tout ce qui est hors de la keep-list — ce qui, pour un projet protobuf-net bien numéroté, correspond à toute la couche DTO — est renommé librement sans risque pour le format de fil.
La règle empirique
protobuf-net inverse la tension habituelle entre sérialisation et obfuscation. Comme le contrat est l”étiquette numérique et non le nom du membre, les DTO en [ProtoMember(N)] explicite sont sûrs au renommage par construction. Concentrez votre effort en un seul endroit : trouvez les types qui laissent le nom refluer vers le contrat — numérotation implicite, AsReference/DynamicType et modèles d”exécution avec des noms sous forme de chaîne —, convertissez ce que vous pouvez en étiquettes explicites, mettez le reste en keep-list, et laissez Nebula renommer toute la couche DTO sans y réfléchir à deux fois.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.