Implement bounded Windows Event Log jobs and verify contracts on cloud Linux
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -33,8 +33,8 @@ impl Binding {
|
||||
);
|
||||
ensure!(
|
||||
j.action.validate()
|
||||
&& (1..=3600).contains(&j.max_runtime_seconds)
|
||||
&& (1..=262144).contains(&j.max_output_bytes)
|
||||
&& j.action
|
||||
.valid_job_limits(j.max_runtime_seconds, j.max_output_bytes)
|
||||
&& j.not_before < j.start_before,
|
||||
"INVALID_JOB"
|
||||
);
|
||||
|
||||
@@ -201,6 +201,39 @@ fn exact_permit_bytes_time_and_all_identity_hash_bindings_are_required() {
|
||||
request.permit_bytes = encode(&permit).unwrap();
|
||||
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
|
||||
binding.verify(&request, now).unwrap();
|
||||
// The exact fixed Event Log source/window/limits are original signed bytes.
|
||||
job.action = Action::QueryLogs {
|
||||
unit: rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: now - chrono::Duration::hours(1),
|
||||
until: now,
|
||||
max_lines: 1000,
|
||||
};
|
||||
request.job_bytes = encode(&job).unwrap();
|
||||
permit.action = job.action.name().into();
|
||||
permit.job_payload_hash = hash(&request.job_bytes);
|
||||
request.permit_bytes = encode(&permit).unwrap();
|
||||
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
|
||||
binding.verify(&request, now).unwrap();
|
||||
let mut wrong_source = job.clone();
|
||||
if let Action::QueryLogs { unit, .. } = &mut wrong_source.action {
|
||||
*unit = "Security".into();
|
||||
}
|
||||
let mut changed = request.clone();
|
||||
changed.job_bytes = encode(&wrong_source).unwrap();
|
||||
assert!(binding.verify(&changed, now).is_err());
|
||||
for (runtime, bytes) in [(9, 4096), (121, 4096), (10, 1023), (10, 65537)] {
|
||||
let mut changed_job = job.clone();
|
||||
changed_job.max_runtime_seconds = runtime;
|
||||
changed_job.max_output_bytes = bytes;
|
||||
let mut changed_permit = permit.clone();
|
||||
changed_permit.max_runtime_seconds = runtime;
|
||||
let mut changed = request.clone();
|
||||
changed.job_bytes = encode(&changed_job).unwrap();
|
||||
changed_permit.job_payload_hash = hash(&changed.job_bytes);
|
||||
changed.permit_bytes = encode(&changed_permit).unwrap();
|
||||
changed.signature = key.sign(&changed.permit_bytes).to_bytes().to_vec();
|
||||
assert!(binding.verify(&changed, now).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
|
||||
@@ -39,4 +39,4 @@ rcgen = { version = "=0.14.10", default-features = false, features = ["crypto",
|
||||
cc = "=1.11.1"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] }
|
||||
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_EventLog", "Win32_System_Diagnostics_ToolHelp", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] }
|
||||
|
||||
@@ -71,10 +71,45 @@ pub fn supported(job: &JobPayload) -> bool {
|
||||
interpreter == "powershell" && powershell().is_ok()
|
||||
}
|
||||
Action::RefreshInventory { scope } => scope == "windows.base",
|
||||
Action::QueryLogs { .. } => crate::event_log::for_job(job).is_ok(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Each prepared operation retains its own typed binding; no non-script action
|
||||
/// can fall through to inventory or borrow the PowerShell execution profile.
|
||||
pub enum PreparedAction {
|
||||
Script(Script),
|
||||
Inventory,
|
||||
EventLog(crate::event_log_job::Prepared),
|
||||
}
|
||||
impl PreparedAction {
|
||||
pub fn prepare(
|
||||
job: &JobPayload,
|
||||
directory: &Path,
|
||||
grant: uuid::Uuid,
|
||||
request: &rmm_agent_core::auth::Request,
|
||||
boot: uuid::Uuid,
|
||||
) -> Result<Self> {
|
||||
ensure!(supported(job), "UNSUPPORTED_CAPABILITY");
|
||||
match &job.action {
|
||||
Action::RunScript { .. } => Ok(Self::Script(Script::prepare(job, directory, grant)?)),
|
||||
Action::RefreshInventory { scope } if scope == "windows.base" => Ok(Self::Inventory),
|
||||
Action::QueryLogs { .. } => Ok(Self::EventLog(
|
||||
crate::event_log_job::Prepared::prepare(job, directory, request, grant, boot)?,
|
||||
)),
|
||||
_ => anyhow::bail!("UNSUPPORTED_CAPABILITY"),
|
||||
}
|
||||
}
|
||||
pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result<Outcome> {
|
||||
match self {
|
||||
Self::Script(script) => script.run(job, cancel),
|
||||
Self::Inventory => inventory(job),
|
||||
Self::EventLog(log) => log.run(job, cancel),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Script {
|
||||
executable: PathBuf,
|
||||
path: PathBuf,
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
//! Bounded, local, fixture-only live Event Log query; not wired into any job.
|
||||
//! Bounded, local, fixture-only Event Log provider. Only the authorized native
|
||||
//! job worker may call the Windows provider; this module confers no authority.
|
||||
//!
|
||||
//! EvtQuery/EvtRender have no per-call timeout. The monotonic deadline below is
|
||||
//! cooperative between Win32 calls; the eventual executor must also supervise
|
||||
@@ -12,8 +13,9 @@ 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";
|
||||
pub use rmm_domain::jobs::{
|
||||
WINDOWS_EVENT_LOG_FIXTURE_CHANNEL as CHANNEL, WINDOWS_EVENT_LOG_FIXTURE_PROVIDER as PROVIDER,
|
||||
};
|
||||
const MAX_BYTES: usize = 256 * 1024;
|
||||
#[cfg(any(windows, test))]
|
||||
const REPORT_RESERVE: usize = 256;
|
||||
@@ -57,7 +59,42 @@ impl Query {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
/// Pure job-to-provider binding. Never opens a channel or touches a bookmark.
|
||||
pub fn for_job(job: &rmm_domain::jobs::JobPayload) -> Result<Query> {
|
||||
use rmm_domain::jobs::{Action, WINDOWS_EVENT_LOG_FIXTURE_SOURCE};
|
||||
let Action::QueryLogs {
|
||||
unit,
|
||||
since,
|
||||
until,
|
||||
max_lines,
|
||||
} = &job.action
|
||||
else {
|
||||
anyhow::bail!("EVENT_LOG_ACTION_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
job.execution_identity == "agent_service"
|
||||
&& unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE
|
||||
&& job.action.validate()
|
||||
&& job
|
||||
.action
|
||||
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes),
|
||||
"EVENT_LOG_JOB_BINDING"
|
||||
);
|
||||
let q = Query {
|
||||
channel: CHANNEL.into(),
|
||||
provider: PROVIDER.into(),
|
||||
start_utc: *since,
|
||||
end_utc: *until,
|
||||
max_events: *max_lines,
|
||||
max_output_bytes: job.max_output_bytes,
|
||||
timeout_ms: 5000,
|
||||
};
|
||||
q.xpath()?;
|
||||
Ok(q)
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Event {
|
||||
pub channel: String,
|
||||
pub provider: String,
|
||||
@@ -501,6 +538,53 @@ mod tests {
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn job_mapping_is_only_fixed_unprivileged_live_logs_with_exact_limits() {
|
||||
use rmm_domain::jobs::{Action, JobPayload, WINDOWS_EVENT_LOG_FIXTURE_SOURCE};
|
||||
let id = uuid::Uuid::new_v4();
|
||||
let now = DateTime::from_timestamp(1_700_000_000, 0).unwrap();
|
||||
let mut job = JobPayload {
|
||||
schema_version: 1,
|
||||
tenant_id: id,
|
||||
asset_id: id,
|
||||
agent_id: id,
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 1,
|
||||
job_id: id,
|
||||
attempt_id: id,
|
||||
action: Action::QueryLogs {
|
||||
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: now,
|
||||
until: now + chrono::Duration::hours(24),
|
||||
max_lines: 1000,
|
||||
},
|
||||
execution_identity: "agent_service".into(),
|
||||
not_before: now,
|
||||
start_before: now + chrono::Duration::seconds(60),
|
||||
max_runtime_seconds: 10,
|
||||
max_output_bytes: 65536,
|
||||
};
|
||||
let q = for_job(&job).unwrap();
|
||||
assert_eq!(
|
||||
(q.channel.as_str(), q.provider.as_str()),
|
||||
(CHANNEL, PROVIDER)
|
||||
);
|
||||
assert_eq!(q.max_output_bytes, 65536);
|
||||
for identity in ["root", "system"] {
|
||||
job.execution_identity = identity.into();
|
||||
assert!(for_job(&job).is_err());
|
||||
}
|
||||
job.execution_identity = "agent_service".into();
|
||||
for bytes in [1023, 65537] {
|
||||
job.max_output_bytes = bytes;
|
||||
assert!(for_job(&job).is_err());
|
||||
}
|
||||
job.max_output_bytes = 65536;
|
||||
if let Action::QueryLogs { until, .. } = &mut job.action {
|
||||
*until += chrono::Duration::nanoseconds(1);
|
||||
}
|
||||
assert!(for_job(&job).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn serialized_byte_budget_includes_xml_escaping_and_metadata() {
|
||||
let q = request();
|
||||
let mut report = Report::new(&q);
|
||||
|
||||
@@ -0,0 +1,778 @@
|
||||
//! Fixed, authorized Event Log subprocess. A command-line mode is not a live
|
||||
//! query API: the child authenticates its real SCM parent, original signed
|
||||
//! request, protected public trust, and an already committed consumption/start.
|
||||
//! Request/grant bytes remain in a private, create-once job file, never argv.
|
||||
use crate::{event_log, native};
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use rmm_agent_core::auth::{Binding, Outcome, Request};
|
||||
use rmm_domain::jobs::{ExecutionPermitPayload, JobPayload, hash};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
fs::{File, OpenOptions},
|
||||
io::{Read, Write},
|
||||
mem::{size_of, size_of_val, zeroed},
|
||||
os::windows::{
|
||||
fs::OpenOptionsExt,
|
||||
io::{AsRawHandle, FromRawHandle, OwnedHandle},
|
||||
},
|
||||
path::{Path, PathBuf},
|
||||
ptr,
|
||||
sync::atomic::AtomicBool,
|
||||
time::Duration,
|
||||
};
|
||||
use uuid::Uuid;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::*,
|
||||
Security::{self, *},
|
||||
Storage::FileSystem::*,
|
||||
System::{Diagnostics::ToolHelp::*, Services::*, Threading::*},
|
||||
};
|
||||
|
||||
pub const MODE: &str = "--eventlog-worker";
|
||||
const CONFIG: &str = r"C:\ProgramData\RustDiscovery\config.json";
|
||||
const TICKET_LIMIT: u64 = 128 * 1024;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct FileId {
|
||||
volume: u64,
|
||||
id: [u8; 16],
|
||||
}
|
||||
fn file_id(handle: HANDLE) -> Result<FileId> {
|
||||
let mut info: FILE_ID_INFO = unsafe { zeroed() };
|
||||
ensure!(
|
||||
unsafe {
|
||||
GetFileInformationByHandleEx(
|
||||
handle,
|
||||
FileIdInfo,
|
||||
(&mut info as *mut FILE_ID_INFO).cast(),
|
||||
size_of::<FILE_ID_INFO>() as u32,
|
||||
)
|
||||
} != 0,
|
||||
"EVENT_LOG_FILE_ID"
|
||||
);
|
||||
Ok(FileId {
|
||||
volume: info.VolumeSerialNumber,
|
||||
id: info.FileId.Identifier,
|
||||
})
|
||||
}
|
||||
fn owned(handle: HANDLE) -> Result<OwnedHandle> {
|
||||
ensure!(
|
||||
!handle.is_null() && handle != INVALID_HANDLE_VALUE,
|
||||
"EVENT_LOG_HANDLE"
|
||||
);
|
||||
Ok(unsafe { OwnedHandle::from_raw_handle(handle) })
|
||||
}
|
||||
fn birth(handle: HANDLE) -> Result<u64> {
|
||||
let (mut c, mut e, mut k, mut u) = unsafe { (zeroed(), zeroed(), zeroed(), zeroed()) };
|
||||
ensure!(
|
||||
unsafe { GetProcessTimes(handle, &mut c, &mut e, &mut k, &mut u) } != 0,
|
||||
"EVENT_LOG_PROCESS_TIME"
|
||||
);
|
||||
Ok((u64::from(c.dwHighDateTime) << 32) | u64::from(c.dwLowDateTime))
|
||||
}
|
||||
fn text(value: *const u16) -> Result<String> {
|
||||
ensure!(!value.is_null(), "EVENT_LOG_NATIVE_STRING");
|
||||
let mut length = 0;
|
||||
while length < 32768 && unsafe { *value.add(length) } != 0 {
|
||||
length += 1;
|
||||
}
|
||||
ensure!(length < 32768, "EVENT_LOG_NATIVE_STRING_SIZE");
|
||||
Ok(String::from_utf16(unsafe {
|
||||
std::slice::from_raw_parts(value, length)
|
||||
})?)
|
||||
}
|
||||
fn process_image(handle: HANDLE) -> Result<PathBuf> {
|
||||
let mut buffer = vec![0u16; 32768];
|
||||
let mut len = buffer.len() as u32;
|
||||
ensure!(
|
||||
unsafe { QueryFullProcessImageNameW(handle, 0, buffer.as_mut_ptr(), &mut len) } != 0,
|
||||
"EVENT_LOG_PARENT_IMAGE"
|
||||
);
|
||||
Ok(String::from_utf16(&buffer[..len as usize])?.into())
|
||||
}
|
||||
struct Service(SC_HANDLE);
|
||||
impl Drop for Service {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
CloseServiceHandle(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn agent_pid(image: &Path) -> Result<u32> {
|
||||
let manager = Service(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
|
||||
ensure!(!manager.0.is_null(), "EVENT_LOG_SCM");
|
||||
let service = Service(unsafe {
|
||||
OpenServiceW(
|
||||
manager.0,
|
||||
native::wide(crate::SERVICE_NAME).as_ptr(),
|
||||
SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS,
|
||||
)
|
||||
});
|
||||
ensure!(!service.0.is_null(), "EVENT_LOG_AGENT_SERVICE");
|
||||
let mut bytes = 0;
|
||||
unsafe {
|
||||
QueryServiceConfigW(service.0, ptr::null_mut(), 0, &mut bytes);
|
||||
}
|
||||
ensure!((1..=32768).contains(&bytes), "EVENT_LOG_AGENT_CONFIG_SIZE");
|
||||
let mut storage = vec![0usize; (bytes as usize).div_ceil(size_of::<usize>())];
|
||||
ensure!(
|
||||
unsafe { QueryServiceConfigW(service.0, storage.as_mut_ptr().cast(), bytes, &mut bytes) }
|
||||
!= 0,
|
||||
"EVENT_LOG_AGENT_CONFIG"
|
||||
);
|
||||
let config = unsafe { &*storage.as_ptr().cast::<QUERY_SERVICE_CONFIGW>() };
|
||||
ensure!(
|
||||
config.dwServiceType == SERVICE_WIN32_OWN_PROCESS
|
||||
&& text(config.lpBinaryPathName)?
|
||||
== format!("\"{}\" --service --config \"{CONFIG}\"", image.display())
|
||||
&& text(config.lpServiceStartName)?.eq_ignore_ascii_case(r"NT AUTHORITY\LocalService"),
|
||||
"EVENT_LOG_AGENT_CONFIG_BINDING"
|
||||
);
|
||||
let mut status: SERVICE_STATUS_PROCESS = unsafe { zeroed() };
|
||||
ensure!(
|
||||
unsafe {
|
||||
QueryServiceStatusEx(
|
||||
service.0,
|
||||
SC_STATUS_PROCESS_INFO,
|
||||
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
|
||||
size_of::<SERVICE_STATUS_PROCESS>() as u32,
|
||||
&mut bytes,
|
||||
)
|
||||
} != 0
|
||||
&& status.dwCurrentState == SERVICE_RUNNING
|
||||
&& status.dwProcessId > 0,
|
||||
"EVENT_LOG_AGENT_NOT_RUNNING"
|
||||
);
|
||||
Ok(status.dwProcessId)
|
||||
}
|
||||
fn token_info(token: HANDLE, class: TOKEN_INFORMATION_CLASS) -> Result<Vec<usize>> {
|
||||
let mut bytes = 0;
|
||||
unsafe {
|
||||
GetTokenInformation(token, class, ptr::null_mut(), 0, &mut bytes);
|
||||
}
|
||||
ensure!((1..=65536).contains(&bytes), "EVENT_LOG_TOKEN_SIZE");
|
||||
let mut data = vec![0usize; (bytes as usize).div_ceil(size_of::<usize>())];
|
||||
ensure!(
|
||||
unsafe { GetTokenInformation(token, class, data.as_mut_ptr().cast(), bytes, &mut bytes) }
|
||||
!= 0,
|
||||
"EVENT_LOG_TOKEN"
|
||||
);
|
||||
Ok(data)
|
||||
}
|
||||
fn service_token(process: HANDLE) -> Result<()> {
|
||||
let mut token = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { OpenProcessToken(process, TOKEN_QUERY, &mut token) } != 0,
|
||||
"EVENT_LOG_TOKEN_OPEN"
|
||||
);
|
||||
let token = owned(token)?;
|
||||
let user = token_info(token.as_raw_handle(), TokenUser)?;
|
||||
let mut service_sid = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe {
|
||||
Security::Authorization::ConvertStringSidToSidW(
|
||||
native::wide(native::service_sid()?).as_ptr(),
|
||||
&mut service_sid,
|
||||
)
|
||||
} != 0,
|
||||
"EVENT_LOG_SERVICE_SID"
|
||||
);
|
||||
struct Sid(PSID);
|
||||
impl Drop for Sid {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
LocalFree(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let service_sid = Sid(service_sid);
|
||||
let mut ls = [0usize; 16];
|
||||
let mut size = size_of_val(&ls) as u32;
|
||||
ensure!(
|
||||
unsafe {
|
||||
CreateWellKnownSid(
|
||||
WinLocalServiceSid,
|
||||
ptr::null_mut(),
|
||||
ls.as_mut_ptr().cast(),
|
||||
&mut size,
|
||||
)
|
||||
} != 0
|
||||
&& unsafe {
|
||||
EqualSid(
|
||||
(*user.as_ptr().cast::<TOKEN_USER>()).User.Sid,
|
||||
ls.as_ptr().cast_mut().cast(),
|
||||
)
|
||||
} != 0,
|
||||
"EVENT_LOG_LOCAL_SERVICE_REQUIRED"
|
||||
);
|
||||
let groups = token_info(token.as_raw_handle(), TokenGroups)?;
|
||||
let g = unsafe { &*groups.as_ptr().cast::<TOKEN_GROUPS>() };
|
||||
let offset = std::mem::offset_of!(TOKEN_GROUPS, Groups);
|
||||
ensure!(
|
||||
g.GroupCount <= 1024
|
||||
&& offset + g.GroupCount as usize * size_of::<SID_AND_ATTRIBUTES>()
|
||||
<= groups.len() * size_of::<usize>(),
|
||||
"EVENT_LOG_TOKEN_GROUPS_SIZE"
|
||||
);
|
||||
let entries = unsafe { std::slice::from_raw_parts(g.Groups.as_ptr(), g.GroupCount as usize) };
|
||||
let mut admins = [0usize; 16];
|
||||
let mut admin_bytes = size_of_val(&admins) as u32;
|
||||
ensure!(
|
||||
unsafe {
|
||||
CreateWellKnownSid(
|
||||
WinBuiltinAdministratorsSid,
|
||||
ptr::null_mut(),
|
||||
admins.as_mut_ptr().cast(),
|
||||
&mut admin_bytes,
|
||||
)
|
||||
} != 0,
|
||||
"EVENT_LOG_ADMIN_SID"
|
||||
);
|
||||
ensure!(
|
||||
!entries
|
||||
.iter()
|
||||
.any(|entry| entry.Attributes & 0x0000_0004 != 0
|
||||
&& unsafe { EqualSid(entry.Sid, admins.as_ptr().cast_mut().cast()) } != 0),
|
||||
"EVENT_LOG_ADMINISTRATOR_FORBIDDEN"
|
||||
);
|
||||
// TOKEN_GROUPS enabled/deny-only bits from winnt.h, as in the pipe peer proof.
|
||||
ensure!(
|
||||
entries
|
||||
.iter()
|
||||
.any(|entry| entry.Attributes & 0x0000_0004 != 0
|
||||
&& entry.Attributes & 0x0000_0010 == 0
|
||||
&& unsafe { EqualSid(entry.Sid, service_sid.0) } != 0),
|
||||
"EVENT_LOG_AGENT_SID_REQUIRED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn parent_pid() -> Result<u32> {
|
||||
let snapshot = owned(unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) })?;
|
||||
let mut entry: PROCESSENTRY32W = unsafe { zeroed() };
|
||||
entry.dwSize = size_of::<PROCESSENTRY32W>() as u32;
|
||||
let mut ok = unsafe { Process32FirstW(snapshot.as_raw_handle(), &mut entry) };
|
||||
while ok != 0 {
|
||||
if entry.th32ProcessID == std::process::id() {
|
||||
return Ok(entry.th32ParentProcessID);
|
||||
}
|
||||
ok = unsafe { Process32NextW(snapshot.as_raw_handle(), &mut entry) };
|
||||
}
|
||||
anyhow::bail!("EVENT_LOG_PARENT_UNVERIFIED")
|
||||
}
|
||||
fn open_private(path: &Path, share_write: bool) -> Result<File> {
|
||||
ensure!(
|
||||
path.is_absolute() && !path.to_string_lossy().starts_with(r"\\"),
|
||||
"EVENT_LOG_LOCAL_PATH"
|
||||
);
|
||||
for parent in path.ancestors().skip(1) {
|
||||
use std::os::windows::fs::MetadataExt;
|
||||
ensure!(
|
||||
std::fs::symlink_metadata(parent)?.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT
|
||||
== 0,
|
||||
"EVENT_LOG_REPARSE_ANCESTOR"
|
||||
);
|
||||
}
|
||||
native::private_path(path, false)?;
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.share_mode(FILE_SHARE_READ | if share_write { FILE_SHARE_WRITE } else { 0 })
|
||||
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||
.open(path)?;
|
||||
use std::os::windows::fs::MetadataExt;
|
||||
ensure!(
|
||||
file.metadata()?.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT == 0,
|
||||
"EVENT_LOG_REPARSE_FILE"
|
||||
);
|
||||
Ok(file)
|
||||
}
|
||||
fn read(file: &mut File, limit: u64) -> Result<Vec<u8>> {
|
||||
ensure!(
|
||||
file.metadata()?.len() <= limit,
|
||||
"EVENT_LOG_PRIVATE_FILE_LIMIT"
|
||||
);
|
||||
let mut value = Vec::new();
|
||||
file.take(limit + 1).read_to_end(&mut value)?;
|
||||
ensure!(value.len() as u64 <= limit, "EVENT_LOG_PRIVATE_FILE_LIMIT");
|
||||
Ok(value)
|
||||
}
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Ticket {
|
||||
request: Request,
|
||||
parent_pid: u32,
|
||||
parent_birth: u64,
|
||||
boot: Uuid,
|
||||
ledger: FileId,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct WorkerConfig {
|
||||
state_directory: PathBuf,
|
||||
job_binding_file: PathBuf,
|
||||
enable_jobs: bool,
|
||||
}
|
||||
fn ticket_name(permit: &ExecutionPermitPayload) -> String {
|
||||
format!("eventlog-{}.json", hash(permit.grant_id.as_bytes()))
|
||||
}
|
||||
/// Prepared data only. No query, worker or Evt handle exists before run.
|
||||
pub struct Prepared {
|
||||
path: PathBuf,
|
||||
_file: File,
|
||||
ticket_hash: String,
|
||||
job_bytes: Vec<u8>,
|
||||
}
|
||||
impl Prepared {
|
||||
pub fn prepare(
|
||||
job: &JobPayload,
|
||||
directory: &Path,
|
||||
request: &Request,
|
||||
grant: Uuid,
|
||||
boot: Uuid,
|
||||
) -> Result<Self> {
|
||||
event_log::for_job(job)?;
|
||||
native::require_local_service()?;
|
||||
service_token(unsafe { GetCurrentProcess() })?;
|
||||
let image = std::env::current_exe()?;
|
||||
ensure!(
|
||||
agent_pid(&image)? == std::process::id(),
|
||||
"EVENT_LOG_REAL_AGENT_REQUIRED"
|
||||
);
|
||||
let permit: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes)?;
|
||||
ensure!(
|
||||
permit.grant_id == grant && !boot.is_nil(),
|
||||
"EVENT_LOG_GRANT_BINDING"
|
||||
);
|
||||
native::private_path(directory, true)?;
|
||||
let ledger = open_private(
|
||||
&directory
|
||||
.parent()
|
||||
.context("EVENT_LOG_STATE_DIRECTORY")?
|
||||
.join("consumption.sqlite"),
|
||||
true,
|
||||
)?;
|
||||
let ticket = Ticket {
|
||||
request: request.clone(),
|
||||
parent_pid: std::process::id(),
|
||||
parent_birth: birth(unsafe { GetCurrentProcess() })?,
|
||||
boot,
|
||||
ledger: file_id(ledger.as_raw_handle())?,
|
||||
};
|
||||
let bytes = serde_json::to_vec(&ticket)?;
|
||||
ensure!(bytes.len() as u64 <= TICKET_LIMIT, "EVENT_LOG_TICKET_LIMIT");
|
||||
let path = directory.join(ticket_name(&permit));
|
||||
let mut writer = OpenOptions::new()
|
||||
.create_new(true)
|
||||
.write(true)
|
||||
.share_mode(0)
|
||||
.open(&path)?;
|
||||
writer.write_all(&bytes)?;
|
||||
writer.sync_all()?;
|
||||
drop(writer);
|
||||
let mut file = open_private(&path, false)?;
|
||||
ensure!(
|
||||
read(&mut file, TICKET_LIMIT)? == bytes,
|
||||
"EVENT_LOG_TICKET_CHANGED"
|
||||
);
|
||||
Ok(Self {
|
||||
path,
|
||||
_file: file,
|
||||
ticket_hash: hash(&bytes),
|
||||
job_bytes: request.job_bytes.clone(),
|
||||
})
|
||||
}
|
||||
pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result<Outcome> {
|
||||
event_log::for_job(job)?;
|
||||
ensure!(
|
||||
serde_json::from_slice::<serde_json::Value>(&self.job_bytes)?
|
||||
== serde_json::to_value(job)?,
|
||||
"EVENT_LOG_JOB_CHANGED"
|
||||
);
|
||||
let mut file = open_private(&self.path, false)?;
|
||||
ensure!(
|
||||
hash(&read(&mut file, TICKET_LIMIT)?) == self.ticket_hash,
|
||||
"EVENT_LOG_TICKET_CHANGED"
|
||||
);
|
||||
let output = crate::process::run(
|
||||
&std::env::current_exe()?,
|
||||
&[MODE.into(), self.path.as_os_str().into()],
|
||||
self.path.parent().context("EVENT_LOG_JOB_DIRECTORY")?,
|
||||
job.max_runtime_seconds,
|
||||
job.max_output_bytes as usize,
|
||||
cancel,
|
||||
)?;
|
||||
if output.interrupted {
|
||||
return Ok(Outcome::unknown(if output.cancelled {
|
||||
"EVENT_LOG_CANCELLED_RESULT_UNKNOWN"
|
||||
} else {
|
||||
"EVENT_LOG_TIMEOUT_RESULT_UNKNOWN"
|
||||
}));
|
||||
}
|
||||
ensure!(
|
||||
output.exit_code == Some(0) && !output.truncated && output.stderr.is_empty(),
|
||||
"EVENT_LOG_WORKER_RESULT_UNVERIFIED"
|
||||
);
|
||||
outcome(job, output.stdout)
|
||||
}
|
||||
}
|
||||
|
||||
fn consumed(
|
||||
db: &rusqlite::Connection,
|
||||
binding: &Binding,
|
||||
ticket: &Ticket,
|
||||
permit: &ExecutionPermitPayload,
|
||||
) -> Result<()> {
|
||||
let length: u64 = db.query_row("SELECT length(e.start) FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1", [permit.grant_id.to_string()], |r| r.get(0))?;
|
||||
ensure!(length <= TICKET_LIMIT, "EVENT_LOG_START_SIZE");
|
||||
type Row = (String, u64, String, String, bool, Vec<u8>, bool);
|
||||
let row: Row = db.query_row("SELECT c.agent,c.generation,c.job,c.attempt,c.result IS NULL,e.start,e.outcome IS NULL FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",
|
||||
[permit.grant_id.to_string()], |r| Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?)))?;
|
||||
ensure!(
|
||||
row.0 == binding.agent_id.to_string()
|
||||
&& row.1 == binding.enrollment_generation
|
||||
&& row.2 == permit.job_id.to_string()
|
||||
&& row.3 == permit.attempt_id.to_string()
|
||||
&& row.4
|
||||
&& row.6,
|
||||
"EVENT_LOG_CONSUMPTION_BINDING"
|
||||
);
|
||||
let start: serde_json::Value = serde_json::from_slice(&row.5)?;
|
||||
ensure!(
|
||||
start["previous_boot_id"] == ticket.boot.to_string()
|
||||
&& serde_json::to_vec(&serde_json::from_value::<Request>(
|
||||
start["request"].clone()
|
||||
)?)? == serde_json::to_vec(&ticket.request)?,
|
||||
"EVENT_LOG_ORIGINAL_START_BINDING"
|
||||
);
|
||||
let identity: String = db.query_row(
|
||||
"SELECT identity FROM windows_binding WHERE length(identity)<=512",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(
|
||||
identity
|
||||
== format!(
|
||||
"{}:{}:{}:{}:{}",
|
||||
binding.tenant_id,
|
||||
binding.asset_id,
|
||||
binding.agent_id,
|
||||
binding.enrollment_generation,
|
||||
binding.assignment_version
|
||||
),
|
||||
"EVENT_LOG_LEDGER_BINDING"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn validate_ticket_path(path: &Path, directory: &Path) -> Result<()> {
|
||||
let name = path
|
||||
.file_name()
|
||||
.and_then(|s| s.to_str())
|
||||
.context("EVENT_LOG_TICKET_NAME")?;
|
||||
let hash_name = name
|
||||
.strip_prefix("eventlog-")
|
||||
.and_then(|s| s.strip_suffix(".json"))
|
||||
.context("EVENT_LOG_TICKET_NAME")?;
|
||||
ensure!(
|
||||
path.parent() == Some(directory)
|
||||
&& hash_name.len() == 64
|
||||
&& hash_name
|
||||
.bytes()
|
||||
.all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c)),
|
||||
"EVENT_LOG_TICKET_PATH_BINDING"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Internal mode admission. Failure emits only the main executable's fixed
|
||||
/// initialization error; no request, query XML or private Win32 error is logged.
|
||||
pub fn worker(path: &Path) -> Result<()> {
|
||||
native::require_local_service()?;
|
||||
service_token(unsafe { GetCurrentProcess() })?;
|
||||
let image = std::env::current_exe()?;
|
||||
let actual_parent = parent_pid()?;
|
||||
ensure!(
|
||||
agent_pid(&image)? == actual_parent,
|
||||
"EVENT_LOG_REAL_PARENT_REQUIRED"
|
||||
);
|
||||
let parent = owned(unsafe {
|
||||
OpenProcess(
|
||||
PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE,
|
||||
0,
|
||||
actual_parent,
|
||||
)
|
||||
})?;
|
||||
let parent_birth = birth(parent.as_raw_handle())?;
|
||||
ensure!(
|
||||
process_image(parent.as_raw_handle())? == image
|
||||
&& unsafe { WaitForSingleObject(parent.as_raw_handle(), 0) } == WAIT_TIMEOUT,
|
||||
"EVENT_LOG_PARENT_INSTANCE"
|
||||
);
|
||||
service_token(parent.as_raw_handle())?;
|
||||
crate::job_binding::check_admin_readonly(Path::new(CONFIG))?;
|
||||
let mut config_file = open_private(Path::new(CONFIG), false)?;
|
||||
let config: WorkerConfig = serde_json::from_slice(&read(&mut config_file, 32768)?)?;
|
||||
ensure!(
|
||||
config.enable_jobs && config.state_directory.is_absolute(),
|
||||
"EVENT_LOG_JOBS_NOT_ENABLED"
|
||||
);
|
||||
let directory = config.state_directory.join("jobs");
|
||||
native::private_path(&directory, true)?;
|
||||
validate_ticket_path(path, &directory)?;
|
||||
// Only the exact jobs leaf is read; PKI/keys and arbitrary private files
|
||||
// cannot be passed to this mode, even by another LocalService process.
|
||||
let mut ticket_file = open_private(path, false)?;
|
||||
let ticket: Ticket = serde_json::from_slice(&read(&mut ticket_file, TICKET_LIMIT)?)?;
|
||||
ensure!(
|
||||
ticket.parent_pid == actual_parent && ticket.parent_birth == parent_birth,
|
||||
"EVENT_LOG_PARENT_INSTANCE"
|
||||
);
|
||||
let binding = crate::job_binding::readonly_binding(&config.job_binding_file)?;
|
||||
let clock = crate::clock::NativeClock::new();
|
||||
let now = clock.now()?;
|
||||
let (job, permit) = binding.verify(&ticket.request, now - chrono::Duration::seconds(2))?;
|
||||
binding.verify(&ticket.request, now + chrono::Duration::seconds(2))?;
|
||||
let query = event_log::for_job(&job)?;
|
||||
let expected = config
|
||||
.state_directory
|
||||
.join("jobs")
|
||||
.join(ticket_name(&permit));
|
||||
ensure!(path == expected, "EVENT_LOG_TICKET_PATH_BINDING");
|
||||
let runtime = tokio::runtime::Runtime::new()?;
|
||||
ensure!(
|
||||
Uuid::parse_str(&runtime.block_on(native::boot_id())?)? == ticket.boot,
|
||||
"EVENT_LOG_ORIGINAL_BOOT_REQUIRED"
|
||||
);
|
||||
let ledger_path = config.state_directory.join("consumption.sqlite");
|
||||
let ledger_file = open_private(&ledger_path, true)?;
|
||||
ensure!(
|
||||
file_id(ledger_file.as_raw_handle())? == ticket.ledger,
|
||||
"EVENT_LOG_LEDGER_FILE_CHANGED"
|
||||
);
|
||||
let db = rusqlite::Connection::open_with_flags(
|
||||
&ledger_path,
|
||||
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
|
||||
)?;
|
||||
db.busy_timeout(Duration::from_millis(100))?;
|
||||
let mut sqlite_handle: HANDLE = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe {
|
||||
rusqlite::ffi::sqlite3_file_control(
|
||||
db.handle(),
|
||||
c"main".as_ptr(),
|
||||
rusqlite::ffi::SQLITE_FCNTL_WIN32_GET_HANDLE,
|
||||
(&mut sqlite_handle as *mut HANDLE).cast(),
|
||||
)
|
||||
} == rusqlite::ffi::SQLITE_OK
|
||||
&& file_id(sqlite_handle)? == ticket.ledger,
|
||||
"EVENT_LOG_CONNECTED_LEDGER_FILE"
|
||||
);
|
||||
db.execute_batch("PRAGMA query_only=ON; BEGIN;")?;
|
||||
consumed(&db, &binding, &ticket, &permit)?;
|
||||
// Per-grant durable CAS prevents worker re-entry after a lost child reply.
|
||||
let marker = path.with_extension("started");
|
||||
let mut once = OpenOptions::new()
|
||||
.create_new(true)
|
||||
.write(true)
|
||||
.share_mode(0)
|
||||
.open(&marker)?;
|
||||
once.write_all(b"event-log-dispatch-v1\n")?;
|
||||
once.sync_all()?;
|
||||
native::private_path(&marker, false)?;
|
||||
// File I/O, CIM and child scheduling cannot extend the signed start window.
|
||||
let now = clock.now()?;
|
||||
binding.verify(&ticket.request, now - chrono::Duration::seconds(2))?;
|
||||
binding.verify(&ticket.request, now + chrono::Duration::seconds(2))?;
|
||||
ensure!(
|
||||
agent_pid(&image)? == actual_parent
|
||||
&& birth(parent.as_raw_handle())? == ticket.parent_birth
|
||||
&& unsafe { WaitForSingleObject(parent.as_raw_handle(), 0) } == WAIT_TIMEOUT,
|
||||
"EVENT_LOG_PARENT_CHANGED"
|
||||
);
|
||||
consumed(&db, &binding, &ticket, &permit)?;
|
||||
let report = event_log::query(&query, &AtomicBool::new(false))?;
|
||||
let bytes = serde_json::to_vec(&report)?;
|
||||
ensure!(
|
||||
bytes.len() <= job.max_output_bytes as usize,
|
||||
"EVENT_LOG_OUTPUT_LIMIT"
|
||||
);
|
||||
std::io::stdout().lock().write_all(&bytes)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct WireReport {
|
||||
channel: String,
|
||||
provider: String,
|
||||
start_utc: DateTime<Utc>,
|
||||
end_utc: DateTime<Utc>,
|
||||
quality: String,
|
||||
completeness: String,
|
||||
truncated: bool,
|
||||
error_code: Option<String>,
|
||||
win32_error: Option<u32>,
|
||||
events: Vec<event_log::Event>,
|
||||
bookmark_updated: bool,
|
||||
deadline_enforcement: String,
|
||||
}
|
||||
fn outcome(job: &JobPayload, bytes: Vec<u8>) -> Result<Outcome> {
|
||||
let q = event_log::for_job(job)?;
|
||||
ensure!(
|
||||
bytes.len() <= q.max_output_bytes as usize,
|
||||
"EVENT_LOG_OUTPUT_LIMIT"
|
||||
);
|
||||
let report: WireReport = serde_json::from_slice(&bytes)?;
|
||||
ensure!(
|
||||
report.channel == q.channel
|
||||
&& report.provider == q.provider
|
||||
&& report.start_utc == q.start_utc
|
||||
&& report.end_utc == q.end_utc
|
||||
&& !report.bookmark_updated
|
||||
&& report.events.len() <= q.max_events as usize
|
||||
&& report.deadline_enforcement == "cooperative_between_win32_calls",
|
||||
"EVENT_LOG_REPORT_BINDING"
|
||||
);
|
||||
let mut ids = std::collections::BTreeSet::new();
|
||||
for event in &report.events {
|
||||
ensure!(
|
||||
event.channel == q.channel
|
||||
&& event.provider == q.provider
|
||||
&& event.record_id > 0
|
||||
&& ids.insert(event.record_id)
|
||||
&& event.created_utc >= q.start_utc
|
||||
&& event.created_utc < q.end_utc
|
||||
&& event.xml.len() <= 64 * 1024
|
||||
&& !event.xml.contains('\0'),
|
||||
"EVENT_LOG_EVENT_BINDING"
|
||||
);
|
||||
}
|
||||
let complete =
|
||||
report.completeness == "complete" && !report.truncated && report.error_code.is_none();
|
||||
let partial = report.completeness == "partial"
|
||||
&& report.truncated
|
||||
&& matches!(
|
||||
report.error_code.as_deref(),
|
||||
Some("EVENT_LOG_EVENT_LIMIT" | "EVENT_LOG_BYTE_LIMIT" | "EVENT_LOG_EVENT_SIZE_LIMIT")
|
||||
);
|
||||
let success =
|
||||
report.quality == "valid" && report.win32_error.is_none() && (complete || partial);
|
||||
let error =
|
||||
report
|
||||
.error_code
|
||||
.as_deref()
|
||||
.unwrap_or(if success { "" } else { "EVENT_LOG_INCOMPLETE" });
|
||||
Ok(Outcome {
|
||||
state: if success { "succeeded" } else { "failed" }.into(),
|
||||
stdout: bytes,
|
||||
stderr: vec![],
|
||||
exit_code: None,
|
||||
output_truncated: report.truncated,
|
||||
reboot_required: false,
|
||||
error_code: if success { String::new() } else { error.into() },
|
||||
evidence: serde_json::json!({"postconditions_passed":success,
|
||||
"source_id":rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE,
|
||||
"channel":q.channel,"provider":q.provider,"start_utc":q.start_utc,"end_utc":q.end_utc,
|
||||
"max_events":q.max_events,"max_output_bytes":q.max_output_bytes,
|
||||
"quality":report.quality,"completeness":report.completeness,"truncated":report.truncated,
|
||||
"error_code":report.error_code,"win32_error":report.win32_error,
|
||||
"bookmark_updated":false,"execution_sid":"S-1-5-19","process_tree_bounded":true,
|
||||
"cursor_status":"not_advanced_no_ack_contract","observed_at":Utc::now()}),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn job() -> JobPayload {
|
||||
let id = Uuid::new_v4();
|
||||
let now = DateTime::from_timestamp(1_700_000_000, 0).unwrap();
|
||||
JobPayload {
|
||||
schema_version: 1,
|
||||
tenant_id: id,
|
||||
asset_id: id,
|
||||
agent_id: id,
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 1,
|
||||
job_id: id,
|
||||
attempt_id: id,
|
||||
action: rmm_domain::jobs::Action::QueryLogs {
|
||||
unit: rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: now,
|
||||
until: now + chrono::Duration::minutes(5),
|
||||
max_lines: 2,
|
||||
},
|
||||
execution_identity: "agent_service".into(),
|
||||
not_before: now,
|
||||
start_before: now + chrono::Duration::seconds(60),
|
||||
max_runtime_seconds: 10,
|
||||
max_output_bytes: 4096,
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn ticket_pre_read_boundary_excludes_keys_siblings_and_noncanonical_leaves() {
|
||||
let directory = Path::new(r"C:\ProgramData\RustDiscovery\state\jobs");
|
||||
let leaf = format!("eventlog-{}.json", "a".repeat(64));
|
||||
assert!(validate_ticket_path(&directory.join(&leaf), directory).is_ok());
|
||||
for path in [
|
||||
PathBuf::from(r"C:\ProgramData\RustDiscovery\state\device-key.pem"),
|
||||
directory.join("..\\jobs").join(&leaf),
|
||||
directory.join(format!("eventlog-{}.json", "A".repeat(64))),
|
||||
directory.join(format!("eventlog-{}.json", "a".repeat(63))),
|
||||
directory.join(format!("eventlog-{}.json:stream", "a".repeat(64))),
|
||||
directory.join("other.json"),
|
||||
] {
|
||||
assert!(
|
||||
validate_ticket_path(&path, directory).is_err(),
|
||||
"{}",
|
||||
path.display()
|
||||
);
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn event_log_outcome_never_equates_valid_quality_with_complete_or_authorized_success() {
|
||||
let job = job();
|
||||
let q = event_log::for_job(&job).unwrap();
|
||||
let mut report = serde_json::json!({"channel":q.channel,"provider":q.provider,
|
||||
"start_utc":q.start_utc,"end_utc":q.end_utc,"quality":"valid",
|
||||
"completeness":"complete","truncated":false,"error_code":null,"win32_error":null,
|
||||
"events":[],"bookmark_updated":false,"deadline_enforcement":"cooperative_between_win32_calls"});
|
||||
assert_eq!(
|
||||
outcome(&job, serde_json::to_vec(&report).unwrap())
|
||||
.unwrap()
|
||||
.state,
|
||||
"succeeded"
|
||||
);
|
||||
for code in [
|
||||
"EVENT_LOG_TIME_LIMIT",
|
||||
"EVENT_LOG_CANCELLED",
|
||||
"EVENT_LOG_API_ERROR",
|
||||
] {
|
||||
let mut partial = report.clone();
|
||||
partial["truncated"] = true.into();
|
||||
partial["completeness"] = "unknown".into();
|
||||
partial["error_code"] = code.into();
|
||||
assert_eq!(
|
||||
outcome(&job, serde_json::to_vec(&partial).unwrap())
|
||||
.unwrap()
|
||||
.state,
|
||||
"failed"
|
||||
);
|
||||
}
|
||||
report["truncated"] = true.into();
|
||||
report["completeness"] = "partial".into();
|
||||
report["error_code"] = "EVENT_LOG_BYTE_LIMIT".into();
|
||||
let bounded = outcome(&job, serde_json::to_vec(&report).unwrap()).unwrap();
|
||||
assert_eq!(bounded.state, "succeeded");
|
||||
assert!(bounded.output_truncated);
|
||||
report["quality"] = "permission_denied".into();
|
||||
report["win32_error"] = 5.into();
|
||||
assert_eq!(
|
||||
outcome(&job, serde_json::to_vec(&report).unwrap())
|
||||
.unwrap()
|
||||
.state,
|
||||
"failed"
|
||||
);
|
||||
report["provider"] = "another-provider".into();
|
||||
assert!(outcome(&job, serde_json::to_vec(&report).unwrap()).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
//! Shared protected public signing binding; never learns trust from a worker ticket.
|
||||
use crate::native;
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rmm_agent_core::auth::Binding;
|
||||
use std::path::Path;
|
||||
fn read_private(path: &Path, limit: u64) -> Result<Vec<u8>> {
|
||||
use std::{fs::OpenOptions, io::Read, os::windows::fs::OpenOptionsExt};
|
||||
use windows_sys::Win32::Storage::FileSystem::{FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_READ};
|
||||
native::private_path(path, false)?;
|
||||
let mut file = OpenOptions::new()
|
||||
.read(true)
|
||||
.share_mode(FILE_SHARE_READ)
|
||||
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||
.open(path)?;
|
||||
ensure!(file.metadata()?.len() <= limit, "BINDING_SIZE");
|
||||
let mut bytes = Vec::new();
|
||||
(&mut file).take(limit + 1).read_to_end(&mut bytes)?;
|
||||
ensure!(bytes.len() as u64 <= limit, "BINDING_SIZE");
|
||||
Ok(bytes)
|
||||
}
|
||||
pub fn check_admin_readonly(path: &Path) -> Result<()> {
|
||||
use std::ptr;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::LocalFree,
|
||||
Security::{
|
||||
self, ACCESS_ALLOWED_ACE, ACL,
|
||||
Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT},
|
||||
DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION,
|
||||
},
|
||||
};
|
||||
unsafe fn sid(sid: Security::PSID) -> Result<String> {
|
||||
let mut raw = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { ConvertSidToStringSidW(sid, &mut raw) } != 0,
|
||||
"BINDING_SID"
|
||||
);
|
||||
let mut len = 0;
|
||||
while unsafe { *raw.add(len) } != 0 {
|
||||
len += 1;
|
||||
ensure!(len < 256, "BINDING_SID_LIMIT");
|
||||
}
|
||||
let value = String::from_utf16(unsafe { std::slice::from_raw_parts(raw, len) })?;
|
||||
unsafe {
|
||||
LocalFree(raw.cast());
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
ensure!(path.is_absolute(), "ABSOLUTE_JOB_BINDING_REQUIRED");
|
||||
// The immediate configuration directory must also deny agent replacement.
|
||||
for (item, directory) in [
|
||||
(path, false),
|
||||
(path.parent().context("BINDING_PARENT")?, true),
|
||||
] {
|
||||
native::private_path(item, directory)?;
|
||||
let mut owner = ptr::null_mut();
|
||||
let mut dacl: *mut ACL = ptr::null_mut();
|
||||
let mut descriptor = ptr::null_mut();
|
||||
let status = unsafe {
|
||||
GetNamedSecurityInfoW(
|
||||
native::wide(item).as_ptr(),
|
||||
SE_FILE_OBJECT,
|
||||
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
|
||||
&mut owner,
|
||||
ptr::null_mut(),
|
||||
&mut dacl,
|
||||
ptr::null_mut(),
|
||||
&mut descriptor,
|
||||
)
|
||||
};
|
||||
ensure!(status == 0, "BINDING_SECURITY");
|
||||
let check = (|| -> Result<()> {
|
||||
ensure!(!owner.is_null() && !dacl.is_null(), "BINDING_NULL_SECURITY");
|
||||
ensure!(
|
||||
matches!(unsafe { sid(owner) }?.as_str(), "S-1-5-18" | "S-1-5-32-544"),
|
||||
"BINDING_ADMIN_OWNER_REQUIRED"
|
||||
);
|
||||
for index in 0..unsafe { (*dacl).AceCount } {
|
||||
let mut raw = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { Security::GetAce(dacl, u32::from(index), &mut raw) } != 0,
|
||||
"BINDING_ACE"
|
||||
);
|
||||
let ace = unsafe { &*raw.cast::<ACCESS_ALLOWED_ACE>() };
|
||||
ensure!(
|
||||
ace.Header.AceType == 0
|
||||
&& usize::from(ace.Header.AceSize)
|
||||
>= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
|
||||
"BINDING_ACE_TYPE"
|
||||
);
|
||||
let who = unsafe { sid(ptr::addr_of!(ace.SidStart).cast_mut().cast()) }?;
|
||||
if !matches!(who.as_str(), "S-1-5-18" | "S-1-5-32-544") {
|
||||
// Generic write/all, owner/DACL/delete and all file/directory mutation bits.
|
||||
ensure!(ace.Mask & 0x500d_0156 == 0, "BINDING_AGENT_WRITE_FORBIDDEN");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
unsafe {
|
||||
LocalFree(descriptor.cast());
|
||||
}
|
||||
check?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn readonly_binding(path: &Path) -> Result<Binding> {
|
||||
check_admin_readonly(path)?;
|
||||
let binding: Binding = serde_json::from_slice(&read_private(path, 8192)?)?;
|
||||
ensure!(
|
||||
!binding.tenant_id.is_nil()
|
||||
&& !binding.agent_id.is_nil()
|
||||
&& !binding.asset_id.is_nil()
|
||||
&& binding.enrollment_generation > 0
|
||||
&& binding.assignment_version > 0
|
||||
&& binding.public_key_hex.len() == 64
|
||||
&& binding
|
||||
.public_key_hex
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_hexdigit()),
|
||||
"JOB_BINDING_PROFILE"
|
||||
);
|
||||
Ok(binding)
|
||||
}
|
||||
@@ -4,6 +4,9 @@
|
||||
pub mod actions;
|
||||
#[cfg(windows)]
|
||||
pub mod clock;
|
||||
pub mod event_log;
|
||||
#[cfg(windows)]
|
||||
pub mod event_log_job;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub mod helper_ipc;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
@@ -12,6 +15,8 @@ pub mod helper_runtime;
|
||||
pub mod helper_system;
|
||||
#[cfg(windows)]
|
||||
pub mod inventory;
|
||||
#[cfg(windows)]
|
||||
pub mod job_binding;
|
||||
pub mod journal;
|
||||
#[cfg(windows)]
|
||||
pub mod native;
|
||||
|
||||
@@ -7,7 +7,7 @@ use rmm_agent_core::{
|
||||
jobs, ledger,
|
||||
reconcile::{self, SyncClock},
|
||||
};
|
||||
use rmm_agent_windows::{CAPABILITIES, journal::Journal, native};
|
||||
use rmm_agent_windows::{CAPABILITIES, job_binding::readonly_binding, journal::Journal, native};
|
||||
use rmm_domain::jobs::{Action, ExecutionPermitPayload};
|
||||
use rmm_protocol::*;
|
||||
use rusqlite::{Connection, OptionalExtension};
|
||||
@@ -216,104 +216,6 @@ fn verified_window(
|
||||
binding.verify(request, now + chrono::Duration::seconds(2))?;
|
||||
Ok(result)
|
||||
}
|
||||
fn readonly_binding(path: &Path) -> Result<Binding> {
|
||||
use std::ptr;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::LocalFree,
|
||||
Security::{
|
||||
self, ACCESS_ALLOWED_ACE, ACL,
|
||||
Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT},
|
||||
DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION,
|
||||
},
|
||||
};
|
||||
unsafe fn sid(sid: Security::PSID) -> Result<String> {
|
||||
let mut raw = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { ConvertSidToStringSidW(sid, &mut raw) } != 0,
|
||||
"BINDING_SID"
|
||||
);
|
||||
let mut len = 0;
|
||||
while unsafe { *raw.add(len) } != 0 {
|
||||
len += 1;
|
||||
ensure!(len < 256, "BINDING_SID_LIMIT");
|
||||
}
|
||||
let value = String::from_utf16(unsafe { std::slice::from_raw_parts(raw, len) })?;
|
||||
unsafe {
|
||||
LocalFree(raw.cast());
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
ensure!(path.is_absolute(), "ABSOLUTE_JOB_BINDING_REQUIRED");
|
||||
// The immediate configuration directory must also deny agent replacement.
|
||||
for (item, directory) in [
|
||||
(path, false),
|
||||
(path.parent().context("BINDING_PARENT")?, true),
|
||||
] {
|
||||
native::private_path(item, directory)?;
|
||||
let mut owner = ptr::null_mut();
|
||||
let mut dacl: *mut ACL = ptr::null_mut();
|
||||
let mut descriptor = ptr::null_mut();
|
||||
let status = unsafe {
|
||||
GetNamedSecurityInfoW(
|
||||
native::wide(item).as_ptr(),
|
||||
SE_FILE_OBJECT,
|
||||
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
|
||||
&mut owner,
|
||||
ptr::null_mut(),
|
||||
&mut dacl,
|
||||
ptr::null_mut(),
|
||||
&mut descriptor,
|
||||
)
|
||||
};
|
||||
ensure!(status == 0, "BINDING_SECURITY");
|
||||
let check = (|| -> Result<()> {
|
||||
ensure!(!owner.is_null() && !dacl.is_null(), "BINDING_NULL_SECURITY");
|
||||
ensure!(
|
||||
matches!(unsafe { sid(owner) }?.as_str(), "S-1-5-18" | "S-1-5-32-544"),
|
||||
"BINDING_ADMIN_OWNER_REQUIRED"
|
||||
);
|
||||
for index in 0..unsafe { (*dacl).AceCount } {
|
||||
let mut raw = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { Security::GetAce(dacl, u32::from(index), &mut raw) } != 0,
|
||||
"BINDING_ACE"
|
||||
);
|
||||
let ace = unsafe { &*raw.cast::<ACCESS_ALLOWED_ACE>() };
|
||||
ensure!(
|
||||
ace.Header.AceType == 0
|
||||
&& usize::from(ace.Header.AceSize)
|
||||
>= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
|
||||
"BINDING_ACE_TYPE"
|
||||
);
|
||||
let who = unsafe { sid(ptr::addr_of!(ace.SidStart).cast_mut().cast()) }?;
|
||||
if !matches!(who.as_str(), "S-1-5-18" | "S-1-5-32-544") {
|
||||
// Generic write/all, owner/DACL/delete and all file/directory mutation bits.
|
||||
ensure!(ace.Mask & 0x500d_0156 == 0, "BINDING_AGENT_WRITE_FORBIDDEN");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
unsafe {
|
||||
LocalFree(descriptor.cast());
|
||||
}
|
||||
check?;
|
||||
}
|
||||
let binding: Binding = serde_json::from_slice(&protected_read(path, 8192)?)?;
|
||||
ensure!(
|
||||
!binding.tenant_id.is_nil()
|
||||
&& !binding.agent_id.is_nil()
|
||||
&& !binding.asset_id.is_nil()
|
||||
&& binding.enrollment_generation > 0
|
||||
&& binding.assignment_version > 0
|
||||
&& binding.public_key_hex.len() == 64
|
||||
&& binding
|
||||
.public_key_hex
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_hexdigit()),
|
||||
"JOB_BINDING_PROFILE"
|
||||
);
|
||||
Ok(binding)
|
||||
}
|
||||
fn import_legacy_inventory(journal: &mut Journal) -> Result<()> {
|
||||
let original = {
|
||||
let mut q = journal
|
||||
@@ -1164,6 +1066,7 @@ impl Agent {
|
||||
let directory = self.config.state_directory.join("jobs");
|
||||
let work_offer = offer.clone();
|
||||
let work_grant = grant.clone();
|
||||
let original_boot = Uuid::parse_str(&self.boot)?;
|
||||
let worker = tokio::task::spawn_blocking(move || {
|
||||
let outcome = (|| -> Result<Outcome> {
|
||||
if !fence.allows(generation, &clock)
|
||||
@@ -1174,17 +1077,24 @@ impl Agent {
|
||||
"START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT",
|
||||
));
|
||||
}
|
||||
let script = if matches!(job.action, Action::RunScript { .. }) {
|
||||
match rmm_agent_windows::actions::Script::prepare(
|
||||
&job,
|
||||
&directory,
|
||||
work_grant.grant_id,
|
||||
) {
|
||||
Ok(script) => Some(script),
|
||||
Err(_) => return Ok(jobs::no_start("failed", "SCRIPT_PREPARATION_FAILED")),
|
||||
let prepared = match rmm_agent_windows::actions::PreparedAction::prepare(
|
||||
&job,
|
||||
&directory,
|
||||
work_grant.grant_id,
|
||||
&request,
|
||||
original_boot,
|
||||
) {
|
||||
Ok(prepared) => prepared,
|
||||
Err(_) => {
|
||||
return Ok(jobs::no_start(
|
||||
"failed",
|
||||
if matches!(job.action, Action::RunScript { .. }) {
|
||||
"SCRIPT_PREPARATION_FAILED"
|
||||
} else {
|
||||
"ACTION_PREPARATION_FAILED"
|
||||
},
|
||||
));
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
// File creation, pool scheduling and fsync never extend a start window.
|
||||
if worker_cancel.load(Ordering::SeqCst) {
|
||||
@@ -1198,11 +1108,7 @@ impl Agent {
|
||||
"START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT",
|
||||
));
|
||||
}
|
||||
if let Some(script) = script {
|
||||
script.run(&job, &worker_cancel)
|
||||
} else {
|
||||
rmm_agent_windows::actions::inventory(&job)
|
||||
}
|
||||
prepared.run(&job, &worker_cancel)
|
||||
})()
|
||||
.unwrap_or_else(|_| Outcome::unknown("WINDOWS_EXECUTOR_EFFECT_UNKNOWN"));
|
||||
let _ = completed.blocking_send((work_offer, work_grant, outcome));
|
||||
@@ -1549,6 +1455,10 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
|
||||
}
|
||||
pub fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
if args.first().map(String::as_str) == Some(rmm_agent_windows::event_log_job::MODE) {
|
||||
ensure!(args.len() == 2, "EVENT_LOG_WORKER_ARGUMENTS");
|
||||
return rmm_agent_windows::event_log_job::worker(Path::new(&args[1]));
|
||||
}
|
||||
if args == ["--help"] {
|
||||
println!(
|
||||
"Development Windows service. --service --config ABSOLUTE_PATH. Jobs disabled by default; require qualified clock, provisioned signing binding, signed Sync and WebUI-authorized grant. No approval bypass."
|
||||
|
||||
+135
-1
@@ -14,6 +14,13 @@ pub fn encode<T: Serialize>(value: &T) -> Result<Vec<u8>, serde_json::Error> {
|
||||
serde_json::to_vec(value)
|
||||
}
|
||||
|
||||
/// One explicitly qualified Event Log source, not an arbitrary channel/XPath.
|
||||
pub const WINDOWS_EVENT_LOG_FIXTURE_SOURCE: &str =
|
||||
"windows.eventlog.application.rustdiscovery-mvp-test";
|
||||
pub const WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY: &str = "logs.windows.eventlog.fixture/1";
|
||||
pub const WINDOWS_EVENT_LOG_FIXTURE_CHANNEL: &str = "Application";
|
||||
pub const WINDOWS_EVENT_LOG_FIXTURE_PROVIDER: &str = "RustDiscovery-MVP-Test";
|
||||
|
||||
/// Fixed per-job Windows PowerShell 5.1 option, never a machine/GPO policy.
|
||||
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
|
||||
pub enum WindowsExecutionProfile {
|
||||
@@ -54,6 +61,7 @@ pub enum Action {
|
||||
deserialize_with = "deserialize_windows_execution_profile",
|
||||
skip_serializing_if = "Option::is_none"
|
||||
)]
|
||||
#[schemars(with = "WindowsExecutionProfile")]
|
||||
windows_execution_profile: Option<WindowsExecutionProfile>,
|
||||
},
|
||||
RefreshInventory {
|
||||
@@ -160,7 +168,8 @@ impl Action {
|
||||
} => {
|
||||
unit(u)
|
||||
&& since < until
|
||||
&& (*until - *since).num_hours() <= 24
|
||||
&& *until - *since <= chrono::Duration::hours(24)
|
||||
&& (u != WINDOWS_EVENT_LOG_FIXTURE_SOURCE || since.timestamp() >= 0)
|
||||
&& *max_lines > 0
|
||||
&& *max_lines <= 1000
|
||||
}
|
||||
@@ -234,6 +243,18 @@ impl Action {
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn is_windows_event_log_fixture(&self) -> bool {
|
||||
matches!(self, Self::QueryLogs { unit, .. } if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE)
|
||||
}
|
||||
/// The outer process budget includes authenticated worker startup/cleanup;
|
||||
/// its inner Event Log calls retain their own cooperative <=5s deadline.
|
||||
pub fn valid_job_limits(&self, runtime_seconds: u32, output_bytes: u32) -> bool {
|
||||
(1..=3600).contains(&runtime_seconds)
|
||||
&& (1..=262144).contains(&output_bytes)
|
||||
&& (!self.is_windows_event_log_fixture()
|
||||
|| ((10..=120).contains(&runtime_seconds)
|
||||
&& (1024..=65536).contains(&output_bytes)))
|
||||
}
|
||||
/// Interpreter identity is part of the immutable action, never inferred at execution.
|
||||
pub fn script_platform(&self) -> Option<&'static str> {
|
||||
match self {
|
||||
@@ -283,6 +304,16 @@ impl Action {
|
||||
&& !(has("linux.base/1") && has("windows.base/1"))
|
||||
&& (scope != "windows.base" || has("rmm.sync.v1"))
|
||||
}
|
||||
Self::QueryLogs { unit, .. }
|
||||
if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE || has("windows.base/1") =>
|
||||
{
|
||||
identity == "agent_service"
|
||||
&& unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE
|
||||
&& has("windows.base/1")
|
||||
&& !has("linux.base/1")
|
||||
&& has("rmm.sync.v1")
|
||||
&& has(WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY)
|
||||
}
|
||||
Self::SetServiceState { state, .. }
|
||||
if identity == "system" || has("windows.base/1") =>
|
||||
{
|
||||
@@ -664,6 +695,28 @@ mod tests {
|
||||
}
|
||||
#[test]
|
||||
fn windows_remote_signed_profile_is_optional_exact_and_capability_bound() {
|
||||
let schema = schemars::schema_for!(Action).to_value();
|
||||
let script_schema = schema["oneOf"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|variant| {
|
||||
variant["properties"]
|
||||
.get("windows_execution_profile")
|
||||
.is_some()
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
script_schema["properties"]["windows_execution_profile"],
|
||||
serde_json::json!({"$ref":"#/$defs/WindowsExecutionProfile"})
|
||||
);
|
||||
assert!(
|
||||
!script_schema["required"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&serde_json::json!("windows_execution_profile"))
|
||||
);
|
||||
assert_eq!(schema["$defs"]["WindowsExecutionProfile"]["type"], "string");
|
||||
let legacy = br#"{"action":"run_script","interpreter":"powershell","script_utf8":"Write-Output 'hi'\r\n","arguments":[],"expected_stdout":null}"#;
|
||||
let mut action: Action = serde_json::from_slice(legacy).unwrap();
|
||||
assert_eq!(encode(&action).unwrap(), legacy);
|
||||
@@ -740,6 +793,87 @@ mod tests {
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes() {
|
||||
let since = DateTime::parse_from_rfc3339("2026-11-14T00:00:00Z")
|
||||
.unwrap()
|
||||
.with_timezone(&Utc);
|
||||
let mut action = Action::QueryLogs {
|
||||
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since,
|
||||
until: since + chrono::Duration::hours(24),
|
||||
max_lines: 1000,
|
||||
};
|
||||
let caps: Vec<String> = [
|
||||
"windows.base/1",
|
||||
"rmm.sync.v1",
|
||||
"query_logs",
|
||||
WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY,
|
||||
]
|
||||
.into_iter()
|
||||
.map(str::to_string)
|
||||
.collect();
|
||||
assert!(action.validate());
|
||||
assert!(action.available_for("agent_service", &caps));
|
||||
assert!(action.valid_job_limits(10, 1024));
|
||||
assert!(action.valid_job_limits(120, 65536));
|
||||
for (runtime, bytes) in [(9, 1024), (121, 1024), (10, 1023), (10, 65537)] {
|
||||
assert!(!action.valid_job_limits(runtime, bytes));
|
||||
}
|
||||
for i in 0..caps.len() {
|
||||
let mut short = caps.clone();
|
||||
short.remove(i);
|
||||
assert!(!action.available_for("agent_service", &short));
|
||||
}
|
||||
for identity in ["root", "system", "SYSTEM"] {
|
||||
assert!(!action.available_for(identity, &caps));
|
||||
}
|
||||
let mut mixed = caps.clone();
|
||||
mixed.push("linux.base/1".into());
|
||||
assert!(!action.available_for("agent_service", &mixed));
|
||||
assert!(!action.available_for("root", &["linux.base/1".into(), "query_logs".into()]));
|
||||
for unit in [
|
||||
"Application",
|
||||
"Security",
|
||||
"windows.eventlog.application.other",
|
||||
] {
|
||||
let mut wrong = action.clone();
|
||||
if let Action::QueryLogs { unit: u, .. } = &mut wrong {
|
||||
*u = unit.into();
|
||||
}
|
||||
assert!(!wrong.available_for("agent_service", &caps));
|
||||
}
|
||||
if let Action::QueryLogs { until, .. } = &mut action {
|
||||
*until += chrono::Duration::nanoseconds(1);
|
||||
}
|
||||
assert!(!action.validate());
|
||||
let linux = Action::QueryLogs {
|
||||
unit: "rmm-test.service".into(),
|
||||
since,
|
||||
until: since + chrono::Duration::hours(24),
|
||||
max_lines: 1000,
|
||||
};
|
||||
assert_eq!(
|
||||
String::from_utf8(encode(&linux).unwrap()).unwrap(),
|
||||
r#"{"action":"query_logs","unit":"rmm-test.service","since":"2026-11-14T00:00:00Z","until":"2026-11-15T00:00:00Z","max_lines":1000}"#
|
||||
);
|
||||
assert!(linux.validate());
|
||||
for identity in ["root", "agent_service"] {
|
||||
assert!(linux.available_for(identity, &["linux.base/1".into(), "query_logs".into()]));
|
||||
}
|
||||
let mut too_long = linux;
|
||||
if let Action::QueryLogs { until, .. } = &mut too_long {
|
||||
*until += chrono::Duration::minutes(59);
|
||||
}
|
||||
assert!(!too_long.validate());
|
||||
let pre_epoch = Action::QueryLogs {
|
||||
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: DateTime::from_timestamp(-1, 0).unwrap(),
|
||||
until: DateTime::from_timestamp(0, 0).unwrap(),
|
||||
max_lines: 1,
|
||||
};
|
||||
assert!(!pre_epoch.validate());
|
||||
}
|
||||
#[test]
|
||||
fn no_terminal_replay_or_unknown_restart() {
|
||||
assert!(!JobState::Succeeded.allows(JobState::Running));
|
||||
assert!(!JobState::Unknown.allows(JobState::Running));
|
||||
|
||||
@@ -192,6 +192,7 @@ pub async fn event(
|
||||
}
|
||||
}
|
||||
script_profile_evidence(&payload.action, &evidence)?;
|
||||
windows_event_log_success_evidence(&payload, r, &evidence)?;
|
||||
if matches!(payload.action, Action::Reboot { .. }) {
|
||||
crate::synchronization::verify_reboot_success(
|
||||
tx, tenant, agent, e, &payload, r, &evidence,
|
||||
@@ -225,6 +226,70 @@ pub async fn event(
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
fn windows_event_log_success_evidence(
|
||||
job: &JobPayload,
|
||||
result: &JobResult,
|
||||
evidence: &Value,
|
||||
) -> Result<()> {
|
||||
if !job.action.is_windows_event_log_fixture() {
|
||||
return Ok(());
|
||||
}
|
||||
let Action::QueryLogs {
|
||||
unit,
|
||||
since,
|
||||
until,
|
||||
max_lines,
|
||||
} = &job.action
|
||||
else {
|
||||
anyhow::bail!("fixed event log action required")
|
||||
};
|
||||
let observed_since: chrono::DateTime<Utc> = serde_json::from_value(
|
||||
evidence
|
||||
.get("start_utc")
|
||||
.cloned()
|
||||
.context("event log start missing")?,
|
||||
)?;
|
||||
let observed_until: chrono::DateTime<Utc> = serde_json::from_value(
|
||||
evidence
|
||||
.get("end_utc")
|
||||
.cloned()
|
||||
.context("event log end missing")?,
|
||||
)?;
|
||||
let complete = evidence.get("completeness") == Some(&json!("complete"))
|
||||
&& evidence.get("truncated") == Some(&json!(false))
|
||||
&& evidence.get("error_code") == Some(&Value::Null);
|
||||
let partial = evidence.get("completeness") == Some(&json!("partial"))
|
||||
&& evidence.get("truncated") == Some(&json!(true))
|
||||
&& matches!(
|
||||
evidence.get("error_code").and_then(Value::as_str),
|
||||
Some("EVENT_LOG_EVENT_LIMIT" | "EVENT_LOG_BYTE_LIMIT" | "EVENT_LOG_EVENT_SIZE_LIMIT")
|
||||
);
|
||||
ensure!(
|
||||
!result.reboot_required
|
||||
&& evidence.get("truncated") == Some(&json!(result.output_truncated))
|
||||
&& job.execution_identity == "agent_service"
|
||||
&& job.action.validate()
|
||||
&& job
|
||||
.action
|
||||
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
|
||||
&& evidence.get("source_id") == Some(&json!(unit))
|
||||
&& evidence.get("channel") == Some(&json!(WINDOWS_EVENT_LOG_FIXTURE_CHANNEL))
|
||||
&& evidence.get("provider") == Some(&json!(WINDOWS_EVENT_LOG_FIXTURE_PROVIDER))
|
||||
&& observed_since == *since
|
||||
&& observed_until == *until
|
||||
&& evidence.get("max_events") == Some(&json!(max_lines))
|
||||
&& evidence.get("max_output_bytes") == Some(&json!(job.max_output_bytes))
|
||||
&& evidence.get("quality") == Some(&json!("valid"))
|
||||
&& evidence.get("win32_error") == Some(&Value::Null)
|
||||
&& evidence.get("bookmark_updated") == Some(&json!(false))
|
||||
&& evidence.get("process_tree_bounded") == Some(&json!(true))
|
||||
&& evidence.get("execution_sid") == Some(&json!("S-1-5-19"))
|
||||
&& (complete || partial),
|
||||
"fixed Windows Event Log evidence mismatch"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// The profile records the requested process option, never an effective GPO policy.
|
||||
fn script_profile_evidence(action: &Action, evidence: &Value) -> Result<()> {
|
||||
if let Action::RunScript {
|
||||
@@ -251,6 +316,94 @@ fn script_profile_evidence(action: &Action, evidence: &Value) -> Result<()> {
|
||||
mod script_profile_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn windows_event_log_success_binds_request_and_keeps_limit_partial_honest() {
|
||||
let id = Uuid::new_v4();
|
||||
let now = Utc::now();
|
||||
let job = JobPayload {
|
||||
schema_version: 1,
|
||||
tenant_id: id,
|
||||
asset_id: id,
|
||||
agent_id: id,
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 1,
|
||||
job_id: id,
|
||||
attempt_id: id,
|
||||
action: Action::QueryLogs {
|
||||
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: now - Duration::hours(1),
|
||||
until: now,
|
||||
max_lines: 1000,
|
||||
},
|
||||
execution_identity: "agent_service".into(),
|
||||
not_before: now,
|
||||
start_before: now + Duration::minutes(1),
|
||||
max_runtime_seconds: 30,
|
||||
max_output_bytes: 4096,
|
||||
};
|
||||
let evidence = json!({"source_id":WINDOWS_EVENT_LOG_FIXTURE_SOURCE,"channel":"Application","provider":"RustDiscovery-MVP-Test","start_utc":now-Duration::hours(1),"end_utc":now,"max_events":1000,"max_output_bytes":4096,"quality":"valid","completeness":"complete","truncated":false,"error_code":null,"win32_error":null,"bookmark_updated":false,"process_tree_bounded":true,"execution_sid":"S-1-5-19"});
|
||||
let result = JobResult::default();
|
||||
windows_event_log_success_evidence(&job, &result, &evidence).unwrap();
|
||||
for conflicting in [
|
||||
JobResult {
|
||||
reboot_required: true,
|
||||
..Default::default()
|
||||
},
|
||||
JobResult {
|
||||
output_truncated: true,
|
||||
..Default::default()
|
||||
},
|
||||
] {
|
||||
assert!(windows_event_log_success_evidence(&job, &conflicting, &evidence).is_err());
|
||||
}
|
||||
for field in [
|
||||
"source_id",
|
||||
"channel",
|
||||
"provider",
|
||||
"start_utc",
|
||||
"end_utc",
|
||||
"max_events",
|
||||
"max_output_bytes",
|
||||
"quality",
|
||||
"win32_error",
|
||||
"bookmark_updated",
|
||||
"process_tree_bounded",
|
||||
"execution_sid",
|
||||
] {
|
||||
let mut bad = evidence.clone();
|
||||
bad[field] = json!("different");
|
||||
assert!(
|
||||
windows_event_log_success_evidence(&job, &result, &bad).is_err(),
|
||||
"{field}"
|
||||
);
|
||||
}
|
||||
for code in [
|
||||
"EVENT_LOG_EVENT_LIMIT",
|
||||
"EVENT_LOG_BYTE_LIMIT",
|
||||
"EVENT_LOG_EVENT_SIZE_LIMIT",
|
||||
] {
|
||||
let mut partial = evidence.clone();
|
||||
partial["completeness"] = json!("partial");
|
||||
partial["truncated"] = json!(true);
|
||||
partial["error_code"] = json!(code);
|
||||
let partial_result = JobResult {
|
||||
output_truncated: true,
|
||||
..Default::default()
|
||||
};
|
||||
windows_event_log_success_evidence(&job, &partial_result, &partial).unwrap();
|
||||
assert!(windows_event_log_success_evidence(&job, &result, &partial).is_err());
|
||||
partial["error_code"] = json!("EVENT_LOG_TIMEOUT");
|
||||
assert!(windows_event_log_success_evidence(&job, &partial_result, &partial).is_err());
|
||||
partial["quality"] = json!("permission_denied");
|
||||
assert!(windows_event_log_success_evidence(&job, &partial_result, &partial).is_err());
|
||||
}
|
||||
let mut permission_denied = evidence.clone();
|
||||
permission_denied["win32_error"] = json!(5);
|
||||
assert!(windows_event_log_success_evidence(&job, &result, &permission_denied).is_err());
|
||||
let mut false_complete = evidence.clone();
|
||||
false_complete["truncated"] = json!(true);
|
||||
assert!(windows_event_log_success_evidence(&job, &result, &false_complete).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn requested_profile_success_evidence_is_exact_without_effective_policy_claim() {
|
||||
let mut action = Action::RunScript {
|
||||
interpreter: "powershell".into(),
|
||||
@@ -383,6 +536,12 @@ pub async fn permit(
|
||||
return Ok(denied("BINDING_MISMATCH"));
|
||||
}
|
||||
let now = Utc::now();
|
||||
if !payload
|
||||
.action
|
||||
.valid_job_limits(payload.max_runtime_seconds, payload.max_output_bytes)
|
||||
{
|
||||
return Ok(denied("INVALID_JOB_LIMITS"));
|
||||
}
|
||||
if !payload.action.validate() {
|
||||
return Ok(denied("APT_MANIFEST_REQUIRED"));
|
||||
}
|
||||
@@ -580,6 +739,9 @@ pub async fn next(
|
||||
if !payload
|
||||
.action
|
||||
.available_for(&payload.execution_identity, &caps)
|
||||
|| !payload
|
||||
.action
|
||||
.valid_job_limits(payload.max_runtime_seconds, payload.max_output_bytes)
|
||||
{
|
||||
tx.commit().await?;
|
||||
return Ok(None);
|
||||
|
||||
@@ -156,6 +156,7 @@ pub struct Variant {
|
||||
deserialize_with = "rmm_domain::jobs::deserialize_windows_execution_profile",
|
||||
skip_serializing_if = "Option::is_none"
|
||||
)]
|
||||
#[schemars(with = "WindowsExecutionProfile")]
|
||||
windows_execution_profile: Option<WindowsExecutionProfile>,
|
||||
}
|
||||
#[derive(Clone, Deserialize, Serialize, schemars::JsonSchema)]
|
||||
@@ -471,6 +472,9 @@ pub async fn plan(
|
||||
let row = &rows[0];
|
||||
let caps = capabilities(row.get("capabilities"))?;
|
||||
let action = target_action(&input, &caps)?;
|
||||
if !action.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) {
|
||||
return Err(fail("VALIDATION_ERROR"));
|
||||
}
|
||||
if !action.available_for(&input.execution_identity, &caps) {
|
||||
return Err(fail("UNSUPPORTED_CAPABILITY"));
|
||||
}
|
||||
@@ -598,6 +602,12 @@ async fn recheck(tx: &mut Transaction<'_, Postgres>, plan: &PlanPayload) -> Resu
|
||||
}
|
||||
let mut references = Vec::new();
|
||||
for job in &plan.jobs {
|
||||
if !job.payload.action.valid_job_limits(
|
||||
job.payload.max_runtime_seconds,
|
||||
job.payload.max_output_bytes,
|
||||
) {
|
||||
return Err(fail("VALIDATION_ERROR"));
|
||||
}
|
||||
if !job.payload.action.validate() {
|
||||
return Err(Error(StatusCode::CONFLICT, "APT_MANIFEST_REQUIRED"));
|
||||
}
|
||||
@@ -1022,6 +1032,7 @@ async fn operations_http(
|
||||
#[cfg(test)]
|
||||
mod windows_contract_tests {
|
||||
use super::*;
|
||||
use chrono::Duration;
|
||||
fn input() -> PlanInput {
|
||||
let tenant = Uuid::new_v4();
|
||||
let now = Utc::now();
|
||||
@@ -1054,6 +1065,33 @@ mod windows_contract_tests {
|
||||
assert!(target_action(&i, &["windows.base/1".into()]).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn fixed_windows_log_web_contract_denies_extra_source_parameters() {
|
||||
let tenant = Uuid::new_v4();
|
||||
let now = Utc::now();
|
||||
let value = json!({"tenant_id":tenant,"action":"query_logs","targets":{"asset_ids":[Uuid::new_v4()]},"parameters":{"execution_identity":"agent_service","timeout_seconds":30,"max_output_bytes":4096,"unit":WINDOWS_EVENT_LOG_FIXTURE_SOURCE,"since":now-Duration::hours(1),"until":now,"max_lines":1000},"schedule":{"not_before":now,"start_before":now+Duration::minutes(10),"offline_policy":"wait_until_deadline"},"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"fixed source"});
|
||||
let input = serde_json::from_value::<PlanRequest>(value.clone())
|
||||
.unwrap()
|
||||
.resolve(tenant)
|
||||
.unwrap();
|
||||
assert!(input.action.is_windows_event_log_fixture());
|
||||
assert!(input.action.validate());
|
||||
assert!(
|
||||
input
|
||||
.action
|
||||
.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes)
|
||||
);
|
||||
assert!(input.script_variants.is_empty());
|
||||
for field in ["channel", "provider", "xpath", "bookmark"] {
|
||||
let mut bad = value.clone();
|
||||
bad["parameters"][field] = json!("arbitrary");
|
||||
assert!(
|
||||
serde_json::from_value::<PlanRequest>(bad)
|
||||
.map(|request| request.resolve(tenant).is_err())
|
||||
.unwrap_or(true)
|
||||
);
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn remote_signed_fixed_variants_bind_profile_without_linux_inheritance() {
|
||||
let mut i = input();
|
||||
let legacy_linux = encode(&i.action).unwrap();
|
||||
@@ -1100,6 +1138,18 @@ mod windows_contract_tests {
|
||||
i.script_variants[1].windows_execution_profile =
|
||||
Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
|
||||
assert!(validate_variants(&i.script_variants).is_err());
|
||||
let schema = schemars::schema_for!(Variant).to_value();
|
||||
assert_eq!(
|
||||
schema["properties"]["windows_execution_profile"],
|
||||
json!({"$ref":"#/$defs/WindowsExecutionProfile"})
|
||||
);
|
||||
assert!(
|
||||
!schema["required"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&json!("windows_execution_profile"))
|
||||
);
|
||||
assert_eq!(schema["$defs"]["WindowsExecutionProfile"]["type"], "string");
|
||||
let legacy = json!({"os_family":"windows", "interpreter":"powershell", "encoding":"utf-8", "script_utf8":"hi"});
|
||||
let inherited: Variant = serde_json::from_value(legacy.clone()).unwrap();
|
||||
assert!(inherited.windows_execution_profile.is_none());
|
||||
@@ -1351,6 +1401,116 @@ mod windows_contract_tests {
|
||||
.unwrap()
|
||||
.is_none()
|
||||
);
|
||||
let now = Utc::now();
|
||||
let mut logs = input();
|
||||
logs.targets.asset_ids = vec![assets[1]];
|
||||
logs.script_variants.clear();
|
||||
logs.max_runtime_seconds = 30;
|
||||
logs.action = Action::QueryLogs {
|
||||
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
||||
since: now - Duration::hours(1),
|
||||
until: now,
|
||||
max_lines: 1000,
|
||||
};
|
||||
assert_eq!(
|
||||
plan(&state, &principal, tenant, logs.clone())
|
||||
.await
|
||||
.unwrap_err()
|
||||
.1,
|
||||
"FORBIDDEN"
|
||||
);
|
||||
sqlx::query("UPDATE memberships SET permissions=array_append(permissions,'logs:read') WHERE principal=$1").bind(&principal.name).execute(&admin).await.unwrap();
|
||||
assert_eq!(
|
||||
plan(&state, &principal, tenant, logs.clone())
|
||||
.await
|
||||
.unwrap_err()
|
||||
.1,
|
||||
"UNSUPPORTED_CAPABILITY"
|
||||
);
|
||||
let mut log_caps = windows_caps.as_array().unwrap().clone();
|
||||
log_caps.extend([
|
||||
json!("query_logs"),
|
||||
json!(WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY),
|
||||
]);
|
||||
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
|
||||
.bind(agents[1])
|
||||
.bind(json!(log_caps))
|
||||
.execute(&admin)
|
||||
.await
|
||||
.unwrap();
|
||||
let view = plan(&state, &principal, tenant, logs).await.unwrap();
|
||||
let log_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap();
|
||||
let bytes: Vec<u8> =
|
||||
sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1")
|
||||
.bind(log_id)
|
||||
.fetch_one(&admin)
|
||||
.await
|
||||
.unwrap();
|
||||
let log_bound: PlanPayload = serde_json::from_slice(&bytes).unwrap();
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
|
||||
.await
|
||||
.unwrap();
|
||||
recheck(&mut tx, &log_bound).await.unwrap();
|
||||
tx.rollback().await.unwrap();
|
||||
let pending = submit(
|
||||
&state,
|
||||
&principal,
|
||||
tenant,
|
||||
log_id,
|
||||
Submit {
|
||||
idempotency_key: "fixed-event-log".into(),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(pending["approval_state"], "pending_approval");
|
||||
assert_eq!(pending["job_count"], 0);
|
||||
let mut changed = log_bound.clone();
|
||||
if let Action::QueryLogs { max_lines, .. } = &mut changed.jobs[0].payload.action {
|
||||
*max_lines = 999;
|
||||
}
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
recheck(&mut tx, &changed).await.unwrap_err().1,
|
||||
"PLAN_HASH_MISMATCH"
|
||||
);
|
||||
tx.rollback().await.unwrap();
|
||||
let mut changed = log_bound.clone();
|
||||
changed.jobs[0].payload.max_output_bytes = 65537;
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
recheck(&mut tx, &changed).await.unwrap_err().1,
|
||||
"VALIDATION_ERROR"
|
||||
);
|
||||
tx.rollback().await.unwrap();
|
||||
log_caps.retain(|cap| cap != WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY);
|
||||
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
|
||||
.bind(agents[1])
|
||||
.bind(json!(log_caps))
|
||||
.execute(&admin)
|
||||
.await
|
||||
.unwrap();
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
recheck(&mut tx, &log_bound).await.unwrap_err().1,
|
||||
"UNSUPPORTED_CAPABILITY"
|
||||
);
|
||||
tx.rollback().await.unwrap();
|
||||
sqlx::query("UPDATE memberships SET permissions=array_remove(permissions,'logs:read') WHERE principal=$1").bind(&principal.name).execute(&admin).await.unwrap();
|
||||
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
recheck(&mut tx, &log_bound).await.unwrap_err().1,
|
||||
"FORBIDDEN"
|
||||
);
|
||||
tx.rollback().await.unwrap();
|
||||
let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM jobs WHERE tenant_id=$1),(SELECT count(*) FROM outbox WHERE tenant_id=$1),(SELECT count(*) FROM execution_permits WHERE tenant_id=$1)").bind(tenant).fetch_one(&admin).await.unwrap();
|
||||
assert_eq!(counts, (0, 0, 0));
|
||||
let after: Vec<u8> =
|
||||
|
||||
Reference in New Issue
Block a user