torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};

use crate::error::{Error, Result};

pub fn is_blocked_ip(ip: IpAddr) -> bool {
    match ip {
        IpAddr::V4(v4) => is_blocked_ipv4(v4),
        IpAddr::V6(v6) => is_blocked_ipv6(v6),
    }
}

/// Drop dial candidates in blocked address classes when `block_private` is set.
///
/// Prefer [`crate::net::DialGate`] at call sites — this thin wrapper remains for
/// tracker announce return filtering. Host `add_static_peers` stay unfiltered.
pub fn filter_peers_for_dial(
    peers: impl IntoIterator<Item = SocketAddr>,
    block_private: bool,
) -> Vec<SocketAddr> {
    crate::net::DialGate::from_block_private(block_private).filter(peers)
}

fn is_blocked_ipv4(ip: Ipv4Addr) -> bool {
    ip.is_private()
        || ip.is_loopback()
        || ip.is_link_local()
        || ip.is_unspecified()
        || ip.is_broadcast()
        || ip.is_multicast()
        || ip.octets()[0] == 0
        || ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1]) // CGNAT 100.64.0.0/10
        || ip.octets()[0] >= 240 // 240.0.0.0/4 reserved
}

fn is_blocked_ipv6(ip: Ipv6Addr) -> bool {
    if let Some(v4) = ip.to_ipv4_mapped() {
        return is_blocked_ipv4(v4);
    }
    ip.is_loopback()
        || ip.is_unspecified()
        || ip.is_multicast()
        || ip.segments()[0] & 0xfe00 == 0xfc00 // unique local fc00::/7
        || ip.segments()[0] & 0xffc0 == 0xfe80 // link-local fe80::/10
}

pub fn resolve_tracker_socket(host: &str, port: u16, block_private: bool) -> Result<SocketAddr> {
    if let Ok(ip) = host.parse::<IpAddr>() {
        if block_private && is_blocked_ip(ip) {
            return Err(Error::Tracker(format!(
                "tracker host {host} resolves to blocked address {ip}"
            )));
        }
        return Ok(SocketAddr::new(ip, port));
    }

    let spec = format!("{host}:{port}");
    let mut last_err = None;
    for addr in spec.to_socket_addrs().map_err(|err| {
        Error::Tracker(format!("resolve tracker {spec}: {err}"))
    })? {
        if block_private && is_blocked_ip(addr.ip()) {
            last_err = Some(addr.ip());
            continue;
        }
        return Ok(addr);
    }

    Err(if let Some(ip) = last_err {
        Error::Tracker(format!(
            "tracker {spec} resolved only to blocked address {ip}"
        ))
    } else {
        Error::Tracker(format!("could not resolve tracker {spec}"))
    })
}

pub fn ensure_http_ok(response: &[u8]) -> Result<()> {
    let line_end = response
        .iter()
        .position(|&b| b == b'\n')
        .ok_or_else(|| Error::Tracker("tracker response missing status line".into()))?;
    let status = std::str::from_utf8(&response[..line_end])
        .map_err(|_| Error::Tracker("tracker status line is not utf-8".into()))?;

    if status.starts_with("HTTP/1.1 301 ")
        || status.starts_with("HTTP/1.0 301 ")
        || status.starts_with("HTTP/1.1 302 ")
        || status.starts_with("HTTP/1.0 302 ")
        || status.starts_with("HTTP/1.1 303 ")
        || status.starts_with("HTTP/1.0 303 ")
        || status.starts_with("HTTP/1.1 307 ")
        || status.starts_with("HTTP/1.0 307 ")
        || status.starts_with("HTTP/1.1 308 ")
        || status.starts_with("HTTP/1.0 308 ")
    {
        return Err(Error::Tracker(
            "tracker redirect responses are not followed".into(),
        ));
    }

    if !(status.starts_with("HTTP/1.1 2") || status.starts_with("HTTP/1.0 2")) {
        return Err(Error::Tracker(format!("tracker returned non-success: {status}")));
    }
    Ok(())
}

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

    #[test]
    fn blocks_loopback() {
        assert!(is_blocked_ip("127.0.0.1".parse().expect("ip")));
        assert!(is_blocked_ip("::1".parse().expect("ip")));
    }

    #[test]
    fn blocks_rfc1918() {
        assert!(is_blocked_ip("10.0.0.1".parse().expect("ip")));
        assert!(is_blocked_ip("192.168.1.1".parse().expect("ip")));
    }

    #[test]
    fn allows_public() {
        assert!(!is_blocked_ip("203.0.113.1".parse().expect("ip")));
    }

    #[test]
    fn blocks_ipv4_multicast() {
        assert!(is_blocked_ip("224.0.0.1".parse().expect("ip")));
        assert!(is_blocked_ip("239.255.255.250".parse().expect("ip")));
    }

    #[test]
    fn filter_peers_for_dial_drops_blocked() {
        let peers = [
            "203.0.113.1:6881".parse().expect("pub"),
            "10.0.0.1:6881".parse().expect("priv"),
            "127.0.0.1:6881".parse().expect("loop"),
        ];
        let kept = filter_peers_for_dial(peers, true);
        assert_eq!(kept.len(), 1);
        assert_eq!(kept[0].ip().to_string(), "203.0.113.1");
        assert_eq!(filter_peers_for_dial(peers, false).len(), 3);
    }

    #[test]
    fn rejects_redirect_status() {
        assert!(ensure_http_ok(b"HTTP/1.1 302 Found\r\n\r\n").is_err());
        assert!(ensure_http_ok(b"HTTP/1.1 200 OK\r\n\r\n").is_ok());
    }
}