use crate::{command, config::Config, privileged}; use anyhow::{bail, Result}; use serde::{Deserialize, Serialize}; use std::time::Duration; pub const MANAGED_CHAIN: &str = "VPS_CONTROL_INPUT"; pub const RATE_CHAIN: &str = "VPS_CONTROL_RATE"; #[derive(Debug, Serialize)] pub struct FirewallStatus { pub backend: String, pub management_enabled: bool, pub persistence_enabled: bool, pub managed_chain: String, pub allowed_interfaces: Vec, pub allowed_sources: Vec, pub allowed_ports: Vec, pub rules: Vec, pub warning: Option, } #[derive(Clone, Debug, Serialize, PartialEq)] pub struct FirewallRule { pub id: String, pub table: String, pub chain: String, pub protocol: String, pub source: String, pub destination: String, pub in_interface: String, pub out_interface: String, pub destination_port: Option, pub target: String, pub packets: u64, pub bytes: u64, pub comment: String, pub managed: bool, pub rate_limit: bool, } #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct AddRuleRequest { pub interface: String, pub source: String, pub protocol: String, pub port: u16, pub target: String, #[serde(default)] pub comment: String, } #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct RateLimitRequest { pub interface: String, pub source: String, pub protocol: String, pub port: u16, pub rate_per_second: u32, pub burst: u32, #[serde(default)] pub comment: String, } pub async fn status(config: &Config, timeout: Duration) -> FirewallStatus { let helper_available = privileged::socket_available(); let management_enabled = config.firewall.management_enabled && helper_available; let dump = if helper_available { privileged::call(&privileged::Request::FirewallDump, timeout) .await .ok() .and_then(|response| response.data) .and_then(|value| value.as_str().map(str::to_owned)) } else { command::run("iptables-save", &["-c"], timeout) .await .ok() .map(|output| output.stdout) }; match dump { Some(text) => FirewallStatus { backend: "iptables".into(), management_enabled, persistence_enabled: config.firewall.persistence_enabled, managed_chain: MANAGED_CHAIN.into(), allowed_interfaces: config.firewall.allowed_interfaces.clone(), allowed_sources: config.firewall.allowed_sources.clone(), allowed_ports: config.firewall.allowed_ports.clone(), rules: parse_iptables_save(&text), warning: if config.firewall.management_enabled && !helper_available { Some("privileged helper socket is unavailable; writes are disabled".into()) } else { None }, }, None => FirewallStatus { backend: "unavailable".into(), management_enabled: false, persistence_enabled: config.firewall.persistence_enabled, managed_chain: MANAGED_CHAIN.into(), allowed_interfaces: config.firewall.allowed_interfaces.clone(), allowed_sources: config.firewall.allowed_sources.clone(), allowed_ports: config.firewall.allowed_ports.clone(), rules: Vec::new(), warning: Some("iptables-save is unavailable or access was denied".into()), }, } } pub async fn add(config: &Config, request: AddRuleRequest, timeout: Duration) -> Result { validate_common( config, &request.interface, &request.source, &request.protocol, request.port, )?; if !matches!(request.target.as_str(), "ACCEPT" | "DROP" | "REJECT") { bail!("target must be ACCEPT, DROP, or REJECT") } let response = privileged::call( &privileged::Request::FirewallAdd { rule: privileged::FirewallRuleRequest { interface: request.interface, source: request.source, protocol: request.protocol, port: request.port, target: request.target, comment: request.comment, }, }, timeout, ) .await?; transaction_id(response) } pub async fn delete(config: &Config, id: &str, timeout: Duration) -> Result { if !config.firewall.management_enabled || !valid_id(id) { bail!("firewall management disabled or invalid rule id") } let response = privileged::call( &privileged::Request::FirewallDelete { id: id.into() }, timeout, ) .await?; transaction_id(response) } pub async fn add_rate_limit( config: &Config, request: RateLimitRequest, timeout: Duration, ) -> Result { validate_common( config, &request.interface, &request.source, &request.protocol, request.port, )?; if !(1..=100_000).contains(&request.rate_per_second) || !(1..=10_000).contains(&request.burst) { bail!("rate_per_second or burst is outside the supported range") } let response = privileged::call( &privileged::Request::RateLimitAdd { policy: privileged::RateLimitRequest { interface: request.interface, source: request.source, protocol: request.protocol, port: request.port, rate_per_second: request.rate_per_second, burst: request.burst, comment: request.comment, }, }, timeout, ) .await?; transaction_id(response) } pub async fn delete_rate_limit(config: &Config, id: &str, timeout: Duration) -> Result { if !config.firewall.management_enabled || !valid_id(id) { bail!("policy management disabled or invalid policy id") } let response = privileged::call( &privileged::Request::RateLimitDelete { id: id.into() }, timeout, ) .await?; transaction_id(response) } pub async fn confirm(id: &str, timeout: Duration) -> Result<()> { if !valid_id(id) { bail!("invalid transaction id") } privileged::call( &privileged::Request::FirewallConfirm { id: id.into() }, timeout, ) .await?; Ok(()) } fn transaction_id(response: privileged::Response) -> Result { let id = response .data .and_then(|value| { value .get("transaction_id") .and_then(|value| value.as_str()) .map(str::to_owned) }) .ok_or_else(|| anyhow::anyhow!("helper did not return a transaction id"))?; if !valid_id(&id) { bail!("helper returned an invalid transaction id") } Ok(id) } fn validate_common( config: &Config, interface: &str, source: &str, protocol: &str, port: u16, ) -> Result<()> { if !config.firewall.management_enabled { bail!("firewall management is disabled") } if !config .firewall .allowed_interfaces .iter() .any(|value| value == interface) || !config .firewall .allowed_sources .iter() .any(|value| value == source) || !config.firewall.allowed_ports.contains(&port) || !matches!(protocol, "tcp" | "udp") { bail!("firewall request is outside the configured allow-list") } Ok(()) } pub fn valid_id(value: &str) -> bool { value.len() == 16 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) } fn parse_iptables_save(text: &str) -> Vec { let mut table = "filter".to_owned(); let mut result = Vec::new(); for (index, line) in text.lines().enumerate() { if let Some(name) = line.strip_prefix('*') { table = name.to_owned(); continue; } if let Some(definition) = line.strip_prefix(':') { let fields: Vec<_> = definition.split_whitespace().collect(); if fields.len() >= 3 { let (packets, bytes) = fields[2] .strip_prefix('[') .and_then(|value| value.strip_suffix(']')) .and_then(|value| value.split_once(':')) .map(|(left, right)| (left.parse().unwrap_or(0), right.parse().unwrap_or(0))) .unwrap_or((0, 0)); result.push(FirewallRule { id: format!("policy-{}-{}", table, fields[0]), table: table.clone(), chain: fields[0].into(), protocol: "all".into(), source: "all".into(), destination: "all".into(), in_interface: String::new(), out_interface: String::new(), destination_port: None, target: format!("POLICY {}", fields[1]), packets, bytes, comment: String::new(), managed: false, rate_limit: false, }); } continue; } if !line.contains(" -A ") && !line.starts_with("-A ") { continue; } let tokens = split_arguments(line); let chain = option(&tokens, "-A").unwrap_or_default(); let comment = option(&tokens, "--comment").unwrap_or_default(); let counters = tokens .first() .and_then(|token| token.strip_prefix('[')) .and_then(|token| token.strip_suffix(']')); let (packets, bytes) = counters .and_then(|value| value.split_once(':')) .map(|(a, b)| (a.parse().unwrap_or(0), b.parse().unwrap_or(0))) .unwrap_or((0, 0)); let managed = matches!(chain.as_str(), MANAGED_CHAIN | RATE_CHAIN) && comment.starts_with("vps-control:"); let id = comment .strip_prefix("vps-control:") .and_then(|value| value.split(':').next()) .filter(|value| valid_id(value)) .map(str::to_owned) .unwrap_or_else(|| format!("rule-{index}")); result.push(FirewallRule { id, table: table.clone(), chain: chain.clone(), protocol: option(&tokens, "-p").unwrap_or_else(|| "all".into()), source: option(&tokens, "-s").unwrap_or_else(|| "0.0.0.0/0".into()), destination: option(&tokens, "-d").unwrap_or_else(|| "0.0.0.0/0".into()), in_interface: option(&tokens, "-i").unwrap_or_default(), out_interface: option(&tokens, "-o").unwrap_or_default(), destination_port: option(&tokens, "--dport").and_then(|value| value.parse().ok()), target: option(&tokens, "-j").unwrap_or_default(), packets, bytes, rate_limit: tokens.iter().any(|token| token == "hashlimit") || chain == RATE_CHAIN, comment, managed, }); } result } fn option(tokens: &[String], name: &str) -> Option { tokens .iter() .position(|token| token == name) .and_then(|index| tokens.get(index + 1)) .cloned() } fn split_arguments(line: &str) -> Vec { let mut result = Vec::new(); let mut current = String::new(); let mut quoted = false; for character in line.chars() { match character { '"' => quoted = !quoted, ' ' | '\t' if !quoted => { if !current.is_empty() { result.push(std::mem::take(&mut current)); } } _ => current.push(character), } } if !current.is_empty() { result.push(current); } result } #[cfg(test)] mod tests { use super::*; #[test] fn parses_structured_rules_and_counters() { let input = "*filter\n[12:840] -A INPUT -i wg0 -s 10.20.0.0/24 -p tcp -m tcp --dport 9105 -j ACCEPT\n[3:180] -A VPS_CONTROL_INPUT -i wg0 -s 10.20.0.2/32 -p tcp --dport 22 -m comment --comment \"vps-control:0123456789abcdef:ssh\" -j ACCEPT\nCOMMIT\n"; let rules = parse_iptables_save(input); assert_eq!(rules.len(), 2); assert_eq!(rules[0].packets, 12); assert_eq!(rules[0].destination_port, Some(9105)); assert!(rules[1].managed); assert_eq!(rules[1].id, "0123456789abcdef"); } }