PKI Workshop
Learn PKI fundamentals, build certificate chains hands-on, and explore PQC migration.Learning sandbox — private keys are stored in your browser and should not be used in production.
Why this matters: PKI is the trust infrastructure everything else in this curriculum assumes exists — certificate chains, revocation, and CA hierarchies are what make 'this key belongs to this identity' a claim anyone can verify.
Start here: Pick a private key source and a CSR profile, fill in the subject attributes, then press Generate CSR: the console shows the OpenSSL run and the resulting PEM request.
For your role
- Developer / Engineer
- Create a CSR, generate a root CA, sign the CSR, inspect the certificate and issue a CRL, then compare with Merkle Tree Certificates and walk the RFC 8555 ACME issuance with an ML-DSA key.
- Security Architect
- The chain comparison with Merkle Tree Certificates and the storage, bandwidth and CPU model for migrating a PKI to PQC are the two design inputs after the five-step basics.
- Researcher / Academic
- The ACME (RFC 8555) issuance flow with a real ML-DSA key and the PKI migration cost model are the parts to reproduce; the session artifacts panel keeps what each step produced.
- IT Ops / DevOps
- Issue, inspect and revoke in the first five steps, then model storage, bandwidth and CPU for your PKI under PQC: the certificate operations you run, with their new sizes.
What is PKI?
(PKI) is a framework of policies, hardware, software, and procedures for creating, managing, distributing, and revoking digital certificates. Defined by ITU-T and profiled for the internet in RFC 5280, PKI enables entities to establish trust through a hierarchy of (CAs) that vouch for the binding between a public key and an identity.
- Certificate Authorities (CAs)
- Registration Authorities (RAs)
- End Entities (subscribers)
- Hierarchical (Root → Intermediate → EE)
- Bridge CA (cross-certification)
- Web of Trust (PGP model)
- X.509v3 certificates (RFC 5280)
- PKCS#10 format (RFC 2986)
- CMP enrollment (RFC 9810, obsoletes RFC 4210)
The Certificate Lifecycle
Every X.509 certificate follows a defined lifecycle from key generation through revocation. RFC 5280 Section 3 describes the certificate path processing model, while RFC 6960 () and RFC 5280 Section 5 (s) define the revocation checking mechanisms that relying parties use to verify certificate validity in real time.
X.509 Certificate Structure
An X.509v3 certificate (RFC 5280 Section 4.1) contains three main parts: the TBSCertificate (to-be-signed data), the signature algorithm identifier, and the digital signature value. The TBSCertificate holds all the fields that get signed by the CA:
Digital Signatures in PKI
Certificate issuance and verification rely on as defined in RFC 5280 Section 4.1.1.2. The CA signs the TBSCertificate using its private key, and any relying party can verify the signature using the CA's public key from a trusted root store.
- Construct TBSCertificate (subject, key, extensions)
- Hash the TBSCertificate (SHA-256, SHA-384, etc.)
- Sign hash with CA private key
- Append signature algorithm OID + signature value
- Extract signature from certificate
- Hash the TBSCertificate independently
- Verify signature against CA public key
- Check validity period, extensions, revocation
Classical vs PQC Algorithms in PKI
Traditional PKI relies on and signatures, both vulnerable to on a cryptographically relevant quantum computer. NIST has standardized post-quantum replacements: (FIPS 204) for signatures and (FIPS 205) for stateless hash-based signatures.
Proven, widely deployed. Small signatures (256-512 bytes). Vulnerable to quantum computers running Shor's algorithm.
Quantum-resistant. ML-DSA-65 signatures ~3,309 bytes, SLH-DSA-SHA2-128s ~7,856 bytes (FIPS 204, FIPS 205). Larger but quantum-safe.
Combine classical + PQC in one certificate for backward compatibility. Protects against both classical and quantum attacks during transition.
PQC Migration for PKI
Root CA certificates can have lifetimes of 20+ years. While data encryption is vulnerable to "" attacks, long-lived CAs are vulnerable to "forge later" attacks, where a cryptographically relevant quantum computer could forge signatures and issue rogue certificates. recommends beginning the transition to post-quantum algorithms immediately, with (NSA) requiring exclusive PQC use in national security systems by 2033 for large PKI systems (2030 for software/firmware signing and networking equipment).
Key migration challenges include certificate size growth (ML-DSA-87 public keys are ~2,592 bytes vs ~91 bytes (SPKI) for ECDSA P-256), constrained device support, and maintaining cross-signed trust chains during the transition period. NIST SP 800-131A Rev 2 provides guidance on algorithm deprecation timelines.
Merkle Tree Certificates: Solving PQC Certificate Bloat
Post-quantum signatures are dramatically larger than their classical counterparts: signatures are 2,420 bytes compared to just 64 bytes for ECDSA P-256 — a 37× increase. A typical TLS certificate chain with three PQ signatures, public keys, and Certificate Transparency SCTs can add 18–36 KB to every handshake, breaking constrained clients and degrading performance.
Merkle Tree Certificates (MTCs), proposed in IETF draft-davidben-tls-merkle-tree-certs by Google and Cloudflare, offer an elegant solution: instead of signing each certificate individually, a Merkle Tree CA (MTCA) batches thousands of certificates as leaves in a , signs only the root hash, and distributes compact inclusion proofs (~736 bytes) that let any relying party verify a certificate belongs to the signed batch. This replaces three separate PQ signatures with a single root signature plus a hash-based proof.
- 3 ML-DSA-44 signatures — 3 × 2,420 B = 7,260 B
- 3 public keys — 3 × 1,312 B = 3,936 B
- 4 CT SCTs: 476 B
- Total: 7,260 + 3,936 + 476 B, which gives 11,672 B (~11.7 KB) per handshake
- 1 root signature: 2,420 B
- 1 root public key: 1,312 B
- Inclusion proof: 736 B
- Total: ~4.5 KB per handshake
Tradeoff: MTC clients must periodically fetch transparency service updates (similar to CRLite). This trades per-handshake size for background data synchronization — a favorable tradeoff for high-traffic servers and constrained IoT devices.
Related Resources
Check off all sections and mark this reading done.
Related modules
In the Industry Landscape
- Cross-IndustryEnterprise PKI & X.509 certificates
- IT Industry / SoftwareWeb PKI & certificate authorities
- Aerospace / AviationBy protocol · Avionics & flight-system authentication
- Automotive / Connected VehiclesBy protocol · V2X message signing (IEEE 1609.2)
- Critical Infrastructure / EnergyBy protocol · Smart metering / AMI PKI
- Education / ResearchBy protocol · Identity federation (SAML/eduroam)
- Finance & BankingBy protocol · Interbank payments & settlement (SWIFT/RTGS)
- Government & DefenseBy protocol · Federal PKI & document signing
- Healthcare / PharmaceuticalBy protocol · Medical-device firmware & authentication · Pharma supply chain (DSCSA/EPCIS)
- Internet of Things (IoT)By protocol · Device identity & provisioning
- Legal / Notary / eSignatureBy protocol · Qualified e-signatures (AdES) · EU digital identity wallets (eIDAS 2.0) · Qualified timestamping (RFC 3161)
- Rail / TransitBy protocol · Train control key management (ETCS) · Positive Train Control PKI
- Supply Chain / LogisticsBy protocol · Port & vessel identity systems · Electronic bills of lading & trade docs · Customs declarations & single windows
- TelecommunicationsBy protocol · Network function & gNB certificates
- Water / WastewaterBy protocol · Water metering & sensor networks
Next step
Practice it: PKI WorkshopPKI Workshop is the hands-on version of this module: the same ideas, run in your browser.
Learning module content can be inaccurate. Please double-check its information. Report inaccuracies in PQC Today GitHub Discussions.