Skip to content
← Tous les articles
· Delta1 Labs AspireNebula

Quoi obfusquer dans une solution .NET Aspire

Un AppHost Aspire est une orchestration de temps de développement que vous ne distribuez jamais ; les assemblys qui atteignent la production sont les services individuels. Voici pourquoi le renommage est sûr de part et d'autre de la frontière entre services, quels assemblys protéger et les rares membres que vous devez tout de même préserver.

Une équipe adopte .NET Aspire, met en place un AppHost et arrive au moment de distribuer. La première question est presque toujours la mauvaise : « comment obfusquer mon application Aspire ? ». Il n”y a pas d”application Aspire unique à obfusquer. Une solution Aspire est un ensemble de services .NET ordinaires plus un modèle de temps de développement qui décrit comment ils s”emboîtent. Savoir lesquels de ces assemblys atteignent réellement un client — et lesquels ne quittent jamais votre machine de build — décide de toute la stratégie de protection, et c”est plus simple qu”il n”y paraît.

L”AppHost est un plan, pas un binaire que vous distribuez

Ouvrez une solution Aspire fraîchement créée et vous obtenez trois sortes de projet : l”AppHost, une bibliothèque partagée ServiceDefaults et un ou plusieurs services (une API, un front end web, des workers). Il est tentant de traiter l”AppHost comme l”application, parce que c”est là que vous appuyez sur F5. Il ne l”est pas. L”AppHost est un modèle d”orchestration. Son seul travail est de construire un graphe de ressources et de leurs relations :

var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.ApiService>("apiservice");

builder.AddProject<Projects.Web>("webfrontend")
       .WithReference(api);

builder.Build().Run();

Ces types Projects.ApiService et Projects.Web ne sont pas quelque chose que vous avez écrit. Le générateur de source d”Aspire émet un type de métadonnées par projet référencé dans l”assembly de l”AppHost, portant le chemin du projet pour que l”hôte puisse le lancer. L”AppHost les utilise au moment du développement pour démarrer des processus, et au moment de la publication pour émettre un manifeste de déploiement (aspire-manifest.json) qu”un outil de déploiement consomme. Dans aucun de ces modes l”assembly de l”AppHost ne voyage vers la production en tant que code en exécution que votre client puisse décortiquer. C”est un artefact de build.

Ainsi la première règle s”écrit d”elle-même : n”obfusquez pas l”AppHost. Il n”y a aucune PI dans un graphe de ressources qu”un attaquant ne pourrait reconstruire en observant la topologie déployée, les types Projects.* générés sont de la plomberie du compilateur, et l”étape du manifeste veut un assembly propre et prévisible. Excluez-le et dépensez le budget de protection là où le code est réellement distribué.

Les services parlent par nom, pas par type

La propriété qui rend Aspire agréable à obfusquer est la façon dont les services se trouvent les uns les autres. Quand le front end web appelle l”API, il ne détient pas de référence vers un type de l”API. Il effectue un appel HTTP vers un nom logique :

builder.Services.AddHttpClient<ApiClient>(c =>
    c.BaseAddress = new("https+http://apiservice"));

apiservice est le nom que vous avez donné à la ressource dans l”AppHost, rien de plus. À l”exécution, la découverte de services le résout depuis la configuration que l”orchestrateur injecte en tant que variables d”environnement au démarrage du processus — une clé par endpoint :

Services__apiservice__https__0 = https://10.0.3.14:8443
Services__apiservice__http__0  = http://10.0.3.14:8080

Lisez cela attentivement, car c”est tout l”argument. Le lien entre deux services est une chaîne de configuration et une URL d”endpoint. Ce n”est pas un nom de type obtenu par réflexion, ni un nom d”assembly, ni une méthode. Quand Nebula renomme ApiService.OrderController.PlaceOrder en a.b.c, le front end web appelle toujours https+http://apiservice/orders et résout toujours apiservice depuis la même clé injectée. Le renommage ne peut atteindre l”autre côté de la frontière de processus, parce que la frontière de processus est une frontière HTTP et rien de managé ne la traverse.

AppHostdev + publication seulement · non distribuéémet aspire-manifest.jsonwebfrontend.dllobfusqué · graine propreapiservice.dllobfusqué · graine propreHTTPhttps+http://apiservicerésolu depuis Services__apiservice__https__0À conserver au-delà de la frontière HTTPDTO JSON (noms de propriété) · classes d''optionsclés de config liées · endpoints atteints par le framework
L''AppHost n''est jamais distribué ; chaque assembly de service est obfusqué avec sa propre graine. Le seul couplage est un nom logique résolu depuis la configuration injectée, donc le renommage est sûr jusqu''à la frontière de sérialisation.

C”est une position réellement meilleure que celle d”un monolithe en processus. Dans un monolithe, deux composants qui partagent un type managé doivent être renommés avec une seule carte coordonnée, sinon l”identité du type partagé dérive. Les services d”Aspire ne partagent jamais un type managé à l”exécution — ils partagent un contrat de câble — vous pouvez donc obfusquer apiservice.dll et webfrontend.dll avec des graines indépendantes sans aucune coordination.

