36. 干货系列从零用Rust编写负载均衡及代理，内网穿透中内网代理的实现 ...

wmproxy

wmproxy已用Rust实现http/https代理, socks5代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现websocket代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子
项目地址

国内: https://gitee.com/tickbh/wmproxy
github: https://github.com/tickbh/wmproxy
项目设计目标

• HTTP转发
  
• HTTPS转发(证书在服务器,内网为HTTP)
  
• TCP转发(纯粹的TCP转发，保持原样的协议)
  
• PROXY转发(服务端接收数据，内网的客户端当成PROXY客户端，相当于逆向访问内网服务器，[新增])
  

实现方案

服务端提供客户端的连接端口，可加密Tls，可双向加密mTls，可账号密码认证，客户端连接服务端的端口等待数据的处理。主要有两个类服务端CenterServer及客户端CenterClient
一些细节可以参考第5篇，第6篇，第10篇，第12篇，有相关的内网穿透的细节。
内网代理的实现

• 首先添加一种模式
  

1. #[serde_as]
2. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3. pub struct MappingConfig {
4.     /// 其它字段....
5.     // 添加模块proxy
6.     pub mode: String,
7. }

复制代码

• 添加内网代理监听端口
  

1. #[serde_as]
2. #[derive(Debug, Clone, Serialize, Deserialize)]
3. pub struct ProxyConfig {
4.     /// 其它字段....
5.     pub(crate) map_http_bind: Option<SocketAddr>,
6.     pub(crate) map_https_bind: Option<SocketAddr>,
7.     pub(crate) map_tcp_bind: Option<SocketAddr>,
8.     // 新加代理接口监听字段
9.     pub(crate) map_proxy_bind: Option<SocketAddr>,
10.     -
11. }

复制代码

目前端口做唯一绑定，后续可根据配置动态响应相应的数据。

• 做映射
  

由于代理和tcp类似，服务端均不做任务处理，只需将数据完全转发给客户端处理即可

1. pub async fn server_new_prxoy(&mut self, stream: TcpStream) -> ProxyResult<()> {
2.     let trans = TransTcp::new(
3.         self.sender(),
4.         self.sender_work(),
5.         self.calc_next_id(),
6.         self.mappings.clone(),
7.     );
8.     tokio::spawn(async move {
9.         if let Err(e) = trans.process(stream, "proxy").await {
10.             log::warn!("内网穿透:转发Proxy转发时发生错误:{:?}", e);
11.         }
12.     });
13.     return Ok(());
14. }

复制代码

• 客户端处理
  客户端将映射流转化成VirtualStream，把它当成一个虚拟流，然后逻辑均用代理的来处理
  

1. let (virtual_sender, virtual_receiver) = channel::<ProtFrame>(10);
2. map.insert(p.sock_map(), virtual_sender);
4. if mapping.as_ref().unwrap().is_proxy() {
5.     let stream = VirtualStream::new(
6.         p.sock_map(),
7.         sender.clone(),
8.         virtual_receiver,
9.     );
11.     let (flag, username, password, udp_bind) = (
12.         option.flag,
13.         option.username.clone(),
14.         option.password.clone(),
15.         option.udp_bind.clone(),
16.     );
17.     tokio::spawn(async move {
18.         // 处理代理的能力
19.         let _ = WMCore::deal_proxy(
20.             stream, flag, username, password, udp_bind,
21.         )
22.         .await;
23.     });
24. }

复制代码

VirtualStream是一个虚拟出一个流连接，并实现AsyncRead及AsyncRead，可以和流一样正常操作，这也是Trait而不是继承的好处之一，定义就可以比较简单：

1. pub struct VirtualStream
2. {
3.     // sock绑定的句柄
4.     id: u32,
5.     // 收到数据通过sender发送给中心端
6.     sender: PollSender<ProtFrame>,
7.     // 收到中心端的写入请求，转成write
8.     receiver: Receiver<ProtFrame>,
9.     // 读取的数据缓存，将转发成ProtFrame
10.     read: BinaryMut,
11.     // 写的数据缓存，直接写入到stream下，从ProtFrame转化而来
12.     write: BinaryMut,
13. }

复制代码

• 设计ProxyServer类
  

统一的代理服务类，剥离相关代码，使代码更清晰

1. /// 代理服务器类, 提供代理服务
2. pub struct ProxyServer {
3.     flag: Flag,
4.     username: Option<String>,
5.     password: Option<String>,
6.     udp_bind: Option<IpAddr>,
7.     headers: Vec<ConfigHeader>,
8. }

复制代码

• 代理HTTP头信息的重写
  在HTTP类中添加相关代码以支持头信息重写
  

