endpoint-libs 1.7.28

Common dependencies to be used with Pathscale projects, projects that use [endpoint-gen](https://github.com/pathscale/endpoint-gen), and projects that use honey_id-types.
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

use std::fs::File;
use std::net::SocketAddr;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;

use eyre::{Context, Result, ensure};
use futures::FutureExt;
use futures::future::BoxFuture;
use rustls::pki_types::CertificateDer;
use rustls::pki_types::PrivateKeyDer;
use rustls::pki_types::pem::PemObject;
use rustls_pemfile::certs;
use tokio_rustls::TlsAcceptor;
use tokio_rustls::server::TlsStream;

use super::ConnectionListener;

pub struct TlsListener<T> {
    tcp: T,
    acceptor: TlsAcceptor,
}

impl<T: ConnectionListener> TlsListener<T> {
    pub async fn bind(under: T, pub_certs: Vec<PathBuf>, priv_cert: PathBuf) -> Result<Self> {
        let certs = load_certs(&pub_certs)?;
        ensure!(
            !certs.is_empty(),
            "No certificates found in file: {:?}",
            pub_certs
        );

        let key = load_private_key(&priv_cert)?;

        #[cfg(feature = "ws-tls12")]
        let protocol_versions: &[&rustls::SupportedProtocolVersion] =
            { &[&rustls::version::TLS13, &rustls::version::TLS12] };
        #[cfg(not(feature = "ws-tls12"))]
        let protocol_versions: &[&rustls::SupportedProtocolVersion] =
            { &[&rustls::version::TLS13] };
        #[cfg(feature = "ws-wtx")]
        let protocol_versions: &[&rustls::SupportedProtocolVersion] =
            { &[&rustls::version::TLS12] };

        #[cfg(any(
            all(feature = "ws", feature = "ws-http1"),
            all(feature = "ws-wtx", feature = "ws-wtx-http2"),
        ))]
        let alpn_protocols = { vec![b"h2".to_vec(), b"http/1.1".to_vec()] };
        #[cfg(all(feature = "ws-wtx", not(feature = "ws-wtx-http2")))]
        let alpn_protocols = { vec![b"http/1.1".to_vec()] };
        #[cfg(all(feature = "ws", not(feature = "ws-http1")))]
        let alpn_protocols = { vec![b"h2".to_vec()] };

        let tls_cfg = {
            let mut cfg = rustls::ServerConfig::builder_with_protocol_versions(protocol_versions)
                .with_no_client_auth()
                .with_single_cert(certs, key)?;
            cfg.alpn_protocols = alpn_protocols;
            Arc::new(cfg)
        };
        let acceptor = TlsAcceptor::from(tls_cfg);
        Ok(Self {
            tcp: under,
            acceptor,
        })
    }
}

impl<T: ConnectionListener + 'static> ConnectionListener for TlsListener<T> {
    type Channel1 = T::Channel1;
    type Channel2 = TlsStream<T::Channel2>;
    fn accept(&self) -> BoxFuture<'_, Result<(Self::Channel1, SocketAddr)>> {
        self.tcp.accept()
    }
    fn handshake(&self, channel: Self::Channel1) -> BoxFuture<'_, Result<Self::Channel2>> {
        async {
            let channel = self.tcp.handshake(channel).await?;
            let tls_stream = self.acceptor.accept(channel).await?;
            Ok(tls_stream)
        }
        .boxed()
    }
}

fn load_certs<'a, T: AsRef<Path>>(
    path: impl IntoIterator<Item = T>,
) -> Result<Vec<CertificateDer<'a>>> {
    let mut r_certs = vec![];
    for p in path {
        let p = p.as_ref();
        let f = File::open(p).with_context(|| format!("Failed to open {}", p.display()))?;

        let reader = &mut std::io::BufReader::new(f);
        let certs_results = certs(reader);

        let certs: Vec<CertificateDer> = certs_results.filter_map(|result| result.ok()).collect();

        r_certs.extend(certs);
    }
    Ok(r_certs)
}

fn load_private_key(path: &PathBuf) -> Result<PrivateKeyDer<'static>> {
    let private_key =
        PrivateKeyDer::from_pem_file(path).wrap_err("Error loading private key from file.")?;

    Ok(private_key)
}