torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Default env-backed SecurePolicy for CLI / simple hosts.

use hmac::{Hmac, Mac};
use rustls::pki_types::CertificateDer;
use sha2::{Digest, Sha256};

use crate::error::{Error, Result};
use crate::secure::credentials::{CredentialBundle, CredentialMode};
use crate::secure::env::SecureEnv;
use crate::secure::policy::{
    Approval, HandshakeOffer, Identity, RatchetContext, SecurePolicy,
};
use crate::secure::tls::TlsMaterial;

type HmacSha256 = Hmac<Sha256>;

/// Wire offer magic for env policy (does not contain the handshake key).
/// v3 binds the offer MAC to the presenter leaf certificate DER hash.
const OFFER_MAGIC: &[u8] = b"tdht-env-v3";
const OFFER_MAC_DOMAIN: &[u8] = b"torrentdht-env-offer-v3";
const OFFER_MAC_LEN: usize = 32;
const MAX_NETWORK_ID_LEN: usize = 1024;

/// Policy driven by `TORRENTDHT_NETWORK_ID` and required `TORRENTDHT_HANDSHAKE_KEY`.
///
/// Handshake offers are MAC'd over `(network_id || sha256(leaf_cert_der))` so approval
/// requires both knowledge of the handshake key and presentation of the bound leaf cert.
pub struct EnvSecurePolicy {
    identity: Identity,
    handshake_key: zeroize::Zeroizing<Vec<u8>>,
    local_leaf_cert_hash: [u8; 32],
}

impl EnvSecurePolicy {
    pub fn from_env() -> Result<Self> {
        let tls = SecureEnv::tls_from_env()?;
        Self::from_env_with_tls(&tls)
    }

    pub fn from_env_with_tls(tls: &TlsMaterial) -> Result<Self> {
        let network_id = SecureEnv::network_id().ok_or_else(|| {
            Error::Secure(format!(
                "missing env {} (required for secure sessions)",
                SecureEnv::NETWORK_ID
            ))
        })?;
        let handshake_key = SecureEnv::handshake_key().ok_or_else(|| {
            Error::Secure(format!(
                "missing env {} (required for secure sessions)",
                SecureEnv::HANDSHAKE_KEY
            ))
        })?;
        let leaf = tls.cert_chain.first().ok_or_else(|| {
            Error::Secure("TLS certificate chain is empty".into())
        })?;
        Self::new(network_id.into_bytes(), handshake_key, leaf.as_ref())
    }

    pub fn new(
        network_id: impl Into<Vec<u8>>,
        handshake_key: impl Into<Vec<u8>>,
        leaf_cert_der: &[u8],
    ) -> Result<Self> {
        let network_id = network_id.into();
        let handshake_key = zeroize::Zeroizing::new(handshake_key.into());
        if network_id.is_empty() {
            return Err(Error::Secure("network id must not be empty".into()));
        }
        if network_id.len() > MAX_NETWORK_ID_LEN {
            return Err(Error::Secure("network id too long".into()));
        }
        if network_id.len() < SecureEnv::MIN_NETWORK_ID_LEN {
            return Err(Error::Secure(format!(
                "network id must be at least {} bytes (got {})",
                SecureEnv::MIN_NETWORK_ID_LEN,
                network_id.len()
            )));
        }
        if handshake_key.is_empty() {
            return Err(Error::Secure("handshake key must not be empty".into()));
        }
        if handshake_key.len() < SecureEnv::MIN_HANDSHAKE_KEY_LEN {
            return Err(Error::Secure(format!(
                "handshake key must be at least {} bytes (got {})",
                SecureEnv::MIN_HANDSHAKE_KEY_LEN,
                handshake_key.len()
            )));
        }
        if leaf_cert_der.is_empty() {
            return Err(Error::Secure("leaf certificate DER must not be empty".into()));
        }
        Ok(Self {
            identity: Identity::new("env", network_id),
            handshake_key,
            local_leaf_cert_hash: leaf_cert_hash(leaf_cert_der),
        })
    }

    pub fn handshake_key(&self) -> &[u8] {
        &self.handshake_key
    }

    fn network_label(&self) -> String {
        String::from_utf8_lossy(&self.identity.bytes).into_owned()
    }

