s5t 0.2.1

SOCKS5 client with tun2socks and one-time request modes
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

#![warn(clippy::pedantic)]

mod prelude;
mod mode;
mod config;
mod socks5;
mod tun;
mod http;

use prelude::*;
use tokio::net::TcpStream;
use tokio_util::sync::CancellationToken;
use tracing_subscriber::fmt;
use tracing_subscriber::EnvFilter;

use crate::socks5::session::ConnectTarget;
use crate::tun::DnsResolver;
use crate::tun::FakeDns;
use crate::{tun::TunSession, socks5::Socks5Session};

#[tokio::main]
async fn main() -> Result<(), AppError> {
    setup_tracing();

    let mut config = Config::new()?;
    config.validate()?;

    debug!(config = ?config, "client started");

    match config.mode {
        Mode::Socks5 => {
            let stream = TcpStream::connect(config.server).await.map_err(|_| AppError::TargetUnreachable)?;
            let mut session = Socks5Session::new(config, stream);

            if session.handshake().await? == consts::s5::auth::AUTH { session.auth().await?; }
            session.connect(ConnectTarget::FromConfig).await?;
            session.send().await
        },
        Mode::Tun2Socks => {
            let cancel_token = CancellationToken::new();
            let dns_resolver = DnsResolver::new();

            let mut session = TunSession::new(config.clone(), dns_resolver.clone(), cancel_token.clone())?;
            let mut fake_dns = FakeDns::new(&config, dns_resolver.clone(), cancel_token.clone()).await?;

            let mut handle_tun = tokio::spawn(async move {
                session.run().await;
            });

            let mut handle_dns = tokio::spawn(async move {
                fake_dns.run().await;
            });

            tokio::select! {
                _ = tokio::signal::ctrl_c() => {
                    info!("Shutting down...");
                    cancel_token.cancel();
                    let _ = tokio::join!(handle_tun, handle_dns);
                }
                result = &mut handle_tun => {
                    if let Err(error) = result {
                        error!(%error, "tun crashed");
                        cancel_token.cancel();
                    }
                    let _ = handle_dns.await;
                }
                result = &mut handle_dns => {
                    if let Err(error) = result {
                        error!(%error, "dns crashed");
                        cancel_token.cancel();
                    }
                    let _ = handle_tun.await;
                }
            }

            Ok(())
        },
        Mode::Tun => Err(AppError::Tun(format!("mode {:?} not yet implemented", config.mode))),
    }
}

#[cfg(debug_assertions)]
fn setup_tracing() {
    fmt()
        .with_target(true)
        .with_env_filter(
            EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| EnvFilter::new("rustls=warn,s5t=trace,s5l=trace"))
        )
        .init();
}

#[cfg(not(debug_assertions))]
fn setup_tracing() {
    let mut directives = vec![
        "smoltcp=error".to_string(),
        "netstack_smoltcp=error".to_string(),
        "rustls=error".to_string(),
    ];

    if let Ok(env_filter) = EnvFilter::try_from_default_env() {
        directives.push(env_filter.to_string());
    } else {
        directives.push("s5t=info".to_string());
    }

    let filter = EnvFilter::new(directives.join(","));

    fmt()
        .with_target(true)
        .with_env_filter(filter)
        .init();
}