Integrate signed agent catalog, tenant enrollment and HTTPS installers
This commit is contained in:
@@ -7,6 +7,10 @@
|
||||
#[path = "../src/helper_ipc.rs"]
|
||||
pub mod helper_ipc;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub mod update_admission { pub use rmm_agent_windows::update_admission::Accepted; }
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub mod update_observer { pub use rmm_agent_windows::update_observer::{Request,Response}; }
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub use rmm_agent_windows::SERVICE_NAME;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod platform {
|
||||
|
||||
@@ -0,0 +1,532 @@
|
||||
//! One reviewed development bootstrap: normal stop of the exact old agent,
|
||||
//! while an existing SQLite reservation excludes a new Sync/permit journal
|
||||
//! commit. No job, approval, SQL row change, helper stop, reset or force kill.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod platform {
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use prost::Message;
|
||||
use rmm_agent_core::{
|
||||
auth::{Binding, Outcome, Request},
|
||||
crypto::DalekVerifier,
|
||||
helper_reconcile::SignedResponse,
|
||||
reconcile::{Channel, verify_response_with},
|
||||
};
|
||||
use rmm_agent_windows::{
|
||||
helper_ipc::{self as ipc, PeerProof, PinnedFile},
|
||||
native,
|
||||
};
|
||||
use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload};
|
||||
use rmm_protocol::{SyncRequest, SyncResponse,Envelope,Payload};
|
||||
use rusqlite::{Connection, OpenFlags};
|
||||
use serde_json::json;
|
||||
use std::{
|
||||
fs::{File, OpenOptions},
|
||||
io::{Read, Write},
|
||||
mem::{size_of, zeroed},
|
||||
os::windows::fs::OpenOptionsExt,
|
||||
path::Path,
|
||||
ptr,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::*, Security::*, Storage::FileSystem::*, System::Services::*,
|
||||
};
|
||||
const AGENT: &str = "9651b2e518b315029cebfa432261a57f0a305aeddde29c56ac22a5ccbc417b32";
|
||||
const HELPER: &str = "59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e";
|
||||
const PIN: &str = "9d46dffe88f565b8b04554335d9669f5c83211b32419908a579b1cd4560443ec";
|
||||
const SETTINGS: &str = "4c073cd3d4badb09d8c0f1c270b4cee9df533df416550f68bf3e336e3da7673c";
|
||||
const CONFIG: &str = "5cd4cb9802d0dd20b961de7e3cd4e5874a1e9a72fc57b577e075e2d2918baac6";
|
||||
const CASE: &str = "c6c80ac4-a52e-4b69-8170-466bcf52049d";
|
||||
const JOB: &str = "0a50aae9-a784-4535-b62f-ef24c301d546";
|
||||
const ATTEMPT: &str = "78295f74-4565-459a-87b0-641a8b95feec";
|
||||
const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state";
|
||||
const HELPER_STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state";
|
||||
struct Handle(SC_HANDLE);
|
||||
impl Drop for Handle {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
CloseServiceHandle(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn admin() -> Result<()> {
|
||||
let mut sid = [0usize; 16];
|
||||
let mut len = std::mem::size_of_val(&sid) as u32;
|
||||
let mut member = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
CreateWellKnownSid(
|
||||
WinBuiltinAdministratorsSid,
|
||||
ptr::null_mut(),
|
||||
sid.as_mut_ptr().cast(),
|
||||
&mut len,
|
||||
)
|
||||
} != 0
|
||||
&& unsafe {
|
||||
CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member)
|
||||
} != 0
|
||||
&& member != 0,
|
||||
"QUIESCENT_ADMIN_REQUIRED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn service(stop:bool) -> Result<Handle> {
|
||||
let manager =
|
||||
Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
|
||||
ensure!(!manager.0.is_null(), "QUIESCENT_SCM_MANAGER");
|
||||
let h = Handle(unsafe {
|
||||
OpenServiceW(
|
||||
manager.0,
|
||||
ipc::wide(rmm_agent_windows::SERVICE_NAME).as_ptr(),
|
||||
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | if stop {SERVICE_STOP}else{0},
|
||||
)
|
||||
});
|
||||
ensure!(!h.0.is_null(), "QUIESCENT_SCM_AGENT");
|
||||
Ok(h)
|
||||
}
|
||||
fn status(h: &Handle) -> Result<SERVICE_STATUS_PROCESS> {
|
||||
let mut s = unsafe { zeroed() };
|
||||
let mut n = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
QueryServiceStatusEx(
|
||||
h.0,
|
||||
SC_STATUS_PROCESS_INFO,
|
||||
(&mut s as *mut SERVICE_STATUS_PROCESS).cast(),
|
||||
size_of::<SERVICE_STATUS_PROCESS>() as u32,
|
||||
&mut n,
|
||||
)
|
||||
} != 0,
|
||||
"QUIESCENT_SCM_STATUS"
|
||||
);
|
||||
Ok(s)
|
||||
}
|
||||
fn protected(path: &Path, readers: &[String], expected: &str) -> Result<(PinnedFile, Vec<u8>)> {
|
||||
let mut file = PinnedFile::open(path, false, readers, &[], false)?;
|
||||
ensure!(
|
||||
file.file.metadata()?.len() <= 65536,
|
||||
"QUIESCENT_PUBLIC_FILE_LIMIT"
|
||||
);
|
||||
let mut raw = Vec::new();
|
||||
(&mut file.file).take(65537).read_to_end(&mut raw)?;
|
||||
ensure!(
|
||||
raw.len() <= 65536 && hash(&raw) == expected,
|
||||
"QUIESCENT_PUBLIC_HASH"
|
||||
);
|
||||
file.check()?;
|
||||
Ok((file, raw))
|
||||
}
|
||||
fn hold_agent(path: &Path) -> Result<File> {
|
||||
native::private_path(path, false)?;
|
||||
Ok(OpenOptions::new()
|
||||
.read(true)
|
||||
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
|
||||
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||
.open(path)?)
|
||||
}
|
||||
fn check_id(file: &File, path: &Path) -> Result<()> {
|
||||
let actual = hold_agent(path)?;
|
||||
ensure!(
|
||||
ipc::file_identity(file)? == ipc::file_identity(&actual)?,
|
||||
"QUIESCENT_DATABASE_REPLACED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn receipt(dir: &Path, name: &str, value: &serde_json::Value) -> Result<()> {
|
||||
let bytes = serde_json::to_vec(value)?;
|
||||
ensure!(bytes.len() <= 16384, "QUIESCENT_RECEIPT_LIMIT");
|
||||
let path = dir.join(name);
|
||||
let mut f = OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.share_mode(FILE_SHARE_READ)
|
||||
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH)
|
||||
.open(&path)?;
|
||||
f.write_all(&bytes)?;
|
||||
f.sync_all()?;
|
||||
drop(f);
|
||||
let mut read = PinnedFile::open(&path, false, &[], &[], false)?;
|
||||
ensure!(read.sha256()? == hash(&bytes), "QUIESCENT_RECEIPT_READBACK");
|
||||
Ok(())
|
||||
}
|
||||
struct Idle {
|
||||
decision: Uuid,
|
||||
checkpoint: u64,
|
||||
helper_checkpoint: u64,
|
||||
request_sha256: String,
|
||||
response_sha256: String,
|
||||
original_echo_job: Uuid,
|
||||
pending_request:Option<String>,
|
||||
pending_request_sha256:Option<String>,
|
||||
}
|
||||
fn idle(
|
||||
db: &Connection,
|
||||
consumption: &Connection,
|
||||
helper: &Connection,
|
||||
intents: &Connection,
|
||||
binding: &Binding,
|
||||
) -> Result<Idle> {
|
||||
let (journal,checkpoint,generation,last,pending,helper_id,helper_cp,fault):(String,u64,u64,String,Option<String>,String,u64,Option<String>)=db.query_row("SELECT journal_id,checkpoint,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?,r.get(7)?)))?;
|
||||
ensure!(fault.is_none(),"QUIESCENT_AGENT_FAULT");
|
||||
let (helper_journal, helper_last, helper_fault,helper_agent_cp): (String, String, Option<String>,u64) = helper
|
||||
.query_row(
|
||||
"SELECT journal_id,last_decision,fault,agent_checkpoint FROM helper_sync_meta WHERE id=1",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?,r.get(3)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
helper_fault.is_none() && helper_last == last && helper_journal == helper_id,
|
||||
"QUIESCENT_HELPER_HEAD_DIFFERS"
|
||||
);
|
||||
let (raw_response, raw_request, applied_cp): (Vec<u8>, Vec<u8>, u64) = helper.query_row(
|
||||
"SELECT response,request,checkpoint FROM helper_sync_decisions WHERE decision_id=?1",
|
||||
[&last],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
applied_cp == helper_cp,
|
||||
"QUIESCENT_HELPER_APPLIED_CHECKPOINT"
|
||||
);
|
||||
let signed: SignedResponse = serde_json::from_slice(&raw_response)?;
|
||||
let parsed: ReconcileDecisionPayload = serde_json::from_slice(&signed.decision_bytes)?;
|
||||
let (agent_request, agent_response): (Vec<u8>, Vec<u8>) = db.query_row(
|
||||
"SELECT request,response FROM reconcile_requests WHERE id=?1",
|
||||
[parsed.request_id.to_string()],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
let response = SyncResponse::decode(agent_response.as_slice())?;
|
||||
let request = SyncRequest::decode(agent_request.as_slice())?;
|
||||
ensure!(
|
||||
raw_request == agent_request
|
||||
&& signed.decision_bytes == response.decision_bytes
|
||||
&& signed.signature == response.signature,
|
||||
"QUIESCENT_RAW_SIGNED_CONTROL_DIFFERS"
|
||||
);
|
||||
let verified = verify_response_with(
|
||||
&DalekVerifier,
|
||||
binding,
|
||||
&request,
|
||||
&Channel {
|
||||
connection_generation: parsed.connection_generation,
|
||||
boot_id: parsed.boot_id,
|
||||
},
|
||||
&response,
|
||||
parsed.issued_at,
|
||||
)?;
|
||||
ensure!(
|
||||
verified.decision_id.to_string() == last
|
||||
&& verified.journal_id.to_string() == journal
|
||||
&& verified.checkpoint == helper_agent_cp
|
||||
&& verified.checkpoint<=checkpoint
|
||||
&& verified.connection_generation<=generation
|
||||
&& verified.helper_journal_id.map(|id| id.to_string()) == Some(helper_id.clone())
|
||||
&& verified.helper_checkpoint == helper_cp
|
||||
&& verified.ready
|
||||
&& verified.helper_ready
|
||||
&& verified.reason == "CONSISTENT",
|
||||
"QUIESCENT_SIGNED_HEAD_BINDING"
|
||||
);
|
||||
let pending_request=if let Some(id)=pending.as_ref() {
|
||||
let (request_raw,envelope_raw,row_generation,response):(Vec<u8>,Vec<u8>,u64,Option<Vec<u8>>)=db.query_row("SELECT request,envelope,generation,response FROM reconcile_requests WHERE id=?1",[id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?)))?;
|
||||
ensure!(response.is_none() && request_raw.len()<=rmm_domain::MAX_MESSAGE && envelope_raw.len()<=rmm_domain::MAX_MESSAGE,"QUIESCENT_ONLY_UNRESPONDED_CONTROL");
|
||||
let request=SyncRequest::decode(request_raw.as_slice())?;
|
||||
let envelope=Envelope::decode(envelope_raw.as_slice())?;
|
||||
ensure!(request.encode_to_vec()==request_raw && envelope.encode_to_vec()==envelope_raw
|
||||
&& request.request_id==*id && request.journal_id==journal && request.checkpoint==checkpoint
|
||||
&& request.previous_decision_id==last && request.helper_previous_decision_id==last
|
||||
&& request.helper_journal_id==helper_id && request.helper_checkpoint>=helper_cp
|
||||
&& request.assignment_version==binding.assignment_version && request.journal_complete
|
||||
&& request.durable_message_ids.is_empty() && request.attempts.len()==2
|
||||
&& row_generation==generation && envelope.connection_generation==generation
|
||||
&& envelope.agent_id==binding.agent_id.to_string() && envelope.enrollment_generation==binding.enrollment_generation
|
||||
&& envelope.boot_id==verified.boot_id.to_string() && envelope.sequence==checkpoint
|
||||
&& rmm_protocol::valid_envelope(&envelope,&binding.agent_id.to_string(),generation)
|
||||
&& matches!(envelope.payload,Some(Payload::SyncRequest(ref body)) if body==&request),"QUIESCENT_PENDING_CONTROL_BINDING");
|
||||
Some(request)
|
||||
}else {
|
||||
ensure!(verified.checkpoint==checkpoint && verified.connection_generation==generation,"QUIESCENT_WITHOUT_PENDING_EXACT_HEAD");
|
||||
None
|
||||
};
|
||||
let busy:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))",[],|r|r.get(0))?;
|
||||
ensure!(!busy, "QUIESCENT_EFFECT_PENDING");
|
||||
let (scope, original) = rmm_agent_windows::echo_probe::archive(db, binding)?
|
||||
.context("QUIESCENT_ECHO_ARCHIVE_MISSING")?;
|
||||
ensure!(
|
||||
rmm_agent_windows::echo_completion::installed(db, binding, &scope, &original)?,
|
||||
"QUIESCENT_ECHO_COMPLETION_MISSING"
|
||||
);
|
||||
let (total,echo,pending_new):(u64,u64,u64)=db.query_row("SELECT count(*),sum(job=?1 AND attempt=?2 AND state='succeeded'),sum(job=?3 AND attempt=?4 AND state IN ('accepted','expired') AND grant_id='') FROM job_attempts",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string(),JOB,ATTEMPT],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
|
||||
ensure!(
|
||||
total == 2 && echo == 1 && pending_new == 1,
|
||||
"QUIESCENT_EXPECTED_TWO_JOB_HISTORY"
|
||||
);
|
||||
if let Some(request)=&pending_request {
|
||||
let echo=request.attempts.iter().filter(|r|r.job_id==scope.job_id.to_string() && r.attempt_id==scope.attempt_id.to_string()).collect::<Vec<_>>();
|
||||
let new=request.attempts.iter().filter(|r|r.job_id==JOB && r.attempt_id==ATTEMPT).collect::<Vec<_>>();
|
||||
ensure!(echo.len()==1 && new.len()==1,"QUIESCENT_PENDING_EXPECTED_ATTEMPTS");
|
||||
let old=echo[0];let new=new[0];
|
||||
let old_grant:String=db.query_row("SELECT grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|r.get(0))?;
|
||||
ensure!(old.state=="succeeded" && old.consumption=="consumed" && old.grant_id==old_grant
|
||||
&& !old.grant_id.is_empty() && old.job_payload_hash==scope.job_payload_hash && old.update_handoff_bytes.is_empty()
|
||||
&& matches!(new.state.as_str(),"accepted"|"expired") && new.consumption=="unconsumed" && new.grant_id.is_empty()
|
||||
&& new.update_handoff_bytes.is_empty(),"QUIESCENT_PENDING_NO_NEW_EFFECT");
|
||||
}
|
||||
let (total, new): (u64, u64) = consumption.query_row(
|
||||
"SELECT count(*),COALESCE(sum(job=?1 OR attempt=?2),0) FROM consumed",
|
||||
[JOB, ATTEMPT],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
ensure!(total == 1 && new == 0, "QUIESCENT_CONSUMPTION_CHANGED");
|
||||
let (start,outcome,finished):(Vec<u8>,Vec<u8>,Vec<u8>)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.job=?1 AND c.attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
|
||||
let start: serde_json::Value = serde_json::from_slice(&start)?;
|
||||
let request: Request = serde_json::from_value(start["request"].clone())?;
|
||||
let at = serde_json::from_value(start["reserved_at"].clone())?;
|
||||
let (job, _) = binding.verify_with(&request, at, &DalekVerifier)?;
|
||||
let o: Outcome = serde_json::from_slice(&outcome)?;
|
||||
ensure!(
|
||||
scope.matches_job(&job)
|
||||
&& o.state == "succeeded"
|
||||
&& o.evidence["postconditions_passed"] == true
|
||||
&& outcome == finished,
|
||||
"QUIESCENT_ORIGINAL_ECHO_EVIDENCE"
|
||||
);
|
||||
ensure!(
|
||||
helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, u64>(0))? == 0
|
||||
&& intents.query_row("SELECT count(*) FROM system_intents", [], |r| r
|
||||
.get::<_, u64>(0))?
|
||||
== 0,
|
||||
"QUIESCENT_HELPER_WORK_PRESENT"
|
||||
);
|
||||
Ok(Idle {
|
||||
decision: verified.decision_id,
|
||||
checkpoint,
|
||||
helper_checkpoint: helper_cp,
|
||||
request_sha256: hash(&raw_request),
|
||||
response_sha256: hash(&raw_response),
|
||||
original_echo_job: scope.job_id,
|
||||
pending_request:pending,
|
||||
pending_request_sha256:pending_request.as_ref().map(|r|hash(&r.encode_to_vec())),
|
||||
})
|
||||
}
|
||||
fn safe_error(error:&anyhow::Error)->serde_json::Value {
|
||||
for cause in error.chain() {
|
||||
let text=cause.to_string();
|
||||
if text.starts_with("QUIESCENT_") && text.bytes().all(|b|b.is_ascii_uppercase()||b==b'_') {return json!({"code":text});}
|
||||
if let Some(sql)=cause.downcast_ref::<rusqlite::Error>() {
|
||||
return match sql {
|
||||
rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),
|
||||
rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),
|
||||
rusqlite::Error::InvalidColumnIndex(index)=>json!({"code":"SQLITE_COLUMN_INDEX","index":index}),
|
||||
rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),
|
||||
_=>json!({"code":"SQLITE_READ_FAILED"}),
|
||||
};
|
||||
}
|
||||
}
|
||||
json!({"code":"SIGNED_OR_ARCHIVED_EVIDENCE_CHECK_FAILED"})
|
||||
}
|
||||
fn safe_metadata(db:&Connection,consumed:&Connection,helper:&Connection,intents:&Connection)->Result<serde_json::Value> {
|
||||
let agent=db.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault IS NOT NULL FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({
|
||||
"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault_present":r.get::<_,bool>(5)?})))?;
|
||||
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,fault IS NOT NULL,agent_checkpoint FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({
|
||||
"current_capture_checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"fault_present":r.get::<_,bool>(3)?,"agent_checkpoint":r.get::<_,u64>(4)?})))?;
|
||||
let mut q=db.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
|
||||
let jobs=q.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
let counts=json!({"events":db.query_row("SELECT count(*) FROM events",[],|r|r.get::<_,u64>(0))?,"job_events":db.query_row("SELECT count(*) FROM job_events",[],|r|r.get::<_,u64>(0))?,
|
||||
"agent_consumed":consumed.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"agent_execution_evidence":consumed.query_row("SELECT count(*) FROM execution_evidence",[],|r|r.get::<_,u64>(0))?,
|
||||
"helper_consumed":helper.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"helper_intents":intents.query_row("SELECT count(*) FROM system_intents",[],|r|r.get::<_,u64>(0))?});
|
||||
Ok(json!({"agent":agent,"helper":helper_meta,"jobs":jobs,"counts":counts}))
|
||||
}
|
||||
pub fn run() -> Result<()> {
|
||||
let args=std::env::args().skip(1).collect::<Vec<_>>();
|
||||
let read_only=args==["--read-idle-check"];
|
||||
ensure!(read_only || args==["--stop-known-idle-agent"],"QUIESCENT_ARGUMENTS");
|
||||
admin()?;
|
||||
let bootstrap = PinnedFile::open(
|
||||
Path::new(r"C:\ProgramData\RustDiscoveryBootstrap"),
|
||||
true,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let dir = bootstrap.path.join(format!("quiescent-stop-{CASE}"));
|
||||
let mut dir_guard=if read_only {None}else{
|
||||
std::fs::create_dir(&dir)?;
|
||||
Some(PinnedFile::open(&dir,true,&[],&[],false)?)
|
||||
};
|
||||
let readers = [
|
||||
ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?,
|
||||
ipc::service_sid(ipc::HELPER_SERVICE)?,
|
||||
];
|
||||
let (mut pin_guard, raw) = protected(
|
||||
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"),
|
||||
&readers,
|
||||
PIN,
|
||||
)?;
|
||||
let pin: ipc::Pin = serde_json::from_slice(&raw)?;
|
||||
pin.validate()?;
|
||||
ensure!(
|
||||
pin.agent.binary_sha256 == AGENT && pin.helper.binary_sha256 == HELPER,
|
||||
"QUIESCENT_EXACT_PAIR"
|
||||
);
|
||||
let (mut settings_guard, _) = protected(
|
||||
Path::new(r"C:\ProgramData\RustDiscoverySystem\helper.json"),
|
||||
&readers,
|
||||
SETTINGS,
|
||||
)?;
|
||||
let (mut config_guard, raw) = protected(
|
||||
Path::new(r"C:\ProgramData\RustDiscovery\config.json"),
|
||||
&[readers[0].clone()],
|
||||
CONFIG,
|
||||
)?;
|
||||
let cfg: serde_json::Value = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
cfg["enable_jobs"] == true
|
||||
&& cfg.get("windows_echo_probe_only").is_none_or(|v|v==false)
|
||||
&& cfg["state_directory"] == AGENT_STATE,
|
||||
"QUIESCENT_EXACT_CONFIGURATION"
|
||||
);
|
||||
let agent_service = service(!read_only)?;
|
||||
let before = status(&agent_service)?;
|
||||
ensure!(
|
||||
before.dwCurrentState == SERVICE_RUNNING,
|
||||
"QUIESCENT_AGENT_NOT_RUNNING"
|
||||
);
|
||||
let mut peer = PeerProof::for_service(&pin.agent, before.dwProcessId)?;
|
||||
let helper_manager=Handle(unsafe{OpenSCManagerW(ptr::null(),ptr::null(),SC_MANAGER_CONNECT)});
|
||||
ensure!(!helper_manager.0.is_null(),"QUIESCENT_HELPER_SCM_MANAGER");
|
||||
let helper_service=Handle(unsafe{OpenServiceW(helper_manager.0,ipc::wide(ipc::HELPER_SERVICE).as_ptr(),SERVICE_QUERY_STATUS|SERVICE_QUERY_CONFIG)});
|
||||
ensure!(!helper_service.0.is_null(),"QUIESCENT_HELPER_SCM");
|
||||
let helper_before=status(&helper_service)?;
|
||||
ensure!(helper_before.dwCurrentState==SERVICE_RUNNING,"QUIESCENT_HELPER_NOT_RUNNING");
|
||||
let mut helper_peer=PeerProof::for_service(&pin.helper,helper_before.dwProcessId)?;
|
||||
// Keep original journal/sidecar names and ledger against replacement.
|
||||
let journal_path = Path::new(AGENT_STATE).join("telemetry.sqlite");
|
||||
let journal_file = hold_agent(&journal_path)?;
|
||||
let _wal = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-wal"))?;
|
||||
let _shm = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-shm"))?;
|
||||
let consumption_path = Path::new(AGENT_STATE).join("consumption.sqlite");
|
||||
let consumption_file = hold_agent(&consumption_path)?;
|
||||
let helper_writer = ipc::service_sid(ipc::HELPER_SERVICE)?;
|
||||
let mut helper_file = PinnedFile::open_read_shared(
|
||||
&Path::new(HELPER_STATE).join("ledger.sqlite"),
|
||||
false,
|
||||
&[],
|
||||
std::slice::from_ref(&helper_writer),
|
||||
)?;
|
||||
let mut intent_file = PinnedFile::open_read_shared(
|
||||
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"),
|
||||
false,
|
||||
&[],
|
||||
&[readers[0].clone()],
|
||||
)?;
|
||||
let db = Connection::open_with_flags(&journal_path, if read_only {OpenFlags::SQLITE_OPEN_READ_ONLY}else{OpenFlags::SQLITE_OPEN_READ_WRITE})?;
|
||||
db.busy_timeout(Duration::from_millis(20))?;
|
||||
let consumed =
|
||||
Connection::open_with_flags(&consumption_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
||||
let helper =
|
||||
Connection::open_with_flags(&helper_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
||||
let intents =
|
||||
Connection::open_with_flags(&intent_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
||||
if read_only {
|
||||
let mut observations=Vec::new();
|
||||
for _ in 0..10 {
|
||||
db.execute_batch("BEGIN")?;helper.execute_batch("BEGIN")?;
|
||||
let checked=idle(&db,&consumed,&helper,&intents,&pin.binding);
|
||||
let metadata=safe_metadata(&db,&consumed,&helper,&intents)?;
|
||||
let error=checked.as_ref().err().map(safe_error);
|
||||
helper.execute_batch("ROLLBACK")?;db.execute_batch("ROLLBACK")?;
|
||||
observations.push(json!({"observed_at":chrono::Utc::now(),"idle_check_passed":checked.is_ok(),"error":error,"metadata":metadata}));
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
peer.check()?;helper_peer.check()?;
|
||||
println!("{}",serde_json::to_string(&json!({"schema_version":1,"mode":"read_idle_check","read_only":true,"quiescence_reservation_held":false,"stop_requested":false,"case_created":false,"sql_data_changed":false,"samples":observations}))?);
|
||||
return Ok(());
|
||||
}
|
||||
let until = Instant::now() + Duration::from_secs(30);
|
||||
let locked = loop {
|
||||
if Instant::now() >= until {
|
||||
anyhow::bail!("QUIESCENT_HEAD_NOT_OBSERVED_NO_STOP");
|
||||
}
|
||||
if db.execute_batch("BEGIN IMMEDIATE").is_err() {
|
||||
std::thread::sleep(Duration::from_millis(25));
|
||||
continue;
|
||||
}
|
||||
helper.execute_batch("BEGIN")?;
|
||||
let value = idle(&db, &consumed, &helper, &intents, &pin.binding);
|
||||
helper.execute_batch("ROLLBACK")?;
|
||||
match value {
|
||||
Ok(value) => break value,
|
||||
Err(_) => {
|
||||
db.execute_batch("ROLLBACK")?;
|
||||
std::thread::sleep(Duration::from_millis(25));
|
||||
}
|
||||
}
|
||||
};
|
||||
// All final observations occur while new agent writes remain excluded.
|
||||
peer.check()?;
|
||||
helper_peer.check()?;
|
||||
pin_guard.check()?;
|
||||
settings_guard.check()?;
|
||||
config_guard.check()?;
|
||||
dir_guard.as_mut().context("QUIESCENT_CASE_GUARD")?.check()?;
|
||||
check_id(&journal_file, &journal_path)?;
|
||||
check_id(&consumption_file, &consumption_path)?;
|
||||
helper_file.check()?;
|
||||
intent_file.check()?;
|
||||
let current = status(&agent_service)?;
|
||||
ensure!(
|
||||
current.dwCurrentState == SERVICE_RUNNING && current.dwProcessId == before.dwProcessId,
|
||||
"QUIESCENT_ORIGINAL_PROCESS_CHANGED"
|
||||
);
|
||||
receipt(
|
||||
&dir,
|
||||
"stop-intent.json",
|
||||
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"agent_sha256":AGENT,"helper_sha256":HELPER,"pin_sha256":PIN,"config_sha256":CONFIG,
|
||||
"agent_pid":before.dwProcessId,"journal_file_id":ipc::file_identity(&journal_file)?,"consumption_file_id":ipc::file_identity(&consumption_file)?,"helper_ledger_file_id":helper_file.identity,"decision_id":locked.decision,
|
||||
"checkpoint":locked.checkpoint,"helper_applied_checkpoint":locked.helper_checkpoint,"signed_request_sha256":locked.request_sha256,"signed_helper_response_sha256":locked.response_sha256,"original_echo_job":locked.original_echo_job,
|
||||
"pending_job":JOB,"pending_control_request":locked.pending_request,"pending_control_request_sha256":locked.pending_request_sha256,"new_grants":0,"helper_consumptions":0,"helper_intents":0,"sql_data_changed":false,"agent_journal_immediate_reservation_held":true,"stop_service_only":rmm_agent_windows::SERVICE_NAME,"force_kill":false}),
|
||||
)?;
|
||||
let mut returned: SERVICE_STATUS = unsafe { zeroed() };
|
||||
let stop_ok =
|
||||
unsafe { ControlService(agent_service.0, SERVICE_CONTROL_STOP, &mut returned) } != 0;
|
||||
let error = if stop_ok {
|
||||
None
|
||||
} else {
|
||||
Some(unsafe { GetLastError() })
|
||||
};
|
||||
let wait = Instant::now() + Duration::from_secs(125);
|
||||
let mut final_status = status(&agent_service)?;
|
||||
while stop_ok && final_status.dwCurrentState != SERVICE_STOPPED && Instant::now() < wait {
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
final_status = status(&agent_service)?;
|
||||
}
|
||||
let stopped = stop_ok && final_status.dwCurrentState == SERVICE_STOPPED;
|
||||
helper_peer.check()?;
|
||||
// Still held through the confirmed stop (or bounded honest failure).
|
||||
check_id(&journal_file, &journal_path)?;
|
||||
check_id(&consumption_file, &consumption_path)?;
|
||||
receipt(
|
||||
&dir,
|
||||
"stop-result.json",
|
||||
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"normal_stop_requested_once":stop_ok,"native_error":error,"stopped":stopped,"state":final_status.dwCurrentState,"pid":final_status.dwProcessId,
|
||||
"sql_data_changed":false,"job_executed":false,"helper_stopped":false,"reset":false,"force_kill":false,"reservation_held_until_observation":true}),
|
||||
)?;
|
||||
db.execute_batch("ROLLBACK")?;
|
||||
ensure!(stopped, "QUIESCENT_STOP_UNCONFIRMED_NO_FORCE");
|
||||
println!("{{\"case_id\":\"{CASE}\",\"stopped\":true,\"sql_data_changed\":false}}");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
fn main() {
|
||||
if let Err(error) = platform::run() {
|
||||
eprintln!("{}", error);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "system-helper")))]
|
||||
fn main() {
|
||||
eprintln!("Windows SYSTEM-helper SDK bootstrap only");
|
||||
std::process::exit(1);
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
//! Administrator bootstrap metadata READ ONLY. Never stops a service, opens a
|
||||
//! writable SQLite connection, repairs history, reads keys, or executes jobs.
|
||||
#[cfg(windows)]
|
||||
mod native {
|
||||
use anyhow::{Result,ensure};
|
||||
use prost::Message;
|
||||
use rusqlite::{Connection,OpenFlags};
|
||||
use serde_json::{Value,json};
|
||||
use std::{path::Path,time::Duration};
|
||||
use windows_sys::Win32::{Foundation::CloseHandle,Security::{GetTokenInformation,TOKEN_ELEVATION,TOKEN_QUERY,TokenElevation},System::Threading::{GetCurrentProcess,OpenProcessToken}};
|
||||
fn db(path:&str)->Result<Connection>{ensure!(Path::new(path).is_file(),"SYNC_DIAGNOSTIC_FILE_MISSING");let db=Connection::open_with_flags(path,OpenFlags::SQLITE_OPEN_READ_ONLY|OpenFlags::SQLITE_OPEN_NO_MUTEX)?;db.busy_timeout(Duration::from_millis(500))?;Ok(db)}
|
||||
fn requests(db:&Connection)->Result<Value>{
|
||||
let mut stmt=db.prepare("SELECT id,generation,length(request),response IS NOT NULL,request FROM reconcile_requests ORDER BY rowid DESC LIMIT 2")?;
|
||||
let rows=stmt.query_map([],|r|Ok((r.get::<_,String>(0)?,r.get::<_,u64>(1)?,r.get::<_,u64>(2)?,r.get::<_,bool>(3)?,r.get::<_,Vec<u8>>(4)?)))?.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
Ok(json!(rows.into_iter().map(|(id,generation,bytes,response,raw)|{
|
||||
let decoded=rmm_protocol::SyncRequest::decode(raw.as_slice()).ok();
|
||||
json!({"request_id":id,"generation":generation,"request_bytes":bytes,"response_present":response,"decoded":decoded.map(|r|json!({"request_id":r.request_id,"checkpoint":r.checkpoint,"previous_decision_id":r.previous_decision_id,"helper_checkpoint":r.helper_checkpoint}))})
|
||||
}).collect::<Vec<_>>()))
|
||||
}
|
||||
fn sample()->Result<Value>{
|
||||
let agent=db(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite")?;
|
||||
let helper=db(r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite")?;
|
||||
let meta=agent.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault":r.get::<_,Option<String>>(5)?})))?;
|
||||
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,agent_checkpoint,fault FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"agent_checkpoint":r.get::<_,u64>(3)?,"fault":r.get::<_,Option<String>>(4)?})))?;
|
||||
let mut stmt=helper.prepare("SELECT decision_id,checkpoint,length(response),length(request) FROM helper_sync_decisions ORDER BY rowid DESC LIMIT 2")?;
|
||||
let decisions=stmt.query_map([],|r|Ok(json!({"decision_id":r.get::<_,String>(0)?,"checkpoint":r.get::<_,u64>(1)?,"response_bytes":r.get::<_,u64>(2)?,"request_bytes":r.get::<_,u64>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
let mut stmt=agent.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
|
||||
let jobs=stmt.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
Ok(json!({"agent":meta,"requests":requests(&agent)?,"helper":helper_meta,"helper_decisions":decisions,"jobs":jobs}))
|
||||
}
|
||||
fn error(e:&anyhow::Error)->Value {
|
||||
for cause in e.chain(){if let Some(sql)=cause.downcast_ref::<rusqlite::Error>(){return match sql {rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),_=>json!({"code":"SQLITE_READ_FAILED"})};}}
|
||||
json!({"code":"READ_DIAGNOSTIC_FAILED"})
|
||||
}
|
||||
pub fn run()->Result<()> {
|
||||
ensure!(std::env::args().count()==1,"SYNC_DIAGNOSTIC_NO_ARGUMENTS");
|
||||
let mut token=std::ptr::null_mut();ensure!(unsafe{OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&mut token)}!=0,"SYNC_DIAGNOSTIC_TOKEN");
|
||||
let mut elevation=TOKEN_ELEVATION{TokenIsElevated:0};let mut size=0;
|
||||
let okay=unsafe{GetTokenInformation(token,TokenElevation,&mut elevation as *mut _ as *mut _,std::mem::size_of::<TOKEN_ELEVATION>() as u32,&mut size)};unsafe{CloseHandle(token)};
|
||||
ensure!(okay!=0&&elevation.TokenIsElevated!=0,"SYNC_DIAGNOSTIC_ADMIN");
|
||||
let mut samples=vec![];
|
||||
for _ in 0..3 {samples.push(sample().unwrap_or_else(|e|json!({"error":error(&e)})));std::thread::sleep(Duration::from_millis(100));}
|
||||
println!("{}",serde_json::to_string(&json!({"schema_version":1,"read_only":true,"utc":chrono::Utc::now(),"samples":samples}))?);Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]fn main(){if native::run().is_err(){eprintln!("SYNC_DIAGNOSTIC_FAILED");std::process::exit(1);}}
|
||||
#[cfg(not(windows))]fn main(){eprintln!("Windows only");std::process::exit(1);}
|
||||
@@ -0,0 +1,245 @@
|
||||
//! Administrative typed metadata only; no writes, effects, jobs, or readiness.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod sdk {
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_windows::{helper_ipc as ipc, helper_system, signed_clock, update_state};
|
||||
use rmm_domain::{
|
||||
agent_update::{ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile},
|
||||
agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy},
|
||||
jobs::hash,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::io::Read;
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)]
|
||||
enum Input {
|
||||
ReadMetadata {
|
||||
updater_sha256: Option<String>,
|
||||
},
|
||||
RenderPair {
|
||||
settings: Vec<u8>,
|
||||
agent_sha256: String,
|
||||
helper_sha256: String,
|
||||
},
|
||||
RenderUpdaterClock {
|
||||
pair_profile: Vec<u8>,
|
||||
updater_sha256: String,
|
||||
policy_sha256: String,
|
||||
service_configuration_sha256: String,
|
||||
qualification_sha256: String,
|
||||
},
|
||||
CanonicalRelease {
|
||||
manifest: ReleaseManifest,
|
||||
},
|
||||
CanonicalRecord {
|
||||
record: InstalledReleaseRecord,
|
||||
},
|
||||
CanonicalPolicy {
|
||||
policy: Box<LocalUpdatePolicy>,
|
||||
},
|
||||
ValidatePublicBundle {
|
||||
record: Vec<u8>,
|
||||
policy: Vec<u8>,
|
||||
keyring: Vec<u8>,
|
||||
health_pin: Vec<u8>,
|
||||
},
|
||||
ValidateRelease {
|
||||
envelope: ReleaseEnvelope,
|
||||
},
|
||||
}
|
||||
fn bytes(raw: Vec<u8>) -> serde_json::Value {
|
||||
serde_json::json!({"sha256":hash(&raw),"bytes":raw})
|
||||
}
|
||||
fn read_metadata(updater_sha256: Option<String>) -> Result<serde_json::Value> {
|
||||
use rmm_agent_core::helper_reconcile::BootSource;
|
||||
use rmm_agent_windows::update_native::{Budget, Role, files, services};
|
||||
let boot = helper_system::WindowsBoot::capture()?;
|
||||
let budget = Budget::new(
|
||||
&boot,
|
||||
boot.current_boot()?,
|
||||
std::time::Duration::from_secs(30),
|
||||
)?;
|
||||
let (settings, _held) = helper_system::read_settings()?;
|
||||
let mut running =
|
||||
services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?;
|
||||
let retained = update_state::RetainedSet::bootstrap_metadata()?;
|
||||
let mut observed = Vec::new();
|
||||
for role in [
|
||||
Role::Agent,
|
||||
Role::Helper,
|
||||
Role::Settings,
|
||||
Role::Pin,
|
||||
Role::TimeProfile,
|
||||
] {
|
||||
observed.push(serde_json::json!({"role":role,"proof":files::observe(role,&budget)?}));
|
||||
}
|
||||
let updater = if let Some(sha) = updater_sha256 {
|
||||
ensure!(ipc::digest(&sha), "BOOTSTRAP_UPDATER_IMAGE");
|
||||
let pin = ipc::PeerPin {
|
||||
service_name: rmm_agent_windows::update_ipc::SERVICE.into(),
|
||||
service_sid: ipc::service_sid(rmm_agent_windows::update_ipc::SERVICE)?,
|
||||
user_sid: "S-1-5-18".into(),
|
||||
binary: rmm_agent_windows::update_ipc::BINARY.into(),
|
||||
binary_sha256: sha,
|
||||
};
|
||||
let readers = [pin.service_sid.clone()];
|
||||
let mut image = ipc::PinnedFile::open(&pin.binary, false, &readers, &[], false)?;
|
||||
ensure!(
|
||||
image.sha256()? == pin.binary_sha256,
|
||||
"BOOTSTRAP_REGISTERED_UPDATER_IMAGE"
|
||||
);
|
||||
let definition = services::updater_bootstrap_definition(&pin)?;
|
||||
image.check()?;
|
||||
Some(
|
||||
serde_json::json!({"pin":pin,"configuration_sha256":hash(&serde_json::to_vec(&definition)?),"configuration":definition,"running_not_qualified":true}),
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
running.check(&budget)?;
|
||||
Ok(
|
||||
serde_json::json!({"schema_version":1,"read_only":true,"boot_id":boot.current_boot()?,
|
||||
"binding":settings.binding,"services":running.proofs(),"files":observed,"retained":retained,
|
||||
"reader_contract_sha256":hash(update_state::READER_CONTRACT),"updater":updater,
|
||||
"readiness_created":false,"target_mutated":false,"qualification_created":false}),
|
||||
)
|
||||
}
|
||||
fn run(input: Input) -> Result<serde_json::Value> {
|
||||
Ok(match input {
|
||||
Input::ReadMetadata { updater_sha256 } => read_metadata(updater_sha256)?,
|
||||
Input::RenderPair {
|
||||
settings,
|
||||
agent_sha256,
|
||||
helper_sha256,
|
||||
} => {
|
||||
ensure!(
|
||||
ipc::digest(&agent_sha256) && ipc::digest(&helper_sha256),
|
||||
"BOOTSTRAP_PAIR_DIGESTS"
|
||||
);
|
||||
let mut s: helper_system::Settings = serde_json::from_slice(&settings)?;
|
||||
s.validate()?;
|
||||
s.agent.binary_sha256 = agent_sha256;
|
||||
s.helper.binary_sha256 = helper_sha256;
|
||||
s.validate()?;
|
||||
let raw = serde_json::to_vec(&s)?;
|
||||
let pin = s.pin()?;
|
||||
ensure!(pin.policy_sha256 == hash(&raw), "BOOTSTRAP_CANONICAL_PAIR");
|
||||
serde_json::json!({"settings":bytes(raw),"pin":bytes(serde_json::to_vec(&pin)?),"shape_only":true})
|
||||
}
|
||||
Input::RenderUpdaterClock {
|
||||
pair_profile,
|
||||
updater_sha256,
|
||||
policy_sha256,
|
||||
service_configuration_sha256,
|
||||
qualification_sha256,
|
||||
} => {
|
||||
ensure!(
|
||||
[
|
||||
&updater_sha256,
|
||||
&policy_sha256,
|
||||
&service_configuration_sha256,
|
||||
&qualification_sha256
|
||||
]
|
||||
.iter()
|
||||
.all(|s| ipc::digest(s)),
|
||||
"BOOTSTRAP_UPDATER_CLOCK_DIGESTS"
|
||||
);
|
||||
let profile: signed_clock::Configuration = serde_json::from_slice(&pair_profile)?;
|
||||
let signed_clock::Configuration::TrustedOs(p) = profile else {
|
||||
anyhow::bail!("BOOTSTRAP_EXPLICIT_ACTIVE_GUEST_PROFILE_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
p.schema_version == 2
|
||||
&& p.trusted_os_active_guest.qualifications.len() == 2
|
||||
&& p.trusted_os_active_guest.qualifications[0].role
|
||||
== rmm_time_attestation::Role::Agent
|
||||
&& p.trusted_os_active_guest.qualifications[1].role
|
||||
== rmm_time_attestation::Role::SystemHelper,
|
||||
"BOOTSTRAP_ORIGINAL_PAIR_PROFILE"
|
||||
);
|
||||
let mut guest = p.trusted_os_active_guest;
|
||||
guest.qualifications = vec![signed_clock::RoleQualification {
|
||||
role: rmm_time_attestation::Role::Updater,
|
||||
binary_sha256: updater_sha256,
|
||||
qualification_sha256,
|
||||
}];
|
||||
let new = signed_clock::UpdaterConfiguration {
|
||||
schema_version: 3,
|
||||
key_generation: p.key_generation,
|
||||
server_instance: p.server_instance,
|
||||
binding: p.binding,
|
||||
public_keys_hex: p.public_keys_hex,
|
||||
updater_policy_sha256: policy_sha256,
|
||||
updater_service_configuration_sha256: service_configuration_sha256,
|
||||
trusted_os_active_guest: guest,
|
||||
};
|
||||
serde_json::json!({"profile":bytes(serde_json::to_vec(&new)?),"shape_only":true,"qualification_created":false})
|
||||
}
|
||||
Input::CanonicalRelease { manifest } => {
|
||||
ensure!(manifest.validate(), "BOOTSTRAP_RELEASE_SHAPE");
|
||||
bytes(serde_json::to_vec(&manifest)?)
|
||||
}
|
||||
Input::CanonicalRecord { record } => bytes(record.bytes().map_err(anyhow::Error::msg)?),
|
||||
Input::CanonicalPolicy { policy } => {
|
||||
ensure!(
|
||||
policy.validate() && policy.schema_version == 2,
|
||||
"BOOTSTRAP_WINDOWS_POLICY_SHAPE"
|
||||
);
|
||||
bytes(serde_json::to_vec(&policy)?)
|
||||
}
|
||||
Input::ValidateRelease { envelope } => {
|
||||
let decoded = envelope.decode().map_err(anyhow::Error::msg)?;
|
||||
serde_json::json!({"manifest":decoded.manifest,"manifest_sha256":hash(&decoded.payload_bytes),"shape_only_not_signature_verified":true})
|
||||
}
|
||||
Input::ValidatePublicBundle {
|
||||
record,
|
||||
policy,
|
||||
keyring,
|
||||
health_pin,
|
||||
} => {
|
||||
let installed =
|
||||
InstalledReleaseRecord::from_bytes(&record).map_err(anyhow::Error::msg)?;
|
||||
let (policy, policy_sha256) =
|
||||
LocalUpdatePolicy::from_bytes(&policy).map_err(anyhow::Error::msg)?;
|
||||
let keys: UpdateKeyringFile = serde_json::from_slice(&keyring)?;
|
||||
let health: HealthKeyPin = serde_json::from_slice(&health_pin)?;
|
||||
ensure!(
|
||||
keys.validate()
|
||||
&& health.validate()
|
||||
&& policy.schema_version == 2
|
||||
&& policy.initial_record_sha256 == hash(&record)
|
||||
&& policy.initial_activation_floor == installed.activation_floor,
|
||||
"BOOTSTRAP_WINDOWS_PUBLIC_BUNDLE_SHAPE"
|
||||
);
|
||||
serde_json::json!({"record_sha256":hash(&record),"policy_sha256":policy_sha256,"keyring_sha256":hash(&keyring),"health_pin_sha256":hash(&health_pin),"shape_only_not_signature_verified":true})
|
||||
}
|
||||
})
|
||||
}
|
||||
pub fn main() -> Result<()> {
|
||||
let mut raw = Vec::new();
|
||||
std::io::stdin()
|
||||
.take(512 * 1024 + 1)
|
||||
.read_to_end(&mut raw)?;
|
||||
ensure!(
|
||||
!raw.is_empty() && raw.len() <= 512 * 1024,
|
||||
"BOOTSTRAP_METADATA_FRAME_LIMIT"
|
||||
);
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&run(serde_json::from_slice(&raw)?)?)?
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
fn main() {
|
||||
if sdk::main().is_err() {
|
||||
eprintln!("WINDOWS_BOOTSTRAP_METADATA_FAILED");
|
||||
std::process::exit(1)
|
||||
}
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "system-helper")))]
|
||||
fn main() {
|
||||
eprintln!("Windows/system-helper required; no operation executed");
|
||||
std::process::exit(2)
|
||||
}
|
||||
Reference in New Issue
Block a user