【黑客入门】Java实现类似Fiddler那样的抓包工具，对http进行拦截抓包，并篡改返回来的数据!!！...

最近在调试一个项目时常常需要对接口进行抓包查看，接口位于微信的公众号内，目前每次调试时都是用的 fiddler 进行抓包查看的。但每次打开 fiddler 去查看对应的接口并找到对应的参数感觉还是有点复杂。

正好今天是周末，打算自己来研究下它的原理并自己通过 java 来写一个。

“

之所以知道 java 可以实现这个功能是因为著名的 web 安全检测工具
burpsuite 就是用 java 写的。

”

分析

在使用 fiddler 或 burpsuite 时其抓包的原理都是通过代理服务器来实现的。fiddler 或 burpsuite 通过自己创建一个代理服务器对需要拦截的 socket 请求进行一次中转，其过程有点像中间人的方式，从而可以实现对请求和响应的拦截和修改。

知道了原理后，那么通过 JAVA 编写一个用于转发 socket 的程序就可以实现请求的拦截了.

为了开发的方便与高效，这里采用 netty 框架来显示代理服务器的开发

本文需要的依赖包为：

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
<dependency>
   <groupId>io.netty</groupId>
   <artifactId>netty-all</artifactId>
   <version>4.1.42.Final</version>
</dependency>

http 请求代理

微信公众号内的接口目前全都是 https 的，直接开发 https 代理程序有一定难度，所以笔者决定在实现 https 的接口抓包之前还是先来搞定 http 的抓包拦截功能

在开发之前先梳理下: 这里以谷歌浏览器访问百度网站为例，先画下其访问流程图

http 请求无代理

对于 http 请求无代理的情况其过程很简单，客户端向服务器发起请求，服务端响应此请求即可

http 请求有代理

由于 http 请求太过简单，其所有的数据传输也都是明文传输了。其最大的安全性是很容易受到中间人攻击（MITM）。与 MITM 类比，那么此处的 http 代理服务器也就是中间人了。作为中间人服务器，它对于客户端的请求可以进行拦截、查看、过滤、转发、篡改等，由代理服务器处理完毕后再决定是否转发给目标服务器。同时对于目标服务器的响应也由中间的代理服务器先进行处理一遍，再决定怎样传回给客户端。

如果用 netty 来实现 http 的代理服务器其主要代码如下：

public class HttpProxyHandler extends ChannelInboundHandlerAdapter implements IProxyHandler {
    private Logger logger = LoggerFactory.getLogger(HttpProxyHandler.class);
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("[HttpProxyHandler]");
        if (msg instanceof HttpRequest) {
            HttpRequest httpRequest = (HttpRequest) msg;
            //获取客户端请求
            ClientRequest clientRequest = ProxyRequestUtil.getClientRequest(ctx.channel());
            if (clientRequest == null) {
                //从本次请求中获取
                Attribute<ClientRequest> clientRequestAttribute = ctx.channel().attr(CLIENTREQUEST_ATTRIBUTE_KEY);
                clientRequest = ProxyRequestUtil.getClientReuqest(httpRequest);
                //将clientRequest保存到channel中
                clientRequestAttribute.setIfAbsent(clientRequest);
            }
            //如果是connect代理请求，返回成功以代表代理成功
            if (sendSuccessResponseIfConnectMethod(ctx, httpRequest.method().name())) {
                logger.debug("[HttpProxyHandler][channelRead] sendSuccessResponseConnect");
                ctx.channel().pipeline().remove("httpRequestDecoder");
                ctx.channel().pipeline().remove("httpResponseEncoder");
                ctx.channel().pipeline().remove("httpAggregator");
                ReferenceCountUtil.release(msg);
                return;
            }
            if (clientRequest.isHttps()) {
                //https请求不在此处转发
                super.channelRead(ctx, msg);
                return;
            }
            sendToServer(clientRequest, ctx, msg);
            return;
        }
        super.channelRead(ctx, msg);
    }
 
    /**
     * 如果是connect请求的话，返回连接建立成功
     *
     * @param ctx        ChannelHandlerContext
     * @param methodName 请求类型名
     * @return 是否为connect请求
     */
    private boolean sendSuccessResponseIfConnectMethod(ChannelHandlerContext ctx, String methodName) {
        if (Constans.CONNECT_METHOD_NAME.equalsIgnoreCase(methodName)) {
            //代理建立成功
            //HTTP代理建立连接
            HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, Constans.CONNECT_SUCCESS);
            ctx.writeAndFlush(response);
            return true;
        }
        return false;
    }
 
 
    @Override
    public void sendToServer(ClientRequest clientRequest, ChannelHandlerContext ctx, Object msg) {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(ctx.channel().eventLoop())
                // 注册线程池
                .channel(ctx.channel().getClass())
                // 使用NioSocketChannel来作为连接用的channel类
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        //添加接收远程server的handler
                        ch.pipeline().addLast(new HttpRequestEncoder());
                        ch.pipeline().addLast(new HttpResponseDecoder());
                        ch.pipeline().addLast(new HttpObjectAggregator(6553600));
                        //代理handler,负责给客户端响应结果
                        ch.pipeline().addLast(new HttpProxyResponseHandler(ctx.channel()));
                    }
                });
 
        //连接远程server
        ChannelFuture cf = bootstrap.connect(clientRequest.getHost(), clientRequest.getPort());
        cf.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    //连接成功
                    future.channel().writeAndFlush(msg);
                    logger.debug("[operationComplete] connect remote server success!");
                } else {
                    //连接失败
                    logger.error("[operationComplete] 连接远程server失败了");
                    ctx.channel().close();
                }
            }
        });
    }
 
    @Override
    public void sendToClient(ClientRequest clientRequest, ChannelHandlerContext ctx, Object msg) {
 
    }
}

