use crate::{EvenError, Result};
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Event {
pub record_id: u64,
pub time_created: u64,
pub event_id: u32,
pub provider: String,
pub channel: String,
pub xml: String,
}
struct Cursor<'a> {
b: &'a [u8],
p: usize,
}
impl<'a> Cursor<'a> {
fn new(b: &'a [u8]) -> Self {
Cursor { b, p: 0 }
}
fn eof(&self) -> bool {
self.p >= self.b.len()
}
fn need(&self, n: usize) -> Result<()> {
if self.p + n > self.b.len() {
Err(EvenError::Short {
need: n,
pos: self.p,
})
} else {
Ok(())
}
}
fn u8(&mut self) -> Result<u8> {
self.need(1)?;
let v = self.b[self.p];
self.p += 1;
Ok(v)
}
fn u16(&mut self) -> Result<u16> {
self.need(2)?;
let v = u16::from_le_bytes([self.b[self.p], self.b[self.p + 1]]);
self.p += 2;
Ok(v)
}
fn u32(&mut self) -> Result<u32> {
self.need(4)?;
let v = u32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap());
self.p += 4;
Ok(v)
}
fn u64(&mut self) -> Result<u64> {
self.need(8)?;
let v = u64::from_le_bytes(self.b[self.p..self.p + 8].try_into().unwrap());
self.p += 8;
Ok(v)
}
fn take(&mut self, n: usize) -> Result<&'a [u8]> {
self.need(n)?;
let s = &self.b[self.p..self.p + n];
self.p += n;
Ok(s)
}
fn peek_u8(&self) -> Result<u8> {
self.need(1)?;
Ok(self.b[self.p])
}
}
fn read_name(c: &mut Cursor) -> Result<String> {
let _name_hash_offset = c.u32()?;
let _name_hash = c.u16()?;
let n_chars = c.u16()? as usize;
let raw = c.take(n_chars * 2)?;
let mut units: Vec<u16> = raw
.chunks_exact(2)
.map(|b| u16::from_le_bytes([b[0], b[1]]))
.collect();
let _nul = c.u16()?;
while units.last() == Some(&0) {
units.pop();
}
Ok(String::from_utf16_lossy(&units))
}
fn read_value(c: &mut Cursor) -> Result<ValueData> {
let ty = c.u8()?;
Ok(match ty {
0x01 => {
let n = c.u16()? as usize;
let raw = c.take(n * 2)?;
let units: Vec<u16> = raw
.chunks_exact(2)
.map(|b| u16::from_le_bytes([b[0], b[1]]))
.collect();
ValueData::Str(String::from_utf16_lossy(&units))
}
0x08 => ValueData::U32(c.u32()?),
0x0A => ValueData::U64(c.u64()?),
0x11 => ValueData::FileTime(c.u64()?),
0x0F => {
let bs = c.take(16)?;
ValueData::Guid(bs.try_into().unwrap())
}
other => {
return Err(EvenError::BinXml(format!(
"unsupported value type {other:#04x} at pos {}",
c.p - 1
)));
}
})
}
#[derive(Clone, Debug)]
enum ValueData {
Str(String),
U32(u32),
U64(u64),
FileTime(u64),
Guid([u8; 16]),
}
impl ValueData {
fn as_str(&self) -> String {
match self {
ValueData::Str(s) => s.clone(),
ValueData::U32(v) => v.to_string(),
ValueData::U64(v) => v.to_string(),
ValueData::FileTime(v) => v.to_string(),
ValueData::Guid(g) => {
format!(
"{:08x}-{:04x}-{:04x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
u32::from_le_bytes([g[0], g[1], g[2], g[3]]),
u16::from_le_bytes([g[4], g[5]]),
u16::from_le_bytes([g[6], g[7]]),
g[8],
g[9],
g[10],
g[11],
g[12],
g[13],
g[14],
g[15]
)
}
}
}
}
pub fn decode_binxml(bytes: &[u8]) -> Result<Event> {
let mut c = Cursor::new(bytes);
let mut ev = Event::default();
let mut xml = String::new();
let mut elem_stack: Vec<String> = Vec::new();
let _pending_attr: Option<String> = None;
if let Ok(0x0F) = c.peek_u8() {
c.u8()?;
c.need(3)?;
c.p += 3;
}
while !c.eof() {
let tok = c.u8()?;
match tok {
0x00 => break, 0x01 | 0x41 => {
let _dep_id = c.u16()?; let _data_size = c.u32()?; let name = read_name(&mut c)?;
xml.push('<');
xml.push_str(&name);
elem_stack.push(name.clone());
capture_system_field(&mut ev, &elem_stack, &name, None);
}
0x02 => {
xml.push('>');
}
0x03 => {
xml.push_str("/>");
elem_stack.pop();
}
0x04 => {
if let Some(name) = elem_stack.pop() {
xml.push_str("</");
xml.push_str(&name);
xml.push('>');
}
}
0x05 | 0x45 => {
let v = read_value(&mut c)?;
let s = v.as_str();
xml.push_str(&s);
if let Some(elem) = elem_stack.last() {
let elem = elem.clone();
capture_system_field(&mut ev, &elem_stack, &elem, Some(&s));
}
}
0x06 | 0x46 => {
let attr_name = read_name(&mut c)?;
let val = read_value(&mut c)?;
let s = val.as_str();
xml.push(' ');
xml.push_str(&attr_name);
xml.push_str("=\"");
xml.push_str(&s);
xml.push('"');
if let Some(elem) = elem_stack.last() {
let elem = elem.clone();
capture_system_attr(&mut ev, &elem_stack, &elem, &attr_name, &s);
}
}
0x0C => {
xml.push_str(&format!("<!--template@{}-->", c.p - 1));
ev.xml = xml;
return Ok(ev);
}
0x0D | 0x0E => {
let sub_id = c.u16()?;
let _ty = c.u8()?;
xml.push_str(&format!("{{sub:{sub_id}}}"));
}
other => {
return Err(EvenError::UnexpectedToken {
tok: other,
pos: c.p - 1,
});
}
}
let _ = &_pending_attr;
}
ev.xml = xml;
Ok(ev)
}
fn capture_system_field(ev: &mut Event, stack: &[String], name: &str, text: Option<&str>) {
if stack.len() >= 2 && stack[0] == "Event" && stack[stack.len() - 2] == "System" {
if let Some(t) = text {
match name {
"EventID" => {
if let Ok(n) = t.parse() {
ev.event_id = n;
}
}
"EventRecordID" => {
if let Ok(n) = t.parse() {
ev.record_id = n;
}
}
"Channel" => ev.channel = t.to_string(),
_ => {}
}
}
}
}
fn capture_system_attr(ev: &mut Event, stack: &[String], elem: &str, attr: &str, val: &str) {
if stack.len() >= 2 && stack[0] == "Event" && stack[stack.len() - 2] == "System" {
match (elem, attr) {
("Provider", "Name") => ev.provider = val.to_string(),
("TimeCreated", "SystemTime") => {
if let Ok(n) = val.parse() {
ev.time_created = n;
}
}
_ => {}
}
}
}
#[doc(hidden)]
pub fn t_open_element(out: &mut Vec<u8>, name: &str) {
out.push(0x01);
out.extend_from_slice(&0u16.to_le_bytes()); out.extend_from_slice(&0u32.to_le_bytes()); t_name(out, name);
}
#[doc(hidden)]
pub fn t_open_element_with_attrs(out: &mut Vec<u8>, name: &str) {
out.push(0x41);
out.extend_from_slice(&0u16.to_le_bytes());
out.extend_from_slice(&0u32.to_le_bytes());
t_name(out, name);
}
#[doc(hidden)]
pub fn t_close_start(out: &mut Vec<u8>) {
out.push(0x02);
}
#[doc(hidden)]
pub fn t_close_empty(out: &mut Vec<u8>) {
out.push(0x03);
}
#[doc(hidden)]
pub fn t_end_element(out: &mut Vec<u8>) {
out.push(0x04);
}
#[doc(hidden)]
pub fn t_attr_string(out: &mut Vec<u8>, name: &str, val: &str) {
out.push(0x06);
t_name(out, name);
t_value_string(out, val);
}
#[doc(hidden)]
pub fn t_value_string(out: &mut Vec<u8>, val: &str) {
let units: Vec<u16> = val.encode_utf16().collect();
out.push(0x01); out.extend_from_slice(&(units.len() as u16).to_le_bytes());
for u in units {
out.extend_from_slice(&u.to_le_bytes());
}
}
#[doc(hidden)]
pub fn t_text_value(out: &mut Vec<u8>, val: &str) {
out.push(0x05); t_value_string(out, val);
}
#[doc(hidden)]
pub fn t_fragment_header(out: &mut Vec<u8>) {
out.push(0x0F);
out.push(0x01); out.push(0x01); out.push(0x00); }
#[doc(hidden)]
pub fn t_eof(out: &mut Vec<u8>) {
out.push(0x00);
}
#[doc(hidden)]
pub fn t_name(out: &mut Vec<u8>, name: &str) {
out.extend_from_slice(&0u32.to_le_bytes()); out.extend_from_slice(&0u16.to_le_bytes()); let units: Vec<u16> = name.encode_utf16().collect();
out.extend_from_slice(&(units.len() as u16).to_le_bytes());
for u in units {
out.extend_from_slice(&u.to_le_bytes());
}
out.extend_from_slice(&0u16.to_le_bytes()); }