Rust SOCKS5协议实现库socks5-impl的使用，支持高性能代理服务器和客户端开发

socks5-impl是一个基于tokio的异步SOCKS5协议实现库，提供了SOCKS5协议的基本抽象和异步读写功能。

特性

• 完全异步
• 支持所有SOCKS5命令
  • CONNECT
  • BIND
  • ASSOCIATE
• 可定制的认证方式
  • 无需认证
  • 用户名/密码
  • GSSAPI

使用示例

以下是基本SOCKS5服务器处理示例：

use socks5_impl::protocol::{handshake, Address, AuthMethod, Reply, Request, Response, StreamOperation};

fn main() -> socks5_impl::Result<()> {
    // 绑定TCP监听端口
    let listener = std::net::TcpListener::bind("127.0.0.1:5000")?;
    let (mut stream, _) = listener.accept()?;

    // 获取客户端握手请求
    let request = handshake::Request::retrieve_from_stream(&mut stream)?;

    // 检查客户端是否支持无认证
    if request.evaluate_method(AuthMethod::NoAuth) {
        let response = handshake::Response::new(AuthMethod::NoAuth);
        response.write_to_stream(&mut stream)?;
    } else {
        // 返回无可用认证方法错误
        let response = handshake::Response::new(AuthMethod::NoAcceptableMethods);
        response.write_to_stream(&mut stream)?;
        let _ = stream.shutdown(std::net::Shutdown::Both);
        let err = "No available handshake method provided by client";
        return Err(std::io::Error::new(std::io::ErrorKind::Unsupported, err).into());
    }

    // 获取客户端请求
    let req = match Request::retrieve_from_stream(&mut stream) {
        Ok(req) => req,
        Err(err) => {
            // 返回通用错误响应
            let resp = Response::new(Reply::GeneralFailure, Address::unspecified());
            resp.write_to_stream(&mut stream)?;
            let _ = stream.shutdown(std::net::Shutdown::Both);
            return Err(err.into());
        }
    };

    // 处理请求命令
    match req.command {
        _ => {} // 实际处理逻辑
    }

    Ok(())
}

完整SOCKS5服务器示例

以下是一个完整的异步SOCKS5服务器实现：

use socks5_impl::server::Server;
use socks5_impl::protocol::{AuthMethod, Reply, Command, Response};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建SOCKS5服务器实例
    let mut server = Server::new();
    
    // 配置支持的认证方法
    server.add_auth_method(AuthMethod::NoAuth);
    
    // 设置请求处理器
    server.set_request_handler(|req, mut stream| async move {
        match req.command {
            // 处理CONNECT命令
            Command::Connect => {
                println!("接收到CONNECT请求，目标: {:?}", req.destination);
                
                // 尝试连接到目标服务器
                let mut target = match tokio::net::TcpStream::connect(req.destination.to_string()).await {
                    Ok(t) => t,
                    Err(e) => {
                        // 返回主机不可达错误
                        let resp = Response::new(Reply::HostUnreachable, Address::unspecified());
                        resp.write_to_stream(&mut stream).await?;
                        return Err(e.into());
                    }
                };
                
                // 返回成功响应
                let resp = Response::new(Reply::Succeeded, Address::unspecified());
                resp.write_to_stream(&mut stream).await?;
                
                // 拆分读写流
                let (mut client_read, mut client_write) = stream.split();
                let (mut target_read, mut target_write) = target.split();
                
                // 双向数据转发
                tokio::select! {
                    _ = tokio::io::copy(&mut client_read, &mut target_write) => {},
                    _ = tokio::io::copy(&mut target_read, &mut client_write) => {},
                }
                
                Ok(())
            }
            _ => {
                // 返回不支持的命令错误
                let resp = Response::new(Reply::CommandNotSupported, Address::unspecified());
                resp.write_to_stream(&mut stream).await?;
                Ok(())
            }
        }
    });
    
    // 启动服务器监听端口
    println!("SOCKS5服务器启动在127.0.0.1:1080");
    server.listen("127.0.0.1:1080").await?;
    
    Ok(())
}

完整SOCKS5客户端示例

以下是一个完整的SOCKS5客户端实现：

use socks5_impl::client::Client;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建SOCKS5客户端并连接到代理服务器
    let mut client = Client::new("127.0.0.1:1080").await?;
    
    // 配置认证方式(此处为无认证)
    client.set_auth(None);
    
    // 通过代理连接到目标服务器
    let mut stream = client.connect("example.com:80").await?;
    println!("成功通过SOCKS5代理连接到example.com:80");
    
    // 发送HTTP GET请求
    let request = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
    stream.write_all(request).await?;
    println!("已发送HTTP请求");
    
    // 读取响应数据
    let mut buf = Vec::new();
    stream.read_to_end(&mut buf).await?;
    println!("收到响应数据: {}字节", buf.len());
    println!("响应首行: {}", String::from_utf8_lossy(&buf[..buf.len().min(100)]));
    
    Ok(())
}

安装方法

在项目中添加依赖：

cargo add socks5-impl

或者在Cargo.toml中添加：

[dependencies]
socks5-impl = "0.7.2"
tokio = { version = "1.0", features = ["full"] }

许可证

GNU General Public License v3.0