Pourquoi la licence de ce client est-elle bloquée ?
Un ingénieur support reçoit un ticket disant qu'une licence « ne s'active pas », mais le client échoue en mode fermé et ne signale que « bloqué ». Voici un outil de diagnostic en lecture seule, bâti sur l'API d'administration de Keyright, qui rejoue tout le pipeline de vérification en mode explicatif et indique exactement quelle vérification a échoué — expiration, révocation, liaison de machine, un siège ou un droit absent — sans jamais exposer la clé.
Un ingénieur support ouvre un ticket : « Le client ACME dit que l’application ne s’active pas — elle dit juste que la licence est bloquée. » C’est toute l’information disponible, car un client de licence correctement conçu est fait pour ne rien donner de plus. Il échoue en mode fermé, refuse l’accès et signale un unique état opaque. L’ingénieur doit maintenant déterminer si l’abonnement a expiré, si la clé a été révoquée, si tous les sièges sont pris, si le client est passé à une nouvelle machine, ou s’il est simplement sur un forfait qui n’a jamais inclus la fonction qu’il essaie d’utiliser — et il doit le faire sans le seul artefact qui rendrait cela trivial et dangereux à partager : la clé signée.
C’est un problème soluble, et la solution n’est pas de rendre le client plus bavard. C’est un petit outil de diagnostic en lecture seule qui parle au service émetteur via l’API d’administration de Keyright et rejoue le pipeline de vérification dans un mode qui explique au lieu d’appliquer.
Le client répond à une question ; le support en a besoin d’une autre
La vérification à l’intérieur du client est un pipeline à court-circuit. Il exécute une séquence fixe de vérifications — la signature est-elle authentique, le « maintenant » est-il dans la fenêtre de validité, la clé est-elle sur la liste de révocation, est-ce la machine à laquelle la licence est liée, y a-t-il un siège libre, la licence accorde-t-elle la fonction demandée — et dès qu’une vérification échoue, il s’arrête et refuse. Il n’évalue jamais les vérifications postérieures à l’échec, car il n’en a pas besoin : la réponse est déjà non.
// Inside the client: fail-closed, short-circuiting, deliberately opaque.
LicenseInfo info = client.Validate(); // offline, never throws
if (!info.IsValid)
return Gate.Deny("This copy is not licensed. Contact your administrator.");
info.IsValid est un unique booléen. L’utilisateur voit « non sous licence ». C’est le comportement correct pour un binaire soumis à l’application, et c’est exactement pourquoi le support ne peut pas travailler à partir de là. La question à laquelle le support doit répondre n’est pas « est-ce bloqué » — il le sait déjà — mais « quelle vérification a échoué, et pourquoi ». Y répondre signifie exécuter le même pipeline contre l’enregistrement de référence du service émetteur, mais avec le court-circuit désactivé, de sorte que chaque vérification rapporte son propre verdict au lieu que le premier échec avale le reste.
Un endpoint de diagnostic en lecture seule
Le service émetteur détient déjà l’enregistrement de référence de chaque licence : sa fenêtre de validité, si elle a été révoquée, à quelle machine elle est liée et combien de ses sièges sont actuellement loués. L’API d’administration expose une vue de diagnostic en lecture seule de cet enregistrement. Elle prend un identifiant non secret — un id de licence, ou une courte empreinte de clé que le client peut lire sur son écran « À propos » — et, en option, une empreinte de machine signalée par le client, afin que la vérification de liaison de nœud puisse aussi être évaluée.
GET /v1/admin/licenses/lic_7f3a9c2e/diagnose?machine=fp_9b21c4 HTTP/1.1
Host: licensing.example.com
Authorization: Bearer {admin_read_token}
La réponse est le pipeline, évalué en entier. Chaque vérification porte son propre verdict — pass, fail ou unknown — et un fail porte un code lisible par machine plus un detail humain. Point crucial, rien ne court-circuite : le fail sur la vérification de siège n’empêche pas la vérification de droit de rapporter, sauf là où une vérification ne peut véritablement pas être évaluée côté serveur.
{
"licenseId": "lic_7f3a9c2e",
"keyFingerprint": "KR…c4e1",
"product": "acme-suite",
"edition": "pro",
"overall": "blocked",
"checks": [
{ "gate": "signature", "verdict": "pass" },
{ "gate": "dateWindow", "verdict": "pass", "expiresOn": "2027-03-01T00:00:00Z" },
{ "gate": "revocation", "verdict": "pass" },
{ "gate": "machine", "verdict": "pass", "detail": "Reported fingerprint matches the bound host." },
{ "gate": "seat", "verdict": "fail", "code": "seats_exhausted",
"detail": "5 of 5 seats are leased. Oldest lease expires in 00:11:42." },
{ "gate": "entitlement","verdict": "unknown",
"detail": "Not reached by the client; not evaluated without a requested feature." }
]
}
Le token de lecture est le mot important. Cet endpoint est en GET seulement et la portée du token n’accorde rien d’autre que des lectures — il ne peut ni révoquer, ni relier, ni prolonger, ni libérer un siège. Un ingénieur support qui peut diagnostiquer ne devrait pas, du fait de cette capacité, pouvoir aussi distribuer de la capacité gratuite en silence. La remédiation est une action distincte et auditée derrière une autre portée.
L’outil de support
Avec un endpoint en lecture seule, l’outil lui-même est mince : récupérer le diagnostic, afficher la liste de vérifications et mettre en tête la première vérification qui échoue — car c’est celle sur laquelle le client s’est réellement arrêté et celle que le client heurte.
public sealed class LicenseDoctor(HttpClient admin)
{
public async Task<Diagnosis> LookUpAsync(string handle, string? machine, CancellationToken ct)
{
var url = $"/v1/admin/licenses/{Uri.EscapeDataString(handle)}/diagnose";
if (machine is not null) url += $"?machine={Uri.EscapeDataString(machine)}";
return (await admin.GetFromJsonAsync<Diagnosis>(url, ct))!;
}
public static void Print(Diagnosis d)
{
Console.WriteLine($"License {d.KeyFingerprint} ({d.Product}/{d.Edition}) → {d.Overall.ToUpper()}");
foreach (var c in d.Checks)
{
var mark = c.Verdict switch
{
"pass" => "[ok] ",
"fail" => "[FAIL]",
_ => "[?] ",
};
Console.WriteLine($" {mark} {c.Gate,-12} {c.Detail}");
}
var cause = d.Checks.FirstOrDefault(c => c.Verdict == "fail");
if (cause is not null)
Console.WriteLine($"\nRoot cause: {cause.Gate} — {cause.Code}\n{cause.Detail}");
}
}
public sealed record Diagnosis(string LicenseId, string KeyFingerprint, string Product,
string Edition, string Overall, IReadOnlyList<Check> Checks);
public sealed record Check(string Gate, string Verdict, string? Code = null, string? Detail = null);
Exécuté contre le ticket d’ACME, il imprime toute l’histoire d’un coup d’œil :
License KR…c4e1 (acme-suite/pro) → BLOCKED
[ok] signature
[ok] dateWindow expires 2027-03-01
[ok] revocation
[ok] machine Reported fingerprint matches the bound host.
[FAIL] seat 5 of 5 seats are leased. Oldest lease expires in 00:11:42.
[?] entitlement Not reached by the client; not evaluated without a requested feature.
Root cause: seat — seats_exhausted
5 of 5 seats are leased. Oldest lease expires in 00:11:42.
Le ticket est désormais résolu en une ligne : ACME n’est ni cassé, ni expiré, ni sur le mauvais forfait — il a simplement utilisé tous les sièges achetés, et une location se libère dans onze minutes. L’ingénieur lui dit d’attendre, de fermer une session ou d’acheter plus de sièges, et personne ne passe un après-midi à poursuivre une expiration qui n’a jamais été le problème.
Lire la vérification de droit
La seule vérification qui affiche unknown par défaut est celle du droit, et la raison mérite d’être dite clairement : les droits sont évalués par rapport à une fonction que l’application a demandée. La vue de diagnostic ne sait pas quelle fonction le client cherchait, elle ne peut donc pas dire si cette concession précise est présente tant que vous ne le lui dites pas. Passez la clé de la fonction et cela se résout :
GET /v1/admin/licenses/lic_7f3a9c2e/diagnose?feature=feature.export HTTP/1.1
{ "gate": "entitlement", "verdict": "fail", "code": "not_granted",
"detail": "This license grants max_projects=10 but not feature.export (Standard edition)." }
Ces clés — feature.export, max_projects, max_major_version — sont les propres noms de droit du fournisseur, transportés dans la concession signée et affichés tels quels. Le diagnostic les lit directement dans l’enregistrement de référence, de sorte que « le client jure avoir payé pour l’export » se résout instantanément en « son édition ne l’inclut pas » — une conversation commerciale, pas un bogue.
Mises en garde, et la ligne que l’outil ne doit pas franchir
Trois limites gardent cela honnête. Premièrement, l’outil est en lecture seule par contrat : diagnostic et remédiation sont des portées distinctes, donc la capacité d’expliquer un blocage n’est jamais la capacité de le défaire en silence. Deuxièmement, deux vérifications dépendent de faits que le serveur ne possède pas — l’empreinte de machine et l’horloge locale vivent sur l’hôte du client, donc le diagnostic ne peut les marquer pass/fail que lorsque le client les signale, et renvoie sinon unknown. Un enregistrement serveur sain accompagné d’un client bloqué est la façon dont l’outil pointe exactement vers ces deux choses : une machine déplacée ou une horloge décalée. Troisièmement, le diagnostic est un instantané au moment où le support l’exécute — un siège épuisé à 14h02 peut être libre à 14h05 — donc les minutages de location qu’il imprime sont indicatifs, pas une garantie.
Et la ligne qu’il ne doit pas franchir : la clé n’entre jamais dans le flux. L’outil identifie une licence par id ou empreinte, la réponse ne renvoie qu’une empreinte, et la transcription de support qui survit au ticket ne porte rien avec quoi un lecteur pourrait activer. Un outil de diagnostic existe pour transformer « ça dit juste bloqué » en « sièges épuisés, se libère dans onze minutes » — pour rendre lisible pour un humain le client qui échoue en mode fermé — tout en révélant exactement aussi peu que le client lui-même.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.