问题 Java https代理（使用https.proxyPort和https.proxyHost）

我正在制作一个依赖于设置的Java应用程序 http.proxyPort 和 http.proxyHost。有两个过程：一个是常规程序，另一个是代理。我有一个简单的套接字监听器运行 http.proxyPort （我控制）。这很简单

while (true) {
    try {
    Socket connection = server.accept();

    Handler handler = new Handler(connection);
    handler.start();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

所以每当“进程1”发出一个http请求时 - 就像

URL yahoo = new URL("http://www.google.ca/");
URLConnection yc = yahoo.openConnection();
System.out.println(yc.getClass().getName());
BufferedReader in = new BufferedReader(new InputStreamReader(yc.getInputStream()));

它通过代理。现在如果客户端使用HTTPS协议怎么办？喜欢改用 https://google.ca？有一处房产 https.proxyPort 和 https.proxyHost但是，如果没有运气，我几乎已经尝试了几个月（开关，不太重要）。我已经阅读了一堆线程（我会在最后列出一些，所以你知道我已经做了一些事情）。

我迄今为止最接近的尝试：服务器

try {
    System.setProperty("javax.net.ssl.keyStore", "test.jks");
    System.setProperty("javax.net.ssl.keyStorePassword", "2520xe");

    SSLServerSocketFactory sslserversocketfactory =
            (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
    SSLServerSocket sslserversocket =
            (SSLServerSocket) sslserversocketfactory.createServerSocket(9999);
    System.out.println("Ready");
    SSLSocket sslsocket = (SSLSocket) sslserversocket.accept();

    InputStream inputstream = sslsocket.getInputStream();
    InputStreamReader inputstreamreader = new InputStreamReader(inputstream);
    BufferedReader bufferedreader = new BufferedReader(inputstreamreader);

    OutputStream toClient = sslsocket.getOutputStream();
    toClient.write(("HTTP/1.0 200 Connection established\n" +
            "Content-Length: " + "Shut down!".getBytes().length
                                     + "\r\n").getBytes("utf-8"));
    toClient.write("Shut down!".getBytes("utf-8"));
    toClient.close();
} catch (Exception exception) {
    exception.printStackTrace();
}

客户

try {
    System.setProperty("https.proxyHost", "127.0.0.1");
    System.setProperty("https.proxyPort", "9999");
    URL yahoo = new URL("https://www.google.ca/");
    URLConnection yc = yahoo.openConnection();
    System.out.println(yc.getClass().getName());
    BufferedReader in = new BufferedReader(
                new InputStreamReader(
                yc.getInputStream()));
    String inputLine;

    while ((inputLine = in.readLine()) != null) 
    System.out.println(inputLine);
    in.close();
} catch (Exception ex) {
    ex.printStackTrace();
}

我得到了这个错误 javax.net.ssl.SSLException: Unrecognized SSL message, plaintext connection? 我用谷歌搜索了它，但是想出了一些邮件。

基本上，我需要创建一个java代理服务器，由客户端设置为客户端 https.proxyPort 和 https.proxyHost 标志，并可以将数据发送回客户端应用程序，可能不会以任何方式修改（它只是使用 URL connection = new URL("https://...")）

我试过的几个网站......

创建一个接受HTTPS的Java代理服务器
http://stilius.net/java/java_ssl.php
让Java接受所有证书还有其他的东西，但我找不到任何链接。我有代码，但是我遇到的错误多于我现在正在做的事情，但如果有帮助我可以加入它（我最初没有，因为这已经是一个很长的问题了）

8391

2018-05-03 04:05

起源

目前我也在努力设置系统属性https.proxyHost。通过将调试器附加到VM进程，似乎VM根本不会获取https.proxyHost属性。 - Christian K.

好的，只使用没有http的proxyHost和proxyPort。或https。前缀现在适合我。看起来这个行为（再次）从Java 6到Java 7也是如此。上面的声明是对Java 7的说法。 - Christian K.

当通过代理请求https URL时，客户端必须请求 CONNECT www.google.ca:443 HTTP/1.0 和代理服务器响应 HTTP/1.0 200 Connection established，都是平原。然后客户端开始SSL握手。 - auntyellow

答案:

正如auntyellow评论的那样：你不需要自己做任何SSL摆弄。基本上，https-proxying是关于在两方之间转发二进制数据。

引用选秀luotonen的Web代理穿隧01.txt：

 CLIENT -> SERVER                        SERVER -> CLIENT
 --------------------------------------  -----------------------------------
 CONNECT home.netscape.com:443 HTTP/1.0
 User-agent: Mozilla/4.0
 <<< empty line >>>
                                         HTTP/1.0 200 Connection established
                                         Proxy-agent: Netscape-Proxy/1.1
                                         <<< empty line >>>
              <<< data tunneling to both directions begins >>>

所以基本上你需要确保你信任你的客户足以从你的代理防火墙位置连接到给定的主机和端口。由于这种常见做法是将允许端口限制为443，拒绝与localhost和“不可信”方的连接。

这是一个可以用作的“简单”服务器 https.proxy 在Java中如果你不相信喷气机：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created for http://stackoverflow.com/q/16351413/1266906.
 */
public class Server extends Thread {

    public static void main(String[] args) {
        (new Server()).run();
    }

    public Server() {
        super("Server Thread");
    }

    @Override
    public void run() {
        try (ServerSocket serverSocket = new ServerSocket(9999)) {
            Socket socket;
            try {
                while ((socket = serverSocket.accept()) != null) {
                    (new Handler(socket)).start();
                }
            } catch (IOException 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 boolean previousWasR = false;

        public Handler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }

        @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) {
                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");
        }
    }
}

2017-11-27 22:35

不错。有皱纹。当代理从一个套接字读取EOS时，它应该关闭另一个套接字以进行输出并退出该线程。当它关闭两个套接字时，它可以关闭它们并退出第二个线程。这有助于HTTP保持活动状态。 - user207421

@EJP感谢您的反馈！我切换到了调用shutdown-methods 并添加了一个最终接近的 forwardSocket。我错过了别的什么吗？ - TheConstructor

用于HTTPS协议的URLConnection的默认java SE7实现使用参数
https.proxyHost 和 https.proxyPort

添加到Tomcat：

-Dhttps.proxyHost =“192.168.121.31”-Dhttps.proxyPort =“3128”

2018-02-04 14:01

问题 Java https代理（使用https.proxyPort和https.proxyHost）

答案:

热门问题