日記/2012/05/02/JavaでHTTP(S)両対応のProxyを実験してみた。 (v1)

public class ProxyHandler implements HttpRequestHandler {
    private final HttpProcessor httpproc;
    private final HttpRequestExecutor httpexecutor;
    private final HttpParams params;
    public ProxyHandler() {
        // Set up HTTP protocol processor for outgoing connections
        this.httpproc = new ImmutableHttpProcessor(/* ... */);
        // Set up outgoing request executor 
        this.httpexecutor = new HttpRequestExecutor();
        this.params = new SyncBasicHttpParams();
        this.params.setIntParameter(/* … */);
    }
 
    @Override
    public void handle(
            final HttpRequest request, 
            final HttpResponse response,
            final HttpContext context) throws HttpException, IOException {
 
        // Proxyを使った "http://hostname(:port)/path" 形式からホスト名と
        // ポート番号と実際のURL Pathを取り出します。
        String incommingUrlStr = request.getRequestLine().getUri();
        URL incommingUrl = null;
        try {
            incommingUrl = new URL(incommingUrlStr);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            System.err.println("ignore illegal url : " + incommingUrlStr + "]");
            return;
        }
        String realHost = incommingUrl.getHost();
        int realPort = incommingUrl.getPort();
        if (-1 == realPort) {
            realPort = 80;
        }
        String actualRequestPath = incommingUrl.getFile();
 
        // 実際のサーバに向けたクライアント用Socketを作成し、
        // DefaultHttpClientConnectionを使ってHTTPパラメータを設定します。
        Socket outsocket = new Socket(realHost, realPort);
        DefaultHttpClientConnection outconn = new DefaultHttpClientConnection();
        outconn.bind(outsocket, this.params);
        
        // この間にProxy関連のリクエストヘッダを除去しています。
 
        // 実際のリクエストURL Pathを使ってリクエストヘッダを組み立てます。
        HttpRequest targetRequest = new BasicHttpRequest(
                request.getRequestLine().getMethod(), 
                actualRequestPath, 
                request.getRequestLine().getProtocolVersion());
        targetRequest.setHeaders(request.getAllHeaders());
 
        // 実際のHTTPサーバと通信します。
        HttpResponse targetResponse = this.httpexecutor.execute(targetRequest, outconn, context);
 
        // レスポンスBODYを取り出します。
        HttpEntity entity = targetResponse.getEntity();
        System.out.println(EntityUtils.getContentMimeType(entity));
        // 今回は実際のHTTPサーバとは毎回切断しますので、切断する前に、
        // レスポンスBODYを全て取り出しておく必要があります。
        // これを忘れると、最終的にUser-Agentに返すレスポンスBODYを作るときに、
        // すでに実際のHTTPサーバとの接続は閉じられているためBODYが読めずに例外となります。
        byte[] responseBody = EntityUtils.toByteArray(entity);
        EntityUtils.consume(entity); // これは要らないかも？
 
        this.httpexecutor.postProcess(response, this.httpproc, context);
        // Proxy関連のResponse Headerの除去と、最終的なResponseの組立
        response.setStatusLine(targetResponse.getStatusLine());
        response.setHeaders(targetResponse.getAllHeaders());
        response.setEntity(new ByteArrayEntity(responseBody));
 
        try {
            // 今回は毎回実際のHTTPサーバとの接続は切断します。
            outsocket.close();
        } catch (Exception e) {}
    }
}

