Http-Proxy-Servlet 支持双向认证的流量转发

た入场券 2021-09-10 06:20 568阅读 0赞

# Http-Proxy-Servlet #

Http-Proxy-Servlet 能提供流量转发功能，并且支持 HTTPS 双向认证。它可以很方便的整合到你的 SpringBoot 程序中，甚至你可以在此基础上搭建一个"网关"程序。

项目地址：[https://github.com/LinYuanBaoBao/http-proxy-servlet.git][https_github.com_LinYuanBaoBao_http-proxy-servlet.git]

## 快速上手 ##

引入依赖：

<dependency>
        <groupId>com.github.LinYuanBaoBao</groupId>
        <artifactId>http-proxy-servlet</artifactId>
        <version>1.0.2-RELEASE</version>
    </dependency>

### 在 SpringBoot 中使用 ###

> 本示例你可以从 `http-proxy-servlet-example-http` 中获取

在 SpringBoot 中使用 Http-Proxy-Servlet 非常的简单，通过 SpringMVC 提供的 `ServletWrappingController` 将 Servlet 包装成一个 Controller，并通过 `SimpleUrlHandlerMapping` 将 Controller 与 `/proxy` 接口进行绑定。

@Configuration
    public class ProxyServletConfiguration {
    
        private final String PROXY_CONTROLLER = "proxyController";
        private final String PROXY_API = "/proxy";
    
        @Bean
        public ServletWrappingController proxyController() throws Exception {
            // Servlet 配置
            Properties properties = new Properties();
            properties.put(ProxyServletConfig.P_CONTEXT, PROXY_API);
            properties.put(ProxyServletConfig.P_LOG, true);
            properties.put(ProxyServletConfig.P_READ_TIMEOUT, -1);
            properties.put(ProxyServletConfig.P_CONNECTION_REQUEST_TIMEOUT, -1);
            properties.put(ProxyServletConfig.P_CONNECT_TIMEOUT, -1);
    
            ServletWrappingController controller = new ServletWrappingController();
            controller.setServletClass(SpringProxyServlet.class);
            controller.setBeanName(PROXY_CONTROLLER);
            controller.setInitParameters(properties);
            controller.afterPropertiesSet();
            return controller;
        }
    
        @Bean
        public SimpleUrlHandlerMapping proxyControllerMapping() {
            SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
            Properties urlProperties = new Properties();
            urlProperties.put(PROXY_API + "/**", PROXY_CONTROLLER);
            mapping.setMappings(urlProperties);
            mapping.setOrder(Integer.MAX_VALUE - 2);
            return mapping;
        }
    
        public static class SpringProxyServlet extends ProxyServlet {
            @Override
            public void initHandler() {
                addHandler(new HttpClientProxyInitHandler());
                addHandler(new ProxyHandler());
                addHandler(new ResponseHandler());
            }
        }
    
    }

因为 **ProxyServlet** 是个抽象类，需要实现 `initHandler()` 方法初始化处理器，上面代码中添加了三个 **Handler** 用于支持基本的 HTTP 流量转发功能：

*  **HttpClientProxyInitHandler**：前置处理器，用于初始化 HttpClientProxy 代理对象
 *  **ProxyHandler**：代理处理器，用于执行代理请求
 *  **ResponseHandler**：后置处理器，用于将代理请求结果响应回客户端

你也可以直接使用 `DefaultProxyServlet`，其同样初始化了这三个处理器。

#### 添加 TargetHandler 处理器 ####

单单如此还不足以实现流量转发功能，你还需要自定义一个前置处理器，用于告诉 `ProxyServlet` 你准备将把请求代理至何处。

这需要你自定义一个 **TargetHandler** 并在业务逻辑中获取待目标的主机地址，如下面代码：

@Component
    public class TargetHandler implements Handler {
    
        @Override
        public void doHandle(RequestContext requestContext) {
            // 将请求代理至 localhost:8081 
            TargetHost targetHost = new TargetHost("localhost",8081);
            requestContext.setTargetHost(targetHost);
        }
    
        @Override
        public HandlerType getType() {
            return HandlerType.PRE_PROXY;
        }
    
        @Override
        public Integer getOrder() {
            return Integer.MIN_VALUE;
        }
    
    }

Handler 类型有三种：

*  **PRE\_PROXY**：前置处理器，它将会在请求代理前运行
 *  **PROXY**：请求代理处理器
 *  **POST\_PROXY**：前置处理器，它将会在请求代理后运行

`getOrder()` 方法返回值将会决定 Handler 在处理链中的执行顺序，**其值越小越先执行，值相同则会根据添加的先后顺序。**

*  对于需要最先执行的 Handler 通常会使用 Integer.MIN\_VALUE 值，如用于初始化 Proxy 代理对象的处理器。
 *  对于需要最后执行的 Handler 通常会使用 Integer.MAX\_VALUE 值，如用于将代理请求结果响应会客户端的处理器。

修改 `initHandler()` 方法，将 TargetHandler 添加至处理器链，如下：

public static class SpringProxyServlet extends ProxyServlet {
        @Override
        public void initHandler() {
            addHandler(new TargetHandler());
            addHandler(new HttpClientProxyInitHandler());
            addHandler(new ProxyHandler());
            addHandler(new ResponseHandler());
        }
    }

#### 测试 ####

此时运行程序，假设访问代理服务 [http://localhost:8080/proxy/v1/applications][http_localhost_8080_proxy_v1_applications] 的请求将会被代理至 [http://localhost:8081/v1/applications][http_localhost_8081_v1_applications]

### 支持 HTTPS 双向认证 ###

> 本示例你可以从 `http-proxy-servlet-example-https` 中获取

若代理的目标服务支持 Https，并且目标服务还需验证请求客户端的身份，那么你可以参考下面示例实现 Https 双向认证。

首先对先前的 **TargetHandler** 做一些修改：

public class TargetHandler implements Handler {
    
        @Override
        public void doHandle(RequestContext requestContext) {
            TargetHost targetHost = new TargetHost("localhost", 8082);
            requestContext.setTargetHost(targetHost);
            requestContext.setScheme(Scheme.HTTPS);
        }
    
        @Override
        public HandlerType getType() {
            return HandlerType.PRE_PROXY;
        }
    
        @Override
        public Integer getOrder() {
            return Integer.MIN_VALUE;
        }
    
    }

我们需要将请求 **Scheme** 类型设置为 HTTPS。

其次确保 `getOrder()` 返回值为 Integer.MIN\_VALUE，HttpsClientProxyInitHandler 会根据 **Scheme** 决定是否创建 HTTPS 连接，因此需要 **TargetHandler** 先与 **HttpsClientProxyInitHandler** 执行。

修改 `initHandler()` 方法，将 **HttpClientProxyInitHandler** 替换为 **HttpsClientProxyInitHandler**。

public static class SpringProxyServlet extends ProxyServlet {
      @Override
      public void initHandler() {
    
        addHandler(new TargetHandler());
    
        // HTTPS 双向认证
        KeyStoreLoader keyStoreLoader = new KeyStoreLoader() {
          @Override
          public KeyStoreModel loadKeyStoreModel(RequestContext requestContext) {
            try {
              KeyStore keyStore = KeyStore.getInstance("PKCS12");
              File certificateFile = ResourceUtils.getFile("classpath:client.p12");
              KeyStore.PasswordProtection password = new KeyStore.PasswordProtection("123456".toCharArray());
              keyStore.load(FileUtils.openInputStream(certificateFile), password.getPassword());
              return new KeyStoreModel(keyStore, password);
            } catch (Exception e) {
              e.printStackTrace();
            }
            return null;
          }
        };
        DefaultSSLContextInitializer sslContextInitializer = new DefaultSSLContextInitializer(keyStoreLoader);
        DefaultHttpsConnectionSocketFactoryRegister httpsConnectionSocketFactoryRegister = new DefaultHttpsConnectionSocketFactoryRegister(sslContextInitializer);
        addHandler(new HttpsClientProxyInitHandler(httpsConnectionSocketFactoryRegister));
    
        addHandler(new ProxyHandler());
        addHandler(new ResponseHandler());
      }
    }

**HttpsClientProxyInitHandler** 构造函数需要一个 **HttpsConnectionSocketFactoryRegister** 接口实现，用于创建 HTTPS-Socket 连接工厂，这里使用 **DefaultHttpsConnectionSocketFactoryRegister**，需要注意的是它暂未对 *hostname* 进行验证，你可以自己实现验证逻辑，并调用 `setHostnameVerifier()` 方法配置它。

而 **DefaultHttpsConnectionSocketFactoryRegister** 构造函数需要一个 **SSLContextInitializer** 接口实现，用于初始化 SSLContext 上下文对象，这里使用的 **DefaultSSLContextInitializer** 它会跳过对服务端的证书校验，你可以继承该类重写 `loadTrustManager()` 方法实现校验逻辑。

此外 **DefaultSSLContextInitializer** 并不清楚你客户端的证书保存于何处，因为它可能跟你的业务逻辑有关，因此你需要实现 **KeyStoreLoader** 接口获取 **KeyStore**。

上面代码中，我本地测试用的客户端证书位于项目资源目录下，并名为 client.p12，其密码为 123456，证书类型为 PKCS12。

#### 测试 ####

此时如果代理的目标服务端已信任 client.p12 证书，则请求将会成功。

你可以参考 [此文章][Link 1] 搭建一个双向认证服务端尝试一下。

### 自定义 Proxy 代理对象 ###

真正转发流量的并非是 **Handler** 而是 **Proxy**，由 **Proxy** 去完成实际代理并将结果响应回调用方。目前仅提供了基于 HttpClient 实现的 **HttpClientProxy**。

如果有需要自定义你可以继承自 **AbstractProxy** 并实现以下三个方法：

*  **proxy()**：执行代理请求
 *  **response()**：将代理请求结果响应回调用方
 *  **destroy()**：销毁代理对象资源

也可以继承 **HttpClientProxy** 并在原有的基础上做修改，如修改响应结果，可以重写 `setResponseEntity()` 方法。

## 扩展参考 ##

### 通过跳板机将请求代理至内网主机 ###

如果你需要将请求代理至内网主机，你可以利用跳板机的端口转发功能，这里推荐使用 **Jcraft**，你的代码可能会是这个样子：

private Integer buildTunnel(Session jumpSession, String targetIp, Integer targetPort) throws JSchException {
      return jumpSession.setPortForwardingL(0, targetIp, targetPort);
    }

## 作者信息 ##

聪明的杰瑞 - [掘金博客][Link 2]、邮箱：[765371578@qq.com][765371578_qq.com]

[https_github.com_LinYuanBaoBao_http-proxy-servlet.git]: https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2FLinYuanBaoBao%2Fhttp-proxy-servlet.git
[http_localhost_8080_proxy_v1_applications]: https://links.jianshu.com/go?to=http%3A%2F%2Flocalhost%3A8080%2Fproxy%2Fv1%2Fapplications
[http_localhost_8081_v1_applications]: https://links.jianshu.com/go?to=http%3A%2F%2Flocalhost%3A8081%2Fv1%2Fapplications
[Link 1]: https://links.jianshu.com/go?to=https%3A%2F%2Fblog.csdn.net%2FBlackButton_CC%2Farticle%2Fdetails%2F99956259
[Link 2]: https://links.jianshu.com/go?to=https%3A%2F%2Fjuejin.im%2Fuser%2F5bd1c4886fb9a05cd777874a
[765371578_qq.com]: https://links.jianshu.com/go?to=mailto%3A765371578%40qq.com