A smart certificate binds an identity to a public key, but its private key never leaves the hardware secure element (TPM / smart-card / HSM) that generated it — the element only performs sign(challenge) on request, so cloning the disk never yields a usable key. That makes the hard problem revocation: once a key or its owner is compromised, how fast does the rest of the world find out?
CRL: next_check = ceil(now / T_refresh) * T_refresh
detection_latency ≈ T_refresh − (t_revoke mod T_refresh)
OCSP live: responder is authoritative in real time
detection_latency ≈ RTT_client_to_responder
Stapling: server refreshes its cached OCSP response every T_refresh
detection_latency ≈ T_refresh − (t_revoke mod T_refresh)
but costs the client 0 extra round-trips (no live query)
- CRL (Certificate Revocation List) — the client periodically downloads the CA's entire revoked-serial list. Simple and private (no per-visit signal to the CA), but freshness is capped by the publish interval — a compromised cert stays trusted until the next scheduled list.
- OCSP (live) — the client asks the CA's responder about this one certificate on every connection. Near-real-time detection, but the responder now learns exactly which site the client is visiting on every handshake — a privacy leak this sim counts as "Client→OCSP queries".
- OCSP Stapling — the server periodically fetches a signed, timestamped OCSP response and staples it directly into the TLS handshake. The client gets a live-ish answer with zero extra round-trips and zero exposure to the responder — the best of both, which is why modern TLS defaults to it.
- Revoke Certificate Now — simulates a key-compromise event at the current sim clock; watch how long each method takes for the client's next handshake to actually read "Revoked".
Real-world relevance: this is the exact trust model behind browser HTTPS, corporate smart-card login, and code-signing — the chain Root CA → Intermediate CA → Leaf certificate is verified on every connection, and the choice of revocation channel is a live security/latency/privacy trade-off engineers still argue about.