torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! BitTorrent wire over an established mTLS handoff.

use std::net::SocketAddr;
use std::time::Duration;

use crate::error::{Error, Result};
use crate::peer::extension::ExtensionMessage;
use crate::peer::io::PeerIo;
use crate::peer::{FrameDecode, Handshake, PeerMessage};
use crate::security::MAX_PEER_READ_BUF;
use crate::torrent::InfoHash;

pub struct PeerConnection {
    pub addr: SocketAddr,
    /// Remote BitTorrent peer id from the wire handshake.
    pub remote_peer_id: [u8; 20],
    stream: PeerIo,
    read_buf: Vec<u8>,
    pub extensions: bool,
    pub fast: bool,
    pub v2: bool,
}

impl PeerConnection {
    /// BitTorrent wire handshake over an already-established mTLS session (initiator).
    pub async fn from_secure_initiator(
        handoff: crate::secure::Handoff,
        handshake: &Handshake,
    ) -> Result<Self> {
        let addr = handoff.peer_addr;
        let stream = PeerIo::from_secure(handoff.transport);
        Self::from_io_initiator(addr, stream, handshake).await
    }

    /// BitTorrent wire handshake over mTLS (acceptor). Returns remote info-hash for routing.
    pub async fn from_secure_acceptor(
        handoff: crate::secure::Handoff,
        local_peer_id: [u8; 20],
        expected: Option<InfoHash>,
    ) -> Result<(Self, InfoHash)> {
        let addr = handoff.peer_addr;
        let stream = PeerIo::from_secure(handoff.transport);
        Self::from_io_acceptor(addr, stream, local_peer_id, expected).await
    }

    /// BitTorrent wire handshake over an already-established MSE/PE stream (initiator).
    pub async fn from_mse_initiator(
        addr: SocketAddr,
        stream: crate::mse::MseStream,
        handshake: &Handshake,
    ) -> Result<Self> {
        Self::from_io_initiator(addr, PeerIo::from_mse(stream), handshake).await
    }

    /// BitTorrent wire handshake over a ready [`PeerIo`] (initiator).
    pub async fn from_io_initiator(
        addr: SocketAddr,
        mut stream: PeerIo,
        handshake: &Handshake,
    ) -> Result<Self> {
        let expected = handshake.info_hash;
        stream.write_all(&encode_handshake_buf(handshake)).await?;
        let mut response = [0u8; 68];
        stream.read_exact(&mut response).await?;
        let (remote, _) = parse_handshake_bytes(&mut response)?;
        if remote.info_hash != expected {
            return Err(Error::Peer("info hash mismatch".into()));
        }
        if remote.peer_id == handshake.peer_id {
            return Err(Error::Peer(
                "remote peer_id matches local peer_id (self-connection)".into(),
            ));
        }
        Ok(Self {
            addr,
            remote_peer_id: remote.peer_id,
            stream,
            read_buf: Vec::with_capacity(4096),
            extensions: handshake.extensions && remote.extensions,
            fast: handshake.fast && remote.fast,
            v2: handshake.v2 && remote.v2,
        })
    }

    /// BitTorrent wire handshake over MSE/PE (acceptor).
    pub async fn from_mse_acceptor(
        addr: SocketAddr,
        stream: crate::mse::MseStream,
        local_peer_id: [u8; 20],
        expected: Option<InfoHash>,
    ) -> Result<(Self, InfoHash)> {
        Self::from_io_acceptor(addr, PeerIo::from_mse(stream), local_peer_id, expected).await
    }