1. impl Operate {
2.     fn deal_request(&self, req: &mut RecvRequest) -> ProtResult<()> {
3.         if let Some(headers) = &self.headers {
4.             // 复写Request的头文件信息
5.             Helper::rewrite_request(req, headers);
6.         }
7.         Ok(())
8.     }
9.    
10.     fn deal_response(&self, res: &mut RecvResponse) -> ProtResult<()> {
11.         if let Some(headers) = &self.headers {
12.             // 复写Request的头文件信息
13.             Helper::rewrite_response(res, headers);
14.         }
15.         Ok(())
16.     }
17. }

复制代码

内网代理流程图：

flowchart TD    A[外部客户端] -->|以代理方式访问|B    B[服务端监听Proxy] |数据转发| C[中心服务端CenterServer]    C |协议传输|D[中心客户端CenterClient]    D |虚拟数据流|E[虚拟客户端]    E |处理数据|F[内网代理服务,可完全访问内网]这样子我们就以代理的方式拥有了所有的内网HTTP相关服务的访问权限。可以简化我们网络的结构。
自动化测试

内网穿透的自动化测试在 tests/mapping
将自动构建内网客户端服务，外网服务端服务做测试，以下部分代码节选：

1. #[tokio::test]
2. async fn run_test() {
3.     let local_server_addr = run_server().await.unwrap();
4.     let addr = "127.0.0.1:0".parse().unwrap();
5.     let proxy = ProxyConfig::builder()
6.         .bind_addr(addr)
7.         .map_http_bind(Some(addr))
8.         .map_https_bind(Some(addr))
9.         .map_tcp_bind(Some(addr))
10.         .map_proxy_bind(Some(addr))
11.         .center(true)
12.         .mode("server".to_string())
13.         .into_value()
14.         .unwrap();
16.     let (server_addr, http_addr, https_addr, tcp_addr, proxy_addr, _sender) =
17.         run_mapping_server(proxy).await.unwrap();
18.     let mut mapping = MappingConfig::new(
19.         "test".to_string(),
20.         "http".to_string(),
21.         "soft.wm-proxy.com".to_string(),
22.         vec![],
23.     );
24.     mapping.local_addr = Some(local_server_addr);
26.     let mut mapping_tcp = MappingConfig::new(
27.         "tcp".to_string(),
28.         "tcp".to_string(),
29.         "soft.wm-proxy.com".to_string(),
30.         vec![],
31.     );
32.     mapping_tcp.local_addr = Some(local_server_addr);
34.     let mut mapping_proxy = MappingConfig::new(
35.         "proxy".to_string(),
36.         "proxy".to_string(),
37.         "soft.wm-proxy.com1".to_string(),
38.         vec![
39.             ConfigHeader::new(wmproxy::HeaderOper::Add, false, "from_proxy".to_string(), "mapping".to_string())
40.         ],
41.     );
42.     mapping_proxy.local_addr = Some(local_server_addr);
44.     let proxy = ProxyConfig::builder()
45.         .bind_addr(addr)
46.         .server(Some(server_addr))
47.         .center(true)
48.         .mode("client".to_string())
49.         .mapping(mapping)
50.         .mapping(mapping_tcp)
51.         .mapping(mapping_proxy)
52.         .into_value()
53.         .unwrap();
54.     let _client_sender = run_mapping_client(proxy).await.unwrap();
56.     fn do_build_req(url: &str, method: &str, body: &Vec<u8>) -> Request<Body> {
57.         let body = BinaryMut::from(body.clone());
58.         Request::builder()
59.             .method(method)
60.             .url(&*url)
61.             .body(Body::new_binary(body))
62.             .unwrap()
63.     }
64.    
65.     {
66.         let url = &*format!("http://{}/", local_server_addr);
67.         let client = Client::builder()
68.             // .http2(false)
69.             .http2_only(true)
70.             .add_proxy(&*format!("http://{}", proxy_addr.unwrap())).unwrap()
71.             .connect(&*url)
72.             .await
73.             .unwrap();
75.         let mut res = client
76.             .send_now(do_build_req(url, "GET", &vec![]))
77.             .await
78.             .unwrap();
79.         let mut result = BinaryMut::new();
80.         res.body_mut().read_all(&mut result).await;
82.         // 测试头信息来确认是否来源于代理
83.         assert_eq!(res.headers().get_value(&"from_proxy"), &"mapping");
84.         assert_eq!(result.remaining(), HELLO_WORLD.as_bytes().len());
85.         assert_eq!(result.as_slice(), HELLO_WORLD.as_bytes());
86.         assert_eq!(res.version(), Version::Http2);
87.     }
88. }

复制代码

小结

内网代理可以实现不想暴露太多信息给外部，但是又能提供内部的完整信息支持，相当于建立了一条可用的HTTP通道。可以在有这方面需求的人优化网络结构。
点击 [关注]，[在看]，[点赞] 是对作者最大的支持

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！