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.
Vous venez de signer votre premier accord de distribution. Un revendeur dans une autre région vendra votre produit .NET, gérera ses propres clients, émettra ses propres clés de licence et vous reversera une part. Le contrat est conclu ; la question d’intégration arrive le lendemain matin : comment nos équipes frappent-elles réellement les clés ?
Il y a deux réponses qui semblent évidentes et qui sont toutes deux des pièges.
La première consiste à confier au revendeur votre clé de signature racine pour qu’il puisse émettre ce dont il a besoin. Désormais, chaque portable de partenaire détient la clé qui valide toute votre gamme de produits, et le jour où l’un d’eux est victime d’hameçonnage, volé ou simplement copié sur une machine personnelle, l’attaquant peut frapper une clé perpétuelle, toutes fonctions, pour n’importe quel produit que vous vendez — et vous ne pouvez pas distinguer ses contrefaçons de vos propres signatures, parce qu’elles sont votre signature.
La seconde consiste à router chaque vente de revendeur à travers votre service d’émission : le revendeur remplit un formulaire, votre service signe la clé, il la transmet. Rien ne fuite, mais vous avez rendu le bureau de vente de vos partenaires dépendant de votre disponibilité et de votre chemin réseau, et un revendeur qui ne peut pas vous joindre ne peut pas conclure une vente.
Le modèle qui ne renonce à aucune des deux est une chaîne de délégation. Cet article en construit une dans Keyright.
Ce qu’est une chaîne de délégation
Empruntez la forme au fonctionnement des certificats TLS. Une clé racine que vous gardez hors ligne signe un petit nombre de certificats intermédiaires ; ces intermédiaires signent les certificats feuilles que les serveurs présentent réellement ; et un navigateur fait confiance à une feuille parce qu’il peut remonter la chaîne jusqu’à une racine qu’il épingle. La racine privée n’a presque jamais besoin de sortir.
Transposées aux licences, trois clés s’alignent en file :
- Votre paire de clés racine réside sur votre instance Keyright et ne signe rien de visible par le client. Elle signe des certificats de délégation et c’est tout.
- Chaque revendeur détient une paire de clés de délégué. Il la génère ; il conserve la moitié privée ; vous ne la voyez jamais. Vous signez un certificat qui lie sa moitié publique à une portée.
- Le revendeur signe les licences client final avec sa clé privée de délégué.
Une licence émise ainsi n’est pas un jeton isolé. C’est un paquet : la licence finale, plus le certificat de délégation qui l’autorise, voyageant ensemble pour que le client puisse vérifier toute la chaîne avec rien d’autre que l’unique clé publique racine qu’il embarque déjà.
Frapper un certificat de délégation
Le revendeur génère une paire de clés de son côté et ne vous envoie que la moitié publique. Vous frappez son certificat avec la CLI d’administration contre votre instance, en l’estampillant de la portée à l’intérieur de laquelle il est autorisé à vendre :
keyright delegate create \
--name "Northwind Distribution GmbH" \
--public-key "MCowBQYDK2VwAyEA9r...kQ=" \
--product acme-suite \
--max-expiry 2027-12-31 \
--allow-entitlement export,max-dpi,seats \
--max-seats 50 \
--not-after 2026-12-31
Lisez la portée attentivement, car chaque champ est un plafond que le revendeur ne peut jamais relever :
--productle fixe à une seule gamme de produits. Un délégué pouracme-suitene peut pas signer une clé pouracme-enterprise.--max-expiryest l’expiration la plus lointaine que peut porter toute licence qu’il émet. Il peut vendre une clé d’un an ; il ne peut pas en vendre une perpétuelle.--allow-entitlementest l’ensemble des noms d’attributs qu’il peut accorder. Tout ce qui est en dehors est écarté à la vérification, de sorte qu’un revendeur ne peut pas activer en silence une fonction que vous réservez à la vente directe.--max-seatsplafonne le nombre de postes sur toute clé individuelle qu’il émet.--not-afterest l’expiration du certificat lui-même — la délégation elle-même expire à cette date, indépendamment des clés émises sous elle, de sorte qu’un contrat de partenaire échu cesse automatiquement de frapper des clés.
Le service renvoie le certificat signé. La signature couvre la clé publique du délégué et la portée ensemble, de sorte que ni l’une ni l’autre ne peut être altérée sans la casser :
HTTP/1.1 201 Created
Content-Type: application/json
{
"delegateId": "del_7Qk2",
"name": "Northwind Distribution GmbH",
"publicKey": "MCowBQYDK2VwAyEA9r...kQ=",
"scope": {
"product": "acme-suite",
"maxExpiry": "2027-12-31T00:00:00Z",
"allowEntitlements": ["export", "max-dpi", "seats"],
"maxSeats": 50
},
"notAfter": "2026-12-31T00:00:00Z",
"signedBy": "root",
"certificate": "eyJ2IjoxLCJkZWxlZ2F0ZUlkIjoiZGVsXzdRazIi...<signed>"
}
Cette chaîne certificate est ce que le revendeur intègre dans chaque licence qu’il émet. Vous ne gardez rien de secret de sa part ; il ne garde rien de secret de la vôtre.
Le revendeur émet dans la portée
Le revendeur exécute sa propre petite étape d’émission — une CLI sur son bureau de vente, ou un service léger à lui — en signant avec la clé privée de délégué. Il n’appelle jamais votre instance pour conclure une vente :
keyright issue \
--delegate-cert ./northwind.cert \
--delegate-key ./northwind.key \
--licensee acct_8f21 \
--expiry 2027-03-01 \
--entitlement export=true \
--entitlement seats=10
La sortie est le paquet — licence finale et certificat de délégation concaténés en un unique blob .lic que le client active exactement comme n’importe quelle autre clé. Si le revendeur tente de déborder — --expiry 2030-01-01, au-delà de son maxExpiry, ou --entitlement watermark=false, qui n’est pas dans son ensemble autorisé — l’émetteur raisonnable le rejette localement. Mais le rejet local est un confort, pas la garantie. La garantie réside dans le client, qui revérifie tout quoi que l’outil du revendeur ait ou non autorisé.
Le client vérifie la chaîne
Sur la machine du client, le SDK est configuré avec une seule chose qui compte : la clé publique racine. Pas celle du revendeur — celle de la racine. Cet unique épinglage est ce qui permet au client de faire confiance à une clé signée par un partenaire dont il n’a jamais entendu parler.
static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
RootPublicKeyBase64 = AcmeKeys.RootPublicKey, // the ROOT, pinned in the app
ServiceUrl = "https://licensing.acme.example",
});
LicenseInfo info = License.Validate();
Validate() parcourt la chaîne à l’intérieur du paquet :
- Il lit le certificat de délégation et vérifie la signature de la licence finale contre la clé publique de délégué que porte le certificat.
- Il vérifie la signature du certificat de délégation contre la clé publique racine épinglée — et refuse si le
notAfterdu certificat est déjà passé. - Il restreint ensuite la licence à la portée du certificat avant de rapporter quoi que ce soit : l’expiration effective est la plus proche entre l’expiration de la licence et le
maxExpirydu délégué ; tout attribut absent deallowEntitlementsest traité comme non défini ; le nombre de postes est plafonné àmaxSeats.
Seule une licence signée par un délégué, dont le délégué est signé par votre racine, et qui se situe entièrement dans sa portée, revient comme valide. À partir de là, votre application applique le contrôle exactement comme elle l’a toujours fait — info.IsValid, puis les attributs :
if (!info.IsValid) { RunEvaluation(info); return; }
if (License.IsEnabled("export")) EnableExport();
int seats = (int)License.GetLimit("seats", fallback: 1);
// Who issued it — useful for support and telemetry, never for the gate itself.
Log.Information("Licensed via {Delegate}", info.IssuedBy); // "del_7Qk2"
Le client ne sait jamais et ne se soucie jamais qu’un revendeur ait signé sa clé. La chaîne est un détail d’implémentation de la confiance ; la porte qu’il rencontre est la même que celle d’un client direct.
La portée ne peut que se réduire
C’est la propriété qui rend la délégation sûre, et il vaut la peine de le dire clairement : rien en aval de la chaîne ne peut accorder plus que ce que son parent a permis. La restriction de l’étape 3 n’est pas un conseil — c’est tout le modèle de sécurité. Un revendeur qui modifie son émetteur pour estampiller maxExpiry: 2099 sur une clé ne gagne rien, parce que le client prend le minimum entre l’expiration de la licence et le maxExpiry de la portée, et la portée est à l’intérieur du certificat, et le certificat est signé par votre racine. Un seul octet modifié dans la portée casse la signature de la racine et la chaîne échoue en mode fermé à l’étape 2.
Ainsi, le pire qu’une clé de revendeur entièrement compromise puisse faire est d’émettre des clés dans la portée que vous lui avez déjà accordée — un produit, une expiration bornée, un ensemble d’attributs fixe, un plafond de postes. C’est une mauvaise journée. Ce n’est pas une catastrophe, et cela ne peut pas être contrefait vers vos autres produits. Comparez à premier piège, où une clé racine divulguée est la catastrophe, point final.
Une révocation qui se propage
Parce que chaque licence finale sur le terrain porte le certificat dont elle descend, vous disposez d’un interrupteur d’arrêt au niveau du certificat. Si la clé d’un revendeur est compromise — ou que le contrat se termine, ou qu’on le surprend à sur-émettre — vous révoquez le délégué, une seule entrée, et chaque licence que ce revendeur a jamais signée cesse de valider à sa prochaine revalidation en fenêtre de grâce :
keyright delegate revoke del_7Qk2 --reason "partner contract ended"
Le client apprend que le délégué est révoqué de la même façon qu’il apprend qu’une clé individuelle l’est — via la liste de révocation qu’il télécharge déjà — et fait échouer la chaîne au maillon du délégué. Vous n’avez pas à savoir à quels clients finaux ce revendeur a vendu, ni à pourchasser des clés individuelles ; couper la branche fait tomber chaque feuille qui s’y trouve. Pour une sortie propre d’un partenaire, vous laisseriez en général aussi notAfter expirer plutôt que de révoquer en dur, de sorte que les clients existants épuisent leurs termes tandis qu’aucune nouvelle clé ne peut être frappée.
Tester la chaîne
Le test qui mérite sa place est le test de dépassement — prouver que le client refuse d’honorer une violation de portée même lorsque la signature du revendeur est parfaitement valide :
[Fact]
public void Client_clamps_a_license_that_exceeds_its_delegate_scope()
{
var root = TestRoot.Create();
var delegate_ = root.MintDelegate(product: "acme-suite",
maxExpiry: new DateTime(2027, 12, 31), maxSeats: 50,
allow: new[] { "export", "seats" });
// A validly-signed key that asks for more than the scope allows.
string bundle = delegate_.Issue(licensee: "acct_8f21",
expiry: new DateTime(2099, 1, 1), // past maxExpiry
entitlements: new() { ["seats"] = 500 }); // past maxSeats
var client = KeyrightClient.Initialize(new KeyrightOptions
{ Product = "acme-suite", RootPublicKeyBase64 = root.PublicKeyBase64,
LicenseBlob = bundle });
var info = client.Validate();
Assert.True(info.IsValid); // chain is well-formed
Assert.True(info.Expiry <= new DateTime(2027, 12, 31)); // expiry clamped to scope
Assert.Equal(50, client.GetLimit("seats", fallback: 1)); // seats clamped to scope
}
Associez-le à l’inverse — une clé dans la portée valide et conserve ses propres chiffres, plus petits — et à un troisième qui révoque le délégué et affirme que la chaîne échoue alors en mode fermé. Un service d’émission factice en mémoire vous permet de frapper racines, délégués et feuilles de test sans toucher à votre instance réelle.
À retenir
Les revendeurs ont besoin de frapper des clés ; vous avez besoin de ne jamais distribuer votre clé racine et de ne jamais rendre vos partenaires dépendants de votre disponibilité pour vendre. Une chaîne de délégation vous donne les deux. Signez à chaque revendeur un certificat qui lie sa clé publique à une portée qui est un plafond dur — un produit, une expiration maximale, un ensemble d’attributs autorisé, un plafond de postes, et une expiration sur la délégation elle-même. Laissez-les signer les clés client final hors ligne avec la moitié privée. N’embarquez que la clé publique racine dans votre application, et laissez le SDK parcourir licence → délégué → racine et restreindre chaque clé à sa portée avant de la déclarer valide. La portée ne peut que se réduire, donc un partenaire compromis est borné, pas catastrophique ; et comme chaque clé porte son certificat parent, révoquer un délégué retire chaque clé qui en dépend sans que vous connaissiez jamais la liste des clients. C’est ainsi que vous laissez cent revendeurs émettre des clés tout en ne détenant toujours qu’exactement une clé qui compte.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.