fast-socks5 0.8.1

Fast SOCKS5 client/server implementation written in Rust async/.await (tokio)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#[forbid(unsafe_code)]
#[macro_use]
extern crate log;

use anyhow::Context;
use fast_socks5::client::Config;
use fast_socks5::{client::Socks5Stream, Result};
use structopt::StructOpt;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};

/// # How to use it:
///
/// GET / of web server by IPv4 address:
///   `$ RUST_LOG=debug cargo run --example client -- --socks-server 127.0.0.1:1337 --username admin --password password -a 208.97.177.124 -p 80`
///
/// GET / of web server by IPv6 address:
///   `$ RUST_LOG=debug cargo run --example client -- --socks-server 127.0.0.1:1337 --username admin --password password -a ::ffff:208.97.177.124 -p 80`
///
/// GET / of web server by domain name:
///   `$ RUST_LOG=debug cargo run --example client -- --socks-server 127.0.0.1:1337 --username admin --password password -a perdu.com -p 80`
///
#[derive(Debug, StructOpt)]
#[structopt(name = "socks5-client", about = "A simple example of a socks5-client.")]
struct Opt {
    /// Socks5 server address + port. eg. `127.0.0.1:1080`
    #[structopt(short, long)]
    pub socks_server: String,

    /// Target address server (not the socks server)
    #[structopt(short = "a", long)]
    pub target_addr: String,

    /// Target port server (not the socks server)
    #[structopt(short = "p", long)]
    pub target_port: u16,

    #[structopt(short, long)]
    pub username: Option<String>,

    #[structopt(long)]
    pub password: Option<String>,

    /// Don't perform the auth handshake, send directly the command request
    #[structopt(short = "k", long)]
    pub skip_auth: bool,
}

#[tokio::main]
async fn main() -> Result<()> {
    env_logger::init();

    spawn_socks_client().await
}

async fn spawn_socks_client() -> Result<()> {
    let opt: Opt = Opt::from_args();
    let domain = opt.target_addr.clone();
    let mut socks;
    let mut config = Config::default();
    config.set_skip_auth(opt.skip_auth);

    // Creating a SOCKS stream to the target address thru the socks server
    if opt.username.is_some() {
        socks = Socks5Stream::connect_with_password(
            opt.socks_server,
            opt.target_addr,
            opt.target_port,
            opt.username.unwrap(),
            opt.password.expect("Please fill the password"),
            config,
        )
        .await?;
    } else {
        socks = Socks5Stream::connect(opt.socks_server, opt.target_addr, opt.target_port, config)
            .await?;
    }

    // Once connection is completed, can start to communicate with the server
    http_request(&mut socks, domain).await?;

    Ok(())
}

/// Simple HTTP request
async fn http_request<T: AsyncRead + AsyncWrite + Unpin>(
    stream: &mut T,
    domain: String,
) -> Result<()> {
    debug!("Requesting body...");

    // construct our request, with a dynamic domain
    let mut headers = vec![];
    headers.extend_from_slice("GET / HTTP/1.1\r\nHost: ".as_bytes());
    headers.extend_from_slice(domain.as_bytes());
    headers
        .extend_from_slice("\r\nUser-Agent: fast-socks5/0.1.0\r\nAccept: */*\r\n\r\n".as_bytes());

    // flush headers
    stream
        .write_all(&headers)
        .await
        .context("Can't write HTTP Headers")?;

    debug!("Reading body response...");
    let mut result = [0u8; 1024];
    // warning: read_to_end() method sometimes await forever when the web server
    // doesn't write EOF char (\r\n\r\n).
    // read() seems more appropriate
    stream
        .read(&mut result)
        .await
        .context("Can't read HTTP Response")?;

    info!("Response: {}", String::from_utf8_lossy(&result));

    if result.starts_with(b"HTTP/1.1") {
        info!("HTTP/1.1 Response detected!");
    }
    //assert!(result.ends_with(b"</HTML>\r\n") || result.ends_with(b"</html>"));

    Ok(())
}