Obfusquer gRPC code-first sans casser les routes
En gRPC code-first (protobuf-net.Grpc), il n'y a pas de fichier .proto : le contrat de service est une interface .NET, et la bibliothèque dérive la route réseau `/package.Service/Method` de l'espace de noms de l'interface, de son nom de type et du nom de chaque méthode à l'exécution. Renommez l'interface ou une méthode et le chemin HTTP/2 change, si bien que les clients frappent une route que le serveur ne sert plus et chaque appel échoue en UNIMPLEMENTED, sans erreur de compilation. Les membres des DTO se comportent à l'inverse : protobuf sérialise par le tag numérique `[ProtoMember]`, donc ces identifiants se renomment sans problème. Cet article lit exactement comment la route est calculée, pourquoi `[Service]` et `[Operation]` permettent de figer les noms réseau tout en renommant les identifiants, et comment écrire une keep-list dans nebula.config.json qui protège l'implémentation et les internes des DTO tout en laissant le routage intact.
Un service gRPC code-first n”a pas de fichier .proto, il est donc tentant de penser qu”il n”y a aucun contrat externe à protéger : ce ne sont que des interfaces C# et des DTO. Mais le contrat n”a pas disparu ; il s”est déplacé dans des métadonnées que le runtime lit par réflexion, et une passe de renommage aveugle les réécrira sans prévenir.
Dans protobuf-net.Grpc, le contrat de service est une interface .NET décorée de quelques attributs, et les DTO sont des classes ordinaires avec des tags [ProtoMember]. Il n”y a ni étape de génération de code ni .proto à versionner. Cette commodité cache un tranchant pour l”obfuscation : la route gRPC qu”un client appelle — le chemin /package.Service/Method porté dans l”en-tête HTTP/2 :path — n”est écrite nulle part où vous puissiez la voir. La bibliothèque la calcule au moment de la liaison, à partir de l”espace de noms de l”interface, de son nom de type et du nom de la méthode. Renommez l”un des trois et vous aurez changé en silence votre contrat réseau public, avec une compilation propre et un serveur qui démarre bien puis répond à chaque appel réel par UNIMPLEMENTED.
Le remède est la même discipline qu”exige tout framework piloté par réflexion : trouvez les noms qui sont lus comme des chaînes sur le réseau, figez exactement ceux-là, et laissez tout ce qui est derrière se renommer.
Ce qui est sur le réseau et ce qui ne l”est pas
Deux systèmes de nommage distincts se rencontrent dans un service gRPC code-first, et ils se comportent de façons opposées sous renommage. Le routage est dérivé d”identifiants ; la sérialisation est régie par des tags numériques. Réussir cette distinction, c”est tout le travail.
Voici le contrat. Ce ne sont qu”une interface et deux DTO, sans aucun code généré :
using System.Threading.Tasks;
using ProtoBuf;
using ProtoBuf.Grpc;
namespace Shop.Contracts;
[ServiceContract]
public interface ICalculator
{
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
}
[ProtoContract]
public class MultiplyRequest
{
[ProtoMember(1)] public double X { get; set; }
[ProtoMember(2)] public double Y { get; set; }
}
[ProtoContract]
public class MultiplyReply
{
[ProtoMember(1)] public double Result { get; set; }
}
Le serveur enregistre l”implémentation contre l”interface, et le client construit un proxy à partir de la même interface :
// Serveur
app.MapGrpcService<CalculatorService>(); // CalculatorService : ICalculator
// Client
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var calc = channel.CreateGrpcService<ICalculator>();
var reply = await calc.Multiply(new MultiplyRequest { X = 6, Y = 7 });
Rien dans ce code ne mentionne la route /Shop.Contracts.Calculator/Multiply. Les deux extrémités la dérivent indépendamment à partir d”ICalculator.
Comment la route est réellement dérivée
Quand protobuf-net.Grpc lie ICalculator, son service binder transforme le type de contrat en un nom de service. La logique est assez petite pour être énoncée exactement : prendre le nom du type, retirer un I initial si le caractère suivant est en majuscule, et préfixer l”espace de noms.
// Equivalent to ProtoBuf.Grpc's ServiceBinder.GetDefaultName(Type).
static string GetServiceName(Type contract)
{
var name = contract.Name; // "ICalculator"
if (contract.IsInterface && name.Length > 1
&& name[0] == 'I' && char.IsUpper(name[1]))
name = name.Substring(1); // "Calculator"
return contract.Namespace + "." + name; // "Shop.Contracts.Calculator"
}
Le nom de l”opération prend par défaut le nom de la méthode, Multiply. gRPC compose alors le chemin HTTP/2 sous la forme /{service}/{operation} :
/Shop.Contracts.Calculator/Multiply
Cette chaîne est le contrat. Elle est construite à partir de trois éléments de métadonnées — espace de noms, nom de type, nom de méthode — dont aucun n”est traité par le compilateur comme porteur. Renommez ICalculator en a et le service devient Shop.Contracts.a ; déplacez-le dans un namespace renommé et le préfixe change ; renommez Multiply en b et l”opération change. Chaque changement produit un chemin différent, et un client compilé contre le contrat d”origine continue d”envoyer l”original. Le serveur n”a pas de handler sur l”ancienne route, donc le flux se ferme avec :
Status(StatusCode="Unimplemented", Detail="Service is unimplemented.")
Aucune erreur de compilation, aucune erreur de démarrage : le service est hébergé tout content sur la nouvelle route tandis que chaque appelant existant la manque.
Pourquoi les membres DTO sont l”inverse
Les corps de requête et de réponse sont la moitié rassurante de l”histoire. protobuf-net ne sérialise pas par nom de membre ; il sérialise par le tag entier que vous déclarez dans [ProtoMember(n)]. Le nom n”existe que pour votre code C#.
Result en a laisse les octets réseau intacts : les membres DTO se renomment librement.Comme la clé réseau est 1, pas Result, Nebula peut renommer la propriété en a, renommer le type DTO MultiplyReply en n”importe quoi (le nom du type n”est jamais transmis non plus), et les octets sur le réseau sont identiques octet pour octet. La seule règle est que les numéros [ProtoMember] doivent rester fixes — et ils le restent, parce que ce sont des littéraux entiers à l”intérieur d”un attribut, pas des identifiants. Il en va de même pour les enums, qui voyagent comme leur valeur numérique.
Ainsi, la surface de contrat que vous devez protéger est précisément : le nom de type de l”interface de service, son espace de noms et les noms de ses méthodes. Rien d”autre.
Figer les noms réseau
Il y a deux façons de garder la route stable. La première est une keep-list qui dit à Nebula de ne pas renommer les interfaces de contrat. La seconde, et la meilleure, est de déclarer les noms réseau explicitement pour que les identifiants soient de nouveau libres.
Avec protobuf-net.Grpc, vous les définissez sur le contrat lui-même :
using ProtoBuf.Grpc.Configuration;
namespace Shop.Contracts;
[Service("shop.Calculator")] // le nom réseau est figé ici…
public interface ICalculator // …donc cet identifiant peut être renommé
{
[Operation("Multiply")] // …et celui-ci aussi
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
}
Maintenant, le binder lit shop.Calculator et Multiply directement depuis les valeurs de l”attribut et ne regarde jamais les noms des métadonnées, donc la route est /shop.Calculator/Multiply peu importe comment l”obfuscateur nomme l”interface ou la méthode. Cela vaut la peine indépendamment de l”obfuscation : cela fige votre surface gRPC publique pour qu”un renommage de routine ou un déplacement de namespace ne puisse la déplacer.
La keep-list dans nebula.config.json
Si vous n”avez pas annoté le contrat avec des noms explicites, figez les noms dérivés en conservant les interfaces de contrat. Tout le reste — l”implémentation, les DTO, les services internes — part dans le renommage :
{
"schemaVersion": 1,
"inputs": [
"bin/Release/net8.0/Shop.Server.dll",
"bin/Release/net8.0/Shop.Contracts.dll"
],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Shop.Contracts.I*", "action": "keep", "members": "public" },
{ "pattern": "Shop.Contracts.*", "action": "rename" },
{ "pattern": "Shop.Server.*", "action": "rename" }
]
}
}
La première règle fait correspondre les interfaces de contrat par le préfixe conventionnel I… et conserve à la fois les noms de type (de sorte que la chaîne de service namespace-plus-nom soit préservée) et leurs noms de méthode publics, tandis que members: "public" laisse tout membre non public dans la portée de l”interface elle-même se renommer encore. La deuxième règle renomme tout le reste dans Shop.Contracts — essentiellement les types DTO et leurs membres, qui sont sûrs parce qu”ils voyagent comme des tags numériques. La troisième règle renomme tout l”assembly serveur : CalculatorService, vos validateurs, les stores internes et les enregistrements DI reçoivent un renommage complet, l”obfuscation de flux de contrôle et le chiffrement de chaînes. Le nom de la classe d”implémentation n”est jamais sur le réseau — la liaison se fait via l”interface — donc il peut disparaître sans problème.
Si vous avez bien annoté chaque contrat avec [Service]/[Operation], vous pouvez supprimer entièrement la règle de keep et laisser les interfaces se renommer elles aussi, parce que les noms réseau vivent désormais dans des littéraux d”attributs que Nebula préserve. Pour la méthode isolée qui fait exception, un attribut sur le membre exact est plus précis qu”un motif de configuration et vit à côté du code :
[Obfuscation(Feature = "renaming", Exclude = true, ApplyToMembers = false)]
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
Exécutez la protection dans le cadre de la compilation de release, contre la sortie publiée :
nebula protect --config nebula.config.json
Les passes de renommage, de flux de contrôle et de chiffrement de chaînes de Nebula sont disponibles dans le niveau gratuit pour l”évaluation ; les protections plus lourdes comme la virtualisation de méthodes font partie de Nebula Pro. Consultez la documentation Nebula pour la syntaxe complète des règles, et /products/nebula pour les niveaux.
Mises en garde et quand cela casse
Le mode de défaillance subtil est celui où cela semble fonctionner. Si votre client et votre serveur référencent le même assembly de contrat obfusqué, les deux dérivent la même route renommée et les appels fonctionnent en test — puis cassent le jour où un client est recompilé à partir du paquet original, où un consommateur non .NET entre avec grpcurl, ou où vous obfusquez un côté et pas l”autre. La route n”est stable que parce que deux compilations se sont trouvées d”accord ; ce n”est pas un contrat. Figez les noms réseau avec [Service]/[Operation] et l”accord devient une garantie.
Deux autres limites honnêtes. D”abord, les endpoints de réflexion ou de server-reflection qui annoncent votre liste de services annonceront les noms renommés si vous avez conservé la nomenclature dérivée : bien si vous possédez les deux extrémités, surprenant si un outil vous introspecte. Ensuite, ces règles ne couvrent que la surface du contrat ; si vous pilotez le routage ou la sérialisation via toute autre réflexion basée sur des chaînes dans votre propre code, cette chaîne est porteuse elle aussi et doit figurer sur la keep-list.
La règle sous-jacente à tout cela est la même qu”obéit tout framework piloté par réflexion : un nom est porteur exactement lorsque quelque chose en dehors de la résolution de tokens propre au CLR le lit comme une chaîne. En gRPC code-first, cet ensemble est petit et connaissable — le nom de type de l”interface de service, son espace de noms et les noms de ses méthodes — et les membres de requête et de réponse n”en font délibérément pas partie, parce que protobuf les indexe par numéro. Figez ces quelques noms, ou déclarez-les carrément avec [Service] et [Operation], et Nebula renommera l”implémentation, les internes des DTO et la logique métier librement, protégeant votre propre service livré sans jamais déplacer une route dont dépend un client.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.