torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Environment-backed TLS and secure-session configuration.

use std::path::PathBuf;

use crate::error::{Error, Result};
use crate::secure::tls::TlsMaterial;

/// Env vars consumed by the secure discovery stack (overridable via API).
pub struct SecureEnv;

impl SecureEnv {
    pub const CA_CERT: &'static str = "TORRENTDHT_CA_CERT";
    pub const CERT: &'static str = "TORRENTDHT_CERT";
    pub const KEY: &'static str = "TORRENTDHT_KEY";
    pub const NETWORK_ID: &'static str = "TORRENTDHT_NETWORK_ID";
    pub const PEER_STORE: &'static str = "TORRENTDHT_PEER_STORE";
    pub const STATE_DIR: &'static str = "TORRENTDHT_STATE_DIR";
    pub const LISTEN_ADDR: &'static str = "TORRENTDHT_LISTEN_ADDR";
    pub const HANDSHAKE_KEY: &'static str = "TORRENTDHT_HANDSHAKE_KEY";

    pub fn tls_from_env() -> Result<TlsMaterial> {
        let ca = std::env::var(Self::CA_CERT).map_err(|_| {
            Error::Secure(format!("missing env {}", Self::CA_CERT))
        })?;
        let cert = std::env::var(Self::CERT).map_err(|_| {
            Error::Secure(format!("missing env {}", Self::CERT))
        })?;
        let key = std::env::var(Self::KEY).map_err(|_| {
            Error::Secure(format!("missing env {}", Self::KEY))
        })?;
        TlsMaterial::from_pem_files(PathBuf::from(ca), PathBuf::from(cert), PathBuf::from(key))
    }

    pub fn network_id() -> Option<String> {
        std::env::var(Self::NETWORK_ID).ok()
    }

    pub fn peer_store_path() -> Option<PathBuf> {
        std::env::var(Self::PEER_STORE).ok().map(PathBuf::from)
    }

    pub fn state_dir() -> Option<PathBuf> {
        std::env::var(Self::STATE_DIR).ok().map(PathBuf::from)
    }

    pub fn listen_addr() -> Option<String> {
        std::env::var(Self::LISTEN_ADDR).ok()
    }

    pub fn handshake_key() -> Option<Vec<u8>> {
        std::env::var(Self::HANDSHAKE_KEY).ok().map(|s| s.into_bytes())
    }

    /// Minimum lengths for commercial deployment (network id + handshake key).
    pub const MIN_NETWORK_ID_LEN: usize = 16;
    pub const MIN_HANDSHAKE_KEY_LEN: usize = 32;

    /// Human-readable list of required env vars for `Client::open`.
    pub fn required_env_help() -> &'static str {
        "Required secure-session environment:\n\
         \n\
         TORRENTDHT_CA_CERT=/path/to/ca.pem\n\
         TORRENTDHT_CERT=/path/to/node.pem\n\
         TORRENTDHT_KEY=/path/to/node-key.pem\n\
         TORRENTDHT_NETWORK_ID=<high-entropy private network name, >=16 chars>\n\
         TORRENTDHT_HANDSHAKE_KEY=<shared secret, >=32 bytes>\n\
         \n\
         Optional:\n\
         TORRENTDHT_PEER_STORE=/path/to/peers.kdl\n\
         TORRENTDHT_STATE_DIR=/path/to/host-state (peers, DHT, resume/ledger; else under download-dir)\n\
         TORRENTDHT_LISTEN_ADDR=0.0.0.0:6881\n\
         TORRENTDHT_RPC_TOKEN=<rpc auth token when rpc-enabled>\n\
         \n\
         Notes:\n\
         - NETWORK_ID is capability-bearing: SHA-1(NETWORK_ID) is announced on public DHT.\n\
           Use a high-entropy value; anyone who knows it can enumerate member addresses.\n\
         - Membership is network-wide: an approved peer can join any torrent loaded on this Client.\n\
         - Run `torrentdht env-check` to validate paths without starting a session.\n\
         - Optional features (RPC, PEX, webseed/FTP, NAT, uTP) default off — enable explicitly."
    }

    /// Validate that required env vars are present and TLS files load.
    pub fn check_required() -> Result<()> {
        let mut missing = Vec::new();
        for key in [Self::CA_CERT, Self::CERT, Self::KEY, Self::NETWORK_ID, Self::HANDSHAKE_KEY] {
            if std::env::var(key).is_err() {
                missing.push(key);
            }
        }
        if !missing.is_empty() {
            return Err(Error::Secure(format!(
                "missing env {}: {}\n\n{}",
                if missing.len() == 1 { "var" } else { "vars" },
                missing.join(", "),
                Self::required_env_help()
            )));
        }
        let _ = Self::tls_from_env()?;
        EnvSecurePolicyProbe::from_env_keys()?;
        Ok(())
    }
}

/// Tiny probe so `check_required` does not create a full policy graph cycle in docs.
struct EnvSecurePolicyProbe;
impl EnvSecurePolicyProbe {
    fn from_env_keys() -> Result<()> {
        let network_id = SecureEnv::network_id().ok_or_else(|| {
            Error::Secure(format!("missing env {}", SecureEnv::NETWORK_ID))
        })?;
        if network_id.trim().is_empty() {
            return Err(Error::Secure(format!(
                "{} must not be empty",
                SecureEnv::NETWORK_ID
            )));
        }
        if network_id.len() < SecureEnv::MIN_NETWORK_ID_LEN {
            return Err(Error::Secure(format!(
                "{} must be at least {} characters for commercial use (got {})",
                SecureEnv::NETWORK_ID,
                SecureEnv::MIN_NETWORK_ID_LEN,
                network_id.len()
            )));
        }
        let key = SecureEnv::handshake_key().ok_or_else(|| {
            Error::Secure(format!("missing env {}", SecureEnv::HANDSHAKE_KEY))
        })?;
        if key.is_empty() {
            return Err(Error::Secure("handshake key must not be empty".into()));
        }
        if key.len() < SecureEnv::MIN_HANDSHAKE_KEY_LEN {
            return Err(Error::Secure(format!(
                "{} must be at least {} bytes for commercial use (got {})",
                SecureEnv::HANDSHAKE_KEY,
                SecureEnv::MIN_HANDSHAKE_KEY_LEN,
                key.len()
            )));
        }
        Ok(())
    }
}