Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Conversation

chrisvest
Copy link
Member

Motivation:
If TLS is OPTIONAL then there won't always be a verified peer.
This means there will be no calls on the server TrustManager to check if the client is trusted.
That makes it look like a resumed session to the resumption controller.
But there won't be any verified peer on the session, and trying to get the peer certificates will throw an exception.

It's also a valid configuration to enable session tickets with TLSv1.2, and doing so makes a meaningful change to the SSLEngine behavior that we need to test for.

Modification:

  • Collect the OpenSSL parameterization code for SSLEngineTest.
  • Add tickets being enabled or not as a parameter.
  • Fix a test that did not anticipate the session ticket behavior.
  • Make the ResumptionController consider if the engine is in client mode, or if it requires client authentication, and only propagate SSLPeerUnverifiedException if so.
  • Make the ResumptionController swallow the SSLPeerUnverifiedException when client auth is OPTIONAL or NONE.
  • Add a test for this scenario.

Result:
We now have test coverage with TLSv1.2 session tickets.
The ResumableX509ExtendedTrustManager interface can now be used together with ClientAuth.OPTIONAL.

Motivation:
It's a valid configuration to enable session tickets with TLSv1.2, and doing so makes a meaningful change to the SSLEngine behavior that we need to test for.

Modification:
- Collect the OpenSSL parameterization code for SSLEngineTest.
- Add tickets being enabled or not as a parameter.
- Fix a test that did not anticipate the session ticket behavior.

Result:
We now have test coverage with TLSv1.2 session tickets.
Motivation:
If TLS is `OPTIONAL` then there won't always be a verified peer.
This means there will be no calls on the server `TrustManager` to check if the client is trusted.
That makes it look like a resumed session to the resumption controller.
But there won't be any verified peer on the session, and trying to get the peer certificates will throw an exception.

Modification:
- Make the `ResumptionController` consider if the engine is in client mode, or if it requires client authentication, and only propagate `SSLPeerUnverifiedException` if so.
- Make the `ResumptionController` swallow the `SSLPeerUnverifiedException` when client auth is OPTIONAL or NONE.
- Add a test for this scenario.

Result:
The `ResumableX509ExtendedTrustManager` interface can now be used together with `ClientAuth.OPTIONAL`.
@chrisvest chrisvest added this to the 4.1.115.Final milestone Oct 18, 2024
@chrisvest chrisvest force-pushed the 4.1-more-ssl-resume branch 4 times, most recently from 3c6b8bf to 12d973b Compare October 18, 2024 17:11
@chrisvest chrisvest force-pushed the 4.1-more-ssl-resume branch from 12d973b to 4ce9964 Compare October 18, 2024 17:16
@chrisvest
Copy link
Member Author

The extra testing makes the builds slower, particularly the BoringSSL builds, but that should be more than compensated for by #14405


