torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use crate::error::{Error, Result};
use crate::security::MAX_PEER_MESSAGE_PAYLOAD;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PeerMessageId {
    Choke = 0,
    Unchoke = 1,
    Interested = 2,
    NotInterested = 3,
    Have = 4,
    Bitfield = 5,
    Request = 6,
    Piece = 7,
    Cancel = 8,
    SuggestPiece = 13,
    HaveAll = 14,
    HaveNone = 15,
    RejectRequest = 16,
    AllowedFast = 17,
    HashRequest = 21,
    Hashes = 22,
    HashReject = 23,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PeerMessage {
    KeepAlive,
    Choke,
    Unchoke,
    Interested,
    NotInterested,
    Have(u32),
    Bitfield(Vec<u8>),
    Request { index: u32, begin: u32, length: u32 },
    Piece {
        index: u32,
        begin: u32,
        data: Vec<u8>,
    },
    Cancel { index: u32, begin: u32, length: u32 },
    Port(u16),
    SuggestPiece(u32),
    HaveAll,
    HaveNone,
    RejectRequest { index: u32, begin: u32, length: u32 },
    AllowedFast(u32),
    HashRequest(crate::peer::hash_messages::HashRequest),
    Hashes(crate::peer::hash_messages::HashHashes),
    HashReject(crate::peer::hash_messages::HashRequest),
    Extended { id: u8, payload: Vec<u8> },
}

impl PeerMessage {
    pub fn id(&self) -> Option<PeerMessageId> {
        match self {
            Self::KeepAlive => None,
            Self::Choke => Some(PeerMessageId::Choke),
            Self::Unchoke => Some(PeerMessageId::Unchoke),
            Self::Interested => Some(PeerMessageId::Interested),
            Self::NotInterested => Some(PeerMessageId::NotInterested),
            Self::Have(_) => Some(PeerMessageId::Have),
            Self::Bitfield(_) => Some(PeerMessageId::Bitfield),
            Self::Request { .. } => Some(PeerMessageId::Request),
            Self::Piece { .. } => Some(PeerMessageId::Piece),
            Self::Cancel { .. } => Some(PeerMessageId::Cancel),
            Self::Port(_) => None,
            Self::SuggestPiece(_) => Some(PeerMessageId::SuggestPiece),
            Self::HaveAll => Some(PeerMessageId::HaveAll),
            Self::HaveNone => Some(PeerMessageId::HaveNone),
            Self::RejectRequest { .. } => Some(PeerMessageId::RejectRequest),
            Self::AllowedFast(_) => Some(PeerMessageId::AllowedFast),
            Self::HashRequest(_) => Some(PeerMessageId::HashRequest),
            Self::Hashes(_) => Some(PeerMessageId::Hashes),
            Self::HashReject(_) => Some(PeerMessageId::HashReject),
            Self::Extended { .. } => None,
        }
    }

    pub fn encode(&self) -> Vec<u8> {
        match self {
            Self::KeepAlive => vec![0, 0, 0, 0],
            Self::Choke
            | Self::Unchoke
            | Self::Interested
            | Self::NotInterested => {
                let id = self.id().expect("message id") as u8;
                vec![0, 0, 0, 1, id]
            }
            Self::Have(index) => {
                let mut out = vec![0, 0, 0, 5, PeerMessageId::Have as u8];
                out.extend(index.to_be_bytes());
                out
            }
            Self::Bitfield(bits) => {
                let len = 1 + bits.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(PeerMessageId::Bitfield as u8);
                out.extend(bits);
                out
            }
            Self::Request { index, begin, length } => {
                let mut out = vec![0, 0, 0, 13, PeerMessageId::Request as u8];
                out.extend(index.to_be_bytes());
                out.extend(begin.to_be_bytes());
                out.extend(length.to_be_bytes());
                out
            }
            Self::Piece { index, begin, data } => {
                let len = 9 + data.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(PeerMessageId::Piece as u8);
                out.extend(index.to_be_bytes());
                out.extend(begin.to_be_bytes());
                out.extend(data);
                out
            }
            Self::Cancel { index, begin, length } => {
                let mut out = vec![0, 0, 0, 13, PeerMessageId::Cancel as u8];
                out.extend(index.to_be_bytes());
                out.extend(begin.to_be_bytes());
                out.extend(length.to_be_bytes());
                out
            }
            Self::Port(port) => {
                let mut out = vec![0, 0, 0, 3, 9];
                out.extend(port.to_be_bytes());
                out
            }
            Self::SuggestPiece(index) => {
                let mut out = vec![0, 0, 0, 5, PeerMessageId::SuggestPiece as u8];
                out.extend(index.to_be_bytes());
                out
            }
            Self::HaveAll => vec![0, 0, 0, 1, PeerMessageId::HaveAll as u8],
            Self::HaveNone => vec![0, 0, 0, 1, PeerMessageId::HaveNone as u8],
            Self::RejectRequest { index, begin, length } => {
                let mut out = vec![0, 0, 0, 13, PeerMessageId::RejectRequest as u8];
                out.extend(index.to_be_bytes());
                out.extend(begin.to_be_bytes());
                out.extend(length.to_be_bytes());
                out
            }
            Self::AllowedFast(index) => {
                let mut out = vec![0, 0, 0, 5, PeerMessageId::AllowedFast as u8];
                out.extend(index.to_be_bytes());
                out
            }
            Self::HashRequest(req) => {
                let payload = req.encode_payload();
                let len = 1 + payload.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(PeerMessageId::HashRequest as u8);
                out.extend_from_slice(&payload);
                out
            }
            Self::Hashes(hashes) => {
                let payload = hashes.encode_payload();
                let len = 1 + payload.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(PeerMessageId::Hashes as u8);
                out.extend_from_slice(&payload);
                out
            }
            Self::HashReject(req) => {
                let payload = req.encode_payload();
                let len = 1 + payload.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(PeerMessageId::HashReject as u8);
                out.extend_from_slice(&payload);
                out
            }
            Self::Extended { id, payload } => {
                let len = 1 + 1 + payload.len();
                let mut out = Vec::with_capacity(4 + len);
                out.extend((len as u32).to_be_bytes());
                out.push(20);
                out.push(*id);
                out.extend(payload);
                out
            }
        }
    }

    pub fn decode(input: &[u8]) -> Result<(Self, &[u8])> {
        match Self::try_decode(input)? {
            FrameDecode::NeedMore => Err(Error::Peer("incomplete peer message".into())),
            FrameDecode::Frame { message, rest } => Ok((message, rest)),
        }
    }

    /// Distinguish incomplete buffers from fatal protocol errors.
    pub fn try_decode(input: &[u8]) -> Result<FrameDecode<'_>> {
        if input.len() < 4 {
            return Ok(FrameDecode::NeedMore);
        }
        let length = u32::from_be_bytes([input[0], input[1], input[2], input[3]]) as usize;
        if length > MAX_PEER_MESSAGE_PAYLOAD {
            return Err(Error::Peer(format!(
                "peer message length {length} exceeds max {MAX_PEER_MESSAGE_PAYLOAD}"
            )));
        }
        if length == 0 {
            return Ok(FrameDecode::Frame {
                message: Self::KeepAlive,
                rest: &input[4..],
            });
        }
        if input.len() < 4 + length {
            return Ok(FrameDecode::NeedMore);
        }
        let id = input[4];
        let payload = &input[5..4 + length];
        let rest = &input[4 + length..];

        let message = match id {
            0 => {
                require_exact_payload(payload, 0, "choke")?;
                Self::Choke
            }
            1 => {
                require_exact_payload(payload, 0, "unchoke")?;
                Self::Unchoke
            }
            2 => {
                require_exact_payload(payload, 0, "interested")?;
                Self::Interested
            }
            3 => {
                require_exact_payload(payload, 0, "not interested")?;
                Self::NotInterested
            }
            4 => {
                require_exact_payload(payload, 4, "have")?;
                let index = read_u32(payload)?;
                Self::Have(index)
            }
            5 => Self::Bitfield(payload.to_vec()),
            6 => {
                require_exact_payload(payload, 12, "request")?;
                let (index, begin, length) = read_request(payload)?;
                Self::Request {
                    index,
                    begin,
                    length,
                }
            }
            7 => {
                let (index, begin, data) = read_piece(payload)?;
                Self::Piece { index, begin, data }
            }
            8 => {
                require_exact_payload(payload, 12, "cancel")?;
                let (index, begin, length) = read_request(payload)?;
                Self::Cancel {
                    index,
                    begin,
                    length,
                }
            }
            9 => {
                // BEP 5 Port — fixed 2-byte payload.
                require_exact_payload(payload, 2, "port")?;
                let port = u16::from_be_bytes([payload[0], payload[1]]);
                Self::Port(port)
            }
            13 => {
                require_exact_payload(payload, 4, "suggest piece")?;
                let index = read_u32(payload)?;
                Self::SuggestPiece(index)
            }
            14 => {
                require_exact_payload(payload, 0, "have all")?;
                Self::HaveAll
            }
            15 => {
                require_exact_payload(payload, 0, "have none")?;
                Self::HaveNone
            }
            16 => {
                require_exact_payload(payload, 12, "reject request")?;
                let (index, begin, length) = read_request(payload)?;
                Self::RejectRequest {
                    index,
                    begin,
                    length,
                }
            }
            17 => {
                require_exact_payload(payload, 4, "allowed fast")?;
                let index = read_u32(payload)?;
                Self::AllowedFast(index)
            }
            21 => {
                let req = crate::peer::hash_messages::HashRequest::decode_payload(payload)?;
                Self::HashRequest(req)
            }
            22 => {
                let hashes = crate::peer::hash_messages::HashHashes::decode_payload(payload)?;
                Self::Hashes(hashes)
            }
            23 => {
                let req = crate::peer::hash_messages::HashRequest::decode_payload(payload)?;
                Self::HashReject(req)
            }
            20 => {
                if payload.is_empty() {
                    return Err(Error::Peer("extended message missing id".into()));
                }
                let id = payload[0];
                Self::Extended {
                    id,
                    payload: payload[1..].to_vec(),
                }
            }
            // Forward-compat: skip unknown message IDs (BEP 3).
            _ => Self::KeepAlive,
        };
        Ok(FrameDecode::Frame { message, rest })
    }
}