上面的代码为转发部分的处理代码，其具体完整实现可以查看文末的 github 地址

对于 http 请求响应的处理代码为：

public class HttpProxyResponseHandler extends ChannelInboundHandlerAdapter {
    private Logger logger = LoggerFactory.getLogger(HttpProxyResponseHandler.class);
    private Channel clientChannel;
 
    public HttpProxyResponseHandler(Channel clientChannel) {
        this.clientChannel = clientChannel;
    }
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            logger.debug("[channelRead][FullHttpResponse] 接收到远程的数据1 content:{}", response.content().toString(Charset.defaultCharset()));
        } else if (msg instanceof DefaultHttpResponse) {
            DefaultHttpResponse response = (DefaultHttpResponse) msg;
            logger.debug("[channelRead][FullHttpResponse] 接收到远程的数据 content:{}", response.toString());
        } else if (msg instanceof DefaultHttpContent) {
            DefaultHttpContent httpContent = (DefaultHttpContent) msg;
            logger.debug("[channelRead][DefaultHttpContent] 接收到远程的数据 content:{}", httpContent.content().toString(Charset.defaultCharset()));
        } else {
            logger.debug("[channelRead] 接收到远程的数据 " + msg.toString());
        }
        //发送给客户端
        clientChannel.writeAndFlush(msg);
    }
}

https 请求拦截

https 的请求相对于 http 的请求流程稍微复杂一点，目前的浏览器主要采用 tls1.2 版本和 tls1.3 版本，在开发 https 的代理之前，先看一下 https 采用 tls1.2 的握手过程是怎么样的

https tls1.2 无代理

其过程可以通过 wireshark 抓包进行分析

通过 tls and ip.addr=[目录 ip] 对 https 通信过程中的数据进行过滤

以下为我分析的 https 中使用的 tls1.2 版本客户端与服务端的握手过程简要分析, 其中参考了一些大牛的文章

• - TLS/SSL 协议详解 (16) client key exchange(https://blog.csdn.net/mrpre/article/details/77868396)

• - TLS/SSL 协议详解 (12) server key exchange(https://blog.csdn.net/mrpre/article/details/77867831)

• - TLS/SSL 协议详解 (30) SSL 中的 RSA、DHE、ECDHE、ECDH 流程与区别 (https://blog.csdn.net/mrpre/article/details/78025940)

• - Https：TLS 握手协议 (https://www.jianshu.com/p/3d7046932040)

• - HTTPS 协议详解 (四)：TLS/SSL 握手过程（https://www.cnblogs.com/huanxiyun/articles/6554085.html）

这其中的知识点比较多，如感兴趣可以仔细看下上面我在梳理过程中所画的时序图，如想深入研究可以进入上方的链接进行深入学习。

我的理解后，其主要就是这样的：CA 保证了通信双方的身份的真实性，基于公私钥交换确保了通信过程中的安全性

对 https 请求进行代理分析

回到本文主题，那么想要对 https 请求进行代理应该如何实现呢？

在了解了 https 的通信过程后，那么我们有两种办法可以对 https 的请求进行代理：

1. 获取到所要代理网站 https 证书颁发机构的私钥，也就是 ca 根证书的私钥，然后自己再重新颁发一个新的证书返回给被代理的客户端

2. 自己生成一个 ca 证书，然后导入到将要被代理的客户端中，让其信任，随后再针对将要代理的请求动态生成 https 证书

通过分析后我们可以知道，想要获取到 ca 根证书的私钥是不太可能的，据说 ca 根证书都是离线存储的，一般人拿不到的（一个 https 证书一年收费上千块不是开玩笑的）,ca 的代理机构的证书也是这个道理。

那么通过上面的再次分析后通过方案 1 来进行请求代理的可行性还高一些，其代理过程可以简单如下图：

在分析过后并自己画一个流程图后对于 https 的代理实现流程清晰多了，其实目前市面上的许多支持 https 的代理软件都是采用的这种方式来实现的，无论是常见的抓包利器 fidder 还是大名鼎鼎的安全测试工具 BurpSuite 都是基于此种方式来做的实现

https 代理基于 netty 的实现

在有了上面的分析后，其实想要自己去实现一个 https 的代理服务器还是有一定难度的，https 握手的细节实现就足以让人费事费力了。但在同样大名鼎鼎的 netty 框架面前这些都是小事儿！netty 中的 SslContext 类帮我们完成了这些细节的实现，我们只管如何调用它便可完成对 https 的握手了，框架就是框架，强大哇！

由于时间关系，对于其实现的具体代码这里不做详细分析了，我已把代码提交到 github 上了.

开源项目 easyHttpProxy

其具体的实现可以参考源码：https://github.com/puhaiyang/easyHttpProxy

为了使用的方便，我也将此项目上传到了 maven 公网，其 maven 为：

<dependency>
  <groupId>com.github.puhaiyang</groupId>
  <artifactId>easy-http-proxy</artifactId>
  <version>0.0.1</version>
</dependency>

//使用时添加依赖包后，调用
 EasyHttpProxyServer.getInstace().start(6667);

即可，其中 6667 为代理服务器监听的端口号，目前已支持了 http/https 并针对其他请求直接进行转发.

如果不想自己生成证书，记得将 jar 包中的 ca.crt、ca.key、ca_private.der 拷贝的项目的运行根目录下，即 classes path 下, 要不然 https 代理时会找不到 ca 根证书会出错。

同时，记得将 ca.crt 导入到根证书

具体步骤可见此截图:

---

作者：水中加点糖

来源链接：

https://blog.csdn.net/puhaiyang/article/details/102649498