Qualify Windows IPC client runtime and prepare bounded native providers
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -0,0 +1,528 @@
|
||||
//! Bounded, local, fixture-only live Event Log query; not wired into any job.
|
||||
//!
|
||||
//! EvtQuery/EvtRender have no per-call timeout. The monotonic deadline below is
|
||||
//! cooperative between Win32 calls; the eventual executor must also supervise
|
||||
//! its process. This module never starts another worker or advances a bookmark.
|
||||
//! API contracts: https://learn.microsoft.com/en-us/windows/win32/api/winevt/nf-winevt-evtquery
|
||||
//! https://learn.microsoft.com/en-us/windows/win32/api/winevt/nf-winevt-evtnext
|
||||
//! https://learn.microsoft.com/en-us/windows/win32/api/winevt/nf-winevt-evtrender
|
||||
//! https://learn.microsoft.com/en-us/windows/win32/api/winevt/ne-winevt-evt_system_property_id
|
||||
use anyhow::{Result, ensure};
|
||||
use chrono::{DateTime, SecondsFormat, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::sync::atomic::AtomicBool;
|
||||
|
||||
pub const CHANNEL: &str = "Application";
|
||||
pub const PROVIDER: &str = "RustDiscovery-MVP-Test";
|
||||
const MAX_BYTES: usize = 256 * 1024;
|
||||
#[cfg(any(windows, test))]
|
||||
const REPORT_RESERVE: usize = 256;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Query {
|
||||
pub channel: String,
|
||||
pub provider: String,
|
||||
pub start_utc: DateTime<Utc>,
|
||||
pub end_utc: DateTime<Utc>,
|
||||
pub max_events: u32,
|
||||
pub max_output_bytes: u32,
|
||||
pub timeout_ms: u32,
|
||||
}
|
||||
impl Query {
|
||||
fn xpath(&self) -> Result<String> {
|
||||
ensure!(
|
||||
self.channel == CHANNEL && self.provider == PROVIDER,
|
||||
"EVENT_LOG_SOURCE_DENIED"
|
||||
);
|
||||
ensure!(
|
||||
self.start_utc.timestamp() >= 0
|
||||
&& self.end_utc > self.start_utc
|
||||
&& self.end_utc - self.start_utc <= chrono::Duration::hours(24),
|
||||
"EVENT_LOG_WINDOW_INVALID"
|
||||
);
|
||||
ensure!(
|
||||
(1..=1000).contains(&self.max_events)
|
||||
&& (1024..=MAX_BYTES as u32).contains(&self.max_output_bytes)
|
||||
&& (1..=5000).contains(&self.timeout_ms),
|
||||
"EVENT_LOG_LIMIT_INVALID"
|
||||
);
|
||||
// Only canonical UTC timestamps enter this fixed expression. Neither a
|
||||
// caller-supplied XPath, a remote session nor a log-file path exists.
|
||||
Ok(format!(
|
||||
"*[System[Provider[@Name='{PROVIDER}'] and TimeCreated[@SystemTime>='{}' and @SystemTime<'{}']]]",
|
||||
self.start_utc.to_rfc3339_opts(SecondsFormat::Nanos, true),
|
||||
self.end_utc.to_rfc3339_opts(SecondsFormat::Nanos, true)
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct Event {
|
||||
pub channel: String,
|
||||
pub provider: String,
|
||||
pub record_id: u64,
|
||||
pub event_id: u16,
|
||||
pub created_utc: DateTime<Utc>,
|
||||
/// Exact bounded XML from EvtRenderEventXml, including fixture EventData;
|
||||
/// no localized publisher DLL/message formatting is performed.
|
||||
pub xml: String,
|
||||
}
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct Report {
|
||||
pub channel: String,
|
||||
pub provider: String,
|
||||
pub start_utc: DateTime<Utc>,
|
||||
pub end_utc: DateTime<Utc>,
|
||||
pub quality: &'static str,
|
||||
pub completeness: &'static str,
|
||||
pub truncated: bool,
|
||||
pub error_code: Option<&'static str>,
|
||||
pub win32_error: Option<u32>,
|
||||
pub events: Vec<Event>,
|
||||
pub bookmark_updated: bool,
|
||||
pub deadline_enforcement: &'static str,
|
||||
}
|
||||
#[cfg(any(windows, test))]
|
||||
impl Report {
|
||||
fn new(q: &Query) -> Self {
|
||||
Self {
|
||||
channel: q.channel.clone(),
|
||||
provider: q.provider.clone(),
|
||||
start_utc: q.start_utc,
|
||||
end_utc: q.end_utc,
|
||||
quality: "valid",
|
||||
completeness: "partial",
|
||||
truncated: false,
|
||||
error_code: None,
|
||||
win32_error: None,
|
||||
events: Vec::new(),
|
||||
bookmark_updated: false,
|
||||
deadline_enforcement: "cooperative_between_win32_calls",
|
||||
}
|
||||
}
|
||||
fn stop(&mut self, code: &'static str, win32: Option<u32>) {
|
||||
self.truncated = true;
|
||||
self.error_code = Some(code);
|
||||
self.win32_error = win32;
|
||||
self.completeness = if self.events.is_empty() {
|
||||
"unknown"
|
||||
} else {
|
||||
"partial"
|
||||
};
|
||||
if win32 == Some(5) {
|
||||
self.quality = "permission_denied";
|
||||
} else if win32.is_some() {
|
||||
self.quality = "error";
|
||||
}
|
||||
}
|
||||
fn push(&mut self, event: Event, limit: usize) -> Result<bool> {
|
||||
self.events.push(event);
|
||||
if serde_json::to_vec(self)?.len() + REPORT_RESERVE > limit {
|
||||
self.events.pop();
|
||||
self.stop("EVENT_LOG_BYTE_LIMIT", None);
|
||||
return Ok(false);
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads only the fixed local fixture source. No persistent state is modified.
|
||||
pub fn query(q: &Query, cancelled: &AtomicBool) -> Result<Report> {
|
||||
let xpath = q.xpath()?;
|
||||
#[cfg(windows)]
|
||||
{
|
||||
windows::query(q, &xpath, cancelled)
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
let _ = (xpath, cancelled);
|
||||
anyhow::bail!("EVENT_LOG_WINDOWS_ONLY")
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod windows {
|
||||
use super::*;
|
||||
use anyhow::Context;
|
||||
use std::{
|
||||
mem::size_of,
|
||||
ptr,
|
||||
sync::atomic::Ordering,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{
|
||||
ERROR_ACCESS_DENIED, ERROR_INSUFFICIENT_BUFFER, ERROR_NO_MORE_ITEMS, ERROR_TIMEOUT,
|
||||
GetLastError,
|
||||
},
|
||||
System::EventLog::*,
|
||||
};
|
||||
|
||||
struct Handle(EVT_HANDLE);
|
||||
impl Drop for Handle {
|
||||
fn drop(&mut self) {
|
||||
if self.0 != 0 {
|
||||
unsafe {
|
||||
EvtClose(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn wide(s: &str) -> Vec<u16> {
|
||||
s.encode_utf16().chain(Some(0)).collect()
|
||||
}
|
||||
fn stopped(report: &mut Report, cancelled: &AtomicBool, until: Instant) -> bool {
|
||||
if cancelled.load(Ordering::SeqCst) {
|
||||
report.stop("EVENT_LOG_CANCELLED", None);
|
||||
true
|
||||
} else if Instant::now() >= until {
|
||||
report.stop("EVENT_LOG_TIME_LIMIT", None);
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
fn failure(report: &mut Report, error: u32) {
|
||||
report.stop(
|
||||
if error == ERROR_ACCESS_DENIED {
|
||||
"EVENT_LOG_PERMISSION_DENIED"
|
||||
} else {
|
||||
"EVENT_LOG_API_ERROR"
|
||||
},
|
||||
Some(error),
|
||||
);
|
||||
}
|
||||
// u64 storage provides the alignment required by EVT_VARIANT. All returned
|
||||
// pointers are read while this owning allocation remains alive.
|
||||
fn render(
|
||||
context: EVT_HANDLE,
|
||||
event: EVT_HANDLE,
|
||||
flags: u32,
|
||||
cap: usize,
|
||||
until: Instant,
|
||||
cancelled: &AtomicBool,
|
||||
) -> Result<(Vec<u64>, usize, u32)> {
|
||||
ensure!(
|
||||
!cancelled.load(Ordering::SeqCst) && Instant::now() < until,
|
||||
"EVENT_LOG_TIME_OR_CANCELLED"
|
||||
);
|
||||
let mut used = 0;
|
||||
let mut count = 0;
|
||||
let first = unsafe {
|
||||
EvtRender(
|
||||
context,
|
||||
event,
|
||||
flags,
|
||||
0,
|
||||
ptr::null_mut(),
|
||||
&mut used,
|
||||
&mut count,
|
||||
)
|
||||
};
|
||||
let error = if first == 0 {
|
||||
unsafe { GetLastError() }
|
||||
} else {
|
||||
0
|
||||
};
|
||||
ensure!(
|
||||
!cancelled.load(Ordering::SeqCst) && Instant::now() < until,
|
||||
"EVENT_LOG_TIME_OR_CANCELLED"
|
||||
);
|
||||
if first == 0 && error != ERROR_INSUFFICIENT_BUFFER {
|
||||
return Err(std::io::Error::from_raw_os_error(error as i32).into());
|
||||
}
|
||||
ensure!(first == 0 && used > 0, "EVENT_LOG_RENDER_PROBE");
|
||||
if used as usize > cap {
|
||||
return Err(std::io::Error::from_raw_os_error(ERROR_INSUFFICIENT_BUFFER as i32).into());
|
||||
}
|
||||
let mut buffer = vec![0u64; (used as usize).div_ceil(8)];
|
||||
let allocated = buffer.len() * 8;
|
||||
ensure!(
|
||||
!cancelled.load(Ordering::SeqCst) && Instant::now() < until,
|
||||
"EVENT_LOG_TIME_OR_CANCELLED"
|
||||
);
|
||||
let ok = unsafe {
|
||||
EvtRender(
|
||||
context,
|
||||
event,
|
||||
flags,
|
||||
allocated as u32,
|
||||
buffer.as_mut_ptr().cast(),
|
||||
&mut used,
|
||||
&mut count,
|
||||
)
|
||||
};
|
||||
let error = if ok == 0 {
|
||||
unsafe { GetLastError() }
|
||||
} else {
|
||||
0
|
||||
};
|
||||
ensure!(
|
||||
!cancelled.load(Ordering::SeqCst) && Instant::now() < until,
|
||||
"EVENT_LOG_TIME_OR_CANCELLED"
|
||||
);
|
||||
if ok == 0 {
|
||||
return Err(std::io::Error::from_raw_os_error(error as i32).into());
|
||||
}
|
||||
ensure!(used as usize <= allocated, "EVENT_LOG_RENDER_SIZE");
|
||||
Ok((buffer, used as usize, count))
|
||||
}
|
||||
fn string(value: &EVT_VARIANT, buffer: &[u64], used: usize) -> Result<String> {
|
||||
ensure!(
|
||||
value.Type == EvtVarTypeString as u32,
|
||||
"EVENT_LOG_PROPERTY_TYPE"
|
||||
);
|
||||
let pointer = unsafe { value.Anonymous.StringVal };
|
||||
let address = pointer as usize;
|
||||
let base = buffer.as_ptr() as usize;
|
||||
ensure!(
|
||||
address >= base && address < base + used && address.is_multiple_of(2),
|
||||
"EVENT_LOG_PROPERTY_POINTER"
|
||||
);
|
||||
let length = (base + used - address) / 2;
|
||||
let units = unsafe { std::slice::from_raw_parts(pointer, length) };
|
||||
let end = units
|
||||
.iter()
|
||||
.position(|x| *x == 0)
|
||||
.context("EVENT_LOG_PROPERTY_TERMINATOR")?;
|
||||
ensure!(end <= 256, "EVENT_LOG_PROPERTY_LIMIT");
|
||||
Ok(String::from_utf16(&units[..end])?)
|
||||
}
|
||||
fn read_event(
|
||||
context: EVT_HANDLE,
|
||||
event: EVT_HANDLE,
|
||||
q: &Query,
|
||||
until: Instant,
|
||||
cancelled: &AtomicBool,
|
||||
) -> Result<Event> {
|
||||
let (buffer, used, count) = render(
|
||||
context,
|
||||
event,
|
||||
EvtRenderEventValues,
|
||||
16 * 1024,
|
||||
until,
|
||||
cancelled,
|
||||
)?;
|
||||
ensure!(
|
||||
count == EvtSystemPropertyIdEND as u32
|
||||
&& used >= count as usize * size_of::<EVT_VARIANT>(),
|
||||
"EVENT_LOG_PROPERTY_COUNT"
|
||||
);
|
||||
let values = unsafe {
|
||||
std::slice::from_raw_parts(buffer.as_ptr().cast::<EVT_VARIANT>(), count as usize)
|
||||
};
|
||||
let provider = string(&values[EvtSystemProviderName as usize], &buffer, used)?;
|
||||
let channel = string(&values[EvtSystemChannel as usize], &buffer, used)?;
|
||||
ensure!(
|
||||
provider == PROVIDER && channel == CHANNEL,
|
||||
"EVENT_LOG_SOURCE_MISMATCH"
|
||||
);
|
||||
let record = &values[EvtSystemEventRecordId as usize];
|
||||
let time = &values[EvtSystemTimeCreated as usize];
|
||||
let id = &values[EvtSystemEventID as usize];
|
||||
ensure!(
|
||||
record.Type == EvtVarTypeUInt64 as u32
|
||||
&& time.Type == EvtVarTypeFileTime as u32
|
||||
&& id.Type == EvtVarTypeUInt16 as u32,
|
||||
"EVENT_LOG_PROPERTY_TYPE"
|
||||
);
|
||||
let record_id = unsafe { record.Anonymous.UInt64Val };
|
||||
let ticks = unsafe { time.Anonymous.FileTimeVal };
|
||||
let unix_ticks = ticks
|
||||
.checked_sub(116_444_736_000_000_000)
|
||||
.context("EVENT_LOG_TIMESTAMP")?;
|
||||
let created_utc = DateTime::from_timestamp(
|
||||
i64::try_from(unix_ticks / 10_000_000)?,
|
||||
((unix_ticks % 10_000_000) * 100) as u32,
|
||||
)
|
||||
.context("EVENT_LOG_TIMESTAMP")?;
|
||||
ensure!(
|
||||
record_id > 0 && created_utc >= q.start_utc && created_utc < q.end_utc,
|
||||
"EVENT_LOG_RECORD_WINDOW"
|
||||
);
|
||||
let (xml, bytes, _) = render(
|
||||
0,
|
||||
event,
|
||||
EvtRenderEventXml,
|
||||
(q.max_output_bytes as usize).min(64 * 1024),
|
||||
until,
|
||||
cancelled,
|
||||
)?;
|
||||
ensure!(bytes >= 2 && bytes.is_multiple_of(2), "EVENT_LOG_XML_SIZE");
|
||||
let units = unsafe { std::slice::from_raw_parts(xml.as_ptr().cast::<u16>(), bytes / 2) };
|
||||
ensure!(
|
||||
units.last() == Some(&0) && !units[..units.len() - 1].contains(&0),
|
||||
"EVENT_LOG_XML_TERMINATOR"
|
||||
);
|
||||
Ok(Event {
|
||||
channel,
|
||||
provider,
|
||||
record_id,
|
||||
event_id: unsafe { id.Anonymous.UInt16Val },
|
||||
created_utc,
|
||||
xml: String::from_utf16(&units[..units.len() - 1])?,
|
||||
})
|
||||
}
|
||||
pub(super) fn query(q: &Query, xpath: &str, cancelled: &AtomicBool) -> Result<Report> {
|
||||
let mut report = Report::new(q);
|
||||
let until = Instant::now() + Duration::from_millis(q.timeout_ms as u64);
|
||||
if stopped(&mut report, cancelled, until) {
|
||||
return Ok(report);
|
||||
}
|
||||
let channel = wide(CHANNEL);
|
||||
let expression = wide(xpath);
|
||||
let handle = Handle(unsafe {
|
||||
EvtQuery(
|
||||
0,
|
||||
channel.as_ptr(),
|
||||
expression.as_ptr(),
|
||||
EvtQueryChannelPath | EvtQueryForwardDirection,
|
||||
)
|
||||
});
|
||||
if handle.0 == 0 {
|
||||
failure(&mut report, unsafe { GetLastError() });
|
||||
return Ok(report);
|
||||
}
|
||||
if stopped(&mut report, cancelled, until) {
|
||||
return Ok(report);
|
||||
}
|
||||
let context =
|
||||
Handle(unsafe { EvtCreateRenderContext(0, ptr::null(), EvtRenderContextSystem) });
|
||||
if context.0 == 0 {
|
||||
failure(&mut report, unsafe { GetLastError() });
|
||||
return Ok(report);
|
||||
}
|
||||
loop {
|
||||
if stopped(&mut report, cancelled, until) {
|
||||
break;
|
||||
}
|
||||
if report.events.len() >= q.max_events as usize {
|
||||
report.stop("EVENT_LOG_EVENT_LIMIT", None);
|
||||
break;
|
||||
}
|
||||
let mut event = 0;
|
||||
let mut returned = 0;
|
||||
let timeout = until
|
||||
.saturating_duration_since(Instant::now())
|
||||
.as_millis()
|
||||
.min(100) as u32;
|
||||
let ok = unsafe { EvtNext(handle.0, 1, &mut event, timeout, 0, &mut returned) };
|
||||
let error = if ok == 0 {
|
||||
unsafe { GetLastError() }
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let event = Handle(event);
|
||||
if stopped(&mut report, cancelled, until) {
|
||||
break;
|
||||
}
|
||||
if ok == 0 {
|
||||
if error == ERROR_NO_MORE_ITEMS {
|
||||
report.completeness = "complete";
|
||||
break;
|
||||
}
|
||||
if error == ERROR_TIMEOUT {
|
||||
continue;
|
||||
}
|
||||
failure(&mut report, error);
|
||||
break;
|
||||
}
|
||||
ensure!(returned == 1 && event.0 != 0, "EVENT_LOG_NEXT_COUNT");
|
||||
let record = read_event(context.0, event.0, q, until, cancelled);
|
||||
if stopped(&mut report, cancelled, until) {
|
||||
break;
|
||||
}
|
||||
match record {
|
||||
Ok(record) => {
|
||||
if !report.push(record, q.max_output_bytes as usize)? {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(error) => {
|
||||
if let Some(code) = error
|
||||
.downcast_ref::<std::io::Error>()
|
||||
.and_then(std::io::Error::raw_os_error)
|
||||
{
|
||||
if code as u32 == ERROR_INSUFFICIENT_BUFFER {
|
||||
report.stop("EVENT_LOG_EVENT_SIZE_LIMIT", None)
|
||||
} else {
|
||||
failure(&mut report, code as u32)
|
||||
}
|
||||
} else {
|
||||
report.quality = "error";
|
||||
report.stop("EVENT_LOG_RENDER_OR_RECORD_INVALID", None)
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
ensure!(
|
||||
serde_json::to_vec(&report)?.len() <= q.max_output_bytes as usize,
|
||||
"EVENT_LOG_REPORT_LIMIT"
|
||||
);
|
||||
Ok(report)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn request() -> Query {
|
||||
let start_utc = DateTime::from_timestamp(1_700_000_000, 0).unwrap();
|
||||
Query {
|
||||
channel: CHANNEL.into(),
|
||||
provider: PROVIDER.into(),
|
||||
start_utc,
|
||||
end_utc: start_utc + chrono::Duration::minutes(5),
|
||||
max_events: 1000,
|
||||
max_output_bytes: 4096,
|
||||
timeout_ms: 1000,
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn only_fixed_source_window_and_finite_limits_are_queryable() {
|
||||
let q = request();
|
||||
let expression = q.xpath().unwrap();
|
||||
assert!(expression.len() < 512);
|
||||
assert!(expression.contains(PROVIDER));
|
||||
for case in 0..7 {
|
||||
let mut q = request();
|
||||
match case {
|
||||
0 => q.channel = "Security".into(),
|
||||
1 => q.provider = "' or 1=1".into(),
|
||||
2 => q.end_utc = q.start_utc,
|
||||
3 => q.end_utc = q.start_utc + chrono::Duration::hours(25),
|
||||
4 => q.max_events = 1001,
|
||||
5 => q.max_output_bytes = MAX_BYTES as u32 + 1,
|
||||
_ => q.timeout_ms = 5001,
|
||||
};
|
||||
assert!(q.xpath().is_err());
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn serialized_byte_budget_includes_xml_escaping_and_metadata() {
|
||||
let q = request();
|
||||
let mut report = Report::new(&q);
|
||||
assert!(
|
||||
!report
|
||||
.push(
|
||||
Event {
|
||||
channel: CHANNEL.into(),
|
||||
provider: PROVIDER.into(),
|
||||
record_id: 1,
|
||||
event_id: 1,
|
||||
created_utc: q.start_utc,
|
||||
xml: "\"\\".repeat(2048)
|
||||
},
|
||||
q.max_output_bytes as usize
|
||||
)
|
||||
.unwrap()
|
||||
);
|
||||
assert!(report.events.is_empty());
|
||||
assert!(report.truncated);
|
||||
assert_eq!(report.error_code, Some("EVENT_LOG_BYTE_LIMIT"));
|
||||
assert!(serde_json::to_vec(&report).unwrap().len() <= q.max_output_bytes as usize);
|
||||
assert!(!report.bookmark_updated);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user