    /// BitTorrent wire handshake over a ready [`PeerIo`] (acceptor).
    pub async fn from_io_acceptor(
        addr: SocketAddr,
        mut stream: PeerIo,
        local_peer_id: [u8; 20],
        expected: Option<InfoHash>,
    ) -> Result<(Self, InfoHash)> {
        let mut peer_buf = [0u8; 68];
        stream.read_exact(&mut peer_buf).await?;
        let (remote, _) = parse_handshake_bytes(&mut peer_buf)?;
        if let Some(expected) = expected {
            if remote.info_hash != expected {
                return Err(Error::Peer("info hash mismatch".into()));
            }
        }
        let local = Handshake::new(remote.info_hash, local_peer_id).with_swarm_features();
        if remote.peer_id == local_peer_id {
            return Err(Error::Peer(
                "remote peer_id matches local peer_id (self-connection)".into(),
            ));
        }
        stream.write_all(&encode_handshake_buf(&local)).await?;
        let hash = remote.info_hash;
        Ok((
            Self {
                addr,
                remote_peer_id: remote.peer_id,
                stream,
                read_buf: Vec::with_capacity(4096),
                extensions: local.extensions && remote.extensions,
                fast: local.fast && remote.fast,
                v2: local.v2 && remote.v2,
            },
            hash,
        ))
    }

    pub async fn send(&mut self, message: &PeerMessage) -> Result<()> {
        let encoded = message.encode();
        self.stream.write_all(&encoded).await?;
        Ok(())
    }

    pub async fn send_extended(
        &mut self,
        extension_id: u8,
        message: &ExtensionMessage,
    ) -> Result<()> {
        let encoded = message.encode(extension_id);
        self.stream.write_all(&encoded).await?;
        Ok(())
    }

    pub async fn recv(&mut self) -> Result<PeerMessage> {
        crate::ingress!("peer_tcp");
        // Idle peers must not hold a max_peers slot indefinitely.
        const IDLE_TIMEOUT: Duration = Duration::from_secs(120);
        loop {
            match PeerMessage::try_decode(&self.read_buf)? {
                FrameDecode::Frame { message, rest } => {
                    self.read_buf = rest.to_vec();
                    return Ok(message);
                }
                FrameDecode::NeedMore => {}
            }

            if self.read_buf.len() >= MAX_PEER_READ_BUF {
                return Err(Error::Peer(format!(
                    "peer read buffer exceeds {MAX_PEER_READ_BUF} bytes"
                )));
            }

            let mut chunk = [0u8; 4096];
            let read = tokio::time::timeout(IDLE_TIMEOUT, self.stream.read(&mut chunk))
                .await
                .map_err(|_| Error::Peer("peer idle/read timeout".into()))??;
            if read == 0 {
                return Err(Error::Peer("peer connection closed".into()));
            }
            self.read_buf.extend_from_slice(&chunk[..read]);
        }
    }
}

fn encode_handshake_buf(handshake: &Handshake) -> Vec<u8> {
    let mut buf = Vec::with_capacity(68);
    buf.push(19);
    buf.extend(b"BitTorrent protocol");
    let mut reserved = [0u8; 8];
    if handshake.extensions {
        crate::peer::extension::enable_extensions(&mut reserved);
    }
    if handshake.fast {
        crate::peer::fast::enable_fast(&mut reserved);
    }
    if handshake.v2 {
        crate::peer::hash_messages::enable_v2(&mut reserved);
    }
    buf.extend(reserved);
    buf.extend(handshake.info_hash.as_bytes());
    buf.extend(handshake.peer_id);
    buf
}

fn parse_handshake_bytes(buf: &mut [u8; 68]) -> Result<(Handshake, [u8; 8])> {
    if buf[0] != 19 || &buf[1..20] != b"BitTorrent protocol" {
        return Err(Error::Peer("invalid handshake".into()));
    }
    let mut reserved = [0u8; 8];
    reserved.copy_from_slice(&buf[20..28]);
    let mut info_hash = [0u8; 20];
    info_hash.copy_from_slice(&buf[28..48]);
    let mut peer_id = [0u8; 20];
    peer_id.copy_from_slice(&buf[48..68]);
    Ok((
        Handshake {
            info_hash: InfoHash::from_bytes(info_hash),
            peer_id,
            extensions: crate::peer::extension::supports_extensions(&reserved),
            fast: crate::peer::fast::supports_fast(&reserved),
            v2: crate::peer::hash_messages::supports_v2(&reserved),
        },
        reserved,
    ))
}