Java SSL客户端Socket配置：如何实现与Python一致的消息传输？

问题概述 #

我需要用SSL封装TCP应用层数据，向TLS 1.2版本的服务器传输数据。Python实现完全正常，但Java端遇到两个核心问题：

• 最初使用HandshakeCompletedListener时，SSL握手成功，但服务器始终收不到消息；
• 去掉监听器后，只有关闭Socket时服务器才会收到数据，且OutputStream.flush()方法未生效，两次发送的内容被合并成一个字符串。

已在Windows证书注册表中安装了正确的信任证书，各实现代码如下：

Python 实现代码 #

import socket
import ssl

HOST, PORT = 'server.com', 8000

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#sock.settimeout(10)

wrappedSocket = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_TLSv1_2)#, ciphers="ADH-AES256-SHA")

# CONNECT AND PRINT REPLY
wrappedSocket.connect((HOST, PORT))

wrappedSocket.send(b"Hello")

wrappedSocket.close()

最初的Java实现（存在问题） #

...

String[] protocols = new String[]{"TLSv1.2"};
SSLSocketFactory factory = (SSLSocketFactory)SSLSocketFactory.getDefault();
SSLSocket socket = (SSLSocket)factory.createSocket("server.com", 8000);
socket.setEnabledProtocols(protocols);
socket.addHandshakeCompletedListener(new HandShakeListener(socket));
socket.startHandshake();

...

class HandShakeListener implements HandshakeCompletedListener{
             
     SSLSocket socket;
             
     public HandShakeListener(SSLSocket socket) {
          this.socket = socket;
                
     }

     @Override
     public void handshakeCompleted(HandshakeCompletedEvent arg0) {
          System.out.println("Handshake Completed");

          PrintWriter out;
      try {
           out = new PrintWriter(
                      new BufferedWriter(
                       new OutputStreamWriter(
                        socket.getOutputStream())));
      } catch (IOException e1) {
        e1.printStackTrace();
        return;
      }
          
          out.println("Hello from Java");
      System.out.println("Sending message");
      out.println();
      out.flush();
          out.close();
     }
}

使用JVM参数：-Djavax.net.debug=all -Djavax.net.ssl.trustStoreType=WINDOWS-ROOT，调试信息显示握手成功且数据已写入，但服务器未收到消息。

调整后的Java实现（仍有问题） #

// Create an SSLContext
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, null, null);
SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

// Connect to the server
SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket("server.com", 8000); // Replace with your target server and port
sslSocket.setEnabledCipherSuites(sslSocketFactory.getSupportedCipherSuites());
sslSocket.setTcpNoDelay(true);

// Perform SSL handshake
sslSocket.startHandshake();

// Send data to server
OutputStream outputStream = sslSocket.getOutputStream();
String message = "This is a test message";
outputStream.write(message.getBytes());
outputStream.flush();

// Send more data to server
String additionalMessage = "This is an additional message";
outputStream.write(additionalMessage.getBytes());
outputStream.flush();

// Close the SSL socket when done
sslSocket.close();

行为差异原因分析 #

1. Python的send行为：
   Python的ssl.wrap_socket返回的Socket调用send()时，会直接将数据写入底层TCP缓冲区，且默认会触发TCP发送（除非系统缓冲区已满）。调用close()时会发送FIN包，服务器能感知到数据传输结束。

2. Java的缓冲与SSL层特性：

   • 最初的监听器实现中，嵌套的BufferedWriter会在应用层缓存数据，即使调用flush()，如果缓冲未填满或没有触发刷新条件（比如换行符），数据会滞留在应用层；同时过早关闭PrintWriter可能导致数据未完全推送到SSL层就被终止。
   • 调整后的代码中，Java的SSLSocket内部有自己的TLS记录缓冲，flush()仅刷新应用层到SSL层的缓冲，但SSL层为了传输优化（合并TLS记录减少开销），可能会延迟发送直到缓冲区满或连接关闭。setTcpNoDelay(true)仅禁用TCP的Nagle算法（合并小TCP包），不影响SSL层的记录缓冲逻辑。

实现与Python一致效果的解决方案 #

方案1：简化输出流，强制SSL层立即发送 #

避免使用多层缓冲流，直接操作SSLSocket的输出流，确保flush()触发SSL层发送记录：

SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
sslContext.init(null, null, null);
SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket("server.com", 8000);
// 明确指定TLSv1.2协议，和Python一致
sslSocket.setEnabledProtocols(new String[]{"TLSv1.2"});
sslSocket.setTcpNoDelay(true);

sslSocket.startHandshake();

OutputStream outputStream = sslSocket.getOutputStream();
// 发送第一条消息，和Python的b"Hello"字节一致
outputStream.write("Hello".getBytes());
// 强制SSL层立即发送当前记录
outputStream.flush();

// 如需发送多条独立消息，每条写完后都调用flush
outputStream.write("Additional message".getBytes());
outputStream.flush();

// 关闭连接，确保FIN包发送
sslSocket.close();

方案2：修复监听器版本的代码 #

如果需要保留HandshakeCompletedListener，需解决缓冲滞留问题：

...

String[] protocols = new String[]{"TLSv1.2"};
SSLSocketFactory factory = (SSLSocketFactory)SSLSocketFactory.getDefault();
SSLSocket socket = (SSLSocket)factory.createSocket("server.com", 8000);
socket.setEnabledProtocols(protocols);
socket.addHandshakeCompletedListener(new HandShakeListener(socket));
socket.startHandshake();

...

class HandShakeListener implements HandshakeCompletedListener{
    SSLSocket socket;
    
    public HandShakeListener(SSLSocket socket) {
        this.socket = socket;
    }

    @Override
    public void handshakeCompleted(HandshakeCompletedEvent arg0) {
        System.out.println("Handshake Completed");
        try {
            // 开启自动刷新的PrintWriter，避免应用层缓冲
            PrintWriter out = new PrintWriter(
                new OutputStreamWriter(socket.getOutputStream()), true);
            out.println("Hello from Java");
            System.out.println("Sending message");
            // 关闭Socket而非输出流，确保数据完整发送
            socket.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
}

关键注意事项 #

• 避免多余缓冲流：BufferedWriter、不带自动刷新的PrintWriter会在应用层缓存数据，导致flush()无法立即将数据推送到SSL层；
• SSL层的flush()作用：OutputStream.flush()会触发SSL层将当前缓冲的TLS记录发送，而非等待缓冲区填满；
• 应用层消息边界：TCP是字节流协议，Python的send()也可能被底层合并发送。如果需要服务器识别独立消息，需在应用层定义分隔规则（比如换行符、长度前缀），而非依赖TCP包边界。

内容的提问来源于stack exchange，提问作者BlindToMLAgainstTheWorld