tx3 0.0.1

tx3 p2p communications
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

use crate::tls::*;
use crate::*;
use std::pin::Pin;
use std::sync::Arc;
use std::task::Context;
use std::task::Poll;

/// A Tx3 p2p connection to a remote peer
pub struct Tx3Connection {
    remote_tls_cert_digest: TlsCertDigest,
    socket: tokio_rustls::TlsStream<tokio::net::TcpStream>,
}

impl Tx3Connection {
    /// Get the TLS certificate digest of the remote end of this connection
    pub fn remote_tls_cert_digest(&self) -> &TlsCertDigest {
        &self.remote_tls_cert_digest
    }

    // -- private -- //

    pub(crate) async fn priv_accept(
        tls: TlsConfig,
        socket: tokio::net::TcpStream,
    ) -> Result<Self> {
        let socket = tokio_rustls::TlsAcceptor::from(tls.srv.clone())
            .accept(socket)
            .await?
            .into();
        let remote_tls_cert_digest = hash_cert(&socket)?;
        Ok(Self {
            remote_tls_cert_digest,
            socket,
        })
    }

    pub(crate) async fn priv_connect(
        tls: TlsConfig,
        socket: tokio::net::TcpStream,
    ) -> Result<Self> {
        let name = "tx3".try_into().unwrap();
        let socket = tokio_rustls::TlsConnector::from(tls.cli.clone())
            .connect(name, socket)
            .await?
            .into();
        let remote_tls_cert_digest = hash_cert(&socket)?;
        Ok(Self {
            remote_tls_cert_digest,
            socket,
        })
    }
}

impl tokio::io::AsyncRead for Tx3Connection {
    #[inline(always)]
    fn poll_read(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut tokio::io::ReadBuf<'_>,
    ) -> Poll<Result<()>> {
        Pin::new(&mut self.socket).poll_read(cx, buf)
    }
}

impl tokio::io::AsyncWrite for Tx3Connection {
    #[inline(always)]
    fn poll_write(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<Result<usize>> {
        Pin::new(&mut self.socket).poll_write(cx, buf)
    }

    #[inline(always)]
    fn poll_flush(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<()>> {
        Pin::new(&mut self.socket).poll_flush(cx)
    }

    #[inline(always)]
    fn poll_shutdown(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<()>> {
        Pin::new(&mut self.socket).poll_shutdown(cx)
    }

    #[inline(always)]
    fn poll_write_vectored(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        bufs: &[std::io::IoSlice<'_>],
    ) -> Poll<Result<usize>> {
        Pin::new(&mut self.socket).poll_write_vectored(cx, bufs)
    }

    #[inline(always)]
    fn is_write_vectored(&self) -> bool {
        self.socket.is_write_vectored()
    }
}

fn hash_cert(
    socket: &tokio_rustls::TlsStream<tokio::net::TcpStream>,
) -> Result<TlsCertDigest> {
    let (_, c) = socket.get_ref();
    if let Some(chain) = c.peer_certificates() {
        if !chain.is_empty() {
            use sha2::Digest;
            let mut digest = sha2::Sha256::new();
            digest.update(&chain[0].0);
            let digest = TlsCertDigest(Arc::new(digest.finalize().into()));
            return Ok(digest);
        }
    }
    Err(other_err("InvalidPeerCert"))
}