PKI Architecture and Certificate Trust Chains

October 2, 2025

When you browse the web, the padlock in the address bar, HTTPS, code signing, email encryption—all of them rely on the same mechanism: Public Key Infrastructure (PKI).

I worked in the CA industry for many years. This post is both a personal summary and a beginner-friendly explainer. It first sketches the basic structure of PKI, then shows how certificates turn "a party you don't know" into "trust you can verify".

The Core Problem: How Do You Trust a Public Key?

Asymmetric cryptography by itself only settles "whoever holds the private key can decrypt or sign". It does not answer: who does this public key actually belong to?

If an attacker impersonates the target with their own key pair, it doesn't matter how "correct" the public key you received is. What PKI solves is establishing trust in the ownership of public keys on an open network.

Basic Roles in PKI

A typical PKI can be viewed as a collaborative system of "issuing, using, and verifying" certificates. Let's break it down by role.

CA (Certificate Authority)

The CA is the trust core of the whole system. After vetting the applicant's identity, it signs the certificate contents with its own private key, thereby declaring "this public key belongs to such-and-such subject".

In practice, CAs are usually layered:

  • Root CA: Its private key is kept offline and it rarely issues end-entity certificates directly. Its certificate is preinstalled in the operating system's or browser's Root Store and is the starting point of trust.
  • Intermediate CA: Issued by the root (or a higher intermediate), it handles day-to-day issuance of server certificates, client certificates, and so on. A leaked root private key would have an enormous blast radius, so the intermediate layer isolates that risk.

The reason you trust a website is, fundamentally, that you trust the set of roots in your local Root Store and the entire chain they issue downward.

RA (Registration Authority)

The RA is not a component that must exist separately, but it is common in large-scale CAs. It handles the certificate application front end, identity verification, and document collection, then passes "approved" requests to the CA for issuance.

Think of it as the CA's "front desk + reviewer": the CA focuses on keys and issuance, the RA on business intake. In small or private CAs, both steps are often done in the same system.

Certificate Holder (Subscriber)

The holder generates a key pair (or has it managed by an HSM or similar) and submits the public key to the CA/RA to apply for a certificate. After issuance, the private key always stays with the holder, while the certificate is presented to others.

Common holders include:

  • Web servers (TLS server certificates)
  • Individuals / devices (client certificates, email signing and encryption)
  • Software publishers (code signing certificates)

A certificate only proves "the binding between a public key and an identity". What actually proves "I am the owner of this certificate" is a signature or handshake that involves the private key.

Relying Party

The relying party is the one who actually decides "whether to trust this certificate": browsers, operating systems, API clients, email clients, and so on.

Its job is roughly: obtain the peer's certificate chain → verify signatures and the path → check validity period / usage / domain name → check revocation status → decide whether to establish trust. Relying parties don't issue certificates, but they decide whether trust takes effect. A misconfigured Root Store or lax validation logic directly weakens PKI's security.

Revocation and Status Services (CRL / OCSP)

Certificates have a validity period, but they may need to be invalidated before it ends (private key leaked, domain changed hands, employee left, and so on). A mechanism is needed to tell relying parties: "stop trusting this certificate."

  • CRL (Certificate Revocation List): A revocation list published periodically by the CA; relying parties download it and check locally.
  • OCSP (Online Certificate Status Protocol): Queries a certificate's status in real time, with finer granularity. Optimizations such as OCSP Stapling reduce dependence on the OCSP service.

Without a reliable revocation channel, a certificate whose private key was stolen could still be abused until it expires—so revocation is an indispensable part of how PKI operates.

Certificates: Binding Identity to a Public Key

A digital certificate is essentially a document signed by a CA that binds "who the subject is" to "what the public key is". Common fields include at least:

  • Subject information (domain name, organization, personal identifier, etc.)
  • Public key and algorithm identifier
  • Validity period
  • Issuer
  • Extensions (key usage, SAN, CRL distribution points, etc.)
  • The CA's digital signature

To verify: check the signature with the issuer's public key → confirm "this binding has not been tampered with and was asserted by that CA". If the issuer is itself trusted by a higher CA, trust can be passed up the chain.

Certificate Format: Everyone Builds on X.509

