Implement bounded Windows Event Log jobs and verify contracts on cloud Linux
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 10:48:05 +01:00
parent d532ff0ffd
commit 5656431ebf
21 changed files with 2296 additions and 136 deletions
+2 -2
View File
@@ -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"
);
+33
View File
@@ -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)]
+1 -1
View File
@@ -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"] }
+35
View File
@@ -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,
+88 -4
View File
@@ -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);
+778
View File
@@ -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());
}
}
+122
View File
@@ -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)
}
+5
View File
@@ -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;
+24 -114
View File
@@ -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
View File
@@ -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));
+162
View File
@@ -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);
+160
View File
@@ -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> =