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.
Tout système de licences a une mauvaise journée qui ressemble à ceci. Un ticket de support mentionne une clé de licence que vous ne reconnaissez pas sur un compte que si. Votre tableau de bord d’abus s’allume parce qu’une clé s’est activée depuis Lisbonne, puis depuis São Paulo onze minutes plus tard. Ou quelqu’un colle une clé directement dans un gist public avec la légende « ça marche, profitez-en ». La clé est réelle, elle a été émise correctement, et le fichier de licence signé sur chaque machine qui la détient se valide toujours parfaitement. L’expiration ne vous sauvera pas : elle est à des mois. Vous devez la révoquer, et il faut que chaque client qui la détient l’apprenne et s’arrête.
Cet article est le mode d’emploi de bout en bout : détecter l’abus qui justifie la révocation, exécuter la révocation contre votre déploiement Keyright, ce que la révocation change vraiment côté serveur et — la partie qui décide si tout cela compte — comment un client SDK déployé apprend que sa clé est morte et échoue en mode fermé.
Pourquoi la révocation est un problème différent de l’expiration
Il est utile d’être précis sur ce qu’est une licence signée. Quand Keyright émet une clé, le client reçoit une charge de licence signée avec la clé privée de votre produit ; le SDK la vérifie hors ligne contre la clé publique que vous épinglez. Cette signature est tout l’intérêt : elle signifie qu’un client peut faire confiance à une licence sans appeler la maison à chaque appel. L’expiration voyage à l’intérieur de cette charge, donc un client l’applique avec zéro réseau.
La révocation brise ce modèle confortable à dessein. Vous prenez une décision après que la licence a été signée : cette clé précise, signature valide comprise, ne devrait plus fonctionner. Rien dans les octets que le client détient déjà ne reflète cela. La signature reste correcte. La seule façon pour un client de découvrir la révocation est de demander à l’autorité qui a pris la décision — votre issuing service — ou de s’appuyer sur une réponse mise en cache à laquelle on permet de devenir obsolète. Ce seul fait gouverne tout ce qui suit, y compris pourquoi l’intervalle de revalidation est le réglage le plus important que vous toucherez.
Étape 0 : détecter l’abus qui mérite une révocation
La révocation est une réponse, donc le déclencheur compte. Quelques signaux la justifient de façon fiable :
- Surutilisation de sièges concurrents. Une clé licenciée pour une poignée de sièges se valide depuis des dizaines d’identités de machine distinctes à la fois. Les enregistrements d’activation de Keyright vous donnent le nombre de nœuds distincts par licence ; quand il dépasse largement le nombre de sièges autorisé et y reste, la clé s’est échappée.
- Voyage impossible. Deux activations de la même clé séparées par plus de fuseaux horaires que de minutes. Une clé ne peut pas être à Lisbonne et à São Paulo en un quart d’heure ; deux copies d’elle, si.
- Exposition publique. La clé apparaît sur un site de collage, un
.envversionné, un fil de support, un forum. Une fois qu’une clé est publique, le comptage des sièges ne suivra pas : vous la révoquez et la réémettez.
Vous pouvez surveiller cela à la main sur le tableau de bord, ou vous appuyer sur les événements d’activation et de validation que l’issuing service enregistre déjà. Dans tous les cas, la décision de révoquer vous appartient ; la mécanique ci-dessous est la même une fois la décision prise.
Étape 1 : révoquer la clé
Un éditeur révoque une licence de l’une des deux façons équivalentes. Dans le tableau de bord, ouvrez la licence et choisissez Revoke — éventuellement avec un motif et le choix de verrouiller immédiatement ou après une courte fenêtre de grâce. Pour l’automatisation — disons un travail antifraude qui révoque sur un webhook de rétrofacturation — appelez directement l’admin API :
POST /v1/admin/licenses/lic_7c1f9a/revoke HTTP/1.1
Host: your-keyright-deployment.example.com
Authorization: Bearer ${KEYRIGHT_ADMIN_TOKEN}
Content-Type: application/json
{
"reason": "leaked_public",
"effective": "immediate"
}
Un appel réussi renvoie la licence mise à jour avec son nouvel état :
{
"licenseId": "lic_7c1f9a",
"product": "acme-suite",
"status": "revoked",
"reason": "leaked_public",
"revokedAtUtc": "2026-11-14T09:30:02Z",
"graceUntilUtc": null
}
Mettre "effective": "grace" à la place remplirait graceUntilUtc avec un horodatage dans un futur proche : plus de détails sur ce compromis plus bas.
Étape 2 : ce que signifie la révocation côté serveur
Côté serveur, la révocation fait deux choses. D’abord, elle bascule l’état faisant autorité de la licence à revoked dans les enregistrements de votre issuing service, avec un horodatage et un motif : c’est la source de vérité que lit désormais toute vérification en ligne. Ensuite, la clé est placée sur une denylist : un ensemble compact et rapide à consulter d’identifiants de licences révoquées que le chemin de validation consulte avant de renvoyer un verdict. La denylist existe pour que la révocation ne nécessite ni relecture ni nouvelle signature de quoi que ce soit ; la signature d’une clé reste mathématiquement valide pour toujours, et la denylist est ce qui l’annule.
Surtout, l’issuing service cesse d’honorer la clé pour toute nouveauté : pas de nouvelles activations, pas de renouvellements, pas de baux de sièges. Une licence révoquée est un compte clos.
Étape 3 : comment les clients déployés l’apprennent
C’est là que les équipes gagnent ou échouent en silence. Vous avez basculé le serveur ; maintenant chaque copie du SDK sur le terrain doit se mettre à jour. Il y a deux populations, et elles se comportent différemment.
Clients en ligne. Tout client qui peut joindre votre déploiement l’apprend à sa prochaine validation. Le ValidateAsync du SDK consulte l’état faisant autorité, voit la correspondance dans la denylist et renvoie un résultat qui n’est plus valide. Si votre application revalide au démarrage et périodiquement — comme elle le devrait —, la fenêtre entre votre révocation et le client échouant en mode fermé est d’un intervalle de revalidation, généralement des minutes. Pour une clé fuitée publiquement, c’est pratiquement immédiat.
Clients en cache et hors ligne. Le SDK met en cache son dernier bon verdict pour que l’application survive à de brèves coupures réseau sans harceler l’utilisateur. Ce cache est gouverné par l’intervalle de revalidation : combien de temps un « valide » mis en cache peut tenir avant que le SDK doive revérifier contre l’issuing service. Une clé révoquée continue de fonctionner sur un client hors ligne jusqu’au moment précis où cet intervalle s’écoule et où la vérification suivante revient révoquée. L’intervalle est donc un cadran direct sur votre exposition : un intervalle de 30 jours signifie qu’une clé révoquée peut continuer de fonctionner hors ligne jusqu’à 30 jours ; un intervalle de 6 heures le plafonne à 6 heures. Pour les produits à haut risque, choisissez un intervalle court et acceptez le trafic de vérification supplémentaire : c’est le prix d’une propagation rapide.
La séquence ci-dessous relie toute la chaîne : l’abus est détecté, l’éditeur révoque, la vérification en ligne suivante échoue en mode fermé, et le cache hors ligne expire à sa frontière de revalidation.
Étape 4 : le motif de gating côté client qui échoue vraiment en mode fermé
Rien du travail côté serveur ne compte si l’application traite une validation échouée comme un haussement d’épaules. La règle est brutale : quand la validation ne réussit pas clairement, refusez la fonctionnalité. Pas de « autoriser en cas d’erreur », pas de « autoriser si on n’est pas sûr » : refusez. Voici la forme, avec des idiomes authentiques du SDK Keyright.
using Keyright;
KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = "MCowBQYDK2VwAyEA...", // épinglée à la compilation
ServiceUrl = "https://your-keyright-deployment.example.com",
RevalidationInterval = TimeSpan.FromHours(6) // court = propagation rapide de la révocation
});
var client = KeyrightClient.Current;
public async Task<bool> TryUnlockPremiumExportAsync()
{
var result = await client.ValidateAsync();
// Échoue FERMÉ : le seul chemin vers « true » est une licence valide et non révoquée de façon explicite.
if (!result.IsValid)
{
if (result.Status == LicenseStatus.Revoked)
{
// Fait autorité : la clé a été révoquée. Verrouillez la fonctionnalité et affichez un message clair.
_log.Warning("License {Id} revoked ({Reason}); locking premium export.",
result.LicenseInfo?.LicenseId, result.RevocationReason);
ShowRevokedNotice(result.RevocationReason);
}
else
{
// Expirée, falsifiée, injoignable avec cache obsolète, etc. Refusée quand même.
_log.Warning("License not valid ({Status}); denying premium export.", result.Status);
}
return false;
}
// Clé valide : contrôlez maintenant l'accès par l'entitlement précis, pas seulement « a une licence ».
if (!client.HasEntitlement("premium-export"))
return false;
var info = result.LicenseInfo;
_log.Information("Premium export unlocked for {Customer}.", info?.CustomerRef);
return true;
}
Trois détails portent tout le poids. D’abord, le chemin unique vers le succès : le contrôle n’atteint le déverrouillage que lorsque IsValid est vrai et que l’entitlement est présent. Toute autre branche renvoie false. Ensuite, la vérification explicite de LicenseStatus.Revoked sert l’expérience utilisateur, pas l’application : une clé révoquée mérite un message plus clair qu’un échec générique, mais même si vous supprimiez cette branche la fonctionnalité se verrouillerait quand même, car le !result.IsValid extérieur l’a déjà refusée. Enfin, le RevalidationInterval court fait un travail discret : il plafonne combien de temps un « valide » mis en cache peut survivre à une révocation.
Une note sur où ne pas échouer fermé : ne faites pas planter sèchement toute l’application sur une erreur réseau transitoire. Le modèle de verdict mis en cache existe précisément pour qu’une brève panne ne rende pas inutilisable un client qui paie. Échouez fermé sur la fonctionnalité, gardez l’application en marche, et laissez la prochaine revalidation réussie restaurer l’accès — ou confirmer la révocation.
Verrouillage immédiat contre grâce
Révoquer avec "effective": "immediate" met la clé sur la denylist maintenant ; la vérification suivante, où qu’elle soit, échoue en mode fermé. C’est correct pour la fraude, les rétrofacturations et les fuites publiques, où vous voulez que la valeur cesse de couler à cette minute.
La grâce est pour le cas de l’erreur honnête. Un bon client a versé sa clé dans un dépôt public ; vous voulez tuer cette clé mais ne pas interrompre son travail pendant qu’il bascule vers un remplacement. Révoquer avec un graceUntilUtc court laisse les clients en ligne continuer à valider jusqu’à cet horodatage, puis échouer en mode fermé — et entre-temps vous remettez au client une clé fraîchement émise. Le compromis est réel : chaque minute de grâce est une minute où la clé fuitée fonctionne encore pour quiconque la détient aussi. Réservez la grâce aux situations à faible risque et associez-la à une réémission immédiate ; par défaut, choisissez le verrouillage immédiat pour tout ce qui sent l’abus.
La version en un paragraphe
La révocation est une décision postérieure à l’émission qu’une signature valide ne peut exprimer, donc les clients doivent l’apprendre en demandant. Vous révoquez via le tableau de bord ou l’admin API ; côté serveur, l’état de la licence bascule à revoked et la clé rejoint une denylist que le chemin de validation consulte. Les clients en ligne échouent en mode fermé à leur prochain ValidateAsync ; les clients hors ligne ne continuent de fonctionner que jusqu’à l’expiration de l’intervalle de revalidation, alors réglez cet intervalle court pour les clés à haut risque. Dans l’application, faites du chemin de refus le choix par défaut et du déverrouillage l’unique exception étroite. Faites cela, et une clé fuitée devient un bref incident plutôt qu’un robinet ouvert.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.