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

use std::error::Error;
use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::Arc;

use async_trait::async_trait;
use tokio::io::split;
use tokio::net::TcpStream;
use tokio_rustls::rustls::ClientConfig;
use tokio_rustls::webpki::DNSNameRef;
use tokio_rustls::TlsConnector;

use common::io::Stream;
use common::tls::{load_certificate, load_private_key};

use crate::tunnel::{TcpTunneler, Tunneler};

pub(crate) struct TlsTunneler {
    tunneler: TcpTunneler,
}

impl TlsTunneler {
    pub(crate) async fn new(
        address: IpAddr,
        port: u16,
        ca_cert: PathBuf,
        client_cert: PathBuf,
        client_key: PathBuf,
        server_hostname: String,
    ) -> Result<Self, Box<dyn Error>> {
        let mut config = ClientConfig::new();
        config.root_store.add(&load_certificate(ca_cert).await?)?;
        let chain = vec![load_certificate(client_cert).await?];
        config.set_single_client_cert(chain, load_private_key(client_key).await?)?;
        let connector = TlsConnector::from(Arc::new(config));

        let to_address = format!("{}:{}", address, port);
        log::debug!("connecting to {}", to_address);
        let tcp_stream = TcpStream::connect(to_address).await?;

        let domain = DNSNameRef::try_from_ascii_str(&server_hostname)?;
        let stream = connector.connect(domain, tcp_stream).await?;
        let (reader, writer) = split(stream);
        Ok(Self {
            tunneler: TcpTunneler::from_stream(Stream::new(reader, writer))?,
        })
    }
}

#[async_trait]
impl Tunneler for TlsTunneler {
    async fn tunnel(&mut self, client: Stream) -> Result<(), Box<dyn Error>> {
        self.tunneler.tunnel(client).await
    }
}