From ed1eaf8adf1640cc306907075dc9f4f1370b7581 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 18 Nov 2026 23:07:20 -0700 Subject: [PATCH] PROXY protocol copies of the mail listeners, from the environment Behind a load balancer that sends PROXY v2, the server needs listeners that take the client's address from the header, believed from the load balancer only. In Kubernetes the chart can't add listeners to a store, and the store-wide trusted networks would make every listener, HTTP included, expect a header from the pod network. INBUXA_MAIL_PROXY_LISTENERS=smtp=10025,imaps=10993 gives each named mail listener a copy on that port, with the same protocol and TLS, that trusts PROXY headers from INBUXA_MAIL_PROXY_TRUSTED_NETWORKS only. The copies aren't stored; the listeners they copy are unchanged. Each variable without the other, an unknown listener, a port given twice and a network wider than /8 are refused. K-C6. --- crates/common/src/config/server/listener.rs | 49 +++++++ crates/common/src/manager/listener_ports.rs | 142 ++++++++++++++++++++ 2 files changed, 191 insertions(+) diff --git a/crates/common/src/config/server/listener.rs b/crates/common/src/config/server/listener.rs index 0aa0ef07..41febdff 100644 --- a/crates/common/src/config/server/listener.rs +++ b/crates/common/src/config/server/listener.rs @@ -48,7 +48,24 @@ impl Listeners { // Parse servers if !bp.registry.is_recovery_mode() { let system = bp.setting_infallible::().await; + // inbuxa: K-C6: PROXY copies of mail listeners, from the environment + let proxy = match crate::manager::listener_ports::proxy_listeners( + types::branding::env_var("MAIL_PROXY_LISTENERS") + .ok() + .as_deref(), + types::branding::env_var("MAIL_PROXY_TRUSTED_NETWORKS") + .ok() + .as_deref(), + ) { + Ok(proxy) => proxy, + Err(err) => { + bp.build_error(ObjectType::NetworkListener.singleton(), err); + None + } + }; + let mut names = Vec::new(); for listener in bp.list_infallible::().await { + names.push(listener.object.name.clone()); if bp.role.as_ref().is_none_or(|r| match &r.listeners { ClusterListenerGroup::EnableAll => true, ClusterListenerGroup::DisableAll => false, @@ -59,7 +76,39 @@ impl Listeners { !group.listener_ids.iter().any(|id| *id == listener.id.id()) } }) { + let copy = proxy.as_ref().and_then(|proxy| { + let (name, port) = proxy + .ports + .iter() + .find(|(name, _)| *name == listener.object.name)?; + let mut object = listener.object.clone(); + object.name = format!("{name}-proxy"); + object.bind = + Map::new(vec![SocketAddr::from_str(&format!("[::]:{port}")).unwrap()]); + object.override_proxy_trusted_networks = Map::new(proxy.trusted.clone()); + Some(RegistryObject { + id: listener.id, + object, + revision: listener.revision, + }) + }); servers.parse_server(bp, listener, &system); + if let Some(copy) = copy { + servers.parse_server(bp, copy, &system); + } + } + } + if let Some(proxy) = &proxy { + for (name, _) in &proxy.ports { + if !names.iter().any(|n| n == name) { + bp.build_warning( + ObjectType::NetworkListener.singleton(), + format!( + "INBUXA_MAIL_PROXY_LISTENERS names '{name}', but this server \ + has no listener of that name to copy" + ), + ); + } } } } else { diff --git a/crates/common/src/manager/listener_ports.rs b/crates/common/src/manager/listener_ports.rs index 7e4b6e77..ebe04a17 100644 --- a/crates/common/src/manager/listener_ports.rs +++ b/crates/common/src/manager/listener_ports.rs @@ -95,10 +95,152 @@ pub fn default_listeners(spec: Option<&str>) -> Result, + pub trusted: Vec, +} + +/// `None` when neither variable is set. +pub fn proxy_listeners( + spec: Option<&str>, + networks: Option<&str>, +) -> Result, String> { + let spec = spec.map(str::trim).filter(|s| !s.is_empty()); + let networks = networks.map(str::trim).filter(|s| !s.is_empty()); + let (spec, networks) = match (spec, networks) { + (None, None) => return Ok(None), + (Some(_), None) => { + return Err(format!( + "{PROXY_ENV_VAR} is set without {PROXY_NETWORKS_ENV_VAR}: name the load \ + balancer's addresses, the only ones whose PROXY headers are believed" + )); + } + (None, Some(_)) => { + return Err(format!( + "{PROXY_NETWORKS_ENV_VAR} is set without {PROXY_ENV_VAR}, which names the \ + listeners that take PROXY headers" + )); + } + (Some(spec), Some(networks)) => (spec, networks), + }; + + let mut ports: Vec<(&'static str, u16)> = Vec::new(); + for item in spec.split(',').map(str::trim).filter(|i| !i.is_empty()) { + let Some((name, port)) = item.split_once('=') else { + return Err(format!( + "{PROXY_ENV_VAR}: '{item}' is not name=port (for example smtp=10025)" + )); + }; + let (name, port) = (name.trim(), port.trim()); + let Some(name) = MAIL_LISTENERS.iter().copied().find(|n| *n == name) else { + return Err(format!( + "{PROXY_ENV_VAR}: '{name}' is not a mail listener; they are {}", + MAIL_LISTENERS.join(", ") + )); + }; + let port = match port.parse::() { + Ok(port) if port > 0 => port, + _ => { + return Err(format!( + "{PROXY_ENV_VAR}: '{port}' is not a port for '{name}' (1 to 65535)" + )); + } + }; + if ports.iter().any(|(n, _)| *n == name) { + return Err(format!("{PROXY_ENV_VAR}: '{name}' is given twice")); + } + if let Some((other, _)) = ports.iter().find(|(_, p)| *p == port) { + return Err(format!( + "{PROXY_ENV_VAR}: '{other}' and '{name}' would both listen on port {port}" + )); + } + ports.push((name, port)); + } + + let mut trusted = Vec::new(); + for item in networks + .split(|c: char| c == ',' || c.is_whitespace()) + .filter(|i| !i.is_empty()) + { + trusted.push(item.parse().map_err(|_| { + format!( + "{PROXY_NETWORKS_ENV_VAR}: '{item}' is not an address or a network of /8 or \ + narrower" + ) + })?); + } + if ports.is_empty() || trusted.is_empty() { + return Err(format!( + "{PROXY_ENV_VAR} and {PROXY_NETWORKS_ENV_VAR} name nothing" + )); + } + Ok(Some(ProxyListeners { ports, trusted })) +} + #[cfg(test)] mod tests { use super::*; + #[test] + fn proxy_listeners_read() { + assert_eq!(proxy_listeners(None, None), Ok(None)); + assert_eq!(proxy_listeners(Some(" "), Some("")), Ok(None)); + let found = proxy_listeners( + Some("smtp=10025, imaps=10993"), + Some("10.0.0.10 192.168.0.0/16,fd00::/8"), + ) + .unwrap() + .unwrap(); + assert_eq!(found.ports, vec![("smtp", 10025), ("imaps", 10993)]); + assert_eq!(found.trusted.len(), 3); + } + + #[test] + fn proxy_listeners_refused() { + for (spec, networks, said) in [ + ( + "smtp=10025", + "", + "without INBUXA_MAIL_PROXY_TRUSTED_NETWORKS", + ), + ("", "10.0.0.1", "without INBUXA_MAIL_PROXY_LISTENERS"), + ("http=10080", "10.0.0.1", "not a mail listener"), + ("smtp=0", "10.0.0.1", "not a port"), + ("smtp=1,smtp=2", "10.0.0.1", "given twice"), + ("smtp=1,imaps=1", "10.0.0.1", "would both listen"), + ("smtp=10025", "0.0.0.0/0", "narrower"), + ("smtp=10025", "::/0", "narrower"), + ("smtp=10025", "not-an-address", "narrower"), + ] { + let err = proxy_listeners(Some(spec), Some(networks)).unwrap_err(); + assert!(err.contains(said), "{spec} {networks}: {err}"); + } + } + fn ports(spec: &str) -> Vec<(&'static str, u16)> { default_listeners(Some(spec)) .unwrap() -- 2.54.0