torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! BEP 52 peer-wire merkle hash messages (IDs 21–23).

use crate::error::{Error, Result};
use crate::piece::MERKLE_BLOCK_SIZE;
use crate::torrent::{MetaVersion, TorrentInfo, V2FileMeta, V2Meta};

/// `hash request` / `hash reject` fixed payload size (root + 4×u32).
pub const HASH_REQUEST_PAYLOAD_LEN: usize = 32 + 4 * 4;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashRequest {
    pub pieces_root: [u8; 32],
    pub base_layer: u32,
    pub index: u32,
    pub length: u32,
    pub proof_layers: u32,
}

impl HashRequest {
    pub fn encode_payload(&self) -> [u8; HASH_REQUEST_PAYLOAD_LEN] {
        let mut out = [0u8; HASH_REQUEST_PAYLOAD_LEN];
        out[..32].copy_from_slice(&self.pieces_root);
        out[32..36].copy_from_slice(&self.base_layer.to_be_bytes());
        out[36..40].copy_from_slice(&self.index.to_be_bytes());
        out[40..44].copy_from_slice(&self.length.to_be_bytes());
        out[44..48].copy_from_slice(&self.proof_layers.to_be_bytes());
        out
    }

    pub fn decode_payload(payload: &[u8]) -> Result<Self> {
        if payload.len() != HASH_REQUEST_PAYLOAD_LEN {
            return Err(Error::Peer(format!(
                "hash request payload length {} != {HASH_REQUEST_PAYLOAD_LEN}",
                payload.len()
            )));
        }
        let mut pieces_root = [0u8; 32];
        pieces_root.copy_from_slice(&payload[..32]);
        Ok(Self {
            pieces_root,
            base_layer: u32::from_be_bytes(payload[32..36].try_into().expect("base")),
            index: u32::from_be_bytes(payload[36..40].try_into().expect("index")),
            length: u32::from_be_bytes(payload[40..44].try_into().expect("length")),
            proof_layers: u32::from_be_bytes(payload[44..48].try_into().expect("proof")),
        })
    }

    pub fn validate_shape(&self) -> Result<()> {
        if self.length < 2 || !self.length.is_power_of_two() {
            return Err(Error::Peer(
                "hash request length must be >= 2 and a power of two".into(),
            ));
        }
        if self.length > 512 {
            return Err(Error::Peer(
                "hash request length must not exceed 512".into(),
            ));
        }
        if !self.index.is_multiple_of(self.length) {
            return Err(Error::Peer(
                "hash request index must be a multiple of length".into(),
            ));
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashHashes {
    pub request: HashRequest,
    pub hashes: Vec<[u8; 32]>,
}

impl HashHashes {
    pub fn encode_payload(&self) -> Vec<u8> {
        let mut out = Vec::with_capacity(HASH_REQUEST_PAYLOAD_LEN + self.hashes.len() * 32);
        out.extend_from_slice(&self.request.encode_payload());
        for hash in &self.hashes {
            out.extend_from_slice(hash);
        }
        out
    }

    pub fn decode_payload(payload: &[u8]) -> Result<Self> {
        if payload.len() < HASH_REQUEST_PAYLOAD_LEN {
            return Err(Error::Peer("hashes payload too short".into()));
        }
        if !(payload.len() - HASH_REQUEST_PAYLOAD_LEN).is_multiple_of(32) {
            return Err(Error::Peer(
                "hashes payload tail must be a multiple of 32".into(),
            ));
        }
        let request = HashRequest::decode_payload(&payload[..HASH_REQUEST_PAYLOAD_LEN])?;
        let mut hashes = Vec::new();
        for chunk in payload[HASH_REQUEST_PAYLOAD_LEN..].chunks_exact(32) {
            let mut hash = [0u8; 32];
            hash.copy_from_slice(chunk);
            hashes.push(hash);
        }
        Ok(Self { request, hashes })
    }
}

/// Base-layer index of the piece layer for `piece_length` (0 when piece == 16 KiB leaf).
pub fn piece_layer_base(piece_length: u32) -> u32 {
    let blocks = (piece_length.max(1) as usize) / MERKLE_BLOCK_SIZE;
    if blocks <= 1 {
        return 0;
    }
    blocks.trailing_zeros()
}

/// Reserved bit: last byte, 4th MSB (`0x10`) — hybrid/v2 protocol capability.
pub const V2_RESERVED_BIT: u8 = 0x10;

pub fn enable_v2(reserved: &mut [u8; 8]) {
    reserved[7] |= V2_RESERVED_BIT;
}

pub fn supports_v2(reserved: &[u8; 8]) -> bool {
    reserved[7] & V2_RESERVED_BIT != 0
}

fn find_file<'a>(v2: &'a V2Meta, root: &[u8; 32]) -> Option<&'a V2FileMeta> {
    v2.files.iter().find(|f| &f.pieces_root == root)
}

/// Answer a piece-layer hash request from torrent v2 metadata (proof_layers must be 0).
pub fn serve_piece_layer_hashes(
    info: &TorrentInfo,
    request: &HashRequest,
) -> Result<Option<HashHashes>> {
    request.validate_shape()?;
    if info.meta_version == MetaVersion::V1 {
        return Ok(None);
    }
    let Some(v2) = info.v2.as_ref() else {
        return Ok(None);
    };
    let expected_base = piece_layer_base(info.piece_length);
    if request.base_layer != expected_base {
        // Only piece-layer serving is required for interop with our stored layers.
        return Ok(None);
    }
    if request.proof_layers != 0 {
        // Proof construction beyond the piece layer is deferred; reject via None.
        return Ok(None);
    }
    let Some(file) = find_file(v2, &request.pieces_root) else {
        return Ok(None);
    };
    let start = request.index as usize;
    let end = start.saturating_add(request.length as usize);
    if end > file.piece_hashes.len() {
        return Ok(None);
    }
    let hashes = file.piece_hashes[start..end].to_vec();
    Ok(Some(HashHashes {
        request: request.clone(),
        hashes,
    }))
}

/// Wire answer for a [`HashRequest`] (caller enforces choke / upload budgeting).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HashRequestAnswer {
    Hashes(HashHashes),
    Reject(HashRequest),
}