/// Result of attempting to parse one peer wire frame from a buffer.
pub enum FrameDecode<'a> {
    NeedMore,
    Frame { message: PeerMessage, rest: &'a [u8] },
}

fn require_exact_payload(payload: &[u8], expected: usize, name: &str) -> Result<()> {
    if payload.len() != expected {
        return Err(Error::Peer(format!(
            "{name} payload length {} != {expected}",
            payload.len()
        )));
    }
    Ok(())
}

fn read_u32(payload: &[u8]) -> Result<u32> {
    let bytes: [u8; 4] = payload
        .get(..4)
        .ok_or_else(|| Error::Peer("payload too short for u32".into()))?
        .try_into()
        .expect("slice to array");
    Ok(u32::from_be_bytes(bytes))
}

fn read_request(payload: &[u8]) -> Result<(u32, u32, u32)> {
    if payload.len() < 12 {
        return Err(Error::Peer("request payload too short".into()));
    }
    Ok((
        u32::from_be_bytes(payload[0..4].try_into().expect("index")),
        u32::from_be_bytes(payload[4..8].try_into().expect("begin")),
        u32::from_be_bytes(payload[8..12].try_into().expect("length")),
    ))
}

fn read_piece(payload: &[u8]) -> Result<(u32, u32, Vec<u8>)> {
    if payload.len() < 8 {
        return Err(Error::Peer("piece payload too short".into()));
    }
    let index = u32::from_be_bytes(payload[0..4].try_into().expect("index"));
    let begin = u32::from_be_bytes(payload[4..8].try_into().expect("begin"));
    Ok((index, begin, payload[8..].to_vec()))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn hash_messages_roundtrip_on_peer_wire() {
        let req = crate::peer::hash_messages::HashRequest {
            pieces_root: [0x11; 32],
            base_layer: 0,
            index: 0,
            length: 2,
            proof_layers: 0,
        };
        let hashes = PeerMessage::Hashes(crate::peer::hash_messages::HashHashes {
            request: req.clone(),
            hashes: vec![[0x22; 32], [0x33; 32]],
        });
        let encoded = hashes.encode();
        let (decoded, rest) = PeerMessage::decode(&encoded).expect("decode");
        assert!(rest.is_empty());
        assert_eq!(decoded, hashes);

        let reject = PeerMessage::HashReject(req);
        let encoded = reject.encode();
        let (decoded, rest) = PeerMessage::decode(&encoded).expect("decode reject");
        assert!(rest.is_empty());
        assert_eq!(decoded, reject);
    }
}