Recuperación elegante de licencia en una app de escritorio
Cuando una licencia caduca, se revoca o el servicio deja de estar accesible por un momento, una app de escritorio no debe reaccionar igual ante los tres casos. Esta guía construye la máquina de estados que deriva la interfaz a partir del resultado de verificación, una política de gracia y el reloj, para que un cliente de pago con una red inestable nunca vea la pantalla de bloqueo pensada para una clave revocada.
Una app de escritorio tiene exactamente una tarea cuando una licencia deja de ser válida: averiguar por qué, y reaccionar en proporción. El fallo que se publica una y otra vez es un único if (!license.IsValid) ShowLockout() que trata una prueba caducada, una clave revocada, un archivo corrupto y un corte de red de dos segundos como el mismo evento. El cliente cuya VPN se cayó un instante recibe la misma pantalla roja que el cliente cuya clave se retiró por impago, y el primero abre un ticket de soporte que dice “tu software me bloqueó sin motivo”.
Idea clave: La UX de recuperación es una función pura de tres entradas —el resultado de verificación, tu política de gracia y el reloj— asignadas a un pequeño conjunto de estados, cada uno con su propia presentación y su propia acción de recuperación. Construye esa asignación como un único reductor, mantén el fallo transitorio estrictamente separado de un veredicto negativo autoritativo, y la pantalla correcta sale sola.
La pregunta real: ¿de cuántas formas puede significar algo “no válido”?
“No válido” no es un solo estado. Un intento de verificación puede aterrizar en al menos seis lugares materialmente distintos, y cada uno implica algo diferente que decir y un botón diferente que ofrecer:
public enum LicenseState
{
Valid, // verified, inside its term
Grace, // tolerated: lapsed-but-recent, or service briefly unreachable
Expired, // past term and past grace; no current entitlement
Revoked, // an authoritative server verdict: this key is dead
Tampered, // signature or clock integrity failed locally
Missing // no key installed yet
}
El corte importante va entre los estados de los que el usuario puede recuperarse y los que no. Expired y Missing los arregla la persona frente al teclado: renovar, o pegar una clave. Revoked y Tampered no; la única acción honesta es una vía hacia soporte. Grace es especial: no hay nada mal sobre lo que el usuario deba actuar, así que la app sigue funcionando y se sana sola. Colapsar todo esto en una sola rama es lo que produce el error de bloqueo-por-un-parpadeo.
El mecanismo: un reductor del resultado a la vista
Una sola llamada de verificación devuelve un resultado, no un booleano. Modélalo, y modela los dos modos de fallo —un veredicto (el servidor o la firma dijeron no) frente a un fallo de transporte (no pudimos preguntar)— como casos distintos, porque no deben fusionarse.
public abstract record VerifyOutcome
{
public sealed record Ok(LicenseClaims Claims) : VerifyOutcome;
public sealed record Negative(DenyReason Reason) : VerifyOutcome; // signed verdict
public sealed record Unreachable(Exception Cause) : VerifyOutcome; // transport only
}
public enum DenyReason { Expired, Revoked, BadSignature, ClockRollback, NotFound }
Ahora toda la política de recuperación es una función pura. Toma el resultado, cuánto tiempo llevamos sin poder contactar el servicio, el presupuesto de gracia y el reloj, y devuelve el estado más todo lo que la interfaz necesita para renderizarlo. Sin E/S, sin temporizadores, trivialmente verificable con pruebas unitarias.
public static LicenseView Reduce(
VerifyOutcome outcome,
TimeSpan sinceLastGoodCheck,
GracePolicy policy,
DateTimeOffset now) => outcome switch
{
VerifyOutcome.Ok ok when ok.Claims.NotAfter > now
=> LicenseView.Active(ok.Claims),
// Term elapsed, but still inside the post-expiry grace budget.
VerifyOutcome.Ok ok when now - ok.Claims.NotAfter <= policy.PostExpiry
=> LicenseView.InGrace(ok.Claims, expiresIn: policy.PostExpiry - (now - ok.Claims.NotAfter)),
// We simply could not reach the service: never a lockout while we have grace left.
VerifyOutcome.Unreachable when sinceLastGoodCheck <= policy.Offline
=> LicenseView.InGrace(reason: "Reconnecting…", expiresIn: policy.Offline - sinceLastGoodCheck),
VerifyOutcome.Unreachable
=> LicenseView.Expired(recoverable: true, message: "Offline too long — reconnect to continue."),
// Authoritative negatives. Each gets its own screen and its own action.
VerifyOutcome.Negative n => n.Reason switch
{
DenyReason.Expired => LicenseView.Expired(recoverable: true),
DenyReason.NotFound => LicenseView.Missing(),
DenyReason.Revoked => LicenseView.Blocked(DenyReason.Revoked), // no self-service fix
DenyReason.BadSignature => LicenseView.Blocked(DenyReason.BadSignature),
DenyReason.ClockRollback=> LicenseView.Blocked(DenyReason.ClockRollback),
_ => LicenseView.Blocked(n.Reason),
},
_ => LicenseView.Blocked(DenyReason.NotFound),
};
Observa el orden de los casos: un resultado Unreachable nunca puede caer hasta un bloqueo duro mientras quede gracia offline. La única manera de llegar a Blocked es un Negative —un veredicto firmado e inequívoco— o una señal de manipulación. Esa única regla de ordenación es toda la defensa contra bloquear a buenos clientes en una red mala.
Unreachable permanecen en Grace y sanan; solo un veredicto negativo firmado cruza a los estados de bloqueo duro de la derecha.Conectarlo a un view-model que se sana solo
El reductor es puro, así que el view-model a su alrededor es delgado: reejecuta la verificación con una cadencia, pasa el resultado por Reduce y publica el LicenseView resultante. La interfaz se enlaza a una sola propiedad y nunca contiene un if de licencias propio.
public sealed class LicenseStatusViewModel : INotifyPropertyChanged
{
private LicenseView _view = LicenseView.Checking();
public LicenseView View { get => _view; private set { _view = value; OnChanged(); } }
public async Task RefreshAsync(CancellationToken ct)
{
VerifyOutcome outcome = await _license.VerifyAsync(ct); // local Ed25519 + optional revalidation
if (outcome is VerifyOutcome.Ok ok)
_clockGuard.RecordTrustedTime(ok.Claims.IssuedAt); // advance the high-water mark
View = Reduce(outcome, _clockGuard.SinceLastGood, _policy, DateTimeOffset.UtcNow);
// Heal automatically: while in Grace, keep retrying on a short backoff.
if (View.State == LicenseState.Grace)
_retry.Schedule(() => _ = RefreshAsync(ct));
}
}
_clockGuard es lo que detiene el truco de atrasar el reloj. Persiste la marca de tiempo más alta jamás verificada, y si el reloj local lee una anterior a esa por más de la tolerancia de desfase, VerifyAsync devuelve Negative(ClockRollback), que el reductor encamina directo a Blocked. Para saber cómo dimensionar esa tolerancia frente a cambios legítimos de horario de verano y zonas horarias, consulta el artículo de Keyright sobre clock-skew y tolerancia de NotBefore.
Las acciones de recuperación: una por estado, nada más
Cada estado distinto de Valid expone exactamente una acción primaria, y la acción corresponde a quien realmente puede arreglarlo:
- Grace — ningún botón. Una franja discreta y no modal (“Trabajando sin conexión — reconectando…”). La app se sana sin que el usuario haga nada.
- Expired — un aviso de “Renovar” no bloqueante que abre el flujo de compra o renovación, y un campo de “Introducir una clave nueva”. La app sigue abierta; donde tenga sentido, degrada a solo lectura o a la superficie gratuita de Community Edition en lugar de apagarse.
- Missing — la pantalla de activación de primer arranque: pega una clave, pulsa verificar,
RefreshAsyncreejecuta. - Revoked / Tampered — estos son los únicos estados que justifican una parada dura. Muestra por qué en lenguaje claro y una única vía de “Contactar soporte”. No hay campo de autoservicio, porque el usuario genuinamente no puede arreglar una clave revocada él mismo; orientarlo a soporte es lo honesto. La búsqueda que ejecuta tu equipo de soporte es el flujo de por-qué-está-bloqueado.
Fíjate en que no hay botón de reintentar en los estados de bloqueo duro. Reverificar una clave revocada solo devuelve el mismo Negative(Revoked); ofrecer “Reintentar” entrena al usuario a aporrearlo y abrir un ticket de todos modos.
Advertencias: dónde duele
El presupuesto de gracia es un compromiso, no un parámetro gratis. Demasiado generoso y un cliente genuinamente caducado funciona durante semanas; demasiado ajustado y un portátil que duerme un fin de semana saluda al usuario con un bloqueo el lunes. Dimensiona policy.Offline frente a tu patrón de uso real; el artículo sobre la ventana de gracia ante cortes transitorios cubre las cuentas.
Degradar a solo lectura es una decisión de producto, no de licencias. El reductor puede decirte que una licencia está Expired; no puede decirte qué funciones es seguro dejar activas. Esa asignación vive en tu capa de permisos, y equivocarla —dejar una exportación de pago activa tras la caducidad— deshace todo el propósito.
El reductor solo es tan honesto como VerifyAsync. Si la verificación se traga un fallo de firma y devuelve Unreachable, una clave manipulada se esconde en el estado de gracia para siempre. Las comprobaciones de firma y reloj son locales y deben fallar hacia Negative, nunca hacia un fallo de transporte. Mantén esa frontera nítida.
Una revalidación en segundo plano nunca debe interrumpir el trabajo. Ejecuta RefreshAsync fuera del hilo de interfaz y deja que el estado cambie el marco —una franja, un elemento de menú deshabilitado— en lugar de lanzar un modal sobre lo que el usuario esté escribiendo.
Conclusión
Trata la recuperación como una asignación pura, no como una dispersión de sentencias if. Modela el resultado de verificación como Ok / Negative / Unreachable, mantén el fallo de transporte estrictamente fuera de la vía de bloqueo, y redúcelo todo a uno de seis estados, cada uno con una presentación y una única acción que corresponde a quien puede arreglarlo. Haz eso y el cliente de red inestable se sana en silencio en Grace mientras la clave revocada recibe la parada que merece, y ninguno ve jamás la pantalla del otro. La Community Edition de Keyright es un buen destino de degradación para apps de escritorio caducadas; la receta completa de recuperación y permisos está en la documentación de Keyright.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.