Code change:
with a certificate, a client presents its X.509 certificate RFC5280 and proves possession of the corresponding private key to a server when negotiating a TLS connection or the resumption of such a <del> connection.  In contemporary versions of TLS RFC8446 RFC5246 this requires that the client send the Certificate and CertificateVerify messages during the handshake and for the server to verify the </del> <ins> connection.  In contemporary versions of TLS TLS TLS1.2 this requires that the client send the Certificate and CertificateVerify messages during the handshake and for the server to verify the </ins> CertificateVerify and Finished messages. <del> HTTP/2 restricts TLS 1.2 renegotiation (RFC7540) and prohibits TLS </del> <ins> HTTP/2 restricts TLS 1.2 renegotiation (RFC9113) and prohibits TLS </ins> 1.3 post-handshake authentication RFC8740.  However, they are sometimes used to implement reactive client certificate <del> authentication in HTTP/1.1 RFC7230 where the server decides whether </del> <ins> authentication in HTTP/1.1 RFC9112 where the server decides whether </ins> to request a client certificate based on the HTTP request.  HTTP application data sent on such a connection after receipt and verification of the client certificate is also mutually-authenticated

Related discussion:
text: attempt NAME "simple alternative" in to say the chain is in the same order as it appears in TLS rather than copying the language from TLS
There's a bunch of text in the draft about putting the certificate chain in the right order. This tries to crib from TLS and ends up being somewhat tricky to get right as TLS has a bunch of carefully worded and - frankly - ambiguous rules. As a simple alternative, how about we just state that the certificates need to appear in the same order as the client sent them in TLS.
Makes sense. Will look at adjusting the text accordingly.
I think this is a bit more fundamental than just the order. It's really a question of whether this is a certificate path, or a pile of input certificates to run verification over. That is, either: The origin runs path building, taking the unordered/unverified pile of input certificates from the header, in TLS order. The proxy runs path building and passes the result in the header. The origin assumes a path has been built and is merely applying ACLs based on some aspect of the resulting path. A mismatch here could result in security issues. For instance, suppose the origin wants to only allow chains issued by intermediate certificate I1 to access . If the header means (1) but the origin expects (2), this ACL is trivially bypassable: Client has a certificate chain EE -> I2 -> CA. Client connects to proxy and sends {EE, I2, CA, I1}. (Or perhaps {EE, I2, I1, CA}. Or whatever else. Different verifiers are differently permissive about path-building. Perhaps it omits I2 altogether and the path-builder picks it up some other way.) Even if the proxy runs certificate verification, a path-building verifier will build the EE -> I2 -> CA path and just consider I1 as a random unused certificate. , per the TLS order rule, contains {EE, I2, CA, I1} Origin server checks this and concludes "aha, this was issued by I1 and can access the resource". Conversely, the semantics are (2), the proxy needs to have enough information to validate the certificate, up to a valid trust anchor for the application. If you all intended to punt that to the origin, that's a different protocol.