use std::collections::BTreeSet;
use std::net::IpAddr;
use thiserror::Error;
pub const CONFIG_PATH: &str = "/data/radius.toml";
pub const SERVER_CERT_PATH: &str = "/data/cert.pem";
pub const SERVER_KEY_PATH: &str = "/data/key.pem";
pub const RADIUS_CA_PATH: &str = "/data/ca.pem";
pub const KANIDM_CA_PATH: &str = "/data/kanidm-ca.pem";
#[derive(Error, Debug, PartialEq, Eq)]
pub enum RadiusConfigError {
#[error("Kanidm URL must be a valid HTTPS URI with a host")]
InvalidKanidmUrl,
#[error("Kanidm API token is empty")]
EmptyToken,
#[error("at least one required Kanidm authorization group must be configured")]
MissingRequiredGroups,
#[error("authorization group SPNs must be nonempty and must not contain controls")]
InvalidGroup,
#[error("RADIUS NAS client list must not be empty")]
MissingClients,
#[error("NAS client names must contain only ASCII letters, numbers, '-' or '_'")]
InvalidClientName,
#[error("NAS client names and IP/CIDR ranges must not be duplicated")]
DuplicateClient,
#[error("NAS IP address or CIDR range is invalid")]
InvalidClientAddress,
#[error("NAS shared secret must be 16-255 safe ASCII characters")]
InvalidSharedSecret,
#[error("RADIUS VLAN must be in the 1..=4094 range")]
InvalidVlan,
#[error("RADIUS CA material must be mounted when radius_ca_path is configured")]
InvalidCaPath,
}
#[derive(Clone, PartialEq, Eq)]
pub struct RadiusClient {
pub name: String,
pub ipaddr: String,
pub secret: String,
}
#[derive(Clone, PartialEq, Eq)]
pub struct RadiusGroup {
pub spn: String,
pub vlan: u16,
}
#[derive(Clone, PartialEq, Eq)]
pub struct RadiusConfig {
pub uri: String,
pub auth_token: String,
pub ca_path: Option<String>,
pub radius_required_groups: Vec<String>,
pub radius_default_vlan: u16,
pub radius_groups: Vec<RadiusGroup>,
pub radius_clients: Vec<RadiusClient>,
pub radius_ca_path: Option<String>,
}
impl RadiusConfig {
pub fn validate(&self) -> Result<(), RadiusConfigError> {
let url = url::Url::parse(&self.uri).map_err(|_| RadiusConfigError::InvalidKanidmUrl)?;
if url.scheme() != "https"
|| url.host_str().is_none()
|| !url.username().is_empty()
|| url.password().is_some()
{
return Err(RadiusConfigError::InvalidKanidmUrl);
}
if self.auth_token.is_empty() {
return Err(RadiusConfigError::EmptyToken);
}
if self.radius_required_groups.is_empty() {
return Err(RadiusConfigError::MissingRequiredGroups);
}
for group in &self.radius_required_groups {
if !valid_group(group) {
return Err(RadiusConfigError::InvalidGroup);
}
}
if !(1..=4094).contains(&self.radius_default_vlan) {
return Err(RadiusConfigError::InvalidVlan);
}
let mut vlan_groups = BTreeSet::new();
for group in &self.radius_groups {
if !valid_group(&group.spn) {
return Err(RadiusConfigError::InvalidGroup);
}
if !(1..=4094).contains(&group.vlan) {
return Err(RadiusConfigError::InvalidVlan);
}
if !vlan_groups.insert(group.spn.as_str()) {
return Err(RadiusConfigError::InvalidGroup);
}
}
if self.radius_clients.is_empty() {
return Err(RadiusConfigError::MissingClients);
}
let mut names = BTreeSet::new();
let mut addresses = BTreeSet::new();
for client in &self.radius_clients {
if client.name.is_empty()
|| client.name.len() > 63
|| !client
.name
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
{
return Err(RadiusConfigError::InvalidClientName);
}
if !names.insert(client.name.as_str()) {
return Err(RadiusConfigError::DuplicateClient);
}
let Some(network) = normalize_nas_address(&client.ipaddr) else {
return Err(RadiusConfigError::InvalidClientAddress);
};
if !addresses.insert(network) {
return Err(RadiusConfigError::DuplicateClient);
}
if !(16..=255).contains(&client.secret.len())
|| !client
.secret
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
{
return Err(RadiusConfigError::InvalidSharedSecret);
}
}
if self.ca_path.as_deref().is_some_and(|p| p != KANIDM_CA_PATH)
|| self
.radius_ca_path
.as_deref()
.is_some_and(|p| p != RADIUS_CA_PATH)
{
return Err(RadiusConfigError::InvalidCaPath);
}
Ok(())
}
pub fn render_toml(&self) -> Result<String, RadiusConfigError> {
self.validate()?;
let mut out = format!(
"uri = {}\nauth_token = {}\nverify_hostnames = true\nverify_certificate = true\n",
quote(&self.uri),
quote(&self.auth_token)
);
if let Some(ca) = &self.ca_path {
out.push_str(&format!("ca_path = {}\n", quote(ca)));
}
out.push_str(&format!(
"radius_cert_path = {}\nradius_key_path = {}\n",
quote(SERVER_CERT_PATH),
quote(SERVER_KEY_PATH)
));
if let Some(ca) = &self.radius_ca_path {
out.push_str(&format!("radius_ca_path = {}\n", quote(ca)));
}
out.push_str(&format!(
"radius_default_vlan = {}\nradius_required_groups = [{}]\n",
self.radius_default_vlan,
self.radius_required_groups
.iter()
.map(|group| quote(group))
.collect::<Vec<_>>()
.join(", ")
));
out.push_str("radius_groups = [\n");
for group in &self.radius_groups {
out.push_str(&format!(
" {{ spn = {}, vlan = {} }},\n",
quote(&group.spn),
group.vlan
));
}
out.push_str("]\nradius_clients = [\n");
for client in &self.radius_clients {
out.push_str(&format!(
" {{ name = {}, ipaddr = {}, secret = {} }},\n",
quote(&client.name),
quote(&client.ipaddr),
quote(&client.secret),
));
}
out.push_str("]\n");
Ok(out)
}
}
fn valid_group(group: &str) -> bool {
!group.trim().is_empty() && !group.chars().any(char::is_control)
}
pub fn normalize_nas_address(address: &str) -> Option<(IpAddr, u8)> {
let (ip, prefix) = match address.split_once('/') {
Some((ip, prefix)) => (ip.parse::<IpAddr>().ok()?, prefix.parse::<u8>().ok()?),
None => {
let ip = address.parse::<IpAddr>().ok()?;
(ip, if ip.is_ipv4() { 32 } else { 128 })
}
};
let max_prefix = if ip.is_ipv4() { 32 } else { 128 };
if prefix == 0 || prefix > max_prefix {
return None;
}
let network = match ip {
IpAddr::V4(v4) => {
let mask = u32::MAX << (32 - u32::from(prefix));
IpAddr::V4((u32::from(v4) & mask).into())
}
IpAddr::V6(v6) => {
let mask = u128::MAX << (128 - u32::from(prefix));
IpAddr::V6((u128::from(v6) & mask).into())
}
};
Some((network, prefix))
}
fn quote(s: &str) -> String {
serde_json::to_string(s).expect("serializing a string cannot fail")
}
#[cfg(test)]
mod tests {
use super::*;
fn valid_config() -> RadiusConfig {
RadiusConfig {
uri: "https://idm.example.com".into(),
auth_token: "header.payload.signature".into(),
ca_path: Some(KANIDM_CA_PATH.into()),
radius_required_groups: vec!["radius_access_allowed@idm.example.com".into()],
radius_default_vlan: 10,
radius_groups: vec![RadiusGroup {
spn: "radius_access_allowed@idm.example.com".into(),
vlan: 20,
}],
radius_clients: vec![RadiusClient {
name: "mikrotik".into(),
ipaddr: "192.0.2.10/32".into(),
secret: "b8_j3Z4yx-3qW1xOAm4c".into(),
}],
radius_ca_path: Some(RADIUS_CA_PATH.into()),
}
}
#[test]
fn renders_upstream_radius_toml() {
let output = valid_config().render_toml().unwrap();
assert!(output.contains("verify_certificate = true"));
assert!(output.contains("radius_cert_path = \"/data/cert.pem\""));
assert!(output.contains("radius_key_path = \"/data/key.pem\""));
assert!(output.contains("radius_ca_path = \"/data/ca.pem\""));
assert!(output.contains("ipaddr = \"192.0.2.10/32\""));
assert!(output.contains("radius_default_vlan = 10"));
assert!(
output.contains("radius_required_groups = [\"radius_access_allowed@idm.example.com\"]")
);
assert!(output.contains("secret = \"b8_j3Z4yx-3qW1xOAm4c\""));
}
#[test]
fn rejects_freeradius_config_injection_in_secret_value() {
for bad_secret in [
"password\\n}\nclient attacker {",
"password!another-command",
"password with spaces",
"password#comment",
"password;next",
"password\"broken",
"password{block",
"short",
] {
let mut config = valid_config();
config.radius_clients[0].secret = bad_secret.into();
assert_eq!(
config.validate(),
Err(RadiusConfigError::InvalidSharedSecret)
);
}
}
#[test]
fn rejects_freeradius_config_injection_in_client_name() {
for bad_name in ["mikrotik\nsecret = attacker", "bad{client", "x y", ""] {
let mut config = valid_config();
config.radius_clients[0].name = bad_name.into();
assert_eq!(config.validate(), Err(RadiusConfigError::InvalidClientName));
}
}
#[test]
fn rejects_invalid_addresses() {
for address in [
"0.0.0.0/0",
"192.0.2.10/33",
"::1/129",
"192.0.2.10\nsecret=x",
"foo",
] {
let mut config = valid_config();
config.radius_clients[0].ipaddr = address.into();
assert_eq!(
config.validate(),
Err(RadiusConfigError::InvalidClientAddress)
);
}
for address in ["192.0.2.10", "192.0.2.0/24", "2001:db8::1", "2001:db8::/64"] {
let mut config = valid_config();
config.radius_clients[0].ipaddr = address.into();
assert!(config.validate().is_ok(), "address: {address}");
}
}
#[test]
fn requires_explicit_authorization_groups_and_safe_vlan() {
let mut config = valid_config();
config.radius_required_groups.clear();
assert_eq!(
config.validate(),
Err(RadiusConfigError::MissingRequiredGroups)
);
config
.radius_required_groups
.push("radius_access_allowed@idm.example.com".into());
config.radius_default_vlan = 0;
assert_eq!(config.validate(), Err(RadiusConfigError::InvalidVlan));
config.radius_default_vlan = 10;
config.radius_groups[0].spn = "staff@idm.example.com".into();
assert!(config.validate().is_ok());
config.radius_groups.push(config.radius_groups[0].clone());
assert_eq!(config.validate(), Err(RadiusConfigError::InvalidGroup));
}
#[test]
fn rejects_duplicates_without_owning_other_clients() {
let mut config = valid_config();
config.radius_clients.push(config.radius_clients[0].clone());
assert_eq!(config.validate(), Err(RadiusConfigError::DuplicateClient));
config.radius_clients[1].name = "other".into();
assert_eq!(config.validate(), Err(RadiusConfigError::DuplicateClient));
}
#[test]
fn secrets_not_derived_as_debug_values() {
let mut config = valid_config();
config.radius_clients[0].secret = "invalid secret".into();
let message = config.validate().unwrap_err().to_string();
assert!(!message.contains("invalid secret"));
assert!(!message.contains(&config.auth_token));
}
#[test]
fn rejects_insecure_kanidm_uri() {
let mut config = valid_config();
config.uri = "http://idm.example.com".into();
assert_eq!(config.validate(), Err(RadiusConfigError::InvalidKanidmUrl));
}
#[test]
fn bare_address_and_host_cidr_are_duplicate_clients() {
for (a, b) in [
("10.0.0.1", "10.0.0.1/32"),
("10.0.0.1/32", "10.0.0.1"),
("2001:db8::1", "2001:db8::1/128"),
("10.0.0.0/24", "10.0.0.7/24"),
] {
let mut config = valid_config();
config.radius_clients[0].ipaddr = a.into();
let mut second = config.radius_clients[0].clone();
second.name = "other".into();
second.ipaddr = b.into();
config.radius_clients.push(second);
assert_eq!(
config.validate(),
Err(RadiusConfigError::DuplicateClient),
"{a} and {b}"
);
}
}
#[test]
fn distinct_prefixes_of_one_address_are_not_duplicates() {
let mut config = valid_config();
config.radius_clients[0].ipaddr = "10.0.0.1/32".into();
let mut second = config.radius_clients[0].clone();
second.name = "other".into();
second.ipaddr = "10.0.0.0/24".into();
config.radius_clients.push(second);
assert_eq!(config.validate(), Ok(()));
}
}