Una credenziale è scaduta mentre l'emittente era ancora attivo.
Niente è stato revocato.
Quindi l'ho tirato di nuovo.
`validUntil`
Prima di quanto fosse stato impostato.
Sono tornato indietro.
Stessa attestazione.
Stesso valore.
Quindi ho controllato un livello sopra.
Schema.
`maxValidFor`
Inferiore.
Ne ho fatto un altro.
Stessa schema.
Attestatore diverso.
Hanno spostato ulteriormente la finestra.
Non è apparso.
La credenziale è tornata più corta.
Nessun ripristino.
Nessun avviso.
Manca solo tempo.
Pensavo potesse essere incoerente.
Quindi ho continuato a spingere.
Più attestazioni.
Stessa frontiera.
Qualsiasi cosa oltre `maxValidFor` non appare mai.
Non rifiutato.
Non corretto.
Solo... sparito.
È allora che è cambiato.
L'attestatore non definisce la durata.
Lo propongono.
Lo schema decide cosa sopravvive.
E niente ti mostra cosa è stato rimosso.
Vedi solo il finale `validUntil`.
Non quella che è stata tentata.
Quindi dall'esterno...
tutto sembra corretto.
La credenziale verifica.
Gli orari si risolvono.
Ma parte della durata non è mai passata.
Sono tornato di nuovo.
Rispetto a quanto è stato presentato...
a cosa teneva effettivamente la credenziale.
Valori diversi.
Stessa attestazione.
Nessuna traccia del divario.
Taglio silenzioso.
Dopo di ciò ho smesso di guardare le credenziali individuali.
E ha iniziato a guardare i modelli.
Diversi emittenti.
Input diversi.
Stesso soffitto.
La variazione continuava a scomparire.
Cosa avrebbe dovuto essere finestre diverse...
collassato nello stesso confine.
Non importava quanto lontano l'attestatore lo spingesse.
Il risultato continuava a ricadere nello stesso posto.
Ho controllato un altro schema.
Maggiore `maxValidFor`.
Stessa comportamento.
Confine diverso.
Stesso modello.
È allora che è diventato ovvio.
La durata non è negoziata.
È filtrato.
L'attestatore suggerisce un intervallo.
Lo schema lo risolve prima che qualcosa diventi visibile.
E una volta che si risolve...
non c'è traccia di ciò che è stato perso.
Sembra solo che sia sempre stato così.
È lì che inizia a mostrarsi.
Un sistema che legge quella credenziale presuppone la finestra più lunga.
Non lo capisce.
L'accesso termina prima del previsto.
Nessun segnale.
Nessuna spiegazione.
Solo un confine precedente.
Un altro livello legge `validUntil` come se fosse completamente controllato dall'attestatore.
Non lo era.
Lo schema ha già deciso parte di esso.
Il permesso si chiude su quel confine invece.
Niente fallisce.
Finisce e basta.
E quando più credenziali si accumulano...
ognuno con finestre intese diverse...
si collassano tutti nello stesso soffitto.
La variazione scompare prima che qualcosa diventi visibile.
Dall'esterno sembra vario.
Sotto è già stata appiattita.
È lì che inizia a sentirsi diverso.
Perché niente fallisce.
Niente viene rifiutato.
Tutto verifica.
Ma qualcosa manca ogni volta.
E il sistema non lo riconosce.
$SIGN ha importanza qui solo se un sistema in cui `maxValidFor` rimuove silenziosamente parte di `validUntil` può ancora reggere una volta che quelle differenze nascoste iniziano ad accumularsi attraverso le credenziali.
Perché una volta che quel modello si accumula...
niente lo segnala.
Niente lo riconcilia.
Niente lo corregge.
Semplicemente scompare.
Quindi la vera domanda diventa questa.
Quando parte della durata di una credenziale non entra mai nel sistema...
cosa esattamente la rete sta effettivamente applicando?
#SignDigitalSovereignInfra #Sign
