Every TLS deployment answers one design question, often by accident: should the server only prove who it is, or should it also demand proof from the caller? Ordinary TLS authenticates the server and leaves the client anonymous at the transport layer, so caller identity has to come from something else, such as a password, an API key or a token. Mutual TLS (mTLS) makes the client present a certificate and prove it holds the matching private key, which turns every caller into an identity with a credential lifecycle of its own. This guide covers the decision: which traffic should require client certificates, the issuance and rotation cost, the threat model at the edge and inside the estate, and a safe rollout. It is written for platform, API and security architects. For how the handshake works see the How TLS Works Guide, and for configuration detail see the mTLS Guide.
Products are listed alphabetically wherever more than one is named. Order is never a ranking.
Key takeaways
- Require client certificates where you control both ends. Internal service-to-service traffic, partner integrations you onboard yourself, devices you provision and administrative endpoints are the natural home of mTLS, because you can issue, rotate and revoke the client credential.
- Keep server-only TLS for anonymous or human-facing edges. Public websites and consumer APIs cannot hand every caller a certificate, so the client is authenticated above TLS with sessions, OAuth tokens or passkeys.
- The real cost is the client credential lifecycle. Every caller now needs a key, a certificate, renewal before expiry and removal when it leaves; with automation that is cheap, without it mTLS becomes an outage generator.
- Optional client authentication is not mTLS. TLS 1.3 lets a server continue when the client sends an empty certificate, and mesh permissive modes accept plaintext; unless the server rejects callers without a valid certificate, nothing has been enforced.
- Public CA certificates are the wrong source for client identity. From 15 June 2026 the Chrome Root Program requires new subscriber certificates from dedicated TLS server hierarchies to assert only serverAuth, so plan client certificates from a private CA or a workload identity system.
The short answer
Use TLS with server authentication only when the caller population is open or unknown in advance (browsers, the public internet, consumer mobile apps you cannot provision), and authenticate the caller at the application layer. Use mutual TLS when the caller population is closed and enumerable, you can run issuance and rotation for every caller, and you want a credential that a thief cannot replay without the private key. The common enterprise answer mixes both: TLS at the public edge, mTLS from the edge inwards and between services, and a token wherever end-user context is needed. For client certificates versus tokens, see mTLS vs Signed Tokens for Service Authentication.
What changes when the server authenticates the client too
In TLS 1.3 (RFC 8446) the difference is a single optional message. A server that wants client authentication sends a CertificateRequest after EncryptedExtensions; the client replies with its Certificate and a CertificateVerify signed over the handshake transcript, which proves possession of the private key. Three RFC details drive most design decisions:
- Empty certificate behaviour: a client with no suitable certificate sends an empty Certificate message. The server may then either continue without client authentication or abort with the
certificate_requiredalert. Which of the two your server does is the whole difference between "requested" and "required". - Proof failure: if the CertificateVerify signature does not verify, the handshake ends with
decrypt_error. - Filtering: if the client certificate does not satisfy the server's OID filters, the server may continue without client authentication or abort with
unsupported_certificate.
Record protection, cipher suites and key exchange are identical, so mTLS adds no confidentiality: it adds an authenticated peer at one hop, and a credential to manage at every caller.
Side-by-side comparison
| Property | TLS (server authentication only) | Mutual TLS (server and client authentication) |
|---|---|---|
| Who is authenticated by the handshake | Server only | Server and client |
| Where caller identity comes from | Application layer: session cookie, password, API key, OAuth token, passkey | Client certificate subject or SAN (DNS name, URI, SPIFFE ID), then optionally a token as well |
| Replay of a stolen caller credential | Depends on the application credential; bearer tokens and API keys are replayable | Not possible without the private key |
| Reachability by unauthenticated callers | Any client can reach application code | Callers without a valid certificate are rejected before any request is parsed (when required) |
| Trust configuration | Client trust stores (usually public roots) | Client trust stores plus a server-side client CA bundle, normally private |
| Revocation of a caller | Revoke the application credential | Short certificate lifetime, CRL or OCSP, or removal from an allow list of identities |
| Behaviour through TLS-terminating proxies | Unaffected | The proof ends at the proxy; identity must be forwarded and the backend protected |
| User experience for people | Invisible | Certificate install on every device; managed fleets only |
| Main failure mode | Weak or stolen application credentials | Expired client or CA certificates, optional or permissive modes, trust bundles that are too broad |
Threat model for each option
Server-only TLS
What it stops: passive interception and tampering on the wire (ATT&CK T1040 Network Sniffing) and impersonation of the server, provided clients validate the chain and name. What it leaves open: anyone can complete a handshake, so every caller reaches your parser, your authentication endpoint and your rate limits. The caller's identity is only as strong as the application credential, which is typically a bearer secret: a leaked API key or token is usable from anywhere until it expires or is revoked. Architecture in words: one server certificate, one trust decision at the client, and caller authentication entirely in the application or gateway.
Mutual TLS
What it stops: unknown callers never reach application code; a stolen certificate file without its key is useless; adversary-in-the-middle attempts (T1557) fail in both directions when both sides validate. What it moves: the target becomes the client private key (T1552.004 Private Keys), the issuing CA and its enrolment process (T1649 Steal or Forge Authentication Certificates), and the trust bundle on each server. Anyone who can obtain a certificate from a CA in the bundle is a valid caller, so an over-broad bundle (a whole enterprise CA trusted by a payments service) is equivalent to letting every enrolled machine in. Architecture in words: a private CA or workload issuer, an enrolment path per caller, a client CA bundle per server or trust domain, and authorisation on the certificate identity.
Where to require client certificates: by traffic type
| Traffic | Recommendation | Why |
|---|---|---|
| Public website and browser sessions | Server-only TLS; authenticate users with passkeys or MFA and sessions | Open population; client certificate prompts in browsers are confusing and unmanageable at scale |
| Consumer mobile app to API | Server-only TLS plus OAuth tokens, ideally sender-constrained with DPoP | App installs cannot be issued unique enterprise certificates reliably; see the DPoP Guide |
| Partner or B2B API with a known set of organisations | mTLS at the gateway, optionally with RFC 8705 certificate-bound tokens | Closed population, contractual onboarding, high value per caller |
| East-west service-to-service inside a cluster or mesh | mTLS required (strict), issued automatically by the mesh or a SPIFFE issuer | Automation makes per-workload certificates cheap; removes network location as the trust basis |
| Edge proxy or gateway to backend | mTLS from proxy to backend, backend reachable only from the proxy | Stops direct calls that bypass the edge and spoof forwarded identity headers |
| Managed devices and IoT | mTLS with device certificates enrolled through EST or SCEP | Devices often have no user or identity provider; see the IoT and Device Certificate Provisioning (EST, SCEP) Guide |
| Databases and message brokers | mTLS for service clients where the platform supports certificate authentication | Replaces shared static passwords with per-client keys |
| Administrative and management interfaces | mTLS for managed admin devices, in addition to user MFA | Shrinks the reachable surface to provisioned endpoints |
mTLS at the edge vs inside the estate
At the edge
At the edge, mTLS is a gate for a known external population, and the gateway does the validation. Two examples show what the customer controls:
- Amazon API Gateway (REST APIs): mTLS is configured on a Regional custom domain with a PEM truststore stored in Amazon S3, holding the full chain up to four certificates. Disable the default
execute-apiendpoint so clients can only arrive through the mTLS domain. Add a Lambda authorizer for revocation checks, which the documentation identifies as the place for additional certificate checks, and track client certificate expiry yourself, since the service validates expiry at handshake time rather than notifying you in advance. Availability: the documentation states mTLS applies to Regional custom domains and not to private APIs. - Cloudflare: mTLS is enabled per hostname, with client CAs set at account level. Choose the Cloudflare-managed CA for a small, stable client population, or bring your own CA for high-volume or high-churn issuance and existing internal PKI. Base access decisions on the verified result exposed as
cf.tls_client_auth.cert_verified, and revoke certificates when a client is retired. Availability: the documentation states per-zone limits on managed-CA certificates and lists bring-your-own CA as an Enterprise plan capability.
The common edge pattern is that mTLS ends at the gateway. The backend then trusts whatever the gateway forwards, so it must accept traffic only from the gateway (ideally over a second mTLS hop) and must strip any client-supplied header that claims to carry certificate details. RFC 8705 explicitly leaves the secure forwarding of client certificate data from a terminating proxy out of scope, so you design it. See the API Gateway Security Guide.
Inside the estate
Internally, mTLS replaces network location as the basis of trust, the shift NIST SP 800-207A describes: policies based on service identities, with SPIFFE as an example identity infrastructure. A service mesh issues and rotates the certificates so application teams never handle keys:
- Istio: the
PeerAuthenticationresource sets the mode.STRICTrequires an mTLS tunnel and a client certificate;PERMISSIVEaccepts plaintext or mTLS;UNSETinherits from the namespace or mesh and, with no parent, behaves as PERMISSIVE. Set STRICT at mesh level once migration is complete, and useportLevelMtls(which needs a workload selector) only for documented exceptions. - Linkerd: mTLS is on by default for TCP traffic between meshed pods, using proxy certificates valid for 24 hours that are rotated automatically and bound to the pod's ServiceAccount. Plan rotation of the trust anchor and issuer certificate: those created by a default install expire after 365 days, and the documentation recommends supplying your own anchor or automating issuer rotation with cert-manager. Add authorization policy to refuse non-meshed sources, which are accepted by default, and account for skip ports and health checks that bypass the proxy.
Certificate format matters too. A SPIFFE X.509-SVID carries exactly one URI SAN holding the SPIFFE ID, is a leaf with cA false and the digitalSignature key usage, and if it includes extended key usage it must assert both serverAuth and clientAuth, so the same certificate serves as client and server identity. See the SPIFFE and SPIRE Guide and the Service Mesh Security Guide.
The issuance and rotation burden
Server-only TLS needs one certificate per service name; mTLS needs one per caller. The burden is manageable only when each line below has an owner and automation.
| Lifecycle task | Internal workloads (mesh or SPIFFE) | Partners and devices (edge) |
|---|---|---|
| Enrolment | Automatic from platform attestation (ServiceAccount, node, cloud identity) | Onboarding process: CSR exchange, EST or SCEP, identity proofing of the organisation or device |
| Typical lifetime | Hours to days (Linkerd proxy certificates: 24 hours) | Months to a year, constrained by how often the partner or device can renew |
| Renewal | Proxy or agent renews in the background | Partner process or device client; the most common source of outages |
| Revocation | Mostly by expiry; remove workload registration | CRL, OCSP or gateway allow list; check what your gateway actually enforces |
| Trust anchor rotation | Planned overlap of old and new roots in every bundle | New CA distributed to partners and gateways before any certificate chains to it |
Public CAs and client identity: the Chrome Root Program requires subscriber certificates issued from dedicated TLS server authentication hierarchies on or after 15 June 2026 to assert only serverAuth. Move any client identity built on public web certificates to a private CA, and never trust a public root as a client CA bundle: that admits anyone who can buy a certificate. Each client certificate is a non-human identity with an owner and a blast radius; see the NHI Authentication Guide, the Enterprise PKI Design and CA Hierarchy Guide and Short-Lived vs Long-Lived Certificates.
Worked scenarios
Scenario 1, TLS only is right: a retailer exposes a public storefront API to its web and mobile apps. Callers are millions of anonymous devices. A client certificate would have to be shared across every install and is trivially extracted, so it proves nothing. The right design is server-only TLS 1.3, OAuth tokens for signed-in customers with DPoP sender constraint on sensitive calls, and bot and rate controls at the edge. mTLS appears only behind the edge, from the gateway to the order and payment services.
Scenario 2, mTLS is right: a payments platform receives settlement files and API calls from forty acquiring partners, each onboarded under contract. API keys have leaked twice through partner logs. The team issues each partner a client certificate from a dedicated private intermediate, with the partner identity in the SAN, a one-year lifetime and a renewal window starting at day 300. The gateway requires a certificate, the trust bundle contains only that intermediate, the default endpoint is closed, and a gateway authoriser checks the certificate serial against a revocation list and maps the SAN to permitted operations. Access tokens are bound to the certificate with RFC 8705 x5t#S256, so a leaked token is useless on its own. The new duty is a certificate register with expiry alerts.
Rolling out client certificate requirements
- Classify traffic: list each listener and decide, using the traffic table above, whether callers form a closed population. Record the decision and owner.
- Stand up issuance first: a private CA or mesh issuer, a dedicated intermediate per population (partners, devices, workloads), and a register. Never start by requiring certificates you cannot yet issue and renew.
- Request, do not require: configure servers to request a client certificate and log the result (presented, valid, identity) while still accepting callers without one. In a mesh this is permissive mode.
- Measure and chase: fix callers still arriving without a valid certificate, or document each as a dated exception.
- Require in rings: switch to required (abort with
certificate_required, Istio STRICT, gateway enforcement) for one service or partner cohort at a time, starting with the lowest-risk callers. - Add authorisation: after authentication works, restrict which identities may call which operations. A valid chain alone admits every certificate the CA has issued.
- Rollback: keep the previous mode as a single configuration change (for example STRICT back to PERMISSIVE for one namespace, or the gateway truststore set back to the previous S3 object version) and rehearse it. Roll back per cohort, never estate-wide, and record the reason.
Decision checklist
- Population: can you list every legitimate caller? If not, use server-only TLS and authenticate above it.
- Issuance: can you enrol, renew and revoke a credential for each caller automatically, or through a defined partner process?
- Termination: where does TLS end, and can the backend be reached any other way?
- Authorisation: will you map certificate identities to permissions, or would mTLS only tell you "someone from our CA"?
- Scale: small estates usually do better with a managed mesh or platform-issued workload identity than their own CA; large estates need an intermediate per population and an inventory from day one.
Common failure patterns
- Requested but never required: the server asks for a certificate, accepts an empty one, and the team believes mTLS is on. Test with a certificate-less client.
- Permissive forever: mesh migration stalls in PERMISSIVE, or a namespace is left UNSET with no mesh-wide policy, so plaintext is still accepted. Track the share of workloads in strict mode as a metric.
- Trust bundle too broad: a sensitive service trusts the whole enterprise CA or a public root, so any enrolled machine, or anyone who can buy a certificate, is an authenticated caller.
- Expiry outages on the client side: partner and device certificates renew on human processes, and anchors created at install time expire after a year. Expiry of client certificates is invisible until the handshake fails. See the Certificate Expiry Outages and 47-Day TLS Certificates Guide.
- Shared client certificates: one certificate copied to many apps, devices or partners, so revoking it breaks everyone and attribution is impossible. One identity per caller, always.
Detection and measurement
Log, per listener, whether a client certificate was presented, whether it validated, the identity (SAN or SPIFFE ID), issuer, serial and expiry, and the reason for each rejected handshake. In meshes, use the proxy's connection telemetry to see which connections are mTLS and which are plaintext. Alert on unregistered identities, certificates from an unexpected intermediate, and spikes of certificate_required or decrypt_error failures (misconfiguration or probing).
| Metric | What it shows | Target |
|---|---|---|
| Share of in-scope listeners requiring (not requesting) client certificates | Enforcement coverage | 100% of listeners classified as closed-population |
| Share of mesh workloads in strict mode | Plaintext exposure inside the estate | Rising to 100% with dated exceptions |
| Client certificates expiring within 30 days without a renewal in flight | Outage risk | Zero |
| Client certificates with a named owner in the register | Inventory quality | 100% |
| Bypass paths found (default endpoints, direct backend reachability) | Architectural gaps | Zero open after each review |
Framework mapping
| Framework | Reference | How the TLS vs mTLS decision maps |
|---|---|---|
| NIST CSF 2.0 | PR.AA-03, PR.DS-02 | mTLS authenticates services and hardware; both options protect data in transit |
| NIST SP 800-53 Rev. 5 | IA-9 Service Identification and Authentication; IA-3 Device Identification and Authentication | Client certificates are a direct means of authenticating services and devices before communication |
| NIST SP 800-53 Rev. 5 | IA-5(2) Public Key-based Authentication; SC-17 Public Key Infrastructure Certificates | Path validation to a chosen anchor, mapping identity to account, private key protection, and CA governance |
| MITRE ATT&CK | T1040, T1557, T1552.004, T1649 | TLS counters sniffing; mTLS counters AiTM in both directions; mTLS shifts risk to private keys and certificate issuance |
| MITRE D3FEND | D3-CBAN Certificate-based Authentication; D3-CERO Certificate Rotation | mTLS is certificate-based authentication; rotation discipline keeps it safe |
Practitioner checklist
- Classify every listener as open or closed population and record whether it requires client certificates.
- Issue client certificates from a private CA or workload identity issuer, with a dedicated intermediate per caller population.
- Confirm by test that servers reject callers with no certificate, not just request one.
- Set mesh policy to strict at mesh level after migration and document every port or namespace exception with an end date.
- Map certificate identities (SAN or SPIFFE ID) to permitted operations; never authorise on chain validity alone.
- Close default endpoints and direct backend paths, and strip inbound certificate headers at the edge.
- Keep a register of edge client certificates with owner, contact and expiry, and alert at 60, 30 and 7 days.
- Plan trust anchor and issuer rotation with overlap, and rehearse rollback per cohort.
Standards and references
- IETF: RFC 8446 The Transport Layer Security (TLS) Protocol Version 1.3
- IETF: RFC 8705 OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens
- SPIFFE: The X.509 SPIFFE Verifiable Identity Document
- Google: Chrome Root Program Policy
- Amazon Web Services: Mutual TLS authentication for REST APIs in API Gateway
- Cloudflare: Client certificates (mTLS)
- Istio: PeerAuthentication reference
- Linkerd: Automatic mTLS
Related NHI Mgmt Group resources: mTLS Guide, How TLS Works Guide, mTLS vs Signed Tokens for Service Authentication, SPIFFE and SPIRE Guide, Certificate Revocation Guide.