The Cache TTL That Keeps Trusting a Revoked Signer

The setting that causes this incident is usually one line in the verifier config, something like a max age of 72 hours on the trusted list cache, and every reviewer approves it because it looks conservative. The trouble is the reference point. That age is counted from when your fetcher last pulled the list, while the publisher has already signed its own expiry into the document. When the two disagree and the upstream endpoint goes dark, your verification service keeps answering "valid" from data its own issuer has declared expired.

Why review never catches it

Trusted lists and registry snapshots in the eIDAS ecosystem follow the ETSI family of trust list and signature formats, and each signed list carries a NextUpdate timestamp that marks where the issuer stops vouching for the content. A cache TTL anchored to fetch time ignores that field completely. Say you fetch a list six hours before its NextUpdate, then the national endpoint starts returning errors: a 72 hour TTL lets you serve that list for more than two and a half days past the point where its issuer stopped standing behind it. If a qualified trust service was withdrawn in the republication you never received, every seal and signature chained to it still passes. Code review can't see this, because the diff only shows a duration, and a duration with no reference point looks fine to anyone reading it.

The opposite reflex is just as bad

After the first postmortem, most teams flip to fail closed and purge the cache as soon as a fetch fails. That turns one member state's outage into a global one, because a verifier that holds the whole trust graph as a single unit drops every lookup when any one list goes missing. What keeps the system working when one part fails is isolation per registry: each list gets its own freshness state, its own breaker and its own verdict, so a dead endpoint in one jurisdiction leaves only the credentials anchored there in doubt. Those results should come back as indeterminate, never invalid, because invalid is a cryptographic claim and an expired cache doesn't support it. Downstream relying parties can then queue or retry, and nobody has to reject a valid seal.

A check you can run this afternoon

For every list in your verifier's cache directory, extract the issuer's expiry with xmllint in xpath mode using string(//*[local-name()='NextUpdate']/*[local-name()='dateTime']), convert it to epoch seconds with date, and alert on any list where the current time is past that value while your service still reports the list as healthy. If that alert fires even once, your staleness ceiling is anchored to the wrong clock. Run the same loop against what the service actually loaded into memory, not just the files on disk, because a hot-reload path that silently failed will show a fresh file next to a stale trust graph. In my experience, which is an estimate rather than a measurement, the gap between disk and memory explains a good share of the cases where the files looked fine but the incident happened anyway.

The decision rule to encode: cached registry data is acceptable only while the current time is before the issuer's NextUpdate plus a grace window of at most 6 hours, and once that window closes, that one registry fails closed to indeterminate while every other registry carries on with its own state.

Why allow any grace window at all instead of cutting off exactly at NextUpdate?

Publishers often republish late, and clock skew between their signing infrastructure and your fleet is real, so a hard cutoff at NextUpdate will produce indeterminate results during routine operation. The grace window absorbs that drift without letting you trust a list for days after it expired. The cost is a few hours in which a withdrawal you haven't received could still pass, and the tolerance for that has to be agreed with the relying parties, not chosen quietly in a config file.

Back to SourceDataVerification · Domains

← Back to SourceDataVerification
Engineering & Architecture Brief

The Cache TTL That Keeps Trusting a Revoked Signer

The setting that causes this incident is usually one line in the verifier config, something like a max age of 72 hours on the trusted list cache, and every reviewer approves it because it looks conservative. The trouble is the reference point. That age is counted from when your fetcher last pulled the list, while the publisher has already signed its own expiry into the document. When the two disagree and the upstream endpoint goes dark, your verification service keeps answering "valid" from data its own issuer has declared expired.

Why review never catches it

Trusted lists and registry snapshots in the eIDAS ecosystem follow the ETSI family of trust list and signature formats, and each signed list carries a NextUpdate timestamp that marks where the issuer stops vouching for the content. A cache TTL anchored to fetch time ignores that field completely. Say you fetch a list six hours before its NextUpdate, then the national endpoint starts returning errors: a 72 hour TTL lets you serve that list for more than two and a half days past the point where its issuer stopped standing behind it. If a qualified trust service was withdrawn in the republication you never received, every seal and signature chained to it still passes. Code review can't see this, because the diff only shows a duration, and a duration with no reference point looks fine to anyone reading it.

The opposite reflex is just as bad

After the first postmortem, most teams flip to fail closed and purge the cache as soon as a fetch fails. That turns one member state's outage into a global one, because a verifier that holds the whole trust graph as a single unit drops every lookup when any one list goes missing. What keeps the system working when one part fails is isolation per registry: each list gets its own freshness state, its own breaker and its own verdict, so a dead endpoint in one jurisdiction leaves only the credentials anchored there in doubt. Those results should come back as indeterminate, never invalid, because invalid is a cryptographic claim and an expired cache doesn't support it. Downstream relying parties can then queue or retry, and nobody has to reject a valid seal.

A check you can run this afternoon

For every list in your verifier's cache directory, extract the issuer's expiry with xmllint in xpath mode using string(//*[local-name()='NextUpdate']/*[local-name()='dateTime']), convert it to epoch seconds with date, and alert on any list where the current time is past that value while your service still reports the list as healthy. If that alert fires even once, your staleness ceiling is anchored to the wrong clock. Run the same loop against what the service actually loaded into memory, not just the files on disk, because a hot-reload path that silently failed will show a fresh file next to a stale trust graph. In my experience, which is an estimate rather than a measurement, the gap between disk and memory explains a good share of the cases where the files looked fine but the incident happened anyway.

The decision rule to encode: cached registry data is acceptable only while the current time is before the issuer's NextUpdate plus a grace window of at most 6 hours, and once that window closes, that one registry fails closed to indeterminate while every other registry carries on with its own state.

Technical FAQ: Why allow any grace window at all instead of cutting off exactly at NextUpdate?

Publishers often republish late, and clock skew between their signing infrastructure and your fleet is real, so a hard cutoff at NextUpdate will produce indeterminate results during routine operation. The grace window absorbs that drift without letting you trust a list for days after it expired. The cost is a few hours in which a withdrawal you haven't received could still pass, and the tolerance for that has to be agreed with the relying parties, not chosen quietly in a config file.

Related Architecture Specifications (EIDASTRUST): complianceservers.com · eudiready.com · ap2cluster.com

More Technical Articles on sourcedataverification.com

Sparse Merkle Trees for National Registry State Attestation: Throughput Benchmarks →Optimizing Database-to-Crypto Ingestion Pipelines for Real-Time Credential Issuance →