    fn offer_mac(&self, network_id: &[u8], leaf_hash: &[u8; 32]) -> Result<[u8; OFFER_MAC_LEN]> {
        let mut mac = HmacSha256::new_from_slice(&self.handshake_key)
            .map_err(|_| Error::Secure("invalid handshake key for HMAC".into()))?;
        mac.update(OFFER_MAC_DOMAIN);
        mac.update(network_id);
        mac.update(leaf_hash);
        let result = mac.finalize().into_bytes();
        let mut out = [0u8; OFFER_MAC_LEN];
        out.copy_from_slice(&result);
        Ok(out)
    }

    fn build_offer_payload(&self) -> Result<Vec<u8>> {
        let network_id = &self.identity.bytes;
        let mac = self.offer_mac(network_id, &self.local_leaf_cert_hash)?;
        let mut payload =
            Vec::with_capacity(OFFER_MAGIC.len() + 2 + network_id.len() + OFFER_MAC_LEN);
        payload.extend_from_slice(OFFER_MAGIC);
        let len = u16::try_from(network_id.len())
            .map_err(|_| Error::Secure("network id too long".into()))?;
        payload.extend_from_slice(&len.to_be_bytes());
        payload.extend_from_slice(network_id);
        payload.extend_from_slice(&mac);
        Ok(payload)
    }

    fn parse_offer(payload: &[u8]) -> Result<(Vec<u8>, [u8; OFFER_MAC_LEN])> {
        let magic_len = OFFER_MAGIC.len();
        let min = magic_len + 2 + OFFER_MAC_LEN;
        if payload.len() < min {
            return Err(Error::Secure("handshake offer truncated".into()));
        }
        if &payload[..magic_len] != OFFER_MAGIC {
            return Err(Error::Secure("handshake offer version/magic mismatch".into()));
        }
        let id_len = u16::from_be_bytes([payload[magic_len], payload[magic_len + 1]]) as usize;
        if id_len == 0 || id_len > MAX_NETWORK_ID_LEN {
            return Err(Error::Secure("handshake offer has invalid network id length".into()));
        }
        let id_start = magic_len + 2;
        let id_end = id_start.checked_add(id_len).ok_or_else(|| {
            Error::Secure("handshake offer length overflow".into())
        })?;
        let mac_end = id_end.checked_add(OFFER_MAC_LEN).ok_or_else(|| {
            Error::Secure("handshake offer length overflow".into())
        })?;
        if payload.len() != mac_end {
            return Err(Error::Secure("handshake offer has trailing or missing bytes".into()));
        }
        let network_id = payload[id_start..id_end].to_vec();
        let mut mac = [0u8; OFFER_MAC_LEN];
        mac.copy_from_slice(&payload[id_end..mac_end]);
        Ok((network_id, mac))
    }
}

impl SecurePolicy for EnvSecurePolicy {
    fn identity(&self) -> Identity {
        self.identity.clone()
    }

    fn handshake_offer(&self) -> Result<HandshakeOffer> {
        // Prove knowledge of HANDSHAKE_KEY bound to this node's leaf certificate.
        Ok(HandshakeOffer {
            payload: self.build_offer_payload()?,
        })
    }

    fn approve_peer(
        &self,
        peer_offer: &HandshakeOffer,
        peer_certs: &[CertificateDer<'static>],
    ) -> Result<Approval> {
        let leaf = peer_certs.first().ok_or_else(|| {
            Error::Secure("peer mTLS leaf certificate required for approval".into())
        })?;
        let peer_leaf_hash = leaf_cert_hash(leaf.as_ref());
        let (peer_network_id, peer_mac) = Self::parse_offer(&peer_offer.payload)?;
        if !constant_time_eq(&peer_network_id, &self.identity.bytes) {
            return Err(Error::Secure(
                "peer handshake offer rejected (network id mismatch)".into(),
            ));
        }
        let expected_mac = self.offer_mac(&peer_network_id, &peer_leaf_hash)?;
        if !constant_time_eq(&peer_mac, &expected_mac) {
            return Err(Error::Secure(
                "peer handshake offer rejected (authenticator/cert mismatch)".into(),
            ));
        }
        // Never put the handshake key into host-visible handoff fields.
        Ok(Approval {
            peer_label: format!("env:{}", self.network_label()),
            notes: Vec::new(),
        })
    }

    fn ratchet(&self, _ctx: &RatchetContext) -> Result<()> {
        Ok(())
    }

    fn credential_mode(&self) -> CredentialMode {
        CredentialMode::SealedChannel
    }

    fn local_credentials(&self) -> Result<CredentialBundle> {
        Ok(CredentialBundle::new(format!(
            "env-member:{}",
            self.network_label()
        )))
    }
}

fn leaf_cert_hash(der: &[u8]) -> [u8; 32] {
    let digest = Sha256::digest(der);
    let mut out = [0u8; 32];
    out.copy_from_slice(&digest);
    out
}

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

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

