wmproxy已用Rust实现http/https代理, socks5代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现websocket代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子
国内: https://gitee.com/tickbh/wmproxy
github: https://github.com/tickbh/wmproxy
在同一个端口上同时支持HTTP/HTTPS/SOCKS5代理，即假设监听8090端口，那么可以设置如下：
curl --proxy socks5://127.0.0.1:8090 http://www.baidu.com curl --proxy http://127.0.0.1:8090 http://www.baidu.com curl --proxy http://127.0.0.1:8090 https://www.baidu.com
以上方案需要都可以兼容打通，才算成功。
不做HTTP服务器，仅简单的解析数据流，然后进行数据转发
RUSTpub async fn process<T>(
username: &Option<String>,
password: &Option<String>,
mut inbound: T,
) -> Result<(), ProxyError<T>>
where
T: AsyncRead + AsyncWrite + Unpin,
{
let mut outbound;
let mut request;
let mut buffer = BinaryMut::new();
loop {
let size = {
let mut buf = ReadBuf::uninit(buffer.chunk_mut());
inbound.read_buf(&mut buf).await?;
buf.filled().len()
};
if size == 0 {
return Err(ProxyError::Extension("empty"));
}
unsafe {
buffer.advance_mut(size);
}
request = webparse::Request::new();
// 通过该方法解析标头是否合法, 若是partial(部分)则继续读数据
// 若解析失败, 则表示非http协议能处理, 则抛出错误
// 此处clone为浅拷贝，不确定是否一定能解析成功，不能影响偏移
match request.parse_buffer(&mut buffer.clone()) {
Ok(_) => match request.get_connect_url() {
Some(host) => {
match HealthCheck::connect(&host).await {
Ok(v) => outbound = v,
Err(e) => {
Self::err_server_status(inbound, 503).await?;
return Err(ProxyError::from(e));
}
}
break;
}
None => {
if !request.is_partial() {
Self::err_server_status(inbound, 503).await?;
return Err(ProxyError::UnknownHost);
}
}
},
Err(WebError::Http(HttpError::Partial)) => {
continue;
}
Err(_) => {
return Err(ProxyError::Continue((Some(buffer), inbound)));
}
}
}
match request.method() {
&Method::Connect => {
log::trace!(
"https connect {:?}",
String::from_utf8_lossy(buffer.chunk())
);
inbound.write_all(b"HTTP/1.1 200 OK\r\n\r\n").await?;
}
_ => {
outbound.write_all(buffer.chunk()).await?;
}
}
let _ = copy_bidirectional(&mut inbound, &mut outbound).await?;
Ok(())
}
此方案仅做浅解析，处理相当高效，但遇到如下问题：
0X05，非ascii字符，其它协议不会影响CONNECT或者connect开头，且查询其它HTTP方法没有以C开头的，这里仅判断第一个字符为C或者c，该协议仅处理一条http请求不参与后续TLS握手协议等保证数据安全RUSTlet mut buffer = BinaryMut::with_capacity(24);
let size = {
let mut buf = ReadBuf::uninit(buffer.chunk_mut());
inbound.read_buf(&mut buf).await?;
buf.filled().len()
};
if size == 0 {
return Err(ProxyError::Extension("empty"));
}
unsafe {
buffer.advance_mut(size);
}
// socks5 协议, 直接返回, 交给socks5层处理
if buffer.as_slice()[0] == 5 {
return Err(ProxyError::Continue((Some(buffer), inbound)));
}
let mut max_req_num = usize::MAX;
// https 协议, 以connect开头, 仅处理一条HTTP请求
if buffer.as_slice()[0] == b'C' || buffer.as_slice()[0] == b'c' {
max_req_num = 1;
}
RUST/// http代理类处理类
struct Operate {
/// 用户名
username: Option<String>,
/// 密码
password: Option<String>,
/// Stream类, https连接后给后续https使用
stream: Option<TcpStream>,
/// http代理keep-alive的复用
sender: Option<Sender<RecvRequest>>,
/// http代理keep-alive的复用
receiver: Option<Receiver<ProtResult<RecvResponse>>>,
}
构建HTTP服务
RUST// 需要将已读的数据buffer重新加到server的已读cache中, 否则解析会出错
let mut server = Server::new_by_cache(inbound, None, buffer);
// 构建HTTP服务回调
let mut operate = Operate {
username: username.clone(),
password: password.clone(),
stream: None,
sender: None,
receiver: None,
};
server.set_max_req(max_req_num);
let _e = server.incoming(&mut operate).await?;
if let Some(outbound) = &mut operate.stream {
let mut inbound = server.into_io();
let _ = copy_bidirectional(&mut inbound, outbound).await?;
}
此时我们已将数据用HTTP服务进行处理，收到相应的请求再进行给远端做转发：
HTTP核心处理回调，此处我们用的是async_trait异步回调
RUST
#[async_trait]
impl OperateTrait for &mut Operate {
async fn operate(&mut self, request: &mut RecvRequest) -> ProtResult<RecvResponse> {
// 已连接直接进行后续处理
if let Some(sender) = &self.sender {
sender.send(request.replace_clone(Body::empty())).await?;
if let Some(res) = self.receiver.as_mut().unwrap().recv().await {
return Ok(res?)
}
return Err(ProtError::Extension("already close by other"))
}
// 获取要连接的对象
let stream = if let Some(host) = request.get_connect_url() {
match HealthCheck::connect(&host).await {
Ok(v) => v,
Err(e) => {
return Err(ProtError::from(e));
}
}
} else {
return Err(ProtError::Extension("unknow tcp stream"));
};
// 账号密码存在，将获取`Proxy-Authorization`进行校验，如果检验错误返回407协议
if self.username.is_some() && self.password.is_some() {
let mut is_auth = false;
if let Some(auth) = request.headers_mut().remove(&"Proxy-Authorization") {
if let Some(val) = auth.as_string() {
is_auth = self.check_basic_auth(&val);
}
}
if !is_auth {
return Ok(Response::builder().status(407).body("")?.into_type());
}
}
// 判断用户协议
match request.method() {
&Method::Connect => {
// https返回200内容直接进行远端和客户端的双向绑定
self.stream = Some(stream);
return Ok(Response::builder().status(200).body("")?.into_type());
}
_ => {
// http协议，需要将客户端的内容转发到服务端，并将服务端数据转回客户端
let client = Client::new(ClientOption::default(), MaybeHttpsStream::Http(stream));
let (mut recv, sender) = client.send2(request.replace_clone(Body::empty())).await?;
match recv.recv().await {
Some(res) => {
self.sender = Some(sender);
self.receiver = Some(recv);
return Ok(res?)
},
None => return Err(ProtError::Extension("already close by other")),
}
}
}
}
}
密码校验，由Basic的密码加密方法，先用base64解密，再用:做拆分，再与用户密码比较
RUSTpub fn check_basic_auth(&self, value: &str) -> bool
{
use base64::engine::general_purpose;
use std::io::Read;
let vals: Vec<&str> = value.split_whitespace().collect();
if vals.len() == 1 {
return false;
}
let mut wrapped_reader = Cursor::new(vals[1].as_bytes());
let mut decoder = base64::read::DecoderReader::new(
&mut wrapped_reader,
&general_purpose::STANDARD);
// handle errors as you normally would
let mut result: Vec<u8> = Vec::new();
decoder.read_to_end(&mut result).unwrap();
if let Ok(value) = String::from_utf8(result) {
let up: Vec<&str> = value.split(":").collect();
if up.len() != 2 {
return false;
}
if up[0] == self.username.as_ref().unwrap() ||
up[1] == self.password.as_ref().unwrap() {
return true;
}
}
return false;
}
代理在计算机网络很常见，比如服务器群组内部通常只会开一个口进行对外访问，就可以通过内网代理来进行处理，从而更好的保护内网服务器。代理让我们网络更安全，但是警惕非正规的代理可能会窃取您的数据。请用HTTPS内容访问更安全。
点击 [关注]，[在看]，[点赞] 是对作者最大的支持
本文作者:问蒙服务框架
本文链接:
版权声明:本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！