use dcerpc::ndr::{NdrDecoder, NdrEncoder};
use dcerpc::transport::SmbPipe;
use dcerpc::{Result, Syntax};
use smb2_client::SmbClient;
use windows_sddl::sid::Sid;
pub fn lsat_syntax() -> Syntax {
Syntax::new("12345778-1234-abcd-ef00-0123456789ab", 0, 0)
}
pub mod opnum {
pub const CLOSE: u16 = 0;
pub const OPEN_POLICY: u16 = 6;
pub const LOOKUP_NAMES: u16 = 14;
pub const LOOKUP_SIDS: u16 = 15;
pub const OPEN_POLICY2: u16 = 44;
pub const LOOKUP_SIDS2: u16 = 57;
pub const LOOKUP_NAMES2: u16 = 58;
}
pub mod access {
pub const POLICY_VIEW_LOCAL_INFORMATION: u32 = 0x0000_0001;
pub const POLICY_LOOKUP_NAMES: u32 = 0x0000_0800;
pub const MAXIMUM_ALLOWED: u32 = 0x0200_0000;
}
#[non_exhaustive]
#[repr(u16)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SidType {
User = 1,
Group = 2,
Domain = 3,
Alias = 4,
WellKnownGroup = 5,
DeletedAccount = 6,
Invalid = 7,
Unknown = 8,
Computer = 9,
Label = 10,
}
impl SidType {
pub fn from_u16(v: u16) -> Self {
match v {
1 => SidType::User,
2 => SidType::Group,
3 => SidType::Domain,
4 => SidType::Alias,
5 => SidType::WellKnownGroup,
6 => SidType::DeletedAccount,
7 => SidType::Invalid,
9 => SidType::Computer,
10 => SidType::Label,
_ => SidType::Unknown,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PolicyHandle(pub [u8; 20]);
impl PolicyHandle {
pub fn decode(d: &mut NdrDecoder) -> Result<Self> {
let attrs = d.u32()?;
let uuid = d.uuid()?;
let mut h = [0u8; 20];
h[..4].copy_from_slice(&attrs.to_le_bytes());
h[4..].copy_from_slice(&uuid);
Ok(PolicyHandle(h))
}
pub fn encode(&self, e: &mut NdrEncoder) {
e.bytes(&self.0);
}
}
pub fn encode_open_policy2(system_name: &str, desired_access: u32) -> Vec<u8> {
let mut e = NdrEncoder::new();
e.referent();
e.conformant_varying_wstr(system_name);
e.align(4);
e.u32(24); e.null_ptr(); e.null_ptr(); e.u32(0); e.null_ptr(); e.null_ptr(); e.u32(desired_access);
e.into_bytes()
}
fn encode_sid(e: &mut NdrEncoder, sid: &Sid) {
e.u32(sid.sub_authorities.len() as u32);
e.u8(sid.revision);
e.u8(sid.sub_authorities.len() as u8);
let a = sid.identifier_authority;
e.bytes(&[
(a >> 40) as u8,
(a >> 32) as u8,
(a >> 24) as u8,
(a >> 16) as u8,
(a >> 8) as u8,
a as u8,
]);
for s in &sid.sub_authorities {
e.u32(*s);
}
}
fn decode_sid(d: &mut NdrDecoder) -> Result<Sid> {
let _max = d.u32()?;
let revision = d.u8()?;
let count = d.u8()? as usize;
let auth = d.read_bytes(6)?;
let identifier_authority = auth.iter().fold(0u64, |acc, &b| (acc << 8) | b as u64);
let mut sub_authorities = Vec::with_capacity(count);
for _ in 0..count {
sub_authorities.push(d.u32()?);
}
Ok(Sid {
revision,
identifier_authority,
sub_authorities,
})
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct LookedUpSid {
pub name: String,
pub domain: String,
pub kind: SidType,
}
pub fn encode_lookup_sids2(
handle: &PolicyHandle,
sids: &[Sid],
lookup_level: u16,
client_revision: u32,
) -> Vec<u8> {
let mut e = NdrEncoder::new();
handle.encode(&mut e);
e.u32(sids.len() as u32); e.referent(); e.u32(sids.len() as u32);
for _ in sids {
e.referent(); }
for sid in sids {
encode_sid(&mut e, sid);
}
e.u32(0); e.null_ptr();
e.u16(lookup_level);
e.align(4);
e.u32(0);
e.u32(0); e.u32(client_revision);
e.into_bytes()
}
pub fn decode_lookup_sids2(stub: &[u8]) -> Result<Vec<LookedUpSid>> {
let mut d = NdrDecoder::new(stub);
let refdom_ptr = d.u32()?;
let mut domain_names: Vec<String> = Vec::new();
if refdom_ptr != 0 {
let dom_entries = d.u32()? as usize;
let dom_arr_ptr = d.u32()?;
let _max_entries = d.u32()?;
if dom_arr_ptr != 0 {
let _dom_max_count = d.u32()?;
let mut dom_headers: Vec<(u16, u32, u32)> = Vec::with_capacity(dom_entries);
for _ in 0..dom_entries {
let name_len = d.u16()?;
let _name_max = d.u16()?;
let name_ptr = d.u32()?;
let sid_ptr = d.u32()?;
dom_headers.push((name_len, name_ptr, sid_ptr));
}
for (_len, name_ptr, sid_ptr) in dom_headers {
let name = if name_ptr != 0 {
d.conformant_varying_wstr()?
} else {
String::new()
};
if sid_ptr != 0 {
let _ = decode_sid(&mut d)?; }
domain_names.push(name);
}
}
}
let entries = d.u32()? as usize;
let names_arr_ptr = d.u32()?;
let mut out = Vec::with_capacity(entries);
if names_arr_ptr != 0 {
let _max_count = d.u32()?;
let mut headers: Vec<(SidType, u32, i32)> = Vec::with_capacity(entries);
for _ in 0..entries {
let sid_type_raw = d.u16()?;
d.align(4);
let _name_len = d.u16()?;
let _name_max = d.u16()?;
let name_ptr = d.u32()?;
let domain_idx = d.u32()? as i32;
let _flags = d.u32()?;
headers.push((SidType::from_u16(sid_type_raw), name_ptr, domain_idx));
}
for (kind, name_ptr, domain_idx) in headers {
let name = if name_ptr != 0 {
d.conformant_varying_wstr()?
} else {
String::new()
};
let domain = if domain_idx >= 0 {
domain_names
.get(domain_idx as usize)
.cloned()
.unwrap_or_default()
} else {
String::new()
};
out.push(LookedUpSid { name, domain, kind });
}
}
Ok(out)
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct LookedUpName {
pub sid: Sid,
pub domain: String,
pub kind: SidType,
}
pub fn encode_lookup_names2(
handle: &PolicyHandle,
names: &[&str],
lookup_level: u16,
client_revision: u32,
) -> Vec<u8> {
let mut e = NdrEncoder::new();
handle.encode(&mut e);
e.u32(names.len() as u32); e.u32(names.len() as u32); for name in names {
let units: Vec<u16> = name.encode_utf16().collect();
let blen = (units.len() * 2) as u16;
e.u16(blen); e.u16(blen); e.referent(); }
for name in names {
let units: Vec<u16> = name.encode_utf16().collect();
let n = units.len() as u32;
e.u32(n); e.u32(0); e.u32(n); for u in units {
e.u16(u);
}
}
e.u32(0); e.null_ptr();
e.u16(lookup_level);
e.align(4);
e.u32(0); e.u32(0); e.u32(client_revision);
e.into_bytes()
}
pub fn decode_lookup_names2(stub: &[u8]) -> Result<Vec<LookedUpName>> {
let mut d = NdrDecoder::new(stub);
let refdom_ptr = d.u32()?;
let mut domain_names: Vec<String> = Vec::new();
let mut domain_sids: Vec<Option<Sid>> = Vec::new();
if refdom_ptr != 0 {
let dom_entries = d.u32()? as usize;
let dom_arr_ptr = d.u32()?;
let _max_entries = d.u32()?;
if dom_arr_ptr != 0 {
let _dom_max_count = d.u32()?;
let mut dom_headers: Vec<(u16, u32, u32)> = Vec::with_capacity(dom_entries);
for _ in 0..dom_entries {
let name_len = d.u16()?;
let _name_max = d.u16()?;
let name_ptr = d.u32()?;
let sid_ptr = d.u32()?;
dom_headers.push((name_len, name_ptr, sid_ptr));
}
for (_len, name_ptr, sid_ptr) in dom_headers {
let name = if name_ptr != 0 {
d.conformant_varying_wstr()?
} else {
String::new()
};
let sid = if sid_ptr != 0 {
Some(decode_sid(&mut d)?)
} else {
None
};
domain_names.push(name);
domain_sids.push(sid);
}
}
}
let entries = d.u32()? as usize;
let sids_arr_ptr = d.u32()?;
let mut out = Vec::with_capacity(entries);
if sids_arr_ptr != 0 {
let _max_count = d.u32()?;
for _ in 0..entries {
let sid_type_raw = d.u16()?;
d.align(4);
let rid = d.u32()?;
let domain_idx = d.u32()? as i32;
let _flags = d.u32()?;
let kind = SidType::from_u16(sid_type_raw);
let (domain, sid) = if domain_idx >= 0 {
let idx = domain_idx as usize;
let dn = domain_names.get(idx).cloned().unwrap_or_default();
let mut sid = domain_sids
.get(idx)
.and_then(|s| s.clone())
.unwrap_or_else(|| Sid {
revision: 1,
identifier_authority: 0,
sub_authorities: vec![],
});
if kind != SidType::Domain {
sid.sub_authorities.push(rid);
}
(dn, sid)
} else {
(
String::new(),
Sid {
revision: 1,
identifier_authority: 0,
sub_authorities: vec![rid],
},
)
};
out.push(LookedUpName { sid, domain, kind });
}
}
Ok(out)
}
pub struct LsatClient<'a> {
pipe: SmbPipe<'a>,
handle: Option<PolicyHandle>,
}
impl<'a> LsatClient<'a> {
pub async fn bind(client: &'a mut SmbClient, file_id: [u8; 16]) -> Result<Self> {
let mut pipe = SmbPipe::new(client, file_id);
pipe.bind(lsat_syntax()).await?;
Ok(LsatClient { pipe, handle: None })
}
async fn ensure_handle(&mut self, system_name: &str) -> Result<PolicyHandle> {
if let Some(h) = self.handle {
return Ok(h);
}
let stub = encode_open_policy2(system_name, access::MAXIMUM_ALLOWED);
let resp = self.pipe.call(opnum::OPEN_POLICY2, &stub).await?;
let mut d = NdrDecoder::new(&resp);
let h = PolicyHandle::decode(&mut d)?;
self.handle = Some(h);
Ok(h)
}
pub async fn lookup_sids(
&mut self,
system_name: &str,
sids: &[Sid],
) -> Result<Vec<LookedUpSid>> {
let h = self.ensure_handle(system_name).await?;
let stub = encode_lookup_sids2(&h, sids, 1, 2);
let resp = self.pipe.call(opnum::LOOKUP_SIDS2, &stub).await?;
decode_lookup_sids2(&resp)
}
pub async fn lookup_names(
&mut self,
system_name: &str,
names: &[&str],
) -> Result<Vec<LookedUpName>> {
let h = self.ensure_handle(system_name).await?;
let stub = encode_lookup_names2(&h, names, 1, 2);
let resp = self.pipe.call(opnum::LOOKUP_NAMES2, &stub).await?;
decode_lookup_names2(&resp)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn open_policy2_marshals_system_and_access() {
let stub = encode_open_policy2("\\\\dc01", access::MAXIMUM_ALLOWED);
assert_eq!(stub.len(), 60);
assert_eq!(
&stub[stub.len() - 4..],
&access::MAXIMUM_ALLOWED.to_le_bytes()
);
}
#[test]
fn lookup_sids2_layout_fixed_prefix() {
let sid = Sid::parse("S-1-5-21-1111-2222-3333-500").unwrap();
let stub = encode_lookup_sids2(&PolicyHandle([0; 20]), &[sid], 1, 2);
assert_eq!(stub.len(), 92);
}
#[test]
fn lookup_names2_marshals_multiple_names() {
let stub = encode_lookup_names2(&PolicyHandle([0; 20]), &["Administrator", "krbtgt"], 1, 2);
assert_eq!(&stub[0..20], &[0u8; 20]);
assert_eq!(u32::from_le_bytes(stub[20..24].try_into().unwrap()), 2); }
#[test]
fn sid_type_maps_known_values_and_defaults_unknown() {
assert_eq!(SidType::from_u16(1), SidType::User);
assert_eq!(SidType::from_u16(2), SidType::Group);
assert_eq!(SidType::from_u16(9), SidType::Computer);
assert_eq!(SidType::from_u16(255), SidType::Unknown);
}
#[test]
fn lookup_sids2_decode_roundtrip_single_result() {
let mut e = NdrEncoder::new();
e.referent();
e.u32(1); e.referent(); e.u32(32); e.u32(1); let dn: Vec<u16> = "CORP".encode_utf16().collect();
let dl = (dn.len() * 2) as u16;
e.u16(dl);
e.u16(dl);
e.referent(); e.referent(); e.u32(dn.len() as u32);
e.u32(0);
e.u32(dn.len() as u32);
for u in dn.iter() {
e.u16(*u);
}
let dom_sid = Sid::parse("S-1-5-21-1-2-3").unwrap();
encode_sid(&mut e, &dom_sid);
e.u32(1); e.referent(); e.u32(1); e.u16(SidType::User as u16);
e.align(4); let nn: Vec<u16> = "Administrator".encode_utf16().collect();
let nl = (nn.len() * 2) as u16;
e.u16(nl);
e.u16(nl);
e.referent(); e.u32(0); e.u32(0); e.u32(nn.len() as u32);
e.u32(0);
e.u32(nn.len() as u32);
for u in nn.iter() {
e.u16(*u);
}
e.u32(1);
e.u32(0);
let stub = e.into_bytes();
let rows = decode_lookup_sids2(&stub).unwrap();
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].name, "Administrator");
assert_eq!(rows[0].domain, "CORP");
assert_eq!(rows[0].kind, SidType::User);
}
}