use anyhow::{bail, Context, Result}; use serde::Deserialize; use std::{collections::HashMap, net::SocketAddr, path::Path}; #[derive(Clone, Debug, Default, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Config { pub server: Server, pub auth: Auth, pub limits: Limits, pub services: Services, pub firewall: Firewall, pub fail2ban: Fail2Ban, pub logging: Logging, pub telemetry: Telemetry, pub logs: Logs, pub tls: Tls, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Server { pub listen: SocketAddr, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Auth { pub mode: String, pub token_file: String, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Limits { pub max_concurrent_requests: usize, pub request_timeout_seconds: u64, pub max_body_bytes: usize, pub read_requests_per_second: f64, pub write_requests_per_second: f64, pub burst: f64, pub command_timeout_seconds: u64, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Services { pub allowed: Vec, pub inventory_limit: usize, pub install_enabled: bool, pub install_timeout_seconds: u64, pub packages: HashMap, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Firewall { pub management_enabled: bool, pub persistence_enabled: bool, pub allowed_interfaces: Vec, pub allowed_sources: Vec, pub allowed_ports: Vec, pub rollback_timeout_seconds: u64, pub max_snapshots: usize, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Fail2Ban { pub management_enabled: bool, pub allowed_jails: Vec, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Logging { pub level: String, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Telemetry { pub connections_enabled: bool, pub process_info_enabled: bool, } #[derive(Clone, Debug, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Logs { pub enabled: bool, pub allowed_units: Vec, pub max_entries_per_request: usize, pub max_message_bytes: usize, } #[derive(Clone, Debug, Deserialize, Default)] #[serde(default, deny_unknown_fields)] pub struct Tls { pub enabled: bool, pub certificate_file: String, pub private_key_file: String, } impl Default for Server { fn default() -> Self { Self { listen: "127.0.0.1:9105" .parse() .expect("valid default listen address"), } } } impl Default for Auth { fn default() -> Self { Self { mode: "token".into(), token_file: "/etc/vps-agent/credentials/control-plane.token".into(), } } } impl Default for Limits { fn default() -> Self { Self { max_concurrent_requests: 32, request_timeout_seconds: 5, max_body_bytes: 65_536, read_requests_per_second: 10.0, write_requests_per_second: 2.0, burst: 20.0, command_timeout_seconds: 4, } } } impl Default for Services { fn default() -> Self { Self { allowed: Vec::new(), inventory_limit: 512, install_enabled: false, install_timeout_seconds: 300, packages: HashMap::new(), } } } impl Default for Fail2Ban { fn default() -> Self { Self { management_enabled: false, allowed_jails: vec!["sshd".into()], } } } impl Default for Firewall { fn default() -> Self { Self { management_enabled: false, persistence_enabled: true, allowed_interfaces: Vec::new(), allowed_sources: Vec::new(), allowed_ports: Vec::new(), rollback_timeout_seconds: 60, max_snapshots: 5, } } } impl Default for Logging { fn default() -> Self { Self { level: "info".into(), } } } impl Default for Telemetry { fn default() -> Self { Self { connections_enabled: true, process_info_enabled: true, } } } impl Default for Logs { fn default() -> Self { Self { enabled: false, allowed_units: vec!["vps-agent.service".into()], max_entries_per_request: 200, max_message_bytes: 16_384, } } } impl Config { pub fn load(path: &Path) -> Result { let text = std::fs::read_to_string(path) .with_context(|| format!("read configuration {}", path.display()))?; let config: Self = toml::from_str(&text).context("parse TOML configuration")?; config.validate()?; Ok(config) } pub fn validate(&self) -> Result<()> { if self.auth.mode != "token" { bail!("auth.mode must be 'token' in v1") } if self.server.listen.ip().is_unspecified() { bail!("refusing unspecified/public listen address; bind a WireGuard IP explicitly") } if self.limits.max_concurrent_requests == 0 || self.limits.max_concurrent_requests > 256 { bail!("max_concurrent_requests must be between 1 and 256") } if !(1..=64).contains(&self.limits.request_timeout_seconds) { bail!("request_timeout_seconds must be between 1 and 64") } if !(1024..=1_048_576).contains(&self.limits.max_body_bytes) { bail!("max_body_bytes must be between 1024 and 1048576") } if self.limits.read_requests_per_second <= 0.0 || self.limits.write_requests_per_second <= 0.0 || self.limits.burst < 1.0 { bail!("rate limits must be positive") } if self.services.allowed.len() > 128 { bail!("at most 128 services may be allow-listed") } if !(1..=2048).contains(&self.services.inventory_limit) { bail!("services.inventory_limit must be between 1 and 2048") } if self.logs.allowed_units.len() > 128 || !(1..=1000).contains(&self.logs.max_entries_per_request) || !(1024..=65_536).contains(&self.logs.max_message_bytes) { bail!("logs limits or allowed unit count are invalid") } if self.logs.enabled && self.logs.allowed_units.is_empty() { bail!("logs.allowed_units must not be empty when log collection is enabled") } for name in &self.logs.allowed_units { if !valid_service_name(name) { bail!("invalid allow-listed log unit name") } } for name in &self.services.allowed { if !valid_service_name(name) { bail!("invalid allow-listed service name") } } if !(30..=1800).contains(&self.services.install_timeout_seconds) { bail!("services.install_timeout_seconds must be between 30 and 1800") } if self.services.packages.len() > 128 { bail!("at most 128 service packages may be configured") } for (service, package) in &self.services.packages { if !self.services.allowed.iter().any(|name| name == service) || !valid_package_name(package) { bail!("invalid service package mapping") } } if self.services.install_enabled && self.services.packages.is_empty() { bail!("services.packages must not be empty when installation is enabled") } if self.firewall.allowed_interfaces.len() > 32 || self.firewall.allowed_sources.len() > 128 || self.firewall.allowed_ports.len() > 512 { bail!("firewall allow-list is too large") } for interface in &self.firewall.allowed_interfaces { if !valid_interface_name(interface) { bail!("invalid firewall interface") } } for source in &self.firewall.allowed_sources { if !valid_cidr(source) || !source .split_once('/') .and_then(|(address, _)| address.parse::().ok()) .is_some_and(|address| address.is_ipv4()) { bail!("invalid IPv4 firewall source CIDR") } } if self.firewall.allowed_ports.contains(&0) { bail!("firewall ports must be between 1 and 65535") } if self.firewall.management_enabled && (self.firewall.allowed_interfaces.is_empty() || self.firewall.allowed_sources.is_empty() || self.firewall.allowed_ports.is_empty()) { bail!("firewall allow-lists must not be empty when management is enabled") } if !(10..=300).contains(&self.firewall.rollback_timeout_seconds) || !(1..=20).contains(&self.firewall.max_snapshots) { bail!("firewall rollback or snapshot limits are invalid") } if self.fail2ban.allowed_jails.len() > 64 { bail!("at most 64 Fail2Ban jails may be allow-listed") } for jail in &self.fail2ban.allowed_jails { if !valid_simple_name(jail) { bail!("invalid allow-listed Fail2Ban jail") } } if self.fail2ban.management_enabled && self.fail2ban.allowed_jails.is_empty() { bail!("fail2ban.allowed_jails must not be empty when management is enabled") } if !matches!( self.logging.level.as_str(), "error" | "warn" | "info" | "debug" | "trace" ) { bail!("logging.level is invalid") } if self.tls.enabled && (self.tls.certificate_file.is_empty() || self.tls.private_key_file.is_empty()) { bail!("TLS certificate and private key paths are required") } Ok(()) } } pub fn valid_service_name(name: &str) -> bool { !name.is_empty() && name.len() <= 128 && name .bytes() .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'-' | b'_' | b'.' | b'@' | b':')) } pub fn valid_simple_name(name: &str) -> bool { !name.is_empty() && name.len() <= 64 && name .bytes() .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'-' | b'_' | b'.')) } pub fn valid_package_name(name: &str) -> bool { !name.is_empty() && name.len() <= 128 && name.bytes().all(|c| { c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, b'+' | b'.' | b'-') }) } pub fn valid_interface_name(name: &str) -> bool { !name.is_empty() && name.len() <= 15 && name .bytes() .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-' | b'.')) } pub fn valid_cidr(value: &str) -> bool { let Some((address, prefix)) = value.split_once('/') else { return false; }; let Ok(address) = address.parse::() else { return false; }; let Ok(prefix) = prefix.parse::() else { return false; }; prefix <= if address.is_ipv4() { 32 } else { 128 } } #[cfg(test)] mod tests { use super::*; #[test] fn safe_defaults_bind_loopback() { let config = Config::default(); assert!(config.server.listen.ip().is_loopback()); assert!(!config.firewall.management_enabled); config.validate().unwrap(); } #[test] fn rejects_unspecified_bind() { let mut config = Config::default(); config.server.listen = "0.0.0.0:9105".parse().unwrap(); assert!(config.validate().is_err()); } #[test] fn validates_service_names() { assert!(valid_service_name("wg-quick@wg0.service")); assert!(!valid_service_name("nginx;reboot")); assert!(!valid_service_name("../../etc/passwd")); } #[test] fn validates_privileged_allow_lists() { assert!(valid_package_name("nginx-core")); assert!(!valid_package_name("nginx;reboot")); assert!(valid_interface_name("wg-home")); assert!(!valid_interface_name("../../eth0")); assert!(valid_cidr("192.168.50.4/32")); assert!(valid_cidr("2001:db8::/64")); assert!(!valid_cidr("192.168.50.4/99")); } }