Skip to content
← Todas las publicaciones
· Delta1 Labs RevocationKeyright

Revocar una clave de licencia filtrada en todos los clientes

Una clave se compartió, apareció en un sitio de pastes o se está activando desde tres continentes a la vez. Aquí tienes el manual práctico: cómo la revocas en Keyright, qué significa la revocación en el servidor y —la parte que la mayoría de los equipos equivoca— cómo los clientes SDK desplegados se enteran de verdad y dejan de funcionar.

Todo sistema de licencias tiene un mal día que se ve así. Un ticket de soporte menciona una clave de licencia que no reconoces en una cuenta que sí. Tu panel de abuso se enciende porque una clave se activó desde Lisboa y luego desde São Paulo once minutos después. O alguien pega una clave directamente en un gist público con la leyenda “funciona, disfruten”. La clave es real, se emitió correctamente, y el archivo de licencia firmado en cada máquina que la tiene sigue validando perfectamente. La caducidad no te salvará: está a meses de distancia. Necesitas revocarla, y necesitas que todos los clientes que la tienen se enteren y se detengan.

Este artículo es el manual de principio a fin: detectar el abuso que justifica la revocación, ejecutar la revocación contra tu despliegue de Keyright, qué cambia realmente la revocación en el servidor y —la parte que decide si algo de esto importa— cómo un cliente SDK desplegado se entera de que su clave está muerta y falla de forma cerrada.

Por qué la revocación es un problema distinto de la caducidad

Conviene ser preciso sobre qué es una licencia firmada. Cuando Keyright emite una clave, el cliente recibe una carga de licencia firmada con la clave privada de tu producto; el SDK la verifica sin conexión contra la clave pública que fijas. Esa firma es el objetivo central: significa que un cliente puede confiar en una licencia sin llamar a casa en cada llamada. La caducidad viaja dentro de esa carga, así que un cliente la aplica con cero red.

La revocación rompe ese modelo cómodo a propósito. Estás tomando una decisión después de que la licencia fuera firmada: esta clave concreta, firma válida incluida, ya no debería funcionar. Nada en los bytes que el cliente ya tiene refleja eso. La firma sigue siendo correcta. La única forma en que un cliente puede descubrir la revocación es preguntar a la autoridad que tomó la decisión —tu issuing service— o apoyarse en una respuesta cacheada a la que se le permite quedarse obsoleta. Ese único hecho gobierna todo lo que sigue, incluido por qué el intervalo de revalidación es el ajuste más importante que tocarás.

Paso 0: detectar el abuso que merece revocación

La revocación es una respuesta, así que el disparador importa. Unas pocas señales la justifican de forma fiable:

  • Uso excesivo de asientos concurrentes. Una clave licenciada para un puñado de asientos valida desde decenas de identidades de máquina distintas a la vez. Los registros de activación de Keyright te dan el recuento de nodos distintos por licencia; cuando supera con creces el número de asientos autorizado y se queda ahí, la clave se ha escapado.
  • Viaje imposible. Dos activaciones de la misma clave separadas por más husos horarios que minutos. Una clave no puede estar en Lisboa y en São Paulo en un cuarto de hora; dos copias de ella sí.
  • Exposición pública. La clave aparece en un sitio de pastes, un .env versionado, un hilo de soporte, un foro. Una vez que una clave es pública, el recuento de asientos no dará abasto: la revocas y la reemites.

Puedes vigilar esto a mano en el panel, o guiarte por los eventos de activación y validación que el issuing service ya registra. En cualquier caso, la decisión de revocar es tuya; la mecánica de abajo es la misma una vez tomada.

Paso 1: revocar la clave

Un proveedor revoca una licencia de una de dos formas equivalentes. En el panel, abre la licencia y elige Revoke —opcionalmente con un motivo y si bloquear de inmediato o tras una ventana de gracia corta. Para automatizar —digamos, un trabajo antifraude que revoca ante un webhook de contracargo— llama directamente a la 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"
}

Una llamada con éxito devuelve la licencia actualizada con su nuevo estado:

