Compare commits
4
Commits
4a2fbef9ac
...
66e77ad83e
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
66e77ad83e | ||
|
|
66c1855056 | ||
|
|
6b03b222e6 | ||
|
|
e6fe4cd285 |
@@ -39,4 +39,4 @@ rcgen = { version = "=0.14.10", default-features = false, features = ["crypto",
|
|||||||
cc = "=1.11.1"
|
cc = "=1.11.1"
|
||||||
|
|
||||||
[target.'cfg(windows)'.dependencies]
|
[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_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"] }
|
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_ApplicationInstallationAndServicing", "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"] }
|
||||||
|
|||||||
@@ -157,6 +157,7 @@ mod service {
|
|||||||
let clock = super::clock::NativeClock::new();
|
let clock = super::clock::NativeClock::new();
|
||||||
STAGE.store(30, Ordering::SeqCst);
|
STAGE.store(30, Ordering::SeqCst);
|
||||||
let pipe = super::clock::named_pipe_diagnostic();
|
let pipe = super::clock::named_pipe_diagnostic();
|
||||||
|
let status_rpc = super::clock::status_rpc_diagnostic();
|
||||||
let first = clock.report();
|
let first = clock.report();
|
||||||
std::thread::sleep(Duration::from_millis(750));
|
std::thread::sleep(Duration::from_millis(750));
|
||||||
STAGE.store(31, Ordering::SeqCst);
|
STAGE.store(31, Ordering::SeqCst);
|
||||||
@@ -164,7 +165,7 @@ mod service {
|
|||||||
let identity_controls = super::clock::identity_controls();
|
let identity_controls = super::clock::identity_controls();
|
||||||
STAGE.store(40, Ordering::SeqCst);
|
STAGE.store(40, Ordering::SeqCst);
|
||||||
let data = serde_json::to_vec_pretty(
|
let data = serde_json::to_vec_pretty(
|
||||||
&serde_json::json!({"schema":1,"case_id":case,"service_name":NAME,"token_sid":"S-1-5-19","elevated":token.elevation_flag!=0,"token":token,"endpoints":endpoints,"named_pipe_diagnostic":pipe,"identity_controls":identity_controls,"source":"MS-W32T:4.1:Opnum6:ncalrpc:SID19:W32Time:V5_descriptor:MUTUAL_AUTH:WINNT:PKT_PRIVACY","read_only":true,"samples":[first,second]}),
|
&serde_json::json!({"schema":1,"case_id":case,"service_name":NAME,"token_sid":"S-1-5-19","elevated":token.elevation_flag!=0,"token":token,"endpoints":endpoints,"named_pipe_diagnostic":pipe,"status_rpc_diagnostic":status_rpc,"identity_controls":identity_controls,"source":"MS-W32T:4.1:Opnum6:ncalrpc:SID19:W32Time:V5_descriptor:MUTUAL_AUTH:WINNT:PKT_PRIVACY","read_only":true,"samples":[first,second]}),
|
||||||
)?;
|
)?;
|
||||||
ensure!(data.len() < 16384, "READINESS_REPORT_SIZE");
|
ensure!(data.len() < 16384, "READINESS_REPORT_SIZE");
|
||||||
STAGE.store(41, Ordering::SeqCst);
|
STAGE.store(41, Ordering::SeqCst);
|
||||||
@@ -259,6 +260,6 @@ fn main() -> anyhow::Result<()> {
|
|||||||
fn main() {
|
fn main() {
|
||||||
println!(
|
println!(
|
||||||
"{}",
|
"{}",
|
||||||
serde_json::to_string(&serde_json::json!({"clock":clock::NativeClock::new().report(),"endpoints":clock::endpoint_report(),"named_pipe_diagnostic":clock::named_pipe_diagnostic(),"identity_controls":clock::identity_controls()})).unwrap()
|
serde_json::to_string(&serde_json::json!({"clock":clock::NativeClock::new().report(),"endpoints":clock::endpoint_report(),"named_pipe_diagnostic":clock::named_pipe_diagnostic(),"status_rpc_diagnostic":clock::status_rpc_diagnostic(),"identity_controls":clock::identity_controls()})).unwrap()
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -71,20 +71,47 @@ typedef struct {
|
|||||||
} RmmClockStatus;
|
} RmmClockStatus;
|
||||||
_Static_assert(sizeof(RmmClockStatus) == 64, "Rust numeric clock ABI");
|
_Static_assert(sizeof(RmmClockStatus) == 64, "Rust numeric clock ABI");
|
||||||
_Static_assert(sizeof(RMM_W32TIME_STATUS) == 120, "MS-W32T x64 structure ABI");
|
_Static_assert(sizeof(RMM_W32TIME_STATUS) == 120, "MS-W32T x64 structure ABI");
|
||||||
static uint32_t invoke_status(RPC_BINDING_HANDLE binding, RmmClockStatus *out) {
|
/* Diagnostic-only numeric ABI. No strings, names, pointers or remote arrays
|
||||||
|
* leave C. A zero native return is meaningful only when return_present is1.
|
||||||
|
* Stages:10 compose,20 binding,30 auth,40 call-timeout,50 arena,
|
||||||
|
* 60 invoking,61 returned,62 raw numeric status,70 local guard,80 mapped,
|
||||||
|
* 90 contained RPC/SEH exception. Never used by the clock trust evaluator.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
uint32_t stage, native_rpc_return, native_rpc_return_present, rpc_exception;
|
||||||
|
uint32_t status_present, ul_size, c_entries, p_entries_present;
|
||||||
|
} RmmClockTrace;
|
||||||
|
_Static_assert(sizeof(RmmClockTrace) == 32, "Rust numeric diagnostic ABI");
|
||||||
|
static uint32_t invoke_status(RPC_BINDING_HANDLE binding, RmmClockStatus *out, RmmClockTrace *trace) {
|
||||||
RMM_W32TIME_STATUS *status = NULL;
|
RMM_W32TIME_STATUS *status = NULL;
|
||||||
unsigned long result = 0;
|
unsigned long result = 0;
|
||||||
Arena arena = {0};
|
Arena arena = {0};
|
||||||
|
if (trace) trace->stage = 50;
|
||||||
if (!result && !InitOnceExecuteOnce(&arena_once, initialize_arena, NULL, NULL)) result = ERROR_NOT_ENOUGH_MEMORY;
|
if (!result && !InitOnceExecuteOnce(&arena_once, initialize_arena, NULL, NULL)) result = ERROR_NOT_ENOUGH_MEMORY;
|
||||||
if (!result && TlsGetValue(arena_index)) result = ERROR_BUSY;
|
if (!result && TlsGetValue(arena_index)) result = ERROR_BUSY;
|
||||||
if (!result && !TlsSetValue(arena_index, &arena)) result = GetLastError();
|
if (!result && !TlsSetValue(arena_index, &arena)) result = GetLastError();
|
||||||
if (!result) {
|
if (!result) {
|
||||||
RpcTryExcept {
|
RpcTryExcept {
|
||||||
|
if (trace) trace->stage = 60;
|
||||||
result = RmmW32TimeQueryStatus(binding, &status);
|
result = RmmW32TimeQueryStatus(binding, &status);
|
||||||
|
if (trace) {
|
||||||
|
trace->stage = 61; trace->native_rpc_return_present = 1;
|
||||||
|
trace->native_rpc_return = result;
|
||||||
|
}
|
||||||
if (!result) {
|
if (!result) {
|
||||||
if (!status || status->ulSize != sizeof(*status) || status->cEntries || status->pEntries)
|
if (trace) {
|
||||||
|
trace->stage = 62; trace->status_present = status != NULL;
|
||||||
|
if (status) {
|
||||||
|
trace->ul_size = status->ulSize; trace->c_entries = status->cEntries;
|
||||||
|
trace->p_entries_present = status->pEntries != NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!status || status->ulSize != sizeof(*status) || status->cEntries || status->pEntries) {
|
||||||
|
if (trace) trace->stage = 70;
|
||||||
result = RPC_X_BAD_STUB_DATA;
|
result = RPC_X_BAD_STUB_DATA;
|
||||||
|
}
|
||||||
else {
|
else {
|
||||||
|
if (trace) trace->stage = 80;
|
||||||
out->leap = status->eLeapIndicator; out->stratum = status->nStratum;
|
out->leap = status->eLeapIndicator; out->stratum = status->nStratum;
|
||||||
out->state = status->ulLcState; out->flags = status->ulTSFlags;
|
out->state = status->ulLcState; out->flags = status->ulTSFlags;
|
||||||
out->last_result = status->eLastSyncResult; out->size = status->ulSize;
|
out->last_result = status->eLastSyncResult; out->size = status->ulSize;
|
||||||
@@ -95,21 +122,24 @@ static uint32_t invoke_status(RPC_BINDING_HANDLE binding, RmmClockStatus *out) {
|
|||||||
}
|
}
|
||||||
} RpcExcept(RpcExceptionFilter(RpcExceptionCode())) {
|
} RpcExcept(RpcExceptionFilter(RpcExceptionCode())) {
|
||||||
result = RpcExceptionCode();
|
result = RpcExceptionCode();
|
||||||
|
if (trace) {trace->stage = 90; trace->rpc_exception = result;}
|
||||||
} RpcEndExcept
|
} RpcEndExcept
|
||||||
release_allocations(&arena);
|
release_allocations(&arena);
|
||||||
TlsSetValue(arena_index, NULL);
|
TlsSetValue(arena_index, NULL);
|
||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
uint32_t rmm_clock_query(RmmClockStatus *out) {
|
static uint32_t pipe_query(RmmClockStatus *out, RmmClockTrace *trace) {
|
||||||
RPC_WSTR text = NULL;
|
RPC_WSTR text = NULL;
|
||||||
RPC_BINDING_HANDLE binding = NULL;
|
RPC_BINDING_HANDLE binding = NULL;
|
||||||
RPC_SECURITY_QOS qos = {0};
|
RPC_SECURITY_QOS qos = {0};
|
||||||
unsigned long result;
|
unsigned long result;
|
||||||
memset(out, 0, sizeof(*out));
|
memset(out, 0, sizeof(*out));
|
||||||
|
if (trace) trace->stage = 10;
|
||||||
result = RpcStringBindingComposeW(NULL, (RPC_WSTR)L"ncacn_np", NULL,
|
result = RpcStringBindingComposeW(NULL, (RPC_WSTR)L"ncacn_np", NULL,
|
||||||
(RPC_WSTR)L"\\pipe\\W32TIME_ALT", NULL, &text);
|
(RPC_WSTR)L"\\pipe\\W32TIME_ALT", NULL, &text);
|
||||||
if (result) return result;
|
if (result) return result;
|
||||||
|
if (trace) trace->stage = 20;
|
||||||
result = RpcBindingFromStringBindingW(text, &binding);
|
result = RpcBindingFromStringBindingW(text, &binding);
|
||||||
RpcStringFreeW(&text);
|
RpcStringFreeW(&text);
|
||||||
if (result) return result;
|
if (result) return result;
|
||||||
@@ -117,13 +147,23 @@ uint32_t rmm_clock_query(RmmClockStatus *out) {
|
|||||||
qos.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT;
|
qos.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT;
|
||||||
qos.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
|
qos.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
|
||||||
qos.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY;
|
qos.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY;
|
||||||
|
if (trace) trace->stage = 30;
|
||||||
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
||||||
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, &qos);
|
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, &qos);
|
||||||
if (!result) result = RpcBindingSetOption(binding, RPC_C_OPT_CALL_TIMEOUT, 1500);
|
if (!result) {
|
||||||
if (!result) result = invoke_status(binding, out);
|
if (trace) trace->stage = 40;
|
||||||
|
result = RpcBindingSetOption(binding, RPC_C_OPT_CALL_TIMEOUT, 1500);
|
||||||
|
}
|
||||||
|
if (!result) result = invoke_status(binding, out, trace);
|
||||||
RpcBindingFree(&binding);
|
RpcBindingFree(&binding);
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
uint32_t rmm_clock_query(RmmClockStatus *out) { return pipe_query(out, NULL); }
|
||||||
|
uint32_t rmm_clock_query_trace(RmmClockTrace *trace) {
|
||||||
|
RmmClockStatus ignored = {0};
|
||||||
|
memset(trace, 0, sizeof(*trace));
|
||||||
|
return pipe_query(&ignored, trace);
|
||||||
|
}
|
||||||
/* Kernel-authenticated ALPC only. No automatic fallback to named pipes.
|
/* Kernel-authenticated ALPC only. No automatic fallback to named pipes.
|
||||||
* The expected SID is fixed locally, never adopted from endpoint metadata.
|
* The expected SID is fixed locally, never adopted from endpoint metadata.
|
||||||
*/
|
*/
|
||||||
@@ -188,7 +228,7 @@ static uint32_t alpc_query(RmmClockStatus *out, unsigned control) {
|
|||||||
qos.ServerSecurityDescriptor = &descriptor;
|
qos.ServerSecurityDescriptor = &descriptor;
|
||||||
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
||||||
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, (RPC_SECURITY_QOS *)&qos);
|
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, (RPC_SECURITY_QOS *)&qos);
|
||||||
if (!result) result = invoke_status(binding, out);
|
if (!result) result = invoke_status(binding, out, NULL);
|
||||||
}
|
}
|
||||||
RpcBindingFree(&binding);
|
RpcBindingFree(&binding);
|
||||||
break; /* no retry, alternate identity, endpoint or weaker transport */
|
break; /* no retry, alternate identity, endpoint or weaker transport */
|
||||||
|
|||||||
@@ -31,6 +31,11 @@ typedef struct {
|
|||||||
unsigned long cEntries;
|
unsigned long cEntries;
|
||||||
[size_is(cEntries)] RMM_W32TIME_ENTRY *pEntries;
|
[size_is(cEntries)] RMM_W32TIME_ENTRY *pEntries;
|
||||||
} RMM_W32TIME_STATUS;
|
} RMM_W32TIME_STATUS;
|
||||||
|
/* Microsoft declares PW32TIME_STATUS_INFO separately. Keep the inner pointer
|
||||||
|
* explicitly unique; the out parameter's outer pointer defaults to ref.
|
||||||
|
* WIDL 7 propagates a parameter-level [ref] through a direct ** declaration.
|
||||||
|
*/
|
||||||
|
typedef [unique] RMM_W32TIME_STATUS *RMM_PW32TIME_STATUS;
|
||||||
[uuid(8fb6d884-2388-11d0-8c35-00c04fda2795), version(4.1), pointer_default(unique)]
|
[uuid(8fb6d884-2388-11d0-8c35-00c04fda2795), version(4.1), pointer_default(unique)]
|
||||||
interface RmmW32Time {
|
interface RmmW32Time {
|
||||||
unsigned long RmmUnusedSlot0([in] handle_t binding);
|
unsigned long RmmUnusedSlot0([in] handle_t binding);
|
||||||
@@ -39,5 +44,5 @@ interface RmmW32Time {
|
|||||||
unsigned long RmmUnusedSlot3([in] handle_t binding);
|
unsigned long RmmUnusedSlot3([in] handle_t binding);
|
||||||
unsigned long RmmUnusedSlot4([in] handle_t binding);
|
unsigned long RmmUnusedSlot4([in] handle_t binding);
|
||||||
unsigned long RmmUnusedSlot5([in] handle_t binding);
|
unsigned long RmmUnusedSlot5([in] handle_t binding);
|
||||||
unsigned long RmmW32TimeQueryStatus([in] handle_t binding, [out, ref] RMM_W32TIME_STATUS **status);
|
unsigned long RmmW32TimeQueryStatus([in] handle_t binding, [out] RMM_PW32TIME_STATUS *status);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -259,6 +259,87 @@ pub fn named_pipe_diagnostic() -> ClockReport {
|
|||||||
}
|
}
|
||||||
.report()
|
.report()
|
||||||
}
|
}
|
||||||
|
/// Diagnostic-only ABI captured before the existing C layout guard. Presence
|
||||||
|
/// flags are numeric0/1; no remote pointers, names or returned entries escape.
|
||||||
|
#[derive(Clone, Copy, Debug, Default, Serialize)]
|
||||||
|
#[repr(C)]
|
||||||
|
pub struct StatusRpcTrace {
|
||||||
|
pub stage: u32,
|
||||||
|
pub native_rpc_return: u32,
|
||||||
|
pub native_rpc_return_present: u32,
|
||||||
|
pub rpc_exception: u32,
|
||||||
|
pub status_present: u32,
|
||||||
|
pub ul_size: u32,
|
||||||
|
pub c_entries: u32,
|
||||||
|
pub p_entries_present: u32,
|
||||||
|
}
|
||||||
|
#[derive(Debug, Serialize)]
|
||||||
|
pub struct StatusRpcDiagnostic {
|
||||||
|
pub rpc_code: u32,
|
||||||
|
pub independent_call: bool,
|
||||||
|
pub trace: Option<StatusRpcTrace>,
|
||||||
|
pub diagnostic_only: bool,
|
||||||
|
pub adapter_qualified: bool,
|
||||||
|
pub trusted: bool,
|
||||||
|
}
|
||||||
|
/// The fixed authenticated named-pipe call is observed separately. It never
|
||||||
|
/// selects a production transport or supplies a trusted timestamp. One worker,
|
||||||
|
/// one outstanding call and no replacement/retry after a local timeout.
|
||||||
|
pub fn status_rpc_diagnostic() -> StatusRpcDiagnostic {
|
||||||
|
#[cfg(windows)]
|
||||||
|
let (rpc_code, trace) = {
|
||||||
|
type Reply = std::sync::mpsc::SyncSender<(u32, StatusRpcTrace)>;
|
||||||
|
type Requests = std::sync::mpsc::SyncSender<Reply>;
|
||||||
|
static WORKER: std::sync::OnceLock<Mutex<Option<Requests>>> = std::sync::OnceLock::new();
|
||||||
|
let worker = WORKER.get_or_init(|| {
|
||||||
|
let (sender, receiver) = std::sync::mpsc::sync_channel::<Reply>(1);
|
||||||
|
let created = std::thread::Builder::new()
|
||||||
|
.name("rmm-clock-status-diag".into())
|
||||||
|
.spawn(move || {
|
||||||
|
#[link(name = "rmm_clock_rpc", kind = "static")]
|
||||||
|
#[link(name = "rpcrt4")]
|
||||||
|
#[link(name = "advapi32")]
|
||||||
|
unsafe extern "C" {
|
||||||
|
fn rmm_clock_query_trace(trace: *mut StatusRpcTrace) -> u32;
|
||||||
|
}
|
||||||
|
while let Ok(reply) = receiver.recv() {
|
||||||
|
let mut trace = StatusRpcTrace::default();
|
||||||
|
// SAFETY: fixed8*u32 C ABI; SEH stays contained inside C.
|
||||||
|
let code = unsafe { rmm_clock_query_trace(&mut trace) };
|
||||||
|
let _ = reply.send((code, trace));
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.is_ok();
|
||||||
|
Mutex::new(created.then_some(sender))
|
||||||
|
});
|
||||||
|
if let Ok(mut worker) = worker.try_lock() {
|
||||||
|
let (reply, receiver) = std::sync::mpsc::sync_channel(1);
|
||||||
|
let sent = worker
|
||||||
|
.as_ref()
|
||||||
|
.is_some_and(|sender| sender.try_send(reply).is_ok());
|
||||||
|
if sent
|
||||||
|
&& let Ok((code, trace)) = receiver.recv_timeout(std::time::Duration::from_secs(2))
|
||||||
|
{
|
||||||
|
(code, Some(trace))
|
||||||
|
} else {
|
||||||
|
*worker = None;
|
||||||
|
(1818, None)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
(170, None)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#[cfg(not(windows))]
|
||||||
|
let (rpc_code, trace) = (50, None);
|
||||||
|
StatusRpcDiagnostic {
|
||||||
|
rpc_code,
|
||||||
|
independent_call: true,
|
||||||
|
trace,
|
||||||
|
diagnostic_only: true,
|
||||||
|
adapter_qualified: false,
|
||||||
|
trusted: false,
|
||||||
|
}
|
||||||
|
}
|
||||||
/// Read-only negative controls for the separate native readiness program.
|
/// Read-only negative controls for the separate native readiness program.
|
||||||
/// Neither control can produce clock authority, even if the OS accepts it.
|
/// Neither control can produce clock authority, even if the OS accepts it.
|
||||||
/// Rejection without a successful genuine status query is not identity proof.
|
/// Rejection without a successful genuine status query is not identity proof.
|
||||||
@@ -443,6 +524,7 @@ mod tests {
|
|||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
fn production_clock_stays_closed_until_native_adapter_qualification() {
|
fn production_clock_stays_closed_until_native_adapter_qualification() {
|
||||||
|
assert_eq!(std::mem::size_of::<StatusRpcTrace>(), 32);
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
NativeClock::new().now().unwrap_err().to_string(),
|
NativeClock::new().now().unwrap_err().to_string(),
|
||||||
"CLOCK_ADAPTER_UNQUALIFIED"
|
"CLOCK_ADAPTER_UNQUALIFIED"
|
||||||
|
|||||||
@@ -16,16 +16,67 @@ pub const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents";
|
|||||||
pub const DB: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite";
|
pub const DB: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite";
|
||||||
const ACTOR_RW: u32 = 0x0012_019f;
|
const ACTOR_RW: u32 = 0x0012_019f;
|
||||||
const SCHEMA:&str="CREATE TABLE IF NOT EXISTS system_intent_meta(id INTEGER PRIMARY KEY CHECK(id=1),file_identity BLOB NOT NULL);
|
const SCHEMA:&str="CREATE TABLE IF NOT EXISTS system_intent_meta(id INTEGER PRIMARY KEY CHECK(id=1),file_identity BLOB NOT NULL);
|
||||||
CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),UNIQUE(job,attempt));
|
CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1)),UNIQUE(job,attempt));
|
||||||
CREATE TABLE IF NOT EXISTS system_intent_mirrors(id TEXT PRIMARY KEY,outcome_sha256 TEXT NOT NULL,mirror_observed_at TEXT NOT NULL);
|
CREATE TABLE IF NOT EXISTS system_intent_mirrors(id TEXT PRIMARY KEY,outcome_sha256 TEXT NOT NULL,mirror_observed_at TEXT NOT NULL);
|
||||||
CREATE TABLE IF NOT EXISTS system_intent_denial_resumes(id TEXT NOT NULL,agent_instance TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(id,agent_instance));
|
CREATE TABLE IF NOT EXISTS system_intent_denial_resumes(id TEXT NOT NULL,agent_instance TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(id,agent_instance));
|
||||||
CREATE TRIGGER IF NOT EXISTS system_intents_no_delete BEFORE DELETE ON system_intents BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;
|
CREATE TRIGGER IF NOT EXISTS system_intents_no_delete BEFORE DELETE ON system_intents BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;
|
||||||
CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;
|
CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR NOT ((NEW.phase=OLD.phase AND NEW.cancel_requested=1 AND OLD.cancel_requested IN (0,1)) OR (OLD.phase='prepared' AND NEW.phase IN ('known_no_dispatch','may_have_dispatched') AND NEW.cancel_requested=OLD.cancel_requested)) BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;
|
||||||
CREATE TRIGGER IF NOT EXISTS system_mirrors_no_delete BEFORE DELETE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END;
|
CREATE TRIGGER IF NOT EXISTS system_mirrors_no_delete BEFORE DELETE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END;
|
||||||
CREATE TRIGGER IF NOT EXISTS system_mirrors_no_update BEFORE UPDATE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END;
|
CREATE TRIGGER IF NOT EXISTS system_mirrors_no_update BEFORE UPDATE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END;
|
||||||
CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_delete BEFORE DELETE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;
|
CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_delete BEFORE DELETE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;
|
||||||
CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_update BEFORE UPDATE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;";
|
CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_update BEFORE UPDATE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;";
|
||||||
|
const LEGACY_INTENTS_TABLE: &str = "CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),UNIQUE(job,attempt));";
|
||||||
|
const LEGACY_MONOTONIC: &str = "CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;";
|
||||||
const CLAIM_RESUME: &str = "INSERT OR IGNORE INTO system_intent_denial_resumes(id,agent_instance,observed_at) VALUES(?1,?2,?3)";
|
const CLAIM_RESUME: &str = "INSERT OR IGNORE INTO system_intent_denial_resumes(id,agent_instance,observed_at) VALUES(?1,?2,?3)";
|
||||||
|
fn initialize_schema(db: &mut Connection) -> Result<()> {
|
||||||
|
let exists: bool = db.query_row(
|
||||||
|
"SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='system_intents')",
|
||||||
|
[],
|
||||||
|
|r| r.get(0),
|
||||||
|
)?;
|
||||||
|
if exists {
|
||||||
|
let columns = db
|
||||||
|
.prepare("PRAGMA table_info(system_intents)")?
|
||||||
|
.query_map([], |r| r.get::<_, String>(1))?
|
||||||
|
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||||
|
if !columns.iter().any(|name| name == "cancel_requested") {
|
||||||
|
ensure!(
|
||||||
|
columns
|
||||||
|
== [
|
||||||
|
"id", "job", "attempt", "grant_id", "body", "digest", "phase"
|
||||||
|
],
|
||||||
|
"SYSTEM_INTENT_LEGACY_SCHEMA"
|
||||||
|
);
|
||||||
|
let old:String=db.query_row("SELECT sql FROM sqlite_master WHERE type='trigger' AND name='system_intents_monotonic'",[],|r|r.get(0))?;
|
||||||
|
let normalize = |s: &str| {
|
||||||
|
s.replace("IF NOT EXISTS ", "")
|
||||||
|
.trim_end_matches(';')
|
||||||
|
.split_whitespace()
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
.join(" ")
|
||||||
|
};
|
||||||
|
ensure!(
|
||||||
|
normalize(&old) == normalize(LEGACY_MONOTONIC),
|
||||||
|
"SYSTEM_INTENT_LEGACY_TRIGGER"
|
||||||
|
);
|
||||||
|
let table: String = db.query_row(
|
||||||
|
"SELECT sql FROM sqlite_master WHERE type='table' AND name='system_intents'",
|
||||||
|
[],
|
||||||
|
|r| r.get(0),
|
||||||
|
)?;
|
||||||
|
ensure!(
|
||||||
|
normalize(&table) == normalize(LEGACY_INTENTS_TABLE),
|
||||||
|
"SYSTEM_INTENT_LEGACY_SCHEMA"
|
||||||
|
);
|
||||||
|
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||||
|
tx.execute_batch("ALTER TABLE system_intents ADD COLUMN cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1));DROP TRIGGER system_intents_monotonic;")?;
|
||||||
|
tx.execute_batch(SCHEMA)?;
|
||||||
|
tx.commit()?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
db.execute_batch(SCHEMA)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
#[derive(Clone, Serialize, Deserialize)]
|
#[derive(Clone, Serialize, Deserialize)]
|
||||||
#[serde(deny_unknown_fields)]
|
#[serde(deny_unknown_fields)]
|
||||||
pub struct Intent {
|
pub struct Intent {
|
||||||
@@ -148,14 +199,14 @@ impl Store {
|
|||||||
} else {
|
} else {
|
||||||
OpenFlags::SQLITE_OPEN_READ_ONLY
|
OpenFlags::SQLITE_OPEN_READ_ONLY
|
||||||
};
|
};
|
||||||
let db = Connection::open_with_flags(DB, flags)?;
|
let mut db = Connection::open_with_flags(DB, flags)?;
|
||||||
db.busy_timeout(Duration::from_millis(250))?;
|
db.busy_timeout(Duration::from_millis(250))?;
|
||||||
if write {
|
if write {
|
||||||
rmm_agent_core::ledger::bounded_journal_capacity(&db)?;
|
rmm_agent_core::ledger::bounded_journal_capacity(&db)?;
|
||||||
let mode: String = db.query_row("PRAGMA journal_mode=PERSIST", [], |r| r.get(0))?;
|
let mode: String = db.query_row("PRAGMA journal_mode=PERSIST", [], |r| r.get(0))?;
|
||||||
ensure!(mode == "persist", "SYSTEM_INTENT_JOURNAL_MODE");
|
ensure!(mode == "persist", "SYSTEM_INTENT_JOURNAL_MODE");
|
||||||
db.execute_batch("PRAGMA synchronous=FULL;PRAGMA temp_store=MEMORY;PRAGMA journal_size_limit=1048576;")?;
|
db.execute_batch("PRAGMA synchronous=FULL;PRAGMA temp_store=MEMORY;PRAGMA journal_size_limit=1048576;")?;
|
||||||
db.execute_batch(SCHEMA)?;
|
initialize_schema(&mut db)?;
|
||||||
db.execute(
|
db.execute(
|
||||||
"INSERT OR IGNORE INTO system_intent_meta VALUES(1,?1)",
|
"INSERT OR IGNORE INTO system_intent_meta VALUES(1,?1)",
|
||||||
[serde_json::to_vec(&identity)?],
|
[serde_json::to_vec(&identity)?],
|
||||||
@@ -241,10 +292,60 @@ impl Store {
|
|||||||
}
|
}
|
||||||
pub fn cancel_before_dispatch(&mut self, id: Uuid) -> Result<Phase> {
|
pub fn cancel_before_dispatch(&mut self, id: Uuid) -> Result<Phase> {
|
||||||
self.check()?;
|
self.check()?;
|
||||||
|
self.db.execute(
|
||||||
|
"UPDATE system_intents SET cancel_requested=1 WHERE id=?1",
|
||||||
|
[id.to_string()],
|
||||||
|
)?;
|
||||||
let (_, phase) = advance(&mut self.db, id, Phase::KnownNoDispatch)?;
|
let (_, phase) = advance(&mut self.db, id, Phase::KnownNoDispatch)?;
|
||||||
self.check()?;
|
self.check()?;
|
||||||
Ok(phase)
|
Ok(phase)
|
||||||
}
|
}
|
||||||
|
/// Denial only. Original phase/request/anchor never changes, even after IPC.
|
||||||
|
pub fn deny(&mut self, original: &Request, boot: Uuid) -> Result<()> {
|
||||||
|
self.check()?;
|
||||||
|
let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?;
|
||||||
|
let intent = self.by_grant(permit.grant_id)?;
|
||||||
|
ensure!(
|
||||||
|
serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)?
|
||||||
|
&& intent.original_boot_id == boot,
|
||||||
|
"SYSTEM_CANCEL_ORIGINAL_BINDING"
|
||||||
|
);
|
||||||
|
self.db.execute(
|
||||||
|
"UPDATE system_intents SET cancel_requested=1 WHERE id=?1",
|
||||||
|
[intent.id.to_string()],
|
||||||
|
)?;
|
||||||
|
self.check()
|
||||||
|
}
|
||||||
|
/// Open a new ordinary RO connection for each observation. No long-lived
|
||||||
|
/// SQLite read transaction or immutable-mode shortcut may hide actor denial.
|
||||||
|
pub fn require_not_denied(
|
||||||
|
original: &Request,
|
||||||
|
boot: Uuid,
|
||||||
|
generation: u64,
|
||||||
|
policy: &str,
|
||||||
|
binary: &str,
|
||||||
|
) -> Result<()> {
|
||||||
|
let mut store = Self::open(false)?;
|
||||||
|
let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?;
|
||||||
|
let intent = store.by_grant(permit.grant_id)?;
|
||||||
|
let (_, phase) = store.load(intent.id)?;
|
||||||
|
ensure!(
|
||||||
|
serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)?
|
||||||
|
&& intent.original_boot_id == boot
|
||||||
|
&& intent.connection_generation == generation
|
||||||
|
&& phase == Phase::MayHaveDispatched
|
||||||
|
&& intent.policy_sha256 == policy
|
||||||
|
&& intent.helper_binary_sha256 == binary,
|
||||||
|
"SYSTEM_CANCEL_ORIGINAL_BINDING"
|
||||||
|
);
|
||||||
|
let denied: i64 = store.db.query_row(
|
||||||
|
"SELECT cancel_requested FROM system_intents WHERE id=?1",
|
||||||
|
[intent.id.to_string()],
|
||||||
|
|r| r.get(0),
|
||||||
|
)?;
|
||||||
|
ensure!(denied == 0, "SYSTEM_MSI_CANCELLED_OR_FENCED");
|
||||||
|
store.check()
|
||||||
|
}
|
||||||
pub fn pending(&self) -> Result<Vec<Intent>> {
|
pub fn pending(&self) -> Result<Vec<Intent>> {
|
||||||
let mut rows=self.db.prepare("SELECT i.id FROM system_intents i WHERE NOT EXISTS(SELECT 1 FROM system_intent_mirrors m WHERE m.id=i.id) ORDER BY i.rowid LIMIT 2")?;
|
let mut rows=self.db.prepare("SELECT i.id FROM system_intents i WHERE NOT EXISTS(SELECT 1 FROM system_intent_mirrors m WHERE m.id=i.id) ORDER BY i.rowid LIMIT 2")?;
|
||||||
let ids = rows
|
let ids = rows
|
||||||
@@ -356,7 +457,7 @@ mod tests {
|
|||||||
let dispatched = Uuid::new_v4();
|
let dispatched = Uuid::new_v4();
|
||||||
for id in [cancelled, dispatched] {
|
for id in [cancelled, dispatched] {
|
||||||
db.execute(
|
db.execute(
|
||||||
"INSERT INTO system_intents VALUES(?1,?1,?1,?1,x'01','immutable','prepared')",
|
"INSERT INTO system_intents(id,job,attempt,grant_id,body,digest,phase) VALUES(?1,?1,?1,?1,x'01','immutable','prepared')",
|
||||||
[id.to_string()],
|
[id.to_string()],
|
||||||
)
|
)
|
||||||
.unwrap();
|
.unwrap();
|
||||||
@@ -377,6 +478,29 @@ mod tests {
|
|||||||
advance(&mut db, dispatched, Phase::KnownNoDispatch).unwrap(),
|
advance(&mut db, dispatched, Phase::KnownNoDispatch).unwrap(),
|
||||||
(0, Phase::MayHaveDispatched)
|
(0, Phase::MayHaveDispatched)
|
||||||
);
|
);
|
||||||
|
for _ in 0..2 {
|
||||||
|
db.execute(
|
||||||
|
"UPDATE system_intents SET cancel_requested=1 WHERE id=?1",
|
||||||
|
[dispatched.to_string()],
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
assert_eq!(
|
||||||
|
db.query_row(
|
||||||
|
"SELECT phase,cancel_requested FROM system_intents WHERE id=?1",
|
||||||
|
[dispatched.to_string()],
|
||||||
|
|r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?))
|
||||||
|
)
|
||||||
|
.unwrap(),
|
||||||
|
("may_have_dispatched".into(), 1)
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
db.execute(
|
||||||
|
"UPDATE system_intents SET cancel_requested=0 WHERE id=?1",
|
||||||
|
[dispatched.to_string()]
|
||||||
|
)
|
||||||
|
.is_err()
|
||||||
|
);
|
||||||
assert!(
|
assert!(
|
||||||
db.execute(
|
db.execute(
|
||||||
"UPDATE system_intents SET phase='prepared' WHERE id=?1",
|
"UPDATE system_intents SET phase='prepared' WHERE id=?1",
|
||||||
@@ -411,4 +535,45 @@ mod tests {
|
|||||||
assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 1);
|
assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 1);
|
||||||
assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 0);
|
assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 0);
|
||||||
}
|
}
|
||||||
|
#[test]
|
||||||
|
fn additive_denial_column_preserves_original_legacy_intents_and_rejects_unknown_trigger() {
|
||||||
|
let mut db = Connection::open_in_memory().unwrap();
|
||||||
|
db.execute_batch(LEGACY_INTENTS_TABLE).unwrap();
|
||||||
|
db.execute_batch(LEGACY_MONOTONIC).unwrap();
|
||||||
|
db.execute("INSERT INTO system_intents VALUES('id','job','attempt','grant',x'0102','original','may_have_dispatched')",[]).unwrap();
|
||||||
|
initialize_schema(&mut db).unwrap();
|
||||||
|
initialize_schema(&mut db).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
db.query_row(
|
||||||
|
"SELECT body,digest,phase,cancel_requested FROM system_intents",
|
||||||
|
[],
|
||||||
|
|r| Ok((
|
||||||
|
r.get::<_, Vec<u8>>(0)?,
|
||||||
|
r.get::<_, String>(1)?,
|
||||||
|
r.get::<_, String>(2)?,
|
||||||
|
r.get::<_, i64>(3)?
|
||||||
|
))
|
||||||
|
)
|
||||||
|
.unwrap(),
|
||||||
|
(
|
||||||
|
vec![1, 2],
|
||||||
|
"original".into(),
|
||||||
|
"may_have_dispatched".into(),
|
||||||
|
0
|
||||||
|
)
|
||||||
|
);
|
||||||
|
db.execute("UPDATE system_intents SET cancel_requested=1", [])
|
||||||
|
.unwrap();
|
||||||
|
assert!(
|
||||||
|
db.execute("UPDATE system_intents SET body=x'03'", [])
|
||||||
|
.is_err()
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
db.execute("UPDATE system_intents SET cancel_requested=0", [])
|
||||||
|
.is_err()
|
||||||
|
);
|
||||||
|
let mut foreign = Connection::open_in_memory().unwrap();
|
||||||
|
foreign.execute_batch("CREATE TABLE system_intents(id,job,attempt,grant_id,body,digest,phase);CREATE TRIGGER system_intents_monotonic BEFORE UPDATE ON system_intents BEGIN SELECT 1;END;").unwrap();
|
||||||
|
assert!(initialize_schema(&mut foreign).is_err());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -7,6 +7,7 @@ use rmm_agent_core::{
|
|||||||
};
|
};
|
||||||
use rmm_domain::jobs::hash;
|
use rmm_domain::jobs::hash;
|
||||||
use serde::{Deserialize, Serialize, de::DeserializeOwned};
|
use serde::{Deserialize, Serialize, de::DeserializeOwned};
|
||||||
|
use sha2::{Digest, Sha256};
|
||||||
use std::{
|
use std::{
|
||||||
ffi::c_void,
|
ffi::c_void,
|
||||||
fs::File,
|
fs::File,
|
||||||
@@ -29,7 +30,13 @@ use windows_sys::Win32::{
|
|||||||
};
|
};
|
||||||
|
|
||||||
pub const HELPER_SERVICE: &str = "RmmDiscoverySystemHelper";
|
pub const HELPER_SERVICE: &str = "RmmDiscoverySystemHelper";
|
||||||
pub const PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-v1";
|
// Framing v2 is deliberately a separate endpoint. Old peers cannot send a
|
||||||
|
// v1 call to this server or interpret the drain receipt as another reply.
|
||||||
|
pub const PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-v2";
|
||||||
|
const FRAME_TAG: [u8; 8] = *b"RDPIPC02";
|
||||||
|
const DRAIN_TAG: [u8; 8] = *b"RDPACK02";
|
||||||
|
const FRAME_HEADER_LEN: usize = 12;
|
||||||
|
const DRAIN_RECEIPT_LEN: usize = 56;
|
||||||
pub const FRAME_LIMIT: usize = 1024 * 1024;
|
pub const FRAME_LIMIT: usize = 1024 * 1024;
|
||||||
pub const CLIENT_PIPE_RIGHTS: u32 = 0x0012_0083; // data R/W, attributes R, RC, synchronize; no bit4
|
pub const CLIENT_PIPE_RIGHTS: u32 = 0x0012_0083; // data R/W, attributes R, RC, synchronize; no bit4
|
||||||
const READ_MASK: u32 = 0x0012_00a9;
|
const READ_MASK: u32 = 0x0012_00a9;
|
||||||
@@ -44,6 +51,7 @@ pub enum Stage {
|
|||||||
ClientSendFrame,
|
ClientSendFrame,
|
||||||
ClientReadReply,
|
ClientReadReply,
|
||||||
ClientReplyBinding,
|
ClientReplyBinding,
|
||||||
|
ClientDrainReceipt,
|
||||||
ClientReport,
|
ClientReport,
|
||||||
ServerConnect,
|
ServerConnect,
|
||||||
ServerReadHeader,
|
ServerReadHeader,
|
||||||
@@ -54,6 +62,7 @@ pub enum Stage {
|
|||||||
ServerCallBinding,
|
ServerCallBinding,
|
||||||
ServerRecheckPeer,
|
ServerRecheckPeer,
|
||||||
ServerReply,
|
ServerReply,
|
||||||
|
ServerDrainReceipt,
|
||||||
Unclassified,
|
Unclassified,
|
||||||
}
|
}
|
||||||
impl Stage {
|
impl Stage {
|
||||||
@@ -66,6 +75,7 @@ impl Stage {
|
|||||||
Self::ClientSendFrame => "client_send_frame",
|
Self::ClientSendFrame => "client_send_frame",
|
||||||
Self::ClientReadReply => "client_read_reply",
|
Self::ClientReadReply => "client_read_reply",
|
||||||
Self::ClientReplyBinding => "client_reply_binding",
|
Self::ClientReplyBinding => "client_reply_binding",
|
||||||
|
Self::ClientDrainReceipt => "client_drain_receipt",
|
||||||
Self::ClientReport => "client_report",
|
Self::ClientReport => "client_report",
|
||||||
Self::ServerConnect => "server_connect",
|
Self::ServerConnect => "server_connect",
|
||||||
Self::ServerReadHeader => "server_read_header",
|
Self::ServerReadHeader => "server_read_header",
|
||||||
@@ -76,6 +86,7 @@ impl Stage {
|
|||||||
Self::ServerCallBinding => "server_call_binding",
|
Self::ServerCallBinding => "server_call_binding",
|
||||||
Self::ServerRecheckPeer => "server_recheck_peer",
|
Self::ServerRecheckPeer => "server_recheck_peer",
|
||||||
Self::ServerReply => "server_reply",
|
Self::ServerReply => "server_reply",
|
||||||
|
Self::ServerDrainReceipt => "server_drain_receipt",
|
||||||
Self::Unclassified => "unclassified",
|
Self::Unclassified => "unclassified",
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -123,6 +134,8 @@ fn known_code(text: &str) -> Option<&'static str> {
|
|||||||
"HELPER_FRAME_CAPACITY",
|
"HELPER_FRAME_CAPACITY",
|
||||||
"HELPER_FRAME_EMPTY",
|
"HELPER_FRAME_EMPTY",
|
||||||
"HELPER_FRAME_LENGTH",
|
"HELPER_FRAME_LENGTH",
|
||||||
|
"HELPER_FRAME_VERSION",
|
||||||
|
"HELPER_DRAIN_RECEIPT",
|
||||||
"HELPER_HANDLE",
|
"HELPER_HANDLE",
|
||||||
"HELPER_IMAGE_PARENT",
|
"HELPER_IMAGE_PARENT",
|
||||||
"HELPER_IMAGE_SIZE",
|
"HELPER_IMAGE_SIZE",
|
||||||
@@ -1189,27 +1202,60 @@ fn encode(value: &impl Serialize) -> Result<Vec<u8>> {
|
|||||||
ensure!(!writer.0.is_empty(), "HELPER_FRAME_EMPTY");
|
ensure!(!writer.0.is_empty(), "HELPER_FRAME_EMPTY");
|
||||||
Ok(writer.0)
|
Ok(writer.0)
|
||||||
}
|
}
|
||||||
fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> {
|
fn frame_header(len: usize) -> Result<[u8; FRAME_HEADER_LEN]> {
|
||||||
let mut bytes = encode(value)?;
|
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
|
||||||
let mut header = u32::try_from(bytes.len())?.to_be_bytes();
|
let mut header = [0; FRAME_HEADER_LEN];
|
||||||
transfer(pipe, &mut header, true, deadline)?;
|
header[..8].copy_from_slice(&FRAME_TAG);
|
||||||
transfer(pipe, &mut bytes, true, deadline)
|
header[8..].copy_from_slice(&u32::try_from(len)?.to_be_bytes());
|
||||||
|
Ok(header)
|
||||||
}
|
}
|
||||||
fn frame_length(header: [u8; 4]) -> Result<usize> {
|
fn send_bytes(pipe: HANDLE, bytes: &mut [u8], deadline: Instant) -> Result<()> {
|
||||||
let len = u32::from_be_bytes(header) as usize;
|
let mut header = frame_header(bytes.len())?;
|
||||||
|
transfer(pipe, &mut header, true, deadline)?;
|
||||||
|
transfer(pipe, bytes, true, deadline)
|
||||||
|
}
|
||||||
|
fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> {
|
||||||
|
send_bytes(pipe, &mut encode(value)?, deadline)
|
||||||
|
}
|
||||||
|
fn frame_length(header: [u8; FRAME_HEADER_LEN]) -> Result<usize> {
|
||||||
|
ensure!(header[..8] == FRAME_TAG, "HELPER_FRAME_VERSION");
|
||||||
|
let len = u32::from_be_bytes(header[8..].try_into()?) as usize;
|
||||||
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
|
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
|
||||||
Ok(len)
|
Ok(len)
|
||||||
}
|
}
|
||||||
fn length(pipe: HANDLE, deadline: Instant) -> Result<usize> {
|
fn length(pipe: HANDLE, deadline: Instant) -> Result<usize> {
|
||||||
let mut header = [0u8; 4];
|
let mut header = [0u8; FRAME_HEADER_LEN];
|
||||||
transfer(pipe, &mut header, false, deadline)?;
|
transfer(pipe, &mut header, false, deadline)?;
|
||||||
frame_length(header)
|
frame_length(header)
|
||||||
}
|
}
|
||||||
fn body<T: DeserializeOwned>(pipe: HANDLE, len: usize, deadline: Instant) -> Result<T> {
|
fn body_bytes(pipe: HANDLE, len: usize, deadline: Instant) -> Result<Vec<u8>> {
|
||||||
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
|
ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH");
|
||||||
let mut bytes = vec![0u8; len];
|
let mut bytes = vec![0u8; len];
|
||||||
transfer(pipe, &mut bytes, false, deadline)?;
|
transfer(pipe, &mut bytes, false, deadline)?;
|
||||||
Ok(serde_json::from_slice(&bytes)?)
|
Ok(bytes)
|
||||||
|
}
|
||||||
|
fn body<T: DeserializeOwned>(pipe: HANDLE, len: usize, deadline: Instant) -> Result<T> {
|
||||||
|
Ok(serde_json::from_slice(&body_bytes(pipe, len, deadline)?)?)
|
||||||
|
}
|
||||||
|
// This fixed-size receipt only acknowledges receipt of these transport bytes.
|
||||||
|
// It never acknowledges durable evidence, clears state, or permits an effect.
|
||||||
|
fn drain_receipt(challenge: Uuid, reply_bytes: &[u8]) -> [u8; DRAIN_RECEIPT_LEN] {
|
||||||
|
let mut receipt = [0; DRAIN_RECEIPT_LEN];
|
||||||
|
receipt[..8].copy_from_slice(&DRAIN_TAG);
|
||||||
|
receipt[8..24].copy_from_slice(challenge.as_bytes());
|
||||||
|
receipt[24..].copy_from_slice(&Sha256::digest(reply_bytes));
|
||||||
|
receipt
|
||||||
|
}
|
||||||
|
fn verify_drain_receipt(
|
||||||
|
receipt: &[u8; DRAIN_RECEIPT_LEN],
|
||||||
|
challenge: Uuid,
|
||||||
|
reply_bytes: &[u8],
|
||||||
|
) -> Result<()> {
|
||||||
|
ensure!(
|
||||||
|
*receipt == drain_receipt(challenge, reply_bytes),
|
||||||
|
"HELPER_DRAIN_RECEIPT"
|
||||||
|
);
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct Server {
|
pub struct Server {
|
||||||
@@ -1305,13 +1351,24 @@ impl Server {
|
|||||||
peer.check().context(Stage::ServerRecheckPeer)?;
|
peer.check().context(Stage::ServerRecheckPeer)?;
|
||||||
Ok(Some(Received { call, peer }))
|
Ok(Some(Received { call, peer }))
|
||||||
}
|
}
|
||||||
pub fn reply(&self, value: &Reply) -> Result<()> {
|
pub fn reply(&self, value: &Reply, peer: &mut PeerProof) -> Result<()> {
|
||||||
send(
|
// Do not disconnect after WriteFile merely copied bytes into a pipe
|
||||||
self.pipe.as_raw_handle(),
|
// buffer. Wait for a receipt from the same fully pinned peer within
|
||||||
value,
|
// the original reply deadline, without an unbounded FlushFileBuffers.
|
||||||
Instant::now() + Duration::from_secs(5),
|
let deadline = Instant::now() + Duration::from_secs(5);
|
||||||
)
|
peer.check().context(Stage::ServerRecheckPeer)?;
|
||||||
.context(Stage::ServerReply)
|
let mut bytes = encode(value).context(Stage::ServerReply)?;
|
||||||
|
send_bytes(self.pipe.as_raw_handle(), &mut bytes, deadline).context(Stage::ServerReply)?;
|
||||||
|
let mut receipt = [0; DRAIN_RECEIPT_LEN];
|
||||||
|
transfer(self.pipe.as_raw_handle(), &mut receipt, false, deadline)
|
||||||
|
.context(Stage::ServerDrainReceipt)?;
|
||||||
|
verify_drain_receipt(&receipt, value.challenge, &bytes)
|
||||||
|
.context(Stage::ServerDrainReceipt)?;
|
||||||
|
peer.check().context(Stage::ServerRecheckPeer)?;
|
||||||
|
if Instant::now() >= deadline {
|
||||||
|
return Err(anyhow::anyhow!("HELPER_PIPE_TIMEOUT")).context(Stage::ServerDrainReceipt);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
pub fn disconnect(&self) {
|
pub fn disconnect(&self) {
|
||||||
unsafe {
|
unsafe {
|
||||||
@@ -1345,7 +1402,9 @@ pub fn exchange(pin: &Pin, call: &Call, timeout: Duration) -> Result<Reply> {
|
|||||||
.context(Stage::ClientHelperPeer)?;
|
.context(Stage::ClientHelperPeer)?;
|
||||||
send(pipe.as_raw_handle(), call, deadline).context(Stage::ClientSendFrame)?;
|
send(pipe.as_raw_handle(), call, deadline).context(Stage::ClientSendFrame)?;
|
||||||
let len = length(pipe.as_raw_handle(), deadline).context(Stage::ClientReadReply)?;
|
let len = length(pipe.as_raw_handle(), deadline).context(Stage::ClientReadReply)?;
|
||||||
let reply: Reply = body(pipe.as_raw_handle(), len, deadline).context(Stage::ClientReadReply)?;
|
let reply_bytes =
|
||||||
|
body_bytes(pipe.as_raw_handle(), len, deadline).context(Stage::ClientReadReply)?;
|
||||||
|
let reply: Reply = serde_json::from_slice(&reply_bytes).context(Stage::ClientReadReply)?;
|
||||||
peer.check().context(Stage::ClientHelperPeer)?;
|
peer.check().context(Stage::ClientHelperPeer)?;
|
||||||
if !(reply.schema_version == 1
|
if !(reply.schema_version == 1
|
||||||
&& reply.challenge == call.challenge
|
&& reply.challenge == call.challenge
|
||||||
@@ -1366,6 +1425,11 @@ pub fn exchange(pin: &Pin, call: &Call, timeout: Duration) -> Result<Reply> {
|
|||||||
) {
|
) {
|
||||||
return Err(anyhow::anyhow!("HELPER_REPLY_OPERATION")).context(Stage::ClientReplyBinding);
|
return Err(anyhow::anyhow!("HELPER_REPLY_OPERATION")).context(Stage::ClientReplyBinding);
|
||||||
}
|
}
|
||||||
|
// Only a complete, authenticated, bound and operation-checked reply gets
|
||||||
|
// this receipt. Hash the received bytes, never a JSON re-serialization.
|
||||||
|
let mut receipt = drain_receipt(call.challenge, &reply_bytes);
|
||||||
|
transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)
|
||||||
|
.context(Stage::ClientDrainReceipt)?;
|
||||||
Ok(reply)
|
Ok(reply)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1388,12 +1452,21 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn untrusted_lengths_are_rejected_before_body_allocation() {
|
fn untrusted_lengths_are_rejected_before_body_allocation() {
|
||||||
for n in [0, (FRAME_LIMIT + 1) as u32, u32::MAX] {
|
for n in [0, (FRAME_LIMIT + 1) as u32, u32::MAX] {
|
||||||
assert!(frame_length(n.to_be_bytes()).is_err());
|
let mut header = [0; FRAME_HEADER_LEN];
|
||||||
|
header[..8].copy_from_slice(&FRAME_TAG);
|
||||||
|
header[8..].copy_from_slice(&n.to_be_bytes());
|
||||||
|
assert!(frame_length(header).is_err());
|
||||||
|
assert!(frame_header(n as usize).is_err());
|
||||||
}
|
}
|
||||||
assert_eq!(
|
let header = frame_header(FRAME_LIMIT).unwrap();
|
||||||
frame_length((FRAME_LIMIT as u32).to_be_bytes()).unwrap(),
|
assert_eq!(frame_length(header).unwrap(), FRAME_LIMIT);
|
||||||
FRAME_LIMIT
|
// Neither a v1 length prefix nor another framing version is accepted.
|
||||||
);
|
let mut old = [0; FRAME_HEADER_LEN];
|
||||||
|
old[..4].copy_from_slice(&1u32.to_be_bytes());
|
||||||
|
assert!(frame_length(old).is_err());
|
||||||
|
let mut foreign = header;
|
||||||
|
foreign[7] = b'1';
|
||||||
|
assert!(frame_length(foreign).is_err());
|
||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
fn protocol_does_not_accept_a_shell_operation() {
|
fn protocol_does_not_accept_a_shell_operation() {
|
||||||
@@ -1417,6 +1490,22 @@ mod tests {
|
|||||||
assert_eq!(diagnostic(&caller).code, "UNCLASSIFIED_IO_OR_CODEC");
|
assert_eq!(diagnostic(&caller).code, "UNCLASSIFIED_IO_OR_CODEC");
|
||||||
let remote = remote_denial(Stage::ClientReplyBinding, "caller-payload-private-marker");
|
let remote = remote_denial(Stage::ClientReplyBinding, "caller-payload-private-marker");
|
||||||
assert_eq!(diagnostic(&remote).code, "UNCLASSIFIED_REMOTE_DENIAL");
|
assert_eq!(diagnostic(&remote).code, "UNCLASSIFIED_REMOTE_DENIAL");
|
||||||
|
let challenge = Uuid::from_u128(1);
|
||||||
|
let raw = br#"{"a":1,"b":2}"#;
|
||||||
|
let receipt = drain_receipt(challenge, raw);
|
||||||
|
assert!(verify_drain_receipt(&receipt, challenge, raw).is_ok());
|
||||||
|
// Same JSON meaning, different exact bytes must not drain this reply.
|
||||||
|
assert!(verify_drain_receipt(&receipt, challenge, br#"{"b":2,"a":1}"#).is_err());
|
||||||
|
assert!(verify_drain_receipt(&receipt, Uuid::from_u128(2), raw).is_err());
|
||||||
|
for offset in [0, 7, 8, 23, 24, DRAIN_RECEIPT_LEN - 1] {
|
||||||
|
let mut changed = receipt;
|
||||||
|
changed[offset] ^= 1;
|
||||||
|
let error = verify_drain_receipt(&changed, challenge, raw)
|
||||||
|
.unwrap_err()
|
||||||
|
.context(Stage::ServerDrainReceipt);
|
||||||
|
assert_eq!(diagnostic(&error).code, "HELPER_DRAIN_RECEIPT");
|
||||||
|
assert_eq!(diagnostic(&error).stage, "server_drain_receipt");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
#[test]
|
#[test]
|
||||||
fn reconfigured_service_cannot_adopt_an_old_running_identity() {
|
fn reconfigured_service_cannot_adopt_an_old_running_identity() {
|
||||||
|
|||||||
@@ -470,6 +470,13 @@ fn verified_mirror_row(
|
|||||||
Ok(outcome)
|
Ok(outcome)
|
||||||
}
|
}
|
||||||
fn system_shape(job: &JobPayload) -> bool {
|
fn system_shape(job: &JobPayload) -> bool {
|
||||||
|
if job.action.windows_msi().is_some() {
|
||||||
|
return job.execution_identity == "system"
|
||||||
|
&& job.action.validate()
|
||||||
|
&& job
|
||||||
|
.action
|
||||||
|
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes);
|
||||||
|
}
|
||||||
job.execution_identity == "system"
|
job.execution_identity == "system"
|
||||||
&& (1..=120).contains(&job.max_runtime_seconds)
|
&& (1..=120).contains(&job.max_runtime_seconds)
|
||||||
&& (1..=65536).contains(&job.max_output_bytes)
|
&& (1..=65536).contains(&job.max_output_bytes)
|
||||||
@@ -487,7 +494,7 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()>
|
|||||||
matches!(
|
matches!(
|
||||||
outcome.state.as_str(),
|
outcome.state.as_str(),
|
||||||
"succeeded" | "failed" | "cancelled" | "expired" | "unknown"
|
"succeeded" | "failed" | "cancelled" | "expired" | "unknown"
|
||||||
) && !outcome.reboot_required
|
) && (job.action.windows_msi().is_some() || !outcome.reboot_required)
|
||||||
&& outcome
|
&& outcome
|
||||||
.stdout
|
.stdout
|
||||||
.len()
|
.len()
|
||||||
@@ -496,6 +503,47 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()>
|
|||||||
"SYSTEM_EXECUTE_OUTCOME_SCOPE"
|
"SYSTEM_EXECUTE_OUTCOME_SCOPE"
|
||||||
);
|
);
|
||||||
if outcome.state == "succeeded" {
|
if outcome.state == "succeeded" {
|
||||||
|
if let Some(m) = job.action.windows_msi() {
|
||||||
|
let e = &outcome.evidence;
|
||||||
|
let after: crate::package::Snapshot = serde_json::from_value(e["after"].clone())?;
|
||||||
|
let noop = e["already_desired"] == true;
|
||||||
|
ensure!(
|
||||||
|
job.action.validate()
|
||||||
|
&& e["provider"] == "windows.msi.fixture/1"
|
||||||
|
&& e["recipe_sha256"] == m.recipe_sha256
|
||||||
|
&& e["artifact_sha256"] == m.recipe.artifact.sha256
|
||||||
|
&& e["postconditions_passed"] == true
|
||||||
|
&& e["state"] == "succeeded"
|
||||||
|
&& e["exit_code"] == serde_json::to_value(outcome.exit_code)?
|
||||||
|
&& e["already_desired"].is_boolean()
|
||||||
|
&& !outcome.output_truncated
|
||||||
|
&& e["reboot_initiated"] == false
|
||||||
|
&& e["automatic_retry"] == false
|
||||||
|
&& after.desired(m),
|
||||||
|
"SYSTEM_MSI_POSTCONDITION_BINDING"
|
||||||
|
);
|
||||||
|
if noop {
|
||||||
|
let before: crate::package::Snapshot = serde_json::from_value(e["before"].clone())?;
|
||||||
|
ensure!(
|
||||||
|
outcome.exit_code.is_none()
|
||||||
|
&& !outcome.reboot_required
|
||||||
|
&& e["installer_process_started"] == false
|
||||||
|
&& e["transaction_started"] == false
|
||||||
|
&& e["installer_reboot_required"].is_null()
|
||||||
|
&& before.desired(m),
|
||||||
|
"SYSTEM_MSI_NOOP_BINDING"
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
ensure!(
|
||||||
|
matches!(outcome.exit_code, Some(0 | 3010))
|
||||||
|
&& e["installer_process_started"] == true
|
||||||
|
&& outcome.reboot_required == (outcome.exit_code == Some(3010))
|
||||||
|
&& e["installer_reboot_required"] == outcome.reboot_required,
|
||||||
|
"SYSTEM_MSI_EXIT_BINDING"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
let Action::SetServiceState { unit, state } = &job.action else {
|
let Action::SetServiceState { unit, state } = &job.action else {
|
||||||
anyhow::bail!("SYSTEM_TYPED_SERVICE_REQUIRED");
|
anyhow::bail!("SYSTEM_TYPED_SERVICE_REQUIRED");
|
||||||
};
|
};
|
||||||
@@ -537,6 +585,43 @@ pub fn map_snapshot(s: &Snapshot) -> HelperSnapshot {
|
|||||||
.collect(),
|
.collect(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
#[cfg(test)]
|
||||||
|
pub(crate) fn msi_test_job() -> JobPayload {
|
||||||
|
use rmm_domain::windows_execution::*;
|
||||||
|
let recipe:WindowsMsiRecipe=serde_json::from_value(json!({"schema_version":1,"recipe_id":MSI_RECIPE_ID,"recipe_version":"1","platform":"windows","upgrade_code":MSI_UPGRADE_CODE,"architecture":"x64","context":"machine","command_profile":"fixture_quiet_no_reboot_v1","artifact":{"artifact_id":uuid::Uuid::from_u128(10),"sha256":"ab".repeat(32),"bytes":32768},"postcondition":{"product_code":MSI_PRODUCT_CODE,"product_version":MSI_VERSION,"payload_path":MSI_PAYLOAD,"payload_sha256":MSI_PAYLOAD_10_SHA256,"payload_bytes":33},"no_reboot":true})).unwrap();
|
||||||
|
let manifest = ResolvedWindowsMsi {
|
||||||
|
recipe_sha256: recipe.sha256().unwrap(),
|
||||||
|
recipe,
|
||||||
|
};
|
||||||
|
let now = chrono::Utc::now();
|
||||||
|
let id = uuid::Uuid::from_u128(1);
|
||||||
|
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::EnsurePackage {
|
||||||
|
provider: "msi".into(),
|
||||||
|
package: MSI_PACKAGE_ID.into(),
|
||||||
|
version: MSI_VERSION.into(),
|
||||||
|
architecture: "x64".into(),
|
||||||
|
recipe_version: "1".into(),
|
||||||
|
installation_context: "machine".into(),
|
||||||
|
recipe_id: Some(MSI_RECIPE_ID.into()),
|
||||||
|
apt_manifest: None,
|
||||||
|
windows_msi_manifest: Some(Box::new(manifest)),
|
||||||
|
},
|
||||||
|
execution_identity: "system".into(),
|
||||||
|
not_before: now,
|
||||||
|
start_before: now + chrono::Duration::minutes(2),
|
||||||
|
max_runtime_seconds: 30,
|
||||||
|
max_output_bytes: 4096,
|
||||||
|
}
|
||||||
|
}
|
||||||
fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
|
fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
|
||||||
native::private_path(state, true)?;
|
native::private_path(state, true)?;
|
||||||
let path = state.join(PROBE_FILE);
|
let path = state.join(PROBE_FILE);
|
||||||
@@ -574,6 +659,50 @@ fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
#[test]
|
#[test]
|
||||||
|
fn msi_scope_requires_bound_independent_postconditions_and_exact_noop_or_installer_exit() {
|
||||||
|
let job = msi_test_job();
|
||||||
|
assert!(system_shape(&job));
|
||||||
|
let m = job.action.windows_msi().unwrap();
|
||||||
|
let p = &m.recipe.postcondition;
|
||||||
|
let snapshot = crate::package::Snapshot {
|
||||||
|
product_code: p.product_code.clone(),
|
||||||
|
related_products: vec![p.product_code.clone()],
|
||||||
|
product_state: Some("5".into()),
|
||||||
|
product_version: Some(p.product_version.clone()),
|
||||||
|
payload_sha256: Some(p.payload_sha256.clone()),
|
||||||
|
payload_bytes: Some(p.payload_bytes),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
let mut out = Outcome {
|
||||||
|
state: "succeeded".into(),
|
||||||
|
exit_code: Some(3010),
|
||||||
|
reboot_required: true,
|
||||||
|
evidence: json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":true,"reboot_initiated":false,"automatic_retry":false,"already_desired":false,"state":"succeeded","exit_code":3010,"installer_process_started":true,"installer_reboot_required":true,"after":snapshot,"before":snapshot}),
|
||||||
|
..Outcome::unknown("")
|
||||||
|
};
|
||||||
|
assert!(checked_outcome(&job, &out).is_ok());
|
||||||
|
out.reboot_required = false;
|
||||||
|
assert!(checked_outcome(&job, &out).is_err());
|
||||||
|
out.reboot_required = true;
|
||||||
|
out.evidence["after"]["payload_sha256"] = "cd".repeat(32).into();
|
||||||
|
assert!(checked_outcome(&job, &out).is_err());
|
||||||
|
out.evidence["after"] = serde_json::to_value(&snapshot).unwrap();
|
||||||
|
out.evidence["already_desired"] = true.into();
|
||||||
|
out.evidence["exit_code"] = serde_json::Value::Null;
|
||||||
|
out.exit_code = None;
|
||||||
|
out.reboot_required = false;
|
||||||
|
out.evidence["installer_reboot_required"] = serde_json::Value::Null;
|
||||||
|
out.evidence["installer_process_started"] = false.into();
|
||||||
|
out.evidence["transaction_started"] = false.into();
|
||||||
|
assert!(checked_outcome(&job, &out).is_ok());
|
||||||
|
out.exit_code = Some(0);
|
||||||
|
assert!(checked_outcome(&job, &out).is_err());
|
||||||
|
out.state = "unknown".into();
|
||||||
|
out.reboot_required = true;
|
||||||
|
out.exit_code = Some(1641);
|
||||||
|
assert!(checked_outcome(&job, &out).is_ok());
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
fn system_route_binds_original_request_shape_budget_and_reply_scope() {
|
fn system_route_binds_original_request_shape_budget_and_reply_scope() {
|
||||||
let id = uuid::Uuid::new_v4();
|
let id = uuid::Uuid::new_v4();
|
||||||
let now = chrono::Utc::now();
|
let now = chrono::Utc::now();
|
||||||
|
|||||||
@@ -69,11 +69,49 @@ pub struct Settings {
|
|||||||
pub max_runtime_seconds: u32,
|
pub max_runtime_seconds: u32,
|
||||||
pub enable_effects: bool,
|
pub enable_effects: bool,
|
||||||
pub allow_reboot: bool,
|
pub allow_reboot: bool,
|
||||||
|
#[serde(
|
||||||
|
default,
|
||||||
|
skip_serializing_if = "Option::is_none",
|
||||||
|
deserialize_with = "strict_recipe_hashes"
|
||||||
|
)]
|
||||||
|
pub allowed_msi_recipe_sha256: Option<Vec<String>>,
|
||||||
|
}
|
||||||
|
fn strict_recipe_hashes<'de, D: serde::Deserializer<'de>>(
|
||||||
|
d: D,
|
||||||
|
) -> std::result::Result<Option<Vec<String>>, D::Error> {
|
||||||
|
Vec::<String>::deserialize(d).map(Some)
|
||||||
}
|
}
|
||||||
impl Settings {
|
impl Settings {
|
||||||
|
fn permits_msi(&self, job: &JobPayload) -> bool {
|
||||||
|
self.schema_version == 2
|
||||||
|
&& job.execution_identity == "system"
|
||||||
|
&& job.action.validate()
|
||||||
|
&& job
|
||||||
|
.action
|
||||||
|
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
|
||||||
|
&& job.max_runtime_seconds <= self.max_runtime_seconds
|
||||||
|
&& job.action.windows_msi().is_some_and(|m| {
|
||||||
|
self.allowed_msi_recipe_sha256
|
||||||
|
.as_ref()
|
||||||
|
.is_some_and(|h| h.contains(&m.recipe_sha256))
|
||||||
|
})
|
||||||
|
}
|
||||||
pub fn validate(&self) -> Result<()> {
|
pub fn validate(&self) -> Result<()> {
|
||||||
ensure!(
|
ensure!(
|
||||||
self.schema_version == 1
|
matches!(self.schema_version, 1 | 2)
|
||||||
|
&& (self.schema_version == 2 || self.allowed_msi_recipe_sha256.is_none())
|
||||||
|
&& self
|
||||||
|
.allowed_msi_recipe_sha256
|
||||||
|
.as_ref()
|
||||||
|
.is_none_or(|hashes| {
|
||||||
|
hashes.len() <= 2
|
||||||
|
&& hashes.iter().all(|h| ipc::digest(h))
|
||||||
|
&& hashes
|
||||||
|
.iter()
|
||||||
|
.collect::<std::collections::BTreeSet<_>>()
|
||||||
|
.len()
|
||||||
|
== hashes.len()
|
||||||
|
})
|
||||||
&& !self.allow_reboot
|
&& !self.allow_reboot
|
||||||
&& (1..=120).contains(&self.max_runtime_seconds)
|
&& (1..=120).contains(&self.max_runtime_seconds)
|
||||||
&& self.allowed_services.len() <= 16,
|
&& self.allowed_services.len() <= 16,
|
||||||
@@ -763,6 +801,11 @@ fn verified_window(
|
|||||||
Ok((job, permit, now))
|
Ok((job, permit, now))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
struct UnsettledMsi {
|
||||||
|
grant: Uuid,
|
||||||
|
request_sha256: String,
|
||||||
|
installer: Box<crate::package::Installer>,
|
||||||
|
}
|
||||||
pub struct SystemHelper {
|
pub struct SystemHelper {
|
||||||
settings: Settings,
|
settings: Settings,
|
||||||
pin: Pin,
|
pin: Pin,
|
||||||
@@ -773,6 +816,7 @@ pub struct SystemHelper {
|
|||||||
boot: WindowsBoot,
|
boot: WindowsBoot,
|
||||||
sync: Option<HelperSync<DalekVerifier>>,
|
sync: Option<HelperSync<DalekVerifier>>,
|
||||||
last_diagnostic: Option<Instant>,
|
last_diagnostic: Option<Instant>,
|
||||||
|
unsettled_msi: Option<UnsettledMsi>,
|
||||||
}
|
}
|
||||||
impl SystemHelper {
|
impl SystemHelper {
|
||||||
pub fn open() -> Result<Self> {
|
pub fn open() -> Result<Self> {
|
||||||
@@ -796,6 +840,7 @@ impl SystemHelper {
|
|||||||
boot,
|
boot,
|
||||||
sync,
|
sync,
|
||||||
last_diagnostic: None,
|
last_diagnostic: None,
|
||||||
|
unsettled_msi: None,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn pin(&self) -> &Pin {
|
pub fn pin(&self) -> &Pin {
|
||||||
@@ -972,7 +1017,8 @@ impl SystemHelper {
|
|||||||
ensure!(
|
ensure!(
|
||||||
job.execution_identity == "system"
|
job.execution_identity == "system"
|
||||||
&& job.max_runtime_seconds <= self.settings.max_runtime_seconds
|
&& job.max_runtime_seconds <= self.settings.max_runtime_seconds
|
||||||
&& matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)),
|
&& (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit))
|
||||||
|
|| self.settings.permits_msi(&job)),
|
||||||
"SYSTEM_ABANDON_POLICY_DENIED"
|
"SYSTEM_ABANDON_POLICY_DENIED"
|
||||||
);
|
);
|
||||||
self.sync()?;
|
self.sync()?;
|
||||||
@@ -1063,6 +1109,9 @@ impl SystemHelper {
|
|||||||
),
|
),
|
||||||
"SYSTEM_SIGNED_SYNC_REQUIRED"
|
"SYSTEM_SIGNED_SYNC_REQUIRED"
|
||||||
);
|
);
|
||||||
|
if job.action.windows_msi().is_some() {
|
||||||
|
return self.execute_msi(generation, request, &job, &permit, peer);
|
||||||
|
}
|
||||||
let mut provider = PreparedService::prepare(&self.settings, &job)?;
|
let mut provider = PreparedService::prepare(&self.settings, &job)?;
|
||||||
self.recheck()?;
|
self.recheck()?;
|
||||||
peer.check()?;
|
peer.check()?;
|
||||||
@@ -1101,6 +1150,211 @@ impl SystemHelper {
|
|||||||
ledger::finish(&self.db, &permit, &outcome)?;
|
ledger::finish(&self.db, &permit, &outcome)?;
|
||||||
Ok(outcome)
|
Ok(outcome)
|
||||||
}
|
}
|
||||||
|
fn execute_msi(
|
||||||
|
&mut self,
|
||||||
|
generation: u64,
|
||||||
|
request: &Request,
|
||||||
|
job: &JobPayload,
|
||||||
|
permit: &ExecutionPermitPayload,
|
||||||
|
peer: &mut ipc::PeerProof,
|
||||||
|
) -> Result<Outcome> {
|
||||||
|
use crate::package::{Prepared, Run};
|
||||||
|
self.observe_unsettled_msi()?;
|
||||||
|
ensure!(
|
||||||
|
self.unsettled_msi.is_none(),
|
||||||
|
"SYSTEM_MSI_PREVIOUS_PROCESS_UNSETTLED"
|
||||||
|
);
|
||||||
|
let began = Instant::now();
|
||||||
|
let original_request_sha256 = hash(&serde_json::to_vec(request)?);
|
||||||
|
let timeout = Duration::from_secs(job.max_runtime_seconds.into());
|
||||||
|
let m = job
|
||||||
|
.action
|
||||||
|
.windows_msi()
|
||||||
|
.context("SYSTEM_MSI_MANIFEST_REQUIRED")?;
|
||||||
|
ensure!(
|
||||||
|
self.settings.permits_msi(job),
|
||||||
|
"SYSTEM_MSI_RECIPE_NOT_ALLOWED"
|
||||||
|
);
|
||||||
|
// No implicit bootstrap: reject absent/unprotected cache before consume.
|
||||||
|
let _cache = PinnedFile::open(Path::new(crate::msi_cache::CACHE), true, &[], &[], false)
|
||||||
|
.context("MSI_CACHE_NOT_CONFIGURED")?;
|
||||||
|
self.recheck()?;
|
||||||
|
peer.check()?;
|
||||||
|
ensure!(
|
||||||
|
self.sync.as_ref().unwrap().can_start(
|
||||||
|
&self.db,
|
||||||
|
&self.guard,
|
||||||
|
generation,
|
||||||
|
&self.clock,
|
||||||
|
&self.boot
|
||||||
|
),
|
||||||
|
"SYSTEM_SIGNED_SYNC_REQUIRED"
|
||||||
|
);
|
||||||
|
let (_, fresh, recorded_at) =
|
||||||
|
verified_window(&self.settings.binding, request, &self.clock)?;
|
||||||
|
ensure!(
|
||||||
|
&fresh == permit && !STOP.load(Ordering::SeqCst),
|
||||||
|
"SYSTEM_MSI_START_FENCED"
|
||||||
|
);
|
||||||
|
ledger::begin_execution(
|
||||||
|
&mut self.db,
|
||||||
|
permit,
|
||||||
|
request,
|
||||||
|
self.boot.current_boot()?,
|
||||||
|
recorded_at,
|
||||||
|
)?;
|
||||||
|
self.sync.as_mut().unwrap().close();
|
||||||
|
let result = (|| -> Result<Outcome> {
|
||||||
|
ensure!(
|
||||||
|
began.elapsed() < timeout,
|
||||||
|
"MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START"
|
||||||
|
);
|
||||||
|
crate::helper_runtime::intent::Store::require_not_denied(
|
||||||
|
request,
|
||||||
|
self.boot.current_boot()?,
|
||||||
|
generation,
|
||||||
|
&self.pin.policy_sha256,
|
||||||
|
&self.pin.helper.binary_sha256,
|
||||||
|
)?;
|
||||||
|
let _copied_archive = crate::msi_cache::import(m, permit.grant_id)?;
|
||||||
|
ensure!(
|
||||||
|
began.elapsed() < timeout,
|
||||||
|
"MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START"
|
||||||
|
);
|
||||||
|
let provider = Prepared::prepare(m, &m.recipe_sha256, began, timeout)?;
|
||||||
|
let run = provider.start(began, timeout, &STOP, || {
|
||||||
|
self.recheck()?;
|
||||||
|
peer.check()?;
|
||||||
|
ensure!(
|
||||||
|
!STOP.load(Ordering::SeqCst),
|
||||||
|
"SYSTEM_MSI_CANCELLED_BEFORE_START"
|
||||||
|
);
|
||||||
|
verified_window(&self.settings.binding, request, &self.clock)?;
|
||||||
|
crate::helper_runtime::intent::Store::require_not_denied(
|
||||||
|
request,
|
||||||
|
self.boot.current_boot()?,
|
||||||
|
generation,
|
||||||
|
&self.pin.policy_sha256,
|
||||||
|
&self.pin.helper.binary_sha256,
|
||||||
|
)?;
|
||||||
|
Ok(())
|
||||||
|
})?;
|
||||||
|
let observation = match run {
|
||||||
|
Run::Noop(value) => *value, // Noop variant can itself be Unknown.
|
||||||
|
Run::Installer(mut child) => loop {
|
||||||
|
// Continue observing this original transaction after start.
|
||||||
|
// A lost clock/peer/agent-denial observation cannot free the
|
||||||
|
// lane or retroactively produce success; never kill/retry.
|
||||||
|
let fenced = STOP.load(Ordering::SeqCst)
|
||||||
|
|| self.clock.now().is_err()
|
||||||
|
|| peer.check().is_err()
|
||||||
|
|| self
|
||||||
|
.boot
|
||||||
|
.current_boot()
|
||||||
|
.and_then(|boot| {
|
||||||
|
crate::helper_runtime::intent::Store::require_not_denied(
|
||||||
|
request,
|
||||||
|
boot,
|
||||||
|
generation,
|
||||||
|
&self.pin.policy_sha256,
|
||||||
|
&self.pin.helper.binary_sha256,
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.is_err();
|
||||||
|
let cancelled = AtomicBool::new(fenced);
|
||||||
|
match child.poll(&cancelled) {
|
||||||
|
Ok(Some(mut value)) => {
|
||||||
|
if fenced {
|
||||||
|
value.state = "unknown";
|
||||||
|
value.code = "MSI_RUNNING_OBSERVATION_FENCED";
|
||||||
|
value.postconditions_passed = false;
|
||||||
|
}
|
||||||
|
if value.state == "unknown" {
|
||||||
|
self.unsettled_msi = Some(UnsettledMsi {
|
||||||
|
grant: permit.grant_id,
|
||||||
|
request_sha256: original_request_sha256.clone(),
|
||||||
|
installer: child,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
break value;
|
||||||
|
}
|
||||||
|
Ok(None) => std::thread::sleep(Duration::from_millis(50)),
|
||||||
|
Err(error) => {
|
||||||
|
let outcome = Outcome {
|
||||||
|
evidence: serde_json::json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":false,"installer_process_started":true,"process_id":child.process_id(),"automatic_retry":false,"observer_error":safe_error(&error)}),
|
||||||
|
..Outcome::unknown("MSI_OBSERVER_FAILED_EFFECT_UNRESOLVED")
|
||||||
|
};
|
||||||
|
self.unsettled_msi = Some(UnsettledMsi {
|
||||||
|
grant: permit.grant_id,
|
||||||
|
request_sha256: original_request_sha256.clone(),
|
||||||
|
installer: child,
|
||||||
|
});
|
||||||
|
return Ok(outcome);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
};
|
||||||
|
let mut evidence = serde_json::to_value(&observation)?;
|
||||||
|
evidence["provider"] = "windows.msi.fixture/1".into();
|
||||||
|
let mut outcome = Outcome {
|
||||||
|
state: observation.state.into(),
|
||||||
|
stdout: vec![],
|
||||||
|
stderr: vec![],
|
||||||
|
exit_code: observation.exit_code.map(|v| v as i32),
|
||||||
|
output_truncated: false,
|
||||||
|
reboot_required: observation.installer_reboot_required.unwrap_or(false),
|
||||||
|
error_code: if observation.state == "succeeded" {
|
||||||
|
String::new()
|
||||||
|
} else {
|
||||||
|
observation.code.into()
|
||||||
|
},
|
||||||
|
evidence,
|
||||||
|
};
|
||||||
|
if outcome.state == "succeeded" {
|
||||||
|
let fresh = self.clock.now().is_ok() && peer.check().is_ok();
|
||||||
|
if !fresh || began.elapsed() >= timeout {
|
||||||
|
outcome.state = "unknown".into();
|
||||||
|
outcome.error_code = "MSI_FINAL_OBSERVATION_FENCED".into();
|
||||||
|
outcome.evidence["postconditions_passed"] = false.into();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(outcome)
|
||||||
|
})();
|
||||||
|
let outcome = result.unwrap_or_else(|error| {
|
||||||
|
let code = safe_error(&error);
|
||||||
|
Outcome {state:if began.elapsed() >= timeout {"unknown"} else {"failed"}.into(),
|
||||||
|
evidence:serde_json::json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":false,"installer_process_started":false,"transaction_started":false,"automatic_retry":false}), ..Outcome::unknown(&code)}
|
||||||
|
});
|
||||||
|
ledger::persist_outcome(&self.db, permit, &outcome)?;
|
||||||
|
self.guard.check(&self.db)?;
|
||||||
|
ledger::finish(&self.db, permit, &outcome)?;
|
||||||
|
Ok(outcome)
|
||||||
|
}
|
||||||
|
fn observe_unsettled_msi(&mut self) -> Result<()> {
|
||||||
|
let Some(slot) = self.unsettled_msi.as_mut() else {
|
||||||
|
return Ok(());
|
||||||
|
};
|
||||||
|
self.guard.check(&self.db)?;
|
||||||
|
let (start, outcome): (Vec<u8>, Vec<u8>) = self.db.query_row(
|
||||||
|
"SELECT start,outcome FROM execution_evidence WHERE grant_id=?1",
|
||||||
|
[slot.grant.to_string()],
|
||||||
|
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||||
|
)?;
|
||||||
|
let start: serde_json::Value = serde_json::from_slice(&start)?;
|
||||||
|
let original: Request = serde_json::from_value(start["request"].clone())?;
|
||||||
|
let saved: Outcome = serde_json::from_slice(&outcome)?;
|
||||||
|
ensure!(
|
||||||
|
hash(&serde_json::to_vec(&original)?) == slot.request_sha256
|
||||||
|
&& saved.state == "unknown",
|
||||||
|
"SYSTEM_MSI_UNSETTLED_ORIGINAL_BINDING"
|
||||||
|
);
|
||||||
|
if slot.installer.process_exited()? {
|
||||||
|
self.unsettled_msi = None;
|
||||||
|
}
|
||||||
|
// No ledger/outcome update here. An observed late exit never revises
|
||||||
|
// the original deadline outcome or grants permission for another job.
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
}
|
}
|
||||||
pub fn safe_error(error: &anyhow::Error) -> String {
|
pub fn safe_error(error: &anyhow::Error) -> String {
|
||||||
if error.chain().any(|cause| {
|
if error.chain().any(|cause| {
|
||||||
@@ -1176,10 +1430,16 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
|
|||||||
let server = ipc::Server::bind(helper.pin().clone())?;
|
let server = ipc::Server::bind(helper.pin().clone())?;
|
||||||
scm_status(SERVICE_RUNNING, 0);
|
scm_status(SERVICE_RUNNING, 0);
|
||||||
while !STOP.load(Ordering::SeqCst) {
|
while !STOP.load(Ordering::SeqCst) {
|
||||||
|
// A failed observation keeps the owned slot and its handles locked.
|
||||||
|
if helper.observe_unsettled_msi().is_err()
|
||||||
|
&& let Some(sync) = &mut helper.sync
|
||||||
|
{
|
||||||
|
sync.close();
|
||||||
|
}
|
||||||
match server.receive() {
|
match server.receive() {
|
||||||
Ok(Some(mut incoming)) => {
|
Ok(Some(mut incoming)) => {
|
||||||
let reply = helper.handle(&incoming.call, &mut incoming.peer);
|
let reply = helper.handle(&incoming.call, &mut incoming.peer);
|
||||||
if let Err(error) = server.reply(&reply) {
|
if let Err(error) = server.reply(&reply, &mut incoming.peer) {
|
||||||
if let Some(sync) = &mut helper.sync {
|
if let Some(sync) = &mut helper.sync {
|
||||||
sync.close();
|
sync.close();
|
||||||
}
|
}
|
||||||
@@ -1230,6 +1490,56 @@ pub fn dispatch() -> Result<()> {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
#[test]
|
#[test]
|
||||||
|
fn old_settings_omit_new_scope_and_only_v2_exact_recipe_hash_and_budget_allow_msi() {
|
||||||
|
let job = crate::helper_runtime::msi_test_job();
|
||||||
|
let m = job.action.windows_msi().unwrap();
|
||||||
|
let peer = PeerPin {
|
||||||
|
service_name: "synthetic".into(),
|
||||||
|
service_sid: "synthetic".into(),
|
||||||
|
user_sid: "synthetic".into(),
|
||||||
|
binary: PathBuf::from("synthetic"),
|
||||||
|
binary_sha256: "ab".repeat(32),
|
||||||
|
};
|
||||||
|
let mut settings = Settings {
|
||||||
|
schema_version: 1,
|
||||||
|
binding: Binding {
|
||||||
|
tenant_id: job.tenant_id,
|
||||||
|
asset_id: job.asset_id,
|
||||||
|
agent_id: job.agent_id,
|
||||||
|
enrollment_generation: 1,
|
||||||
|
assignment_version: 1,
|
||||||
|
public_key_hex: "ab".repeat(32),
|
||||||
|
},
|
||||||
|
agent: peer.clone(),
|
||||||
|
helper: peer,
|
||||||
|
allowed_services: vec![],
|
||||||
|
max_runtime_seconds: 30,
|
||||||
|
enable_effects: false,
|
||||||
|
allow_reboot: false,
|
||||||
|
allowed_msi_recipe_sha256: None,
|
||||||
|
};
|
||||||
|
let legacy = serde_json::to_value(&settings).unwrap();
|
||||||
|
assert!(legacy.get("allowed_msi_recipe_sha256").is_none());
|
||||||
|
let mut null = legacy.clone();
|
||||||
|
null["allowed_msi_recipe_sha256"] = serde_json::Value::Null;
|
||||||
|
assert!(serde_json::from_value::<Settings>(null).is_err());
|
||||||
|
assert!(!settings.permits_msi(&job));
|
||||||
|
settings.allowed_msi_recipe_sha256 = Some(vec![m.recipe_sha256.clone()]);
|
||||||
|
assert!(!settings.permits_msi(&job));
|
||||||
|
assert_eq!(
|
||||||
|
settings.validate().unwrap_err().to_string(),
|
||||||
|
"SYSTEM_POLICY_PROFILE"
|
||||||
|
);
|
||||||
|
settings.schema_version = 2;
|
||||||
|
assert!(settings.permits_msi(&job));
|
||||||
|
assert!(!settings.enable_effects);
|
||||||
|
settings.max_runtime_seconds = 29;
|
||||||
|
assert!(!settings.permits_msi(&job));
|
||||||
|
settings.max_runtime_seconds = 30;
|
||||||
|
settings.allowed_msi_recipe_sha256 = Some(vec!["cd".repeat(32)]);
|
||||||
|
assert!(!settings.permits_msi(&job));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
fn service_adapter_exposes_only_implemented_states() {
|
fn service_adapter_exposes_only_implemented_states() {
|
||||||
assert_eq!(desired_state("running").unwrap(), SERVICE_RUNNING);
|
assert_eq!(desired_state("running").unwrap(), SERVICE_RUNNING);
|
||||||
assert_eq!(desired_state("stopped").unwrap(), SERVICE_STOPPED);
|
assert_eq!(desired_state("stopped").unwrap(), SERVICE_STOPPED);
|
||||||
|
|||||||
@@ -18,6 +18,9 @@ pub mod inventory;
|
|||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
pub mod job_binding;
|
pub mod job_binding;
|
||||||
pub mod journal;
|
pub mod journal;
|
||||||
|
pub mod package;
|
||||||
|
#[cfg(all(windows, feature = "system-helper"))]
|
||||||
|
pub mod msi_cache;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
pub mod native;
|
pub mod native;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
|
|||||||
@@ -0,0 +1,178 @@
|
|||||||
|
//! Fixed public-byte staging and independent SYSTEM cache import. No IPC path,
|
||||||
|
//! URL or byte-array authority. Directories must be provisioned separately;
|
||||||
|
//! this module never installs/repairs an ACL, directory, policy or service.
|
||||||
|
use crate::helper_ipc::{self as ipc, PinnedFile};
|
||||||
|
use anyhow::{Context, Result, ensure};
|
||||||
|
use rmm_domain::windows_execution::ResolvedWindowsMsi;
|
||||||
|
use sha2::{Digest, Sha256};
|
||||||
|
use std::{
|
||||||
|
fs::{File, OpenOptions},
|
||||||
|
io::{Read, Write},
|
||||||
|
mem::zeroed,
|
||||||
|
os::windows::{
|
||||||
|
fs::OpenOptionsExt,
|
||||||
|
io::{AsRawHandle, FromRawHandle},
|
||||||
|
},
|
||||||
|
path::{Path, PathBuf},
|
||||||
|
ptr,
|
||||||
|
};
|
||||||
|
use uuid::Uuid;
|
||||||
|
use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*};
|
||||||
|
|
||||||
|
pub const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state";
|
||||||
|
pub const STAGE: &str = r"C:\ProgramData\RustDiscovery\state\msi-stage";
|
||||||
|
pub const CACHE: &str = r"C:\ProgramData\RustDiscoverySystem\cache";
|
||||||
|
fn name(m: &ResolvedWindowsMsi) -> Result<String> {
|
||||||
|
ensure!(m.validate(), "MSI_CACHE_MANIFEST");
|
||||||
|
Ok(format!("{}.msi", m.recipe.artifact.sha256))
|
||||||
|
}
|
||||||
|
fn regular(file: &File, directory: bool) -> Result<()> {
|
||||||
|
let mut i: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
|
||||||
|
ensure!(
|
||||||
|
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut i) } != 0
|
||||||
|
&& i.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
|
||||||
|
&& (i.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory
|
||||||
|
&& (directory || i.nNumberOfLinks == 1),
|
||||||
|
"MSI_CACHE_NONREGULAR"
|
||||||
|
);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
/// Keep every actual parent open without DELETE sharing throughout the copy.
|
||||||
|
/// Source data/ACL is untrusted; only the original signed digest authorizes bytes.
|
||||||
|
fn parents(path: &Path) -> Result<Vec<File>> {
|
||||||
|
let mut held = Vec::new();
|
||||||
|
for p in path.ancestors().skip(1) {
|
||||||
|
let raw = unsafe {
|
||||||
|
CreateFileW(
|
||||||
|
ipc::wide(p).as_ptr(),
|
||||||
|
FILE_READ_ATTRIBUTES,
|
||||||
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||||
|
ptr::null(),
|
||||||
|
OPEN_EXISTING,
|
||||||
|
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
|
||||||
|
ptr::null_mut(),
|
||||||
|
)
|
||||||
|
};
|
||||||
|
ensure!(
|
||||||
|
raw != INVALID_HANDLE_VALUE,
|
||||||
|
"MSI_CACHE_PARENT_NOT_CONFIGURED"
|
||||||
|
);
|
||||||
|
let file = unsafe { File::from_raw_handle(raw) };
|
||||||
|
regular(&file, true)?;
|
||||||
|
held.push(file);
|
||||||
|
}
|
||||||
|
Ok(held)
|
||||||
|
}
|
||||||
|
fn checked_bytes(path: &Path, m: &ResolvedWindowsMsi) -> Result<Vec<u8>> {
|
||||||
|
let _parents = parents(path)?;
|
||||||
|
let mut file = OpenOptions::new()
|
||||||
|
.read(true)
|
||||||
|
.share_mode(FILE_SHARE_READ)
|
||||||
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||||
|
.open(path)
|
||||||
|
.context("MSI_STAGE_NOT_CONFIGURED")?;
|
||||||
|
regular(&file, false)?;
|
||||||
|
let id = ipc::file_identity(&file)?;
|
||||||
|
ensure!(
|
||||||
|
file.metadata()?.len() == m.recipe.artifact.bytes && m.recipe.artifact.bytes <= 262144,
|
||||||
|
"MSI_CACHE_LENGTH"
|
||||||
|
);
|
||||||
|
let mut bytes = Vec::new();
|
||||||
|
(&mut file).take(262145).read_to_end(&mut bytes)?;
|
||||||
|
ensure!(
|
||||||
|
bytes.len() as u64 == m.recipe.artifact.bytes
|
||||||
|
&& format!("{:x}", Sha256::digest(&bytes)) == m.recipe.artifact.sha256,
|
||||||
|
"MSI_CACHE_DIGEST"
|
||||||
|
);
|
||||||
|
let again = OpenOptions::new()
|
||||||
|
.read(true)
|
||||||
|
.share_mode(FILE_SHARE_READ)
|
||||||
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||||
|
.open(path)?;
|
||||||
|
regular(&again, false)?;
|
||||||
|
ensure!(ipc::file_identity(&again)? == id, "MSI_CACHE_FILE_REPLACED");
|
||||||
|
Ok(bytes)
|
||||||
|
}
|
||||||
|
pub fn stage_configured() -> bool {
|
||||||
|
crate::native::private_path(Path::new(STAGE), true).is_ok()
|
||||||
|
}
|
||||||
|
/// Called by LocalService only for the already approved original job/attempt.
|
||||||
|
pub fn stage(m: &ResolvedWindowsMsi, bytes: &[u8]) -> Result<()> {
|
||||||
|
crate::native::require_local_service()?;
|
||||||
|
let path = Path::new(STAGE).join(name(m)?);
|
||||||
|
let _parents = parents(&path)?;
|
||||||
|
crate::native::private_path(Path::new(STAGE), true)?;
|
||||||
|
ensure!(
|
||||||
|
bytes.len() as u64 == m.recipe.artifact.bytes
|
||||||
|
&& format!("{:x}", Sha256::digest(bytes)) == m.recipe.artifact.sha256,
|
||||||
|
"MSI_DOWNLOAD_DIGEST"
|
||||||
|
);
|
||||||
|
if path.try_exists()? {
|
||||||
|
ensure!(checked_bytes(&path, m)? == bytes, "MSI_STAGE_CONFLICT");
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
let mut file = OpenOptions::new()
|
||||||
|
.read(true)
|
||||||
|
.write(true)
|
||||||
|
.create_new(true)
|
||||||
|
.share_mode(FILE_SHARE_READ)
|
||||||
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||||
|
.open(&path)?;
|
||||||
|
regular(&file, false)?;
|
||||||
|
let id = ipc::file_identity(&file)?;
|
||||||
|
file.write_all(bytes)?;
|
||||||
|
file.sync_all()?;
|
||||||
|
ensure!(ipc::file_identity(&file)? == id, "MSI_STAGE_FILE_CHANGED");
|
||||||
|
drop(file);
|
||||||
|
crate::native::private_path(&path, false)?;
|
||||||
|
ensure!(checked_bytes(&path, m)? == bytes, "MSI_STAGE_CONFLICT");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
/// Called ONLY after full independent helper authorization and durable consume.
|
||||||
|
/// Publish to the fixed SYS/Admin cache without replacing any existing entry.
|
||||||
|
/// Returned guards pin the copied archive until the provider holds its own.
|
||||||
|
pub fn import(m: &ResolvedWindowsMsi, grant: Uuid) -> Result<Vec<PinnedFile>> {
|
||||||
|
let file_name = name(m)?;
|
||||||
|
ensure!(!grant.is_nil(), "MSI_CACHE_GRANT");
|
||||||
|
let destination = Path::new(CACHE).join(file_name);
|
||||||
|
let _parents = parents(&destination)?;
|
||||||
|
let root = PinnedFile::open(Path::new(CACHE), true, &[], &[], false)
|
||||||
|
.context("MSI_CACHE_NOT_CONFIGURED")?;
|
||||||
|
if destination.try_exists()? {
|
||||||
|
let archive = PinnedFile::open(&destination, false, &[], &[], false)?;
|
||||||
|
checked_bytes(&destination, m)?;
|
||||||
|
return Ok(vec![root, archive]);
|
||||||
|
}
|
||||||
|
let source: PathBuf = Path::new(STAGE).join(name(m)?);
|
||||||
|
let bytes = checked_bytes(&source, m)?; // Never trust actor ownership/data.
|
||||||
|
let pending = Path::new(CACHE).join(format!("{}.{}.pending", m.recipe.artifact.sha256, grant));
|
||||||
|
let mut file = OpenOptions::new()
|
||||||
|
.read(true)
|
||||||
|
.write(true)
|
||||||
|
.create_new(true)
|
||||||
|
.share_mode(FILE_SHARE_READ)
|
||||||
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||||
|
.open(&pending)?;
|
||||||
|
regular(&file, false)?;
|
||||||
|
file.write_all(&bytes)?;
|
||||||
|
file.sync_all()?;
|
||||||
|
drop(file);
|
||||||
|
// Cache directory was already independently validated SYS/Admin-only. New
|
||||||
|
// SYSTEM-created files inherit that boundary; no ACL repair is performed.
|
||||||
|
let copied = PinnedFile::open(&pending, false, &[], &[], false)?;
|
||||||
|
checked_bytes(&pending, m)?;
|
||||||
|
drop(copied);
|
||||||
|
ensure!(
|
||||||
|
unsafe {
|
||||||
|
MoveFileExW(
|
||||||
|
ipc::wide(&pending).as_ptr(),
|
||||||
|
ipc::wide(&destination).as_ptr(),
|
||||||
|
0,
|
||||||
|
)
|
||||||
|
} != 0,
|
||||||
|
"MSI_CACHE_CREATE_ONLY_PUBLICATION"
|
||||||
|
);
|
||||||
|
let archive = PinnedFile::open(&destination, false, &[], &[], false)?;
|
||||||
|
checked_bytes(&destination, m)?;
|
||||||
|
Ok(vec![root, archive])
|
||||||
|
}
|
||||||
@@ -17,9 +17,10 @@
|
|||||||
use anyhow::{Result, ensure};
|
use anyhow::{Result, ensure};
|
||||||
#[cfg(any(windows, test))]
|
#[cfg(any(windows, test))]
|
||||||
use rmm_domain::windows_execution::{ResolvedWindowsMsi, valid_package_code};
|
use rmm_domain::windows_execution::{ResolvedWindowsMsi, valid_package_code};
|
||||||
use serde::Serialize;
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
|
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
#[serde(deny_unknown_fields)]
|
||||||
pub struct Snapshot {
|
pub struct Snapshot {
|
||||||
pub product_code: String,
|
pub product_code: String,
|
||||||
pub package_code: Option<String>,
|
pub package_code: Option<String>,
|
||||||
@@ -34,7 +35,7 @@ pub struct Snapshot {
|
|||||||
}
|
}
|
||||||
impl Snapshot {
|
impl Snapshot {
|
||||||
#[cfg(any(windows, test))]
|
#[cfg(any(windows, test))]
|
||||||
fn desired(&self, r: &ResolvedWindowsMsi) -> bool {
|
pub(crate) fn desired(&self, r: &ResolvedWindowsMsi) -> bool {
|
||||||
let p = &r.recipe.postcondition;
|
let p = &r.recipe.postcondition;
|
||||||
self.product_code == p.product_code
|
self.product_code == p.product_code
|
||||||
&& self.related_products == [p.product_code.clone()]
|
&& self.related_products == [p.product_code.clone()]
|
||||||
@@ -854,8 +855,17 @@ mod windows {
|
|||||||
system_root: PathBuf,
|
system_root: PathBuf,
|
||||||
}
|
}
|
||||||
impl Prepared {
|
impl Prepared {
|
||||||
pub fn prepare(r: &ResolvedWindowsMsi, allowed_recipe_sha256: &str) -> Result<Self> {
|
pub fn prepare(
|
||||||
|
r: &ResolvedWindowsMsi,
|
||||||
|
allowed_recipe_sha256: &str,
|
||||||
|
began: Instant,
|
||||||
|
timeout: Duration,
|
||||||
|
) -> Result<Self> {
|
||||||
validate(r, allowed_recipe_sha256)?;
|
validate(r, allowed_recipe_sha256)?;
|
||||||
|
ensure!(
|
||||||
|
within_budget(began, timeout),
|
||||||
|
"MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START"
|
||||||
|
);
|
||||||
let mut roots = Vec::new();
|
let mut roots = Vec::new();
|
||||||
for path in [CACHE, FIXTURES] {
|
for path in [CACHE, FIXTURES] {
|
||||||
let file = OpenOptions::new()
|
let file = OpenOptions::new()
|
||||||
@@ -872,9 +882,17 @@ mod windows {
|
|||||||
false,
|
false,
|
||||||
)?;
|
)?;
|
||||||
inspect_archive(&mut archive, r)?;
|
inspect_archive(&mut archive, r)?;
|
||||||
|
ensure!(
|
||||||
|
within_budget(began, timeout),
|
||||||
|
"MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START"
|
||||||
|
);
|
||||||
let system_root = system_root()?;
|
let system_root = system_root()?;
|
||||||
let msiexec = Held::open(&system_root.join("System32").join("msiexec.exe"), true)?;
|
let msiexec = Held::open(&system_root.join("System32").join("msiexec.exe"), true)?;
|
||||||
let before = snapshot_for(r)?;
|
let before = snapshot_for(r)?;
|
||||||
|
ensure!(
|
||||||
|
within_budget(began, timeout),
|
||||||
|
"MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START"
|
||||||
|
);
|
||||||
ensure!(
|
ensure!(
|
||||||
before.baseline_allowed(r),
|
before.baseline_allowed(r),
|
||||||
"MSI_EXISTING_PRODUCT_OR_PAYLOAD_CONFLICT"
|
"MSI_EXISTING_PRODUCT_OR_PAYLOAD_CONFLICT"
|
||||||
@@ -911,6 +929,7 @@ mod windows {
|
|||||||
/// config, privilege, policy, clock, reboot or foreign process occurs.
|
/// config, privilege, policy, clock, reboot or foreign process occurs.
|
||||||
pub fn start(
|
pub fn start(
|
||||||
mut self,
|
mut self,
|
||||||
|
began: Instant,
|
||||||
timeout: Duration,
|
timeout: Duration,
|
||||||
cancelled: &AtomicBool,
|
cancelled: &AtomicBool,
|
||||||
check_effect_fence: impl FnOnce() -> Result<()>,
|
check_effect_fence: impl FnOnce() -> Result<()>,
|
||||||
@@ -923,7 +942,6 @@ mod windows {
|
|||||||
);
|
);
|
||||||
// One original budget includes all synchronous verification and
|
// One original budget includes all synchronous verification and
|
||||||
// the eventual installer. A late Noop is not retroactive success.
|
// the eventual installer. A late Noop is not retroactive success.
|
||||||
let began = Instant::now();
|
|
||||||
let archive = inspect_archive(&mut self.archive, &self.recipe);
|
let archive = inspect_archive(&mut self.archive, &self.recipe);
|
||||||
if !within_budget(began, timeout) {
|
if !within_budget(began, timeout) {
|
||||||
return Ok(self.verification_timeout(None));
|
return Ok(self.verification_timeout(None));
|
||||||
@@ -1010,6 +1028,11 @@ mod windows {
|
|||||||
timeout: Duration,
|
timeout: Duration,
|
||||||
}
|
}
|
||||||
impl Installer {
|
impl Installer {
|
||||||
|
/// Observe only this retained process handle. Never adopt a PID, kill,
|
||||||
|
/// restart, or revise an already persisted timeout outcome.
|
||||||
|
pub fn process_exited(&mut self) -> Result<bool> {
|
||||||
|
Ok(self.child.try_wait()?.is_some())
|
||||||
|
}
|
||||||
pub fn process_id(&self) -> u32 {
|
pub fn process_id(&self) -> u32 {
|
||||||
self.child.id()
|
self.child.id()
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -367,6 +367,25 @@ struct Agent {
|
|||||||
impl Agent {
|
impl Agent {
|
||||||
fn close_gate(&mut self) {
|
fn close_gate(&mut self) {
|
||||||
self.fence.close();
|
self.fence.close();
|
||||||
|
#[cfg(feature = "system-helper")]
|
||||||
|
if let Some(running) = &self.running
|
||||||
|
&& running.grant.execution_identity == "system"
|
||||||
|
{
|
||||||
|
running.cancel.store(true, Ordering::SeqCst);
|
||||||
|
let denied = (|| -> Result<()> {
|
||||||
|
let mut store = rmm_agent_windows::helper_runtime::intent::Store::open(true)?;
|
||||||
|
let intent = store.by_grant(running.grant.grant_id)?;
|
||||||
|
ensure!(
|
||||||
|
intent.permit()? == running.grant,
|
||||||
|
"SYSTEM_CANCEL_GRANT_BINDING"
|
||||||
|
);
|
||||||
|
store.deny(&intent.request, Uuid::parse_str(&self.boot)?)
|
||||||
|
})();
|
||||||
|
if denied.is_err() {
|
||||||
|
self.helper_refused = true;
|
||||||
|
eprintln!("SYSTEM_CANCEL_PERSISTENCE_FAILED");
|
||||||
|
}
|
||||||
|
}
|
||||||
if let Some(sync) = &mut self.sync {
|
if let Some(sync) = &mut self.sync {
|
||||||
sync.close();
|
sync.close();
|
||||||
}
|
}
|
||||||
@@ -566,7 +585,11 @@ impl Agent {
|
|||||||
}
|
}
|
||||||
#[cfg(feature = "system-helper")]
|
#[cfg(feature = "system-helper")]
|
||||||
{
|
{
|
||||||
Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file()
|
(job.action.windows_msi().is_none()
|
||||||
|
|| (self.config.state_directory
|
||||||
|
== Path::new(rmm_agent_windows::msi_cache::AGENT_STATE)
|
||||||
|
&& rmm_agent_windows::msi_cache::stage_configured()))
|
||||||
|
&& Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file()
|
||||||
&& self
|
&& self
|
||||||
.helper
|
.helper
|
||||||
.as_ref()
|
.as_ref()
|
||||||
@@ -983,9 +1006,69 @@ impl Agent {
|
|||||||
let completed = self.completed_tx.clone();
|
let completed = self.completed_tx.clone();
|
||||||
let work_offer = offer.clone();
|
let work_offer = offer.clone();
|
||||||
let work_grant = grant.clone();
|
let work_grant = grant.clone();
|
||||||
|
let msi = job.action.windows_msi().cloned();
|
||||||
|
let address = self.config.connect_address;
|
||||||
|
let ca = self.ca.clone();
|
||||||
|
let state = self.config.state_directory.clone();
|
||||||
|
let request_for_stage = request.clone();
|
||||||
|
let binding_for_stage = binding.clone();
|
||||||
let worker = tokio::spawn(async move {
|
let worker = tokio::spawn(async move {
|
||||||
|
let staged = if let Some(m) = msi {
|
||||||
|
let result = async {
|
||||||
|
ensure!(
|
||||||
|
!worker_cancel.load(Ordering::SeqCst)
|
||||||
|
&& fence.allows_identity(generation, true, &clock),
|
||||||
|
"MSI_DOWNLOAD_FENCED"
|
||||||
|
);
|
||||||
|
verified_window(&binding_for_stage, &request_for_stage, &clock)?;
|
||||||
|
let cert = protected_read(&state.join("device.pem"), 32768)?;
|
||||||
|
let key = protected_read(&state.join("device.key"), 16384)?;
|
||||||
|
let tls = crate::https_channel::mtls_client(address, &ca, &cert, &key)?;
|
||||||
|
let response = tls
|
||||||
|
.get(format!(
|
||||||
|
"https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}",
|
||||||
|
crate::https_channel::server_name()?,
|
||||||
|
address.port(),
|
||||||
|
m.recipe.artifact.artifact_id,
|
||||||
|
work_grant.job_id,
|
||||||
|
work_grant.attempt_id
|
||||||
|
))
|
||||||
|
.send()
|
||||||
|
.await?;
|
||||||
|
ensure!(
|
||||||
|
response
|
||||||
|
.headers()
|
||||||
|
.get("x-artifact-sha256")
|
||||||
|
.and_then(|v| v.to_str().ok())
|
||||||
|
== Some(m.recipe.artifact.sha256.as_str()),
|
||||||
|
"MSI_DOWNLOAD_METADATA"
|
||||||
|
);
|
||||||
|
let bytes = crate::https_channel::bounded_body(
|
||||||
|
response,
|
||||||
|
m.recipe.artifact.bytes as usize,
|
||||||
|
"application/octet-stream",
|
||||||
|
)
|
||||||
|
.await?;
|
||||||
|
ensure!(
|
||||||
|
!worker_cancel.load(Ordering::SeqCst)
|
||||||
|
&& fence.allows_identity(generation, true, &clock),
|
||||||
|
"MSI_DOWNLOAD_FENCED"
|
||||||
|
);
|
||||||
|
verified_window(&binding_for_stage, &request_for_stage, &clock)?;
|
||||||
|
tokio::task::spawn_blocking(move || {
|
||||||
|
rmm_agent_windows::msi_cache::stage(&m, &bytes)
|
||||||
|
})
|
||||||
|
.await??;
|
||||||
|
Ok::<_, anyhow::Error>(())
|
||||||
|
}
|
||||||
|
.await;
|
||||||
|
result.is_ok()
|
||||||
|
} else {
|
||||||
|
true
|
||||||
|
};
|
||||||
let _result = helper
|
let _result = helper
|
||||||
.delegate(intent, move || {
|
.delegate(intent, move || {
|
||||||
|
ensure!(staged, "MSI_DOWNLOAD_NOT_READY");
|
||||||
ensure!(
|
ensure!(
|
||||||
!worker_cancel.load(Ordering::SeqCst),
|
!worker_cancel.load(Ordering::SeqCst),
|
||||||
"CANCELLED_BEFORE_DISPATCH"
|
"CANCELLED_BEFORE_DISPATCH"
|
||||||
@@ -1298,7 +1381,7 @@ impl Agent {
|
|||||||
#[cfg(feature="system-helper")]
|
#[cfg(feature="system-helper")]
|
||||||
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
|
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() {
|
||||||
let mut store=rmm_agent_windows::helper_runtime::intent::Store::open(true)?;
|
let mut store=rmm_agent_windows::helper_runtime::intent::Store::open(true)?;
|
||||||
if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.cancel_before_dispatch(intent.id)?;}
|
if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.deny(&intent.request,Uuid::parse_str(&self.boot)?)?;store.cancel_before_dispatch(intent.id)?;}
|
||||||
}
|
}
|
||||||
if state=="accepted" {self.record(generation,&JobOffer::decode(bytes.as_slice())?,&grant,jobs::no_start("cancelled","CANCELLED_BEFORE_START"))?;needs_sync=true;}
|
if state=="accepted" {self.record(generation,&JobOffer::decode(bytes.as_slice())?,&grant,jobs::no_start("cancelled","CANCELLED_BEFORE_START"))?;needs_sync=true;}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,368 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Source-bound Pipe-v2 pack and create-once native units, never deployment.
|
||||||
|
|
||||||
|
The access root only supplies the existing pinned SSH transport and immutable
|
||||||
|
native Core proofs. No credentials/devstate symlinks, copies, services or jobs.
|
||||||
|
"""
|
||||||
|
import argparse
|
||||||
|
import base64
|
||||||
|
import hashlib
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
from pathlib import Path
|
||||||
|
import re
|
||||||
|
import shutil
|
||||||
|
import stat
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import uuid
|
||||||
|
|
||||||
|
CODE = Path(__file__).resolve().parents[2]
|
||||||
|
ACCESS = Path('/home/kevin/Schreibtisch/Coding/rust-discovery')
|
||||||
|
sys.path.insert(0, str(ACCESS / 'deploy/windows'))
|
||||||
|
sys.path.insert(0, str(ACCESS / 'deploy'))
|
||||||
|
import client_bootstrap as cb
|
||||||
|
import auto_transport_acceptance as auto
|
||||||
|
import runtime_upgrade as previous
|
||||||
|
|
||||||
|
require = cb.contract.require
|
||||||
|
BUILD = CODE / 'devstate/windows-pipe-drain-build'
|
||||||
|
NATIVE = CODE / 'devstate/windows-client/native-pipe-v2'
|
||||||
|
# These imported transports read their original protected access configuration.
|
||||||
|
# Their new local upload/error receipts belong to this isolated checkout.
|
||||||
|
cb.EVIDENCE = CODE / 'devstate/windows-client'
|
||||||
|
CORE = ACCESS / 'devstate/core-no-start/build-de37ee99-11bf-465b-9519-45ad8f6e5b87/manifest.json'
|
||||||
|
CORE_SHA = '1bc082031fcad20d5a519b0004f63d499dbba2ea9ce25d56230d48d2556d474b'
|
||||||
|
LOCAL = CODE / 'devstate/windows-pipe-drain/qualification-1e0f2b22-1e74-41af-b8ed-0a356be054ba/qualification.json'
|
||||||
|
LOCAL_SHA = 'a7e3c604d4ad19feed0323ac23aa7a0290b6fb93bc57649cafbadbe5f293b1d4'
|
||||||
|
TARGET = 'x86_64-pc-windows-gnu'
|
||||||
|
NAMES = {'agent': 'rmm-agent-windows.exe', 'helper': 'rmm-helper-windows.exe',
|
||||||
|
'probe': 'RuntimeStateProbe.exe', 'system_probe': 'SystemStateProbe.exe',
|
||||||
|
'lib': 'windows-tests-lib.exe', 'bin': 'windows-tests-bin.exe'}
|
||||||
|
# Expected V2 native lists: unchanged names, two existing codec cases extended.
|
||||||
|
TESTS = {
|
||||||
|
'lib': sorted([
|
||||||
|
'clock::tests::gate_requires_all_status_and_uncertainty_evidence',
|
||||||
|
'clock::tests::production_clock_stays_closed_until_native_adapter_qualification',
|
||||||
|
'clock::tests::suspend_closes_until_actual_post_resume_sync',
|
||||||
|
'clock::tests::timeout_worker_stays_closed_without_a_second_call',
|
||||||
|
'clock::tests::wall_step_and_overflow_fail_closed',
|
||||||
|
'helper_ipc::tests::pipe_client_rights_cannot_create_an_instance',
|
||||||
|
'helper_ipc::tests::protocol_does_not_accept_a_shell_operation',
|
||||||
|
'helper_ipc::tests::reconfigured_service_cannot_adopt_an_old_running_identity',
|
||||||
|
'helper_ipc::tests::serialization_refuses_oversized_frame',
|
||||||
|
'helper_ipc::tests::untrusted_lengths_are_rejected_before_body_allocation',
|
||||||
|
'helper_runtime::intent::tests::cancel_and_dispatch_cas_are_exclusive_and_history_cannot_be_rewritten',
|
||||||
|
'helper_runtime::tests::system_route_binds_original_request_shape_budget_and_reply_scope',
|
||||||
|
'helper_system::tests::completed_scm_state_cannot_override_elapsed_runtime',
|
||||||
|
'helper_system::tests::fixture_recovery_cannot_add_commands_reboots_or_restart_attempts',
|
||||||
|
'helper_system::tests::service_adapter_exposes_only_implemented_states',
|
||||||
|
'helper_system::tests::single_fixture_cannot_start_services_or_groups_as_dependencies',
|
||||||
|
'journal::tests::bounded_existing_journal_preserves_identity_sequence_and_unacked_bytes',
|
||||||
|
'journal::tests::durable_reopen_ack_identity_and_single_process',
|
||||||
|
'journal::tests::migrates_original_passive_schema_without_rewriting_pending_envelopes',
|
||||||
|
'journal::tests::unsupported_page_size_is_refused_without_mutating_existing_data',
|
||||||
|
'native::tests::boot_identity_survives_independent_native_queries',
|
||||||
|
'native::tests::native_inventory_has_real_windows_sources_and_no_fake_inodes',
|
||||||
|
'process::tests::arguments_never_become_shell_code_and_trailing_slashes_are_quoted']),
|
||||||
|
'bin': sorted([
|
||||||
|
'https_channel::endpoint_tests::configured_dns_identity_cannot_inject_a_url_or_disable_name_checks',
|
||||||
|
'runtime::tests::bound_helper_unknown_repairs_generic_crash_gap_without_ack_or_duplicate_result',
|
||||||
|
'runtime::tests::legacy_inventory_keeps_original_bytes_until_concrete_core_ack',
|
||||||
|
'runtime::tests::old_passive_configuration_cannot_enable_jobs_or_read_the_clock',
|
||||||
|
'runtime::tests::worker_fence_requires_same_generation_and_entire_clock_interval',
|
||||||
|
'wire_channel::tests::auto_fallback_classifies_upgrade_refusal_but_never_authentication',
|
||||||
|
'wire_channel::tests::explicit_transport_names_cannot_enable_verification_bypasses'])}
|
||||||
|
COUNTS = {'lib': 23, 'bin': 7}
|
||||||
|
|
||||||
|
|
||||||
|
def sha(path):
|
||||||
|
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
|
||||||
|
|
||||||
|
|
||||||
|
def save(path, value):
|
||||||
|
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||||
|
cb.contract.write_private(path, value)
|
||||||
|
|
||||||
|
|
||||||
|
def private_file(path):
|
||||||
|
path = Path(path)
|
||||||
|
require(not path.is_symlink() and not path.parent.is_symlink(), 'private regular path')
|
||||||
|
info = path.lstat()
|
||||||
|
require(stat.S_ISREG(info.st_mode) and info.st_uid == os.getuid()
|
||||||
|
and stat.S_IMODE(info.st_mode) == 0o600, 'private regular owner/mode')
|
||||||
|
return path
|
||||||
|
|
||||||
|
|
||||||
|
def sources():
|
||||||
|
require(ACCESS.is_dir() and not ACCESS.is_symlink() and cb.ROOT == ACCESS,
|
||||||
|
'original access checkout only; no copied configuration')
|
||||||
|
names = {'Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', 'proto/agent.proto',
|
||||||
|
'deploy/windows/system_pipe_acceptance.py', 'docs/windows-helper-pipe-drain.md'}
|
||||||
|
names.update(str(p.relative_to(CODE)) for p in (CODE / 'crates').glob('*/Cargo.toml'))
|
||||||
|
for crate in ('agent-windows', 'agent-core', 'domain', 'protocol'):
|
||||||
|
names.update(str(p.relative_to(CODE)) for p in (CODE / 'crates' / crate).rglob('*')
|
||||||
|
if p.is_file() and p.suffix in ('.rs', '.c', '.h', '.idl', '.toml'))
|
||||||
|
names.update('crates/agent/src/' + n + '.rs' for n in ('https_channel', 'transport', 'wire_channel'))
|
||||||
|
require(all((CODE / n).is_file() and not (CODE / n).is_symlink() for n in names), 'complete fixed build sources')
|
||||||
|
transport = {}
|
||||||
|
for module in tuple(sys.modules.values()):
|
||||||
|
raw = getattr(module, '__file__', None)
|
||||||
|
if raw:
|
||||||
|
path = Path(raw).resolve()
|
||||||
|
if path.is_relative_to(ACCESS / 'deploy') and path.suffix == '.py':
|
||||||
|
transport[str(path.relative_to(ACCESS))] = sha(path)
|
||||||
|
require('deploy/windows/client_bootstrap.py' in transport, 'actual transport source binding')
|
||||||
|
return {'code': {n: sha(CODE / n) for n in sorted(names)}, 'access_transport': dict(sorted(transport.items()))}
|
||||||
|
|
||||||
|
|
||||||
|
def core_proof():
|
||||||
|
require(sha(CORE) == CORE_SHA, 'exact original Linux-first Core manifest')
|
||||||
|
manifest = cb.contract.protected_json(CORE)
|
||||||
|
result = {'manifest_sha256': CORE_SHA}
|
||||||
|
for platform, count in (('linux', 80), ('windows', 58)):
|
||||||
|
path = CORE.parent / (platform + '-passed.json')
|
||||||
|
proof = cb.contract.protected_json(path)
|
||||||
|
require(proof['verified'] is True and proof['platform'] == platform
|
||||||
|
and proof['manifest_sha256'] == CORE_SHA, 'actual same-manifest native Core proof')
|
||||||
|
actual = proof['native']['reports']
|
||||||
|
require(set(actual) == set(manifest['test_counts'][platform])
|
||||||
|
and sum(len(v['names']) for v in actual.values()) == count, 'all native Core reports')
|
||||||
|
for kind, item in actual.items():
|
||||||
|
n = manifest['test_counts'][platform][kind]
|
||||||
|
output = base64.b64decode(item['stdout_b64'], validate=True)
|
||||||
|
require(item['exit_code'] == 0 and item['timed_out'] is False
|
||||||
|
and item['names'] == manifest['test_names'][platform][kind]
|
||||||
|
and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
|
||||||
|
and re.search(rb'test result: ok\. ' + str(n).encode()
|
||||||
|
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', output),
|
||||||
|
'complete actual native Core result')
|
||||||
|
result[platform] = {'proof_sha256': sha(path), 'case_id': proof['case_id']}
|
||||||
|
for name, digest in manifest['source_files'].items():
|
||||||
|
if name.startswith(('crates/agent-core/', 'crates/domain/', 'crates/protocol/', 'proto/')):
|
||||||
|
require(sha(CODE / name) == digest, 'isolated common source equals actual native Core proof')
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
def reused_qualification():
|
||||||
|
require(sha(LOCAL) == LOCAL_SHA, 'exact retained local qualification')
|
||||||
|
value = cb.contract.protected_json(LOCAL)
|
||||||
|
require(value['type'] == 'rmm.windows.pipe-drain-local-qualification'
|
||||||
|
and value['source_before_after_equal'] is True and value['native_executed'] is False
|
||||||
|
and value['clock_qualified'] is False and value['native_counts_expected'] == COUNTS
|
||||||
|
and len(value['commands']) == 4 and all(c['exit_code'] == 0 for c in value['commands']),
|
||||||
|
'actual previous cross-Clippy/release/unit-link qualification')
|
||||||
|
for name, digest in value['source_files'].items():
|
||||||
|
require(sha(CODE / name) == digest, 'all original qualified inputs remain unchanged')
|
||||||
|
for item in list(value['artifacts'].values()) + list(value['unit_links'].values()):
|
||||||
|
path = Path(item['path'])
|
||||||
|
target = LOCAL.parent / 'target'
|
||||||
|
require(path.is_relative_to(target), 'qualified link under private target')
|
||||||
|
current = target
|
||||||
|
for part in ('',) + path.relative_to(target).parts:
|
||||||
|
if part:
|
||||||
|
current = current / part
|
||||||
|
info = current.lstat()
|
||||||
|
require(not stat.S_ISLNK(info.st_mode) and info.st_uid in (0, os.getuid())
|
||||||
|
and info.st_mode & 0o022 == 0, 'protected original compiler output')
|
||||||
|
require(stat.S_ISREG(path.lstat().st_mode) and sha(path) == item['sha256']
|
||||||
|
and path.stat().st_size == item['bytes'], 'retained exact qualified links')
|
||||||
|
require(re.search(r'^pub const ADAPTER_QUALIFIED: bool = false;$',
|
||||||
|
(CODE / 'crates/agent-windows/src/clock.rs').read_text(), re.M), 'production clock remains closed')
|
||||||
|
return value
|
||||||
|
|
||||||
|
|
||||||
|
def command(args, folder, name):
|
||||||
|
with (folder / (name + '.stdout')).open('xb') as out, (folder / (name + '.stderr')).open('xb') as err:
|
||||||
|
result = subprocess.run(args, stdout=out, stderr=err)
|
||||||
|
save(folder / (name + '.json'), {'exit_code': result.returncode, 'local_only': True, 'arguments': args})
|
||||||
|
require(result.returncode == 0, 'local build failed; original stdout/stderr retained')
|
||||||
|
|
||||||
|
|
||||||
|
def build():
|
||||||
|
before, common, prior = sources(), core_proof(), reused_qualification()
|
||||||
|
folder = BUILD / ('build-' + str(uuid.uuid4()))
|
||||||
|
folder.mkdir(mode=0o700, parents=True)
|
||||||
|
save(folder / 'source-before.json', before)
|
||||||
|
save(folder / 'reused-qualification.json', {'path': str(LOCAL), 'sha256': LOCAL_SHA, 'value': prior})
|
||||||
|
image = prior['build_image']
|
||||||
|
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable compiler image')
|
||||||
|
target = LOCAL.parent / 'target'
|
||||||
|
# Only these two RELEASE examples were missing. Original Clippy, EXEs and
|
||||||
|
# unit links are hash-bound above and are deliberately not rerun/rebuilt.
|
||||||
|
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
|
||||||
|
'-v', str(CODE) + ':/src:ro', '-v', str(target) + ':/target', '-e', 'CARGO_TARGET_DIR=/target',
|
||||||
|
'--entrypoint', 'cargo', image, 'build', '--manifest-path', '/src/Cargo.toml', '--locked', '--offline',
|
||||||
|
'--target', TARGET, '-p', 'rmm-agent-windows', '--features', 'system-helper', '--release',
|
||||||
|
'--example', 'runtime_state', '--example', 'system_state'], folder, 'release-examples')
|
||||||
|
selected = {'agent': Path(prior['artifacts']['agent']['path']), 'helper': Path(prior['artifacts']['helper']['path']),
|
||||||
|
'lib': Path(prior['unit_links']['lib']['path']), 'bin': Path(prior['unit_links']['bin']['path']),
|
||||||
|
'probe': target / TARGET / 'release/examples/runtime_state.exe',
|
||||||
|
'system_probe': target / TARGET / 'release/examples/system_state.exe'}
|
||||||
|
artifacts = {}
|
||||||
|
for kind, original in selected.items():
|
||||||
|
output, retained = folder / NAMES[kind], folder / (NAMES[kind] + '.linked')
|
||||||
|
original_sha = sha(original)
|
||||||
|
for destination in (retained, output):
|
||||||
|
shutil.copyfile(original, destination)
|
||||||
|
destination.chmod(0o600)
|
||||||
|
if kind in COUNTS:
|
||||||
|
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(folder) + ':/artifacts',
|
||||||
|
'--entrypoint', 'x86_64-w64-mingw32-strip', image, '--strip-debug', '/artifacts/' + NAMES[kind]],
|
||||||
|
folder, 'strip-' + kind)
|
||||||
|
require(sha(original) == sha(retained) == original_sha, 'original links retained unchanged')
|
||||||
|
data = output.read_bytes()
|
||||||
|
offset = int.from_bytes(data[60:64], 'little')
|
||||||
|
require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows AMD64 PE')
|
||||||
|
artifacts[kind] = {'path': str(output), 'name': NAMES[kind], 'sha256': sha(output), 'bytes': len(data),
|
||||||
|
'original_link_path': str(retained), 'original_link_sha256': original_sha,
|
||||||
|
'release_build': kind not in COUNTS, 'debug_stripped': kind in COUNTS}
|
||||||
|
require(sources() == before and core_proof() == common and reused_qualification() == prior,
|
||||||
|
'compiler inputs, original links and native Core proof unchanged before/after')
|
||||||
|
manifest = {'schema_version': 1, 'type': 'rmm.windows.pipe-v2-build', 'source_files': before,
|
||||||
|
'source_before_after_equal': True, 'code_root': str(CODE), 'access_root': str(ACCESS),
|
||||||
|
'artifacts': artifacts, 'test_names_expected': TESTS, 'native_counts_expected': COUNTS,
|
||||||
|
'core_native_proofs': common, 'reused_local_qualification': {'path': str(LOCAL), 'sha256': LOCAL_SHA},
|
||||||
|
'build_image_id': image, 'transport_version': 2, 'raw_v1_controls_qualified': False,
|
||||||
|
'production_clock_qualified': False, 'native_executed': False}
|
||||||
|
save(folder / 'manifest.json', manifest)
|
||||||
|
print(json.dumps({'manifest': str(folder / 'manifest.json'), 'native_executed': False}))
|
||||||
|
|
||||||
|
|
||||||
|
SCRIPT = r'''
|
||||||
|
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
|
||||||
|
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('run','read')-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed Pipe V2 unit case'}
|
||||||
|
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('native-pipe-v2-'+$p.id)
|
||||||
|
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Private unit type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty unit ACL'};foreach($r in $rules){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit ACL'}}}
|
||||||
|
function WriteNew($path,$value){$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 16 -Compress));$f=[IO.File]::Open($path,'CreateNew','Write','Read');try{$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
|
||||||
|
function ReadPrivate($path){Safe $path $false;if((Get-Item -LiteralPath $path).Length-gt196608){throw 'Unit report bound'};return (Get-Content -LiteralPath $path -Raw|ConvertFrom-Json)}
|
||||||
|
Safe $root $true
|
||||||
|
if($p.action-eq'read'){
|
||||||
|
if(!(Test-Path -LiteralPath $case)){@{case_exists=$false;completed=$false;readback_only=$true}|ConvertTo-Json -Compress;exit 0}
|
||||||
|
Safe $case $true;$i=ReadPrivate (Join-Path $case 'intent.json');if($i.manifest_sha256-cne$p.manifest_sha256){throw 'Original unit intent'}
|
||||||
|
$result=Join-Path $case 'result.json';if(Test-Path -LiteralPath $result){ReadPrivate $result|ConvertTo-Json -Depth 16 -Compress;exit 0}
|
||||||
|
$lists=@{};$reports=@{};foreach($kind in @('lib','bin')){$file=Join-Path $case ('list-'+$kind+'.json');if(Test-Path -LiteralPath $file){$lists[$kind]=ReadPrivate $file};$file=Join-Path $case ('report-'+$kind+'.json');if(Test-Path -LiteralPath $file){$reports[$kind]=ReadPrivate $file}}
|
||||||
|
@{case_exists=$true;completed=$false;readback_only=$true;started=(Test-Path -LiteralPath (Join-Path $case 'started.json'));lists=$lists;reports=$reports}|ConvertTo-Json -Depth 16 -Compress;exit 0
|
||||||
|
}
|
||||||
|
if(Test-Path -LiteralPath $case){throw 'Existing unit case: readback only'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p
|
||||||
|
function Run($exe,$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit process start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(30000)){$timed=$true;$c.Kill();if(!$c.WaitForExit(2000)){throw 'Own unit process did not exit'}};if(!$o.Wait(2000)-or!$e.Wait(2000)-or$o.Result.Length-gt65536-or$e.Result.Length-gt65536){throw 'Bounded unit output collection'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout=$o.Result;stderr=$e.Result}}finally{$c.Dispose()}}
|
||||||
|
$lists=@{};$paths=@{}
|
||||||
|
foreach($kind in @('lib','bin')){
|
||||||
|
$a=$p.artifacts.$kind;if($a.sha256-notmatch'^[a-f0-9]{64}$'-or$a.name-cne('windows-tests-'+$kind+'.exe')){throw 'Fixed test artifact'};$folder=Join-Path $root $a.sha256;Safe $folder $true;$exe=Join-Path $folder $a.name;Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$a.sha256-or(Get-Item -LiteralPath $exe).Length-ne$a.bytes){throw 'Exact unit artifact'}
|
||||||
|
$listed=Run $exe '--list --format terse';[string[]]$names=@($listed.stdout-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''});[Array]::Sort($names,[StringComparer]::Ordinal)
|
||||||
|
$value=@{sha256=$a.sha256;names=$names;listed=$listed};WriteNew (Join-Path $case ('list-'+$kind+'.json')) $value
|
||||||
|
if($listed.exit_code-ne0-or$listed.timed_out-or$names.Count-ne$p.counts.$kind-or(($names-join"`n")-cne(@($p.test_names.$kind)-join"`n"))){throw 'Exact complete native list before ANY tests'};$lists[$kind]=$value;$paths[$kind]=$exe
|
||||||
|
}
|
||||||
|
WriteNew (Join-Path $case 'both-lists-verified.json') @{manifest_sha256=$p.manifest_sha256;both_lists_verified_before_any_test=$true}
|
||||||
|
WriteNew (Join-Path $case 'started.json') @{start_once=$true};$reports=@{}
|
||||||
|
foreach($kind in @('lib','bin')){$run=Run $paths[$kind] '--test-threads=1';$value=@{sha256=$lists[$kind].sha256;names=$lists[$kind].names;listed=$lists[$kind].listed;result=$run};WriteNew (Join-Path $case ('report-'+$kind+'.json')) $value;$reports[$kind]=$value;if($run.exit_code-ne0-or$run.timed_out){throw 'Native unit execution failed; readback only'}}
|
||||||
|
$value=@{completed=$true;manifest_sha256=$p.manifest_sha256;reports=$reports;both_lists_verified_before_any_test=$true;bootstrap_administrator_units=$true;local_service_proof=$false;native_pipe_proof=$false;rmm_jobs=$false;product_state_writes=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 16 -Compress
|
||||||
|
'''
|
||||||
|
|
||||||
|
|
||||||
|
def verified(path, current=True):
|
||||||
|
path = private_file(path)
|
||||||
|
require(path.parent.parent == BUILD and path.parent.name.startswith('build-')
|
||||||
|
and str(uuid.UUID(path.parent.name[6:])) == path.parent.name[6:], 'fixed private build namespace')
|
||||||
|
value = cb.contract.protected_json(path)
|
||||||
|
require(value['type'] == 'rmm.windows.pipe-v2-build' and value['schema_version'] == 1
|
||||||
|
and value['source_before_after_equal'] is True and value['production_clock_qualified'] is False
|
||||||
|
and value['transport_version'] == 2 and value['raw_v1_controls_qualified'] is False
|
||||||
|
and value['native_executed'] is False
|
||||||
|
and value['reused_local_qualification'] == {'path': str(LOCAL), 'sha256': LOCAL_SHA}
|
||||||
|
and value['native_counts_expected'] == COUNTS and value['test_names_expected'] == TESTS
|
||||||
|
and value['code_root'] == str(CODE) and value['access_root'] == str(ACCESS), 'exact V2 build profile')
|
||||||
|
if current:
|
||||||
|
require(value['source_files'] == sources() and value['core_native_proofs'] == core_proof(), 'current source/Core proof binding')
|
||||||
|
require(set(value['artifacts']) == set(NAMES), 'six exact artifacts')
|
||||||
|
for kind, item in value['artifacts'].items():
|
||||||
|
output, original = private_file(item['path']), private_file(item['original_link_path'])
|
||||||
|
require(output == path.parent / NAMES[kind] and original == path.parent / (NAMES[kind] + '.linked')
|
||||||
|
and sha(output) == item['sha256'] and output.stat().st_size == item['bytes']
|
||||||
|
and sha(original) == item['original_link_sha256']
|
||||||
|
and item['release_build'] is (kind not in COUNTS)
|
||||||
|
and item['debug_stripped'] is (kind in COUNTS), 'exact retained delivery and original link')
|
||||||
|
return value
|
||||||
|
|
||||||
|
|
||||||
|
def native(path, ident=None):
|
||||||
|
path = path.resolve()
|
||||||
|
manifest = verified(path, current=ident is None)
|
||||||
|
if ident is None:
|
||||||
|
ident = str(uuid.uuid4());folder = NATIVE / ident;folder.mkdir(mode=0o700, parents=True)
|
||||||
|
save(folder / 'intent.json', {'id': ident, 'manifest_path': str(path), 'manifest_sha256': sha(path),
|
||||||
|
'runner_sha256': sha(__file__), 'script_sha256': hashlib.sha256(SCRIPT.encode()).hexdigest()})
|
||||||
|
before = {'counts': auto.scopes(), 'flags': auto.status()}
|
||||||
|
require(auto.flags_disabled(before['flags']), 'closed fault flags before native units')
|
||||||
|
save(folder / 'server-before.json', before)
|
||||||
|
for kind in COUNTS:
|
||||||
|
previous.upload(manifest['artifacts'][kind])
|
||||||
|
save(folder / 'started-local.json', {'start_once': True})
|
||||||
|
action = 'run'
|
||||||
|
else:
|
||||||
|
require(str(uuid.UUID(ident)) == ident, 'canonical original native case')
|
||||||
|
folder = NATIVE / ident;intent = cb.contract.protected_json(folder / 'intent.json')
|
||||||
|
require(intent['manifest_sha256'] == sha(path) and intent['manifest_path'] == str(path)
|
||||||
|
and intent['runner_sha256'] == sha(__file__)
|
||||||
|
and intent['script_sha256'] == hashlib.sha256(SCRIPT.encode()).hexdigest(), 'same original case; readback only')
|
||||||
|
action = 'read'
|
||||||
|
result = cb.powershell(SCRIPT, {'id': ident, 'action': action, 'manifest_sha256': sha(path),
|
||||||
|
'artifacts': {k: manifest['artifacts'][k] for k in COUNTS},
|
||||||
|
'counts': COUNTS, 'test_names': TESTS}, timeout=150)
|
||||||
|
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
|
||||||
|
if result.get('completed') is not True:
|
||||||
|
print(json.dumps({'verified': False, 'case_id': ident, 'readback_only': True, 'completed': False,
|
||||||
|
'case_exists': result.get('case_exists'), 'tests_repeated': False}))
|
||||||
|
return
|
||||||
|
require(result['manifest_sha256'] == sha(path) and set(result['reports']) == set(COUNTS)
|
||||||
|
and result['both_lists_verified_before_any_test'] is True
|
||||||
|
and result['rmm_jobs'] is False and result['product_state_writes'] is False
|
||||||
|
and result['local_service_proof'] is False and result['native_pipe_proof'] is False,
|
||||||
|
'actual narrow unit result, no runtime proof')
|
||||||
|
for kind, actual in result['reports'].items():
|
||||||
|
run, listed = actual['result'], actual['listed']
|
||||||
|
names = re.findall(r'^(.+): test\r?$', listed['stdout'], re.M)
|
||||||
|
require(actual['sha256'] == manifest['artifacts'][kind]['sha256']
|
||||||
|
and names == actual['names'] == TESTS[kind] and len(set(names)) == COUNTS[kind]
|
||||||
|
and listed['exit_code'] == run['exit_code'] == 0 and not listed['timed_out'] and not run['timed_out']
|
||||||
|
and re.search(r'test result: ok\. ' + str(COUNTS[kind])
|
||||||
|
+ r' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', run['stdout']),
|
||||||
|
'every exact named native unit passed, none skipped/filtered')
|
||||||
|
before = cb.contract.protected_json(folder / 'server-before.json')
|
||||||
|
require(auto.scopes() == before['counts'] and auto.status() == before['flags'], 'both central counts and closed flags unchanged')
|
||||||
|
if action == 'run':
|
||||||
|
verified(path) # Full before/after source and retained-artifact check.
|
||||||
|
proof = {'verified': True, 'case_id': ident, 'manifest_path': str(path), 'manifest_sha256': sha(path),
|
||||||
|
'native': result, 'no_jobs': True, 'clock_adapter_qualified': False,
|
||||||
|
'local_service_proof': False, 'native_pipe_proof': False}
|
||||||
|
destination = folder / 'passed.json'
|
||||||
|
if destination.exists():
|
||||||
|
require(cb.contract.protected_json(destination) == proof, 'retain exact original proof')
|
||||||
|
else:
|
||||||
|
save(destination, proof)
|
||||||
|
print(json.dumps({'verified': True, 'case_id': ident, 'tests': COUNTS, 'proof': str(destination)}))
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
os.umask(0o077)
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__)
|
||||||
|
parser.add_argument('phase', choices=('build-local', 'native-units', 'readback'))
|
||||||
|
parser.add_argument('--access-root', required=True, type=Path)
|
||||||
|
parser.add_argument('--manifest', type=Path)
|
||||||
|
parser.add_argument('--case')
|
||||||
|
args = parser.parse_args()
|
||||||
|
require(args.access_root == ACCESS and not args.access_root.is_symlink(), 'exact existing access root')
|
||||||
|
if args.phase == 'build-local':
|
||||||
|
require(args.manifest is None and args.case is None, 'build only')
|
||||||
|
build()
|
||||||
|
else:
|
||||||
|
require(args.manifest is not None and ((args.phase == 'readback') == bool(args.case)), 'explicit manifest and original readback case')
|
||||||
|
native(args.manifest, args.case)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
try:
|
||||||
|
main()
|
||||||
|
except Exception as error:
|
||||||
|
print('WINDOWS_PIPE_V2_QUALIFICATION_INCOMPLETE:' + type(error).__name__)
|
||||||
|
raise SystemExit(2) from None
|
||||||
@@ -0,0 +1,69 @@
|
|||||||
|
# Numerische Windows-Zeitdienstdiagnose
|
||||||
|
|
||||||
|
Stand2026-11-14: Diagnosequelle implementiert und unabhängig vom Produktions-
|
||||||
|
Clockpfad gebaut. Keine Lockerung von Statusguard, ALPC-/Identitätsprüfung,
|
||||||
|
`NativeClock.now()` oder `ADAPTER_QUALIFIED=false`. Keine neue Clockauthority.
|
||||||
|
Die feste zusätzliche Named-Pipe-Statusabfrage liefert ausschließlich acht
|
||||||
|
numerische Felder: Phase, tatsächliche RPC-Rückgabe samt Presenceflag,
|
||||||
|
aufgefangene Ausnahme und Strukturgrößen-/Zeigerpräsenz. Keine Quellen-/Peer-
|
||||||
|
Namen, Pointerwerte oder zusätzlichen Rückgabeeinträge werden veröffentlicht.
|
||||||
|
Eigener begrenzter Diagnoseworker; nach Timeout kein Ersatz/Retry.
|
||||||
|
|
||||||
|
Lokal tatsächlich bestanden: Windows-Example-Clippy mit Warnungen als Fehler,
|
||||||
|
fünf Linux-Clocktests, Windows-Testlink (nicht nativ ausgeführt) und Release-
|
||||||
|
Link.125Quellinputs vorher/nachher identisch. Originale Werkzeugabweichung
|
||||||
|
(Buildimage ohne WIDL) privat erhalten; erfolgreicher Build mit vorhandenem
|
||||||
|
unveränderlichem Clockimage. Artefakt `ecad703ad7208d55681c63ba9513fcf4c73b671951d4d1b5db1af9df49f43bdf`,
|
||||||
|
1779541Bytes. Privater Build `release-ca9a63b8-127c-4933-a45d-9e82449d6980`,
|
||||||
|
Qualifikation `36ce552e…`.
|
||||||
|
|
||||||
|
Danach tatsächlich auf der Windows-VM unter dem separaten LocalService-
|
||||||
|
Bootstrapdienst ausgeführt, Fall `2996df8c-b261-466a-8963-a526babf7f67`.
|
||||||
|
NativeReport und getrennter Readback identisch, eigener Dienst entfernt.
|
||||||
|
ALPC weiter1753/kein Endpunkt, keine erfolgreichen Identitätsnegativkontrollen.
|
||||||
|
Zusätzliche unabhängige Abfrage:1783, `stage=90`, `rpc_exception=1783`,
|
||||||
|
`native_rpc_return_present=0`, `status_present=0`. **Eine aufgefangene RPC-/
|
||||||
|
NDR-Ausnahme vor normaler Stub-Rückkehr ist belegt; der eigene nachgelagerte
|
||||||
|
Strukturguard wurde nicht erreicht.** Das Nullwertfeld `native_rpc_return=0`
|
||||||
|
ist ohne Presenceflag ausdrücklich kein erfolgreicher nativer Return.
|
||||||
|
|
||||||
|
Die genaue RPC-/NDR-Ursache bleibt offen. Source-/IDL-Prüfung folgt anhand
|
||||||
|
des [Microsoft-IDL](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-w32t/5793e908-22ef-4cea-962f-fca8a72c485a).
|
||||||
|
W32Time wurde für diese Diagnose nicht umkonfiguriert, keine Uhr gesetzt und
|
||||||
|
kein RMM-Job ausgeführt. Zentrale Windows0/0/0/0 und Linux30/30/26/0 samt
|
||||||
|
geschlossenen Testhooks/Rootpolicy erhalten. Dieses Ergebnis qualifiziert
|
||||||
|
weder Named-Pipe-Serveridentität noch eine vertrauenswürdige Uhr. Erst recht
|
||||||
|
öffnet es keinen Grant-/Jobpfad.
|
||||||
|
|
||||||
|
## Enger WIDL-Zeigervertrag: lokal korrigierter Kandidat
|
||||||
|
|
||||||
|
Die erhaltene generierte WIDL7-Typbeschreibung kodiert den ursprünglichen
|
||||||
|
Status-Ausgabeparameter als `FC_RP→FC_RP→STATUS`. Der dokumentierte Vertrag
|
||||||
|
verlangt außen eine Referenz, innen den Unique-Statuspointer. Auch die neu aus
|
||||||
|
Microsofts vollständigem IDL erzeugte WIDL7-Datei zeigt den doppelten Ref:
|
||||||
|
Es handelt sich präziser um die rekursive Parameterattributbehandlung dieses
|
||||||
|
Compilers, nicht lediglich um eine andere Schreibweise unseres Narrow-IDL.
|
||||||
|
[Pointerregeln](https://learn.microsoft.com/en-us/windows/win32/rpc/three-pointer-types),
|
||||||
|
[Typformat](https://learn.microsoft.com/en-us/windows/win32/rpc/pointers-tfs),
|
||||||
|
[WIDL7-Compilerquelle](https://raw.githubusercontent.com/wine-mirror/wine/wine-7.0/tools/widl/typegen.c).
|
||||||
|
|
||||||
|
Der enge Kandidat deklariert den inneren Typ ausdrücklich `[unique]` und lässt
|
||||||
|
das redundante äußere `[ref]` zugunsten des dokumentierten Parameterdefaults
|
||||||
|
weg. WIDL erzeugt tatsächlich `FC_RP→FC_UP→STATUS`; kein Stubbyte wurde gepatcht.
|
||||||
|
Ganze Procedureformatfolge/Opnum6 unverändert, alle19Statusfeldoffsets und120B-
|
||||||
|
Struktur gegen frisch erzeugte Microsoft-Full-IDL-Header per AMD64-Clangassert
|
||||||
|
geprüft. C/Auth/Statusguard/Clockgate unverändert. MicrosoftMIDL wurde mangels
|
||||||
|
nativer Werkzeuge ausdrücklich noch nicht ausgeführt.
|
||||||
|
|
||||||
|
Neuer privater Buildfall `f5805176-4a5a-468d-b1b2-088030253c8d`, Qualifikation
|
||||||
|
`e96baaf6…`:63Compilerinputs vorher/nachher gleich, fünf Clocktests tatsächlich
|
||||||
|
bestanden, beide WindowsGNU-Alltargets-Clippyprofile, Release- und Unitlink
|
||||||
|
bestanden. Ein zunächst0Tests selektierender Aufruf und ein falscher lokaler
|
||||||
|
Harnesslink bleiben als unvollständige Vorgängerlogs erhalten. Neues Artefakt
|
||||||
|
`91889303e1650d8612b946512f069a3421eb686c7bed315426c48bd62b18a1fd`,
|
||||||
|
Original-Linkdatei erhalten. Nur `native/w32time.idl` geändert, SHA `37da4acb…`.
|
||||||
|
|
||||||
|
**Native Prüfung dieses Kandidaten noch nicht ausgeführt.** Der tatsächliche
|
||||||
|
Auslöser der bisherigen1783-Ausnahme ist damit weiter nicht bewiesen. Kein
|
||||||
|
Clockvertrauen aus Codegenerierung oder lokalem Build, keine Rückstufung vom
|
||||||
|
unqualifizierten ALPC-Pfad auf eine nur vermeintlich authentisierte Pipe.
|
||||||
@@ -0,0 +1,112 @@
|
|||||||
|
# Windows Helper: begrenzte Transportbestätigung
|
||||||
|
|
||||||
|
Dieser Schnitt ist im isolierten Zweig `codex/windows-pipe-drain` implementiert.
|
||||||
|
Eine native Ausführung des neuen Framings und ein Komponentenupgrade sind noch
|
||||||
|
nicht nachgewiesen. Die bestehenden Nachweise des Agenten `89004ad3…` und Helpers
|
||||||
|
`e6aacbdd…` bleiben historische Belege ihres ursprünglichen Framings.
|
||||||
|
|
||||||
|
## Anlass und Beleggrenze
|
||||||
|
|
||||||
|
Beim tatsächlichen Agenten wurde `client_read_reply / HELPER_PIPE_IO / 233`
|
||||||
|
beobachtet; die Helperdiagnose war nicht vorhanden. Der bisherige Dienst rief
|
||||||
|
auch nach erfolgreichem Schreiben der Antwort sofort `DisconnectNamedPipe` auf.
|
||||||
|
Microsoft dokumentiert, dass dabei ungelesene Pipebytes verworfen werden. Das
|
||||||
|
ist ein konkreter möglicher Fehlerpfad, aber kein Nachweis, dass genau dieser
|
||||||
|
Pfad die beobachtete Störung verursacht hat.
|
||||||
|
[DisconnectNamedPipe](https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-disconnectnamedpipe)
|
||||||
|
|
||||||
|
Eine fehlende Diagnose beweist weder einen erfolgreichen Peercheck noch eine
|
||||||
|
bestimmte Ablehnung: strukturierte `Denied`-Antworten erzeugen keinen privaten
|
||||||
|
Pipefehlerbeleg, Connect-Leerlauf kann ohne Beleg enden, und das begrenzte
|
||||||
|
Diagnoseschreiben selbst kann fehlschlagen. Diese Pfade werden hier nicht
|
||||||
|
umgedeutet oder gelockert.
|
||||||
|
|
||||||
|
## Framing v2 und Reihenfolge
|
||||||
|
|
||||||
|
Agent und Helper verwenden ausschließlich `\\.\pipe\RustDiscovery-System-v2`.
|
||||||
|
Jeder JSON-Frame beginnt mit acht ASCIIbytes `RDPIPC02`, gefolgt von vier Bytes
|
||||||
|
Länge in Big Endian und den bisherigen, maximal 1 MiB großen JSONbytes.
|
||||||
|
V1 und V2 haben unterschiedliche Endpunkte; zusätzlich verweigert der V2-Parser
|
||||||
|
alte oder fremde Framingtags. Es gibt keinen stillen Fallback. Beide EXEs müssen
|
||||||
|
als gemeinsam qualifiziertes, gegenseitig gepinntes Paar bereitgestellt werden.
|
||||||
|
Die JSONschemas von Call/Reply, `helper.system.v1`, Systempolicy-Schema 1 und
|
||||||
|
RMM-Jobbytes ändern sich nicht.
|
||||||
|
|
||||||
|
Nach dem vollständigen Lesen der Antwort prüft der Agent weiterhin den tatsächlichen
|
||||||
|
Helperprozess, Schema, Challenge, Enrollmentbindung, Policyhash, Helperbinaryhash
|
||||||
|
und die Operation/Antwort-Zuordnung. Erst danach schreibt er genau 56 Bytes:
|
||||||
|
`RDPACK02` (8), ursprüngliche UUID-Challenge in UUID-Bytefolge (16), SHA-256 der
|
||||||
|
**exakt empfangenen JSON-Antwortbytes** (32). Es findet keine Re-Serialisierung
|
||||||
|
für diese Prüfsumme statt. Auch eine vollständig geprüfte `Denied`-Antwort wird
|
||||||
|
so transportseitig bestätigt, ohne sie in einen Erfolg umzuwandeln.
|
||||||
|
|
||||||
|
Der Helper prüft denselben bereits authentifizierten Peer vor dem Schreiben und
|
||||||
|
nach dem Lesen der Bestätigung. Schreiben, Empfang und Prüfung der Bestätigung
|
||||||
|
teilen dieselbe bisherige Antwortdeadline von fünf Sekunden; der Client behält
|
||||||
|
seine bisherige Gesamtdeadline. Erst danach trennt die Dienstschleife die Pipe.
|
||||||
|
Fehlende, falsche oder verspätete Bestätigung schließt den bestehenden Syncgate
|
||||||
|
und trennt die Verbindung über den bisherigen Fehlerpfad; statische Diagnosen
|
||||||
|
unterscheiden `server_drain_receipt` und `client_drain_receipt`. Es gibt keinen
|
||||||
|
weiteren Aufruf, Retry oder erneute Ausführung.
|
||||||
|
|
||||||
|
Diese Bestätigung bestätigt nur den Empfang der Antwortbytes. Sie ist kein
|
||||||
|
JobResult-, Journal-, SignedSync-, Grant-, Freigabe- oder Wirkungsbeleg und löscht
|
||||||
|
keinen dauerhaften Zustand. Ein bereits ausgeführter Auftrag wird durch einen
|
||||||
|
fehlenden Transport-ACK nicht zurückgenommen oder wiederholt.
|
||||||
|
|
||||||
|
`FlushFileBuffers` wird nicht verwendet: dieser synchrone Pipeaufruf wartet laut
|
||||||
|
Microsoft bis zum Lesen aller gepufferten Daten und bietet hier keine passende
|
||||||
|
begrenzte Warteoperation.
|
||||||
|
[FlushFileBuffers](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-flushfilebuffers)
|
||||||
|
|
||||||
|
## Prüfung und verbleibender nativer Nachweis
|
||||||
|
|
||||||
|
Die bestehenden IPC-Codecfälle prüfen zusätzlich fremde/alte Frameversionen,
|
||||||
|
begrenzte Längen sowie manipulierte ACK-Tags, Challenge und Prüfsumme. Eine andere
|
||||||
|
JSON-Bytefolge mit gleichem JSON-Inhalt darf den ursprünglichen Frame nicht
|
||||||
|
bestätigen. Die bestehenden Unitfallzahlen bleiben dadurch unverändert.
|
||||||
|
Lokale Qualifikation wird separat in einem geschützten `devstate/`-Beleg mit
|
||||||
|
Quellen- und Artefakthashes erfasst. Cross-Clippy und Linken sind kein nativer
|
||||||
|
Pipebeleg. Vor einem Zielupgrade sind unabhängiger Quellreview, die nativen
|
||||||
|
Windows-Units des gleichen Manifests und ein eigener erhaltender Paarupgrade mit
|
||||||
|
explizitem Backup sowie anschließendem tatsächlichen Agent/Helper-Austausch
|
||||||
|
notwendig. Alle Produktgates bleiben geschlossen.
|
||||||
|
|
||||||
|
Lokale Ausführung: Default- und `system-helper`-Clippy für alle Windows-GNU-Targets
|
||||||
|
mit `-D warnings`, Release-Build beider EXEs und Linken beider Unitprogramme waren
|
||||||
|
erfolgreich. 61 gebundene Quelldateien blieben vor/nach dem Lauf gleich. Die
|
||||||
|
bestehenden 23 Library- und 7 Binary-Unitfälle sind weiterhin die **erwartete**
|
||||||
|
native Liste; hier wurde kein Windows-Testprogramm ausgeführt. Geschützter
|
||||||
|
Beleg: `devstate/windows-pipe-drain/qualification-1e0f2b22-1e74-41af-b8ed-0a356be054ba/qualification.json`.
|
||||||
|
|
||||||
|
## Separater Build-/Unitrunner
|
||||||
|
|
||||||
|
`deploy/windows/system_pipe_acceptance.py` erstellt einen neuen Pack unter
|
||||||
|
`devstate/windows-pipe-drain-build/`. Er prüft den unveränderten lokalen
|
||||||
|
Qualifikationsbeleg samt ursprünglichen Links und verwendet die bereits
|
||||||
|
bestandenen Clippy-/Release-/Unitlinkschritte wieder. Nur die fehlenden beiden
|
||||||
|
Release-Stateprobes werden ergänzt. Alle sechs Auslieferungsdateien erhalten
|
||||||
|
eine unveränderte `.linked`-Kopie; ausschließlich die Unit-Auslieferungskopien
|
||||||
|
werden von Debuginformationen befreit. Neue Quellen einschließlich Runner,
|
||||||
|
Compilerimage, Cargo-/Protoinputs und tatsächlich verwendeter Bootstrapmodule
|
||||||
|
sind vor/nach dem Build gebunden.
|
||||||
|
|
||||||
|
`--access-root` muss der ursprüngliche Hauptcheckout sein. Nur dort werden die
|
||||||
|
vorhandenen geschützten Zugangskonfigurationen für den bereits gepinnten
|
||||||
|
Bootstraptransport und die tatsächlichen Linux-80-/Windows-58-Corebelege gelesen.
|
||||||
|
Es werden keine Zugangsdaten oder Main-`devstate`-Bäume kopiert oder verlinkt.
|
||||||
|
Neue Build-, Upload- und Unitfallbelege gehören zum isolierten Pipeworktree.
|
||||||
|
|
||||||
|
Der Native-Unitfall verwendet den neuen Namespace `native-pipe-v2`. **Beide**
|
||||||
|
vollständigen nativen Listen müssen exakt den erwarteten 23 Library- und 7
|
||||||
|
Binary-Namen entsprechen, bevor irgendein Unitfall ausgeführt wird. Intent,
|
||||||
|
Listen, Start und einzelne Testergebnisse werden create-only gespeichert.
|
||||||
|
Nach einem Antwortverlust darf ausschließlich derselbe Fall gelesen werden;
|
||||||
|
auch ein fehlender oder unvollständiger Fall löst keinen erneuten Start aus.
|
||||||
|
Die Units laufen als Bootstrapadministrator, nicht als Produkt-LocalService,
|
||||||
|
und beweisen keinen tatsächlichen Pipeaustausch. Zentral gespeicherte
|
||||||
|
Gerätezähler und geschlossene Fault-/Policyflags werden vor/nach verglichen.
|
||||||
|
|
||||||
|
Der bestehende rohe `helper_peer_controls::raw`-Probe schreibt weiterhin einen
|
||||||
|
V1-Header. Sein Ablehnungsresultat ist deshalb **kein** V2-Peernegativnachweis;
|
||||||
|
Runner und Manifest behaupten ausdrücklich keine solche Qualifikation.
|
||||||
@@ -0,0 +1,89 @@
|
|||||||
|
# Windows MSI runtime: implementierter, noch nicht nativ abgenommener Schnitt
|
||||||
|
|
||||||
|
Stand 2026-11-14, isolierter Zweig `codex/windows-msi-runtime`, Basis `66c1855`.
|
||||||
|
Dies ist ein Quellen-/Lokalnachweis. Es wurde damit kein Windows-Installer,
|
||||||
|
RMM-Job, Dienstwechsel oder Bootstrap am Ziel ausgeführt. Die nativen
|
||||||
|
Domain-/Backend-Nachweise des vorhergehenden M4-Schritts ersetzen die folgenden
|
||||||
|
noch offenen Runtime-Nachweise nicht.
|
||||||
|
|
||||||
|
## Implementierte Grenze
|
||||||
|
|
||||||
|
Der Network-Agent lädt ausschließlich das im genehmigten Originaljob gebundene
|
||||||
|
MSI-Artefakt über den bestehenden mTLS-Client und den festen Agent-Endpunkt.
|
||||||
|
Es gibt keine Installer-URL, Weiterleitung, Bearer-Abkürzung oder abgeschaltete
|
||||||
|
TLS-Prüfung. Länge und SHA-256 sind auf das Manifest und höchstens 256 KiB
|
||||||
|
begrenzt. Das Staging liegt unter dem festen Agentzustandsverzeichnis.
|
||||||
|
|
||||||
|
Der SYSTEM-Helper nimmt weiterhin nur die originale signierte Request an,
|
||||||
|
keinen Callerpfad und keine Installerbytes. Settings-Schema 1 bleibt SCM-only;
|
||||||
|
Schema 2 kann höchstens zwei genaue Recipe-SHA-256 freigeben. Fehlende neue
|
||||||
|
Settings-Felder werden beim Serialisieren ausgelassen; vorhandenes `null` ist
|
||||||
|
kein erlaubter Recipe-Allowlistwert. Die lokale Allowlist begrenzt ausschließlich
|
||||||
|
und ersetzt weder Plan, Startgrant, Clock noch signierten Sync.
|
||||||
|
|
||||||
|
Vor einer SYSTEM-Cachekopie persistiert der Helper den atomaren Originalstart
|
||||||
|
mit Verbrauch. Die Kopie verwendet den manifestabgeleiteten SHA-Pfad, prüft
|
||||||
|
Nicht-Reparse, Elternhandles, File-ID, Länge, Hash und die SYS/Admin-Cachegrenze.
|
||||||
|
Neue Cacheeinträge werden ohne Ersetzen bestehender Dateien veröffentlicht.
|
||||||
|
Cache/Staging müssen vorher eingerichtet sein; der Runtimecode repariert weder
|
||||||
|
ACLs noch Verzeichnisse. Der Provider hält eigene Archiv-/Prozesshandles.
|
||||||
|
|
||||||
|
Ein originales monotones Laufzeitbudget umfasst SYSTEM-Cacheaufbereitung,
|
||||||
|
MSI-Metadaten, unabhängige Bestandsprüfung, Noopentscheidung und Installerlauf.
|
||||||
|
Die festen Argumente und MSI-Tabellenprüfungen bleiben erhalten. Erfolg benötigt
|
||||||
|
unabhängige Product-/Family-/PackageCode-/Payload-Nachbedingungen; `3010` bleibt
|
||||||
|
als Rebootbedarf sichtbar, `1641` unklar, `1618` ein fehlgeschlagener eigener
|
||||||
|
Start. Noop hat keinen Installerexitcode. Weder automatischer Reboot noch
|
||||||
|
allgemeines `msiexec`-Kill oder automatischer Wiederholungsstart sind enthalten.
|
||||||
|
|
||||||
|
Die vorhandene Intentzeile besitzt zusätzlich eine dauerhafte, ausschließlich
|
||||||
|
verweigernde Abbruchmarkierung. Sie ist nur von 0 nach 1 änderbar; Originalbytes,
|
||||||
|
Grant und `may_have_dispatched` werden dabei nicht zurückgesetzt. Eine eng
|
||||||
|
geprüfte additive Migration akzeptiert nur die bisherige genaue Tabellen- und
|
||||||
|
Triggerdefinition. Der Helper liest die vollständige Originalbindung über eine
|
||||||
|
jeweils frische gewöhnliche Read-only-Verbindung vor Noop/Start und während der
|
||||||
|
Beobachtung. Fehlende, fehlerhafte oder gesperrte Beobachtung verweigert. Dies ist
|
||||||
|
keine zusätzliche Ausführungsautorität. Zwischen letzter Prüfung und OS-Start
|
||||||
|
bleibt das übliche kleine Rennen; es gibt kein behauptetes Rückgängigmachen.
|
||||||
|
|
||||||
|
Nach unklarem Timeout oder Beobachtungsfehler hält der Helper den eigenen Child,
|
||||||
|
Archivhandles und Originalgrant-/Requestbindung in einem ungeklärten Slot.
|
||||||
|
Weitere MSI-Starts werden bis zur Beobachtung desselben Prozessendes verweigert.
|
||||||
|
Ein späterer Exit ändert das bereits persistierte `unknown` nicht. Nach einem
|
||||||
|
Helperabsturz bleibt die ursprüngliche Ledger-Sperre bestehen. Intent, Abandon,
|
||||||
|
RawMirror und signierter Core-Sync behalten ihre strengen Originalbindungen;
|
||||||
|
keine Missing-row-Regel wurde gelockert.
|
||||||
|
|
||||||
|
## Tatsächlich lokale Prüfung
|
||||||
|
|
||||||
|
Der private Fall `qualified-ee6681c7-8d9d-4af9-8947-5325e1ea2e0f` unter
|
||||||
|
`devstate/windows-msi-runtime/` bindet 82 Compiler-/Manifestquellen vor und nach
|
||||||
|
allen qualifizierten Prüfungen identisch. Qualification-SHA-256:
|
||||||
|
`17f3eb2258773a22be26afd9681d271f69136cfb52dbda31aac2a0ef577b3816`.
|
||||||
|
|
||||||
|
- Linux-Container: 10 Bibliothekstests ausgeführt, 10 bestanden, 0 ignoriert.
|
||||||
|
- Windows-GNU: Default- und SYSTEM-Feature-Alltargets-Clippy mit `-D warnings`
|
||||||
|
bestanden.
|
||||||
|
- Windows-GNU: Lib-/Agent-Bin-Unittests gelinkt, nicht ausgeführt.
|
||||||
|
- Windows-GNU: beide Releasebinaries gelinkt; AMD64-PE geprüft. Originale und
|
||||||
|
mit `--strip-all` bearbeitete Auslieferungsdateien sind getrennt erhalten.
|
||||||
|
- `git diff --check` bestanden. Keine Domain-/Core-/Server-/Web- oder
|
||||||
|
Root-Cargo-/Lockänderung.
|
||||||
|
|
||||||
|
Release-Auslieferung Agent:
|
||||||
|
`7d9b1221ccb3587437d0866296472330947a16445c4e40069981fc4197242d83`.
|
||||||
|
Release-Auslieferung Helper:
|
||||||
|
`96589d53d366a0ccbd60c301fd3d1f03cd4d9f93d85bdcb3ce9b7f4647afc273`.
|
||||||
|
Die Zwischenbelege vor der ergänzten laufenden Abbruchbeobachtung bleiben
|
||||||
|
historisch erhalten und sind nicht die finale Qualification.
|
||||||
|
|
||||||
|
## Noch offen
|
||||||
|
|
||||||
|
Die Windows-Unitbinaries, Cache-/Staging-ACLs und gehaltenen Handles, tatsächliche
|
||||||
|
PERSIST-Migration mit konkurrierender Deny-Lesung, Installer 1.0, MajorUpgrade
|
||||||
|
1.1, beide Noops und die Abbruch-/Unklarheitsfälle müssen auf der Windows-VM
|
||||||
|
nachgewiesen werden. Installerjobs benötigen jeweils die reale WebUI-Grenze.
|
||||||
|
Capabilityliste bleibt passiv, Clock-Gate unqualifiziert, Job-/Effektdefaults
|
||||||
|
bleiben geschlossen. Diese Implementierung behauptet weder native MSI-Abnahme
|
||||||
|
noch Windows-MVP-Abschluss. EXE, WinGet, allgemeine Installerargumente oder eine
|
||||||
|
neue Rebootstrecke gehören nicht zu diesem Schnitt.
|
||||||
Reference in New Issue
Block a user