use crate::{command, config::Config, privileged}; use anyhow::{bail, Result}; use serde::{Deserialize, Serialize}; use std::{net::IpAddr, time::Duration}; #[derive(Debug, Serialize)] pub struct Status { pub installed: bool, pub running: bool, pub version: Option, pub jails: Vec, pub jail_statuses: Vec, pub management_enabled: bool, pub manageable_jails: Vec, } #[derive(Debug, Default, Serialize, PartialEq)] pub struct JailStatus { pub jail: String, pub currently_failed: u64, pub total_failed: u64, pub currently_banned: u64, pub total_banned: u64, pub banned_ips: Vec, } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields)] pub struct BanRequest { pub jail: String, pub ip: String, } pub async fn status(config: &Config, timeout: Duration) -> Status { let version = match command::run("fail2ban-client", &["--version"], timeout).await { Ok(output) => Some(output.stdout.trim().to_owned()), Err(_) => { return Status { installed: false, running: false, version: None, jails: vec![], jail_statuses: vec![], management_enabled: false, manageable_jails: config.fail2ban.allowed_jails.clone(), } } }; match command::run("fail2ban-client", &["status"], timeout).await { Ok(output) => { let jails = parse_jail_list(&output.stdout); let mut jail_statuses = Vec::new(); let mut tasks = tokio::task::JoinSet::new(); for name in jails.iter().take(64) { let name = name.clone(); tasks.spawn(async move { jail(&name, timeout).await }); } while let Some(result) = tasks.join_next().await { if let Ok(Ok(status)) = result { jail_statuses.push(status); } } jail_statuses.sort_by(|left, right| left.jail.cmp(&right.jail)); Status { installed: true, running: true, version, jails, jail_statuses, management_enabled: config.fail2ban.management_enabled && privileged::socket_available(), manageable_jails: config.fail2ban.allowed_jails.clone(), } } Err(_) => Status { installed: true, running: false, version, jails: vec![], jail_statuses: vec![], management_enabled: config.fail2ban.management_enabled && privileged::socket_available(), manageable_jails: config.fail2ban.allowed_jails.clone(), }, } } pub async fn jail(name: &str, timeout: Duration) -> Result { validate_jail(name)?; let output = command::run("fail2ban-client", &["status", name], timeout).await?; Ok(parse_jail_status(name, &output.stdout)) } pub async fn ban( config: &Config, request: &BanRequest, unban: bool, timeout: Duration, ) -> Result<()> { validate_jail(&request.jail)?; let ip: IpAddr = request .ip .parse() .map_err(|_| anyhow::anyhow!("invalid IP address"))?; if !config .fail2ban .allowed_jails .iter() .any(|value| value == &request.jail) { bail!("jail is not allow-listed") } privileged::call( &privileged::Request::Fail2BanAction { jail: request.jail.clone(), ip: ip.to_string(), operation: if unban { "unban".into() } else { "ban".into() }, }, timeout, ) .await?; Ok(()) } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields)] pub struct ConfigureRequest { pub jail: String, pub enabled: bool, pub bantime_seconds: u32, pub findtime_seconds: u32, pub maxretry: u16, } pub async fn configure( config: &Config, request: ConfigureRequest, timeout: Duration, ) -> Result<()> { validate_jail(&request.jail)?; if !config .fail2ban .allowed_jails .iter() .any(|value| value == &request.jail) { bail!("jail is not allow-listed") } privileged::call( &privileged::Request::Fail2BanConfigure { settings: privileged::Fail2BanSettings { jail: request.jail, enabled: request.enabled, bantime_seconds: request.bantime_seconds, findtime_seconds: request.findtime_seconds, maxretry: request.maxretry, }, }, timeout, ) .await?; Ok(()) } pub fn validate_jail(name: &str) -> Result<()> { if name.is_empty() || name.len() > 64 || !name .bytes() .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'-' | b'_' | b'.')) { bail!("invalid jail name") } Ok(()) } fn parse_jail_list(text: &str) -> Vec { text.lines() .find_map(|line| line.split_once("Jail list:")) .map(|(_, list)| { list.split(',') .map(str::trim) .filter(|v| !v.is_empty()) .map(str::to_owned) .collect() }) .unwrap_or_default() } fn parse_jail_status(name: &str, text: &str) -> JailStatus { let mut result = JailStatus { jail: name.to_owned(), ..JailStatus::default() }; for line in text.lines() { let normalized = line.trim().trim_start_matches(['|', '`', '-', '_']).trim(); let Some((key, value)) = normalized.split_once(':') else { continue; }; let value = value.trim(); match key.trim() { "Currently failed" => result.currently_failed = value.parse().unwrap_or_default(), "Total failed" => result.total_failed = value.parse().unwrap_or_default(), "Currently banned" => result.currently_banned = value.parse().unwrap_or_default(), "Total banned" => result.total_banned = value.parse().unwrap_or_default(), "Banned IP list" => { result.banned_ips = value.split_whitespace().map(str::to_owned).collect() } _ => {} } } result } #[cfg(test)] mod tests { use super::*; #[test] fn parses_statuses() { assert_eq!( parse_jail_list("Number of jail: 2\nJail list: sshd, nginx-http-auth\n"), vec!["sshd", "nginx-http-auth"] ); let jail = parse_jail_status("sshd", "Currently failed: 2\nTotal failed: 14\nCurrently banned: 1\nTotal banned: 3\nBanned IP list: 192.0.2.1\n"); assert_eq!(jail.currently_banned, 1); assert_eq!(jail.banned_ips, vec!["192.0.2.1"]); } #[test] fn rejects_command_like_jail() { assert!(validate_jail("sshd").is_ok()); assert!(validate_jail("sshd;shutdown").is_err()); assert!(validate_jail("../../root").is_err()); } }