1use std::collections::BTreeSet;
12use std::net::IpAddr;
13
14use thiserror::Error;
15
16pub 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#[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#[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#[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 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 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 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 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
228pub 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 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 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 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}