use core::fmt;
pub mod config_entry {
pub const EDIT_FLAGS_NODE: &str = "PolicyModules\\CertificateAuthority_MicrosoftDefault.Policy";
pub const EDIT_FLAGS_ENTRY: &str = "EditFlags";
pub const INTERFACE_FLAGS_NODE: &str = "";
pub const INTERFACE_FLAGS_ENTRY: &str = "InterfaceFlags";
pub const CRL_FLAGS_NODE: &str = "";
pub const CRL_FLAGS_ENTRY: &str = "CRLFlags";
}
pub const CSRA_INTERFACE_UUID: &str = "d99e6e73-fc88-11d0-b498-00a0c90312f4";
pub const CSRA_D2_INTERFACE_UUID: &str = "7fe0d935-dda6-11d1-a71f-00c04fc3141e";
pub const GET_CONFIG_ENTRY_OPNUM: u16 = 44;
pub fn build_get_config_entry_request(authority: &str, node_path: &str, entry: &str) -> Vec<u8> {
let mut out = Vec::new();
let mut e = NdrEncoder::new(&mut out);
e.referent();
e.conformant_varying_wstr(authority);
e.align(4);
e.referent();
e.conformant_varying_wstr(node_path);
e.align(4);
e.referent();
e.conformant_varying_wstr(entry);
out
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EditFlags(pub u32);
impl EditFlags {
pub const EDITF_ENABLEREQUESTEXTENSIONS: u32 = 0x00000001;
pub const EDITF_REQUESTEXTENSIONLIST: u32 = 0x00000002;
pub const EDITF_DISABLEEXTENSIONLIST: u32 = 0x00000004;
pub const EDITF_ADDOLDKEYUSAGE: u32 = 0x00000008;
pub const EDITF_ADDOLDCERTTYPE: u32 = 0x00000010;
pub const EDITF_ATTRIBUTEENDDATE: u32 = 0x00000020;
pub const EDITF_BASICCONSTRAINTSCRITICAL: u32 = 0x00000040;
pub const EDITF_ENABLEAKIKEYID: u32 = 0x00000100;
pub const EDITF_ATTRIBUTECA: u32 = 0x00000200;
pub const EDITF_IGNOREREQUESTERGROUP: u32 = 0x00000400;
pub const EDITF_ENABLEAKIISSUERNAME: u32 = 0x00000800;
pub const EDITF_ENABLEAKIISSUERSERIAL: u32 = 0x00001000;
pub const EDITF_ENABLEAKICRITICAL: u32 = 0x00002000;
pub const EDITF_SERVERUPGRADED: u32 = 0x00004000;
pub const EDITF_DISABLEOLDOSCNUPN: u32 = 0x00008000;
pub const EDITF_ADDOLDKEYUSAGE_2: u32 = 0x00010000;
pub const EDITF_ATTRIBUTESUBJECTALTNAME2: u32 = 0x00040000;
pub const EDITF_ENABLELDAPREFERRALS: u32 = 0x00080000;
pub const EDITF_ENABLECHASECRLBRANCH: u32 = 0x00100000;
pub const EDITF_AUDITCERTTEMPLATELOAD: u32 = 0x00200000;
pub fn has_esc6(&self) -> bool {
(self.0 & Self::EDITF_ATTRIBUTESUBJECTALTNAME2) != 0
}
pub fn describe(&self) -> Vec<&'static str> {
let mut out = Vec::new();
macro_rules! chk {
($($bit:ident),* $(,)?) => {
$(
if (self.0 & Self::$bit) != 0 {
out.push(stringify!($bit));
}
)*
};
}
chk!(
EDITF_ENABLEREQUESTEXTENSIONS,
EDITF_REQUESTEXTENSIONLIST,
EDITF_DISABLEEXTENSIONLIST,
EDITF_ADDOLDKEYUSAGE,
EDITF_ADDOLDCERTTYPE,
EDITF_ATTRIBUTEENDDATE,
EDITF_BASICCONSTRAINTSCRITICAL,
EDITF_ENABLEAKIKEYID,
EDITF_ATTRIBUTECA,
EDITF_IGNOREREQUESTERGROUP,
EDITF_ENABLEAKIISSUERNAME,
EDITF_ENABLEAKIISSUERSERIAL,
EDITF_ENABLEAKICRITICAL,
EDITF_SERVERUPGRADED,
EDITF_DISABLEOLDOSCNUPN,
EDITF_ATTRIBUTESUBJECTALTNAME2,
EDITF_ENABLELDAPREFERRALS,
EDITF_ENABLECHASECRLBRANCH,
EDITF_AUDITCERTTEMPLATELOAD,
);
out
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InterfaceFlags(pub u32);
impl InterfaceFlags {
pub const IF_LOCKICERTREQUEST: u32 = 0x00000001;
pub const IF_NOREMOTEICERTREQUEST: u32 = 0x00000002;
pub const IF_NOLOCALICERTREQUEST: u32 = 0x00000004;
pub const IF_NOREMOTEICERTADMIN: u32 = 0x00000008;
pub const IF_NOLOCALICERTADMIN: u32 = 0x00000010;
pub const IF_NOREMOTEICERTADMINBACKUP: u32 = 0x00000020;
pub const IF_NOLOCALICERTADMINBACKUP: u32 = 0x00000040;
pub const IF_NOSNAPSHOTBACKUP: u32 = 0x00000080;
pub const IF_ENFORCEENCRYPTICERTREQUEST: u32 = 0x00000200;
pub const IF_ENFORCEENCRYPTICERTADMIN: u32 = 0x00000400;
pub const IF_ENABLEEXITKEYRETRIEVAL: u32 = 0x00000800;
pub const IF_ENABLEADMINASAUDITOR: u32 = 0x00001000;
pub fn has_esc11(&self) -> bool {
(self.0 & Self::IF_ENFORCEENCRYPTICERTREQUEST) == 0
}
pub fn describe(&self) -> Vec<&'static str> {
let mut out = Vec::new();
macro_rules! chk {
($($bit:ident),* $(,)?) => {
$(
if (self.0 & Self::$bit) != 0 {
out.push(stringify!($bit));
}
)*
};
}
chk!(
IF_LOCKICERTREQUEST,
IF_NOREMOTEICERTREQUEST,
IF_NOLOCALICERTREQUEST,
IF_NOREMOTEICERTADMIN,
IF_NOLOCALICERTADMIN,
IF_NOREMOTEICERTADMINBACKUP,
IF_NOLOCALICERTADMINBACKUP,
IF_NOSNAPSHOTBACKUP,
IF_ENFORCEENCRYPTICERTREQUEST,
IF_ENFORCEENCRYPTICERTADMIN,
IF_ENABLEEXITKEYRETRIEVAL,
IF_ENABLEADMINASAUDITOR,
);
out
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CrlFlags(pub u32);
impl CrlFlags {
pub const CRLF_DELTA_USE_OLDEST_UNEXPIRED_BASE: u32 = 0x00000004;
pub const CRLF_DELETE_EXPIRED_CRLS: u32 = 0x00000008;
pub const CRLF_PUBLISH_EXPIRED_CERT_CRLS: u32 = 0x00000200;
pub fn describe(&self) -> Vec<&'static str> {
let mut out = Vec::new();
if (self.0 & Self::CRLF_DELTA_USE_OLDEST_UNEXPIRED_BASE) != 0 {
out.push("CRLF_DELTA_USE_OLDEST_UNEXPIRED_BASE");
}
if (self.0 & Self::CRLF_DELETE_EXPIRED_CRLS) != 0 {
out.push("CRLF_DELETE_EXPIRED_CRLS");
}
if (self.0 & Self::CRLF_PUBLISH_EXPIRED_CERT_CRLS) != 0 {
out.push("CRLF_PUBLISH_EXPIRED_CERT_CRLS");
}
out
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Esc6Finding {
pub ca_name: String,
pub edit_flags: EditFlags,
pub severity: Severity,
pub remediation: &'static str,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Esc11Finding {
pub ca_name: String,
pub interface_flags: InterfaceFlags,
pub severity: Severity,
pub remediation: &'static str,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Severity {
Low,
Medium,
High,
Critical,
}
impl fmt::Display for Severity {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Severity::Low => f.write_str("low"),
Severity::Medium => f.write_str("medium"),
Severity::High => f.write_str("high"),
Severity::Critical => f.write_str("critical"),
}
}
}
pub fn detect_esc6(ca_name: &str, edit_flags: EditFlags) -> Option<Esc6Finding> {
if edit_flags.has_esc6() {
Some(Esc6Finding {
ca_name: ca_name.to_string(),
edit_flags,
severity: Severity::Critical,
remediation:
"Clear EDITF_ATTRIBUTESUBJECTALTNAME2 on the CA: `certutil -setreg policy\\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2 && net stop certsvc && net start certsvc`. Any low-priv requester can currently obtain a client-auth cert bound to Administrator@<realm>.",
})
} else {
None
}
}
pub fn detect_esc11(ca_name: &str, interface_flags: InterfaceFlags) -> Option<Esc11Finding> {
if interface_flags.has_esc11() {
Some(Esc11Finding {
ca_name: ca_name.to_string(),
interface_flags,
severity: Severity::High,
remediation:
"Set IF_ENFORCEENCRYPTICERTREQUEST on the CA: `certutil -setreg CA\\InterfaceFlags +IF_ENFORCEENCRYPTICERTREQUEST && net stop certsvc && net start certsvc`. Without this the CA accepts NTLM-relayed requests without packet privacy.",
})
} else {
None
}
}
struct NdrEncoder<'a> {
out: &'a mut Vec<u8>,
referent_counter: u32,
}
impl<'a> NdrEncoder<'a> {
fn new(out: &'a mut Vec<u8>) -> Self {
Self {
out,
referent_counter: 0x0002_0000,
}
}
fn referent(&mut self) {
let r = self.referent_counter;
self.referent_counter = self.referent_counter.wrapping_add(4);
self.u32(r);
}
fn u32(&mut self, v: u32) {
self.align(4);
self.out.extend_from_slice(&v.to_le_bytes());
}
fn align(&mut self, n: usize) {
while self.out.len() % n != 0 {
self.out.push(0);
}
}
fn conformant_varying_wstr(&mut self, s: &str) {
let units: Vec<u16> = s.encode_utf16().chain(core::iter::once(0)).collect();
let n = units.len() as u32;
self.align(4);
self.u32(n); self.u32(0); self.u32(n); for u in units {
self.out.extend_from_slice(&u.to_le_bytes());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn edit_flags_esc6_bit_detected() {
let f =
EditFlags(EditFlags::EDITF_ATTRIBUTESUBJECTALTNAME2 | EditFlags::EDITF_ENABLEAKIKEYID);
assert!(f.has_esc6());
let d = f.describe();
assert!(d.contains(&"EDITF_ATTRIBUTESUBJECTALTNAME2"));
assert!(d.contains(&"EDITF_ENABLEAKIKEYID"));
}
#[test]
fn edit_flags_default_shape_no_esc6() {
let f = EditFlags(0x0001_5014);
assert!(!f.has_esc6());
}
#[test]
fn interface_flags_esc11_detected_on_missing_encryption() {
let f = InterfaceFlags(InterfaceFlags::IF_LOCKICERTREQUEST);
assert!(f.has_esc11());
}
#[test]
fn interface_flags_esc11_clear_when_encryption_enforced() {
let f = InterfaceFlags(
InterfaceFlags::IF_LOCKICERTREQUEST | InterfaceFlags::IF_ENFORCEENCRYPTICERTREQUEST,
);
assert!(!f.has_esc11());
}
#[test]
fn detect_esc6_emits_finding_only_when_bit_set() {
assert!(detect_esc6(
"corp-CA-01",
EditFlags(EditFlags::EDITF_ATTRIBUTESUBJECTALTNAME2)
)
.is_some());
assert!(detect_esc6("corp-CA-01", EditFlags(0)).is_none());
}
#[test]
fn detect_esc11_emits_finding_only_when_encryption_missing() {
assert!(detect_esc11("corp-CA-01", InterfaceFlags(0)).is_some());
assert!(detect_esc11(
"corp-CA-01",
InterfaceFlags(InterfaceFlags::IF_ENFORCEENCRYPTICERTREQUEST)
)
.is_none());
}
#[test]
fn get_config_entry_request_carries_all_three_strings() {
let stub = build_get_config_entry_request(
"corp-CA-01",
config_entry::EDIT_FLAGS_NODE,
config_entry::EDIT_FLAGS_ENTRY,
);
for lit in ["corp-CA-01", config_entry::EDIT_FLAGS_ENTRY] {
let expected: Vec<u8> = format!("{lit}\0")
.encode_utf16()
.flat_map(|u| u.to_le_bytes())
.collect();
assert!(
stub.windows(expected.len()).any(|w| w == expected),
"config-entry stub must carry `{lit}` as UTF-16LE + NUL"
);
}
}
#[test]
fn severity_display() {
assert_eq!(format!("{}", Severity::Critical), "critical");
assert_eq!(format!("{}", Severity::High), "high");
}
}