@Override
    public void handle(
            final HttpRequest request, 
            final HttpResponse response,
            final HttpContext context) throws HttpException, IOException {
 
        String requestMethod = request.getRequestLine().getMethod();
        if ("CONNECT".equals(requestMethod)) {
            // ひとまず 200 OKを返す準備
            response.setStatusCode(HttpStatus.SC_OK);
            response.setReasonPhrase("Connection established");
            // HttpContextの switch_to_https (このサンプルが独自に用意)をONにします。
            context.setAttribute("switch_to_https", true);
            // "Host"ヘッダーを取り出し、ホスト名とポート番号を取り出します。
            Header[] headers = request.getHeaders("Host");
            Header hostHeader = headers[0];
            String hostValue = hostHeader.getValue();
            System.out.println("HTTPS Host: " + hostValue);
            int colon = hostValue.indexOf(':');
            // HttpContextにホスト名とポート番号を設定します。
            if (-1 == colon) {
                context.setAttribute("https.host", hostValue);
                context.setAttribute("https.port", 443);
            } else {
                context.setAttribute("https.host", hostValue.substring(0, colon));
                int port = 443;
                try {
                    String port_s = hostValue.substring(colon + 1);
                    port = Integer.parseInt(port_s);
                } catch (Exception ignore) { port = 443; }
                context.setAttribute("https.port", port);
            }
            return;
        }
        /* … */

public void run() {
        System.out.println("New connection thread");
        HttpContext context = new BasicHttpContext(null);
        // HTTPS中継モード関連パラメタの初期化
        boolean switchToHttps = false;
        context.setAttribute("switch_to_https", switchToHttps);
        context.setAttribute("https.host", "");
        context.setAttribute("https.port", -1);
        try {
            while (!Thread.interrupted() && inconn.isOpen()) {
                switchToHttps = (Boolean)context.getAttribute("switch_to_https");
                if (switchToHttps) {
                    // CONNECTメソッドを受けて、HttpService用のループを抜ける。
                    System.out.println("Switching HTTPS Tunneling mode...");
                    break;
                } else {
                    System.out.println("handleRequest start");
                    this.httpservice.handleRequest(this.inconn, context);
                    // HTTPS切り替えの取得（最新の値を取得）
                    switchToHttps = (Boolean)context.getAttribute("switch_to_https");
                    if (!switchToHttps) {
                        // HTTPSでなければclose()により強制flush
                        // (これを入れないとcurlでHTTP Proxyのレスポンスが取得できなかった)
                        this.inconn.close();
                    }
                    System.out.println("handleRequest end");
                }
            }
            if (switchToHttps) {
                // HTTPS中継モードで接続先のホスト名とポート番号を取得
                String targetHost = (String)context.getAttribute("https.host");
                int targetPort = (Integer)context.getAttribute("https.port");
                Socket targetSocket = null;
                if ("localhost".equals(targetHost) && 8081 == targetPort) {
                    // redirect to TLS relay server
                    // ここは後述
                    targetSocket = new Socket("localhost", 8889);
                } else {
                    // 中身を覗かないHTTPS中継モードはこちら。
                    targetSocket = new Socket(targetHost, targetPort);
                }
                // 中継スレッドの作成とstart()
                Thread in2target = new TcpRelayWorker("in2target", insocket, targetSocket);
                in2target.setDaemon(true);
                in2target.start();
                Thread target2in = new TcpRelayWorker("target2in", targetSocket, insocket);
                target2in.setDaemon(true);
                target2in.start();
            }

// Set up the HTTP service
        this.httpService = new HttpService(
                inhttpproc, 
                // new DefaultConnectionReuseStrategy(), 
                // ->
                new AlwaysConnectionReuseStrategy(), 
                new DefaultHttpResponseFactory(),
                reqistry,
                this.params);

public class TlsHandler implements HttpRequestHandler {
    // ...
    // サーバ証明書の検証をスルーするためのSSLContextとSSLSocketFactory
    protected SSLContext sslContext;
    protected SSLSocketFactory sslSocketFactory;
 
    public TlsHandler(String _targetHost, int _targetPort) {
        try {
            // サーバ証明書の検証をスルーするための専用のTrustManagerの準備
            this.sslContext = SSLContext.getInstance("TLSv1");
            TrustManager tm = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] chain,
                        String authType) throws CertificateException {
                }
 
                public void checkServerTrusted(X509Certificate[] chain,
                        String authType) throws CertificateException {
                }
 
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            this.sslContext.init(null, new TrustManager[] { tm }, null);
            // サーバ証明書の検証をスルーする設定のSSLSocketFactoryの生成
            this.sslSocketFactory = sslContext.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    @Override
    public void handle(
            final HttpRequest request, 
            final HttpResponse response,
            final HttpContext context) throws HttpException, IOException {
 
        // サーバ証明書の検証をスルーするSSLSocketFactoryでSocket生成
        Socket outsocket = this.sslSocketFactory.createSocket(this.targetHost, this.targetPort);
        DefaultHttpClientConnection outconn = new DefaultHttpClientConnection();
        outconn.bind(outsocket, this.params);
        System.out.println("Outgoing connection to " + outsocket.getInetAddress());

public class Server {
 
    public static void main(String[] args) throws Exception {
        Thread t = new IncommingListener(8888);
        t.setDaemon(false);
        t.start();
        Thread t2 = new TlsRequestListener(8889, "localhost", 8081);
        t2.setDaemon(true);
        t2.start();
    }
}

if (switchToHttps) {
                // ...
                if ("localhost".equals(targetHost) && 8081 == targetPort) {
                    // 内部のMITM Proxy(TlsRequestListener)に接続
                    targetSocket = new Socket("localhost", 8889);
                } else {