use std::fmt;
use tracing::field;
use crate::java_regex::{JavaPattern, JavaReplacementError};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Case {
Preserve,
Lower,
Upper,
}
#[derive(Debug, Clone)]
pub enum Rule {
Default,
Translate(Box<Translate>),
}
#[derive(Debug, Clone)]
pub struct Translate {
pub num_components: usize,
pub format: String,
pub match_re: Option<JavaPattern>,
pub subst: Option<Subst>,
pub case: Case,
}
#[derive(Debug, Clone)]
pub struct Subst {
from: JavaPattern,
to: String,
global: bool,
}
#[derive(Debug, thiserror::Error)]
pub enum NameError {
#[error("Invalid rule: {0}")]
Parse(String),
#[error("Invalid rule: {spec}: {source}")]
Pattern {
spec: String,
source: regex::Error,
},
#[error("Malformed Kerberos name: {0}")]
MalformedName(String),
#[error("{0}")]
BadFormat(String),
#[error("{0}")]
Replacement(#[from] JavaReplacementError),
#[error("Non-simple name {name} after auth_to_local rule {rule}")]
NonSimple {
name: String,
rule: String,
},
#[error("No rules apply to {0}")]
NoMatch(String),
}
impl Rule {
pub fn parse(spec: &str) -> Result<Self, NameError> {
let spec = spec.trim();
if spec == "DEFAULT" {
return Ok(Self::Default);
}
let invalid = || NameError::Parse(spec.to_owned());
let pattern = |source: &str| {
JavaPattern::new(source).map_err(|source| NameError::Pattern {
spec: spec.to_owned(),
source,
})
};
let rest = spec.strip_prefix("RULE:[").ok_or_else(invalid)?;
let digits = rest.len() - rest.trim_start_matches(|c: char| c.is_ascii_digit()).len();
let (count, rest) = rest.split_at_checked(digits).ok_or_else(invalid)?;
let num_components: usize = count.parse().map_err(|_| invalid())?;
let rest = rest.strip_prefix(':').ok_or_else(invalid)?;
let (format, mut rest) = rest.split_once(']').ok_or_else(invalid)?;
let mut match_re = None;
if let Some(after) = rest.strip_prefix('(')
&& let Some((source, after)) = after.split_once(')')
{
match_re = Some(pattern(source)?);
rest = after;
}
let mut subst = None;
if let Some(after) = rest.strip_prefix("s/")
&& let Some((from, after)) = after.split_once('/')
&& let Some((to, after)) = after.split_once('/')
{
let (global, after) = after
.strip_prefix('g')
.map_or((false, after), |after| (true, after));
subst = Some(Subst {
from: pattern(from)?,
to: to.to_owned(),
global,
});
rest = after;
}
let rest = rest.strip_prefix('/').unwrap_or(rest);
let case = match rest {
"" => Case::Preserve,
"L" => Case::Lower,
"U" => Case::Upper,
_ => return Err(invalid()),
};
Ok(Self::Translate(Box::new(Translate {
num_components,
format: format.to_owned(),
match_re,
subst,
case,
})))
}
fn apply(&self, params: &[&str], default_realm: &str) -> Result<Option<String>, NameError> {
let (result, case) = match self {
Self::Default => (
match params {
[realm, first, ..] => (*realm == default_realm).then(|| (*first).to_owned()),
_ => None,
},
Case::Preserve,
),
Self::Translate(translate) => {
let Translate {
num_components,
format,
match_re,
subst,
case,
} = &**translate;
if params.len() - 1 != *num_components {
return Ok(None);
}
let base = replace_parameters(format, params)?;
let result = if match_re.as_ref().is_none_or(|re| re.matches(&base)) {
Some(match subst {
None => base,
Some(Subst {
from,
to,
global: true,
}) => from.replace_all(&base, to)?,
Some(Subst {
from,
to,
global: false,
}) => from.replace_first(&base, to)?,
})
} else {
None
};
(result, *case)
}
};
let Some(result) = result else {
return Ok(None);
};
if result.contains(['/', '@']) {
return Err(NameError::NonSimple {
name: result,
rule: self.to_string(),
});
}
Ok(Some(match case {
Case::Preserve => result,
Case::Lower => result.to_lowercase(),
Case::Upper => result.to_uppercase(),
}))
}
}
impl fmt::Display for Rule {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Default => f.write_str("DEFAULT"),
Self::Translate(translate) => {
let Translate {
num_components,
format,
match_re,
subst,
case,
} = &**translate;
write!(f, "RULE:[{num_components}:{format}]")?;
if let Some(re) = match_re {
write!(f, "({})", re.as_str())?;
}
if let Some(Subst { from, to, global }) = subst {
write!(f, "s/{}/{to}/", from.as_str())?;
if *global {
f.write_str("g")?;
}
}
match case {
Case::Preserve => Ok(()),
Case::Lower => f.write_str("/L"),
Case::Upper => f.write_str("/U"),
}
}
}
}
}
fn replace_parameters(format: &str, params: &[&str]) -> Result<String, NameError> {
let mut out = String::new();
let mut rest = format;
while let Some((before, after)) = rest.split_once('$') {
out.push_str(before);
let digits = after.len() - after.trim_start_matches(|c: char| c.is_ascii_digit()).len();
let (number, tail) = after.split_at_checked(digits).ok_or_else(|| {
NameError::BadFormat(format!("bad format in username mapping in {after}"))
})?;
let index: usize = number.parse().map_err(|_| {
NameError::BadFormat(format!("bad format in username mapping in {number}"))
})?;
let param = params.get(index).ok_or_else(|| {
NameError::BadFormat(format!(
"index {index} from {format} is outside of the valid range 0 to {}",
params.len() - 1
))
})?;
out.push_str(param);
rest = tail;
}
out.push_str(rest);
Ok(out)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct KerberosName {
pub service_name: String,
pub host_name: Option<String>,
pub realm: Option<String>,
}
impl KerberosName {
pub fn parse(principal: &str) -> Result<Self, NameError> {
let malformed = || NameError::MalformedName(principal.to_owned());
let Some((head, realm)) = principal.split_once('@') else {
return Ok(Self {
service_name: principal.to_owned(),
host_name: None,
realm: None,
});
};
if realm.contains(['/', '@']) {
return Err(malformed());
}
let (service_name, host_name) = match head.split_once('/') {
Some((_, host)) if host.contains('/') => return Err(malformed()),
Some((service, host)) => (service, Some(host.to_owned())),
None => (head, None),
};
Ok(Self {
service_name: service_name.to_owned(),
host_name,
realm: Some(realm.to_owned()),
})
}
}
impl fmt::Display for KerberosName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.service_name)?;
if let Some(host) = &self.host_name {
write!(f, "/{host}")?;
}
if let Some(realm) = &self.realm {
write!(f, "@{realm}")?;
}
Ok(())
}
}
#[tracing::instrument(
level = "debug",
skip_all,
fields(mechanism = "GSSAPI", mapped = field::Empty),
err
)]
pub fn short_name(
rules: &[Rule],
name: &KerberosName,
default_realm: &str,
) -> Result<String, NameError> {
let Some(realm) = name.realm.as_deref() else {
return Ok(name.service_name.clone());
};
let mut params = vec![realm, name.service_name.as_str()];
params.extend(name.host_name.as_deref());
for rule in rules {
if let Some(result) = rule.apply(¶ms, default_realm)? {
tracing::Span::current().record("mapped", result.as_str());
return Ok(result);
}
}
let rules = rules.iter().map(ToString::to_string).collect::<Vec<_>>();
Err(NameError::NoMatch(format!(
"{name}, rules [{}]",
rules.join(", ")
)))
}
#[cfg(test)]
mod tests {
use assert2::check;
use super::*;
fn rules(specs: &[&str]) -> Vec<Rule> {
specs
.iter()
.map(|s| Rule::parse(s).unwrap_or_else(|e| panic!("{s}: {e}")))
.collect()
}
type MappingCase<'a> = (&'a [&'a str], &'a str, &'a str, Result<&'a str, &'a str>);
fn map(specs: &[&str], default_realm: &str, principal: &str) -> Result<String, String> {
let name = KerberosName::parse(principal).map_err(|e| e.to_string())?;
short_name(&rules(specs), &name, default_realm).map_err(|e| e.to_string())
}
#[test]
fn short_names_follow_kafka() {
const TEST_PARSE: &[&str] = &[
r"RULE:[1:$1](App\..*)s/App\.(.*)/$1/g",
r"RULE:[2:$1](App\..*)s/App\.(.*)/$1/g",
"DEFAULT",
];
const TO_LOWER: &[&str] = &[
"RULE:[1:$1]/L",
"RULE:[2:$1](Test.*)s/ABC///L",
"RULE:[2:$1](ABC.*)s/ABC/XYZ/g/L",
r"RULE:[2:$1](App\..*)s/App\.(.*)/$1/g/L",
"RULE:[2:$1]/L",
"DEFAULT",
];
const TO_UPPER: &[&str] = &[
"RULE:[1:$1]/U",
"RULE:[2:$1](Test.*)s/ABC///U",
"RULE:[2:$1](ABC.*)s/ABC/XYZ/g/U",
r"RULE:[2:$1](App\..*)s/App\.(.*)/$1/g/U",
"RULE:[2:$1]/U",
"DEFAULT",
];
const AUDIT: &[&str] = &[
"RULE:[1:$1](ali)s/x/y/",
"RULE:[2:$1](.*)s/(.*)/$1_$1/U",
"RULE:[1:$1@$0](.*@OTHER)s/@.*//",
"RULE:[1:$1](bad.*)s/a/@/",
"DEFAULT",
];
let cases: &[MappingCase<'_>] = &[
(
TEST_PARSE,
"REALM.COM",
"App.service-name/example.com@REALM.COM",
Ok("service-name"),
),
(
TEST_PARSE,
"REALM.COM",
"App.service-name@REALM.COM",
Ok("service-name"),
),
(TEST_PARSE, "REALM.COM", "user/host@REALM.COM", Ok("user")),
(
&["DEFAULT"],
"REALM",
"kafka/host.example.com@REALM",
Ok("kafka"),
),
(TO_LOWER, "REALM.COM", "User@REALM.COM", Ok("user")),
(TO_LOWER, "REALM.COM", "TestABC/host@FOO.COM", Ok("test")),
(
TO_LOWER,
"REALM.COM",
"ABC_User_ABC/host@FOO.COM",
Ok("xyz_user_xyz"),
),
(
TO_LOWER,
"REALM.COM",
"App.SERVICE-name/example.com@REALM.COM",
Ok("service-name"),
),
(TO_LOWER, "REALM.COM", "User/root@REALM.COM", Ok("user")),
(TO_UPPER, "REALM.COM", "User@REALM.COM", Ok("USER")),
(TO_UPPER, "REALM.COM", "TestABC/host@FOO.COM", Ok("TEST")),
(
TO_UPPER,
"REALM.COM",
"ABC_User_ABC/host@FOO.COM",
Ok("XYZ_USER_XYZ"),
),
(
TO_UPPER,
"REALM.COM",
"App.SERVICE-name/example.com@REALM.COM",
Ok("SERVICE-NAME"),
),
(TO_UPPER, "REALM.COM", "User/root@REALM.COM", Ok("USER")),
(AUDIT, "REALM.COM", "alice@REALM.COM", Ok("alice")),
(AUDIT, "REALM.COM", "ali@REALM.COM", Ok("ali")),
(AUDIT, "REALM.COM", "svc/host@REALM.COM", Ok("SVC_SVC")),
(AUDIT, "REALM.COM", "bob@OTHER", Ok("bob")),
(
AUDIT,
"REALM.COM",
"bad@REALM.COM",
Err("Non-simple name b@d after auth_to_local rule RULE:[1:$1](bad.*)s/a/@/"),
),
(
AUDIT,
"REALM.COM",
"u@ELSE",
Err("No rules apply to u@ELSE, rules [RULE:[1:$1](ali)s/x/y/, \
RULE:[2:$1](.*)s/(.*)/$1_$1//U, RULE:[1:$1@$0](.*@OTHER)s/@.*//, \
RULE:[1:$1](bad.*)s/a/@/, DEFAULT]"),
),
(
AUDIT,
"REALM.COM",
"x/y/z@REALM.COM",
Err("Malformed Kerberos name: x/y/z@REALM.COM"),
),
(AUDIT, "REALM.COM", "simple", Ok("simple")),
(
&["DEFAULT"],
"",
"x@REALM",
Err("No rules apply to x@REALM, rules [DEFAULT]"),
),
(&["DEFAULT"], "", "x@", Ok("x")),
(
&["RULE:[1:$2]", "DEFAULT"],
"R",
"x@R",
Err("index 2 from $2 is outside of the valid range 0 to 1"),
),
(
&["RULE:[1:$]"],
"R",
"x@R",
Err("bad format in username mapping in "),
),
(&["RULE:[1:$1@$0]s/@R$//"], "R", "x@R", Ok("x")),
];
for (specs, default_realm, principal, expected) in cases {
check!(
map(specs, default_realm, principal).as_deref()
== expected.map_err(str::to_owned).as_deref(),
"{principal} under {specs:?}"
);
}
}
#[test]
fn invalid_rules_are_rejected() {
for spec in [
"default",
"DEFAUL",
"DEFAULT/L",
"DEFAULT/g",
"rule:[1:$1]",
"rule:[1:$1]/L/U",
"rule:[1:$1]/U/L",
"rule:[1:$1]/LU",
"RULE:[1:$1/L",
"RULE:[1:$1]/l",
"RULE:[2:$1](ABC.*)s/ABC/XYZ/L/g",
"RULE:[1:$1]s/A/a",
"RULE:[:$1]",
"RULE:[1:$1](a",
] {
check!(Rule::parse(spec).is_err(), "{spec}");
}
}
#[test]
fn rules_print_as_kafka_prints_them() {
for (spec, printed) in [
("DEFAULT", "DEFAULT"),
(
"RULE:[2:$1@$0](.*@R)s/@R//gL",
"RULE:[2:$1@$0](.*@R)s/@R//g/L",
),
("RULE:[1:$1]U", "RULE:[1:$1]/U"),
] {
check!(rules(&[spec])[0].to_string() == printed);
}
}
#[test]
fn names_parse_as_kerberos_name_does() {
let name = |service: &str, host: Option<&str>, realm: Option<&str>| KerberosName {
service_name: service.to_owned(),
host_name: host.map(ToOwned::to_owned),
realm: realm.map(ToOwned::to_owned),
};
check!(KerberosName::parse("a/b@R").ok() == Some(name("a", Some("b"), Some("R"))));
check!(KerberosName::parse("a@R").ok() == Some(name("a", None, Some("R"))));
check!(KerberosName::parse("a/b").ok() == Some(name("a/b", None, None)));
check!(KerberosName::parse("a@R@S").is_err());
}
}