use std::path::PathBuf;
use crate::error::{Error, Result};
use crate::secure::tls::TlsMaterial;
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())
}
pub const MIN_NETWORK_ID_LEN: usize = 16;
pub const MIN_HANDSHAKE_KEY_LEN: usize = 32;
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."
}
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(())
}
}
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(())
}
}