torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! MSE/PE handshake (initiator + acceptor).

use std::collections::VecDeque;
use std::time::Duration;

use sha1::{Digest, Sha1};
use tokio::net::TcpStream;
use tokio::time::timeout;

use crate::error::{Error, Result};
use crate::mse::dh::{self, PUBLIC_KEY_LEN};
use crate::mse::rc4::Rc4;
use crate::mse::carrier::MseCarrier;
use crate::mse::stream::MseStream;
use crate::utp::UtpStream;

const RC4_DROP: usize = 1024;
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(30);
const CRYPTO_PLAINTEXT: u32 = 0x01;
const CRYPTO_RC4: u32 = 0x02;
const CRYPTO_PROVIDE: u32 = CRYPTO_PLAINTEXT | CRYPTO_RC4;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CryptoSelect {
    Plaintext,
    Rc4,
}

impl CryptoSelect {
    fn from_u32(value: u32) -> Result<Self> {
        match value {
            CRYPTO_PLAINTEXT => Ok(Self::Plaintext),
            CRYPTO_RC4 => Ok(Self::Rc4),
            other => Err(Error::Peer(format!(
                "MSE crypto_select unsupported: {other:#x}"
            ))),
        }
    }

    fn to_u32(self) -> u32 {
        match self {
            Self::Plaintext => CRYPTO_PLAINTEXT,
            Self::Rc4 => CRYPTO_RC4,
        }
    }
}

struct BufIo {
    stream: MseCarrier,
    pending: VecDeque<u8>,
}

impl BufIo {
    fn new(stream: MseCarrier) -> Self {
        Self {
            stream,
            pending: VecDeque::new(),
        }
    }

    async fn write_all(&mut self, data: &[u8]) -> Result<()> {
        self.stream.write_all(data).await
    }

    async fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
        let mut filled = 0;
        while filled < buf.len() {
            if let Some(byte) = self.pending.pop_front() {
                buf[filled] = byte;
                filled += 1;
                continue;
            }
            let n = self.stream.read(&mut buf[filled..]).await?;
            if n == 0 {
                return Err(Error::Peer("MSE connection closed".into()));
            }
            filled += n;
        }
        Ok(())
    }

    async fn read_some(&mut self, buf: &mut [u8]) -> Result<usize> {
        if !self.pending.is_empty() {
            let n = buf.len().min(self.pending.len());
            for slot in buf.iter_mut().take(n) {
                *slot = self.pending.pop_front().expect("pending");
            }
            return Ok(n);
        }
        let n = self.stream.read(buf).await?;
        if n == 0 {
            return Err(Error::Peer("MSE connection closed".into()));
        }
        Ok(n)
    }

    fn into_carrier(self) -> MseCarrier {
        debug_assert!(self.pending.is_empty());
        self.stream
    }
}

fn sha1(parts: &[&[u8]]) -> [u8; 20] {
    let mut h = Sha1::new();
    for p in parts {
        h.update(p);
    }
    h.finalize().into()
}

fn s_bytes(s: &num_bigint::BigUint) -> [u8; PUBLIC_KEY_LEN] {
    dh::encode_public(s)
}

fn init_rc4(outgoing_key: &[u8; 20], incoming_key: &[u8; 20]) -> (Rc4, Rc4) {
    let mut enc = Rc4::new(outgoing_key);
    let mut dec = Rc4::new(incoming_key);
    enc.discard(RC4_DROP);
    dec.discard(RC4_DROP);
    (enc, dec)
}

fn keys_initiator(s: &[u8; PUBLIC_KEY_LEN], skey: &[u8; 20]) -> ([u8; 20], [u8; 20]) {
    (sha1(&[b"keyA", s, skey]), sha1(&[b"keyB", s, skey]))
}

fn keys_acceptor(s: &[u8; PUBLIC_KEY_LEN], skey: &[u8; 20]) -> ([u8; 20], [u8; 20]) {
    (sha1(&[b"keyB", s, skey]), sha1(&[b"keyA", s, skey]))
}

/// Initiator (client) MSE handshake. `skey` is the torrent info-hash.
pub async fn dial_mse(stream: TcpStream, skey: &[u8; 20]) -> Result<MseStream> {
    dial_mse_carrier(MseCarrier::Tcp(stream), skey).await
}