Les trois choses qui mordent encore

L”indépendance s”arrête exactement aux données qui traversent le câble, et au projet partagé contre lequel les deux services compilent. Trois surfaces demandent de l”attention.

DTO sérialisés. Le contrat HTTP est du JSON, et System.Text.Json se lie par nom de propriété. Si apiservice renvoie un OrderResult et que webfrontend le désérialise, les deux côtés s”accordent sur "orderId", "total", etc. — par nom. Renommez la propriété de l”un ou l”autre côté et le champ disparaît silencieusement de la charge utile :

// avant — sérialise { "orderId": 4012, "total": 59.90 }
public sealed class OrderResult
{
    public int OrderId { get; set; }
    public decimal Total { get; set; }
}
// après un renommage aveugle — la clé JSON change avec le nom de la propriété
.property instance int32 a() { .get instance int32 OrderResult::get_a() }
// System.Text.Json écrit maintenant { "a": 4012, ... } et l''appelant voit null

Le correctif est la même règle de conservation que requiert tout type web sérialisé : excluez les propriétés du DTO du renommage, ou fixez les noms avec [JsonPropertyName] pour que la clé du câble soit découplée du nom du membre. La liste de conservation de Nebula gère cela de façon déclarative — faites correspondre l”espace de noms du DTO et conservez les noms de propriété publics, tandis que les corps de méthode et tout l”interne restent entièrement obfusqués.

Liaison de configuration. Les services lient des options depuis la configuration — y compris les valeurs de découverte de services et de chaîne de connexion qu”Aspire injecte. builder.Services.Configure<SmtpOptions>(config.GetSection("Smtp")) fait correspondre SmtpOptions.Host à la clé Smtp:Host par nom de propriété. Renommée, la liaison renvoie une valeur par défaut et la fonctionnalité se configure mal à l”exécution sans exception. Les classes d”options liées depuis la configuration appartiennent à la liste de conservation pour la même raison que les DTO.

ServiceDefaults. C”est le seul assembly partagé sous forme managée plutôt que par le câble. Le Program.cs de chaque service l”appelle :

builder.AddServiceDefaults();   // OpenTelemetry, health checks, découverte de services
// ...
app.MapDefaultEndpoints();      // /health et /alive

AddServiceDefaults est une méthode publique dans ServiceDefaults.dll, appelée depuis chaque assembly de service. Si vous obfusquez ServiceDefaults.dll seul et renommez cette méthode publique, chaque appelant casse — le site d”appel dans apiservice.dll cherche toujours AddServiceDefaults. La réponse n”est pas de garder le nom de la méthode publique à jamais ; c”est d”obfusquer la solution comme une unité, pour que le renommeur réécrive la méthode et tous ses sites d”appel ensemble à travers les assemblys. C”est de l”obfuscation multi-projet ordinaire : regroupez ServiceDefaults avec ses consommateurs sous une seule exécution, et la plomberie publique peut être renommée librement parce que l”obfuscateur voit les deux bouts. Notez que les chaînes d”endpoint "/health" et "/alive" sont des littéraux, pas des symboles — le renommage ne les touche pas et elles continuent de fonctionner.

Où vont les transformations lourdes

Les frontières conservées, dirigez la vraie protection vers le code qui porte de la valeur à l”intérieur de chaque service : vérifications de licence et de droits, logique de tarification et de quotas, dérivation de clés, tout algorithme propriétaire. Appliquez l”aplatissement du flux de contrôle, le chiffrement de chaînes et — sur les rares méthodes qui justifient le coût à l”exécution — la virtualisation de code à ces méthodes en particulier, exactement comme vous le feriez dans un build à service unique. La forme d”Aspire ne change pas ce que vous protégez ; elle change seulement l”empaquetage autour. Une configuration Nebula raisonnable obfusque chaque projet de service, conserve la surface sérialisée et liée à la configuration, exclut l”AppHost et s”exécute sur la sortie de build avant que dotnet publish ne produise les images de conteneur :

{
  "input": "apiservice.dll",
  "keep": [
    "ApiService.Contracts.*",
    "ApiService.Options.*"
  ],
  "controlFlow": "aggressive",
  "stringEncryption": true,
  "virtualize": [ "ApiService.Licensing.*" ]
}

À retenir

Une solution Aspire n”est pas une application avec une histoire de protection particulière ; ce sont plusieurs services ordinaires dont le couplage se trouve être basé sur des chaînes et hors processus, orchestrés par un AppHost que vous ne distribuez jamais. Cela rend la stratégie nette : sautez l”AppHost, obfusquez chaque service avec sa propre graine, conservez les surfaces JSON et de configuration qui traversent la frontière, et obfusquez ServiceDefaults avec les services qui l”appellent. Puis dirigez les transformations lourdes vers la logique d”application des règles et métier à l”intérieur de chaque processus — là où elle a toujours eu sa place. Pour la référence complète des règles de conservation, voyez la documentation de configuration de Nebula, et vérifiez le résultat avec Glass.NET.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.