高性能的HTTP代理 LittleProxy

引用:

https://github.com/adamfisk/LittleProxy

拦截和操纵HTTPS流量,LittleProxy使用中间人(MITM)管理器。 LittleProxy的默认实现(SelfSignedMitmManager)具有相当有限的功能集。 为了更好地控制证书模拟,浏览器信任,TLS握手等,请使用LittleProxy兼容的MITM扩展:

 

一个LittleProxy MITM扩展,旨在支持包括Android在内的所有Java平台
支持椭圆曲线加密和自定义信任存储的LittleProxy MITM扩展

要过滤HTTP流量,可以使用HttpFiltersSource(适配器)添加请求和响应过滤器,例如:

请参阅org.littleshoot.proxy.HttpFilters的Javadoc来查看您可以使用的方法。

 

要启用aggregator和inflater,必须在HttpFiltersSource#get(Request / Response)BufferSizeInBytes()方法中返回一个大于0的值。 这为您提供了一个“FullHttp(请求/响应)”,未压缩过滤器中的完整内容。 否则,你必须自己处理大块。

这个大小限制适用于每个连接。 例如,要禁止在* .iso或* dmg文件中通过URL进行聚合,您可以在过滤器源代码中返回如下所示的过滤器:


这可以在应用程序中进行大量的下载,这些应用程序定期处理大小有限的FullHttpResponses来修改其内容,例如HTML。

像LittleProxy这样的代理服务器总是包含一个Web服务器。 如果您在原始请求中获得没有方案,主机和端口的URI,那么这是对您的代理的直接请求。 您可以返回一个HttpFilters实现,它可以回答HTML内容的响应,或者像这样在clientToProxyRequest中重定向:

在回答重定向时,您应该添加一个Connection:close标头,以避免阻止行为:

 

 

<dependency>
			<groupId>org.littleshoot</groupId>
			<artifactId>littleproxy</artifactId>
			<version>1.1.2</version>
			<exclusions>
				<exclusion>
					<artifactId>netty-all</artifactId>
					<groupId>io.netty</groupId>
				</exclusion>
			</exclusions>
		</dependency>

<dependency>
			<groupId>io.netty</groupId>
			<artifactId>netty-all</artifactId>
			<version>4.1.19.Final</version>
		</dependency>


<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>23.6-jre</version>
		</dependency>

  

 

package com.pc.proxy;


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponse;
import org.littleshoot.proxy.HttpFilters;
import org.littleshoot.proxy.HttpFiltersAdapter;
import org.littleshoot.proxy.HttpFiltersSourceAdapter;
import org.littleshoot.proxy.HttpProxyServerBootstrap;
import org.littleshoot.proxy.impl.DefaultHttpProxyServer;

public class ProxyServer {

    public static void main(String[] args) {

        HttpProxyServerBootstrap bootstrap = DefaultHttpProxyServer.bootstrap();

        bootstrap.withPort(8080)
                .withFiltersSource(new HttpFiltersSourceAdapter() {

                    @Override
                    public HttpFilters filterRequest(HttpRequest originalRequest, ChannelHandlerContext ctx) {
                        return new HttpFiltersAdapter(originalRequest) {

                            @Override
                            public HttpResponse clientToProxyRequest(HttpObject httpObject) {
                                // TODO: implement your filtering here
                                return new AnswerRequestFilter(originalRequest,"test").clientToProxyRequest(httpObject);
                            }

                            @Override
                            public HttpObject serverToProxyResponse(HttpObject httpObject) {
                                // TODO: implement your filtering here
                                return httpObject;
                            }

                            @Override
                            public void proxyToServerConnectionSucceeded(ChannelHandlerContext serverCtx) {
                                ChannelPipeline pipeline = serverCtx.pipeline();
                                if (pipeline.get("inflater") != null) {
                                    pipeline.remove("inflater");
                                }
                                if (pipeline.get("aggregator") != null) {
                                    pipeline.remove("aggregator");
                                }
                                super.proxyToServerConnectionSucceeded(serverCtx);
                            }

                        };
                    }


                    @Override
                    public int getMaximumResponseBufferSizeInBytes() {
                        return 10 * 1024 * 1024;
                    }


                });

        bootstrap.start();
    }

}

  

package com.pc.proxy;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;
import org.littleshoot.proxy.HttpFiltersAdapter;

import java.io.UnsupportedEncodingException;

public class AnswerRequestFilter extends HttpFiltersAdapter {
    private String answer;

    public AnswerRequestFilter(HttpRequest originalRequest, String answer) {
        super(originalRequest, null);
        this.answer = answer;
    }

    public AnswerRequestFilter(HttpRequest originalRequest, ChannelHandlerContext ctx) {
        super(originalRequest, ctx);
    }

    @Override
    public HttpResponse clientToProxyRequest(HttpObject httpObject){
        ByteBuf buffer = null;
        try {
            buffer = Unpooled.wrappedBuffer(answer.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buffer);
        HttpUtil.setContentLength(response, buffer.readableBytes());
//        HttpHeaders.setHeader(response, HttpHeaders.Names.CONTENT_TYPE, "text/html");
        response.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/html");
        return response;
    }
}

  

 

posted @ 2018-01-30 17:08  佛法无边  阅读(6853)  评论(0编辑  收藏