Node-locking des activations et survivre à la dérive d'empreinte
Une licence node-locked lie un siège à une machine. Le lien est une empreinte machine : un hachage stable et salé dérivé de signaux matériels et du système d'exploitation, jamais d'identifiants matériels bruts. Cette analyse montre comment le SDK Keyright calcule l'empreinte et l'envoie dans ActivateAsync, comment le service d'émission compte les empreintes distinctes comme des appareils actifs, et le vrai problème opérationnel de la dérive d'empreinte : un clone de VM, un disque réimagé, une carte réseau remplacée ou une extension de RAM modifient l'empreinte, la machine semble neuve et les sièges s'épuisent. Nous couvrons les empreintes multisignaux pondérées, la correspondance par tolérance, la désactivation et l'expiration de bail pour récupérer les sièges, et le verrouillage qui échoue en fermé.
Le node-locking répond à une question : est-ce la machine sur laquelle la licence a été activée ? C”est le modèle de licence le plus ancien et le plus intuitif : vous achetez trois sièges, vous installez sur trois machines, et chaque installation est épinglée au matériel sur lequel elle tourne. Le mécanisme d”épinglage est une empreinte machine : un identifiant court et stable que le SDK dérive de la machine et envoie au service d”émission lors de l”activation. Le service la mémorise, la compte comme un siège occupé et, dès lors, s”attend à voir la même empreinte chaque fois que cette installation se signale.
Le modèle est simple jusqu”à ce que le matériel change. Une empreinte n”est stable que dans la mesure où les signaux dont elle est construite le sont, et les vraies machines mutent : les disques sont réimagés, les cartes réseau sont remplacées, les VM sont clonées, les portables reçoivent plus de RAM. Quand les signaux bougent, l”empreinte bouge avec eux, la machine paraît neuve pour le service d”émission et un siège qui aurait dû rester en place est dépensé deux fois. Ce mode de défaillance — la dérive d”empreinte — est le vrai sujet de cet article. Nous construirons d”abord l”empreinte, la raccorderons à l”activation Keyright, puis consacrerons l”essentiel du temps à la faire survivre au monde physique.
Ce qu”est une empreinte machine
Une empreinte est un unique hachage représentant une machine. Vous n”envoyez jamais d”identifiants matériels bruts au service d”émission : ce serait à la fois un risque pour la vie privée et un dossier réversible du matériel de quelqu”un. À la place, vous collectez une poignée de signaux raisonnablement stables par machine, les combinez et hachez la combinaison avec un sel propre au produit :
- GUID de machine — l”identité d”installation au niveau du système d”exploitation (
MachineGuidsous Windows,/etc/machine-idsous Linux, leIOPlatformUUIDsous macOS). - Adresse MAC principale — l”adresse matérielle de l”adaptateur réseau principal, les adaptateurs virtuels et de loopback étant filtrés.
- Numéro de série du volume système — le numéro de série du volume du système d”exploitation.
- Identifiant de CPU — signature de modèle/fonctionnalités du processeur.
Aucun de ces éléments ne quitte la machine seul. Ils sont concaténés et réduits à un unique digest SHA-256, salé avec une valeur propre à votre produit, de sorte que la même machine produise des empreintes différentes pour des produits différents et que le digest ne puisse pas être précalculé contre une table arc-en-ciel de matériel courant.
using System.Security.Cryptography;
using System.Text;
public static class MachineFingerprint
{
// Per-product salt — distinct per Keyright product, kept out of logs.
private const string ProductSalt = "keyright:acme-cad:v1";
public static string Compute()
{
// Each signal is collected best-effort; a missing signal yields "".
var signals = new[]
{
HardwareSignals.MachineGuid(), // OS install identity
HardwareSignals.PrimaryMac(), // main NIC, virtual adapters excluded
HardwareSignals.VolumeSerial(), // OS volume serial
HardwareSignals.CpuId(), // processor signature
};
// Order matters: a fixed order makes the digest reproducible.
var material = ProductSalt + "|" + string.Join("|", signals);
var hash = SHA256.HashData(Encoding.UTF8.GetBytes(material));
return Convert.ToHexString(hash).ToLowerInvariant(); // opaque, one-way
}
}
La sortie ressemble à 9f2c…a1, et c”est tout ce que le service d”émission voit un jour. Il n”y a pas de chemin du digest vers la MAC ou le numéro de série du volume : le hachage est unidirectionnel, et le sel signifie que l”empreinte d”une machine connue ne peut pas être reproduite sans le sel du produit. Voilà le contrat de confidentialité : les empreintes sont hachées et salées, jamais des PII brutes, et jamais réversibles en identifiants matériels.
Lier un siège à l”activation
Le SDK envoie l”empreinte dans ActivateAsync. L”initialisation donne au client le produit, la clé publique de signature et l”URL du service de votre déploiement ; l”activation fait une requête de la clé de licence plus l”empreinte calculée vers POST /v1/activate.
KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-cad",
PublicKeyBase64 = "MCowBQYDK2VwAyEA...", // verifies signed responses
ServiceUrl = "https://license.acme.example",
});
var client = KeyrightClient.Current;
// The fingerprint is attached to the activation request automatically,
// but you can inspect or override it for testing.
var result = await client.ActivateAsync(licenseKey);
if (!result.IsValid)
{
// Fail CLOSED: no seat, no licensed functionality.
ShowActivationError(result.Reason); // e.g. SeatsExhausted, InvalidKey
return;
}
Côté service, /v1/activate enregistre le couple (clé de licence, empreinte). Le compteur de sièges est le décompte des empreintes distinctes liées à cette clé : une clé vendue avec trois sièges accepte trois empreintes distinctes et refuse la quatrième avec un résultat SeatsExhausted. Réactiver la même empreinte est idempotent : cela relie la machine qu”il connaît déjà sans consommer de siège supplémentaire. C”est pourquoi l”empreinte doit être stable : toute la notion du service de « combien de machines » est « combien d”empreintes distinctes ai-je vues ».
Chaque exécution ultérieure appelle ValidateAsync, qui recalcule l”empreinte et la présente. Si elle correspond à un lien vivant, la validation réussit et le SDK expose les détails de la licence et les entitlements :
var v = await client.ValidateAsync();
if (!v.IsValid)
{
EnterReadOnlyMode(); // fail closed on any validation failure
return;
}
Console.WriteLine($"Licensed to {v.LicenseInfo.Owner}, seat bound to this machine.");
if (client.HasEntitlement("export.dwg"))
EnableDwgExport();
Le problème de la dérive
C”est ici que le modèle propre rencontre la réalité du matériel. Observez le schéma ci-dessous : les signaux d”une machine alimentent le hachage, le hachage devient une empreinte, et l”empreinte occupe un siège sur le service d”émission. Le chemin inférieur montre ce que fait la dérive : un signal change, le hachage change, et le service voit une nouvelle machine se disputer un nouveau siège tandis que l”ancien lien compte toujours.
Les causes sont banales et fréquentes : un disque réimagé régénère le GUID de machine du système ; un adaptateur réseau remplacé ou dépendant du dock change la MAC ; cloner un modèle de VM duplique — ou, pire, randomise — chaque signal ; une mise à jour de firmware change un numéro de série de volume. Chacune bascule le digest. Un signal unique tout ou rien est fragile ; la solution est de cesser de traiter l”empreinte comme une seule valeur fragile.
Atténuation : pondérer plusieurs signaux
Au lieu de hacher tout en un unique digest impitoyable, calculez une empreinte à partir de composants pondérés et acceptez une correspondance lorsque suffisamment de poids concorde. Le SDK envoie l”ensemble de composants ; le service d”émission décide si l”ensemble présenté est assez proche d”un lien connu pour être la même machine.
public sealed record FingerprintComponent(string Name, string Value, int Weight);
public static IReadOnlyList<FingerprintComponent> Components() => new[]
{
new FingerprintComponent("machineGuid", Hash(HardwareSignals.MachineGuid()), 40),
new FingerprintComponent("volumeSerial", Hash(HardwareSignals.VolumeSerial()), 25),
new FingerprintComponent("cpuId", Hash(HardwareSignals.CpuId()), 20),
new FingerprintComponent("primaryMac", Hash(HardwareSignals.PrimaryMac()), 15),
};
static string Hash(string s) =>
Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes("keyright:acme-cad:v1|" + s)))
.ToLowerInvariant();
Chaque composant est salé et haché individuellement : le signal brut ne quitte toujours jamais la machine. Le service stocke les composants liés à l”activation et, à chaque validation, note l”ensemble présenté par rapport à eux. Si les composants correspondants portent au moins une part configurée du poids total, c”est la même machine ; une seule MAC changée (15 sur 100) ne bascule pas l”identité, mais un changement total le fait.
Correspondance par tolérance côté service
match score = Σ weight(component) where presented.value == bound.value
same machine if match score >= tolerance threshold (e.g. 70 of 100)
re-bind if same machine and some components changed (heal the drift)
new machine if match score < threshold (count a seat)
Un seuil de tolérance absorbe la dérive ordinaire. Quand une machine correspond au-dessus du seuil mais que certains composants ont changé — la MAC a bougé, par exemple — le service la traite comme le même siège et relie au nouvel ensemble de composants, guérissant la dérive pour que la validation suivante corresponde proprement. Ce n”est que lorsque trop a changé qu”il compte une nouvelle machine. Choisissez le seuil délibérément : trop lâche et des machines distinctes entrent en collision sur un même siège ; trop strict et des mises à niveau ordinaires épuisent les sièges.
Récupérer des sièges : désactivation et expiration de bail
La tolérance réduit la dérive mais ne peut pas tout attraper : une réimage complète ou un portable retiré laisse réellement un lien obsolète occupant un siège. Deux mécanismes le rendent.
Désactivation explicite. Avant de mettre hors service ou de déplacer une licence, le client libère son siège. Cela fait une requête vers POST /v1/deactivate et le siège revient aussitôt.
// Freeing a seat so it can be re-used elsewhere.
var released = await client.DeactivateAsync();
if (released.IsValid)
Console.WriteLine("Seat released; this machine no longer counts.");
Expiration de bail. La désactivation ne fonctionne que lorsque la machine est encore là pour l”appeler : un disque mort ne se désactive jamais. C”est pourquoi chaque lien porte aussi un bail avec une expiration que le client renouvelle à chaque ValidateAsync. Une machine qui cesse de valider — retirée, réimagée, définitivement hors ligne — cesse de renouveler ; une fois son bail expiré, le service d”émission récupère le siège automatiquement. La désactivation est la voie propre et immédiate ; l”expiration du bail est le filet de secours pour les machines disparues. À la réactivation (l”utilisateur réinstalle, ou déplace la clé vers un matériel de remplacement) le SDK calcule simplement l”empreinte actuelle et ActivateAsync la lie au siège désormais libre.
Échouer en fermé, toujours
La règle non négociable : lorsque l”activation est refusée, que la validation échoue ou que les sièges sont épuisés, l”application doit échouer en fermé — refuser la fonctionnalité sous licence plutôt que présumer la bonne foi. Le node-locking n”a de sens que si la porte tient quand la réponse est « non » :
var v = await client.ValidateAsync();
bool licensed = v.IsValid
&& v.LicenseInfo is { } info
&& !info.IsExpired;
if (!licensed)
{
// Seat exhausted, fingerprint unknown, lease lapsed, or offline past grace:
// do NOT enable paid features. Degrade, don't default-open.
EnterReadOnlyMode();
return;
}
EnableLicensedFeatures();
Conteneurs et identité éphémère
Le node-locking suppose une machine durable. Un conteneur n”en a pas : chaque nouveau conteneur calcule une empreinte différente et brûlerait un siège à chaque démarrage, épuisant le compteur presque aussitôt. Pour les charges de travail jetables ou autoscalées, le node-locking est le mauvais outil ; vous voulez plutôt un modèle d”identité adaptée à l”éphémère : des baux très courts qui récupèrent en quelques minutes, ou un modèle de concurrence qui compte l”usage simultané plutôt que les machines distinctes. (Nous couvrons ce modèle séparément dans notre article sur les sièges flottants comptés par bail.) Réservez le node-locking aux postes de travail et serveurs durables, où une empreinte stable est un atout plutôt qu”un combat.
Résumé
Le node-locking lie un siège à une machine via une empreinte salée et unidirectionnelle : assez stable pour compter, assez privée pour ne jamais exposer d”identifiants matériels. Le mode de défaillance qui mord en production est la dérive : un changement de matériel ordinaire déplace l”empreinte et double silencieusement la consommation de sièges. Le remède n”est pas un unique hachage fragile mais une empreinte multisignaux pondérée avec un seuil de tolérance qui relie à travers les petits changements, soutenue par une désactivation explicite et une expiration de bail pour récupérer les sièges des machines disparues. Verrouillez le tout en échouant en fermé, et gardez les charges éphémères sur un modèle d”identité conçu pour elles.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.