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