Skip to main content

kaniop_radius/reconcile/
config.rs

1//! Validated configuration for the upstream Kanidm RADIUS container.
2//!
3//! The upstream bootstrap converts radius_clients to FreeRADIUS clients.conf
4//! using *unquoted* values. Never pass untrusted Kubernetes Secret values
5//! through to that bootstrap without checking its syntax first.
6//!
7//! This module deliberately does not log or derive Debug for credential-bearing
8//! objects. The caller must put the resulting TOML in a Kubernetes Secret, not
9//! a ConfigMap, status field, event, or pod annotation.
10
11use std::collections::BTreeSet;
12use std::net::IpAddr;
13
14use thiserror::Error;
15
16/// Location where the upstream container expects configuration.
17pub const CONFIG_PATH: &str = "/data/radius.toml";
18pub const SERVER_CERT_PATH: &str = "/data/cert.pem";
19pub const SERVER_KEY_PATH: &str = "/data/key.pem";
20pub const RADIUS_CA_PATH: &str = "/data/ca.pem";
21pub const KANIDM_CA_PATH: &str = "/data/kanidm-ca.pem";
22
23/// No user-supplied content is included in validation errors: clients may hold
24/// secrets and should never be accidentally logged by a reconciler.
25#[derive(Error, Debug, PartialEq, Eq)]
26pub enum RadiusConfigError {
27    #[error("Kanidm URL must be a valid HTTPS URI with a host")]
28    InvalidKanidmUrl,
29    #[error("Kanidm API token is empty")]
30    EmptyToken,
31    #[error("at least one required Kanidm authorization group must be configured")]
32    MissingRequiredGroups,
33    #[error("authorization group SPNs must be nonempty and must not contain controls")]
34    InvalidGroup,
35    #[error("RADIUS NAS client list must not be empty")]
36    MissingClients,
37    #[error("NAS client names must contain only ASCII letters, numbers, '-' or '_'")]
38    InvalidClientName,
39    #[error("NAS client names and IP/CIDR ranges must not be duplicated")]
40    DuplicateClient,
41    #[error("NAS IP address or CIDR range is invalid")]
42    InvalidClientAddress,
43    #[error("NAS shared secret must be 16-255 safe ASCII characters")]
44    InvalidSharedSecret,
45    #[error("RADIUS VLAN must be in the 1..=4094 range")]
46    InvalidVlan,
47    #[error("RADIUS CA material must be mounted when radius_ca_path is configured")]
48    InvalidCaPath,
49}
50
51/// A NAS definition obtained from a Kubernetes Secret reference.
52///
53/// Its secret must never appear in a Custom Resource, status, event or log.
54#[derive(Clone, PartialEq, Eq)]
55pub struct RadiusClient {
56    pub name: String,
57    pub ipaddr: String,
58    pub secret: String,
59}
60
61#[derive(Clone, PartialEq, Eq)]
62pub struct RadiusGroup {
63    pub spn: String,
64    pub vlan: u16,
65}
66
67/// Validated runtime configuration; contains a bearer token and NAS secrets.
68///
69/// Upstream consumes this as TOML at startup and then execs FreeRADIUS. Mounted
70/// Secret updates require a Deployment rollout; they are not live-reloaded.
71#[derive(Clone, PartialEq, Eq)]
72pub struct RadiusConfig {
73    pub uri: String,
74    pub auth_token: String,
75    pub ca_path: Option<String>,
76    pub radius_required_groups: Vec<String>,
77    pub radius_default_vlan: u16,
78    pub radius_groups: Vec<RadiusGroup>,
79    pub radius_clients: Vec<RadiusClient>,
80    pub radius_ca_path: Option<String>,
81}
82
83impl RadiusConfig {
84    /// Validate against both Kanidm's TOML shape and the FreeRADIUS clients.conf
85    /// generated by upstream bootstrap.rs. This method checks the syntax of the
86    /// resolved *secret value*, not just the Secret reference in the Kubernetes CR.
87    pub fn validate(&self) -> Result<(), RadiusConfigError> {
88        let url = url::Url::parse(&self.uri).map_err(|_| RadiusConfigError::InvalidKanidmUrl)?;
89        if url.scheme() != "https"
90            || url.host_str().is_none()
91            || !url.username().is_empty()
92            || url.password().is_some()
93        {
94            return Err(RadiusConfigError::InvalidKanidmUrl);
95        }
96        if self.auth_token.is_empty() {
97            return Err(RadiusConfigError::EmptyToken);
98        }
99        if self.radius_required_groups.is_empty() {
100            return Err(RadiusConfigError::MissingRequiredGroups);
101        }
102
103        for group in &self.radius_required_groups {
104            if !valid_group(group) {
105                return Err(RadiusConfigError::InvalidGroup);
106            }
107        }
108        if !(1..=4094).contains(&self.radius_default_vlan) {
109            return Err(RadiusConfigError::InvalidVlan);
110        }
111        let mut vlan_groups = BTreeSet::new();
112        for group in &self.radius_groups {
113            if !valid_group(&group.spn) {
114                return Err(RadiusConfigError::InvalidGroup);
115            }
116            if !(1..=4094).contains(&group.vlan) {
117                return Err(RadiusConfigError::InvalidVlan);
118            }
119            if !vlan_groups.insert(group.spn.as_str()) {
120                return Err(RadiusConfigError::InvalidGroup);
121            }
122        }
123
124        if self.radius_clients.is_empty() {
125            return Err(RadiusConfigError::MissingClients);
126        }
127        let mut names = BTreeSet::new();
128        let mut addresses = BTreeSet::new();
129        for client in &self.radius_clients {
130            // Upstream writes "client <name> { ... }" without escaping <name>.
131            if client.name.is_empty()
132                || client.name.len() > 63
133                || !client
134                    .name
135                    .bytes()
136                    .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
137            {
138                return Err(RadiusConfigError::InvalidClientName);
139            }
140            if !names.insert(client.name.as_str()) {
141                return Err(RadiusConfigError::DuplicateClient);
142            }
143            let Some(network) = normalize_nas_address(&client.ipaddr) else {
144                return Err(RadiusConfigError::InvalidClientAddress);
145            };
146            if !addresses.insert(network) {
147                return Err(RadiusConfigError::DuplicateClient);
148            }
149
150            // Upstream writes "secret = <value>" as an unquoted FreeRADIUS
151            // directive. Forbid whitespace, comments, quotes, delimiters and
152            // control characters. Recommend base64url-generated random secrets.
153            if !(16..=255).contains(&client.secret.len())
154                || !client
155                    .secret
156                    .bytes()
157                    .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
158            {
159                return Err(RadiusConfigError::InvalidSharedSecret);
160            }
161        }
162        if self.ca_path.as_deref().is_some_and(|p| p != KANIDM_CA_PATH)
163            || self
164                .radius_ca_path
165                .as_deref()
166                .is_some_and(|p| p != RADIUS_CA_PATH)
167        {
168            return Err(RadiusConfigError::InvalidCaPath);
169        }
170        Ok(())
171    }
172
173    /// Render deterministic TOML using JSON string quoting, which is also valid
174    /// TOML basic-string syntax. RADIUS callers MUST store the result in a Secret.
175    pub fn render_toml(&self) -> Result<String, RadiusConfigError> {
176        self.validate()?;
177        let mut out = format!(
178            "uri = {}\nauth_token = {}\nverify_hostnames = true\nverify_certificate = true\n",
179            quote(&self.uri),
180            quote(&self.auth_token)
181        );
182        if let Some(ca) = &self.ca_path {
183            out.push_str(&format!("ca_path = {}\n", quote(ca)));
184        }
185        out.push_str(&format!(
186            "radius_cert_path = {}\nradius_key_path = {}\n",
187            quote(SERVER_CERT_PATH),
188            quote(SERVER_KEY_PATH)
189        ));
190        if let Some(ca) = &self.radius_ca_path {
191            out.push_str(&format!("radius_ca_path = {}\n", quote(ca)));
192        }
193        out.push_str(&format!(
194            "radius_default_vlan = {}\nradius_required_groups = [{}]\n",
195            self.radius_default_vlan,
196            self.radius_required_groups
197                .iter()
198                .map(|group| quote(group))
199                .collect::<Vec<_>>()
200                .join(", ")
201        ));
202        out.push_str("radius_groups = [\n");
203        for group in &self.radius_groups {
204            out.push_str(&format!(
205                "  {{ spn = {}, vlan = {} }},\n",
206                quote(&group.spn),
207                group.vlan
208            ));
209        }
210        out.push_str("]\nradius_clients = [\n");
211        for client in &self.radius_clients {
212            out.push_str(&format!(
213                "  {{ name = {}, ipaddr = {}, secret = {} }},\n",
214                quote(&client.name),
215                quote(&client.ipaddr),
216                quote(&client.secret),
217            ));
218        }
219        out.push_str("]\n");
220        Ok(out)
221    }
222}
223
224fn valid_group(group: &str) -> bool {
225    !group.trim().is_empty() && !group.chars().any(char::is_control)
226}
227
228/// Canonical network of a NAS address: a bare IP is a host route, and host
229/// bits of a CIDR are masked, so `10.0.0.1`, `10.0.0.1/32` and (for a /24)
230/// `10.0.0.7/24` and `10.0.0.0/24` compare equal. `None` for anything that is
231/// not an IP or an IP/prefix with a non-zero, in-range prefix length.
232pub fn normalize_nas_address(address: &str) -> Option<(IpAddr, u8)> {
233    let (ip, prefix) = match address.split_once('/') {
234        Some((ip, prefix)) => (ip.parse::<IpAddr>().ok()?, prefix.parse::<u8>().ok()?),
235        None => {
236            let ip = address.parse::<IpAddr>().ok()?;
237            (ip, if ip.is_ipv4() { 32 } else { 128 })
238        }
239    };
240    let max_prefix = if ip.is_ipv4() { 32 } else { 128 };
241    if prefix == 0 || prefix > max_prefix {
242        return None;
243    }
244    let network = match ip {
245        IpAddr::V4(v4) => {
246            let mask = u32::MAX << (32 - u32::from(prefix));
247            IpAddr::V4((u32::from(v4) & mask).into())
248        }
249        IpAddr::V6(v6) => {
250            let mask = u128::MAX << (128 - u32::from(prefix));
251            IpAddr::V6((u128::from(v6) & mask).into())
252        }
253    };
254    Some((network, prefix))
255}
256
257fn quote(s: &str) -> String {
258    // This is infallible for String (including any Unicode), unlike arbitrary
259    // serde_json::Value serialization. JSON and TOML basic-string escapes agree
260    // for the values emitted by serde_json here.
261    serde_json::to_string(s).expect("serializing a string cannot fail")
262}
263
264#[cfg(test)]
265mod tests {
266    use super::*;
267
268    fn valid_config() -> RadiusConfig {
269        RadiusConfig {
270            uri: "https://idm.example.com".into(),
271            auth_token: "header.payload.signature".into(),
272            ca_path: Some(KANIDM_CA_PATH.into()),
273            radius_required_groups: vec!["radius_access_allowed@idm.example.com".into()],
274            radius_default_vlan: 10,
275            radius_groups: vec![RadiusGroup {
276                spn: "radius_access_allowed@idm.example.com".into(),
277                vlan: 20,
278            }],
279            radius_clients: vec![RadiusClient {
280                name: "mikrotik".into(),
281                ipaddr: "192.0.2.10/32".into(),
282                secret: "b8_j3Z4yx-3qW1xOAm4c".into(),
283            }],
284            radius_ca_path: Some(RADIUS_CA_PATH.into()),
285        }
286    }
287
288    #[test]
289    fn renders_upstream_radius_toml() {
290        let output = valid_config().render_toml().unwrap();
291        assert!(output.contains("verify_certificate = true"));
292        assert!(output.contains("radius_cert_path = \"/data/cert.pem\""));
293        assert!(output.contains("radius_key_path = \"/data/key.pem\""));
294        assert!(output.contains("radius_ca_path = \"/data/ca.pem\""));
295        assert!(output.contains("ipaddr = \"192.0.2.10/32\""));
296        assert!(output.contains("radius_default_vlan = 10"));
297        assert!(
298            output.contains("radius_required_groups = [\"radius_access_allowed@idm.example.com\"]")
299        );
300        assert!(output.contains("secret = \"b8_j3Z4yx-3qW1xOAm4c\""));
301    }
302
303    #[test]
304    fn rejects_freeradius_config_injection_in_secret_value() {
305        for bad_secret in [
306            "password\\n}\nclient attacker {",
307            "password!another-command",
308            "password with spaces",
309            "password#comment",
310            "password;next",
311            "password\"broken",
312            "password{block",
313            "short",
314        ] {
315            let mut config = valid_config();
316            config.radius_clients[0].secret = bad_secret.into();
317            assert_eq!(
318                config.validate(),
319                Err(RadiusConfigError::InvalidSharedSecret)
320            );
321        }
322    }
323
324    #[test]
325    fn rejects_freeradius_config_injection_in_client_name() {
326        for bad_name in ["mikrotik\nsecret = attacker", "bad{client", "x y", ""] {
327            let mut config = valid_config();
328            config.radius_clients[0].name = bad_name.into();
329            assert_eq!(config.validate(), Err(RadiusConfigError::InvalidClientName));
330        }
331    }
332
333    #[test]
334    fn rejects_invalid_addresses() {
335        for address in [
336            "0.0.0.0/0",
337            "192.0.2.10/33",
338            "::1/129",
339            "192.0.2.10\nsecret=x",
340            "foo",
341        ] {
342            let mut config = valid_config();
343            config.radius_clients[0].ipaddr = address.into();
344            assert_eq!(
345                config.validate(),
346                Err(RadiusConfigError::InvalidClientAddress)
347            );
348        }
349        for address in ["192.0.2.10", "192.0.2.0/24", "2001:db8::1", "2001:db8::/64"] {
350            let mut config = valid_config();
351            config.radius_clients[0].ipaddr = address.into();
352            assert!(config.validate().is_ok(), "address: {address}");
353        }
354    }
355
356    #[test]
357    fn requires_explicit_authorization_groups_and_safe_vlan() {
358        let mut config = valid_config();
359        config.radius_required_groups.clear();
360        assert_eq!(
361            config.validate(),
362            Err(RadiusConfigError::MissingRequiredGroups)
363        );
364        config
365            .radius_required_groups
366            .push("radius_access_allowed@idm.example.com".into());
367        config.radius_default_vlan = 0;
368        assert_eq!(config.validate(), Err(RadiusConfigError::InvalidVlan));
369        config.radius_default_vlan = 10;
370        // VLAN mapping groups are independent of the groups granting access.
371        config.radius_groups[0].spn = "staff@idm.example.com".into();
372        assert!(config.validate().is_ok());
373        config.radius_groups.push(config.radius_groups[0].clone());
374        assert_eq!(config.validate(), Err(RadiusConfigError::InvalidGroup));
375    }
376
377    #[test]
378    fn rejects_duplicates_without_owning_other_clients() {
379        let mut config = valid_config();
380        config.radius_clients.push(config.radius_clients[0].clone());
381        assert_eq!(config.validate(), Err(RadiusConfigError::DuplicateClient));
382        config.radius_clients[1].name = "other".into();
383        assert_eq!(config.validate(), Err(RadiusConfigError::DuplicateClient));
384    }
385
386    #[test]
387    fn secrets_not_derived_as_debug_values() {
388        // Validation errors are safe to report through status and events; they
389        // cannot accidentally include the bearer token or NAS shared secret.
390        let mut config = valid_config();
391        config.radius_clients[0].secret = "invalid secret".into();
392        let message = config.validate().unwrap_err().to_string();
393        assert!(!message.contains("invalid secret"));
394        assert!(!message.contains(&config.auth_token));
395    }
396
397    #[test]
398    fn rejects_insecure_kanidm_uri() {
399        let mut config = valid_config();
400        config.uri = "http://idm.example.com".into();
401        assert_eq!(config.validate(), Err(RadiusConfigError::InvalidKanidmUrl));
402    }
403
404    #[test]
405    fn bare_address_and_host_cidr_are_duplicate_clients() {
406        for (a, b) in [
407            ("10.0.0.1", "10.0.0.1/32"),
408            ("10.0.0.1/32", "10.0.0.1"),
409            ("2001:db8::1", "2001:db8::1/128"),
410            ("10.0.0.0/24", "10.0.0.7/24"),
411        ] {
412            let mut config = valid_config();
413            config.radius_clients[0].ipaddr = a.into();
414            let mut second = config.radius_clients[0].clone();
415            second.name = "other".into();
416            second.ipaddr = b.into();
417            config.radius_clients.push(second);
418            assert_eq!(
419                config.validate(),
420                Err(RadiusConfigError::DuplicateClient),
421                "{a} and {b}"
422            );
423        }
424    }
425
426    #[test]
427    fn distinct_prefixes_of_one_address_are_not_duplicates() {
428        let mut config = valid_config();
429        config.radius_clients[0].ipaddr = "10.0.0.1/32".into();
430        let mut second = config.radius_clients[0].clone();
431        second.name = "other".into();
432        second.ipaddr = "10.0.0.0/24".into();
433        config.radius_clients.push(second);
434        assert_eq!(config.validate(), Ok(()));
435    }
436}