update
This commit is contained in:
@@ -35,7 +35,7 @@ and returns liveness only. The complete route table is in
|
||||
`../docs/architecture.md`. Limits default to 64 KiB bodies, 32 concurrent calls,
|
||||
five-second requests, 10 read rps, 2 write rps, and burst 20.
|
||||
|
||||
System data comes from `/proc` and `/sys`; fixed `ip`, `nft`/`iptables`,
|
||||
System data comes from `/proc` and `/sys`; fixed `ip`, `iptables`,
|
||||
`fail2ban-client`, `wg`, and `systemctl` invocations augment it. User input is
|
||||
never part of a command string. Jail names and IPs are validated, and systemd
|
||||
names must exactly match the configuration allow-list.
|
||||
@@ -49,15 +49,17 @@ administrator must opt in after review.
|
||||
|
||||
## systemd and privilege
|
||||
|
||||
Install `packaging/vps-agent.service`. It caps memory at 64 MiB, CPU at 10%,
|
||||
Install `packaging/vps-agent.service`, `vps-agent-helper.socket`, and
|
||||
`vps-agent-helper@.service`. The daemon unit caps memory at 64 MiB, CPU at 10%,
|
||||
tasks at 64, removes all capabilities, sets `NoNewPrivileges`, and enables
|
||||
filesystem/kernel/namespace hardening. The agent logs to journald and does not
|
||||
write successful polls or metrics to disk.
|
||||
|
||||
Read APIs work unprivileged on ordinary supported distributions. Process owners
|
||||
may be absent due to `/proc` permissions. Fail2Ban changes and service restarts
|
||||
will return an error unless the administrator adds narrowly scoped polkit/sudo
|
||||
policy; the installer deliberately grants none. Firewall is read-only in v1.
|
||||
may be absent due to `/proc` permissions. The socket-activated root helper runs
|
||||
one typed request at a time and has no shell/command endpoint. Writes remain off
|
||||
until their local allow-lists and `management_enabled` flags are configured.
|
||||
Firewall persistence requires `iptables-persistent`/`netfilter-persistent`.
|
||||
|
||||
## Lifecycle and troubleshooting
|
||||
|
||||
|
||||
@@ -15,13 +15,25 @@ burst = 20.0
|
||||
command_timeout_seconds = 4
|
||||
|
||||
[services]
|
||||
allowed = ["nginx", "fail2ban", "wg-quick@wg0"]
|
||||
allowed = ["nginx.service", "fail2ban.service", "wg-quick@wg0.service"]
|
||||
inventory_limit = 512
|
||||
install_enabled = false
|
||||
install_timeout_seconds = 300
|
||||
packages = { "nginx.service" = "nginx", "fail2ban.service" = "fail2ban" }
|
||||
|
||||
[firewall]
|
||||
management_enabled = false
|
||||
persistence_enabled = true
|
||||
allowed_interfaces = []
|
||||
allowed_sources = []
|
||||
allowed_ports = []
|
||||
rollback_timeout_seconds = 60
|
||||
max_snapshots = 5
|
||||
|
||||
[fail2ban]
|
||||
management_enabled = false
|
||||
allowed_jails = ["sshd"]
|
||||
|
||||
[logging]
|
||||
level = "info"
|
||||
|
||||
|
||||
15
agent/packaging/vps-agent-helper.socket
Normal file
15
agent/packaging/vps-agent-helper.socket
Normal file
@@ -0,0 +1,15 @@
|
||||
[Unit]
|
||||
Description=VPS Control privileged helper socket
|
||||
|
||||
[Socket]
|
||||
ListenStream=/run/vps-agent-helper/control.sock
|
||||
Accept=yes
|
||||
MaxConnections=1
|
||||
SocketUser=vps-agent
|
||||
SocketGroup=vps-agent
|
||||
SocketMode=0600
|
||||
DirectoryMode=0750
|
||||
RemoveOnStop=yes
|
||||
|
||||
[Install]
|
||||
WantedBy=sockets.target
|
||||
26
agent/packaging/vps-agent-helper@.service
Normal file
26
agent/packaging/vps-agent-helper@.service
Normal file
@@ -0,0 +1,26 @@
|
||||
[Unit]
|
||||
Description=VPS Control privileged helper request
|
||||
Documentation=https://github.com/example/vps-control
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
ExecStart=/usr/local/bin/vps-agent --privileged-helper --config /etc/vps-agent/config.toml
|
||||
StandardInput=socket
|
||||
StandardOutput=socket
|
||||
StandardError=journal
|
||||
User=root
|
||||
Group=root
|
||||
TimeoutStartSec=330
|
||||
UMask=0077
|
||||
PrivateTmp=true
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
RestrictSUIDSGID=true
|
||||
LockPersonality=true
|
||||
RestrictRealtime=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6 AF_NETLINK
|
||||
136
agent/src/api.rs
136
agent/src/api.rs
@@ -10,7 +10,7 @@ use axum::{
|
||||
http::{header::AUTHORIZATION, Method, Request, StatusCode},
|
||||
middleware::{self, Next},
|
||||
response::{IntoResponse, Response},
|
||||
routing::{get, post},
|
||||
routing::{delete, get, post},
|
||||
Json, Router,
|
||||
};
|
||||
use serde_json::{json, Value};
|
||||
@@ -113,13 +113,22 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/network/listeners", get(network_listeners))
|
||||
.route("/v1/network/connections", get(network_connections))
|
||||
.route("/v1/firewall/rules", get(firewall_rules))
|
||||
.route("/v1/firewall/rules", post(firewall_add))
|
||||
.route("/v1/firewall/rules/:id", delete(firewall_delete))
|
||||
.route(
|
||||
"/v1/firewall/transactions/:id/confirm",
|
||||
post(firewall_confirm),
|
||||
)
|
||||
.route("/v1/rate-limits", get(rate_limits).post(rate_limit_add))
|
||||
.route("/v1/rate-limits/:id", delete(rate_limit_delete))
|
||||
.route("/v1/fail2ban/status", get(fail2ban_status))
|
||||
.route("/v1/fail2ban/jails/:jail", get(fail2ban_jail))
|
||||
.route("/v1/fail2ban/ban", post(fail2ban_ban))
|
||||
.route("/v1/fail2ban/unban", post(fail2ban_unban))
|
||||
.route("/v1/fail2ban/configure", post(fail2ban_configure))
|
||||
.route("/v1/wireguard/status", get(wireguard_status))
|
||||
.route("/v1/services", get(service_list))
|
||||
.route("/v1/services/:name/restart", post(service_restart))
|
||||
.route("/v1/services/:name/:operation", post(service_mutation))
|
||||
.route("/v1/logs", get(log_entries))
|
||||
.layer(DefaultBodyLimit::max(max_body))
|
||||
.layer(middleware::from_fn_with_state(
|
||||
@@ -286,11 +295,74 @@ async fn network_connections(
|
||||
}
|
||||
|
||||
async fn firewall_rules(State(state): State<Arc<AppState>>) -> Json<firewall::FirewallStatus> {
|
||||
Json(firewall::status(command_timeout(&state)).await)
|
||||
Json(firewall::status(&state.config, command_timeout(&state)).await)
|
||||
}
|
||||
|
||||
async fn firewall_add(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(request): Json<firewall::AddRuleRequest>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
let transaction_id = firewall::add(&state.config, request, command_timeout(&state)).await?;
|
||||
tracing::info!("managed firewall rule added");
|
||||
Ok(Json(
|
||||
json!({"status":"pending_confirmation","transaction_id":transaction_id}),
|
||||
))
|
||||
}
|
||||
|
||||
async fn firewall_delete(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
let transaction_id = firewall::delete(&state.config, &id, command_timeout(&state)).await?;
|
||||
tracing::info!(rule_id = id, "managed firewall rule deleted");
|
||||
Ok(Json(
|
||||
json!({"status":"pending_confirmation","transaction_id":transaction_id}),
|
||||
))
|
||||
}
|
||||
|
||||
async fn rate_limits(State(state): State<Arc<AppState>>) -> Json<Vec<firewall::FirewallRule>> {
|
||||
let mut rules = firewall::status(&state.config, command_timeout(&state))
|
||||
.await
|
||||
.rules;
|
||||
rules.retain(|rule| rule.rate_limit && rule.managed);
|
||||
Json(rules)
|
||||
}
|
||||
|
||||
async fn rate_limit_add(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(request): Json<firewall::RateLimitRequest>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
let transaction_id =
|
||||
firewall::add_rate_limit(&state.config, request, command_timeout(&state)).await?;
|
||||
tracing::info!("managed L4 rate-limit policy added");
|
||||
Ok(Json(
|
||||
json!({"status":"pending_confirmation","transaction_id":transaction_id}),
|
||||
))
|
||||
}
|
||||
|
||||
async fn rate_limit_delete(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
let transaction_id =
|
||||
firewall::delete_rate_limit(&state.config, &id, command_timeout(&state)).await?;
|
||||
tracing::info!(policy_id = id, "managed L4 rate-limit policy deleted");
|
||||
Ok(Json(
|
||||
json!({"status":"pending_confirmation","transaction_id":transaction_id}),
|
||||
))
|
||||
}
|
||||
|
||||
async fn firewall_confirm(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
firewall::confirm(&id, command_timeout(&state)).await?;
|
||||
tracing::info!(transaction_id = id, "firewall transaction confirmed");
|
||||
Ok(Json(json!({"status":"ok"})))
|
||||
}
|
||||
|
||||
async fn fail2ban_status(State(state): State<Arc<AppState>>) -> Json<fail2ban::Status> {
|
||||
Json(fail2ban::status(command_timeout(&state)).await)
|
||||
Json(fail2ban::status(&state.config, command_timeout(&state)).await)
|
||||
}
|
||||
|
||||
async fn fail2ban_jail(
|
||||
@@ -326,7 +398,7 @@ async fn mutate_ban(
|
||||
.ip
|
||||
.parse::<std::net::IpAddr>()
|
||||
.map_err(|_| ApiError::bad_request("invalid IP address"))?;
|
||||
fail2ban::ban(&request, unban, command_timeout(state)).await?;
|
||||
fail2ban::ban(&state.config, &request, unban, command_timeout(state)).await?;
|
||||
let action = if unban { "unban" } else { "ban" };
|
||||
tracing::info!(
|
||||
action,
|
||||
@@ -337,6 +409,15 @@ async fn mutate_ban(
|
||||
Ok(Json(json!({"status": "ok"})))
|
||||
}
|
||||
|
||||
async fn fail2ban_configure(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(request): Json<fail2ban::ConfigureRequest>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
fail2ban::configure(&state.config, request, command_timeout(&state)).await?;
|
||||
tracing::info!("managed Fail2Ban configuration updated");
|
||||
Ok(Json(json!({"status":"ok"})))
|
||||
}
|
||||
|
||||
async fn wireguard_status(
|
||||
State(state): State<Arc<AppState>>,
|
||||
) -> Result<Json<Vec<wireguard::Interface>>, ApiError> {
|
||||
@@ -344,33 +425,34 @@ async fn wireguard_status(
|
||||
}
|
||||
|
||||
async fn service_list(State(state): State<Arc<AppState>>) -> Json<Vec<services::ServiceStatus>> {
|
||||
Json(services::list(&state.config.services.allowed, command_timeout(&state)).await)
|
||||
Json(services::list(&state.config.services, command_timeout(&state)).await)
|
||||
}
|
||||
|
||||
async fn service_restart(
|
||||
async fn service_mutation(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Path(name): Path<String>,
|
||||
Path((name, operation)): Path<(String, String)>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
if !state
|
||||
.config
|
||||
.services
|
||||
.allowed
|
||||
.iter()
|
||||
.any(|item| item == &name)
|
||||
{
|
||||
return Err(ApiError::new(
|
||||
StatusCode::FORBIDDEN,
|
||||
"service is not allow-listed",
|
||||
"not_allowed",
|
||||
));
|
||||
if operation == "install" {
|
||||
services::install(
|
||||
&name,
|
||||
&state.config.services,
|
||||
Duration::from_secs(state.config.services.install_timeout_seconds),
|
||||
)
|
||||
.await?;
|
||||
} else {
|
||||
services::action(
|
||||
&name,
|
||||
&operation,
|
||||
&state.config.services,
|
||||
command_timeout(&state),
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
services::restart(
|
||||
&name,
|
||||
&state.config.services.allowed,
|
||||
command_timeout(&state),
|
||||
)
|
||||
.await?;
|
||||
tracing::info!(service = name, "allow-listed service restarted");
|
||||
tracing::info!(
|
||||
service = name,
|
||||
operation,
|
||||
"allow-listed service mutation completed"
|
||||
);
|
||||
Ok(Json(json!({"status": "ok"})))
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use anyhow::{bail, Context, Result};
|
||||
use serde::Deserialize;
|
||||
use std::{net::SocketAddr, path::Path};
|
||||
use std::{collections::HashMap, net::SocketAddr, path::Path};
|
||||
|
||||
#[derive(Clone, Debug, Default, Deserialize)]
|
||||
#[serde(default, deny_unknown_fields)]
|
||||
@@ -10,6 +10,7 @@ pub struct Config {
|
||||
pub limits: Limits,
|
||||
pub services: Services,
|
||||
pub firewall: Firewall,
|
||||
pub fail2ban: Fail2Ban,
|
||||
pub logging: Logging,
|
||||
pub telemetry: Telemetry,
|
||||
pub logs: Logs,
|
||||
@@ -41,20 +42,35 @@ pub struct Limits {
|
||||
pub command_timeout_seconds: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, Deserialize)]
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(default, deny_unknown_fields)]
|
||||
pub struct Services {
|
||||
pub allowed: Vec<String>,
|
||||
pub inventory_limit: usize,
|
||||
pub install_enabled: bool,
|
||||
pub install_timeout_seconds: u64,
|
||||
pub packages: HashMap<String, String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(default, deny_unknown_fields)]
|
||||
pub struct Firewall {
|
||||
pub management_enabled: bool,
|
||||
pub persistence_enabled: bool,
|
||||
pub allowed_interfaces: Vec<String>,
|
||||
pub allowed_sources: Vec<String>,
|
||||
pub allowed_ports: Vec<u16>,
|
||||
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<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(default, deny_unknown_fields)]
|
||||
pub struct Logging {
|
||||
@@ -118,10 +134,35 @@ impl Default for Limits {
|
||||
}
|
||||
}
|
||||
|
||||
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,
|
||||
}
|
||||
@@ -190,6 +231,9 @@ impl Config {
|
||||
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)
|
||||
@@ -209,8 +253,68 @@ impl Config {
|
||||
bail!("invalid allow-listed service name")
|
||||
}
|
||||
}
|
||||
if self.firewall.management_enabled {
|
||||
bail!("firewall management requires the v2 privileged helper and is unavailable")
|
||||
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::<std::net::IpAddr>().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(),
|
||||
@@ -235,6 +339,43 @@ pub fn valid_service_name(name: &str) -> bool {
|
||||
.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::<std::net::IpAddr>() else {
|
||||
return false;
|
||||
};
|
||||
let Ok(prefix) = prefix.parse::<u8>() else {
|
||||
return false;
|
||||
};
|
||||
prefix <= if address.is_ipv4() { 32 } else { 128 }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -260,4 +401,15 @@ mod tests {
|
||||
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"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use crate::command;
|
||||
use crate::{command, config::Config, privileged};
|
||||
use anyhow::{bail, Result};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{net::IpAddr, time::Duration};
|
||||
@@ -9,6 +9,9 @@ pub struct Status {
|
||||
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)]
|
||||
@@ -28,7 +31,7 @@ pub struct BanRequest {
|
||||
pub ip: String,
|
||||
}
|
||||
|
||||
pub async fn status(timeout: Duration) -> Status {
|
||||
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(_) => {
|
||||
@@ -37,21 +40,47 @@ pub async fn status(timeout: Duration) -> Status {
|
||||
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) => Status {
|
||||
installed: true,
|
||||
running: true,
|
||||
version,
|
||||
jails: parse_jail_list(&output.stdout),
|
||||
},
|
||||
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(),
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -62,21 +91,71 @@ pub async fn jail(name: &str, timeout: Duration) -> Result<JailStatus> {
|
||||
Ok(parse_jail_status(name, &output.stdout))
|
||||
}
|
||||
|
||||
pub async fn ban(request: &BanRequest, unban: bool, timeout: Duration) -> Result<()> {
|
||||
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"))?;
|
||||
let operation = if unban { "unbanip" } else { "banip" };
|
||||
command::run(
|
||||
"fail2ban-client",
|
||||
&[
|
||||
"set",
|
||||
request.jail.as_str(),
|
||||
operation,
|
||||
ip.to_string().as_str(),
|
||||
],
|
||||
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?;
|
||||
|
||||
@@ -1,68 +1,379 @@
|
||||
use crate::command;
|
||||
use serde::Serialize;
|
||||
use serde_json::Value;
|
||||
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 managed_table: String,
|
||||
pub ruleset: Value,
|
||||
pub persistence_enabled: bool,
|
||||
pub managed_chain: String,
|
||||
pub allowed_interfaces: Vec<String>,
|
||||
pub allowed_sources: Vec<String>,
|
||||
pub allowed_ports: Vec<u16>,
|
||||
pub rules: Vec<FirewallRule>,
|
||||
pub warning: Option<String>,
|
||||
}
|
||||
|
||||
pub async fn status(timeout: Duration) -> FirewallStatus {
|
||||
if command::run("nft", &["--version"], timeout).await.is_ok() {
|
||||
return match command::run("nft", &["--json", "list", "ruleset"], timeout).await {
|
||||
Ok(output) => FirewallStatus {
|
||||
backend: "nftables".into(),
|
||||
management_enabled: false,
|
||||
managed_table: "inet vps_control".into(),
|
||||
ruleset: serde_json::from_str(&output.stdout).unwrap_or(Value::Null),
|
||||
warning: None,
|
||||
},
|
||||
Err(error) => FirewallStatus {
|
||||
backend: "nftables".into(),
|
||||
management_enabled: false,
|
||||
managed_table: "inet vps_control".into(),
|
||||
ruleset: Value::Null,
|
||||
warning: Some(format!("rules unavailable: {error}")),
|
||||
},
|
||||
};
|
||||
}
|
||||
#[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<u16>,
|
||||
pub target: String,
|
||||
pub packets: u64,
|
||||
pub bytes: u64,
|
||||
pub comment: String,
|
||||
pub managed: bool,
|
||||
pub rate_limit: bool,
|
||||
}
|
||||
|
||||
for (program, backend) in [
|
||||
("iptables-nft", "iptables-nft"),
|
||||
("iptables", "iptables-legacy"),
|
||||
] {
|
||||
if let Ok(version) = command::run(program, &["--version"], timeout).await {
|
||||
let detected = if version.stdout.contains("nf_tables") {
|
||||
"iptables-nft"
|
||||
#[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 {
|
||||
backend
|
||||
};
|
||||
let rules = command::run(program, &["-S"], timeout)
|
||||
.await
|
||||
.ok()
|
||||
.map(|v| v.stdout);
|
||||
return FirewallStatus {
|
||||
backend: detected.into(),
|
||||
management_enabled: false,
|
||||
managed_table: "inet vps_control".into(),
|
||||
ruleset: rules.map(Value::String).unwrap_or(Value::Null),
|
||||
warning: Some(
|
||||
"legacy-compatible firewall view is read-only and has limited structure".into(),
|
||||
),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
FirewallStatus {
|
||||
backend: "unavailable".into(),
|
||||
management_enabled: false,
|
||||
managed_table: "inet vps_control".into(),
|
||||
ruleset: Value::Null,
|
||||
warning: Some("no supported firewall userspace utility found".into()),
|
||||
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<String> {
|
||||
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<String> {
|
||||
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<String> {
|
||||
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<String> {
|
||||
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<String> {
|
||||
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<FirewallRule> {
|
||||
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<String> {
|
||||
tokens
|
||||
.iter()
|
||||
.position(|token| token == name)
|
||||
.and_then(|index| tokens.get(index + 1))
|
||||
.cloned()
|
||||
}
|
||||
|
||||
fn split_arguments(line: &str) -> Vec<String> {
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,6 +5,7 @@ mod fail2ban;
|
||||
mod firewall;
|
||||
mod logs;
|
||||
mod network;
|
||||
mod privileged;
|
||||
mod services;
|
||||
mod system;
|
||||
mod wireguard;
|
||||
@@ -17,7 +18,14 @@ use tracing_subscriber::EnvFilter;
|
||||
|
||||
#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn main() -> Result<()> {
|
||||
let config_path = parse_args()?;
|
||||
let arguments = parse_args()?;
|
||||
if arguments.privileged_helper {
|
||||
return privileged::serve_once(&arguments.config_path);
|
||||
}
|
||||
if let Some(transaction) = arguments.firewall_rollback {
|
||||
return privileged::rollback_firewall(&arguments.config_path, &transaction);
|
||||
}
|
||||
let config_path = arguments.config_path;
|
||||
let config = Config::load(&config_path)?;
|
||||
tracing_subscriber::fmt()
|
||||
.with_env_filter(
|
||||
@@ -54,9 +62,17 @@ async fn main() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_args() -> Result<PathBuf> {
|
||||
struct Arguments {
|
||||
config_path: PathBuf,
|
||||
privileged_helper: bool,
|
||||
firewall_rollback: Option<String>,
|
||||
}
|
||||
|
||||
fn parse_args() -> Result<Arguments> {
|
||||
let mut args = env::args().skip(1);
|
||||
let mut config = PathBuf::from("/etc/vps-agent/config.toml");
|
||||
let mut privileged_helper = false;
|
||||
let mut firewall_rollback = None;
|
||||
while let Some(argument) = args.next() {
|
||||
match argument.as_str() {
|
||||
"--config" => {
|
||||
@@ -65,6 +81,10 @@ fn parse_args() -> Result<PathBuf> {
|
||||
.map(PathBuf::from)
|
||||
.context("--config needs a path")?
|
||||
}
|
||||
"--privileged-helper" => privileged_helper = true,
|
||||
"--firewall-rollback" => {
|
||||
firewall_rollback = Some(args.next().context("--firewall-rollback needs an id")?)
|
||||
}
|
||||
"--version" | "-V" => {
|
||||
println!("vps-agent {}", env!("CARGO_PKG_VERSION"));
|
||||
std::process::exit(0);
|
||||
@@ -76,7 +96,11 @@ fn parse_args() -> Result<PathBuf> {
|
||||
_ => anyhow::bail!("unknown argument: {argument}"),
|
||||
}
|
||||
}
|
||||
Ok(config)
|
||||
Ok(Arguments {
|
||||
config_path: config,
|
||||
privileged_helper,
|
||||
firewall_rollback,
|
||||
})
|
||||
}
|
||||
|
||||
async fn wait_for_shutdown() {
|
||||
|
||||
915
agent/src/privileged.rs
Normal file
915
agent/src/privileged.rs
Normal file
@@ -0,0 +1,915 @@
|
||||
use crate::config::{valid_interface_name, valid_service_name, valid_simple_name, Config};
|
||||
use anyhow::{bail, Context, Result};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
fs::{self, OpenOptions},
|
||||
io::{BufRead, BufReader, Read, Write},
|
||||
os::unix::fs::OpenOptionsExt,
|
||||
path::{Path, PathBuf},
|
||||
process::{Command, Stdio},
|
||||
time::{Duration, SystemTime, UNIX_EPOCH},
|
||||
};
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::UnixStream,
|
||||
};
|
||||
|
||||
pub const SOCKET_PATH: &str = "/run/vps-agent-helper/control.sock";
|
||||
const MANAGED_CHAIN: &str = "VPS_CONTROL_INPUT";
|
||||
const MAX_MESSAGE_BYTES: usize = 64 * 1024;
|
||||
const MAX_SNAPSHOT_BYTES: usize = 2 * 1024 * 1024;
|
||||
const SNAPSHOT_DIRECTORY: &str = "/var/lib/vps-agent/firewall";
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Request {
|
||||
FirewallDump,
|
||||
FirewallAdd {
|
||||
rule: FirewallRuleRequest,
|
||||
},
|
||||
FirewallDelete {
|
||||
id: String,
|
||||
},
|
||||
FirewallConfirm {
|
||||
id: String,
|
||||
},
|
||||
RateLimitAdd {
|
||||
policy: RateLimitRequest,
|
||||
},
|
||||
RateLimitDelete {
|
||||
id: String,
|
||||
},
|
||||
ServiceInstall {
|
||||
service: String,
|
||||
},
|
||||
ServiceAction {
|
||||
service: String,
|
||||
operation: String,
|
||||
},
|
||||
Fail2BanAction {
|
||||
jail: String,
|
||||
ip: String,
|
||||
operation: String,
|
||||
},
|
||||
Fail2BanConfigure {
|
||||
settings: Fail2BanSettings,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct FirewallRuleRequest {
|
||||
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,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Fail2BanSettings {
|
||||
pub jail: String,
|
||||
pub enabled: bool,
|
||||
pub bantime_seconds: u32,
|
||||
pub findtime_seconds: u32,
|
||||
pub maxretry: u16,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Response {
|
||||
pub ok: bool,
|
||||
pub changed: bool,
|
||||
pub error: Option<String>,
|
||||
pub data: Option<Value>,
|
||||
}
|
||||
|
||||
impl Response {
|
||||
fn success(changed: bool) -> Self {
|
||||
Self {
|
||||
ok: true,
|
||||
changed,
|
||||
error: None,
|
||||
data: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn with_data(data: Value) -> Self {
|
||||
Self {
|
||||
ok: true,
|
||||
changed: false,
|
||||
error: None,
|
||||
data: Some(data),
|
||||
}
|
||||
}
|
||||
|
||||
fn transaction(id: &str) -> Self {
|
||||
Self {
|
||||
ok: true,
|
||||
changed: true,
|
||||
error: None,
|
||||
data: Some(serde_json::json!({"transaction_id": id})),
|
||||
}
|
||||
}
|
||||
|
||||
fn failure(error: impl Into<String>) -> Self {
|
||||
Self {
|
||||
ok: false,
|
||||
changed: false,
|
||||
error: Some(error.into()),
|
||||
data: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn call(request: &Request, timeout_duration: Duration) -> Result<Response> {
|
||||
tokio::time::timeout(timeout_duration, async {
|
||||
let mut stream = UnixStream::connect(SOCKET_PATH)
|
||||
.await
|
||||
.context("connect privileged helper")?;
|
||||
let mut payload = serde_json::to_vec(request).context("encode helper request")?;
|
||||
if payload.len() > MAX_MESSAGE_BYTES - 1 {
|
||||
bail!("helper request is too large")
|
||||
}
|
||||
payload.push(b'\n');
|
||||
stream
|
||||
.write_all(&payload)
|
||||
.await
|
||||
.context("write helper request")?;
|
||||
stream.shutdown().await.context("finish helper request")?;
|
||||
let mut response = Vec::new();
|
||||
stream
|
||||
.take((MAX_MESSAGE_BYTES + 1) as u64)
|
||||
.read_to_end(&mut response)
|
||||
.await
|
||||
.context("read helper response")?;
|
||||
if response.len() > MAX_MESSAGE_BYTES {
|
||||
bail!("helper response is too large")
|
||||
}
|
||||
let response: Response =
|
||||
serde_json::from_slice(&response).context("decode helper response")?;
|
||||
if !response.ok {
|
||||
bail!(
|
||||
"privileged helper: {}",
|
||||
response.error.as_deref().unwrap_or("operation failed")
|
||||
)
|
||||
}
|
||||
Ok(response)
|
||||
})
|
||||
.await
|
||||
.context("privileged helper timed out")?
|
||||
}
|
||||
|
||||
pub fn serve_once(config_path: &Path) -> Result<()> {
|
||||
let uid = Command::new("id")
|
||||
.arg("-u")
|
||||
.output()
|
||||
.context("determine helper uid")?;
|
||||
if !uid.status.success() || String::from_utf8_lossy(&uid.stdout).trim() != "0" {
|
||||
bail!("privileged helper must run as root")
|
||||
}
|
||||
let response = match read_request().and_then(|request| execute(config_path, request)) {
|
||||
Ok(response) => response,
|
||||
Err(error) => Response::failure(format!("{error:#}")),
|
||||
};
|
||||
serde_json::to_writer(std::io::stdout().lock(), &response).context("write helper response")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_request() -> Result<Request> {
|
||||
let mut reader = BufReader::new(std::io::stdin().lock()).take((MAX_MESSAGE_BYTES + 1) as u64);
|
||||
let mut payload = Vec::new();
|
||||
reader.read_until(b'\n', &mut payload)?;
|
||||
if payload.len() > MAX_MESSAGE_BYTES {
|
||||
bail!("helper request is too large")
|
||||
}
|
||||
serde_json::from_slice(&payload).context("decode helper request")
|
||||
}
|
||||
|
||||
fn execute(config_path: &Path, request: Request) -> Result<Response> {
|
||||
let config = Config::load(config_path)?;
|
||||
match request {
|
||||
Request::FirewallDump => dump_firewall(),
|
||||
Request::FirewallAdd { rule } => add_firewall_rule(&config, &rule),
|
||||
Request::FirewallDelete { id } => delete_managed_rule(&config, MANAGED_CHAIN, &id),
|
||||
Request::FirewallConfirm { id } => confirm_firewall(&id),
|
||||
Request::RateLimitAdd { policy } => add_rate_limit(&config, &policy),
|
||||
Request::RateLimitDelete { id } => delete_managed_rule(&config, "VPS_CONTROL_RATE", &id),
|
||||
Request::ServiceInstall { service } => install_service(&config, &service),
|
||||
Request::ServiceAction { service, operation } => {
|
||||
service_action(&config, &service, &operation)
|
||||
}
|
||||
Request::Fail2BanAction {
|
||||
jail,
|
||||
ip,
|
||||
operation,
|
||||
} => fail2ban_action(&config, &jail, &ip, &operation),
|
||||
Request::Fail2BanConfigure { settings } => configure_fail2ban(&config, &settings),
|
||||
}
|
||||
}
|
||||
|
||||
fn dump_firewall() -> Result<Response> {
|
||||
let output = Command::new("iptables-save")
|
||||
.arg("-c")
|
||||
.output()
|
||||
.context("execute iptables-save")?;
|
||||
if !output.status.success() || output.stdout.len() > MAX_SNAPSHOT_BYTES {
|
||||
bail!("iptables-save failed or exceeded size limit")
|
||||
}
|
||||
let rules = String::from_utf8(output.stdout).context("iptables-save output is not UTF-8")?;
|
||||
Ok(Response::with_data(Value::String(rules)))
|
||||
}
|
||||
|
||||
fn add_firewall_rule(config: &Config, rule: &FirewallRuleRequest) -> Result<Response> {
|
||||
if !config.firewall.management_enabled {
|
||||
bail!("firewall management is disabled")
|
||||
}
|
||||
if !valid_interface_name(&rule.interface)
|
||||
|| !config
|
||||
.firewall
|
||||
.allowed_interfaces
|
||||
.iter()
|
||||
.any(|value| value == &rule.interface)
|
||||
{
|
||||
bail!("interface is not allow-listed")
|
||||
}
|
||||
if !config
|
||||
.firewall
|
||||
.allowed_sources
|
||||
.iter()
|
||||
.any(|value| value == &rule.source)
|
||||
{
|
||||
bail!("source is not allow-listed")
|
||||
}
|
||||
if !matches!(rule.protocol.as_str(), "tcp" | "udp") {
|
||||
bail!("protocol must be tcp or udp")
|
||||
}
|
||||
if !matches!(rule.target.as_str(), "ACCEPT" | "DROP" | "REJECT") {
|
||||
bail!("unsupported firewall target")
|
||||
}
|
||||
if rule.port == 0 || !config.firewall.allowed_ports.contains(&rule.port) {
|
||||
bail!("port is not allow-listed")
|
||||
}
|
||||
if rule.comment.len() > 80
|
||||
|| !rule
|
||||
.comment
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b' ' | b'.' | b'_' | b'-'))
|
||||
{
|
||||
bail!("comment contains unsupported characters")
|
||||
}
|
||||
|
||||
let (transaction, snapshot) = prepare_firewall_transaction(config)?;
|
||||
let result = apply_firewall_rule(rule).and_then(|changed| {
|
||||
if config.firewall.persistence_enabled {
|
||||
run_status("netfilter-persistent", &["save"])
|
||||
.context("persist firewall with netfilter-persistent")?;
|
||||
}
|
||||
if !changed {
|
||||
bail!("firewall rule was not changed")
|
||||
}
|
||||
Ok(Response::transaction(&transaction))
|
||||
});
|
||||
rollback_on_error(result, &transaction, &snapshot, config)
|
||||
}
|
||||
|
||||
fn apply_firewall_rule(rule: &FirewallRuleRequest) -> Result<bool> {
|
||||
if !command_succeeds("iptables", &["-w", "5", "-S", MANAGED_CHAIN]) {
|
||||
run_status("iptables", &["-w", "5", "-N", MANAGED_CHAIN])?;
|
||||
}
|
||||
if !command_succeeds("iptables", &["-w", "5", "-C", "INPUT", "-j", MANAGED_CHAIN]) {
|
||||
run_status(
|
||||
"iptables",
|
||||
&["-w", "5", "-I", "INPUT", "1", "-j", MANAGED_CHAIN],
|
||||
)?;
|
||||
}
|
||||
|
||||
let port = rule.port.to_string();
|
||||
let id = random_id()?;
|
||||
let suffix = if rule.comment.is_empty() {
|
||||
format!("{}-{}", rule.protocol, rule.port)
|
||||
} else {
|
||||
rule.comment.clone()
|
||||
};
|
||||
let comment = format!("vps-control:{id}:{suffix}");
|
||||
let arguments = [
|
||||
"-w",
|
||||
"5",
|
||||
"-C",
|
||||
MANAGED_CHAIN,
|
||||
"-i",
|
||||
&rule.interface,
|
||||
"-s",
|
||||
&rule.source,
|
||||
"-p",
|
||||
&rule.protocol,
|
||||
"--dport",
|
||||
&port,
|
||||
"-m",
|
||||
"conntrack",
|
||||
"--ctstate",
|
||||
"NEW,ESTABLISHED",
|
||||
"-m",
|
||||
"comment",
|
||||
"--comment",
|
||||
&comment,
|
||||
"-j",
|
||||
&rule.target,
|
||||
];
|
||||
if command_succeeds("iptables", &arguments) {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut append_arguments = arguments;
|
||||
append_arguments[2] = "-A";
|
||||
run_status("iptables", &append_arguments)?;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn add_rate_limit(config: &Config, policy: &RateLimitRequest) -> Result<Response> {
|
||||
validate_firewall_common(
|
||||
config,
|
||||
&policy.interface,
|
||||
&policy.source,
|
||||
&policy.protocol,
|
||||
policy.port,
|
||||
&policy.comment,
|
||||
)?;
|
||||
if !(1..=100_000).contains(&policy.rate_per_second) || !(1..=10_000).contains(&policy.burst) {
|
||||
bail!("rate limit is outside the supported range")
|
||||
}
|
||||
let (transaction, snapshot) = prepare_firewall_transaction(config)?;
|
||||
let result = apply_rate_limit(policy).and_then(|changed| {
|
||||
persist_if_enabled(config)?;
|
||||
if !changed {
|
||||
bail!("rate-limit policy was not changed")
|
||||
}
|
||||
Ok(Response::transaction(&transaction))
|
||||
});
|
||||
rollback_on_error(result, &transaction, &snapshot, config)
|
||||
}
|
||||
|
||||
fn apply_rate_limit(policy: &RateLimitRequest) -> Result<bool> {
|
||||
const CHAIN: &str = "VPS_CONTROL_RATE";
|
||||
ensure_chain(CHAIN, 1)?;
|
||||
let id = random_id()?;
|
||||
let suffix = if policy.comment.is_empty() {
|
||||
format!("{}-{}", policy.protocol, policy.port)
|
||||
} else {
|
||||
policy.comment.clone()
|
||||
};
|
||||
let allow_comment = format!("vps-control:{id}:rate:{suffix}");
|
||||
let drop_comment = format!("vps-control:{id}:rate-drop:{suffix}");
|
||||
let port = policy.port.to_string();
|
||||
let rate = format!("{}/second", policy.rate_per_second);
|
||||
let burst = policy.burst.to_string();
|
||||
let hash_name = format!("vp_{}", &id[..12]);
|
||||
run_status(
|
||||
"iptables",
|
||||
&[
|
||||
"-w",
|
||||
"5",
|
||||
"-A",
|
||||
CHAIN,
|
||||
"-i",
|
||||
&policy.interface,
|
||||
"-s",
|
||||
&policy.source,
|
||||
"-p",
|
||||
&policy.protocol,
|
||||
"--dport",
|
||||
&port,
|
||||
"-m",
|
||||
"conntrack",
|
||||
"--ctstate",
|
||||
"NEW",
|
||||
"-m",
|
||||
"hashlimit",
|
||||
"--hashlimit-upto",
|
||||
&rate,
|
||||
"--hashlimit-burst",
|
||||
&burst,
|
||||
"--hashlimit-mode",
|
||||
"srcip",
|
||||
"--hashlimit-name",
|
||||
&hash_name,
|
||||
"-m",
|
||||
"comment",
|
||||
"--comment",
|
||||
&allow_comment,
|
||||
"-j",
|
||||
"ACCEPT",
|
||||
],
|
||||
)?;
|
||||
if let Err(error) = run_status(
|
||||
"iptables",
|
||||
&[
|
||||
"-w",
|
||||
"5",
|
||||
"-A",
|
||||
CHAIN,
|
||||
"-i",
|
||||
&policy.interface,
|
||||
"-s",
|
||||
&policy.source,
|
||||
"-p",
|
||||
&policy.protocol,
|
||||
"--dport",
|
||||
&port,
|
||||
"-m",
|
||||
"conntrack",
|
||||
"--ctstate",
|
||||
"NEW",
|
||||
"-m",
|
||||
"comment",
|
||||
"--comment",
|
||||
&drop_comment,
|
||||
"-j",
|
||||
"DROP",
|
||||
],
|
||||
) {
|
||||
let _ = delete_rules_by_comment(CHAIN, &id);
|
||||
return Err(error);
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn delete_managed_rule(config: &Config, chain: &str, id: &str) -> Result<Response> {
|
||||
if !config.firewall.management_enabled || !valid_id(id) {
|
||||
bail!("firewall management disabled or invalid rule id")
|
||||
}
|
||||
if !matches!(chain, MANAGED_CHAIN | "VPS_CONTROL_RATE") {
|
||||
bail!("unmanaged chain")
|
||||
}
|
||||
let (transaction, snapshot) = prepare_firewall_transaction(config)?;
|
||||
let result = delete_rules_by_comment(chain, id).and_then(|changed| {
|
||||
persist_if_enabled(config)?;
|
||||
if !changed {
|
||||
bail!("managed rule was not found")
|
||||
}
|
||||
Ok(Response::transaction(&transaction))
|
||||
});
|
||||
rollback_on_error(result, &transaction, &snapshot, config)
|
||||
}
|
||||
|
||||
fn delete_rules_by_comment(chain: &str, id: &str) -> Result<bool> {
|
||||
let output = Command::new("iptables")
|
||||
.args(["-w", "5", "-S", chain])
|
||||
.output()
|
||||
.context("list managed firewall chain")?;
|
||||
if !output.status.success() {
|
||||
bail!("list managed firewall chain failed")
|
||||
}
|
||||
let marker = format!("vps-control:{id}:");
|
||||
let text = String::from_utf8(output.stdout).context("iptables output is not UTF-8")?;
|
||||
let mut matches: Vec<Vec<String>> = text
|
||||
.lines()
|
||||
.filter(|line| line.contains(&marker))
|
||||
.map(split_command_line)
|
||||
.collect();
|
||||
let changed = !matches.is_empty();
|
||||
matches.reverse();
|
||||
for mut arguments in matches {
|
||||
if arguments.first().map(String::as_str) != Some("-A") {
|
||||
bail!("unexpected managed firewall rule")
|
||||
}
|
||||
arguments[0] = "-D".into();
|
||||
let references: Vec<&str> = arguments.iter().map(String::as_str).collect();
|
||||
run_status("iptables", &[&["-w", "5"], references.as_slice()].concat())?;
|
||||
}
|
||||
Ok(changed)
|
||||
}
|
||||
|
||||
fn ensure_chain(chain: &str, input_position: u8) -> Result<()> {
|
||||
if !command_succeeds("iptables", &["-w", "5", "-S", chain]) {
|
||||
run_status("iptables", &["-w", "5", "-N", chain])?;
|
||||
}
|
||||
if !command_succeeds("iptables", &["-w", "5", "-C", "INPUT", "-j", chain]) {
|
||||
let position = input_position.to_string();
|
||||
run_status(
|
||||
"iptables",
|
||||
&["-w", "5", "-I", "INPUT", &position, "-j", chain],
|
||||
)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate_firewall_common(
|
||||
config: &Config,
|
||||
interface: &str,
|
||||
source: &str,
|
||||
protocol: &str,
|
||||
port: u16,
|
||||
comment: &str,
|
||||
) -> Result<()> {
|
||||
if !config.firewall.management_enabled
|
||||
|| !valid_interface_name(interface)
|
||||
|| !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")
|
||||
}
|
||||
if comment.len() > 80
|
||||
|| !comment
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b' ' | b'.' | b'_' | b'-'))
|
||||
{
|
||||
bail!("comment contains unsupported characters")
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn service_action(config: &Config, service: &str, operation: &str) -> Result<Response> {
|
||||
if !valid_service_name(service) || !config.services.allowed.iter().any(|value| value == service)
|
||||
{
|
||||
bail!("service is not allow-listed")
|
||||
}
|
||||
match operation {
|
||||
"start" | "stop" | "restart" | "enable" | "disable" => {}
|
||||
_ => bail!("unsupported service operation"),
|
||||
}
|
||||
if matches!(operation, "start" | "stop" | "restart") {
|
||||
run_status("systemctl", &[operation, "--no-block", "--", service])?;
|
||||
} else {
|
||||
run_status("systemctl", &[operation, "--", service])?;
|
||||
}
|
||||
Ok(Response::success(true))
|
||||
}
|
||||
|
||||
fn fail2ban_action(config: &Config, jail: &str, ip: &str, operation: &str) -> Result<Response> {
|
||||
if !config.fail2ban.management_enabled
|
||||
|| !valid_simple_name(jail)
|
||||
|| !config
|
||||
.fail2ban
|
||||
.allowed_jails
|
||||
.iter()
|
||||
.any(|value| value == jail)
|
||||
{
|
||||
bail!("Fail2Ban jail is not allow-listed")
|
||||
}
|
||||
let address: std::net::IpAddr = ip.parse().context("invalid IP address")?;
|
||||
let command = match operation {
|
||||
"ban" => "banip",
|
||||
"unban" => "unbanip",
|
||||
_ => bail!("unsupported Fail2Ban operation"),
|
||||
};
|
||||
run_status(
|
||||
"fail2ban-client",
|
||||
&["set", jail, command, &address.to_string()],
|
||||
)?;
|
||||
Ok(Response::success(true))
|
||||
}
|
||||
|
||||
fn configure_fail2ban(config: &Config, settings: &Fail2BanSettings) -> Result<Response> {
|
||||
if !config.fail2ban.management_enabled
|
||||
|| !valid_simple_name(&settings.jail)
|
||||
|| !config
|
||||
.fail2ban
|
||||
.allowed_jails
|
||||
.iter()
|
||||
.any(|value| value == &settings.jail)
|
||||
|| !(10..=2_592_000).contains(&settings.bantime_seconds)
|
||||
|| !(10..=86_400).contains(&settings.findtime_seconds)
|
||||
|| !(1..=100).contains(&settings.maxretry)
|
||||
{
|
||||
bail!("invalid or non-allow-listed Fail2Ban settings")
|
||||
}
|
||||
let directory = Path::new("/etc/fail2ban/jail.d");
|
||||
fs::create_dir_all(directory).context("create Fail2Ban jail directory")?;
|
||||
let path = directory.join(format!("vps-control-{}.local", settings.jail));
|
||||
let backup = fs::read(&path).ok();
|
||||
let temporary = directory.join(format!(".vps-control-{}.tmp", settings.jail));
|
||||
let content = format!(
|
||||
"# Managed by VPS Control; manual changes will be replaced.\n[{}]\nenabled = {}\nbantime = {}\nfindtime = {}\nmaxretry = {}\n",
|
||||
settings.jail,
|
||||
if settings.enabled { "true" } else { "false" },
|
||||
settings.bantime_seconds,
|
||||
settings.findtime_seconds,
|
||||
settings.maxretry
|
||||
);
|
||||
let mut file = OpenOptions::new()
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.mode(0o644)
|
||||
.open(&temporary)?;
|
||||
file.write_all(content.as_bytes())?;
|
||||
file.sync_all()?;
|
||||
fs::rename(&temporary, &path)?;
|
||||
if let Err(error) = run_status("fail2ban-client", &["-t"])
|
||||
.and_then(|_| run_status("systemctl", &["reload", "fail2ban.service"]))
|
||||
{
|
||||
match backup {
|
||||
Some(previous) => fs::write(&path, previous)?,
|
||||
None => {
|
||||
let _ = fs::remove_file(&path);
|
||||
}
|
||||
}
|
||||
let _ = run_status("systemctl", &["reload", "fail2ban.service"]);
|
||||
bail!("Fail2Ban validation failed and configuration was rolled back: {error:#}")
|
||||
}
|
||||
Ok(Response::success(true))
|
||||
}
|
||||
|
||||
fn persist_if_enabled(config: &Config) -> Result<()> {
|
||||
if config.firewall.persistence_enabled {
|
||||
run_status("netfilter-persistent", &["save"])
|
||||
.context("persist firewall with netfilter-persistent")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn prepare_firewall_transaction(config: &Config) -> Result<(String, PathBuf)> {
|
||||
if fs::read_dir(SNAPSHOT_DIRECTORY)
|
||||
.ok()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Result::ok)
|
||||
.any(|entry| entry.file_name().to_string_lossy().starts_with("pending-"))
|
||||
{
|
||||
bail!("another firewall transaction is pending confirmation")
|
||||
}
|
||||
let snapshot = create_snapshot(config.firewall.max_snapshots)?;
|
||||
let id = random_id()?;
|
||||
let pending = Path::new(SNAPSHOT_DIRECTORY).join(format!("pending-{id}.rules"));
|
||||
fs::rename(&snapshot, &pending).context("mark firewall snapshot pending")?;
|
||||
let unit = format!("vps-agent-firewall-rollback-{id}");
|
||||
let delay = format!("{}s", config.firewall.rollback_timeout_seconds);
|
||||
let status = Command::new("systemd-run")
|
||||
.args([
|
||||
"--unit",
|
||||
&unit,
|
||||
"--on-active",
|
||||
&delay,
|
||||
"--timer-property=AccuracySec=1s",
|
||||
"/usr/local/bin/vps-agent",
|
||||
"--firewall-rollback",
|
||||
&id,
|
||||
"--config",
|
||||
"/etc/vps-agent/config.toml",
|
||||
])
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.context("schedule firewall safety rollback")?;
|
||||
if !status.success() {
|
||||
let _ = fs::remove_file(&pending);
|
||||
bail!("firewall safety rollback could not be scheduled")
|
||||
}
|
||||
Ok((id, pending))
|
||||
}
|
||||
|
||||
fn confirm_firewall(id: &str) -> Result<Response> {
|
||||
if !valid_id(id) {
|
||||
bail!("invalid firewall transaction id")
|
||||
}
|
||||
let pending = Path::new(SNAPSHOT_DIRECTORY).join(format!("pending-{id}.rules"));
|
||||
if !pending.is_file() {
|
||||
bail!("firewall transaction is not pending")
|
||||
}
|
||||
cancel_rollback(id);
|
||||
fs::remove_file(pending).context("remove confirmed firewall snapshot")?;
|
||||
Ok(Response::success(true))
|
||||
}
|
||||
|
||||
pub fn rollback_firewall(config_path: &Path, id: &str) -> Result<()> {
|
||||
if !valid_id(id) {
|
||||
bail!("invalid firewall transaction id")
|
||||
}
|
||||
let config = Config::load(config_path)?;
|
||||
let pending = Path::new(SNAPSHOT_DIRECTORY).join(format!("pending-{id}.rules"));
|
||||
if !pending.is_file() {
|
||||
return Ok(());
|
||||
}
|
||||
restore_snapshot(&pending)?;
|
||||
persist_if_enabled(&config)?;
|
||||
fs::remove_file(pending)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cancel_rollback(id: &str) {
|
||||
let timer = format!("vps-agent-firewall-rollback-{id}.timer");
|
||||
let service = format!("vps-agent-firewall-rollback-{id}.service");
|
||||
let _ = command_succeeds("systemctl", &["stop", &timer]);
|
||||
let _ = command_succeeds("systemctl", &["stop", &service]);
|
||||
}
|
||||
|
||||
fn rollback_on_error(
|
||||
result: Result<Response>,
|
||||
transaction: &str,
|
||||
snapshot: &Path,
|
||||
config: &Config,
|
||||
) -> Result<Response> {
|
||||
match result {
|
||||
Ok(response) => Ok(response),
|
||||
Err(error) => {
|
||||
cancel_rollback(transaction);
|
||||
if let Err(rollback_error) = restore_snapshot(snapshot) {
|
||||
bail!("operation failed: {error:#}; rollback failed: {rollback_error:#}")
|
||||
}
|
||||
let _ = persist_if_enabled(config);
|
||||
let _ = fs::remove_file(snapshot);
|
||||
bail!("operation failed and was rolled back: {error:#}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn random_id() -> Result<String> {
|
||||
let mut bytes = [0_u8; 8];
|
||||
fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
|
||||
Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect())
|
||||
}
|
||||
|
||||
fn valid_id(value: &str) -> bool {
|
||||
value.len() == 16 && value.bytes().all(|byte| byte.is_ascii_hexdigit())
|
||||
}
|
||||
|
||||
fn split_command_line(line: &str) -> Vec<String> {
|
||||
let mut values = Vec::new();
|
||||
let mut value = String::new();
|
||||
let mut quoted = false;
|
||||
for character in line.chars() {
|
||||
match character {
|
||||
'"' => quoted = !quoted,
|
||||
' ' | '\t' if !quoted => {
|
||||
if !value.is_empty() {
|
||||
values.push(std::mem::take(&mut value));
|
||||
}
|
||||
}
|
||||
_ => value.push(character),
|
||||
}
|
||||
}
|
||||
if !value.is_empty() {
|
||||
values.push(value);
|
||||
}
|
||||
values
|
||||
}
|
||||
|
||||
fn install_service(config: &Config, service: &str) -> Result<Response> {
|
||||
if !config.services.install_enabled {
|
||||
bail!("service installation is disabled")
|
||||
}
|
||||
if !valid_service_name(service) || !config.services.allowed.iter().any(|item| item == service) {
|
||||
bail!("service is not allow-listed")
|
||||
}
|
||||
let package = config
|
||||
.services
|
||||
.packages
|
||||
.get(service)
|
||||
.context("service has no package mapping")?;
|
||||
let unit = format!("vps-agent-install-{}.service", random_id()?);
|
||||
let timeout_seconds = format!("{}s", config.services.install_timeout_seconds);
|
||||
let runtime_property = format!("RuntimeMaxSec={timeout_seconds}");
|
||||
let status = Command::new("systemd-run")
|
||||
.args([
|
||||
"--unit",
|
||||
&unit,
|
||||
"--collect",
|
||||
"--no-block",
|
||||
"--property",
|
||||
&runtime_property,
|
||||
"--setenv=DEBIAN_FRONTEND=noninteractive",
|
||||
"/usr/bin/apt-get",
|
||||
"-q",
|
||||
"-y",
|
||||
"--no-install-recommends",
|
||||
"-o",
|
||||
"DPkg::Lock::Timeout=30",
|
||||
"install",
|
||||
package,
|
||||
])
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.context("queue allow-listed package installation")?;
|
||||
if !status.success() {
|
||||
bail!("package installation could not be queued")
|
||||
}
|
||||
Ok(Response::success(true))
|
||||
}
|
||||
|
||||
fn create_snapshot(maximum: usize) -> Result<PathBuf> {
|
||||
fs::create_dir_all(SNAPSHOT_DIRECTORY).context("create firewall snapshot directory")?;
|
||||
let output = Command::new("iptables-save")
|
||||
.arg("-c")
|
||||
.output()
|
||||
.context("execute iptables-save")?;
|
||||
if !output.status.success() || output.stdout.len() > MAX_SNAPSHOT_BYTES {
|
||||
bail!("iptables snapshot failed or exceeded size limit")
|
||||
}
|
||||
let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos();
|
||||
let path = Path::new(SNAPSHOT_DIRECTORY).join(format!("snapshot-{timestamp}.rules"));
|
||||
let mut file = OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.mode(0o600)
|
||||
.open(&path)
|
||||
.context("create firewall snapshot")?;
|
||||
file.write_all(&output.stdout)?;
|
||||
file.sync_all()?;
|
||||
prune_snapshots(maximum)?;
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn prune_snapshots(maximum: usize) -> Result<()> {
|
||||
let mut snapshots: Vec<_> = fs::read_dir(SNAPSHOT_DIRECTORY)?
|
||||
.filter_map(Result::ok)
|
||||
.filter(|entry| entry.file_name().to_string_lossy().starts_with("snapshot-"))
|
||||
.collect();
|
||||
snapshots.sort_by_key(|entry| entry.file_name());
|
||||
let remove_count = snapshots.len().saturating_sub(maximum);
|
||||
for entry in snapshots.into_iter().take(remove_count) {
|
||||
fs::remove_file(entry.path())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn restore_snapshot(path: &Path) -> Result<()> {
|
||||
let file = fs::File::open(path).context("open firewall snapshot")?;
|
||||
let mut child = Command::new("iptables-restore")
|
||||
.arg("-c")
|
||||
.stdin(Stdio::from(file))
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.context("execute iptables-restore")?;
|
||||
if !child.wait()?.success() {
|
||||
bail!("iptables-restore failed")
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn command_succeeds(program: &str, arguments: &[&str]) -> bool {
|
||||
Command::new(program)
|
||||
.args(arguments)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.is_ok_and(|status| status.success())
|
||||
}
|
||||
|
||||
fn run_status(program: &str, arguments: &[&str]) -> Result<()> {
|
||||
let status = Command::new(program)
|
||||
.args(arguments)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.with_context(|| format!("execute {program}"))?;
|
||||
if !status.success() {
|
||||
bail!("{program} failed")
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn socket_available() -> bool {
|
||||
Path::new(SOCKET_PATH).exists()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn helper_request_rejects_unknown_fields() {
|
||||
let payload = br#"{"action":"firewall_add","rule":{"interface":"wg0","source":"10.0.0.1/32","protocol":"tcp","port":22,"extra":true}}"#;
|
||||
assert!(serde_json::from_slice::<Request>(payload).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn helper_request_is_typed() {
|
||||
let payload = br#"{"action":"service_install","service":"nginx.service"}"#;
|
||||
assert!(matches!(
|
||||
serde_json::from_slice::<Request>(payload).unwrap(),
|
||||
Request::ServiceInstall { .. }
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,8 @@
|
||||
use crate::{command, config::valid_service_name};
|
||||
use crate::{
|
||||
command,
|
||||
config::{valid_service_name, Services},
|
||||
privileged,
|
||||
};
|
||||
use anyhow::{bail, Result};
|
||||
use serde::Serialize;
|
||||
use std::{collections::HashMap, time::Duration};
|
||||
@@ -6,100 +10,190 @@ use std::{collections::HashMap, time::Duration};
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct ServiceStatus {
|
||||
pub name: String,
|
||||
pub load_state: String,
|
||||
pub active_state: String,
|
||||
pub sub_state: String,
|
||||
pub pid: u32,
|
||||
pub memory_bytes: Option<u64>,
|
||||
pub active_since_monotonic_us: Option<u64>,
|
||||
pub description: String,
|
||||
pub unit_file_state: String,
|
||||
pub managed: bool,
|
||||
pub install_available: bool,
|
||||
}
|
||||
|
||||
pub async fn list(allowed: &[String], timeout: Duration) -> Vec<ServiceStatus> {
|
||||
let mut result = Vec::with_capacity(allowed.len());
|
||||
for name in allowed {
|
||||
match inspect(name, timeout).await {
|
||||
Ok(status) => result.push(status),
|
||||
Err(_) => result.push(ServiceStatus {
|
||||
name: name.clone(),
|
||||
active_state: "unavailable".into(),
|
||||
sub_state: "unknown".into(),
|
||||
pid: 0,
|
||||
memory_bytes: None,
|
||||
active_since_monotonic_us: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pub async fn restart(name: &str, allowed: &[String], timeout: Duration) -> Result<()> {
|
||||
if !valid_service_name(name) || !allowed.iter().any(|item| item == name) {
|
||||
bail!("service is not allow-listed")
|
||||
}
|
||||
command::run("systemctl", &["restart", "--", name], timeout).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn inspect(name: &str, timeout: Duration) -> Result<ServiceStatus> {
|
||||
if !valid_service_name(name) {
|
||||
bail!("invalid service name")
|
||||
}
|
||||
let output = command::run(
|
||||
pub async fn list(config: &Services, timeout: Duration) -> Vec<ServiceStatus> {
|
||||
let units_future = command::run(
|
||||
"systemctl",
|
||||
&[
|
||||
"show",
|
||||
"list-units",
|
||||
"--type=service",
|
||||
"--all",
|
||||
"--no-legend",
|
||||
"--no-pager",
|
||||
"--property=ActiveState,SubState,MainPID,MemoryCurrent,ActiveEnterTimestampMonotonic",
|
||||
"--",
|
||||
name,
|
||||
"--plain",
|
||||
],
|
||||
timeout,
|
||||
);
|
||||
let files_future = command::run(
|
||||
"systemctl",
|
||||
&[
|
||||
"list-unit-files",
|
||||
"--type=service",
|
||||
"--no-legend",
|
||||
"--no-pager",
|
||||
],
|
||||
timeout,
|
||||
);
|
||||
let (units_output, files_output) = tokio::join!(units_future, files_future);
|
||||
let unit_files = files_output
|
||||
.ok()
|
||||
.map(|output| parse_unit_files(&output.stdout))
|
||||
.unwrap_or_default();
|
||||
let mut rows = match units_output {
|
||||
Ok(output) => parse_units(&output.stdout, config),
|
||||
Err(_) => Vec::new(),
|
||||
};
|
||||
for row in &mut rows {
|
||||
row.unit_file_state = unit_files
|
||||
.get(&row.name)
|
||||
.cloned()
|
||||
.unwrap_or_else(|| "unknown".into());
|
||||
}
|
||||
for (name, state) in &unit_files {
|
||||
if !rows.iter().any(|item| &item.name == name) {
|
||||
let managed = config.allowed.iter().any(|item| item == name);
|
||||
rows.push(ServiceStatus {
|
||||
name: name.clone(),
|
||||
load_state: "loaded".into(),
|
||||
active_state: "inactive".into(),
|
||||
sub_state: "dead".into(),
|
||||
description: "Installed unit file".into(),
|
||||
unit_file_state: state.clone(),
|
||||
managed,
|
||||
install_available: false,
|
||||
});
|
||||
}
|
||||
}
|
||||
for name in &config.allowed {
|
||||
if !rows.iter().any(|item| &item.name == name) {
|
||||
rows.push(ServiceStatus {
|
||||
name: name.clone(),
|
||||
load_state: "not-found".into(),
|
||||
active_state: "inactive".into(),
|
||||
sub_state: "dead".into(),
|
||||
description: config
|
||||
.packages
|
||||
.get(name)
|
||||
.map(|package| format!("Not installed (package: {package})"))
|
||||
.unwrap_or_else(|| "Not installed".into()),
|
||||
unit_file_state: "not-found".into(),
|
||||
managed: true,
|
||||
install_available: config.install_enabled && config.packages.contains_key(name),
|
||||
});
|
||||
}
|
||||
}
|
||||
rows.sort_by(|left, right| {
|
||||
right
|
||||
.managed
|
||||
.cmp(&left.managed)
|
||||
.then_with(|| left.name.cmp(&right.name))
|
||||
});
|
||||
rows.truncate(config.inventory_limit);
|
||||
rows
|
||||
}
|
||||
|
||||
pub async fn action(
|
||||
name: &str,
|
||||
operation: &str,
|
||||
config: &Services,
|
||||
timeout: Duration,
|
||||
) -> Result<()> {
|
||||
validate_managed(name, config)?;
|
||||
if !matches!(
|
||||
operation,
|
||||
"start" | "stop" | "restart" | "enable" | "disable"
|
||||
) {
|
||||
bail!("unsupported service operation")
|
||||
}
|
||||
privileged::call(
|
||||
&privileged::Request::ServiceAction {
|
||||
service: name.into(),
|
||||
operation: operation.into(),
|
||||
},
|
||||
timeout,
|
||||
)
|
||||
.await?;
|
||||
let values: HashMap<_, _> = output
|
||||
.stdout
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once('='))
|
||||
.collect();
|
||||
Ok(ServiceStatus {
|
||||
name: name.to_owned(),
|
||||
active_state: values
|
||||
.get("ActiveState")
|
||||
.copied()
|
||||
.unwrap_or("unknown")
|
||||
.to_owned(),
|
||||
sub_state: values
|
||||
.get("SubState")
|
||||
.copied()
|
||||
.unwrap_or("unknown")
|
||||
.to_owned(),
|
||||
pid: values
|
||||
.get("MainPID")
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or_default(),
|
||||
memory_bytes: values.get("MemoryCurrent").and_then(|v| v.parse().ok()),
|
||||
active_since_monotonic_us: values
|
||||
.get("ActiveEnterTimestampMonotonic")
|
||||
.and_then(|v| v.parse().ok()),
|
||||
})
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn install(name: &str, config: &Services, timeout: Duration) -> Result<()> {
|
||||
validate_managed(name, config)?;
|
||||
if !config.install_enabled || !config.packages.contains_key(name) {
|
||||
bail!("service installation is disabled or unavailable")
|
||||
}
|
||||
privileged::call(
|
||||
&privileged::Request::ServiceInstall {
|
||||
service: name.into(),
|
||||
},
|
||||
timeout,
|
||||
)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate_managed(name: &str, config: &Services) -> Result<()> {
|
||||
if !valid_service_name(name) || !config.allowed.iter().any(|item| item == name) {
|
||||
bail!("service is not allow-listed")
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_units(text: &str, config: &Services) -> Vec<ServiceStatus> {
|
||||
text.lines()
|
||||
.filter_map(|line| {
|
||||
let mut fields = line.split_whitespace();
|
||||
let name = fields.next()?.trim_start_matches(['●', ' ']).to_owned();
|
||||
let load_state = fields.next()?.to_owned();
|
||||
let active_state = fields.next()?.to_owned();
|
||||
let sub_state = fields.next()?.to_owned();
|
||||
let description = fields.collect::<Vec<_>>().join(" ");
|
||||
let managed = config.allowed.iter().any(|item| item == &name);
|
||||
Some(ServiceStatus {
|
||||
install_available: managed
|
||||
&& config.install_enabled
|
||||
&& config.packages.contains_key(&name),
|
||||
name,
|
||||
load_state,
|
||||
active_state,
|
||||
sub_state,
|
||||
description,
|
||||
unit_file_state: "unknown".into(),
|
||||
managed,
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn parse_unit_files(text: &str) -> HashMap<String, String> {
|
||||
text.lines()
|
||||
.filter_map(|line| {
|
||||
let mut fields = line.split_whitespace();
|
||||
Some((fields.next()?.to_owned(), fields.next()?.to_owned()))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejects_service_outside_allowlist_without_execution() {
|
||||
assert!(
|
||||
restart("postgresql", &["nginx".into()], Duration::from_secs(1))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(restart(
|
||||
"nginx;reboot",
|
||||
&["nginx;reboot".into()],
|
||||
Duration::from_secs(1)
|
||||
)
|
||||
.await
|
||||
.is_err());
|
||||
#[test]
|
||||
fn parses_systemd_inventory() {
|
||||
let config = Services {
|
||||
allowed: vec!["nginx.service".into()],
|
||||
..Services::default()
|
||||
};
|
||||
let rows = parse_units("nginx.service loaded active running A web server\nssh.service loaded inactive dead SSH daemon\n", &config);
|
||||
assert_eq!(rows.len(), 2);
|
||||
assert!(rows[0].managed);
|
||||
assert_eq!(rows[0].description, "A web server");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user