Whether international or Chinese national cryptography (SM, "ShangMi"), mainstream certificates in practice almost all sit on the X.509 v3 skeleton: ASN.1 defines the structure, DER encodes it into a byte stream, and it is distributed as PEM (-----BEGIN CERTIFICATE-----) or DER files.

In other words, the format framework is unified. What really makes the difference is the algorithms, OIDs, and key usage conventions inside, and whether the trust system and protocol stack accept those algorithms.

The common "containers" are worth a quick mention:

  • The certificate itself: X.509 (.cer / .crt / .pem)
  • Private key and certificate bundles: PKCS#12 (.p12 / .pfx), PKCS#8, etc.
  • Application material: PKCS#10 (CSR)

These containers are used in both international and SM scenarios; the difference is still in the algorithm suites.

International Certificates (RSA / ECC)

"International certificates" generally means X.509 certificates that follow IETF PKIX practice (RFC 5280, etc.) and use mainstream international algorithm suites:

Component Common choices
Public key algorithm RSA (2048/3072…), ECDSA (P-256 / P-384, etc.)
Digest / signature SHA-256, SHA-384, etc.; e.g. sha256WithRSAEncryption, ecdsa-with-SHA256
Symmetric encryption (protocol side) AES, etc. (the certificate does not carry session keys; TLS negotiates them separately)

Their characteristics can be summarized as:

  • Mature ecosystem: Supported by default in browsers, operating systems, OpenSSL, Java, Go, and so on; Root Stores are dominated by internationally trusted public CAs.
  • One certificate, many uses: For TLS server certificates, the same key often handles both handshake authentication and key-exchange-related capabilities (depending on Key Usage and protocol version). Personal certificates, code signing, and so on are split by purpose, but separating signing and encryption keys is not a mandatory rule.
  • Good interoperability: Cross-border websites, public clouds, and open-source software stacks are all built around it.

SM Certificates (Chinese National Cryptography)

SM certificates can also be X.509 v3, but the algorithms and specification constraints are replaced with China's commercial cryptography system; the format requirements are given in standards such as GM/T 0015 (Digital Certificate Format). The core algorithms are usually:

Algorithm Purpose
SM2 Elliptic curve public key algorithm (signing, key exchange, public key encryption)
SM3 Hash algorithm (a role similar to the SHA family)
SM4 Block cipher (mostly used for encryption at the protocol layer)

The certificate marks the algorithms with SM OIDs, for example (common values, for reference):

  • SM2 public key: 1.2.156.10197.1.301
  • SM3withSM2 signature: 1.2.156.10197.1.501

A striking feature of SM practice is dual certificates (especially in e-government, finance, and similar scenarios):

  • Signing certificate: Key Usage centers on digitalSignature (and non-repudiation, etc.); the private key should be generated locally and be non-exportable.
  • Encryption certificate: Key Usage centers on keyEncipherment / data encryption; the encryption private key is often generated with CA involvement or escrowed by the CA, to support requirements such as key recovery.

Both certificates' Subjects point to the same entity, but their keys, serial numbers, and purposes are separate—unlike the habit in many international TLS scenarios of "one server certificate does everything".

Private Key Generation in Dual Certificates

Dual certificates are not just "issuing two certificates". The key point is where the two private keys come from and who can get them. This directly determines whether non-repudiation and key recovery can both hold.

Signing private key: generated on the user side, never touched by the CA

Typical flow:

  1. Generate the SM2 signing key pair inside a USB Key / smart card / local cryptographic module
  2. The private key never leaves the device (non-exportable)
  3. Only the public key goes into the CSR, which is submitted to the RA/CA for review and issuance of the signing certificate

Only then does "whoever signed is responsible" make sense: the CA never held the signing private key, so it cannot forge the user's signature afterward, which satisfies the business requirement of non-repudiation.

Encryption private key: generated by the CA / key management center, escrowable and recoverable

