Freeze minimal SYSTEM nonstart 221 closure and reproducible Windows source
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -386,6 +386,7 @@ mod probe {
|
||||
role: Role::Agent,
|
||||
helper_image_sha256: None,
|
||||
binding_schema: 1,
|
||||
updater_image_sha256: None,
|
||||
},
|
||||
};
|
||||
if kind == "tenant-mismatch" {
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
//! Offline, deny-only typed transition from the existing 30s script policy to
|
||||
//! passive new pair pins. No files, IPC, services, sync, jobs or approvals.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
fn main() -> anyhow::Result<()> {
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_windows::helper_system::Settings;
|
||||
use rmm_domain::jobs::{PrivilegedScriptProfile, hash};
|
||||
use serde::Deserialize;
|
||||
use std::io::{Read, Write};
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Input {
|
||||
schema_version: u32,
|
||||
current_settings: Vec<u8>,
|
||||
current_settings_sha256: String,
|
||||
new_agent_sha256: String,
|
||||
new_helper_sha256: String,
|
||||
}
|
||||
fn render(input: Input) -> Result<serde_json::Value> {
|
||||
ensure!(
|
||||
input.schema_version == 1
|
||||
&& !input.current_settings.is_empty()
|
||||
&& input.current_settings.len() <= 32768
|
||||
&& hash(&input.current_settings) == input.current_settings_sha256
|
||||
&& rmm_domain::agent_update::digest(&input.new_agent_sha256)
|
||||
&& rmm_domain::agent_update::digest(&input.new_helper_sha256),
|
||||
"SCRIPT_PAIR_PREPARE_INPUT"
|
||||
);
|
||||
let mut settings: Settings = serde_json::from_slice(&input.current_settings)?;
|
||||
settings.validate()?;
|
||||
ensure!(
|
||||
settings.schema_version == 3
|
||||
&& settings.enable_effects
|
||||
&& settings.max_runtime_seconds == 30
|
||||
&& !settings.allow_reboot
|
||||
&& settings.allowed_services.is_empty()
|
||||
&& settings.allowed_msi_recipe_sha256.is_none()
|
||||
&& settings.allowed_script_profiles.as_deref()
|
||||
== Some(&[PrivilegedScriptProfile::FullMaintenanceV1])
|
||||
&& settings.agent.binary_sha256 != input.new_agent_sha256
|
||||
&& settings.helper.binary_sha256 != input.new_helper_sha256,
|
||||
"SCRIPT_PAIR_EXACT_ORIGINAL_30S_SCOPE_REQUIRED"
|
||||
);
|
||||
settings.agent.binary_sha256 = input.new_agent_sha256;
|
||||
settings.helper.binary_sha256 = input.new_helper_sha256;
|
||||
settings.enable_effects = false;
|
||||
settings.allowed_script_profiles = None;
|
||||
settings.validate()?;
|
||||
let settings_bytes = serde_json::to_vec(&settings)?;
|
||||
let pin = settings.pin()?;
|
||||
let pin_bytes = serde_json::to_vec(&pin)?;
|
||||
ensure!(
|
||||
pin.policy_sha256 == hash(&settings_bytes),
|
||||
"SCRIPT_PAIR_CANONICAL_POLICY"
|
||||
);
|
||||
Ok(
|
||||
serde_json::json!({"schema_version":1,"source":"actual_rust_settings_codec",
|
||||
"prepared_only":true,"target_mutations":false,"target_job_executed":false,
|
||||
"effects_enabled":false,"settings_bytes":settings_bytes,"settings_sha256":hash(&settings_bytes),
|
||||
"pin_bytes":pin_bytes,"pin_sha256":hash(&pin_bytes),"policy_sha256":pin.policy_sha256,
|
||||
"helper_settings_source_sha256":hash(include_bytes!("../src/helper_system.rs")),
|
||||
"peer_codec_source_sha256":hash(include_bytes!("../src/helper_ipc.rs"))}),
|
||||
)
|
||||
}
|
||||
let mut input = Vec::new();
|
||||
std::io::stdin()
|
||||
.take(128 * 1024 + 1)
|
||||
.read_to_end(&mut input)?;
|
||||
ensure!(input.len() <= 128 * 1024, "SCRIPT_PAIR_PREPARE_FRAME_LIMIT");
|
||||
let output = render(serde_json::from_slice(&input)?)?;
|
||||
std::io::stdout().write_all(&serde_json::to_vec(&output)?)?;
|
||||
std::io::stdout().write_all(b"\n")?;
|
||||
Ok(())
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "system-helper")))]
|
||||
fn main() {
|
||||
eprintln!("Windows/system-helper typed renderer only; no operation executed");
|
||||
std::process::exit(2);
|
||||
}
|
||||
@@ -0,0 +1,587 @@
|
||||
//! Explicit G205 bootstrap operator. No service stop/start, job, enrollment,
|
||||
//! configuration rewrite, clock bootstrap or normal HelperSync::apply.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod platform {
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use fs2::FileExt;
|
||||
use rmm_agent_core::{
|
||||
auth::Binding,
|
||||
windows_system_nonstart::{self as recovery, ClosedPairGuard, Local},
|
||||
};
|
||||
use rmm_agent_windows::{
|
||||
SERVICE_NAME,
|
||||
helper_ipc::{self as ipc, PinnedFile},
|
||||
helper_runtime::intent,
|
||||
helper_system, native,
|
||||
};
|
||||
use rmm_domain::{
|
||||
jobs::hash,
|
||||
windows_system_nonstart::{BOOT, FILE_ROLES, NativeFile, NonstartProof},
|
||||
};
|
||||
use rusqlite::{Connection, OpenFlags};
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
fs::{File, OpenOptions},
|
||||
io::{Read, Seek, SeekFrom},
|
||||
os::windows::{fs::OpenOptionsExt, io::AsRawHandle},
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
use windows_sys::Win32::{Security::*, Storage::FileSystem::*, System::Services::*};
|
||||
static PHASE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn phase(value: usize) {
|
||||
PHASE.store(value, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
pub fn diagnostic(error: &anyhow::Error) -> serde_json::Value {
|
||||
let phases = [
|
||||
"arguments",
|
||||
"admin_and_stopped",
|
||||
"public_binding",
|
||||
"helper_settings",
|
||||
"lifetime_locks",
|
||||
"intent_acl",
|
||||
"held_file_ids",
|
||||
"boot_measurement",
|
||||
"intent_empty_snapshot",
|
||||
"journal_open",
|
||||
"original_identity_rows",
|
||||
"witness_or_apply",
|
||||
];
|
||||
let codes = error
|
||||
.chain()
|
||||
.filter_map(|cause| {
|
||||
let text = cause.to_string();
|
||||
(text.len() <= 96
|
||||
&& !text.is_empty()
|
||||
&& text
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_'))
|
||||
.then_some(text)
|
||||
})
|
||||
.take(8)
|
||||
.collect::<Vec<_>>();
|
||||
let mut data = serde_json::json!({"schema_version":1,"diagnostic_only":true,"phase":phases.get(PHASE.load(std::sync::atomic::Ordering::Relaxed)).unwrap_or(&"unknown"),"codes":codes});
|
||||
for cause in error.chain() {
|
||||
if let Some(sql) = cause.downcast_ref::<rusqlite::Error>() {
|
||||
data["sqlite"] = match sql {
|
||||
rusqlite::Error::SqliteFailure(code, _) => {
|
||||
serde_json::json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code})
|
||||
}
|
||||
rusqlite::Error::QueryReturnedNoRows => {
|
||||
serde_json::json!({"code":"SQLITE_NO_ROWS"})
|
||||
}
|
||||
rusqlite::Error::InvalidColumnType(index, name, _) => {
|
||||
serde_json::json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":if name.len()<=48&&name.bytes().all(|b|b.is_ascii_alphanumeric()||b==b'_'){name.as_str()}else{"redacted"}})
|
||||
}
|
||||
_ => serde_json::json!({"code":"SQLITE_READ_FAILED"}),
|
||||
};
|
||||
break;
|
||||
}
|
||||
if let Some(codec) = cause.downcast_ref::<serde_json::Error>() {
|
||||
data["codec"] = serde_json::json!({"code":"JSON_CODEC","line":codec.line(),"column":codec.column()});
|
||||
}
|
||||
if let Some(io) = cause.downcast_ref::<std::io::Error>() {
|
||||
data["io"] = serde_json::json!({"kind":format!("{:?}",io.kind()),"os_code":io.raw_os_error()});
|
||||
}
|
||||
}
|
||||
data
|
||||
}
|
||||
const ROOT: &str = r"C:\ProgramData\RustDiscovery";
|
||||
const STATE: &str = r"C:\ProgramData\RustDiscovery\state";
|
||||
const PATHS: [&str; 6] = [
|
||||
r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite",
|
||||
r"C:\ProgramData\RustDiscovery\state\consumption.sqlite",
|
||||
r"C:\ProgramData\RustDiscovery\state\agent.lock",
|
||||
r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite",
|
||||
r"C:\ProgramData\RustDiscoverySystem\state\executor.lock",
|
||||
intent::DB,
|
||||
];
|
||||
struct Sc(SC_HANDLE);
|
||||
impl Drop for Sc {
|
||||
fn drop(&mut self) {
|
||||
unsafe { CloseServiceHandle(self.0) };
|
||||
}
|
||||
}
|
||||
fn stopped(name: &str) -> Result<()> {
|
||||
let manager =
|
||||
Sc(unsafe { OpenSCManagerW(std::ptr::null(), std::ptr::null(), SC_MANAGER_CONNECT) });
|
||||
ensure!(!manager.0.is_null(), "ALIGN_SCM_MANAGER");
|
||||
let wide = name.encode_utf16().chain(Some(0)).collect::<Vec<_>>();
|
||||
let service = Sc(unsafe { OpenServiceW(manager.0, wide.as_ptr(), SERVICE_QUERY_STATUS) });
|
||||
ensure!(!service.0.is_null(), "ALIGN_SCM_SERVICE");
|
||||
let mut status: SERVICE_STATUS_PROCESS = unsafe { std::mem::zeroed() };
|
||||
let mut size = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
QueryServiceStatusEx(
|
||||
service.0,
|
||||
SC_STATUS_PROCESS_INFO,
|
||||
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
|
||||
std::mem::size_of::<SERVICE_STATUS_PROCESS>() as u32,
|
||||
&mut size,
|
||||
)
|
||||
} != 0
|
||||
&& status.dwCurrentState == SERVICE_STOPPED,
|
||||
"ALIGN_BOTH_SERVICES_MUST_BE_STOPPED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn both() -> Result<()> {
|
||||
stopped(SERVICE_NAME)?;
|
||||
stopped(ipc::HELPER_SERVICE)
|
||||
}
|
||||
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,
|
||||
std::ptr::null_mut(),
|
||||
sid.as_mut_ptr().cast(),
|
||||
&mut len,
|
||||
)
|
||||
} != 0
|
||||
&& unsafe {
|
||||
CheckTokenMembership(std::ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member)
|
||||
} != 0
|
||||
&& member != 0,
|
||||
"ALIGN_ADMINISTRATOR_REQUIRED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn leaf(path: &Path) -> Result<File> {
|
||||
for parent in path.ancestors() {
|
||||
ensure!(
|
||||
std::os::windows::fs::MetadataExt::file_attributes(&parent.symlink_metadata()?)
|
||||
& FILE_ATTRIBUTE_REPARSE_POINT
|
||||
== 0,
|
||||
"ALIGN_NO_REPARSE"
|
||||
);
|
||||
}
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
|
||||
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
||||
.open(path)?;
|
||||
native_id(&file)?;
|
||||
Ok(file)
|
||||
}
|
||||
fn native_id(file: &File) -> Result<[u32; 3]> {
|
||||
let mut i: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
|
||||
ensure!(
|
||||
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut i) } != 0
|
||||
&& i.nNumberOfLinks == 1
|
||||
&& i.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)
|
||||
== 0,
|
||||
"ALIGN_FILE_ID"
|
||||
);
|
||||
Ok([i.dwVolumeSerialNumber, i.nFileIndexHigh, i.nFileIndexLow])
|
||||
}
|
||||
fn bytes(mut file: &File, max: u64) -> Result<Vec<u8>> {
|
||||
ensure!(file.metadata()?.len() <= max, "ALIGN_FILE_LIMIT");
|
||||
file.seek(SeekFrom::Start(0))?;
|
||||
let mut data = vec![];
|
||||
file.take(max + 1).read_to_end(&mut data)?;
|
||||
ensure!(data.len() as u64 <= max, "ALIGN_FILE_CHANGED");
|
||||
Ok(data)
|
||||
}
|
||||
struct Held {
|
||||
path: PathBuf,
|
||||
file: File,
|
||||
id: ipc::FileIdentity,
|
||||
legacy: [u32; 3],
|
||||
}
|
||||
struct Guard {
|
||||
held: Vec<Held>,
|
||||
_locks: Vec<File>,
|
||||
_settings: RefCell<Vec<PinnedFile>>,
|
||||
_public: RefCell<Vec<PinnedFile>>,
|
||||
boot: Uuid,
|
||||
intents: RefCell<intent::Store>,
|
||||
}
|
||||
impl ClosedPairGuard for Guard {
|
||||
fn check(&self) -> Result<()> {
|
||||
both()?;
|
||||
self.intents.borrow_mut().check()?;
|
||||
for file in self
|
||||
._settings
|
||||
.borrow_mut()
|
||||
.iter_mut()
|
||||
.chain(self._public.borrow_mut().iter_mut())
|
||||
{
|
||||
file.check()?;
|
||||
}
|
||||
ensure!(
|
||||
ipc::file_identity(&self._locks[0])? == self.held[2].id
|
||||
&& ipc::file_identity(&self._locks[1])? == self.held[4].id,
|
||||
"ALIGN_ORIGINAL_LOCK_OWNER_HANDLES"
|
||||
);
|
||||
for h in &self.held {
|
||||
ensure!(
|
||||
ipc::file_identity(&h.file)? == h.id
|
||||
&& native_id(&h.file)? == h.legacy
|
||||
&& ipc::file_identity(&leaf(&h.path)?)? == h.id,
|
||||
"ALIGN_ORIGINAL_FILE_REPLACED"
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn files(&self) -> Result<[NativeFile; 6]> {
|
||||
self.check()?;
|
||||
let mut out = vec![];
|
||||
for (index, (h, role)) in self.held.iter().zip(FILE_ROLES).enumerate() {
|
||||
// Read a lifetime lock ONLY through the original HANDLE that
|
||||
// owns its LockFileEx range; a second handle is correctly denied.
|
||||
let f = match index {
|
||||
2 => &self._locks[0],
|
||||
4 => &self._locks[1],
|
||||
_ => &h.file,
|
||||
};
|
||||
out.push(NativeFile {
|
||||
role: role.into(),
|
||||
file_id: Some(h.legacy),
|
||||
sha256: Some(hash(&bytes(f, 256 * 1024 * 1024).context(match index {
|
||||
0 => "ALIGN_HASH_TELEMETRY",
|
||||
1 => "ALIGN_HASH_CONSUMPTION",
|
||||
2 => "ALIGN_HASH_AGENT_LOCK",
|
||||
3 => "ALIGN_HASH_HELPER_LEDGER",
|
||||
4 => "ALIGN_HASH_HELPER_LOCK",
|
||||
_ => "ALIGN_HASH_SYSTEM_INTENTS",
|
||||
})?)),
|
||||
});
|
||||
}
|
||||
out.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("ALIGN_FILE_COUNT"))
|
||||
}
|
||||
fn boot(&self) -> Result<Uuid> {
|
||||
Ok(self.boot)
|
||||
}
|
||||
}
|
||||
struct Db {
|
||||
db: Connection,
|
||||
_held: Vec<File>,
|
||||
}
|
||||
impl Db {
|
||||
fn open(path: &str, write: bool) -> Result<Self> {
|
||||
let mut file = leaf(Path::new(path))?;
|
||||
let mut header = [0; 20];
|
||||
file.read_exact(&mut header)?;
|
||||
ensure!(
|
||||
header.starts_with(b"SQLite format 3\0")
|
||||
&& header[18] == header[19]
|
||||
&& matches!(header[18], 1 | 2),
|
||||
"ALIGN_SQLITE_HEADER"
|
||||
);
|
||||
let mut held = vec![file];
|
||||
let mut wal = false;
|
||||
let mut shm = false;
|
||||
let mut journal = false;
|
||||
for (suffix, present) in [
|
||||
("-wal", &mut wal),
|
||||
("-shm", &mut shm),
|
||||
("-journal", &mut journal),
|
||||
] {
|
||||
let p = format!("{path}{suffix}");
|
||||
if Path::new(&p).try_exists()? {
|
||||
held.push(leaf(Path::new(&p))?);
|
||||
*present = true;
|
||||
}
|
||||
}
|
||||
let flags = if write {
|
||||
OpenFlags::SQLITE_OPEN_READ_WRITE
|
||||
} else {
|
||||
OpenFlags::SQLITE_OPEN_READ_ONLY
|
||||
};
|
||||
let db = if !write && header[18] == 2 && !(wal && shm) {
|
||||
ensure!(!wal && !shm && !journal, "ALIGN_ORIGINAL_WAL_INCOMPLETE");
|
||||
Connection::open_with_flags(
|
||||
format!("file:///{}?mode=ro&immutable=1", path.replace('\\', "/")),
|
||||
flags | OpenFlags::SQLITE_OPEN_URI,
|
||||
)?
|
||||
} else {
|
||||
Connection::open_with_flags(path, flags)?
|
||||
};
|
||||
db.busy_timeout(std::time::Duration::from_millis(500))?;
|
||||
Ok(Self { db, _held: held })
|
||||
}
|
||||
}
|
||||
pub fn run() -> Result<()> {
|
||||
let args = std::env::args().skip(1).collect::<Vec<_>>();
|
||||
if args == ["--receipt-contract"] {
|
||||
let file = PinnedFile::open(
|
||||
Path::new(
|
||||
r"C:\ProgramData\RustDiscoveryBootstrap\system-nonstart-221-receipt.json",
|
||||
),
|
||||
false,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let event=PinnedFile::open(Path::new(r"C:\ProgramData\RustDiscoveryBootstrap\6907fdbbcd1c287c2545fde2f9ebae54fd3b6629b10b61dc5d3884584d8c74c9\placeholder-envelope.pb"),false,&[],&[],false)?;
|
||||
println!("{}",serde_json::to_string(&recovery::receipt_contract(&bytes(&file.file,4*1024*1024)?,&bytes(&event.file,16384)?)?)?);
|
||||
return Ok(());
|
||||
}
|
||||
let apply = args == ["--apply"];
|
||||
let verify = args == ["--verify-applied"];
|
||||
ensure!(
|
||||
apply || verify || args == ["--witness"],
|
||||
"ALIGN_FIXED_ARGUMENTS"
|
||||
);
|
||||
phase(1);
|
||||
admin()?;
|
||||
both()?;
|
||||
phase(2);
|
||||
let readers = [ipc::service_sid(SERVICE_NAME)?];
|
||||
let mut public = vec![PinnedFile::open(
|
||||
Path::new(ROOT),
|
||||
true,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?];
|
||||
let binding_file = PinnedFile::open(
|
||||
&Path::new(ROOT).join("binding.json"),
|
||||
false,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let binding: Binding = serde_json::from_slice(&bytes(&binding_file.file, 8192)?)?;
|
||||
public.push(binding_file);
|
||||
phase(3);
|
||||
let (settings, pins) = helper_system::read_settings()?;
|
||||
ensure!(
|
||||
settings.enable_effects
|
||||
&& !settings.allow_reboot
|
||||
&& settings.schema_version == 3
|
||||
&& settings.pin()?.policy_sha256
|
||||
== "cfd126d383ec0a948a73270a8362bd835d79341a079be05ce50088f0dbc5791c",
|
||||
"ALIGN_ORIGINAL_PASSIVE_HELPER_ONLY"
|
||||
);
|
||||
phase(4);
|
||||
let mut locks = vec![];
|
||||
for index in [2, 4] {
|
||||
let file = leaf(Path::new(PATHS[index]))?;
|
||||
file.try_lock_exclusive()
|
||||
.context("ALIGN_ORIGINAL_LIFETIME_LOCK_BUSY")?;
|
||||
locks.push(file);
|
||||
}
|
||||
both()?;
|
||||
native::private_path(Path::new(STATE), true)?;
|
||||
phase(5);
|
||||
let helper_writer = [ipc::service_sid(ipc::HELPER_SERVICE)?];
|
||||
let agent_writer = [ipc::service_sid(SERVICE_NAME)?];
|
||||
public.push(PinnedFile::open_read_shared(
|
||||
Path::new(intent::ROOT),
|
||||
true,
|
||||
&agent_writer,
|
||||
&[],
|
||||
)?);
|
||||
for path in [intent::DB, &format!("{}-journal", intent::DB)] {
|
||||
let proof = PinnedFile::open_read_shared(Path::new(path), false, &[], &agent_writer)?;
|
||||
public.push(proof);
|
||||
}
|
||||
phase(6);
|
||||
let mut held = vec![];
|
||||
for (index, path) in PATHS.into_iter().enumerate() {
|
||||
if matches!(index, 3 | 4) {
|
||||
let _check =
|
||||
PinnedFile::open_read_shared(Path::new(path), false, &[], &helper_writer)?;
|
||||
} else if index != 5 {
|
||||
native::private_path(Path::new(path), false)?;
|
||||
}
|
||||
let file = leaf(Path::new(path))?;
|
||||
held.push(Held {
|
||||
path: PathBuf::from(path),
|
||||
id: ipc::file_identity(&file)?,
|
||||
legacy: native_id(&file)?,
|
||||
file,
|
||||
});
|
||||
}
|
||||
phase(7);
|
||||
let boot = Uuid::parse_str(
|
||||
&tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()?
|
||||
.block_on(native::boot_id())?,
|
||||
)?;
|
||||
ensure!(boot == BOOT, "ALIGN_ORIGINAL_BOOT_REQUIRED");
|
||||
phase(8);
|
||||
let guard = Guard {
|
||||
held,
|
||||
_locks: locks,
|
||||
_settings: RefCell::new(pins),
|
||||
_public: RefCell::new(public),
|
||||
boot,
|
||||
intents: RefCell::new(intent::Store::open(false)?),
|
||||
};
|
||||
guard.check()?;
|
||||
phase(9);
|
||||
let a = Db::open(PATHS[0], apply).context("ALIGN_OPEN_TELEMETRY_RO")?;
|
||||
let c = Db::open(PATHS[1], apply).context("ALIGN_OPEN_CONSUMPTION_RO")?;
|
||||
let h = Db::open(PATHS[3], apply).context("ALIGN_OPEN_HELPER_JOURNAL")?;
|
||||
let intents = Db::open(PATHS[5], false).context("ALIGN_OPEN_INTENTS_RO")?;
|
||||
phase(10);
|
||||
let intents_identity: Vec<u8> = intents.db.query_row(
|
||||
"SELECT file_identity FROM system_intent_meta WHERE id=1",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(
|
||||
serde_json::from_slice::<ipc::FileIdentity>(&intents_identity)? == guard.held[5].id,
|
||||
"ALIGN_ORIGINAL_INTENT_JOURNAL_IDENTITY"
|
||||
);
|
||||
let (ledger, lock, identity): (Vec<u8>, Vec<u8>, String) = h.db.query_row(
|
||||
"SELECT ledger,executor_lock,binding_sha256 FROM windows_helper_files WHERE id=1",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
serde_json::from_slice::<ipc::FileIdentity>(&ledger)? == guard.held[3].id
|
||||
&& serde_json::from_slice::<ipc::FileIdentity>(&lock)? == guard.held[4].id
|
||||
&& identity == ipc::binding_hash(&settings.binding)?,
|
||||
"ALIGN_HELPER_ORIGINAL_LEDGER_LOCK_IDENTITY"
|
||||
);
|
||||
phase(11);
|
||||
|
||||
let live_file = PinnedFile::open(
|
||||
Path::new(
|
||||
r"C:\ProgramData\RustDiscoveryBootstrap\1f18d4273d5d19bdc9d8b3bfe4ed49c7aaa0b7cc282c9a04024896f8db274b85\native-live-archive.json",
|
||||
),
|
||||
false,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let live_raw = bytes(&live_file.file, 1024 * 1024)?;
|
||||
ensure!(
|
||||
hash(&live_raw) == "1f18d4273d5d19bdc9d8b3bfe4ed49c7aaa0b7cc282c9a04024896f8db274b85",
|
||||
"NONSTART_EXACT_LIVE_ARCHIVE"
|
||||
);
|
||||
let archived: serde_json::Value = serde_json::from_slice(&live_raw)?;
|
||||
let live = &archived["live_archive"];
|
||||
let stop_file = PinnedFile::open(
|
||||
Path::new(
|
||||
r"C:\ProgramData\RustDiscoveryBootstrap\system-nonstart-221-stop\stopped.json",
|
||||
),
|
||||
false,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let stop_raw = bytes(&stop_file.file, 32768)?;
|
||||
let stop: serde_json::Value = serde_json::from_slice(&stop_raw)?;
|
||||
ensure!(
|
||||
stop["both_stopped"] == true
|
||||
&& stop["force_used"] == false
|
||||
&& stop["original_held_process_exits_verified"] == true
|
||||
&& stop["journal_rows_changed_by_bootstrap"] == false
|
||||
&& stop["target_job_executed"] == false
|
||||
&& stop["live_archive_sha256"] == hash(&live_raw),
|
||||
"NONSTART_ORIGINAL_HELD_EXIT_PROOF"
|
||||
);
|
||||
ensure!(
|
||||
stop["original_services"]["RmmDiscoverySystemHelper"]["pid"] == 1304
|
||||
&& stop["original_services"]["RmmDiscoverySystemHelper"]["birth"]
|
||||
== "134393135436289391"
|
||||
&& stop["original_services"]["RmmDiscoveryWindows"]["pid"] == 8688
|
||||
&& stop["original_services"]["RmmDiscoveryWindows"]["birth"]
|
||||
== "134393135446375865",
|
||||
"NONSTART_ORIGINAL_LIFETIMES"
|
||||
);
|
||||
let nonstart = NonstartProof {
|
||||
helper_pid: 1304,
|
||||
helper_birth_filetime: live["helper_birth_filetime"]
|
||||
.as_str()
|
||||
.context("NONSTART_BIRTH")?
|
||||
.into(),
|
||||
helper_image_sha256: live["helper_image_sha256"]
|
||||
.as_str()
|
||||
.context("NONSTART_IMAGE")?
|
||||
.into(),
|
||||
system_script_source_sha256: live["system_script_source_sha256"]
|
||||
.as_str()
|
||||
.context("NONSTART_SOURCE")?
|
||||
.into(),
|
||||
read_share_error: serde_json::from_value(live["read_share_error"].clone())?,
|
||||
read_write_share_passed: live["read_write_share_passed"] == true,
|
||||
state_directory_file_id: serde_json::from_value(
|
||||
live["state_directory_file_id"].clone(),
|
||||
)?,
|
||||
evidence_sha256: vec![hash(&live_raw), hash(&stop_raw)],
|
||||
};
|
||||
ensure!(
|
||||
nonstart.valid() && live["original_peer_verified_before_after"] == true,
|
||||
"NONSTART_ORIGINAL_LIVE_PROOF"
|
||||
);
|
||||
let local = Local {
|
||||
agent: &a.db,
|
||||
consumption: &c.db,
|
||||
helper: &h.db,
|
||||
intents: &intents.db,
|
||||
binding: &binding,
|
||||
helper_binding: &settings.binding,
|
||||
};
|
||||
if apply || verify {
|
||||
let file = PinnedFile::open(
|
||||
Path::new(
|
||||
r"C:\ProgramData\RustDiscoveryBootstrap\system-nonstart-221-receipt.json",
|
||||
),
|
||||
false,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let raw = bytes(&file.file, 4 * 1024 * 1024)?;
|
||||
if apply {
|
||||
recovery::apply(&local, &guard, &raw, chrono::Utc::now())?;
|
||||
}
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&recovery::verify_applied(&local, &guard, &raw)?)?
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
let witness = recovery::witness(&local, &guard, nonstart)?;
|
||||
for (name, raw) in [
|
||||
("target_job_offer", &witness.target_job_offer),
|
||||
("agent_start", &witness.agent_start),
|
||||
("helper_start", &witness.helper_start),
|
||||
("agent_outcome", &witness.agent_outcome),
|
||||
("helper_outcome", &witness.helper_outcome),
|
||||
("intent", &witness.intent),
|
||||
] {
|
||||
ensure!(
|
||||
serde_json::from_value::<Vec<u8>>(live[name].clone())? == *raw,
|
||||
"NONSTART_LIVE_ARCHIVE_ORIGINAL_CHANGED"
|
||||
);
|
||||
}
|
||||
for index in 0..2 {
|
||||
ensure!(
|
||||
serde_json::from_value::<Vec<u8>>(live["original_requests"][index].clone())?
|
||||
== witness.original_requests[index]
|
||||
&& serde_json::from_value::<rmm_domain::checkpoint_repair::SignedDecision>(
|
||||
live["original_responses"][index].clone()
|
||||
)? == witness.original_responses[index],
|
||||
"NONSTART_LIVE_ORIGINAL_SYNCS_CHANGED"
|
||||
);
|
||||
}
|
||||
guard.check()?;
|
||||
println!("{}", serde_json::to_string(&witness)?);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
fn main() {
|
||||
if let Err(error) = platform::run() {
|
||||
eprintln!("{}", platform::diagnostic(&error));
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "system-helper")))]
|
||||
fn main() {
|
||||
eprintln!("Windows system-helper only");
|
||||
std::process::exit(1);
|
||||
}
|
||||
Reference in New Issue
Block a user