    const NET_A: &[u8] = b"network-a-abcdef"; // 16 bytes
    const NET_B: &[u8] = b"network-b-abcdef";
    const KEY: &[u8] = b"0123456789abcdef0123456789abcdef"; // 32 bytes
    const KEY_OTHER: &[u8] = b"fedcba9876543210fedcba9876543210";
    const LEAF_A: &[u8] = b"test-leaf-cert-a-der-bytes!!!!!!";
    const LEAF_B: &[u8] = b"test-leaf-cert-b-der-bytes!!!!!!";

    fn certs(leaf: &'static [u8]) -> Vec<CertificateDer<'static>> {
        vec![CertificateDer::from(leaf)]
    }

    #[test]
    fn rejects_foreign_network_id() {
        let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let foreign = EnvSecurePolicy::new(NET_B, KEY, LEAF_B).expect("policy");
        let offer = foreign.handshake_offer().expect("offer");
        assert!(local.approve_peer(&offer, &certs(LEAF_B)).is_err());
    }

    #[test]
    fn accepts_matching_network_key_and_cert() {
        let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
        let offer = b.handshake_offer().expect("offer");
        let approval = a.approve_peer(&offer, &certs(LEAF_B)).expect("approve");
        assert_eq!(approval.peer_label, "env:network-a-abcdef");
        assert!(!approval.peer_label.contains("shared-key"));
    }

    #[test]
    fn rejects_cert_swap() {
        let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
        let offer = b.handshake_offer().expect("offer");
        // Offer was MAC'd for LEAF_B but peer presents LEAF_A.
        assert!(a.approve_peer(&offer, &certs(LEAF_A)).is_err());
    }

    #[test]
    fn rejects_missing_peer_certs() {
        let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
        let offer = b.handshake_offer().expect("offer");
        assert!(a.approve_peer(&offer, &[]).is_err());
    }

    #[test]
    fn rejects_wrong_handshake_key() {
        let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let foreign = EnvSecurePolicy::new(NET_A, KEY_OTHER, LEAF_B).expect("policy");
        let offer = foreign.handshake_offer().expect("offer");
        assert!(local.approve_peer(&offer, &certs(LEAF_B)).is_err());
    }

    #[test]
    fn rejects_substring_key_spoof() {
        let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let spoof = HandshakeOffer {
            payload: b"torrentdht-env-v1:evil:secret".to_vec(),
        };
        assert!(local.approve_peer(&spoof, &certs(LEAF_A)).is_err());
    }

    #[test]
    fn offer_does_not_contain_raw_handshake_key() {
        let policy = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let offer = policy.handshake_offer().expect("offer");
        assert!(
            !offer
                .payload
                .windows(KEY.len())
                .any(|w| w == KEY),
            "raw handshake key must not appear in offer"
        );
        assert!(offer.payload.starts_with(OFFER_MAGIC));
    }

    #[test]
    fn credentials_do_not_echo_handshake_key() {
        let policy = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
        let creds = policy.local_credentials().expect("creds");
        assert_eq!(creds.bytes, b"env-member:network-a-abcdef");
        assert!(!creds.bytes.windows(KEY.len()).any(|w| w == KEY));
    }

    #[test]
    fn rejects_empty_network_id_and_key() {
        assert!(EnvSecurePolicy::new(b"", KEY, LEAF_A).is_err());
        assert!(EnvSecurePolicy::new(NET_A, b"", LEAF_A).is_err());
        assert!(EnvSecurePolicy::new(b"short", KEY, LEAF_A).is_err());
        assert!(EnvSecurePolicy::new(NET_A, b"short-key", LEAF_A).is_err());
        assert!(EnvSecurePolicy::new(NET_A, KEY, b"").is_err());
    }
}