Ejecuta para siempre las versiones que pagaste
Una licencia perpetua con ventana de mantenimiento permite a un cliente ejecutar para siempre todas las versiones publicadas mientras sus actualizaciones estaban activas, pero no las versiones que publicas después de que caduquen. Aquí se explica cómo modelarlo en una única licencia Keyright firmada: una reclamación maintenance-through, la fecha de publicación de la compilación incrustada en tu ensamblado y la única comparación que nunca debe fallar en cerrado.
La mayoría de los modelos de licencia basados en el tiempo responden a una pregunta: ¿sigue siendo válida la licencia ahora mismo? Una suscripción caduca, la aplicación consulta el reloj y, pasada la fecha, falla en cerrado. Esa es la forma correcta para un alquiler. Es la forma equivocada para el modelo comercial más antiguo del software de escritorio: cómpralo una vez, poséelo para siempre, paga por separado para seguir recibiendo actualizaciones.
En ese modelo la licencia nunca caduca para ejecutar el producto. Lo que caduca es el derecho del cliente a nuevas compilaciones. Un cliente que compró la versión 2.0 con un año de mantenimiento puede ejecutar la 2.0 —y todas las versiones que publicaste durante ese año— por el resto del tiempo. Cuando llega la versión del año siguiente y su mantenimiento ha caducado, esa compilación simplemente aún no es suya. A esto se le llama a veces licencia de reserva perpetua (perpetual-fallback), y hacerlo bien depende de una comparación que, a diferencia de cualquier otra comprobación de caducidad que hayas escrito, no debe fallar en cerrado.
El contrato: perpetua para ejecutar, una ventana para actualizar
Separa los dos relojes en tu cabeza, porque todo el diseño se deriva de mantenerlos aparte:
- La vida de la licencia es para siempre. El
KindesPerpetual, elExpiryUtcesnull, yValidate()devuelveIsValid = truedurante el resto de la vida de la licencia. Nada aquí cuenta hacia atrás. - La ventana de mantenimiento es una fecha: llámala
maintenance_through. Dice: este cliente tiene derecho a cualquier compilación que hayas publicado en este día o antes. No es una caducidad. Nunca invalida la licencia. Solo responde si una compilación concreta está cubierta.
Como una licencia perpetua no tiene ExpiryUtc, no puedes colar la fecha de mantenimiento en el campo de caducidad sin convertir toda la licencia en una suscripción que falla en cerrado, lo que bloquearía al cliente del software que posee en el momento en que caduca el mantenimiento. La ventana de mantenimiento es su propia reclamación, deliberadamente mantenida fuera de la ruta de caducidad.
{
"sub": "acct_8f21c",
"tier": "pro",
"kind": "perpetual",
"iat": "2026-11-12T00:00:00Z",
"exp": null,
"claims": {
"maintenance_through": "2027-11-12"
}
}
Un único objeto firmado. exp es null, así que la licencia se ejecuta para siempre. maintenance_through es una fecha que el cliente puede ver en su recibo, y gobierna exactamente una cosa: qué compilaciones puede ejecutar.
Por qué una fecha, no un número de versión
El instinto ingenuo es estampar una versión máxima en la licencia: “con licencia hasta 2.x”. Resístelo. Las versiones semánticas son un grafo, no una línea. Podrías publicar 2.4.1 como un parche de seguridad para la rama antigua después de que 3.0 ya se haya publicado en la nueva. Ahora “¿está esta versión dentro del rango con licencia?” es una pregunta sobre topología de ramas, y cada respuesta que des es discutible.
Una fecha de publicación es un único eje monótono. Una compilación se publicó un día; el mantenimiento llegó hasta un día; uno es anterior o posterior al otro, sin empates que razonar. Así que la licencia lleva una fecha, y cada compilación lleva la fecha en que se publicó. Comparas dos números fijos.
Incrusta la fecha de publicación en la compilación
La compilación tiene que saber cuándo se publicó. Un atributo de ensamblado en tiempo de compilación es el lugar natural, pero establécelo desde la publicación —el momento en que tu canalización publica el artefacto— no desde el reloj que tuviera la máquina local durante una compilación de desarrollo. Pásalo desde CI como una propiedad de MSBuild:
<!-- ReleaseDate lo suministra la canalización de publicación:
dotnet build -p:ReleaseDate=2027-10-14 -->
<PropertyGroup>
<ReleaseDate Condition="'$(ReleaseDate)' == ''">1900-01-01</ReleaseDate>
</PropertyGroup>
<ItemGroup>
<AssemblyMetadata Include="ReleaseDate" Value="$(ReleaseDate)" />
</ItemGroup>
El valor por defecto 1900-01-01 es deliberado: una compilación que no fue producida por la canalización de publicación (el portátil de alguien) se lee como imposiblemente antigua y queda cubierta por cualquier licencia real, así que las compilaciones locales nunca activan la comprobación. Léelo de vuelta una vez al arrancar:
static class BuildInfo
{
public static DateOnly ReleaseDate { get; } =
typeof(BuildInfo).Assembly
.GetCustomAttributes<AssemblyMetadataAttribute>()
.Where(a => a.Key == "ReleaseDate")
.Select(a => DateOnly.ParseExact(a.Value!, "yyyy-MM-dd"))
.DefaultIfEmpty(new DateOnly(1900, 1, 1))
.First();
}
La única comparación que no debe fallar en cerrado
Cualquier otra comprobación de caducidad que hayas escrito lee “ahora” y rechaza el servicio pasada una fecha. Esta no toca el reloj en absoluto. Ambos operandos son fijos: la fecha de publicación de la compilación es una constante incrustada en el ensamblado, y la fecha de mantenimiento es una reclamación firmada que ya has verificado sin conexión. Estás haciendo una única pregunta: ¿se publicó esta compilación durante la ventana que pagó el cliente?
public enum MaintenanceStatus { Covered, OutsideWindow }
public MaintenanceStatus CheckMaintenance(LicenseInfo info)
{
// Validate() ya confirmó la firma y que esta es una licencia perpetua,
// válida y de pago. La única pregunta restante es qué COMPILACIONES cubre.
DateOnly? through = info.Claims.GetDate("maintenance_through");
// Sin reclamación de mantenimiento significa actualizaciones de por vida (p. ej.
// un tier que nunca limita versiones). La ausencia NO es caducidad: falla ABIERTO.
if (through is not { } cutoff)
return MaintenanceStatus.Covered;
return BuildInfo.ReleaseDate <= cutoff
? MaintenanceStatus.Covered // publicada en/antes del corte -> con licencia, para siempre
: MaintenanceStatus.OutsideWindow; // esta compilación es más nueva que la cobertura del cliente
}
Dos decisiones cargan con todo el modelo. Primero, una reclamación ausente falla en abierto: una licencia perpetua sin ventana de mantenimiento debe ejecutar cualquier cosa, porque la ausencia de una ventana no es una ventana caducada. Segundo, OutsideWindow no es un estado inválido: la licencia sigue siendo perfectamente válida y de pago; el cliente simplemente ha instalado una compilación más nueva que la que compró.
Fíjate en lo que no está en esa función: DateTimeOffset.UtcNow. Como ninguno de los operandos depende de la hora actual, esta comprobación es inmune al retroceso del reloj por construcción. Un cliente que retrasa su reloj cinco años no cambia nada: la compilación se publicó igualmente después de que se agotara su mantenimiento. Es un agradable contraste con la caducidad de una suscripción, donde “ahora” es exactamente el valor que un atacante quiere mover.
Conectarlo al arranque
Mantén las dos preocupaciones en el orden que exige el modelo: primero ¿tiene este cliente licencia en absoluto?, luego ¿está cubierta esta compilación?
var info = client.Validate(); // sin conexión, contra la clave pública incrustada
if (!info.IsValid || !info.IsPaid)
{
// No es un cliente de pago: la ruta ordinaria de fallo en cerrado.
RunAsCommunityEdition();
return;
}
switch (licensing.CheckMaintenance(info))
{
case MaintenanceStatus.Covered:
RunLicensed(info);
break;
case MaintenanceStatus.OutsideWindow:
// Válida, de pago, perpetua: POSEE el producto. Solo ha instalado
// una compilación publicada después de que caducaran sus actualizaciones.
ShowMaintenanceLapsedNotice(info.Claims.GetDate("maintenance_through"));
RunLicensed(info); // déjale seguir trabajando; ver abajo
break;
}
La rama OutsideWindow es donde los productos se equivocan. Fallar en cerrado a Community Edition ahí —despojando de funciones de pago porque el cliente instaló una actualización— convierte una mejora en una degradación y se lee, correctamente, como que el producto retiene como rehén el software del propio cliente. Las opciones honestas son más estrechas:
- Recomendado: deja que la aplicación se ejecute y muestra un aviso tranquilo y descartable: “La versión 2.1 se publicó después de que terminara tu mantenimiento el 12 de noviembre de 2027. Renueva para obtener las últimas actualizaciones, o continúa en la versión 2.0, que tu licencia cubre de forma permanente.” El cliente conserva todo lo que pagó.
- Más estricto, aún justo: rehúsa iniciar esta compilación y dirígele a la última versión cubierta (2.0), que puede descargar y ejecutar para siempre. Estás declinando ejecutar una compilación más nueva, no revocando la licencia.
Lo que nunca haces es bajar a un cliente perpetuo de pago a la Community Edition gratuita por una fecha que gobierna las actualizaciones, no la propiedad.
El flujo del administrador: renovar el mantenimiento
Renovar el mantenimiento no es un producto nuevo ni una clave de firma nueva: es la misma licencia perpetua con la ventana movida hacia adelante. En el servicio de emisión reemites para la misma cuenta con un maintenance_through posterior; sub, tier y kind no cambian:
keyright license reissue \
--account acct_8f21c \
--kind perpetual \
--maintenance-through 2028-11-12
El cliente recibe la licencia reemitida, la reactiva, y cada compilación que publiques hasta la nueva fecha queda cubierta. Nada de las instalaciones antiguas cambia: una máquina que aún ejecuta la 2.0 ya estaba cubierta y sigue cubierta. Como la fecha de mantenimiento viaja dentro del contenido firmado, la única forma de extender la cobertura es que se emita una nueva licencia; editar a mano la fecha en el archivo rompe la firma y toda la licencia falla la verificación, que es el comportamiento de fallo en cerrado que sí quieres.
Una conclusión práctica
La licencia de reserva perpetua es una reclamación y una comparación, pero la comparación corre al revés que cualquier otra comprobación de caducidad que poseas. Mantén la fecha de mantenimiento fuera de la ruta de ExpiryUtc para que la licencia nunca caduque al ejecutarse. Compara una fecha de publicación incrustada contra una fecha maintenance-through firmada, nunca una cadena de versión y nunca el reloj del sistema. Falla en abierto cuando la reclamación está ausente, y trata una compilación fuera de la ventana como “más nueva que tu cobertura” en vez de “sin licencia”. Hecho así, dejar que el mantenimiento caduque hace exactamente lo que el contrato le prometió al cliente cuando compró: conserva la ejecución de cada versión que pagó, durante todo el tiempo que quiera, y el día que quiera tu compilación más nueva, renovar es un cambio de fecha, no un nuevo trato.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.