impl HashRequestAnswer {
    pub fn resolve(info: &TorrentInfo, request: HashRequest) -> Self {
        match serve_piece_layer_hashes(info, &request) {
            Ok(Some(hashes)) => Self::Hashes(hashes),
            Ok(None) => Self::Reject(request),
            Err(err) => {
                tracing::debug!(%err, "invalid hash request");
                Self::Reject(request)
            }
        }
    }

    /// Payload bytes that count toward the upload limiter (same basis as piece data).
    pub fn upload_bytes(&self) -> u64 {
        match self {
            Self::Hashes(hashes) => hashes.encode_payload().len() as u64,
            Self::Reject(_) => HASH_REQUEST_PAYLOAD_LEN as u64,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::torrent::{InfoHash, V2FileMeta};
    use std::path::PathBuf;

    #[test]
    fn hash_request_roundtrip() {
        let req = HashRequest {
            pieces_root: [0xAB; 32],
            base_layer: 0,
            index: 0,
            length: 2,
            proof_layers: 0,
        };
        let decoded = HashRequest::decode_payload(&req.encode_payload()).expect("decode");
        assert_eq!(decoded, req);
    }

    #[test]
    fn serves_piece_layer_slice() {
        let hashes = vec![[1u8; 32], [2u8; 32], [3u8; 32], [4u8; 32]];
        let root = crate::piece::merkle::pieces_root_from_layer(&hashes);
        let info = TorrentInfo {
            info_hash: InfoHash::from_bytes([0; 20]),
            info_hash_v2: None,
            name: "x".into(),
            piece_length: MERKLE_BLOCK_SIZE as u32,
            pieces: vec![[0; 20]; 4],
            files: vec![(PathBuf::from("x"), 4 * MERKLE_BLOCK_SIZE as u64)],
            total_len: 4 * MERKLE_BLOCK_SIZE as u64,
            private: false,
            meta_version: MetaVersion::Hybrid,
            v2: Some(V2Meta {
                files: vec![V2FileMeta {
                    path: PathBuf::from("x"),
                    length: 4 * MERKLE_BLOCK_SIZE as u64,
                    pieces_root: root,
                    piece_hashes: hashes.clone(),
                }],
                piece_hashes: hashes.clone(),
                pieces_root: root,
            }),
        };
        let req = HashRequest {
            pieces_root: root,
            base_layer: 0,
            index: 0,
            length: 2,
            proof_layers: 0,
        };
        let served = serve_piece_layer_hashes(&info, &req)
            .expect("serve")
            .expect("some");
        assert_eq!(served.hashes, hashes[..2]);

        let answer = HashRequestAnswer::resolve(&info, req.clone());
        assert!(matches!(answer, HashRequestAnswer::Hashes(_)));
        assert_eq!(answer.upload_bytes(), (48 + 2 * 32) as u64);

        let bad = HashRequest {
            pieces_root: [0; 32],
            base_layer: 0,
            index: 0,
            length: 2,
            proof_layers: 0,
        };
        assert!(matches!(
            HashRequestAnswer::resolve(&info, bad),
            HashRequestAnswer::Reject(_)
        ));
    }
}