pub async fn dial_mse_utp(stream: UtpStream, skey: &[u8; 20]) -> Result<MseStream> {
    dial_mse_carrier(MseCarrier::Utp(stream), skey).await
}

pub async fn dial_mse_carrier(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
    timeout(HANDSHAKE_TIMEOUT, dial_mse_inner(stream, skey))
        .await
        .map_err(|_| Error::Peer("MSE dial handshake timed out".into()))?
}

async fn dial_mse_inner(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
    let mut sock = BufIo::new(stream);
    let kp = dh::generate_keypair()?;
    sock.write_all(&dh::encode_public(&kp.public)).await?;

    let mut yb_buf = [0u8; PUBLIC_KEY_LEN];
    sock.read_exact(&mut yb_buf).await?;
    drain_pad(&mut sock, 512).await?;

    let secret = dh::shared_secret(&dh::decode_public(&yb_buf), &kp.secret);
    let s = s_bytes(&secret);
    let (out_key, in_key) = keys_initiator(&s, skey);
    let (mut enc, mut dec) = init_rc4(&out_key, &in_key);

    let req1 = sha1(&[b"req1", &s]);
    let mut xor = sha1(&[b"req2", skey]);
    let req3 = sha1(&[b"req3", &s]);
    for (a, b) in xor.iter_mut().zip(req3.iter()) {
        *a ^= *b;
    }

    let mut plain = Vec::with_capacity(16);
    plain.extend_from_slice(&[0u8; 8]);
    plain.extend_from_slice(&CRYPTO_PROVIDE.to_be_bytes());
    plain.extend_from_slice(&0u16.to_be_bytes());
    plain.extend_from_slice(&0u16.to_be_bytes());
    let encrypted = enc.process_copy(&plain);

    let mut packet3 = Vec::with_capacity(40 + encrypted.len());
    packet3.extend_from_slice(&req1);
    packet3.extend_from_slice(&xor);
    packet3.extend_from_slice(&encrypted);
    sock.write_all(&packet3).await?;

    let mut vc = [0u8; 8];
    sock.read_exact(&mut vc).await?;
    dec.process(&mut vc);
    if vc != [0u8; 8] {
        return Err(Error::Peer("MSE VC mismatch (dial)".into()));
    }
    let mut select_buf = [0u8; 4];
    sock.read_exact(&mut select_buf).await?;
    dec.process(&mut select_buf);
    let select = CryptoSelect::from_u32(u32::from_be_bytes(select_buf))?;
    if select.to_u32() & CRYPTO_PROVIDE == 0 {
        return Err(Error::Peer("MSE crypto_select not in provide".into()));
    }
    let mut len_buf = [0u8; 2];
    sock.read_exact(&mut len_buf).await?;
    dec.process(&mut len_buf);
    let pad_d = u16::from_be_bytes(len_buf) as usize;
    if pad_d > 512 {
        return Err(Error::Peer("MSE PadD too large".into()));
    }
    if pad_d > 0 {
        let mut pad = vec![0u8; pad_d];
        sock.read_exact(&mut pad).await?;
        dec.process(&mut pad);
    }

    finish(sock, select, enc, dec)
}

/// Acceptor (server) MSE handshake for a single known `skey` (info-hash).
pub async fn accept_mse(stream: TcpStream, skey: &[u8; 20]) -> Result<MseStream> {
    accept_mse_carrier(MseCarrier::Tcp(stream), skey).await
}

pub async fn accept_mse_utp(stream: UtpStream, skey: &[u8; 20]) -> Result<MseStream> {
    accept_mse_carrier(MseCarrier::Utp(stream), skey).await
}

pub async fn accept_mse_carrier(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
    timeout(HANDSHAKE_TIMEOUT, accept_mse_inner(stream, skey))
        .await
        .map_err(|_| Error::Peer("MSE accept handshake timed out".into()))?
}

