经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Rust » 查看文章
36. 干货系列从零用Rust编写负载均衡及代理，内网穿透中内网代理的实现
来源：cnblogs　　作者：问蒙服务框架　　时间：2023/12/22 16:21:52　　对本文有异议

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. 首先添加一种模式
  1. #[serde_as]
  2. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
  3. pub struct MappingConfig {
  4.     /// 其它字段....
  5.     // 添加模块proxy
  6.     pub mode: String,
  7. }
  1. 添加内网代理监听端口
  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. }

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

  1. 做映射

由于代理和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. }
  1. 客户端处理
    客户端将映射流转化成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. }
  1. 设计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. }
  1. 代理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通道。可以在有这方面需求的人优化网络结构。

点击 [关注]，[在看]，[点赞] 是对作者最大的支持

原文链接：https://www.cnblogs.com/wmproxy/p/wmproxy36.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Rust热门文章

  • Rust GUI库 egui 的简单应用
  • 36. 干货系列从零用Rust编写负载均衡及代理，内网穿透中内网代理的实现
  • 用Rust手把手编写一个Proxy(代理), TLS加密通讯
  • 简明快速配置 Rust 工具链
  • 9. 用Rust手把手编写一个wmproxy(代理，内网穿透等), HTTP2改造篇之HPACK示例, 了解http2头信息如何处理
  • rust 过程宏
  • 45从零开始用Rust编写nginx，静态文件服务器竟然还有这些细节
  • 37. 干货系列从零用Rust编写负载均衡及代理，负载均衡中try_files实现
  • 26. 干货系列从零用Rust编写正反向代理，如何发布Rust项目到Docker
  • 折腾 Quickwit，Rust 编写的分布式搜索引擎-官方教程

    • Rust推荐文章

  • 折腾 Quickwit，Rust 编写的分布式搜索引擎-官方教程
  • 折腾 Quickwit，Rust 编写的分布式搜索引擎(专为从对象存储中实现亚秒级搜索而设计)
  • Rust使用Sauron实现Web界面交互
  • Rust GUI库 egui 的简单应用
  • 50从零开始用Rust编写nginx，原来TLS证书还可以这么申请
  • 48从零开始用Rust编写nginx，搭建一个简单又好看官方网站
  • 45从零开始用Rust编写nginx，静态文件服务器竟然还有这些细节
  • 44从零开始用Rust编写nginx，命令行参数的设计与解析及说明
  • 43 干货系列从零用Rust编写负载均衡及代理，内网穿透方案完整部署
  • rust angular 自签名证书 wss

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号