If the encryption key also existed only on the user's device, losing it would make historical ciphertext undecryptable—bad for email archiving, official documents, and regulatory forensics. So the common practice is:

  1. The KMC (Key Management Center) or CA generates the encryption key pair
  2. The encryption certificate is issued for the encryption public key
  3. The encryption private key is protected and delivered to the user (commonly: wrapped in a digital envelope / SM2 encryption using the user's signing public key; the user unwraps it with the signing private key and writes it into the Key)
  4. The CA/KMC retains, or can recover, a copy of the encryption private key (key escrow / key recovery)

This produces an asymmetric security model:

Signing key Encryption key
Who generates it The user (or a user-side crypto device) CA / KMC
Does the private key leave its generator Generally no Yes, securely delivered to the user, and the server side can retain recovery capability
Design goal Non-repudiation, identity authentication Confidential communication, with ciphertext recovery after loss or staff departure
Consequence of loss Just reapply for a signing certificate (historical signatures remain verifiable) Without escrow, historical ciphertext may be permanently undecryptable

When applying for dual certificates, the client usually completes the signing certificate application first, then uses its signing capability to "unwrap" the protected encryption private key delivered by the CA. That is why many SM RA/client flows have signing and encryption certificates requested as a pair, in a dependent order.

Note that not every SM deployment strictly follows "encryption keys must be escrowed". Device certificates and some TLS gateway scenarios may simplify things. But in businesses like electronic seals, secure email, and government documents—which need both non-repudiation and decryptable archives—the differences above are practically standard.

Feature Comparison

Dimension International certificates SM certificates
Structural skeleton X.509 v3 X.509 v3 (constrained by GM/T 0015)
Typical algorithms RSA / ECDSA + SHA-2 SM2 + SM3 (protocol side often pairs with SM4)
Key organization Mostly a single certificate; split by business as needed Often mandatory signing + encryption certificates
Trust source International Root Stores / public CAs SM root hierarchies, industry/government CAs
Protocols and clients Standard TLS, natively supported by mainstream browsers SM TLS (e.g. GMTLS), requiring an SM stack or gateway
Main driver Global interoperability Domestic compliance (the Cryptography Law, MLPS, etc.)

In one sentence: the formats can look very similar, but the algorithms, OIDs, dual-certificate conventions, and trust domains are not the same thing. Put an SM certificate into a browser that only knows RSA/ECDSA, or connect an international certificate to an SM gateway that only accepts SM suites, and it will fail at validation or handshake. The problem is usually not "is this a certificate" but "does the other side accept this cryptography and these OIDs".

Real deployments also often use "dual stacks": the same service offers both international TLS and SM TLS, or an SSL gateway terminates the algorithm and forwards a unified protocol internally. When choosing, first clarify the compliance requirements and client capabilities, then deal with certificate applications and chain construction.

Trust Chains: From Leaf to Root

In practice, root CAs rarely sign end-entity certificates directly; instead there are layers:

arduino
Root CA
  └── Intermediate CA
        └── Server/user certificate (Leaf)

The validation process can be summarized as:

  1. Obtain the leaf certificate (and intermediate certificates) presented by the peer
  2. Verify signatures upward along the issuance relationship until reaching a locally trusted root
  3. Check the validity period, usage (Extended Key Usage), domain name match (SAN), and so on
  4. Check whether it has been revoked (CRL / OCSP)

If any step fails, trust is not established. This is "certificate chain validation".

Ideally, a relying party trusts only its "own" tree. In reality, mergers and acquisitions, industry interconnection, dual SM/international stacks, and root key rotation all break this single-tree assumption—giving rise to two frequent problems: cross-certification and trust root rollover.

Cross-Certification

Cross-certification solves: how two independent PKIs can let each other's users verify each other's certificates.

Common form:

css
Root of PKI-A ──cross-signs──→ Root (or intermediate) of PKI-B
Root of PKI-B ──cross-signs──→ Root (or intermediate) of PKI-A   // when bidirectional

This means the A root signs B's CA certificate with its own private key (or vice versa), so a relying party that "only trusts the A root" can bridge a leaf certificate in the B domain to the A root and complete path building. Industries also commonly use a Bridge CA as a hub in a star topology, to avoid every pair of organizations signing a pair of cross-certificates.

The practical headaches of cross-certification:

  • Paths are no longer unique: The same leaf certificate may yield multiple paths to different trust anchors, so the client has to do path building and policy filtering (certificate policy OIDs, name constraints, path length constraints, etc.).
  • Misaligned policies: If A's vetting standards, key usages, or algorithm suites differ from B's, cross-signing amounts to "opening a hole in the trust boundary"—the bigger the hole, the bigger the risk.
  • SM and international coexistence: When the two sides differ in algorithms, OIDs, and dual-certificate conventions, cross-certification is often more than "signing a cross-certificate"; you must also make sure the relying party's crypto stack can verify both sides. Many deployments simply avoid true cross-certification by using gateways or dual-certificate deployments.
  • Revocation and lifecycle: Cross-certificates themselves need validity management and revocation. Once a cross relationship is withdrawn, trust paths that used to "route around" through it must become invalid immediately; otherwise you get ghost trust.

In one sentence: cross-certification is a hard requirement for inter-organizational interconnection, but it is also the part of PKI operations that is easiest to misconfigure and hardest to troubleshoot. Problems often show up as "some clients pass, others don't", and the root cause is usually path building or policy constraints rather than a broken leaf certificate.

Trust Root Rollover

Root CAs have lifespans too: algorithm upgrades (such as retiring weak signatures), responding to key compromise, compliance-driven replacement, and vendor/industry root migrations all trigger a trust root rollover. A root can't just be "swapped out", because relying parties' Root Store updates usually lag behind CA-side issuance.

In practice, the safer approach is a rolling switch with old and new roots coexisting, rather than a hard cutover:

  1. Generate the new root, keeping its private key offline; if needed, issue new intermediate CAs first.
  2. Transition via cross-signing or chain bridging: Use the old root to sign the new root (or new intermediates), and/or the new root to sign old intermediates, so that clients that "only trust the old root" and those that "already trust the new root" can both build valid paths during the transition.
  3. Parallel issuance: During the transition, leaf certificates can hang off both old and new chains, or servers can send certificate chains that can be anchored by either side.
  4. Push trust anchor updates: Operating systems, browsers, industry terminals, and embedded devices gradually include the new root; on internal networks, use Group Policy / MDM / image preinstallation.
  5. Retire the old root: Once relying parties broadly trust the new root and certificates on the old chain have expired or been reissued, stop issuing from the old root, revoke or let old cross relationships expire as planned, and finally remove the old anchor from Root Stores.

Some common pitfalls:

  • Replacing server certificates without managing client Root Stores → Browsers on the public internet may already have the new root, while legacy internal systems, IoT, and custom apps still only trust the old one.
  • Transition period too short → Embedded and offline devices update on cycles measured in years, so root rollover windows are often measured in years, not weeks.
  • Incomplete chains: The server sends only the leaf and omits the cross/intermediate certificate needed for "old root → new intermediate", so some clients cannot complete path building.
  • SM root migration follows the same rhythm, with the additional need to confirm that the new root's algorithm and OIDs match the endpoints' SM modules.

The essence of a trust chain is "walk until you reach some locally trusted anchor". Cross-certification joins multiple trees together in space; root rollover moves the anchor smoothly in time. Both require coordination between the CA, business systems, and relying parties; simply "reapplying for a leaf certificate" is usually not enough.

Certificate Transparency and CT Logs

Roots and public CAs are "changed with great caution" not only because Root Stores update slowly, but also because public PKI assumes by default that any CA trusted by browsers can, in theory, issue a certificate for your domain. If a CA is compromised or misissues, victims often find out only after the fact. Certificate Transparency (CT) adds a layer of "public issuance ledger" for exactly this.

What CT Solves

CT requires public CAs, after issuance (or at the precertificate stage), to submit certificates to public CT Logs in exchange for an SCT (Signed Certificate Timestamp). Mainstream browsers check publicly trusted TLS certificates for enough SCTs from compliant logs; if not satisfied, the handshake fails or a warning is shown.

The effect:

  • Issuance can't happen in secret: Once it's in a Log, domain owners, security researchers, and browser vendors can all see "who has issued certificates for my domain".
  • Misissuance can be held accountable: Many past incidents of CAs being distrusted or roots being downgraded were tied to publicly auditable issuance records. CT makes it very hard to keep "quietly issuing a phishing certificate" hidden for long.
  • Ties into root rollover: For a new root or new intermediate to enter the public trust ecosystem, besides passing Root Store review, its issuance pipeline must also integrate CT. When an old CA is removed from trust, people can trace back through the Logs to assess the impact.

What a CT Log Looks Like

A CT Log is an append-only log with cryptographic commitments (based on a Merkle Tree):

  1. The CA submits a precertificate / certificate
  2. The Log returns an SCT (think of it as a receipt saying "I have committed to including this")
  3. The certificate later formally enters the Log; anyone can query and monitor it
  4. The Log periodically publishes the tree head hash (STH), so outsiders can audit "whether history has been rewritten"

The SCT can appear in a certificate extension, in OCSP, or in a TLS handshake extension. Browsers care about "whether there are compliant SCTs"; they don't require you to dig through the Logs yourself.

Log operators need long-term high availability and community auditing. Common participants include Google, Cloudflare, DigiCert, Let's Encrypt, and others. TrustAsia, a public CA in China, also operates a CT log service publicly, making it one of the few non-US operators in the public CT ecosystem. A CA can be both a Log "contributor" (submitting the certificates it issues to be recorded) and a Log "bookkeeper".

Relationship to Operations / Root Rollover

  • Applying for public certificates: CT is now almost always the default; Let's Encrypt and commercial CAs handle submission and SCT embedding for you.
  • Monitoring your own domains: Use crt.sh or major CT monitoring services to watch SAN/CN. A certificate issued by an unknown CA is often the earliest warning signal—very useful during root rollovers, CA switches, or misissuance.
  • Private CAs / SM internal networks: CT is generally not mandatory; browser CT policies target publicly trusted roots. Internal self-signed and industry SM roots usually rely on their own trust anchors and governance rather than public CT Logs.
  • During root or CA retirement: While rolling old and new chains, use CT to confirm "whether the new chain is visible publicly, and whether the old CA is still issuing abnormally". For relying parties, this is another layer of visibility beyond swapping anchors.

Think of it this way: the certificate chain answers "can this certificate be verified cryptographically?"; CT answers "was this certificate's issuance publicly recorded?". Trust root rollover changes the anchors; CT changes the auditability of public issuance. Together, they let modern public PKI keep pressure on misissuance and malicious behavior despite "having to trust a set of roots".

How Trust Lands in HTTPS

HTTPS can be roughly understood as HTTP over TLS: the browser first completes a TLS handshake with the server, settling identity and session keys, then sends HTTP over the encrypted channel. PKI certificates appear mainly in the handshake—to answer "is the other end really the site I want to visit?"

Taking a visit to https://example.com as an example, the certificate-related steps are usually:

  1. The server presents its certificate chain during the TLS handshake
  2. The browser verifies that the chain anchors to a local root CA (plus SCT / revocation and other policies)
  3. It confirms the certificate subject matches the current domain (SAN)
  4. It uses the public key in the certificate (or the identity the certificate attests) to complete authentication and key agreement

After that, application data is transmitted encrypted. "The other side really is example.com" comes from PKI; session confidentiality comes from the symmetric keys agreed in the handshake. Without either, you don't have complete HTTPS trust.

What the TLS Handshake Does

The handshake has to accomplish three things at once: negotiate the version and algorithms, authenticate identity, and derive a shared key. Using the still widely deployed TLS 1.2 mental model (simplified):

  1. ClientHello: The client declares its supported protocol versions, cipher suite list, and extensions (SNI, ALPN, supported_groups, etc.)
  2. ServerHello: The server picks the version and suite, sends its certificate chain (Certificate), and, if needed, key exchange parameters (ServerKeyExchange)
  3. Client verifies the certificate: Chain validation, domain matching, usage checks; on failure, the connection is dropped
  4. Key exchange: Both sides use ECDHE or similar to generate a pre-master secret / shared secret, then derive traffic keys
  5. Finished: Integrity is confirmed with a handshake digest, after which they switch to encrypted application data

TLS 1.3 flattens the flow: it removes static RSA key transport, merges many messages, and usually completes in 1-RTT (there is also 0-RTT early data, but it carries replay risk and should be enabled with care). For operators, the felt difference is fewer round trips, shorter cipher suite names, and legacy algorithms removed outright.

The certificate's role here is clear: it doesn't encrypt the entire HTTP exchange; it proves "the party holding the corresponding private key has an identity vouched for by a CA". The heavy bulk encryption and decryption is handed to the symmetric keys derived after the handshake (AES-GCM, ChaCha20-Poly1305, etc.).

Mutual TLS (mTLS) simply adds the symmetric step: the server also requires the client to present a certificate and validates it—common for APIs, microservices, and the inner side of SM gateways.

A Brief History of SSL / TLS Versions

You still often hear "SSL", but modern HTTPS actually uses TLS; SSL is historical baggage.

Version Rough status Notes
SSL 2.0 / 3.0 Disabled Design flaws and known attacks (e.g. POODLE); should never be enabled
TLS 1.0 / 1.1 Deprecated Deprecated by mainstream browsers and standards such as PCI
TLS 1.2 Still widely used Needs correct suite and extension configuration to avoid legacy algorithms
TLS 1.3 Currently recommended Simpler, forward secrecy by default; preferred for new public deployments

Version negotiation happens at the start of the handshake: the client reports its supported list, and the server picks one from the intersection. A typical symptom of misconfiguration is "some old clients connect, but new browsers error out", or the reverse—usually because the server enables too narrow or too old a set of versions.

In SM scenarios there are also SM TLS stacks such as GB/T 38636 and GMTLS (often bound to SM2/SM3/SM4 suites), coexisting with IETF TLS. Dual-stack sites typically serve international traffic over TLS 1.2/1.3 and SM traffic on a dedicated port or gateway, rather than "mixing two cryptographic philosophies" in the same handshake.

How Cipher Suites and Protocols Work Together

A cipher suite is the named combination of algorithms chosen during the handshake. TLS 1.2 names are long and roughly encode:

  • Key exchange / authentication (e.g. ECDHE_RSA, ECDHE_ECDSA)
  • Bulk encryption (e.g. AES_128_GCM, CHACHA20_POLY1305)
  • Pseudo-random and integrity components (in AEAD suites, integrity is already built into GCM/Poly1305)

For example, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 reads as: exchange keys with ECDHE, authenticate the server with an RSA certificate, and protect the record layer with AES-GCM.

Some practical points when choosing:

  • Prefer ECDHE + AEAD: Provides forward secrecy (PFS), so even if the server's long-term private key leaks, historical traffic should not be decryptable.
  • Match the certificate algorithm to the suite: RSA certificates pair with _RSA_, ECDSA certificates with _ECDSA_; for SM, SM2 certificates pair with SM suites. If you change the certificate's algorithm, change the suite list accordingly, or the handshake will fail.
  • TLS 1.3 suites are shorter: For example TLS_AES_128_GCM_SHA256. Key exchange and authentication are split out of the suite name and negotiated via extensions (supported_groups, certificate types, etc.). If you can enable 1.3, you spend less time agonizing over long 1.2 suite names.
  • Protocol and suite are two separate knobs: Upgrading to TLS 1.2 while still enabling RSA key transport, RC4, 3DES, and so on leaves security poor; conversely, very modern suites with the version locked to 1.0 will also be blocked by policy.

New Members: Post-Quantum Cryptography (PQC)

The security of RSA / ECDH / ECDSA in classical suites rests on integer factorization or the elliptic curve discrete logarithm. Once large-scale quantum computers are available, Shor's algorithm will "break" these hard problems—hence Harvest Now, Decrypt Later: adversaries stockpile ciphertext now and decrypt it once quantum capability matures. For HTTPS to resist this threat, both key exchange and signatures need replacing.

NIST finalized the first batch of post-quantum standards (2024), with names changed from competition code names to official names:

Official name Origin / standard Role Roughly corresponds today to
ML-KEM Kyber, FIPS 203 Key encapsulation (KEM) for key establishment ECDHE / classical key exchange
ML-DSA Dilithium, FIPS 204 Digital signatures (primary) RSA / ECDSA signatures and certificates
SLH-DSA SPHINCS+, FIPS 205 Stateless hash-based signatures (backup route) Long-lived trust anchors, algorithm diversity
FN-DSA (in progress) Falcon, FIPS 206 draft More compact lattice-based signatures Constrained environments needing smaller signatures

An intuitive mapping onto TLS / PKI:

  • "Key exchange" in the handshake → look at supported_groups: besides x25519 and secp256r1, entries like mlkem768 will gradually appear. In practice the transition relies heavily on hybrid schemes, such as X25519 + ML-KEM, where both must succeed, so that "PQC implementations are still new, and classical crypto remains the safety net".
  • "Authentication" in the handshake → look at signature_algorithms / certificates: the IETF is adding ML-DSA-44 / 65 / 87 to TLS (e.g. mldsa44, mldsa65, mldsa87). Public keys and CA signature algorithms in certificates will also move toward ML-DSA (or hybrid certificate chains).
  • Record-layer symmetric encryption → AES-GCM, ChaCha20, and the like are relatively robust against quantum attacks (the main concern is Grover, countered by longer keys), so "the AES part of the suite name" often stays for now; what changes is the KEM + signature in front.

Compared with traditional suite selection, PQC adds some practical constraints:

  • Larger sizes: ML-DSA public keys and signatures are roughly an order of magnitude larger than ECDSA, so certificate chains, handshake messages, and CT Log entries all get heavier; CDNs and embedded systems need to re-estimate bandwidth and MTU.
  • Ecosystem still ramping up: The post-quantum roadmaps of browsers, OpenSSL, commercial CAs, and the SM side are not aligned. The common path on the public internet is "enable hybrid KEM first, migrate signatures/certificates later".
  • Algorithm diversity: The main path is ML-KEM + ML-DSA; for critical roots or long-term signatures, consider SLH-DSA as a heterogeneous backup, to avoid "one lattice assumption collapses and everything falls".
  • Relationship to SM: SM's main battlefield is still SM2/SM3/SM4; post-quantum is a separate, parallel line of evolution. In the long run there may be "SM + PQC" alongside international hybrids. At this early stage, keep the two timelines distinct and don't assume one has replaced the other.

In one sentence: the "member list" of cipher suites is expanding from RSA/ECDHE to post-quantum algorithms such as ML-KEM / ML-DSA; TLS 1.3's extension mechanism is well suited to accommodating them, and PKI needs to prepare in parallel for larger certificates and possibly hybrid trust chains.

The relationship can be summed up as:

  • Protocol version determines how the handshake proceeds and which capabilities are allowed
  • Cipher suite / negotiation extensions determine which set of algorithms this particular connection uses (classical and post-quantum)
  • Certificates / PKI determine whether identity can be trusted (signature algorithms are likewise migrating toward ML-DSA and others)

The HTTPS "padlock" is the result of all three layers lighting up together, not the work of any single layer.

Summary

To tie the thread together:

  1. The problem: Asymmetric cryptography lets you use keys, but on its own cannot prove "who a public key belongs to".
  2. The roles: The CA issues, the RA vets, holders safeguard private keys, relying parties validate, and CRL/OCSP handle invalidation—PKI is a collaboration, not a single certificate.
  3. Certificates: X.509 binds identity to a public key. The international system uses RSA/ECDSA; SM uses SM2 dual certificates (signing keys generated locally, encryption keys often escrowable and recoverable). The format skeletons are similar, but algorithms and trust domains differ.
  4. Trust chains: Validation must reach a local trust anchor. Cross-certification joins trees in space; root rollover moves anchors in time; on the public internet, CT Logs also keep a ledger of issuance, making misissuance and abuse harder to hide.
  5. Landing in HTTPS: The TLS handshake handles authentication and key agreement. Version (mainly 1.2/1.3 today), cipher suites/negotiation extensions, and certificates are all indispensable. The suite list has expanded from ECDHE+AES to post-quantum members such as ML-KEM / ML-DSA, with hybrids common during the transition.

In one sentence: encryption secures the channel, certificates and trust chains make identity trustworthy, and CT plus protocol evolution keep this trust auditable and able to upgrade along with cryptography. Behind the little padlock is a system held up by roles, formats, anchors, logs, and handshakes together.