（SSL隧道）javax.net.SSL.SSLException:无法识别的SSL消息，纯文本连接？
我用了一个模板来写这篇文章。但它仅适用于HTTPS连接。我的任务是读取和编辑通过隧道的数据。我试图通过SSLServerSocketFactory对其进行解密。但是我遇到了这个错误 我在keytool的帮助下创建了一个密钥：（SSL隧道）javax.net.SSL.SSLException:无法识别的SSL消息，纯文本连接？,java,sockets,https,sslhandshakeexception,sslsocketfactory,Java,Sockets,Https,Sslhandshakeexception,Sslsocketfactory,我用了一个模板来写这篇文章。但它仅适用于HTTPS连接。我的任务是读取和编辑通过隧道的数据。我试图通过SSLServerSocketFactory对其进行解密。但是我遇到了这个错误 我在keytool的帮助下创建了一个密钥： keytool -genkeypair -dname "cn=Mark Jones, ou=JavaSoft, o=Sun, c=US" -alias business -keypass kpi135 -keystore mySrvKeystore2 -storepass
keytool -genkeypair -dname "cn=Mark Jones, ou=JavaSoft, o=Sun, c=US" -alias business -keypass kpi135 -keystore mySrvKeystore2 -storepass ab987c -validity 365
客户端[请求]>myserver测试（本地主机）>互联网>myserver测试（本地主机）>客户端[响应]
package sample;
import javax.net.ssl.SSLServerSocketFactory;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ServerTest extends Thread {
Boolean stateSSL = false; // whether the socket is created with SSL
Integer port = 9798;
public static void main(String[] args) {
(new Server()).run();
}
public ServerTest() {
super("ServerTest Thread");
}
public ServerSocket createSLLSocket() {
try {
// comment block for create non-ssl connection
// and uncomment return null;
System.setProperty("javax.net.ssl.trustStore", "D:\\OnlyTemp\\mySrvKeystore2");
System.setProperty("javax.net.ssl.trustStorePassword", "ab987c");
SSLServerSocketFactory sslserversocketfactory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
ServerSocket sslserversocket = sslserversocketfactory.createServerSocket(port);
ServerSocket acceptSocket = sslserversocket;
System.out.println("++ created [with] ssl server");
return acceptSocket;
//return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public void run() {
System.out.println("++ server ServerTest run ");
try {
Socket acceptSocket = null;
ServerSocket serverSSLSocket = createSLLSocket();
ServerSocket serverSocket = null;
if (serverSSLSocket != null) {
stateSSL = true;
} else {
System.out.println("-- created [without] ssl server");
serverSocket = new ServerSocket(port);
stateSSL = false;
}
if (stateSSL == false) {
System.out.println("-- server [stateSSL] false");
try {
while ((acceptSocket = serverSocket.accept()) != null) {
(new Handler(acceptSocket, stateSSL)).start();
}
} catch (Exception e) {
e.printStackTrace(); // TODO: implement catch
}
} else {
try {
while ((acceptSocket = serverSSLSocket.accept()) != null) {
(new Handler(acceptSocket, stateSSL)).start();
}
} catch (Exception e) {
e.printStackTrace(); // TODO: implement catch
}
}
} catch (IOException e) {
e.printStackTrace(); // TODO: implement catch
return;
}
}
public static class Handler extends Thread {
public static final Pattern CONNECT_PATTERN = Pattern.compile("CONNECT (.+):(.+) HTTP/(1\\.[01])",
Pattern.CASE_INSENSITIVE);
private final Socket clientSocket;
private final Boolean stateSSL;
private boolean previousWasR = false;
public Handler(Socket clientSocket, Boolean stateSSL) {
this.clientSocket = clientSocket;
this.stateSSL = stateSSL;
}
@Override
public void run() {
try {
String request = readLine(clientSocket);
System.out.println(request);
Matcher matcher = CONNECT_PATTERN.matcher(request);
if (matcher.matches()) {
String header;
do {
header = readLine(clientSocket);
}
while (!"".equals(header));
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(clientSocket.getOutputStream(),
"ISO-8859-1");
final Socket forwardSocket;
try {
forwardSocket = new Socket(matcher.group(1), Integer.parseInt(matcher.group(2)));
System.out.println(forwardSocket);
} catch (IOException | NumberFormatException e) {
e.printStackTrace(); // TODO: implement catch
outputStreamWriter.write("HTTP/" + matcher.group(3) + " 502 Bad Gateway\r\n");
outputStreamWriter.write("Proxy-agent: Simple/0.1\r\n");
outputStreamWriter.write("\r\n");
outputStreamWriter.flush();
return;
}
try {
outputStreamWriter.write("HTTP/" + matcher.group(3) + " 200 Connection established\r\n");
outputStreamWriter.write("Proxy-agent: Simple/0.1\r\n");
outputStreamWriter.write("\r\n");
outputStreamWriter.flush();
Thread remoteToClient = new Thread() {
@Override
public void run() {
forwardData(forwardSocket, clientSocket);
}
};
remoteToClient.start();
try {
if (previousWasR) {
int read = clientSocket.getInputStream().read();
if (read != -1) {
if (read != '\n') {
forwardSocket.getOutputStream().write(read);
}
forwardData(clientSocket, forwardSocket);
} else {
if (!forwardSocket.isOutputShutdown()) {
forwardSocket.shutdownOutput();
}
if (!clientSocket.isInputShutdown()) {
clientSocket.shutdownInput();
}
}
} else {
forwardData(clientSocket, forwardSocket);
}
} finally {
try {
remoteToClient.join();
} catch (InterruptedException e) {
e.printStackTrace(); // TODO: implement catch
}
}
} finally {
forwardSocket.close();
}
}
} catch (IOException e) {
// hide temp
e.printStackTrace(); // TODO: implement catch
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace(); // TODO: implement catch
}
}
}
private static void forwardData(Socket inputSocket, Socket outputSocket) {
try {
InputStream inputStream = inputSocket.getInputStream();
try {
OutputStream outputStream = outputSocket.getOutputStream();
try {
byte[] buffer = new byte[4096];
int read;
do {
read = inputStream.read(buffer);
if (read > 0) {
outputStream.write(buffer, 0, read);
if (inputStream.available() < 1) {
outputStream.flush();
}
}
}
while (read >= 0);
} finally {
if (!outputSocket.isOutputShutdown()) {
outputSocket.shutdownOutput();
}
}
} finally {
if (!inputSocket.isInputShutdown()) {
inputSocket.shutdownInput();
}
}
} catch (IOException e) {
e.printStackTrace(); // TODO: implement catch
}
}
private String readLine(Socket socket) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
int next;
readerLoop:
while ((next = socket.getInputStream().read()) != -1) {
if (previousWasR && next == '\n') {
previousWasR = false;
continue;
}
previousWasR = false;
switch (next) {
case '\r':
previousWasR = true;
break readerLoop;
case '\n':
break readerLoop;
default:
byteArrayOutputStream.write(next);
break;
}
}
return byteArrayOutputStream.toString("ISO-8859-1");
}
}
}
包装样品；
导入javax.net.ssl.SSLServerSocketFactory；
导入java.io.*；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类ServerTest扩展了线程{
Boolean stateSSL=false；//套接字是否使用SSL创建
整数端口=9798；
公共静态void main（字符串[]args）{
（新服务器（））.run（）；
}
公共服务器测试（）{
超级（“服务器测试线程”）；
}
公共服务器套接字createSLLSocket（）{
试一试{
//用于创建非ssl连接的注释块
//和取消注释返回null；
System.setProperty（“javax.net.ssl.trustStore”，“D:\\OnlyTemp\\mySrvKeystore2”）；
setProperty（“javax.net.ssl.trustStorePassword”、“ab987c”）；
SSLServerSocketFactory SSLServerSocketFactory=（SSLServerSocketFactory）SSLServerSocketFactory.getDefault（）；
ServerSocket sslserversocket=sslserversocketfactory.createServerSocket（端口）；
ServerSocket acceptSocket=sslserversocket；
System.out.println（“++使用ssl服务器创建”）；
返回接受套接字；
//返回null；
}捕获（例外e）{
e、 printStackTrace（）；
返回null；
}
}
@凌驾
公开募捐{
System.out.println（“++服务器测试运行”）；
试一试{
Socket-acceptSocket=null；
ServerSocket serverSSLSocket=createSLLSocket（）；
ServerSocket ServerSocket=null；
if（serverSSLSocket！=null）{
statesl=true；
}否则{
System.out.println（“--created[without]ssl server”）；
serverSocket=新的serverSocket（端口）；
statesl=false；
}
if（stateSSL==false）{
System.out.println（“--server[statesll]false”）；
试一试{
而（（acceptSocket=serverSocket.accept（））！=null）{
（新处理程序（acceptSocket，stateSSL））.start（）；
}
}捕获（例外e）{
e、 printStackTrace（）；//TODO:实现捕获
}
}否则{
试一试{
而（（acceptSocket=serverSSLSocket.accept（））！=null）{
（新处理程序（acceptSocket，stateSSL））.start（）；
}
}捕获（例外e）{
e、 printStackTrace（）；//TODO:实现捕获
}
}
}捕获（IOE异常）{
e、 printStackTrace（）；//TODO:实现捕获
返回；
}
}
公共静态类处理程序扩展线程{
公共静态最终模式CONNECT_Pattern=Pattern.compile（“CONNECT（++）：（++）HTTP/（1\\[01]），
模式（不区分大小写）；
私有最终套接字clientSocket；
私有最终布尔状态SSL；
私有布尔值previousWasR=false；
公共处理程序（套接字clientSocket，布尔状态SSL）{
this.clientSocket=clientSocket；
this.statesl=statesl；
}
@凌驾
公开募捐{
试一试{
字符串请求=readLine（clientSocket）；
系统输出打印项次（请求）；
Matcher Matcher=CONNECT\u PATTERN.Matcher（请求）；
if（matcher.matches（））{
字符串头；
做{
header=readLine（clientSocket）；
}
而（！“”.equals（header））；
OutputStreamWriter OutputStreamWriter=新的OutputStreamWriter（clientSocket.getOutputStream（），
“ISO-8859-1”）；
最终插座和前插座；
试一试{
forwardSocket=新套接字（matcher.group（1），Integer.parseInt（matcher.group（2））；
System.out.println（forwardSocket）；
}捕获（IOException | NumberFormatException e）{
e、 printStackTrace（）；//TODO:实现捕获
outputStreamWriter.write（“HTTP/”+matcher.group（3）+“502坏网关\r\n”）；
outputStreamWriter.write（“代理：简单/0.1\r\n”）；
outputStreamWriter.write（“\r\n”）；
outputStreamWriter.flush（）；
返回；
}
试一试{
outputStreamWriter.write（“HTTP/”+matcher.group（3）+“200连接已建立\r\n”）；
outputStreamWriter.write（“代理：简单/0.1\r\n”）；
outputStreamWriter.write（“\r\n”）；
outputStreamWriter.flush（）；
线程remoteToClient=新线程（）{
@凌驾
公开募捐{