Node-locking de activaciones y sobrevivir a la deriva de huella
Una licencia node-locked vincula un asiento a una máquina. El vínculo es una huella de máquina: un hash estable y salteado derivado de señales de hardware y del sistema operativo, nunca de identificadores de hardware en crudo. Este análisis muestra cómo el SDK de Keyright calcula la huella y la envía en ActivateAsync, cómo el servicio de emisión cuenta huellas distintas como dispositivos activos y el problema operativo real de la deriva de huella: un clon de VM, un disco reimaginado, una NIC cambiada o una ampliación de RAM alteran la huella, la máquina parece nueva y los asientos se agotan. Cubrimos huellas multiseñal ponderadas, coincidencia por tolerancia, desactivación y expiración de arrendamiento para recuperar asientos, y la verificación que falla en cerrado.
El node-locking responde a una pregunta: ¿es esta la máquina en la que se activó la licencia? Es el modelo de licenciamiento más antiguo e intuitivo: compras tres asientos, instalas en tres máquinas y cada instalación queda fijada al hardware en el que corre. El mecanismo de fijación es una huella de máquina: un identificador corto y estable que el SDK deriva de la máquina y envía al servicio de emisión en la activación. El servicio la recuerda, la cuenta como un asiento ocupado y, a partir de ahí, espera ver la misma huella cada vez que esa instalación se registre.
El modelo es simple hasta que el hardware cambia. Una huella es tan estable como las señales de las que se construye, y las máquinas reales mutan: los discos se reimaginan, las tarjetas de red se cambian, las VM se clonan, los portátiles reciben más RAM. Cuando las señales se mueven, la huella se mueve con ellas, la máquina parece nueva para el servicio de emisión y un asiento que debería haberse quedado en su sitio se gasta dos veces. Ese modo de fallo —la deriva de huella— es el verdadero tema de este artículo. Construiremos primero la huella, la conectaremos a través de la activación de Keyright y luego dedicaremos la mayor parte del tiempo a hacerla sobrevivir al mundo físico.
Qué es una huella de máquina
Una huella es un único hash que representa a una máquina. Nunca envías identificadores de hardware en crudo al servicio de emisión: eso sería tanto un riesgo de privacidad como un dossier reversible del hardware de alguien. En su lugar, recopilas un puñado de señales razonablemente estables por máquina, las combinas y hasheas la combinación con un salt específico del producto:
- GUID de máquina — la identidad de instalación a nivel de sistema operativo (
MachineGuiden Windows,/etc/machine-iden Linux, elIOPlatformUUIDen macOS). - Dirección MAC principal — la dirección de hardware del adaptador de red principal, con los adaptadores virtuales y de loopback filtrados.
- Número de serie del volumen del sistema — el número de serie del volumen del sistema operativo.
- Identificador de CPU — firma de modelo/características del procesador.
Ninguna de estas sale de la máquina por sí sola. Se concatenan y se reducen a un único digest SHA-256, salteado con un valor único de tu producto para que la misma máquina produzca huellas distintas para productos distintos y el digest no pueda precalcularse contra una tabla arcoíris de hardware común.
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 salida es algo como 9f2c…a1, y eso es todo lo que el servicio de emisión llega a ver. No hay camino desde el digest de vuelta a la MAC o al número de serie del volumen: el hash es unidireccional, y el salt significa que la huella de una máquina conocida no puede reproducirse sin el salt del producto. Este es el contrato de privacidad: las huellas se hashean y se saltean, nunca son PII en crudo y nunca son reversibles a identificadores de hardware.
Vincular un asiento en la activación
El SDK envía la huella en ActivateAsync. La inicialización da al cliente el producto, la clave pública de firma y la URL del servicio de tu despliegue; la activación hace una petición de la clave de licencia más la huella calculada a 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;
}
Del lado del servicio, /v1/activate registra el par (clave de licencia, huella). El medidor de asientos es el recuento de huellas distintas vinculadas a esa clave: una clave vendida con tres asientos acepta tres huellas distintas y rechaza la cuarta con un resultado SeatsExhausted. Reactivar la misma huella es idempotente: vuelve a vincular la máquina que ya conoce y no consume un asiento extra. Por eso la huella debe ser estable: toda la noción del servicio sobre “cuántas máquinas” es “cuántas huellas distintas he visto”.
Cada ejecución posterior llama a ValidateAsync, que recalcula la huella y la presenta. Si coincide con un vínculo vivo, la validación tiene éxito y el SDK expone los detalles de la licencia y las 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();
El problema de la deriva
Aquí es donde el modelo limpio se encuentra con la realidad del hardware. Observa el diagrama de abajo: las señales de una máquina alimentan el hash, el hash se convierte en una huella, y la huella ocupa un asiento en el servicio de emisión. La ruta inferior muestra lo que hace la deriva: una señal cambia, el hash cambia y el servicio ve una máquina nueva compitiendo por un asiento nuevo mientras el vínculo antiguo sigue contando.
Las causas son cotidianas y frecuentes: un disco reimaginado regenera el GUID de máquina del sistema operativo; un adaptador de red cambiado o dependiente del dock cambia la MAC; clonar una plantilla de VM duplica —o, peor, aleatoriza— cada señal; una actualización de firmware cambia un número de serie de volumen. Cada una voltea el digest. Una única señal de todo o nada es frágil; la solución es dejar de tratar la huella como un solo valor frágil.
Mitigación: ponderar varias señales
En lugar de hashear todo en un único digest implacable, calcula una huella a partir de componentes ponderados y acepta una coincidencia cuando suficiente peso concuerda. El SDK envía el conjunto de componentes; el servicio de emisión decide si el conjunto presentado está lo bastante cerca de un vínculo conocido como para ser la misma máquina.
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();
Cada componente se saltea y hashea individualmente: la señal en crudo sigue sin salir nunca de la máquina. El servicio almacena los componentes vinculados en la activación y, en cada validación, puntúa el conjunto presentado contra ellos. Si los componentes coincidentes llevan al menos una cuota configurada del peso total, es la misma máquina; una sola MAC cambiada (15 de 100) no voltea la identidad, pero un cambio total sí.
Coincidencia por tolerancia en el servicio
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 umbral de tolerancia absorbe la deriva ordinaria. Cuando una máquina coincide por encima del umbral pero algunos componentes han cambiado —la MAC se movió, por ejemplo— el servicio la trata como el mismo asiento y vuelve a vincular al nuevo conjunto de componentes, sanando la deriva para que la siguiente validación coincida limpiamente. Solo cuando ha cambiado demasiado cuenta una máquina nueva. Elige el umbral con cuidado: demasiado laxo y máquinas distintas colisionan en un mismo asiento; demasiado estricto y las actualizaciones ordinarias agotan asientos.
Recuperar asientos: desactivación y expiración de arrendamiento
La tolerancia reduce la deriva pero no puede atraparlo todo: una reimagen completa o un portátil retirado deja realmente un vínculo obsoleto ocupando un asiento. Dos mecanismos lo devuelven.
Desactivación explícita. Antes de dar de baja o mover una licencia, el cliente libera su asiento. Esto hace una petición a POST /v1/deactivate y el asiento regresa de inmediato.
// 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.");
Expiración de arrendamiento. La desactivación solo funciona cuando la máquina todavía existe para llamarla: un disco muerto nunca se desactiva. Por eso cada vínculo lleva además un arrendamiento con una expiración que el cliente renueva en cada ValidateAsync. Una máquina que deja de validar —retirada, reimaginada, permanentemente sin conexión— deja de renovar; una vez que su arrendamiento caduca, el servicio de emisión recupera el asiento automáticamente. La desactivación es la vía limpia e inmediata; la expiración del arrendamiento es el respaldo para las máquinas que desaparecieron. En la reactivación (el usuario reinstala, o mueve la clave a un hardware de reemplazo) el SDK simplemente calcula la huella actual y ActivateAsync la vincula al asiento ahora libre.
Fallar en cerrado, siempre
La regla innegociable: cuando se rechaza la activación, la validación falla o los asientos se agotan, la aplicación debe fallar en cerrado —negar la funcionalidad con licencia en lugar de presumir buena voluntad. El node-locking solo tiene sentido si la puerta se sostiene cuando la respuesta es “no”:
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();
Contenedores e identidad efímera
El node-locking asume una máquina duradera. Un contenedor no tiene una: cada contenedor nuevo calcula una huella distinta y quemaría un asiento en cada arranque, agotando el medidor casi de inmediato. Para cargas de trabajo desechables o autoescaladas, el node-locking es la herramienta equivocada; en su lugar quieres un modelo de identidad apta para lo efímero: arrendamientos muy cortos que recuperan en minutos, o un modelo de concurrencia que cuenta el uso simultáneo en lugar de máquinas distintas. (Cubrimos ese modelo por separado en nuestro artículo sobre asientos flotantes contados por arrendamiento.) Reserva el node-locking para estaciones de trabajo y servidores duraderos, donde una huella estable es una ventaja en vez de una pelea.
Resumen
El node-locking vincula un asiento a una máquina mediante una huella salteada y unidireccional: lo bastante estable para contar, lo bastante privada para no exponer nunca identificadores de hardware. El modo de fallo que muerde en producción es la deriva: un cambio de hardware ordinario mueve la huella y duplica silenciosamente el consumo de asientos. La cura no es un único hash frágil sino una huella multiseñal ponderada con un umbral de tolerancia que vuelve a vincular a través de cambios pequeños, respaldada por desactivación explícita y expiración de arrendamiento para recuperar asientos de máquinas que ya no están. Protégelo todo fallando en cerrado y mantén las cargas efímeras en un modelo de identidad hecho para ellas.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.