Files
vps-control/agent/src/fail2ban.rs
2026-09-22 23:37:05 +03:00

237 lines
7.0 KiB
Rust

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<String>,
pub jails: Vec<String>,
pub jail_statuses: Vec<JailStatus>,
pub management_enabled: bool,
pub manageable_jails: Vec<String>,
}
#[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<String>,
}
#[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<JailStatus> {
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<String> {
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());
}
}