Android代理服务器处理SSL

我正在编写自己的代理服务器。我有最简单的实现。第一个代码片段是在端口8080上设置服务器侦听（在该端口上，请求将通过WiFi设置重定向）：

}

第二种是通过套接字传递请求和响应数据：

public class ProxyConnectionHandler implements Runnable {

private static final int BUFFER_SIZE = 8192;

Socket mProxySocket;
Socket mOutsideSocket;

public ProxyConnectionHandler(Socket proxySocket) {
    mProxySocket = proxySocket;
}

@Override
public void run() {
    try {
        long startTimestamp = System.currentTimeMillis();

        InputStream proxyInputStream = mProxySocket.getInputStream();


        byte[] bytes = new byte[BUFFER_SIZE];
        int bytesRead = proxyInputStream.read(bytes, 0, BUFFER_SIZE);
        String request = new String(bytes);

        Log.d("ACHTUNG", "Request: " + request);

        String host = extractHost(request);

        int port = request.startsWith("CONNECT") ? 443 : 80;
        mOutsideSocket = new Socket(host, port);
        OutputStream outsideOutputStream = mOutsideSocket.getOutputStream();
        outsideOutputStream.write(bytes, 0, bytesRead);
        outsideOutputStream.flush();

        InputStream outsideSocketInputStream = mOutsideSocket.getInputStream();
        OutputStream proxyOutputStream = mProxySocket.getOutputStream();
        byte[] responseArray = new byte[BUFFER_SIZE];

        do
        {
            bytesRead = outsideSocketInputStream.read(responseArray, 0, BUFFER_SIZE);
            if (bytesRead > 0)
            {
                proxyOutputStream.write(responseArray, 0, bytesRead);
                String response = new String(bytes, 0, bytesRead);
                Log.d("ACHTUNG", "Response: " + response);
            }
        } while (bytesRead > 0);

        proxyOutputStream.flush();
        mOutsideSocket.close();
        mProxySocket.close();

        Log.d("ACHTUNG", "Cycle: " + (System.currentTimeMillis() - startTimestamp));

    } catch (Exception e) {
        e.printStackTrace();
    }
}

private String extractHost(String request) {
    int hStart = request.indexOf("Host: ") + 6;
    int hEnd = request.indexOf('\n', hStart);
    return request.substring(hStart, hEnd - 1);
}

}

当我进入浏览器时，它对HTTP页面有效，但对HTTPS无效。还有更多的东西需要处理SSL。我不想阅读SSL包，我只想把它们传递出去。怎么做？

我找到了解决办法

如果来自客户端的SSL请求被修改为HTTP“CONNECT”方法。但是，该请求不得发送到外部服务器。代理服务器必须使用以下命令响应客户端：

"HTTP/1.1 200 Connection established\r\n\r\n"

下一步是允许客户端和服务器之间的双向套接字连接。应该是这样的：

public class Https443RequestHandler implements RequestHandler {

    private static final int BUFFER_SIZE = 8192;
    private static final String CRLF = "\r\n";

    Socket mProxySocket;
    Socket mOutsideSocket;

    public Https443RequestHandler(Socket proxySocket) {
        this.mProxySocket = proxySocket;
    }

    @Override
    public void handle(String request) throws Exception {
        byte[] bytes = request.getBytes();
        int bytesRead = bytes.length;

        String host = extractHost(request);
        int port = 443;

        mOutsideSocket = new Socket();
        mOutsideSocket.setKeepAlive(true);
        mOutsideSocket.connect(new InetSocketAddress(host, port));

        OutputStream proxyOutputStream = mProxySocket.getOutputStream();
        proxyOutputStream.write(("HTTP/1.1 200 Connection established" + CRLF + CRLF).getBytes());
        proxyOutputStream.flush();

        DirectionalConnectionHandler client = new DirectionalConnectionHandler(mProxySocket, mOutsideSocket);
        client.start();
        DirectionalConnectionHandler server = new DirectionalConnectionHandler(mOutsideSocket, mProxySocket);
        server.start();

        client.join();
        server.join();

        mOutsideSocket.close();
        mProxySocket.close();
    }

    private String extractHost(String request) {
        int hStart = request.indexOf("Host: ") + 6;
        int hEnd = request.indexOf('\n', hStart);
        return request.substring(hStart, hEnd - 1);
    }
}

---

}

在浏览器中我得到：错误\u隧道\u连接\u失败

public class Https443RequestHandler implements RequestHandler {

    private static final int BUFFER_SIZE = 8192;
    private static final String CRLF = "\r\n";

    Socket mProxySocket;
    Socket mOutsideSocket;

    public Https443RequestHandler(Socket proxySocket) {
        this.mProxySocket = proxySocket;
    }

    @Override
    public void handle(String request) throws Exception {
        byte[] bytes = request.getBytes();
        int bytesRead = bytes.length;

        String host = extractHost(request);
        int port = 443;

        mOutsideSocket = new Socket();
        mOutsideSocket.setKeepAlive(true);
        mOutsideSocket.connect(new InetSocketAddress(host, port));

        OutputStream proxyOutputStream = mProxySocket.getOutputStream();
        proxyOutputStream.write(("HTTP/1.1 200 Connection established" + CRLF + CRLF).getBytes());
        proxyOutputStream.flush();

        DirectionalConnectionHandler client = new DirectionalConnectionHandler(mProxySocket, mOutsideSocket);
        client.start();
        DirectionalConnectionHandler server = new DirectionalConnectionHandler(mOutsideSocket, mProxySocket);
        server.start();

        client.join();
        server.join();

        mOutsideSocket.close();
        mProxySocket.close();
    }

    private String extractHost(String request) {
        int hStart = request.indexOf("Host: ") + 6;
        int hEnd = request.indexOf('\n', hStart);
        return request.substring(hStart, hEnd - 1);
    }
}

public class DirectionalConnectionHandler extends Thread
{
    private final InputStream in;
    private final OutputStream out;

    DirectionalConnectionHandler(final Socket sin, final Socket sout) throws IOException
    {
        in = sin.getInputStream();
        out = sout.getOutputStream();
    }

    @Override
    public void run()
    {
        final byte[] buf = new byte[4096];
        int count;

        try
    {
        while ((count = in.read(buf, 0, buf.length)) != -1)
        {
            String stream = new String(buf);
            out.write(buf, 0, count);
        }
        out.flush();
    }
    catch (final IOException e)
    {
        // Just swallow as we can't recover from this
    }
}