SSLSession session = engine.getSession();
boolean valid = session.isValid();
if (valid && (engine.getUseClientMode() || engine.getNeedClientAuth() || engine.getWantClientAuth()) &&
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

can you add a comment clarifying the goal of this conditional?

getUseClientMode -> I assume this is to cover the case of "always do this on the client"

getNeedClientAuth || getWantClientAuth -> isn't the default treated by some engines as "want"? for example iirc openssl flavors will have the server request the client's certificate but if they don't return one it will succeed. so I'm just trying to understand if client/server need to be consistent and if not, why.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@Scottmitch I've added comments explaining the logic. Please take a look.

@chrisvest chrisvest merged commit dc356e8 into netty:4.1 Oct 22, 2024
16 of 17 checks passed
@chrisvest chrisvest deleted the 4.1-more-ssl-resume branch October 22, 2024 20:09
chrisvest added a commit that referenced this pull request Oct 22, 2024
…h session tickets (#14404)

Motivation:
If TLS is `OPTIONAL` then there won't always be a verified peer.
This means there will be no calls on the server `TrustManager` to check
if the client is trusted.
That makes it look like a resumed session to the resumption controller.
But there won't be any verified peer on the session, and trying to get
the peer certificates will throw an exception.

It's also a valid configuration to enable session tickets with TLSv1.2,
and doing so makes a meaningful change to the `SSLEngine` behavior that
we need to test for.

Modification:
- Collect the OpenSSL parameterization code for `SSLEngineTest`.
- Add tickets being enabled or not as a parameter.
- Fix a test that did not anticipate the session ticket behavior.
- Make the `ResumptionController` consider if the engine is in client
mode, or if it requires client authentication, and only propagate
`SSLPeerUnverifiedException` if so.
- Make the `ResumptionController` swallow the
`SSLPeerUnverifiedException` when client auth is OPTIONAL or NONE.
- Add a test for this scenario.

Result:
We now have test coverage with TLSv1.2 session tickets.
The `ResumableX509ExtendedTrustManager` interface can now be used
together with `ClientAuth.OPTIONAL`.
chrisvest added a commit to chrisvest/netty that referenced this pull request Oct 22, 2024
…h session tickets (netty#14404)

Motivation:
If TLS is `OPTIONAL` then there won't always be a verified peer.
This means there will be no calls on the server `TrustManager` to check
if the client is trusted.
That makes it look like a resumed session to the resumption controller.
But there won't be any verified peer on the session, and trying to get
the peer certificates will throw an exception.

It's also a valid configuration to enable session tickets with TLSv1.2,
and doing so makes a meaningful change to the `SSLEngine` behavior that
we need to test for.

Modification:
- Collect the OpenSSL parameterization code for `SSLEngineTest`.
- Add tickets being enabled or not as a parameter.
- Fix a test that did not anticipate the session ticket behavior.
- Make the `ResumptionController` consider if the engine is in client
mode, or if it requires client authentication, and only propagate
`SSLPeerUnverifiedException` if so.
- Make the `ResumptionController` swallow the
`SSLPeerUnverifiedException` when client auth is OPTIONAL or NONE.
- Add a test for this scenario.

Result:
We now have test coverage with TLSv1.2 session tickets.
The `ResumableX509ExtendedTrustManager` interface can now be used
together with `ClientAuth.OPTIONAL`.
Copy link
Member

@normanmaurer normanmaurer left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Late LGTM

chrisvest added a commit that referenced this pull request Oct 23, 2024
Motivation:
Some trust manager implementations produce custom user principals and
store them in the SSLSession. Resumed TLS sessions, however, don't
always recover the stored contents. For instance, with TLSv1.3 stateless
session resumption, our TLS implementations only store the peer
certificate chain (or even just the leaf cert) in the session ticket. In
such a case, the trust manager would like to be notified of the
resumption, so that the peer principal can be recreated and stored in
the session once again.

Modification:
Add a ResumableX509ExtendedTrustManager interface, with callbacks for
resumed client and server sessions. Add infrastructure (the
ResumptionController) to detect session resumption in an SSLEngine
implementation agnostic way; if a TLS handshake completed without any
calls to the TrustManager, then we've made a "stateless resumption"
(hand-wave details) and should call the appropriate resume method. The
JDK APIs don't provide a method to reliably discern if a session has
been resumed, so we instead detect if the trust manager was called
during the handshake. We do this by wrapping user-supplied trust
managers that implement the ResumableX509ExtendedTrustManager interface.
The wrapper will monitor calls to the trust manager and register the
relevant SSLEngine in the controller — the engine is the object that the
trust manager and the SslHandler both have access to, which reliably
identifies the specific TLS session. Before finished the handshake, the
SslHandler queries the ResumptionController to see if the trust manager
has already been called, or if it needs to be notified of resumption.
Since it's possible that the peer certificates have expired since the
initial session, the trust manager gets another change to throw
CertificateException.

Result:
Handlers that expect to find user principals in the authenticated
SSLSessions no longer find empty sessions, provided they use a trust
manager that correctly implements ResumableX509ExtendedTrustManager.

This is a forward port of #14358,
#14404, and
#14411
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

3 participants