Una credencial expiró mientras el emisor aún estaba activo.
Nada fue revocado.
Así que lo tiré de nuevo.
`validUntil`
Antes de lo que se había establecido.
Volví.
La misma atestación.
El mismo valor.
Así que verifiqué un nivel arriba.
Esquema.
`maxValidFor`
Menor.
Corrí otro.
El mismo esquema.
Atestador diferente.
Empujaron la ventana más lejos.
No apareció.
La credencial volvió más corta.
Sin revertir.
Sin advertencia.
Solo falta tiempo.
Pensé que podría ser inconsistente.
Así que seguí empujándolo.
Más atestaciones.
El mismo límite.
Cualquier cosa más allá de `maxValidFor` nunca aparece.
No rechazado.
No corregido.
Simplemente... desaparecido.
Ahí es cuando se trasladó.
El atestador no define la duración.
Lo proponen.
El esquema decide qué sobrevive.
Y nada te muestra lo que fue removido.
Solo ves el `validUntil` final.
No el que se intentó.
Así que desde el exterior...
todo parece correcto.
La credencial verifica.
Las marcas de tiempo se resuelven.
Pero parte de la duración nunca pasó.
Volví otra vez.
Comparado con lo que se presentó...
a lo que la credencial realmente mantenía.
Diferentes valores.
Misma atestación.
Sin rastro de la brecha.
Recorte silencioso.
Después de eso dejé de mirar credenciales individuales.
Y comenzó a mirar patrones.
Diferentes emisores.
Diferentes entradas.
Mismo techo.
La variación seguía desapareciendo.
Lo que debería haber sido diferentes ventanas...
colapsado en el mismo límite.
No importaba cuán lejos empujara el atestador.
El resultado seguía aterrizando en el mismo lugar.
Revisé otro esquema.
Mayor `maxValidFor`.
Mismo comportamiento.
Diferente límite.
M mismo patrón.
Ahí es cuando se volvió obvio.
La duración no se negocia.
Está filtrado.
El atestador sugiere un rango.
El esquema lo resuelve antes de que algo se vuelva visible.
Y una vez que se resuelve...
no hay registro de lo que se perdió.
Simplemente parece que siempre fue así.
Ahí es donde comienza a aparecer.
Un sistema que lee esa credencial asume la ventana más larga.
No lo entiende.
El acceso termina antes de lo esperado.
Sin señal.
Sin explicación.
Solo un límite anterior.
Otra capa lee `validUntil` como si estuviera completamente controlada por el atestador.
No lo fue.
El esquema ya decidió parte de ello.
El permiso se cierra en ese límite en su lugar.
Nada falla.
Simplemente termina.
Y cuando múltiples credenciales se apilan...
cada uno con diferentes ventanas previstas...
todos colapsan al mismo techo.
La variación desaparece antes de que algo se vuelva visible.
Desde el exterior parece diverso.
Debajo ya ha sido aplanado.
Ahí es donde comienza a sentirse diferente.
Porque nada falla.
Nada se rechaza.
Todo verifica.
Pero algo falta cada vez.
Y el sistema no lo reconoce.
$SIGN solo importa aquí si un sistema donde `maxValidFor` elimina silenciosamente parte de `validUntil` puede seguir sosteniéndose una vez que esas diferencias ocultas comienzan a acumularse a través de credenciales.
Porque una vez que ese patrón se acumula...
nada lo señala.
Nada lo reconcilia.
Nada lo corrige.
Simplemente desaparece.
Así que la verdadera pregunta se convierte en esto.
Cuando parte de la duración de una credencial nunca entra en el sistema...
¿qué exactamente está haciendo cumplir la red?
#SignDigitalSovereignInfra #Sign
