torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::net::SocketAddr;
use std::time::{Duration, Instant};

use hmac::{Hmac, Mac};
use sha1::Sha1;

use crate::dht::node_id::NodeId;

type HmacSha1 = Hmac<Sha1>;

const ROTATION_INTERVAL: Duration = Duration::from_secs(300);

/// BEP-5-style announce tokens with rotating random secret (HMAC-SHA1).
#[derive(Debug)]
pub struct AnnounceTokenTable {
    current: [u8; 20],
    previous: Option<[u8; 20]>,
    rotated_at: Instant,
}

impl AnnounceTokenTable {
    pub fn random() -> Self {
        Self {
            current: *NodeId::random().as_bytes(),
            previous: None,
            rotated_at: Instant::now(),
        }
    }

    pub fn issue(&mut self, addr: SocketAddr) -> Vec<u8> {
        self.maybe_rotate();
        self.issue_for_secret(self.current, addr)
    }

    pub fn verify(&mut self, addr: SocketAddr, token: &[u8]) -> bool {
        if token.is_empty() || token.len() > 64 {
            return false;
        }
        self.maybe_rotate();
        let current = self.issue_for_secret(self.current, addr);
        if current.len() == token.len() && constant_time_eq(&current, token) {
            return true;
        }
        if let Some(previous) = self.previous {
            let legacy = self.issue_for_secret(previous, addr);
            return legacy.len() == token.len() && constant_time_eq(&legacy, token);
        }
        false
    }

    fn maybe_rotate(&mut self) {
        if self.rotated_at.elapsed() < ROTATION_INTERVAL {
            return;
        }
        self.previous = Some(self.current);
        self.current = *NodeId::random().as_bytes();
        self.rotated_at = Instant::now();
    }

    fn issue_for_secret(&self, secret: [u8; 20], addr: SocketAddr) -> Vec<u8> {
        let mut mac = HmacSha1::new_from_slice(&secret)
            .expect("HMAC-SHA1 accepts any key length");
        mac.update(&addr_material(addr));
        let digest = mac.finalize().into_bytes();
        digest[..8].to_vec()
    }
}

fn addr_material(addr: SocketAddr) -> Vec<u8> {
    let mut out = Vec::with_capacity(18);
    match addr {
        SocketAddr::V4(v4) => {
            out.extend_from_slice(&v4.ip().octets());
            out.extend_from_slice(&v4.port().to_be_bytes());
        }
        SocketAddr::V6(v6) => {
            out.extend_from_slice(&v6.ip().octets());
            out.extend_from_slice(&v6.port().to_be_bytes());
        }
    }
    out
}

fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
    if a.len() != b.len() {
        return false;
    }
    a.iter()
        .zip(b.iter())
        .fold(0u8, |acc, (x, y)| acc | (x ^ y))
        == 0
}

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

    #[test]
    fn token_roundtrip_for_addr() {
        let mut table = AnnounceTokenTable::random();
        let addr: SocketAddr = "203.0.113.7:6881".parse().expect("addr");
        let token = table.issue(addr);
        assert!(table.verify(addr, &token));
    }

    #[test]
    fn token_rejects_wrong_addr() {
        let mut table = AnnounceTokenTable::random();
        let a: SocketAddr = "203.0.113.7:6881".parse().expect("a");
        let b: SocketAddr = "203.0.113.8:6881".parse().expect("b");
        let token = table.issue(a);
        assert!(!table.verify(b, &token));
    }

    #[test]
    fn previous_secret_accepts_during_rotation_window() {
        let mut table = AnnounceTokenTable::random();
        let addr: SocketAddr = "203.0.113.7:6881".parse().expect("addr");
        let old = table.issue(addr);
        table.previous = Some(table.current);
        table.current = *NodeId::random().as_bytes();
        assert!(table.verify(addr, &old));
    }
}