{
  "licenseId": "lic_7c1f9a",
  "product": "acme-suite",
  "status": "revoked",
  "reason": "leaked_public",
  "revokedAtUtc": "2026-11-14T09:30:02Z",
  "graceUntilUtc": null
}

Poner "effective": "grace" en su lugar poblaría graceUntilUtc con una marca de tiempo en el futuro cercano: más sobre ese compromiso abajo.

Paso 2: qué significa la revocación en el servidor

En el servidor, la revocación hace dos cosas. Primero, cambia el estado autoritativo de la licencia a revoked en los registros de tu issuing service, con marca de tiempo y motivo: esta es la fuente de verdad que ahora lee toda comprobación en línea. Segundo, la clave se coloca en una denylist: un conjunto compacto y de consulta rápida de identificadores de licencias revocadas que la ruta de validación comprueba antes de devolver un veredicto. La denylist existe para que la revocación no requiera releer ni volver a firmar nada; la firma de una clave sigue siendo matemáticamente válida para siempre, y la denylist es lo que la anula.

Fundamentalmente, el issuing service deja de honrar la clave para cualquier cosa nueva: sin activaciones nuevas, sin renovaciones, sin arrendamientos de asientos. Una licencia revocada es una cuenta cerrada.

Paso 3: cómo se enteran los clientes desplegados

Aquí es donde los equipos ganan o fallan en silencio. Has cambiado el servidor; ahora cada copia del SDK en el campo tiene que ponerse al día. Hay dos poblaciones, y se comportan de forma distinta.

Clientes en línea. Cualquier cliente que puede alcanzar tu despliegue se entera en su siguiente validación. El ValidateAsync del SDK consulta el estado autoritativo, ve el acierto en la denylist y devuelve un resultado que ya no es válido. Si tu app revalida al arrancar y de forma periódica —como debería—, la ventana entre tu revocación y el cliente fallando de forma cerrada es un intervalo de revalidación, normalmente minutos. Para una clave filtrada públicamente, eso es prácticamente inmediato.

Clientes cacheados y sin conexión. El SDK cachea su último veredicto bueno para que la app sobreviva a cortes breves de red sin incordiar al usuario. Esa caché la gobierna el intervalo de revalidación: cuánto tiempo se permite que un “válido” cacheado se mantenga antes de que el SDK deba volver a comprobar contra el issuing service. Una clave revocada sigue funcionando en un cliente sin conexión justo hasta el momento en que ese intervalo transcurre y la siguiente comprobación vuelve como revocada. El intervalo es por tanto un dial directo sobre tu exposición: un intervalo de 30 días significa que una clave revocada puede seguir funcionando sin conexión hasta 30 días; un intervalo de 6 horas lo limita a 6 horas. Para productos de alto riesgo, elige un intervalo corto y acepta el tráfico extra de comprobaciones: es el precio de una propagación rápida.

La secuencia de abajo enlaza toda la cadena: se detecta el abuso, el proveedor revoca, la siguiente comprobación en línea falla de forma cerrada, y la caché sin conexión expira en su frontera de revalidación.

Detección de abuso Proveedor / admin API Issuing service Clientes SDK viaje imposible / exceso de asientos POST /revoke status=revoked, denylist++ ValidateAsync (en línea) revoked → IsValid=false la app falla cerrada cliente sin conexión: cacheado válido hasta fin del intervalo el intervalo de revalidación acota la exposición sin conexión

Paso 4: el patrón de gating en el cliente que de verdad falla cerrado

Nada del trabajo en el servidor importa si la app trata una validación fallida como un encogimiento de hombros. La regla es contundente: cuando la validación no tiene éxito claro, deniega la función. Nada de “permitir si hay error”, nada de “permitir si no estamos seguros”: deniega. Esta es la forma, usando idiomas genuinos del SDK de Keyright.

using Keyright;

