java实现http/https抓包拦截

蔚落 2023-06-09 10:17 49阅读 0赞

*最近在调试一个项目时常常需要对接口进行抓包查看，接口位于微信的公众号内，目前每次调试时都是用的 **fiddler**进行抓包查看的。但每次打开fiddler去查看对应的接口并找到对应的参数感觉还是有点复杂，正好今天是周末，打算自己来研究下它的原理并自己通过java来写一个（之所以知道java可以实现这个功能是因为著名的web安全检测工具 **burpsuite** 就是用java写的)*

# 分析 #

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

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

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

本文需要的依赖包为：

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

# *http请求代理* #

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

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

### http请求无代理 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70][]

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

### http请求有代理 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 1][]

由于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抓包进行分析

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 2][]

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

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

*  *- TLS/SSL 协议详解 (16) client key exchange([https://blog.csdn.net/mrpre/article/details/77868396][https_blog.csdn.net_mrpre_article_details_77868396])*
 *  *- TLS/SSL 协议详解(12) server key exchange([https://blog.csdn.net/mrpre/article/details/77867831][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_blog.csdn.net_mrpre_article_details_78025940])*
 *  *- Https：TLS 握手协议([https://www.jianshu.com/p/3d7046932040][https_www.jianshu.com_p_3d7046932040])*
 *  *- HTTPS协议详解(四)：TLS/SSL握手过程（[https://www.cnblogs.com/huanxiyun/articles/6554085.html][https_www.cnblogs.com_huanxiyun_articles_6554085.html]）*

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 3][]

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

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

## 对https请求进行代理分析 ##

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

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

1.  获取到所要代理网站https证书颁发机构的私钥，也就是ca根证书的私钥，然后自己再重新颁发一个新的证书返回给被代理的客户端
2.  自己生成一个ca证书，然后导入到将要被代理的客户端中，让其信任，随后再针对将要代理的请求动态生成https证书

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 4][]

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

## https代理基于netty的实现 ##

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

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

## 开源项目easyHttpProxy ##

其具体的实现可以参考源码：[https://github.com/puhaiyang/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导入到根证书

具体步骤可见此截图:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 5][]

欢迎留言评论，共同学习共同进步!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70]: /images/20230531/21cdd8db121c4123988452fd04815054.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 1]: /images/20230531/7ba375ed214c48dabb0106ffabba822b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 2]: /images/20230531/51d46a02b6964600aba17071f8854f47.png
[https_blog.csdn.net_mrpre_article_details_77868396]: https://blog.csdn.net/mrpre/article/details/77868396
[https_blog.csdn.net_mrpre_article_details_77867831]: https://blog.csdn.net/mrpre/article/details/77867831
[https_blog.csdn.net_mrpre_article_details_78025940]: https://blog.csdn.net/mrpre/article/details/78025940
[https_www.jianshu.com_p_3d7046932040]: https://www.jianshu.com/p/3d7046932040
[https_www.cnblogs.com_huanxiyun_articles_6554085.html]: https://www.cnblogs.com/huanxiyun/articles/6554085.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 3]: /images/20230531/d5e2a17a98104f9b824ea05d1607a68c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 4]: /images/20230531/4ee893dcad884509b0e16e34433f4c6b.png
[https_github.com_puhaiyang_easyHttpProxy]: https://github.com/puhaiyang/easyHttpProxy
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70 5]: /images/20230531/e785bdc9d6d24a2eb4e34f8b031e561a.png