use std::ffi::OsString;
use std::fmt;
use std::net::SocketAddr;
use crate::auth::{Secret, is_vchar};
use crate::site::BaseUrl;
pub const BIND: &str = "SENU_BIND";
pub const WEB_USER: &str = "SENU_WEB_USER";
pub const WEB_PASSWORD: &str = "SENU_WEB_PASSWORD";
pub const API_TOKEN: &str = "SENU_API_TOKEN";
pub const MCP_TOKEN: &str = "SENU_MCP_TOKEN";
pub const SITE_URL: &str = "SENU_SITE_URL";
pub const DEFAULT_BIND: &str = "127.0.0.1:3000";
#[derive(Debug)]
pub struct ServeConfig {
pub bind: SocketAddr,
pub web_user: Secret,
pub web_password: Secret,
pub api_token: Secret,
}
#[derive(Debug)]
pub struct SiteConfig {
pub bind: SocketAddr,
pub base_url: Option<BaseUrl>,
}
#[derive(Debug)]
pub struct McpConfig {
pub token: Secret,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Problem {
Missing,
Empty,
Malformed,
Unknown,
Repeated,
SameValueAs(&'static str),
NotForSite,
OnlyForSite,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ConfigError {
pub variable: String,
pub problem: Problem,
}
impl ConfigError {
fn new(variable: impl Into<String>, problem: Problem) -> Self {
Self {
variable: variable.into(),
problem,
}
}
}
impl fmt::Display for ConfigError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = &self.variable;
match &self.problem {
Problem::Missing => write!(f, "senu: {name} is not set"),
Problem::Empty => write!(f, "senu: {name} is set but empty"),
Problem::Malformed => write!(f, "senu: {name} is malformed: {}", rule(name)),
Problem::Unknown => write!(
f,
"senu: {name} is an unknown variable; roles and tenants cannot be configured"
),
Problem::Repeated => write!(f, "senu: {name} is set more than once"),
Problem::SameValueAs(other) => {
write!(f, "senu: {name} must not have the same value as {other}")
}
Problem::NotForSite => write!(
f,
"senu: {name} is set, but `senu site` serves public pages and uses no credentials; unset it"
),
Problem::OnlyForSite => write!(
f,
"senu: {name} is set, but only `senu site` uses it; unset it"
),
}
}
}
impl std::error::Error for ConfigError {}
fn rule(variable: &str) -> &'static str {
match variable {
BIND => "expected a loopback IP address and port, such as 127.0.0.1:3000",
WEB_USER => "expected 1 to 64 visible ASCII characters (0x21-0x7E) without ':'",
SITE_URL => {
"expected an https:// address that ends in '/', such as https://example.org/senu/"
}
_ => "expected 1 to 256 visible ASCII characters (0x21-0x7E)",
}
}
const KNOWN: [&str; 6] = [BIND, WEB_USER, WEB_PASSWORD, API_TOKEN, MCP_TOKEN, SITE_URL];
const MAX_USER_BYTES: usize = 64;
const MAX_SECRET_BYTES: usize = 256;
struct Validated {
bind: SocketAddr,
web_user: Option<Secret>,
web_password: Option<Secret>,
api_token: Option<Secret>,
mcp_token: Option<Secret>,
}
pub fn serve_config<I>(vars: I) -> Result<ServeConfig, ConfigError>
where
I: IntoIterator<Item = (OsString, OsString)>,
{
let values = validate(vars)?;
Ok(ServeConfig {
bind: values.bind,
web_user: required(WEB_USER, values.web_user)?,
web_password: required(WEB_PASSWORD, values.web_password)?,
api_token: required(API_TOKEN, values.api_token)?,
})
}
pub fn mcp_config<I>(vars: I) -> Result<McpConfig, ConfigError>
where
I: IntoIterator<Item = (OsString, OsString)>,
{
let values = validate(vars)?;
Ok(McpConfig {
token: required(MCP_TOKEN, values.mcp_token)?,
})
}
pub fn site_config<I>(vars: I) -> Result<SiteConfig, ConfigError>
where
I: IntoIterator<Item = (OsString, OsString)>,
{
let [bind, user, password, api, mcp, site_url] = collect(vars)?;
let credentials = [
(WEB_USER, user),
(WEB_PASSWORD, password),
(API_TOKEN, api),
(MCP_TOKEN, mcp),
];
for (name, value) in credentials {
if value.is_some() {
return Err(ConfigError::new(name, Problem::NotForSite));
}
}
let base_url = match site_url {
None => None,
Some(raw) if raw.is_empty() => return Err(ConfigError::new(SITE_URL, Problem::Empty)),
Some(raw) => Some(
raw.to_str()
.and_then(BaseUrl::new)
.ok_or_else(|| ConfigError::new(SITE_URL, Problem::Malformed))?,
),
};
Ok(SiteConfig {
bind: bind_address(bind)?,
base_url,
})
}
fn required(name: &'static str, value: Option<Secret>) -> Result<Secret, ConfigError> {
value.ok_or_else(|| ConfigError::new(name, Problem::Missing))
}
fn validate<I>(vars: I) -> Result<Validated, ConfigError>
where
I: IntoIterator<Item = (OsString, OsString)>,
{
let raw = collect(vars)?;
let [bind, user, password, api, mcp, site_url] = raw;
if site_url.is_some() {
return Err(ConfigError::new(SITE_URL, Problem::OnlyForSite));
}
let validated = Validated {
bind: bind_address(bind)?,
web_user: credential(WEB_USER, user, MAX_USER_BYTES, true)?,
web_password: credential(WEB_PASSWORD, password, MAX_SECRET_BYTES, false)?,
api_token: credential(API_TOKEN, api, MAX_SECRET_BYTES, false)?,
mcp_token: credential(MCP_TOKEN, mcp, MAX_SECRET_BYTES, false)?,
};
let credentials = [
(WEB_USER, &validated.web_user),
(WEB_PASSWORD, &validated.web_password),
(API_TOKEN, &validated.api_token),
(MCP_TOKEN, &validated.mcp_token),
];
for (i, (name, value)) in credentials.iter().enumerate() {
for (earlier, earlier_value) in &credentials[..i] {
if let (Some(value), Some(earlier_value)) = (value, earlier_value)
&& value == earlier_value
{
return Err(ConfigError::new(*name, Problem::SameValueAs(earlier)));
}
}
}
Ok(validated)
}
fn collect<I>(vars: I) -> Result<[Option<OsString>; 6], ConfigError>
where
I: IntoIterator<Item = (OsString, OsString)>,
{
let mut values: [Option<OsString>; 6] = Default::default();
let mut unknown = std::collections::BTreeSet::new();
let mut repeated = None;
for (name, value) in vars {
let name = name.to_string_lossy();
if !name.starts_with("SENU_") {
continue;
}
match KNOWN.iter().position(|known| *known == name) {
Some(index) => {
if values[index].replace(value).is_some() {
repeated.get_or_insert(KNOWN[index]);
}
}
None => {
unknown.insert(printable_name(&name));
}
}
}
if let Some(name) = unknown.into_iter().next() {
return Err(ConfigError::new(name, Problem::Unknown));
}
if let Some(name) = repeated {
return Err(ConfigError::new(name, Problem::Repeated));
}
Ok(values)
}
fn printable_name(name: &str) -> String {
name.chars()
.map(|c| if c.is_ascii_graphic() { c } else { '?' })
.collect()
}
fn bind_address(raw: Option<OsString>) -> Result<SocketAddr, ConfigError> {
let Some(raw) = raw else {
return Ok(SocketAddr::from(([127, 0, 0, 1], 3000)));
};
if raw.is_empty() {
return Err(ConfigError::new(BIND, Problem::Empty));
}
match raw.to_str().map(str::parse::<SocketAddr>) {
Some(Ok(addr)) if addr.ip().is_loopback() => Ok(addr),
_ => Err(ConfigError::new(BIND, Problem::Malformed)),
}
}
fn credential(
name: &'static str,
raw: Option<OsString>,
max_bytes: usize,
forbid_colon: bool,
) -> Result<Option<Secret>, ConfigError> {
let Some(raw) = raw else {
return Ok(None);
};
if raw.is_empty() {
return Err(ConfigError::new(name, Problem::Empty));
}
let malformed = || ConfigError::new(name, Problem::Malformed);
let text = raw.into_string().map_err(|_| malformed())?;
let valid = text.len() <= max_bytes
&& text.bytes().all(is_vchar)
&& !(forbid_colon && text.contains(':'));
if valid {
Secret::new(text).map(Some).map_err(|_| malformed())
} else {
Err(malformed())
}
}
#[cfg(test)]
mod tests {
use super::*;
const USER: &str = "demo";
const PASSWORD: &str = "web-password-sentinel";
const API: &str = "api-token-sentinel";
const MCP: &str = "mcp-token-sentinel";
fn env(pairs: &[(&str, &str)]) -> Vec<(OsString, OsString)> {
pairs
.iter()
.map(|(k, v)| (OsString::from(k), OsString::from(v)))
.collect()
}
fn serve_env() -> Vec<(&'static str, &'static str)> {
vec![
(WEB_USER, USER),
(WEB_PASSWORD, PASSWORD),
(API_TOKEN, API),
("PATH", "/usr/bin"),
("HOME", "/nonexistent"),
]
}
fn with(
base: &[(&'static str, &'static str)],
name: &'static str,
value: &'static str,
) -> Vec<(&'static str, &'static str)> {
let mut pairs: Vec<_> = base.iter().copied().filter(|(k, _)| *k != name).collect();
pairs.push((name, value));
pairs
}
fn without(
base: &[(&'static str, &'static str)],
name: &str,
) -> Vec<(&'static str, &'static str)> {
base.iter().copied().filter(|(k, _)| *k != name).collect()
}
fn serve_err(pairs: &[(&str, &str)]) -> ConfigError {
serve_config(env(pairs)).expect_err("configuration should be rejected")
}
fn mcp_err(pairs: &[(&str, &str)]) -> ConfigError {
mcp_config(env(pairs)).expect_err("configuration should be rejected")
}
fn assert_problem(err: &ConfigError, variable: &str, problem: Problem) {
assert_eq!(err.variable, variable, "{err:?}");
assert_eq!(err.problem, problem, "{err:?}");
}
#[test]
fn valid_serve_configuration_uses_the_default_bind() {
let config = serve_config(env(&serve_env())).expect("valid configuration");
assert_eq!(config.bind, DEFAULT_BIND.parse().unwrap());
assert!(config.web_user.matches(USER.as_bytes()));
assert!(config.web_password.matches(PASSWORD.as_bytes()));
assert!(config.api_token.matches(API.as_bytes()));
}
#[test]
fn loopback_binds_are_accepted_including_port_zero() {
for bind in ["127.0.0.1:0", "127.0.0.1:8080", "127.1.2.3:3000", "[::1]:0"] {
let config = serve_config(env(&with(&serve_env(), BIND, bind))).expect(bind);
assert_eq!(config.bind, bind.parse().unwrap());
}
}
#[test]
fn non_loopback_or_malformed_binds_are_rejected() {
for bind in [
"0.0.0.0:3000",
"[::]:3000",
"192.168.1.10:3000",
"[::ffff:127.0.0.1]:3000",
"localhost:3000",
"127.0.0.1",
"127.0.0.1:65536",
"http://127.0.0.1:3000",
] {
let err = serve_err(&with(&serve_env(), BIND, bind));
assert_problem(&err, BIND, Problem::Malformed);
}
assert_problem(
&serve_err(&with(&serve_env(), BIND, "")),
BIND,
Problem::Empty,
);
}
#[test]
fn each_serve_variable_is_required() {
for name in [WEB_USER, WEB_PASSWORD, API_TOKEN] {
assert_problem(
&serve_err(&without(&serve_env(), name)),
name,
Problem::Missing,
);
}
}
#[test]
fn each_serve_variable_must_be_non_empty() {
for name in [WEB_USER, WEB_PASSWORD, API_TOKEN] {
assert_problem(
&serve_err(&with(&serve_env(), name, "")),
name,
Problem::Empty,
);
}
}
#[test]
fn length_limits_are_inclusive() {
let user64 = "u".repeat(64);
let user65 = "u".repeat(65);
let secret256 = "s".repeat(256);
let secret257 = "s".repeat(257);
let leak = |s: String| -> &'static str { Box::leak(s.into_boxed_str()) };
assert!(serve_config(env(&with(&serve_env(), WEB_USER, leak(user64)))).is_ok());
assert_problem(
&serve_err(&with(&serve_env(), WEB_USER, leak(user65))),
WEB_USER,
Problem::Malformed,
);
for name in [WEB_PASSWORD, API_TOKEN] {
assert!(serve_config(env(&with(&serve_env(), name, leak(secret256.clone())))).is_ok());
assert_problem(
&serve_err(&with(&serve_env(), name, leak(secret257.clone()))),
name,
Problem::Malformed,
);
}
}
#[test]
fn only_visible_ascii_is_accepted() {
for value in [
"has space",
"tab\there",
"new\nline",
"del\u{7f}",
"café",
"\u{0}",
] {
for name in [WEB_USER, WEB_PASSWORD, API_TOKEN] {
assert_problem(
&serve_err(&with(&serve_env(), name, value)),
name,
Problem::Malformed,
);
}
}
}
#[test]
fn user_name_must_not_contain_a_colon_but_secrets_may() {
assert_problem(
&serve_err(&with(&serve_env(), WEB_USER, "de:mo")),
WEB_USER,
Problem::Malformed,
);
assert!(serve_config(env(&with(&serve_env(), WEB_PASSWORD, "pa:ss"))).is_ok());
}
#[cfg(unix)]
#[test]
fn non_unicode_values_are_malformed() {
use std::os::unix::ffi::OsStringExt;
let mut vars = env(&without(&serve_env(), API_TOKEN));
vars.push((
OsString::from(API_TOKEN),
OsString::from_vec(vec![b'a', 0xff]),
));
let err = serve_config(vars).unwrap_err();
assert_problem(&err, API_TOKEN, Problem::Malformed);
}
#[test]
fn unknown_senu_variables_are_rejected() {
let err = serve_err(&with(&serve_env(), "SENU_ROLE", "admin"));
assert_problem(&err, "SENU_ROLE", Problem::Unknown);
let err = serve_err(&with(&serve_env(), "SENU_TENANT", "globex"));
assert_problem(&err, "SENU_TENANT", Problem::Unknown);
let err = mcp_err(&[(MCP_TOKEN, MCP), ("SENU_", "x")]);
assert_problem(&err, "SENU_", Problem::Unknown);
}
#[test]
fn repeated_variables_are_rejected() {
let mut pairs = serve_env();
pairs.push((API_TOKEN, API));
assert_problem(&serve_err(&pairs), API_TOKEN, Problem::Repeated);
}
#[test]
fn credential_values_must_differ() {
let err = serve_err(&with(&serve_env(), API_TOKEN, PASSWORD));
assert_eq!(err.problem, Problem::SameValueAs(WEB_PASSWORD));
assert_eq!(err.variable, API_TOKEN);
let err = serve_err(&with(&serve_env(), WEB_PASSWORD, USER));
assert_eq!(err.problem, Problem::SameValueAs(WEB_USER));
let mut pairs = serve_env();
pairs.push((MCP_TOKEN, API));
let err = serve_err(&pairs);
assert_problem(&err, MCP_TOKEN, Problem::SameValueAs(API_TOKEN));
}
#[test]
fn site_needs_nothing_and_accepts_only_a_loopback_bind() {
let config = site_config(env(&[("PATH", "/bin")])).unwrap();
assert_eq!(config.bind, "127.0.0.1:3000".parse().unwrap());
let config = site_config(env(&[(BIND, "[::1]:0")])).unwrap();
assert_eq!(config.bind, "[::1]:0".parse().unwrap());
let err = site_config(env(&[(BIND, "0.0.0.0:3000")])).unwrap_err();
assert_problem(&err, BIND, Problem::Malformed);
}
#[test]
fn site_refuses_every_credential_without_printing_it() {
for name in [WEB_USER, WEB_PASSWORD, API_TOKEN, MCP_TOKEN] {
let err = site_config(env(&[(name, "zz-credential-value")])).unwrap_err();
assert_problem(&err, name, Problem::NotForSite);
let message = err.to_string();
assert!(
message.contains(name) && message.contains("senu site"),
"{message}"
);
assert!(!message.contains("zz-credential-value"), "{message}");
}
let err = site_config(env(&[("SENU_X", "1")])).unwrap_err();
assert_problem(&err, "SENU_X", Problem::Unknown);
}
#[test]
fn valid_mcp_configuration_needs_only_the_mcp_token() {
let config = mcp_config(env(&[(MCP_TOKEN, MCP)])).expect("valid configuration");
assert!(config.token.matches(MCP.as_bytes()));
}
#[test]
fn mcp_does_not_fall_back_to_the_api_token() {
assert_problem(&mcp_err(&[(API_TOKEN, API)]), MCP_TOKEN, Problem::Missing);
assert_problem(&mcp_err(&[]), MCP_TOKEN, Problem::Missing);
}
#[test]
fn mcp_token_is_validated_and_kept_distinct() {
assert_problem(&mcp_err(&[(MCP_TOKEN, "")]), MCP_TOKEN, Problem::Empty);
assert_problem(
&mcp_err(&[(MCP_TOKEN, "two words")]),
MCP_TOKEN,
Problem::Malformed,
);
let err = mcp_err(&[(MCP_TOKEN, MCP), (WEB_PASSWORD, MCP)]);
assert_problem(&err, MCP_TOKEN, Problem::SameValueAs(WEB_PASSWORD));
}
#[test]
fn messages_name_the_variable_and_never_the_value() {
let sentinel = "sentinel-value-0123456789";
let leak: &'static str = sentinel;
let failures = [
serve_err(&with(
&serve_env(),
API_TOKEN,
"sentinel-value-0123456789 x",
)),
serve_err(&with(&serve_env(), WEB_USER, "sentinel-value-0123456789:")),
serve_err(&with(&serve_env(), BIND, leak)),
serve_err(&[(WEB_USER, USER), (WEB_PASSWORD, leak), (API_TOKEN, leak)]),
mcp_err(&[(MCP_TOKEN, &"sentinel-value-0123456789".repeat(20))]),
];
for err in failures {
let message = err.to_string();
assert!(message.contains(&err.variable), "{message}");
assert!(message.starts_with("senu: "), "{message}");
assert!(!message.contains(sentinel), "{message}");
assert!(!format!("{err:?}").contains(sentinel));
}
}
#[test]
fn messages_describe_the_problem() {
let missing = serve_err(&without(&serve_env(), API_TOKEN)).to_string();
assert!(missing.contains("not set"), "{missing}");
let unknown = serve_err(&with(&serve_env(), "SENU_ROLE", "x")).to_string();
assert!(unknown.contains("unknown"), "{unknown}");
let bind = serve_err(&with(&serve_env(), BIND, "0.0.0.0:1")).to_string();
assert!(bind.contains("loopback"), "{bind}");
let same = serve_err(&with(&serve_env(), API_TOKEN, PASSWORD)).to_string();
assert!(
same.contains(WEB_PASSWORD) && same.contains(API_TOKEN),
"{same}"
);
}
#[test]
fn debug_output_of_configs_redacts_secrets() {
let serve = serve_config(env(&serve_env())).unwrap();
let text = format!("{serve:?}");
for secret in [PASSWORD, API] {
assert!(!text.contains(secret), "{text}");
}
let mcp = mcp_config(env(&[(MCP_TOKEN, MCP)])).unwrap();
assert!(!format!("{mcp:?}").contains(MCP));
}
#[test]
fn the_site_url_is_an_https_address_that_ends_in_a_slash() {
let config = site_config(env(&[(SITE_URL, "https://example.org/senu/")])).unwrap();
let base = config.base_url.expect("a base URL");
assert_eq!(base.as_str(), "https://example.org/senu/");
assert!(site_config(env(&[])).unwrap().base_url.is_none());
let empty = site_config(env(&[(SITE_URL, "")])).unwrap_err();
assert_problem(&empty, SITE_URL, Problem::Empty);
for bad in [
"http://example.net/",
"https://example.net",
"https://example.net/senu",
"example.net/",
"https:///x/",
"https://example.net//x/",
"https://example.net/?q=1/",
"https://example.net/#top/",
"https://example.net/\"x/",
"https://example.net/<x>/",
"https://example.net/a b/",
"https://example.net/é/",
"//example.net/",
"javascript:alert(1)/",
] {
let err = site_config(env(&[(SITE_URL, bad)])).unwrap_err();
assert_problem(&err, SITE_URL, Problem::Malformed);
let message = err.to_string();
assert!(message.contains("https://example.org/senu/"), "{message}");
assert!(!message.contains(bad), "{message}");
}
let long = format!("https://example.org/{}/", "a".repeat(200));
let err = site_config(env(&[(SITE_URL, &long)])).unwrap_err();
assert_problem(&err, SITE_URL, Problem::Malformed);
}
#[test]
fn the_site_url_is_refused_by_the_other_modes() {
let mut vars = serve_env();
vars.push((SITE_URL, "https://example.org/"));
let err = serve_config(env(&vars)).unwrap_err();
assert_problem(&err, SITE_URL, Problem::OnlyForSite);
let err =
mcp_config(env(&[(MCP_TOKEN, MCP), (SITE_URL, "https://example.org/")])).unwrap_err();
assert_problem(&err, SITE_URL, Problem::OnlyForSite);
assert!(err.to_string().contains("only `senu site` uses it"));
}
}