use core::fmt;
pub const PRIMARY_GROUP_RID_RODC: u32 = 521;
pub const PRIMARY_GROUP_RID_DC: u32 = 516;
pub fn ldap_filter_rodc_computers() -> &'static str {
"(&(objectCategory=computer)(primaryGroupID=521))"
}
pub fn ldap_filter_krbtgt_all() -> &'static str {
"(sAMAccountName=krbtgt*)"
}
pub fn ldap_filter_per_rodc_krbtgt(suffix: u32) -> String {
format!("(sAMAccountName=krbtgt_{suffix:05})")
}
pub fn is_per_rodc_krbtgt_sam(sam: &str) -> Option<u32> {
let rest = sam.strip_prefix("krbtgt_")?;
if rest.is_empty() {
return None;
}
rest.parse::<u32>().ok()
}
pub fn per_rodc_krbtgt_sam(suffix: u32) -> String {
format!("krbtgt_{suffix:05}")
}
pub fn per_rodc_krbtgt_dn(suffix: u32, domain_dn: &str) -> String {
format!("CN={},CN=Users,{}", per_rodc_krbtgt_sam(suffix), domain_dn)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RodcObject {
pub dn: String,
pub sam_account_name: String,
pub krbtgt_link_dn: String,
pub krbtgt_suffix: Option<u32>,
pub revealed: Vec<String>,
pub reveal_on_demand: Vec<String>,
pub never_reveal: Vec<String>,
}
impl RodcObject {
pub fn from_attrs(
dn: impl Into<String>,
sam_account_name: impl Into<String>,
krbtgt_link_dn: impl Into<String>,
revealed: Vec<String>,
reveal_on_demand: Vec<String>,
never_reveal: Vec<String>,
) -> Self {
let dn = dn.into();
let sam_account_name = sam_account_name.into();
let krbtgt_link_dn = krbtgt_link_dn.into();
let krbtgt_suffix = leaf_cn(&krbtgt_link_dn).and_then(is_per_rodc_krbtgt_sam);
Self {
dn,
sam_account_name,
krbtgt_link_dn,
krbtgt_suffix,
revealed,
reveal_on_demand,
never_reveal,
}
}
}
fn leaf_cn(dn: &str) -> Option<&str> {
let rdn = dn.split(',').next()?.trim();
rdn.strip_prefix("CN=").or_else(|| rdn.strip_prefix("cn="))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RevealFinding {
pub rodc_dn: String,
pub principal_dn: String,
pub tier: RevealTier,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RevealTier {
Tier0,
Tier1,
Tier2,
Unknown,
}
impl fmt::Display for RevealTier {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RevealTier::Tier0 => f.write_str("tier-0"),
RevealTier::Tier1 => f.write_str("tier-1"),
RevealTier::Tier2 => f.write_str("tier-2"),
RevealTier::Unknown => f.write_str("unknown-tier"),
}
}
}
pub struct RevealAudit<'a, F: Fn(&str) -> RevealTier> {
pub rodcs: &'a [RodcObject],
pub classify: F,
}
impl<'a, F: Fn(&str) -> RevealTier> RevealAudit<'a, F> {
pub fn run(&self) -> Vec<RevealFinding> {
let mut out = Vec::new();
for rodc in self.rodcs {
for principal in &rodc.revealed {
let tier = (self.classify)(principal);
if matches!(tier, RevealTier::Tier0) {
out.push(RevealFinding {
rodc_dn: rodc.dn.clone(),
principal_dn: principal.clone(),
tier,
});
}
}
}
out
}
}
pub const RODC_AUDIT_ATTRS: &[&str] = &[
"sAMAccountName",
"distinguishedName",
"primaryGroupID",
"msDS-KrbTgtLink",
"msDS-RevealedList",
"msDS-RevealOnDemandGroup",
"msDS-NeverRevealGroup",
"msDS-RevealedUsers",
];
pub const KRBTGT_AUDIT_ATTRS: &[&str] = &[
"sAMAccountName",
"distinguishedName",
"msDS-KeyVersionNumber",
"pwdLastSet",
"msDS-RevealedListBL",
];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn per_rodc_krbtgt_naming_roundtrip() {
let sam = per_rodc_krbtgt_sam(23179);
assert_eq!(sam, "krbtgt_23179");
assert_eq!(is_per_rodc_krbtgt_sam(&sam), Some(23179));
let dn = per_rodc_krbtgt_dn(23179, "DC=corp,DC=local");
assert_eq!(dn, "CN=krbtgt_23179,CN=Users,DC=corp,DC=local");
}
#[test]
fn per_rodc_krbtgt_shape_rejects_non_rodc_krbtgt() {
assert_eq!(is_per_rodc_krbtgt_sam("krbtgt"), None);
assert_eq!(is_per_rodc_krbtgt_sam("krbtgt_"), None);
assert_eq!(is_per_rodc_krbtgt_sam("krbtgt_notnumeric"), None);
assert_eq!(is_per_rodc_krbtgt_sam("something-else"), None);
}
#[test]
fn per_rodc_krbtgt_short_suffix_still_matches() {
assert_eq!(is_per_rodc_krbtgt_sam("krbtgt_1"), Some(1));
assert_eq!(is_per_rodc_krbtgt_sam("krbtgt_00042"), Some(42));
}
#[test]
fn rodc_object_parses_krbtgt_suffix() {
let rodc = RodcObject::from_attrs(
"CN=RODC01,OU=Domain Controllers,DC=corp,DC=local",
"RODC01$",
"CN=krbtgt_54321,CN=Users,DC=corp,DC=local",
vec!["CN=alice,CN=Users,DC=corp,DC=local".into()],
vec![],
vec![],
);
assert_eq!(rodc.krbtgt_suffix, Some(54321));
assert_eq!(rodc.revealed.len(), 1);
}
#[test]
fn reveal_audit_flags_tier0_leakage() {
let rodc = RodcObject::from_attrs(
"CN=RODC01,OU=Domain Controllers,DC=corp,DC=local",
"RODC01$",
"CN=krbtgt_54321,CN=Users,DC=corp,DC=local",
vec![
"CN=alice,CN=Users,DC=corp,DC=local".into(),
"CN=Administrator,CN=Users,DC=corp,DC=local".into(),
"CN=svc-web,OU=Services,DC=corp,DC=local".into(),
],
vec![],
vec![],
);
let rodcs = vec![rodc];
let audit = RevealAudit {
rodcs: &rodcs,
classify: |dn: &str| {
if dn.contains("Administrator") {
RevealTier::Tier0
} else if dn.contains("svc-web") {
RevealTier::Tier1
} else {
RevealTier::Tier2
}
},
};
let findings = audit.run();
assert_eq!(findings.len(), 1);
assert_eq!(findings[0].tier, RevealTier::Tier0);
assert!(findings[0].principal_dn.contains("Administrator"));
}
#[test]
fn ldap_filters_shape() {
assert!(ldap_filter_rodc_computers().contains("primaryGroupID=521"));
assert!(ldap_filter_krbtgt_all().contains("krbtgt"));
let f = ldap_filter_per_rodc_krbtgt(12);
assert_eq!(f, "(sAMAccountName=krbtgt_00012)");
}
#[test]
fn well_known_rids() {
assert_eq!(PRIMARY_GROUP_RID_RODC, 521);
assert_eq!(PRIMARY_GROUP_RID_DC, 516);
}
}