From 54b99ad05b028e656ab98dbce592eac5c1619901 Mon Sep 17 00:00:00 2001 From: HTHou Date: Thu, 19 Nov 2026 14:51:40 +0800 Subject: [PATCH] THRIFT-6564: Add configurable TLS protocols to Java transports Client: java Apply an explicitly configured protocol list to Java SSL server sockets, blocking client sockets, and nonblocking client engines. Release a listener or blocking socket if configuration fails and configure the client engine before opening its channel. Generated-by: OpenAI Codex (GPT-6) --- .../transport/TNonblockingSSLSocket.java | 38 +++- .../transport/TSSLTransportFactory.java | 67 +++++-- .../thrift/async/TestTAsyncSSLProgress.java | 41 +++++ .../TestTSSLTransportFactoryProtocols.java | 173 ++++++++++++++++++ 4 files changed, 302 insertions(+), 17 deletions(-) create mode 100644 lib/java/src/test/java/org/apache/thrift/transport/TestTSSLTransportFactoryProtocols.java diff --git a/lib/java/src/main/java/org/apache/thrift/transport/TNonblockingSSLSocket.java b/lib/java/src/main/java/org/apache/thrift/transport/TNonblockingSSLSocket.java index 1872d2c2718..1ca806e5432 100644 --- a/lib/java/src/main/java/org/apache/thrift/transport/TNonblockingSSLSocket.java +++ b/lib/java/src/main/java/org/apache/thrift/transport/TNonblockingSSLSocket.java @@ -61,12 +61,19 @@ public class TNonblockingSSLSocket extends TNonblockingSocket implements SocketA protected TNonblockingSSLSocket(String host, int port, int timeout, SSLContext sslContext) throws IOException, TTransportException { + this(host, port, timeout, sslContext, null); + } + + TNonblockingSSLSocket( + String host, int port, int timeout, SSLContext sslContext, String[] enabledProtocols) + throws IOException, TTransportException { + this(host, port, timeout, createClientEngine(sslContext, host, port, enabledProtocols)); + } + + private TNonblockingSSLSocket(String host, int port, int timeout, SSLEngine sslEngine) + throws IOException, TTransportException { super(host, port, timeout); - sslEngine_ = sslContext.createSSLEngine(host, port); - sslEngine_.setUseClientMode(true); - SSLParameters sslParams = sslEngine_.getSSLParameters(); - sslParams.setEndpointIdentificationAlgorithm("HTTPS"); - sslEngine_.setSSLParameters(sslParams); + sslEngine_ = sslEngine; int appBufferSize = sslEngine_.getSession().getApplicationBufferSize(); int netBufferSize = sslEngine_.getSession().getPacketBufferSize(); @@ -77,6 +84,27 @@ protected TNonblockingSSLSocket(String host, int port, int timeout, SSLContext s isHandshakeCompleted = false; } + private static SSLEngine createClientEngine( + SSLContext sslContext, String host, int port, String[] enabledProtocols) + throws TTransportException { + SSLEngine engine = sslContext.createSSLEngine(host, port); + engine.setUseClientMode(true); + SSLParameters sslParams = engine.getSSLParameters(); + sslParams.setEndpointIdentificationAlgorithm("HTTPS"); + engine.setSSLParameters(sslParams); + if (enabledProtocols != null) { + try { + engine.setEnabledProtocols(enabledProtocols); + } catch (IllegalArgumentException e) { + throw new TTransportException( + TTransportException.NOT_OPEN, + "Could not configure TLS protocols for " + host + ":" + port, + e); + } + } + return engine; + } + /** {@inheritDoc} */ @Override public SelectionKey registerSelector(Selector selector, int interests) throws IOException { diff --git a/lib/java/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java b/lib/java/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java index 9a08b19b74d..4d30dd6e684 100644 --- a/lib/java/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java +++ b/lib/java/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java @@ -19,6 +19,7 @@ package org.apache.thrift.transport; +import java.io.Closeable; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; @@ -124,20 +125,27 @@ private static TServerSocket createServer( InetAddress ifAddress, TSSLTransportParameters params) throws TTransportException { + SSLServerSocket serverSocket = null; try { - SSLServerSocket serverSocket = - (SSLServerSocket) factory.createServerSocket(port, 100, ifAddress); + serverSocket = (SSLServerSocket) factory.createServerSocket(port, 100, ifAddress); serverSocket.setSoTimeout(timeout); serverSocket.setNeedClientAuth(clientAuth); - if (params != null && params.cipherSuites != null) { - serverSocket.setEnabledCipherSuites(params.cipherSuites); + if (params != null) { + if (params.cipherSuites != null) { + serverSocket.setEnabledCipherSuites(params.cipherSuites); + } + String[] enabledProtocols = params.enabledProtocols; + if (enabledProtocols != null) { + serverSocket.setEnabledProtocols(enabledProtocols); + } } return new TServerSocket( new TServerSocket.ServerSocketTransportArgs() .serverSocket(serverSocket) .clientTimeout(timeout)); } catch (Exception e) { - throw new TTransportException("Could not bind to port " + port, e); + closeSocketOnFailure(serverSocket, e); + throw new TTransportException("Could not create SSL server socket on port " + port, e); } } @@ -154,7 +162,7 @@ private static TServerSocket createServer( public static TSocket getClientSocket(String host, int port, int timeout) throws TTransportException { SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault(); - return createClient(factory, host, port, timeout); + return createClient(factory, host, port, timeout, null); } /** @@ -190,7 +198,7 @@ public static TSocket getClientSocket( } SSLContext ctx = createSSLContext(params); - return createClient(ctx.getSocketFactory(), host, port, timeout); + return createClient(ctx.getSocketFactory(), host, port, timeout, params.enabledProtocols); } /** @@ -246,7 +254,7 @@ public static TNonblockingSocket getNonblockingClientSocket( "Either one of the KeyStore or TrustStore must be set for SSLTransportParameters"); } SSLContext ctx = createSSLContext(params); - return new TNonblockingSSLSocket(host, port, timeout, ctx); + return new TNonblockingSSLSocket(host, port, timeout, ctx, params.enabledProtocols); } private static SSLContext createSSLContext(TSSLTransportParameters params) @@ -339,23 +347,41 @@ private static InputStream getStoreAsStream(String store) throws IOException { } } - private static TSocket createClient(SSLSocketFactory factory, String host, int port, int timeout) + private static TSocket createClient( + SSLSocketFactory factory, String host, int port, int timeout, String[] enabledProtocols) throws TTransportException { + SSLSocket socket = null; try { - SSLSocket socket = (SSLSocket) factory.createSocket(host, port); + socket = (SSLSocket) factory.createSocket(host, port); socket.setSoTimeout(timeout); SSLParameters sslParams = socket.getSSLParameters(); sslParams.setEndpointIdentificationAlgorithm("HTTPS"); socket.setSSLParameters(sslParams); + if (enabledProtocols != null) { + socket.setEnabledProtocols(enabledProtocols); + } return new TSocket(socket); } catch (TTransportException tte) { + closeSocketOnFailure(socket, tte); throw tte; } catch (Exception e) { + closeSocketOnFailure(socket, e); throw new TTransportException( TTransportException.NOT_OPEN, "Could not connect to " + host + " on port " + port, e); } } + private static void closeSocketOnFailure(Closeable socket, Exception failure) { + if (socket == null) { + return; + } + try { + socket.close(); + } catch (IOException closeError) { + failure.addSuppressed(closeError); + } + } + /** A Class to hold all the SSL parameters */ public static class TSSLTransportParameters { protected String protocol = "TLS"; @@ -374,12 +400,14 @@ public static class TSSLTransportParameters { protected boolean isKeyStoreSet = false; protected boolean isTrustStoreSet = false; + private String[] enabledProtocols; + public TSSLTransportParameters() {} /** * Create parameters specifying the protocol and cipher suites * - * @param protocol The specific protocol (TLS/SSL) can be specified with versions + * @param protocol the algorithm passed to {@link SSLContext#getInstance(String)} * @param cipherSuites */ public TSSLTransportParameters(String protocol, String[] cipherSuites) { @@ -390,7 +418,7 @@ public TSSLTransportParameters(String protocol, String[] cipherSuites) { * Create parameters specifying the protocol, cipher suites and if client authentication is * required * - * @param protocol The specific protocol (TLS/SSL) can be specified with versions + * @param protocol the algorithm passed to {@link SSLContext#getInstance(String)} * @param cipherSuites * @param clientAuth */ @@ -403,6 +431,21 @@ public TSSLTransportParameters(String protocol, String[] cipherSuites, boolean c this.clientAuth = clientAuth; } + /** + * Sets the protocols enabled on server sockets and on synchronous and asynchronous client + * transports created with these parameters. + * + * @param protocols protocol names supported by the JSSE provider, or {@code null} to use the + * provider defaults + * @throws IllegalArgumentException if the array is empty + */ + public void setEnabledProtocols(String... protocols) { + if (protocols != null && protocols.length == 0) { + throw new IllegalArgumentException("At least one protocol must be specified"); + } + enabledProtocols = protocols == null ? null : Arrays.copyOf(protocols, protocols.length); + } + /** * Set the keystore, password, certificate type and the store type * diff --git a/lib/java/src/test/java/org/apache/thrift/async/TestTAsyncSSLProgress.java b/lib/java/src/test/java/org/apache/thrift/async/TestTAsyncSSLProgress.java index 514ac31fe6b..330cf28775e 100644 --- a/lib/java/src/test/java/org/apache/thrift/async/TestTAsyncSSLProgress.java +++ b/lib/java/src/test/java/org/apache/thrift/async/TestTAsyncSSLProgress.java @@ -35,6 +35,7 @@ import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; +import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; import java.nio.ByteBuffer; @@ -64,6 +65,7 @@ import org.apache.thrift.transport.TNonblockingSocket; import org.apache.thrift.transport.TNonblockingTransport; import org.apache.thrift.transport.TSSLTransportFactory; +import org.apache.thrift.transport.TSSLTransportFactory.TSSLTransportParameters; import org.junit.jupiter.api.Test; public class TestTAsyncSSLProgress { @@ -87,6 +89,45 @@ public void testSunJsseTls13TaskDoesNotDelayTimeoutOrOtherCalls() throws Excepti checkTaskTimeout("TLSv1.3"); } + @Test + public void testNonblockingClientNegotiatesConfiguredProtocol() throws Exception { + TSSLTransportParameters params = new TSSLTransportParameters(); + params.setTrustStore( + System.getProperty("javax.net.ssl.trustStore"), + System.getProperty("javax.net.ssl.trustStorePassword")); + params.setEnabledProtocols("TLSv1.2"); + try (SSLServerSocket listener = + (SSLServerSocket) + SSLContext.getDefault() + .getServerSocketFactory() + .createServerSocket(0, 1, InetAddress.getByName("localhost")); + TNonblockingTransport transport = + TSSLTransportFactory.getNonblockingClientSocket( + "localhost", listener.getLocalPort(), 0, params)) { + listener.setEnabledProtocols(new String[] {"TLSv1.3", "TLSv1.2"}); + listener.setSoTimeout(5000); + CompletableFuture serverDone = + serve( + listener, + socket -> { + readRequest(socket); + DataOutputStream output = new DataOutputStream(socket.getOutputStream()); + output.writeInt(1); + output.writeByte(42); + output.flush(); + assertEquals("TLSv1.2", ((SSLSocket) socket).getSession().getProtocol()); + }); + + TAsyncClientManager manager = new TAsyncClientManager(); + try { + assertArrayEquals(new byte[] {42}, call(manager, transport, 5000).get(6, TimeUnit.SECONDS)); + serverDone.get(5, TimeUnit.SECONDS); + } finally { + manager.stop(); + } + } + } + private void checkTaskTimeout(String protocol) throws Exception { assumeTrue(Security.getProvider("SunJSSE") != null); assumeTrue( diff --git a/lib/java/src/test/java/org/apache/thrift/transport/TestTSSLTransportFactoryProtocols.java b/lib/java/src/test/java/org/apache/thrift/transport/TestTSSLTransportFactoryProtocols.java new file mode 100644 index 00000000000..4d58599baa1 --- /dev/null +++ b/lib/java/src/test/java/org/apache/thrift/transport/TestTSSLTransportFactoryProtocols.java @@ -0,0 +1,173 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.thrift.transport; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.net.InetAddress; +import java.net.ServerSocket; +import java.net.Socket; +import java.util.Arrays; +import java.util.HashSet; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLServerSocket; +import javax.net.ssl.SSLSocket; +import org.apache.thrift.transport.TSSLTransportFactory.TSSLTransportParameters; +import org.junit.jupiter.api.Test; + +public class TestTSSLTransportFactoryProtocols { + private static final InetAddress LOOPBACK = InetAddress.getLoopbackAddress(); + + @Test + public void testUsesConfiguredServerProtocols() throws Exception { + TSSLTransportParameters params = serverParameters("TLS"); + String[] protocols = {"TLSv1.2"}; + params.setEnabledProtocols(protocols); + protocols[0] = "TLSv1.3"; + assertArrayEquals(new String[] {"TLSv1.2"}, enabledServerProtocols(params)); + + params.setEnabledProtocols("TLSv1.3", "TLSv1.2"); + assertEquals( + new HashSet<>(Arrays.asList("TLSv1.3", "TLSv1.2")), + new HashSet<>(Arrays.asList(enabledServerProtocols(params)))); + } + + @Test + public void testUsesContextDefaultsWhenServerProtocolsAreUnset() throws Exception { + SSLContext context = SSLContext.getInstance("TLSv1.2"); + context.init(null, null, null); + try (SSLServerSocket defaultSocket = + (SSLServerSocket) context.getServerSocketFactory().createServerSocket()) { + String[] defaultProtocols = defaultSocket.getEnabledProtocols(); + TSSLTransportParameters params = serverParameters("TLSv1.2"); + assertArrayEquals(defaultProtocols, enabledServerProtocols(params)); + + params.setEnabledProtocols("TLSv1.2"); + params.setEnabledProtocols((String[]) null); + assertArrayEquals(defaultProtocols, enabledServerProtocols(params)); + } + } + + @Test + public void testRejectsAnEmptyServerProtocolList() { + TSSLTransportParameters params = new TSSLTransportParameters(); + assertThrows(IllegalArgumentException.class, params::setEnabledProtocols); + } + + @Test + public void testClosesSocketWhenServerProtocolIsUnsupported() throws Exception { + int port; + try (ServerSocket socket = new ServerSocket(0, 1, LOOPBACK)) { + port = socket.getLocalPort(); + } + + TSSLTransportParameters params = serverParameters("TLS"); + params.setEnabledProtocols("unsupported-protocol"); + TTransportException failure = + assertThrows( + TTransportException.class, + () -> { + try (TServerSocket socket = + TSSLTransportFactory.getServerSocket(port, 0, LOOPBACK, params)) {} + }); + assertInstanceOf(IllegalArgumentException.class, failure.getCause()); + + try (ServerSocket socket = new ServerSocket(port, 1, LOOPBACK)) { + assertEquals(port, socket.getLocalPort()); + } + } + + @Test + public void testUsesConfiguredBlockingClientProtocols() throws Exception { + TSSLTransportParameters params = clientParameters(); + params.setEnabledProtocols("TLSv1.2"); + try (ServerSocket listener = new ServerSocket(0, 1, LOOPBACK); + TSocket client = + TSSLTransportFactory.getClientSocket( + LOOPBACK.getHostAddress(), listener.getLocalPort(), 0, params)) { + SSLSocket socket = (SSLSocket) client.getSocket(); + assertArrayEquals(new String[] {"TLSv1.2"}, socket.getEnabledProtocols()); + assertEquals("HTTPS", socket.getSSLParameters().getEndpointIdentificationAlgorithm()); + } + } + + @Test + public void testClosesBlockingClientSocketWhenProtocolIsUnsupported() throws Exception { + TSSLTransportParameters params = clientParameters(); + params.setEnabledProtocols("unsupported-protocol"); + try (ServerSocket listener = new ServerSocket(0, 1, LOOPBACK)) { + listener.setSoTimeout(5000); + TTransportException failure = + assertThrows( + TTransportException.class, + () -> + TSSLTransportFactory.getClientSocket( + LOOPBACK.getHostAddress(), listener.getLocalPort(), 0, params) + .close()); + assertInstanceOf(IllegalArgumentException.class, failure.getCause()); + + try (Socket peer = listener.accept()) { + peer.setSoTimeout(5000); + assertEquals(-1, peer.getInputStream().read()); + } + } + } + + @Test + public void testRejectsUnsupportedNonblockingClientProtocol() { + TSSLTransportParameters params = clientParameters(); + params.setEnabledProtocols("unsupported-protocol"); + TTransportException failure = + assertThrows( + TTransportException.class, + () -> + TSSLTransportFactory.getNonblockingClientSocket( + LOOPBACK.getHostAddress(), 0, 0, params) + .close()); + assertInstanceOf(IllegalArgumentException.class, failure.getCause()); + } + + private static TSSLTransportParameters clientParameters() { + TSSLTransportParameters params = new TSSLTransportParameters(); + params.setTrustStore( + System.getProperty("javax.net.ssl.trustStore"), + System.getProperty("javax.net.ssl.trustStorePassword")); + return params; + } + + private static TSSLTransportParameters serverParameters(String algorithm) { + TSSLTransportParameters params = new TSSLTransportParameters(algorithm, null); + params.setKeyStore( + System.getProperty("javax.net.ssl.keyStore"), + System.getProperty("javax.net.ssl.keyStorePassword")); + return params; + } + + private static String[] enabledServerProtocols(TSSLTransportParameters params) + throws TTransportException { + try (TServerSocket transport = TSSLTransportFactory.getServerSocket(0, 0, LOOPBACK, params)) { + SSLServerSocket socket = (SSLServerSocket) transport.getServerSocket(); + return socket.getEnabledProtocols(); + } + } +}