# What is mTLS?

> Mutual TLS is a connection where the client, like the server, shows a certificate and proves it holds the private key. In OAuth, it can replace a client secret and tie an access token to the client.

Explainer by Boston Identity, 2026-10-16. 6 min read. https://insights.bostonidentity.com/glossary/mtls

- What it is: protocol
- Defined by: IETF, RFC 8705 (its use in OAuth)
- Who it's for: Teams securing service and agent access to APIs

## What is mTLS?

Ordinary TLS (Transport Layer Security, the encryption behind HTTPS) proves the server's identity to the client. In mutual TLS, the client also sends its own X.509 certificate during the handshake and proves it holds the matching private key [S1 §1.2].

RFC 8705, an IETF (Internet Engineering Task Force) standard from February 2020, brings this into OAuth, the framework that lets an application get an access token and use it at an API [S1 §1]. A client can authenticate to the authorization server with its certificate in place of a shared secret, which the RFC says gives better security [S1 §1]. The authorization server can also bind the access token to that certificate. Anyone who holds an ordinary bearer token can use it, while a bound token works only for the party holding the certificate's private key, so a stolen or replayed token is useless [S1 §1].

The RFC treats the two uses as separate: they work well together, and a deployment can run either one alone [S1 §1]. A public client, one with no credentials of its own, can still get bound tokens by making a self-signed certificate [S1 §4].

Think of it like this: Think of a guard who shows you a badge and asks to see yours before letting you in. A bound token is a visitor pass printed with your badge number, so it is useless to someone who finds it without your badge. The comparison breaks down at the badge itself, which is only as good as whoever issued it.

Not the same as: Not the same as the HTTPS a browser uses every day, where only the server shows a certificate. Mutual TLS also does not bind tokens by itself: certificate-bound tokens are a separate feature that an authorization server advertises when it supports them [S1 §3.3].

## How does mTLS work?

Three parties take part: the client (an application or agent), the authorization server that issues tokens, and the resource server, which is the API the client wants to reach. The client talks to both servers over mutual TLS.

[Figure: The client proves its certificate at the token endpoint, gets a token bound to it, and must show the same certificate at the API.]

1. **The server asks for the client's certificate.** During the TLS handshake, the server requests a certificate; a client does not send one unasked [S1 §5]. The client sends its X.509 certificate and a signed CertificateVerify message, which proves it holds the private key. The server checks that message and the handshake's Finished message [S1 §1.2].
2. **The client names itself at the token endpoint.** Over that connection, the client asks the authorization server for a token and must include its client_id, the name it is registered under [S1 §2]. The server looks up that client's settings and checks the certificate from the handshake against them. A missing or wrong certificate gets the standard OAuth error invalid_client [S1 §2].
3. **The authorization server checks the certificate.** Under the PKI (public key infrastructure) method, the server validates the certificate chain and matches one subject name registered for that client, such as a distinguished name or a DNS name [S1 §2.1]. Under the self-signed method, the client registers its certificates in advance. The server skips chain validation and checks that the certificate matches one of them [S1 §2.2].
4. **The authorization server binds the token to the certificate.** When the token is a JSON Web Token (JWT), the server should place a SHA-256 hash of the certificate, its thumbprint, in the token's cnf (confirmation) claim as x5t#S256 [S1 §3.1]. When the API checks tokens by introspection, a lookup at the authorization server, the same hash comes back in the response [S1 §3.2].
5. **The client reaches the API with the same certificate.** The client must send each API request over mutual TLS, using the same certificate it used at the token endpoint [S1 §3]. The API must know in advance to ask for a certificate, because the token arrives only after the handshake is over [S1 §3].
6. **The API compares the certificate with the token.** The resource server must take the client certificate from its TLS layer and check that it matches the one tied to the token. If they differ, it must reject the request with HTTP 401 and the error invalid_token [S1 §3]. The API does not need to validate the certificate's chain, because here mutual TLS only proves possession of the key [S1 §6.2].

## Why does mTLS matter now?

