Validate the read-only Windows journal verifier on the Linux test VM
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 22:39:15 +01:00
parent cd3225dbed
commit 363975d8a8
2 changed files with 371 additions and 0 deletions
@@ -0,0 +1,362 @@
//! Operator-side readback of the two historical Windows test decisions.
//! Output contains public digests only. This example has no repair or job entry point.
use anyhow::{Context, Result, ensure};
use prost::Message;
use rmm_agent_core::{
auth::Binding,
crypto::DalekVerifier,
helper_reconcile::SignedResponse,
reconcile::{Channel, verify_response_with},
};
use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload};
use rmm_protocol::{Envelope, Payload, SyncRequest, SyncResponse};
use rusqlite::{Connection, OpenFlags, params};
use std::{
fs::{File, OpenOptions},
io::Read,
path::Path,
};
use uuid::Uuid;
const AGENT: &str = "63ea15b2-0643-403d-b5b4-cba1288dbea3";
const BOOT: &str = "a9ad0895-5a96-8f2c-8fb6-cfdc2d5225ea";
const FIRST: &str = "b6a3101f-68ad-41c8-be4e-4c7c2bc963d6";
const LAST: &str = "0633a4de-7e52-4e5d-a2a1-59fb134817fe";
const FAULT: &str = "HELPER_CHECKPOINT_REQUIRED";
const BINDING_SHA256: &str = "9239ee9f4142735867e77451478bf309fbf449d730a0ede6c958bc8018830dde";
const CASES: [(&str, &str, u64); 2] = [
("1418b4a3-8370-404d-b29a-920ba9f0f4d7", FIRST, 6755),
("9eba037c-825f-4a96-be14-cca130c1e83d", LAST, 6756),
];
fn held(path: &Path) -> Result<File> {
for node in path.ancestors() {
let meta = node.symlink_metadata()?;
ensure!(!meta.file_type().is_symlink(), "unexpected symbolic link");
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
ensure!(
meta.file_attributes() & 0x400 == 0,
"unexpected reparse point"
);
}
}
let mut options = OpenOptions::new();
options.read(true);
#[cfg(windows)]
{
use std::os::windows::fs::OpenOptionsExt;
options.share_mode(3); // FILE_SHARE_READ | FILE_SHARE_WRITE, deny delete/rename.
}
let f = options.open(path)?;
ensure!(f.metadata()?.is_file(), "expected a regular file");
Ok(f)
}
struct Snapshot {
db: Connection,
_held: Vec<File>,
}
impl Snapshot {
fn open(path: &str) -> Result<Self> {
let mut file = held(Path::new(path))?;
let mut hdr = [0; 20];
file.read_exact(&mut hdr)?;
ensure!(&hdr[..16] == b"SQLite format 3\0", "unexpected DB header");
ensure!(
hdr[18] == hdr[19] && matches!(hdr[18], 1 | 2),
"unexpected DB mode"
);
let mut handles = vec![file];
if hdr[18] == 2 {
// Pin both original sidecars before the read-only SQLite connection opens.
for suffix in ["-wal", "-shm"] {
handles.push(held(Path::new(&format!("{path}{suffix}")))?);
}
}
let db = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
db.execute_batch("PRAGMA query_only=ON; PRAGMA trusted_schema=OFF; BEGIN;")?;
ensure!(
db.is_readonly(rusqlite::DatabaseName::Main)?,
"read-only database required"
);
Ok(Self { db, _held: handles })
}
}
fn inspect(
agent: &Connection,
local: &Connection,
helper: &Connection,
binding: &Binding,
) -> Result<()> {
let count = |db: &Connection, sql| -> Result<i64> { Ok(db.query_row(sql, [], |r| r.get(0))?) };
ensure!(
count(agent, "SELECT count(*) FROM reconcile_requests")? == 2
&& count(local, "SELECT count(*) FROM reconcile_consumption")? == 2
&& count(helper, "SELECT count(*) FROM helper_sync_decisions")? == 1,
"history length"
);
ensure!(
count(
agent,
"SELECT (SELECT count(*) FROM job_attempts)+(SELECT count(*) FROM reconcile_outcomes)+(SELECT count(*) FROM reconcile_results)"
)? == 0
&& count(
local,
"SELECT (SELECT count(*) FROM consumed)+(SELECT count(*) FROM execution_evidence)"
)? == 0
&& count(
helper,
"SELECT (SELECT count(*) FROM consumed)+(SELECT count(*) FROM execution_evidence)"
)? == 0,
"nonempty execution history"
);
let chan = Channel {
connection_generation: 150,
boot_id: Uuid::parse_str(BOOT)?,
};
let mut digest_lines = Vec::new();
for (request_id, decision_id, checkpoint) in CASES {
let (raw_request, envelope_bytes, raw_response): (Vec<u8>, Vec<u8>, Vec<u8>) = agent.query_row(
"SELECT request,envelope,response FROM reconcile_requests WHERE id=? AND generation=150 AND length(request) BETWEEN 1 AND 524288 AND length(envelope) BETWEEN 1 AND 524288 AND length(response) BETWEEN 1 AND 524288",
[request_id], |r| Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
let request = SyncRequest::decode(raw_request.as_slice())?;
let envelope = Envelope::decode(envelope_bytes.as_slice())?;
let response = SyncResponse::decode(raw_response.as_slice())?;
ensure!(
request.encode_to_vec() == raw_request && response.encode_to_vec() == raw_response,
"noncanonical original record"
);
ensure!(
envelope.protocol_major == 1
&& envelope.protocol_minor == 0
&& envelope.agent_id == AGENT
&& envelope.enrollment_generation == 1
&& envelope.connection_generation == 150
&& envelope.boot_id == BOOT
&& envelope.sequence == checkpoint
&& envelope.payload == Some(Payload::SyncRequest(request.clone())),
"envelope binding"
);
let first = decision_id == FIRST;
ensure!(
request.request_id == request_id
&& request.checkpoint == checkpoint
&& request.assignment_version == 1
&& request.helper_checkpoint == 1
&& request.journal_complete
&& request.previous_decision_id == if first { "" } else { FIRST }
&& request.previous_request_id.is_empty()
&& request.helper_previous_decision_id.is_empty()
&& request.attempts.is_empty(),
"request history"
);
// Historical validation uses the signed issue time, never a present-day lease.
let historical: ReconcileDecisionPayload =
serde_json::from_slice(&response.decision_bytes)?;
let d = verify_response_with(
&DalekVerifier,
binding,
&request,
&chan,
&response,
historical.issued_at,
)?;
ensure!(
d.decision_id.to_string() == decision_id
&& d.attempts.is_empty()
&& d.ready == first
&& d.helper_ready == first
&& d.reason == if first { "CONSISTENT" } else { FAULT },
"signed decision"
);
let ledger_response: Vec<u8> = local.query_row("SELECT response FROM reconcile_consumption WHERE decision_id=? AND length(response) BETWEEN 1 AND 524288", [decision_id], |r|r.get(0))?;
ensure!(
ledger_response == raw_response,
"consumption decision differs"
);
if !first {
let (helper_raw, helper_request): (Vec<u8>, Vec<u8>) = helper.query_row(
"SELECT response,request FROM helper_sync_decisions WHERE decision_id=? AND checkpoint=1 AND length(response) BETWEEN 1 AND 2097152 AND length(request) BETWEEN 1 AND 524288",
[decision_id], |r|Ok((r.get(0)?,r.get(1)?)))?;
let h: SignedResponse = serde_json::from_slice(&helper_raw)?;
ensure!(
helper_request == raw_request
&& h.decision_bytes == response.decision_bytes
&& h.signature == response.signature,
"helper signed history"
);
let head: bool = agent.query_row("SELECT EXISTS(SELECT 1 FROM reconcile_meta WHERE id=1 AND journal_id=?1 AND checkpoint=6756 AND generation=150 AND last_decision=?2 AND pending_request IS NULL AND helper_id=?3 AND helper_checkpoint=1 AND fault=?4)",params![request.journal_id, LAST, request.helper_journal_id, FAULT], |r|r.get(0))?;
let helper_head: bool = helper.query_row("SELECT EXISTS(SELECT 1 FROM helper_sync_meta WHERE id=1 AND journal_id=?1 AND checkpoint>=1 AND generation=150 AND last_decision=?2 AND agent_journal_id=?3 AND agent_checkpoint=6756 AND fault IS NULL)",params![request.helper_journal_id,LAST,request.journal_id],|r|r.get(0))?;
ensure!(head && helper_head, "live reconciliation heads differ");
}
digest_lines.push(format!(
"{checkpoint} request {}\n{checkpoint} decision {}\n{checkpoint} signature {}",
hash(&raw_request),
hash(&response.decision_bytes),
hash(&response.signature)
));
}
for line in digest_lines {
println!("{line}");
}
println!(
"public key {}",
hash(&hex::decode(&binding.public_key_hex)?)
);
println!("gen150 journals agree on {LAST}; helper decisions 1");
println!("agent fault {FAULT}; jobs and consumptions 0");
Ok(())
}
fn main() -> Result<()> {
ensure!(
cfg!(windows) && std::env::args_os().count() == 1,
"fixed Windows VM readback only"
);
let mut bytes = Vec::new();
held(Path::new(r"C:\ProgramData\RustDiscovery\binding.json"))?
.take(8193)
.read_to_end(&mut bytes)?;
ensure!(
bytes.len() <= 8192 && hash(&bytes) == BINDING_SHA256,
"unexpected public binding"
);
let binding: Binding = serde_json::from_slice(&bytes)?;
let agent = Snapshot::open(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite")
.context("agent database")?;
let local = Snapshot::open(r"C:\ProgramData\RustDiscovery\state\consumption.sqlite")
.context("agent consumption")?;
let helper = Snapshot::open(r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite")
.context("helper database")?;
inspect(&agent.db, &local.db, &helper.db, &binding)
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::{Duration, Utc};
use ed25519_dalek::{Signer, SigningKey};
#[test]
fn verifies_two_originals_and_rejects_changed_history() -> Result<()> {
let a = Connection::open_in_memory()?;
let l = Connection::open_in_memory()?;
let h = Connection::open_in_memory()?;
rmm_agent_core::reconcile::initialize(&a)?;
a.execute_batch("CREATE TABLE job_attempts(job);")?;
for db in [&l, &h] {
db.execute_batch(
"CREATE TABLE consumed(grant_id); CREATE TABLE execution_evidence(grant_id);",
)?;
}
l.execute_batch("CREATE TABLE reconcile_consumption(decision_id,response);")?;
h.execute_batch("CREATE TABLE helper_sync_decisions(decision_id,checkpoint,response,request); CREATE TABLE helper_sync_meta(id,journal_id,checkpoint,generation,last_decision,agent_journal_id,agent_checkpoint,fault);")?;
let id = Uuid::new_v4();
let peer = Uuid::new_v4();
let key = SigningKey::from_bytes(&[13; 32]); // Public deterministic fixture only.
let binding = Binding {
tenant_id: Uuid::new_v4(),
agent_id: Uuid::parse_str(AGENT)?,
asset_id: Uuid::new_v4(),
assignment_version: 1,
enrollment_generation: 1,
public_key_hex: hex::encode(key.verifying_key().to_bytes()),
};
for (req, dec, cp) in CASES {
let first = dec == FIRST;
let r = SyncRequest {
request_id: req.into(),
journal_id: id.to_string(),
checkpoint: cp,
assignment_version: 1,
journal_complete: true,
helper_journal_id: peer.to_string(),
helper_checkpoint: 1,
previous_decision_id: if first { "" } else { FIRST }.into(),
..Default::default()
};
let raw = r.encode_to_vec();
let e = Envelope {
protocol_major: 1,
agent_id: AGENT.into(),
enrollment_generation: 1,
connection_generation: 150,
boot_id: BOOT.into(),
sequence: cp,
payload: Some(Payload::SyncRequest(r)),
..Default::default()
};
let now = Utc::now() - Duration::hours(1);
let d = ReconcileDecisionPayload {
domain: "rmm.reconciliation-decision".into(),
schema_version: 1,
decision_id: Uuid::parse_str(dec)?,
request_id: Uuid::parse_str(req)?,
request_hash: hash(&raw),
tenant_id: binding.tenant_id,
asset_id: binding.asset_id,
agent_id: binding.agent_id,
enrollment_generation: 1,
assignment_version: 1,
connection_generation: 150,
boot_id: Uuid::parse_str(BOOT)?,
journal_id: id,
checkpoint: cp,
helper_journal_id: Some(peer),
helper_checkpoint: 1,
issued_at: now,
valid_until: now + Duration::seconds(60),
ready: first,
helper_ready: first,
reason: if first { "CONSISTENT" } else { FAULT }.into(),
attempts: vec![],
acknowledged_message_ids: vec![],
key_id: hash(&key.verifying_key().to_bytes()),
};
let bytes = serde_json::to_vec(&d)?;
let signed = SyncResponse {
signature: key.sign(&bytes).to_bytes().into(),
decision_bytes: bytes,
};
a.execute("INSERT INTO reconcile_requests(id,request,envelope,generation,response) VALUES(?,?,?,150,?)",params![req,raw,e.encode_to_vec(),signed.encode_to_vec()])?;
l.execute(
"INSERT INTO reconcile_consumption VALUES(?,?)",
params![dec, signed.encode_to_vec()],
)?;
if !first {
h.execute(
"INSERT INTO helper_sync_decisions VALUES(?,1,?,?)",
params![
dec,
serde_json::to_vec(&SignedResponse {
signature: signed.signature,
decision_bytes: signed.decision_bytes
})?,
raw
],
)?;
}
}
a.execute("UPDATE reconcile_meta SET journal_id=?,checkpoint=6756,generation=150,last_decision=?,helper_id=?,helper_checkpoint=1,fault=?",params![id.to_string(),LAST,peer.to_string(),FAULT])?;
h.execute(
"INSERT INTO helper_sync_meta VALUES(1,?,9,150,?,?,6756,NULL)",
params![peer.to_string(), LAST, id.to_string()],
)?;
inspect(&a, &l, &h, &binding)?;
let mut foreign = binding.clone();
foreign.public_key_hex =
hex::encode(SigningKey::from_bytes(&[14; 32]).verifying_key().to_bytes());
assert!(inspect(&a, &l, &h, &foreign).is_err());
l.execute(
"UPDATE reconcile_consumption SET response=x'01' WHERE decision_id=?",
[FIRST],
)?;
assert!(inspect(&a, &l, &h, &binding).is_err());
Ok(())
}
}
+9
View File
@@ -387,3 +387,12 @@ Ausführungszählern erfasste Prüfbeleg hat SHA-256
Zwei lokal veränderte Kopien derselben zweiten Serverlesung dienten als
Negativproben. Der Prüfer verwarf eine ersetzte Signatur und ebenso
einen fälschlich als gültigen Vorgänger eingetragenen Checkpoint 6756.
Auf der Cloud-Linux-VM prüfte das Fixture
`tests::verifies_two_originals_and_rejects_changed_history` die
Journalgegenprüfung am 15. November um 21:38:31 UTC. Beide
Originalsignaturen der Testdaten bestanden. Das Fixture wies einen
fremden Schlüssel und eine veränderte Verbrauchsquittung ab. Ein Test
bestand mit Exit 0 als UID 65534 im eigenen Netzwerk-Namespace.
Fall `97130142-3ac3-4d7d-b086-f366e99d9a30`, SHA-256 des Belegs
`36368fb6325448e4d0e66e431542ac98e8ccc1d722e2ec32720daf0bba4e6870`.