tunneler 0.4.0

Tunnel TCP or UDP traffic over TCP, (mutual) TLS or DNS (authoritative server or direct connection)
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::error::Error;
use std::net::IpAddr;
use std::sync::Arc;
use std::time::Duration;

use async_channel::Receiver;
use simple_logger::SimpleLogger;
use structopt::StructOpt;

use common::cli::{Cli, TunneledType, TunnelerType};
use common::io::Stream;
use common::network::{Listener, TcpListener};

use crate::dns::DnsTunneler;
use crate::network::UdpListener;
use crate::tls::TlsTunneler;
use crate::tunnel::{TcpTunneler, Tunneler};

mod dns;
mod network;
mod tls;
mod tunnel;

fn main() -> Result<(), Box<dyn Error>> {
    let args: Cli = Cli::from_args();

    SimpleLogger::new()
        .with_level(args.log_level)
        .init()
        .unwrap();
    log::debug!("start client - args are {:?}", args);

    start_client(args)
}

#[tokio::main]
async fn start_client(args: Cli) -> Result<(), Box<dyn Error>> {
    let mut listener =
        new_listener(args.tunneled_type, args.local_address, args.local_port).await?;
    let (clients_sender, clients_receiver) = async_channel::unbounded::<Stream>();

    let tunnel_type = Arc::new(args.tunneler_type);
    let accept_clients_future = listener.accept_clients(clients_sender);
    let tunnel_clients_future = tunnel_clients(
        clients_receiver,
        tunnel_type.clone(),
        args.remote_address,
        args.remote_port,
    );
    match tokio::try_join!(accept_clients_future, tunnel_clients_future) {
        Ok(_) => Ok(()),
        Err(e) => Err(e),
    }
}

async fn new_listener(
    type_: TunneledType,
    address: IpAddr,
    port: u16,
) -> Result<Box<dyn Listener>, Box<dyn Error>> {
    match type_ {
        TunneledType::Tcp => Ok(Box::new(TcpListener::new(address, port).await?)),
        TunneledType::Udp => Ok(Box::new(UdpListener::new(address, port).await?)),
    }
}

async fn new_tunneler(
    type_: &TunnelerType,
    address: IpAddr,
    port: u16,
) -> Result<Box<dyn Tunneler>, Box<dyn Error>> {
    match type_ {
        TunnelerType::Tcp => Ok(Box::new(TcpTunneler::new(address, port).await?)),
        TunnelerType::Dns {
            read_timeout_in_milliseconds,
            idle_client_timeout_in_milliseconds,
            client_suffix,
        } => Ok(Box::new(
            DnsTunneler::new(
                address,
                port,
                Duration::from_millis(*read_timeout_in_milliseconds),
                Duration::from_millis(*idle_client_timeout_in_milliseconds),
                client_suffix.clone(),
            )
            .await?,
        )),
        TunnelerType::Tls {
            ca_cert,
            cert,
            key,
            server_hostname,
        } => Ok(Box::new(
            TlsTunneler::new(
                address,
                port,
                ca_cert.to_path_buf(),
                cert.to_path_buf(),
                key.to_path_buf(),
                server_hostname.clone(),
            )
            .await?,
        )),
    }
}

async fn tunnel_clients(
    clients: Receiver<Stream>,
    tunnel_type: Arc<TunnelerType>,
    remote_address: IpAddr,
    remote_port: u16,
) -> Result<(), Box<dyn Error>> {
    while let Ok(client) = clients.recv().await {
        tokio::spawn(tunnel_client(
            client,
            tunnel_type.clone(),
            remote_address,
            remote_port,
        ));
    }
    Ok(())
}

async fn tunnel_client(
    client: Stream,
    tunnel_type: Arc<TunnelerType>,
    remote_address: IpAddr,
    remote_port: u16,
) {
    let mut tunnel = match new_tunneler(&tunnel_type, remote_address, remote_port).await {
        Ok(t) => t,
        Err(e) => {
            log::error!(
                "failed to create {:?} tunnel to {}:{}: {}",
                tunnel_type,
                remote_address,
                remote_port,
                e
            );
            return;
        }
    };
    if let Err(e) = tunnel.tunnel(client).await {
        log::error!("failed to tunnel client: {}", e);
    }
}