KeyrightClient.Initialize(new KeyrightOptions
{
    Product = "acme-suite",
    PublicKeyBase64 = "MCowBQYDK2VwAyEA...",          // fijada en tiempo de compilación
    ServiceUrl = "https://your-keyright-deployment.example.com",
    RevalidationInterval = TimeSpan.FromHours(6)       // corto = propagación rápida de la revocación
});

var client = KeyrightClient.Current;

public async Task<bool> TryUnlockPremiumExportAsync()
{
    var result = await client.ValidateAsync();

    // Falla CERRADO: el único camino a "true" es una licencia válida y no revocada de forma explícita.
    if (!result.IsValid)
    {
        if (result.Status == LicenseStatus.Revoked)
        {
            // Autoritativo: la clave fue revocada. Bloquea la función y muestra un mensaje claro.
            _log.Warning("License {Id} revoked ({Reason}); locking premium export.",
                result.LicenseInfo?.LicenseId, result.RevocationReason);
            ShowRevokedNotice(result.RevocationReason);
        }
        else
        {
            // Caducada, manipulada, inalcanzable con caché obsoleta, etc. Igualmente denegada.
            _log.Warning("License not valid ({Status}); denying premium export.", result.Status);
        }
        return false;
    }

    // Clave válida: ahora controla el acceso por el entitlement concreto, no solo por "tiene licencia".
    if (!client.HasEntitlement("premium-export"))
        return false;

    var info = result.LicenseInfo;
    _log.Information("Premium export unlocked for {Customer}.", info?.CustomerRef);
    return true;
}

Tres detalles cargan con el peso. Primero, el único camino al éxito: el control solo llega al desbloqueo cuando IsValid es verdadero y el entitlement está presente. Cualquier otra rama devuelve false. Segundo, la comprobación explícita de LicenseStatus.Revoked es para la experiencia de usuario, no para la aplicación: una clave revocada merece un mensaje más claro que un fallo genérico, pero aunque borraras esa rama la función seguiría bloqueándose, porque el !result.IsValid exterior ya la denegó. Tercero, el RevalidationInterval corto hace un trabajo discreto: es el techo de cuánto puede sobrevivir un “válido” cacheado a una revocación.

Una nota sobre dónde no fallar cerrado: no hagas caer en seco toda la app ante un error de red transitorio. El modelo de veredicto cacheado existe precisamente para que un corte breve no deje inservible a un cliente que paga. Falla cerrado en la función, mantén la app en marcha, y deja que la siguiente revalidación con éxito restaure el acceso —o confirme la revocación.

Bloqueo inmediato frente a gracia

Revocar con "effective": "immediate" pone la clave en la denylist ahora; la siguiente comprobación en cualquier parte falla cerrada. Eso es correcto para fraude, contracargos y filtraciones públicas, donde quieres que el valor deje de fluir este minuto.

La gracia es para el caso del error honesto. Un buen cliente subió su clave a un repositorio público; quieres matar esa clave pero no interrumpir su trabajo mientras migra a un reemplazo. Revocar con un graceUntilUtc corto deja que los clientes en línea sigan validando hasta esa marca de tiempo, y luego fallan cerrado —y mientras tanto le entregas al cliente una clave recién emitida. El compromiso es real: cada minuto de gracia es un minuto que la clave filtrada sigue funcionando para quien más la tenga. Reserva la gracia para situaciones de bajo riesgo y combínala con reemisión inmediata; por defecto, elige el bloqueo inmediato para cualquier cosa que huela a abuso.

La versión de un párrafo

La revocación es una decisión posterior a la emisión que una firma válida no puede expresar, así que los clientes deben enterarse preguntando. Revocas desde el panel o la admin API; en el servidor el estado de la licencia cambia a revoked y la clave se une a una denylist que la ruta de validación consulta. Los clientes en línea fallan cerrado en su siguiente ValidateAsync; los clientes sin conexión siguen funcionando solo hasta que expira el intervalo de revalidación, así que fija ese intervalo corto para claves de alto riesgo. En la app, haz que el camino de denegación sea el predeterminado y el desbloqueo la única excepción estrecha. Haz eso, y una clave filtrada es un incidente breve en lugar de un grifo abierto.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.