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:
@@ -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."
|
||||
|
||||
Reference in New Issue
Block a user