async fn accept_mse_inner(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
    let mut sock = BufIo::new(stream);
    let mut ya_buf = [0u8; PUBLIC_KEY_LEN];
    sock.read_exact(&mut ya_buf).await?;

    let kp = dh::generate_keypair()?;
    sock.write_all(&dh::encode_public(&kp.public)).await?;

    let secret = dh::shared_secret(&dh::decode_public(&ya_buf), &kp.secret);
    let s = s_bytes(&secret);
    let req1 = sha1(&[b"req1", &s]);
    sync_hash(&mut sock, &req1, 512).await?;

    let mut xor_buf = [0u8; 20];
    sock.read_exact(&mut xor_buf).await?;
    let req3 = sha1(&[b"req3", &s]);
    let mut req2 = xor_buf;
    for (a, b) in req2.iter_mut().zip(req3.iter()) {
        *a ^= *b;
    }
    if req2 != sha1(&[b"req2", skey]) {
        return Err(Error::Peer("MSE SKEY mismatch (accept)".into()));
    }

    let (out_key, in_key) = keys_acceptor(&s, skey);
    let (mut enc, mut dec) = init_rc4(&out_key, &in_key);

    let mut vc = [0u8; 8];
    sock.read_exact(&mut vc).await?;
    dec.process(&mut vc);
    if vc != [0u8; 8] {
        return Err(Error::Peer("MSE VC mismatch (accept)".into()));
    }
    let mut provide_buf = [0u8; 4];
    sock.read_exact(&mut provide_buf).await?;
    dec.process(&mut provide_buf);
    let provide = u32::from_be_bytes(provide_buf);
    let select = if provide & CRYPTO_RC4 != 0 {
        CryptoSelect::Rc4
    } else if provide & CRYPTO_PLAINTEXT != 0 {
        CryptoSelect::Plaintext
    } else {
        return Err(Error::Peer(
            "MSE crypto_provide has no supported method".into(),
        ));
    };

    let mut len_buf = [0u8; 2];
    sock.read_exact(&mut len_buf).await?;
    dec.process(&mut len_buf);
    let pad_c = u16::from_be_bytes(len_buf) as usize;
    if pad_c > 512 {
        return Err(Error::Peer("MSE PadC too large".into()));
    }
    if pad_c > 0 {
        let mut pad = vec![0u8; pad_c];
        sock.read_exact(&mut pad).await?;
        dec.process(&mut pad);
    }
    sock.read_exact(&mut len_buf).await?;
    dec.process(&mut len_buf);
    let ia_len = u16::from_be_bytes(len_buf) as usize;
    if ia_len > 65_535 {
        return Err(Error::Peer("MSE IA too large".into()));
    }
    if ia_len > 0 {
        let mut ia = vec![0u8; ia_len];
        sock.read_exact(&mut ia).await?;
        dec.process(&mut ia);
    }

    let mut plain = Vec::with_capacity(14);
    plain.extend_from_slice(&[0u8; 8]);
    plain.extend_from_slice(&select.to_u32().to_be_bytes());
    plain.extend_from_slice(&0u16.to_be_bytes());
    let encrypted = enc.process_copy(&plain);
    sock.write_all(&encrypted).await?;

    finish(sock, select, enc, dec)
}

fn finish(sock: BufIo, select: CryptoSelect, enc: Rc4, dec: Rc4) -> Result<MseStream> {
    if !sock.pending.is_empty() {
        return Err(Error::Peer("MSE leftover bytes after handshake".into()));
    }
    let (enc, dec) = match select {
        CryptoSelect::Rc4 => (Some(enc), Some(dec)),
        CryptoSelect::Plaintext => (None, None),
    };
    Ok(MseStream::new(sock.into_carrier(), select, enc, dec))
}

async fn drain_pad(sock: &mut BufIo, max: usize) -> Result<()> {
    let mut total = 0usize;
    let mut buf = [0u8; 64];
    while total < max {
        match timeout(Duration::from_millis(25), sock.read_some(&mut buf)).await {
            Ok(Ok(n)) => total = total.saturating_add(n),
            Ok(Err(err)) => return Err(err),
            Err(_) => break,
        }
    }
    Ok(())
}

async fn sync_hash(sock: &mut BufIo, needle: &[u8; 20], max_pad: usize) -> Result<()> {
    let mut window = Vec::with_capacity(max_pad + 20);
    let mut buf = [0u8; 64];
    while window.len() < max_pad + 20 {
        let n = sock.read_some(&mut buf).await?;
        window.extend_from_slice(&buf[..n]);
        if let Some(pos) = window.windows(20).position(|w| w == needle) {
            let rest = &window[pos + 20..];
            for &byte in rest {
                sock.pending.push_back(byte);
            }
            return Ok(());
        }
    }
    Err(Error::Peer("MSE sync hash not found within pad window".into()))
}