Skip to content
← Todas las publicaciones
· Delta1 Labs LicensingKeyright

Licencia todas las versiones desde un solo par de claves

Rotar las claves de firma en cada versión mayor es la trampa: rompe las compilaciones antiguas, obliga a una migración masiva y no te da ningún control por cliente. El modelo mejor mantiene un solo par de claves durante toda la vida del producto y lleva lo que una licencia puede hacer —qué versiones ejecuta, qué funciones desbloquea, cuánto puede usar— en derechos firmados. Este artículo muestra los tres patrones con código real, cómo las concesiones permanecen a prueba de manipulaciones con y sin conexión, y cuándo recurrir a la cobertura de versiones completa.

Hay un atajo tentador cuando publicas una nueva versión mayor de un producto de pago: emitir las licencias de la nueva versión con un nuevo par de claves de firma, embeber la nueva clave pública en la nueva compilación y dejar que las claves antiguas dejen de verificar. Parece un corte limpio. Es una trampa.

Un par de claves ligado a una versión rompe todo lo anterior: una compilación 3.x no puede verificar una licencia firmada con la clave 4.x, y viceversa. Te ves obligado a reemitir y migrar a todos los clientes de pago a la vez, según tu calendario, no el suyo. Y no obtienes ninguna granularidad: no puedes dejar que la licencia de un cliente cubra tanto 3.x como 4.x, porque la clave es de todo o nada. El par de claves es el lugar equivocado para codificar una decisión comercial.

El modelo: un par de claves, durante toda la vida del producto

Mantén un solo par de claves de firma para el producto, para siempre. La clave pública embebida en tu aplicación nunca se mueve: publicar la 4.0 no la toca. Lleva lo que una licencia puede hacer en derechos: concesiones firmadas de tipo nombre → valor que viajan dentro de la licencia y se verifican contra la clave que ya tienes embebida.

Cambia lo que un cliente puede ejecutar, desbloquear o usar reemitiendo su clave, nunca rotando claves y enviando una nueva clave pública.

Un derecho se entrega de dos formas que tu aplicación ya verifica: dentro del archivo de licencia sin conexión y dentro del arrendamiento de activación en línea de corta duración. Ambos están firmados con RSA y se comprueban contra tu clave pública embebida, así que un cliente no puede añadir una concesión, cambiar un flag ni subir un número: editar cualquier parte rompe la firma y el SDK rechaza el artefacto completo. Como cada SDK (.NET, Node, Python, Java) y el formato HTTP en bruto verifican el mismo payload firmado, las mismas concesiones se leen igual en una línea de producto multilenguaje desde una sola clave pública.

Un par de claves clave pública embebida verifica App v3.x misma clave — las compilaciones viejas siguen App v4.x sin nueva clave para una versión mayor Compilación aislada lee concesiones sin conexión, sin red max_major_version qué versiones se ejecutan feature.pdf_export qué funciones se desbloquean max_projects cuánto se puede usar derechos firmados
Un par de claves verifica cada compilación. Tres derechos firmados deciden qué puede hacer cada licencia.

Caso 1 — control de versiones, sin rotar claves

Tu aplicación conoce su propia versión mayor. La licencia lleva la versión mayor más alta que cubre. Ejecútala solo igual o por debajo de ese techo:

const int runningMajor = 4;                                   // this build's major version
var raw = info.Entitlements.GetRaw("max_major_version");       // e.g. "3" or "4" (a name you choose)
int ceiling = int.TryParse(raw, out var m) ? m : 3;           // absent => your pre-coverage default
if (runningMajor > ceiling)
    ShowUpgradeRequired($"Your license covers up to v{ceiling}.x.");

Una licencia vendida para la línea 3.x lleva max_major_version: "3" —o nada, si es anterior al esquema, en cuyo caso tu código trata «ausente» como la última versión mayor antes de añadir la regla. Publica la 4.0 y rechaza esa clave localmente, contra la clave pública que ya está en la aplicación. Un cliente que compra la actualización a 4.0 obtiene su clave reemitida con "4". Un techo más alto sigue ejecutándose en compilaciones antiguas, así que una licencia 4.x sigue funcionando en 3.x. Ninguna clave se movió; ninguna compilación envió una nueva clave pública.

Caso 2 — desbloquear una función

Una concesión booleana: activada o desactivada. El accesor trata true, 1, yes o enabled como activados:

if (info.Entitlements.IsEnabled("feature.pdf_export"))
    EnablePdfExport();

Este es el desbloqueo por edición: «Exportar», «SSO», «informes avanzados» se activan desde la licencia del cliente, verificados sin conexión, y cambias quién recibe qué reemitiendo, sin nueva compilación. (Los feature flags operativos de un despliegue que tú controlas se superponen dentro de lo que el derecho ya permite; el derecho es siempre la barrera dura.)

Caso 3 — forzar una cuota numérica

Un número por el que el cliente pagó: asientos, proyectos, llamadas a la API, dispositivos. La lectura del límite trata "unlimited" como efectivamente infinito, y el valor de reserva es lo que recibe un valor ausente (fallo cerrado):

long maxProjects = info.Entitlements.GetLimit("max_projects", fallback: 3);
if (currentProjectCount >= maxProjects)
    throw new QuotaExceeded($"Your plan allows {maxProjects} projects.");

Subir el límite de un cliente es una reemisión de clave con un nuevo max_projects. Sin compilación, sin cambio de clave, y surte efecto en su próxima renovación de arrendamiento o próxima licencia sin conexión.

Establecer las concesiones

Adjunta los derechos cuando emites o actualizas una clave —desde el panel o la API de administración:

curl -X POST "https://keyright.example.com/admin/licenses" \
  -H "X-Admin-Token: $KEYRIGHT_ADMIN_TOKEN" -H "Content-Type: application/json" \
  -d '{ "licensee": "Acme Ltd", "product": "your-product", "tier": "pro",
        "entitlements": { "max_major_version": "3", "feature.pdf_export": "true", "max_projects": "10" } }'

Mejor aún, pon los valores por defecto en la plantilla de edición/nivel para que cada clave emitida bajo ella los herede. Así funciona lo «automático en adelante»: establece max_major_version en tu edición actual hoy, y cuando publiques la próxima versión mayor, sube la plantilla (o añade una nueva edición). Cada clave acuñada después lleva el nuevo techo; cada clave que ya está en el campo conserva aquello con lo que se emitió, y sigue funcionando.

Cuándo recurrir a la cobertura de versiones

Un derecho sencillo max_major_version responde «qué versiones puede ejecutar esta licencia» a la granularidad de una versión mayor. Si vendes por fecha de lanzamiento, ventanas de mantenimiento o rangos de versión exactos —«cada versión 2.x», «cualquier cosa publicada en el año posterior a la compra», «lo que se publique mientras la suscripción esté activa»— usa la cobertura de versiones de primera clase de Keyright, que registra y firma el conjunto completo de cobertura y responde la elegibilidad para cualquier compilación concreta. El derecho es la versión ligera, con granularidad de versión mayor, de la misma idea; la cobertura de versiones es la precisa.

La conclusión

Tu par de claves de firma identifica tu producto, no una versión de él. Mantenlo estable durante toda la vida del producto y deja que los derechos firmados lleven las decisiones comerciales: qué versiones ejecuta una licencia, qué funciones desbloquea, cuánto puede usar. Cambias lo que un cliente puede hacer reemitiendo su clave contra la clave que ya envías, y las compilaciones antiguas nunca se rompen porque la clave pública nunca se movió.

Prueba Nebula.NET

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