Revision -15 of OAuth 2.1 recommends asymmetric client authentication and names mutual TLS and signed JWTs as examples [BI-FIND-2026-1112](https://insights.bostonidentity.com/ref/BI-FIND-2026-1112). For public clients, the draft requires the authorization server to catch a reused refresh token. Binding the token to the client instance with DPoP (Demonstrating Proof of Possession) or mutual TLS is one of the two ways it gives [BI-FIND-2026-1109](https://insights.bostonidentity.com/ref/BI-FIND-2026-1109).

Agent security guidance asks for certificates as well. Anthropic's zero trust guide for agents adds X.509 certificates with rotation and revocation, and then mutual TLS, at its higher tiers [BI-FIND-2026-0596](https://insights.bostonidentity.com/ref/BI-FIND-2026-0596). OWASP's top 10 for agentic applications names mutual TLS certificates as one example of the short-lived, narrowly scoped credentials it wants for each task [BI-FIND-2025-0093](https://insights.bostonidentity.com/ref/BI-FIND-2025-0093). The agent protocols themselves leave it optional. An Agent2Agent (A2A) 1.0 agent card may declare mutual TLS among five methods, and none is required [BI-FIND-2026-0760](https://insights.bostonidentity.com/ref/BI-FIND-2026-0760). The July 2026 Model Context Protocol (MCP) specification does not require sender-bound tokens at all [BI-FIND-2025-0015](https://insights.bostonidentity.com/ref/BI-FIND-2025-0015).

On the workload side, an OAuth working-group draft lets a workload present its SPIFFE certificate over mutual TLS in place of a stored secret [BI-FIND-2026-0316](https://insights.bostonidentity.com/ref/BI-FIND-2026-0316). The IETF's workload identity group also has a mutual TLS profile, but it leaves trust anchor distribution out and gives revocation a single paragraph with no numbers [BI-FIND-2026-0517](https://insights.bostonidentity.com/ref/BI-FIND-2026-0517).

## Where does it fit?

- Compared with DPoP: Both tie an OAuth token to a key the client holds, and OAuth 2.1 offers either one to stop refresh-token replay [BI-FIND-2026-1109](https://insights.bostonidentity.com/ref/BI-FIND-2026-1109). Mutual TLS proves the key in the TLS connection, so the proof ends at any proxy or gateway that ends the connection [BI-FIND-2026-0180](https://insights.bostonidentity.com/ref/BI-FIND-2026-0180).
- Compared with SPIFFE: SPIFFE gives a workload an identity and credentials that carry it, one of which is a certificate. Mutual TLS is one way to present that certificate, and an OAuth draft uses it so a workload can authenticate without a stored secret [BI-FIND-2026-0316](https://insights.bostonidentity.com/ref/BI-FIND-2026-0316).
- Compared with OAuth: OAuth is the framework for issuing and using access tokens. Mutual TLS plugs into it twice: as a way for a client to authenticate without a shared secret, and as a way to make its tokens useless to a thief [S1 §1].

## What goes wrong?

- A proxy ends the proof. The RFC lets servers end TLS at a load balancer or proxy, but how the certificate details then reach the application server is out of its scope [S1 §6.5]. Mutual TLS proves the identity only as far as the TLS connection reaches [BI-FIND-2026-0518](https://insights.bostonidentity.com/ref/BI-FIND-2026-0518), and a draft on agent authentication says it breaks at every proxy, gateway and service mesh that ends the connection [BI-FIND-2026-0180](https://insights.bostonidentity.com/ref/BI-FIND-2026-0180).
- Under the PKI method, an attacker could present a certificate with the same subject name, issued by another certificate authority (CA) the server trusts. The server should trust only a few CAs whose issuing rules meet its needs [S1 §7.4].
- X.509 validation is complex, and mistakes in it have caused security holes before. Implementers should use a well-tested library and should not write their own checks [S1 §7.5].
- Whether and how to check if a certificate was revoked is left to the authorization server [S1 §2.1].
- A new certificate invalidates the tokens bound to the old one, so the client has to get new tokens, usually with a refresh token [S1 §6.3].
- Before TLS 1.3, the client certificate travels unencrypted, and third parties can use it to track a client [S1 §8].
- When a server asks for a certificate, a browser may show the user an intrusive certificate picker. The RFC lets servers offer separate mutual TLS endpoints to keep that away from ordinary clients [S1 §5].

## What should a security leader ask?

1. Where does TLS end between our clients and our APIs, and what checks the client certificate after that point?
2. Do our access tokens carry a certificate thumbprint, and does every API compare it with the certificate on the connection?
3. Which certificate authorities does our authorization server trust for client certificates, and who could get one with a subject name that matches one of our clients?
4. What happens to an agent's tokens when its certificate rotates, and how fast can we revoke a stolen certificate?
5. Which of our agent connections, over MCP or A2A, let a client skip mutual TLS or token binding?

## Sources

- [S1] [OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens](https://www.rfc-editor.org/rfc/rfc8705) (IETF, RFC 8705, Standards Track, February 2020)

## Evidence

- [BI-FIND-2026-1112](https://insights.bostonidentity.com/ref/BI-FIND-2026-1112): OAuth 2.1 specifies how a client authenticates but leaves validating who the client is to the authorization server. In the editors' words, "Whether and how an Authorization Server validates the identity of a client or the party providing/operating this client is out of scope of this specification." Section 2.4 gives the authentication side with examples: asymmetric methods are RECOMMENDED, such as mutual TLS or signed JWTs (private_key_jwt), and where a client cannot authenticate the server SHOULD use other means, for example requiring the redirect URI to be registered or asking the resource owner to confirm identity. Servers SHOULD weigh their confidence in a client's identity before allowing more sensitive access, such as the client credentials grant, and the attestation-based client authentication draft comes up only in the native-apps section, as a way to raise assurance of a mobile app's identity. (from "OAuth 2.1's March draft builds in the security best practice, but 2.1-only clients can fail with older servers")
- [BI-FIND-2026-1109](https://insights.bostonidentity.com/ref/BI-FIND-2026-1109): Revision -15 of OAuth 2.1 turns the advice in OAuth 2.0's security best current practice (RFC 9700) into the base protocol. The authorization code grant now carries PKCE: clients are REQUIRED to send a code challenge and authorization servers MUST enforce it, unless the client is confidential and the server has reasonable assurance that it implements the OpenID Connect nonce properly. Redirect URIs are registered in full and must match exactly, except for the port on loopback redirects. The implicit and password grants are left out, clients MUST NOT send access tokens in a URI query parameter, and for public clients the authorization server MUST catch refresh-token replay, either by binding the token to the client instance (DPoP and mutual TLS are the examples given) or by rotating it on every refresh. (from "OAuth 2.1's March draft builds in the security best practice, but 2.1-only clients can fail with older servers")
- [BI-FIND-2026-0596](https://insights.bostonidentity.com/ref/BI-FIND-2026-0596): Anthropic requires a cryptographic identifier for each agent instance at its Foundation tier. "Every agent instance needs a unique, cryptographically rooted identifier that persists across its actions", and "Unique identifiers alone are a labeling exercise". Service tokens should be measured in minutes, and static API keys and shared service-account passwords "are no longer a legitimate entry point, not even at Foundation". Higher tiers add X.509 certificates with rotation and revocation, mutual TLS, then hardware-backed identity with remote attestation, and access control climbs from deny-by-default roles to per-action authorization with immediate revocation. The standards named are OAuth 2.0, X.509, mTLS, FIDO2 and OpenTelemetry; SPIFFE, WIMSE and token exchange do not appear. (from "Anthropic asks for per-agent identity; its guide leaves Claude Code sub-agent credentials unspecified")
- [BI-FIND-2025-0093](https://insights.bostonidentity.com/ref/BI-FIND-2025-0093): OWASP's identity entry, ASI03 Identity and Privilege Abuse, puts the root cause in "the architectural mismatch between user-centric identity systems and agentic design": without "a distinct, governed identity of its own, an agent operates in an attribution gap that makes enforcing true least privilege impossible." Its nine mitigations ask for per-agent identities, "short-lived, narrowly scoped tokens per task" such as mTLS certificates or scoped tokens, a policy check on every action, human approval for escalation, and OAuth tokens bound "to a signed intent that includes subject, audience, purpose, and session". It names no standard for any of them: token exchange, SPIFFE, OIDC, DPoP and the MCP authorization specification appear nowhere in the 57 pages. (from "OWASP's agent Top 10 blames identity systems built for people, and does not say how it chose or ranked its risks")
- [BI-FIND-2026-0760](https://insights.bostonidentity.com/ref/BI-FIND-2026-0760): A2A 1.0 authenticates the calling agent and stops there. An agent's card can declare API keys, HTTP authentication, OAuth 2.0, OpenID Connect or mutual TLS, none of them required, and credentials are fetched out of band and sent with every request. Nothing in the core protocol carries the person the work is done for or the agents a task passed through: 'Identity information is handled at the protocol layer, not within A2A semantics'. Authorization, including authorization by the user's identity, which the specification lists as an option, is left to each implementation, and extensions are the hook for adding more. There is no token exchange, no actor claim and no on-behalf-of field. An enterprise that lets a partner's agent call its own over A2A has to bring the user's identity and the delegation record in its own tokens. (from "A2A 1.0 connects agents across companies and leaves out the person they act for")
- [BI-FIND-2025-0015](https://insights.bostonidentity.com/ref/BI-FIND-2025-0015): Measured against this 2025 checklist, the Model Context Protocol's own rules now cover one part of the identity advice and leave the rest to whoever deploys it. The paper asked for tokens restricted to one audience, short-lived and narrowly scoped, bound to the sender with DPoP or mutual TLS, issued just in time and per tool, with rich authorization requests for fine-grained grants. The July 2026 specification makes audience binding mandatory and forbids passing a token on. It does not require sender binding, per-tool grants or just-in-time issuance, and authorization itself remains optional. A team that reads the specification as a security baseline gets the first of those and none of the others. (from "An early MCP security checklist was never tested, and the protocol has since adopted only part of it")
- [BI-FIND-2026-0316](https://insights.bostonidentity.com/ref/BI-FIND-2026-0316): An OAuth working-group draft lets a workload authenticate to an authorization server with the identity its platform issued, in place of a stored secret. It covers three forms of SPIFFE credential: a signed token presented under a new assertion type, a certificate presented over mutual TLS, and a key-bound workload token with a proof of possession. A server must advertise which it accepts and support at least one. This is the missing piece between workload identity and OAuth that speakers in this corpus have been calling duct tape, now on the standards track. One implementation is listed, Keycloak, in preview, for the first of the three forms. (from "A draft lets a workload sign in to OAuth with its SPIFFE identity, not a secret; one preview supports part of it")
- [BI-FIND-2026-0517](https://insights.bostonidentity.com/ref/BI-FIND-2026-0517): The profile adds little on its own. Hostname validation under RFC 9525 stays exactly as it is when a client connects by DNS name; the workload identifier rides as an extra identity in a URI subject alternative name, placed and counted by reference to the WIMSE credentials draft; and authorization "MUST NOT" evaluate the identifier's path without its trust domain and trust anchor. Trust anchors are simply "configured for the trust domain", with no bundle distribution, and revocation and certificate lifetime get one SHOULD paragraph with no numbers, CRL or OCSP. AI agents are not mentioned. (from "The IETF's workload mutual-TLS profile leaves the certificate, trust anchors and revocation to other documents")
- [BI-FIND-2026-0180](https://insights.bostonidentity.com/ref/BI-FIND-2026-0180): The draft names the gateway problem our corpus keeps circling and puts the fix at a different layer. Mutual TLS gives an agent 'strong channel binding and cryptographic proof of control over the agent's private key', and it breaks at every proxy, gateway and service mesh that terminates the connection, which is where enterprises put their agent gateways. So authentication moves to the application layer: a Workload Proof Token, 'a signed JSON Web Token that binds an agent's authentication to a specific message context', or an HTTP message signature, either of which survives an intermediary at the cost of needing short lifetimes and replay defences. Uber already chose the application layer by putting token exchange in its SDK rather than trusting the mesh; Sierra's proxy is the intermediary this section is about. Whether a gateway can carry the chain remains open; what the draft settles is that the channel cannot. (from "Six rival vendors wrote the agent-identity draft the IETF just adopted, and it invents nothing")
- [BI-FIND-2026-0518](https://insights.bostonidentity.com/ref/BI-FIND-2026-0518): Mutual TLS proves the identity only as far as the TLS connection reaches. Section 5 tells deployments whose traffic crosses a TLS-terminating proxy to add an application-layer WIMSE mechanism on top, without naming one; the working group's HTTP-signature profile is built around exactly that proxy, so we read that profile as the expected companion to this one. (from "The IETF's workload mutual-TLS profile leaves the certificate, trust anchors and revocation to other documents")

---

© 2026 Boston Identity LLC. All rights reserved. Published by Boston Identity LLC.
Quote up to 100 words with the credit "Boston Identity, IAM Insights" and a link to https://insights.bostonidentity.com/glossary/mtls. Claim numbers may be cited freely. Training, fine-tuning and text-and-data-mining use of this page is permitted.
Terms: https://insights.bostonidentity.com/terms · How to cite: https://insights.bostonidentity.com/cite
