From d395fd34641a110499c582e40e351dc71194e243 Mon Sep 17 00:00:00 2001 From: Phoebus Date: Mon, 21 Sep 2026 20:01:38 -0700 Subject: [PATCH] fix(installer): make GUI bridge approvals single-use and bounded Consume the approval before destructive work and refuse a second start_install from a retry, a second frontend or a reconnect. Bound request lines and secret values; reject deeply nested JSON. Add regression tests for replay, oversized input and nesting. --- .../phoebus-installer/src/gui_bridge.rs | 143 ++++++++++++++++-- 1 file changed, 134 insertions(+), 9 deletions(-) diff --git a/installer-rs/crates/phoebus-installer/src/gui_bridge.rs b/installer-rs/crates/phoebus-installer/src/gui_bridge.rs index 4edb69b..7de68e5 100644 --- a/installer-rs/crates/phoebus-installer/src/gui_bridge.rs +++ b/installer-rs/crates/phoebus-installer/src/gui_bridge.rs @@ -30,6 +30,11 @@ use serde_json::{json, Value}; pub const PROTOCOL_VERSION: u32 = 1; const MAX_LOG_TAIL: usize = 200; +/// Upper bound on one request line. The frontend sends small, typed requests; +/// anything larger is refused before parsing rather than buffered blindly. +const MAX_LINE_BYTES: usize = 256 * 1024; +/// Upper bound on a single secret value (passwords/passphrases/API keys). +const MAX_SECRET_BYTES: usize = 16 * 1024; // --------------------------------------------------------------------------- // Protocol types @@ -161,6 +166,11 @@ pub struct Bridge { api_key: Option, approved_digest: Option, phase: std::rc::Rc>, + /// One destructive transaction at a time. An approval is single-use: it is + /// consumed when the install starts so a replay, a second frontend or a + /// reconnected client cannot start a second overlapping installation. + installing: bool, + installed: bool, quit: bool, } @@ -175,6 +185,8 @@ impl Bridge { api_key: None, approved_digest: None, phase: std::rc::Rc::new(std::cell::Cell::new(DiskPhase::BeforeStorage)), + installing: false, + installed: false, quit: false, } } @@ -189,6 +201,8 @@ impl Bridge { api_key: None, approved_digest: None, phase: std::rc::Rc::new(std::cell::Cell::new(DiskPhase::BeforeStorage)), + installing: false, + installed: false, quit: false, } } @@ -204,6 +218,15 @@ impl Bridge { if line.is_empty() { return Ok(()); } + if line.len() > MAX_LINE_BYTES { + return write_json( + out, + &json!({ + "ok": false, + "error": format!("request too large ({} bytes)", line.len()), + }), + ); + } let request: Request = match serde_json::from_str(line) { Ok(request) => request, Err(e) => { @@ -399,6 +422,19 @@ impl Bridge { .secrets .as_ref() .ok_or_else(|| "set_secrets requires a `secrets` object".to_string())?; + for value in [ + &patch.luks, + &patch.user_password, + &patch.root_password, + &patch.ai_api_key, + ] + .into_iter() + .flatten() + { + if value.len() > MAX_SECRET_BYTES { + return Err("secret value is too large".into()); + } + } if let Some(v) = &patch.luks { let s = SecretString::new(v.clone()); self.installer.exec.register_secret(&s); @@ -497,6 +533,16 @@ impl Bridge { request: &Request, out: &mut dyn Write, ) -> Result { + if self.installing { + return Err("an installation is already in progress".into()); + } + if self.installed { + return Err( + "this session has already installed Phoebus; start a new session to \ + install again" + .into(), + ); + } // The plan may not have changed since the user approved it. let current = self.plan_digest(); match (&self.approved_digest, &request.plan_digest) { @@ -553,6 +599,10 @@ impl Bridge { phase: self.phase.clone(), }; self.phase.set(DiskPhase::BeforeStorage); + // Consume the approval and mark the session busy before any destructive + // work: a replay or a second frontend can never reach storage_prepare. + self.approved_digest = None; + self.installing = true; let outcome = self.installer.install_observed( &auth, self.luks.as_ref(), @@ -560,17 +610,21 @@ impl Bridge { self.root_password.as_ref(), &mut observer, ); + self.installing = false; match outcome { - Ok(()) => Ok(json!({ - "complete": true, - "dry_run": dry_run, - "log_path": self.installer.exec.log_path().display().to_string(), - "next_actions": [ - "Remove the installation medium.", - "Restart the computer and boot Phoebus OS.", - ], - })), + Ok(()) => { + self.installed = true; + Ok(json!({ + "complete": true, + "dry_run": dry_run, + "log_path": self.installer.exec.log_path().display().to_string(), + "next_actions": [ + "Remove the installation medium.", + "Restart the computer and boot Phoebus OS.", + ], + })) + } Err(e) => { let message = self.installer.exec.redactor().redact(&e.to_string()); let (disk_changed, next_actions) = disk_change_report(self.phase.get()); @@ -1150,4 +1204,75 @@ mod tests { assert_eq!(response(&lines)["data"]["bye"], json!(true)); assert!(bridge.should_quit()); } + + #[test] + fn start_install_cannot_be_replayed_after_success() { + let mut bridge = test_bridge(); + set_valid_config(&mut bridge); + let (digest, _) = approve(&mut bridge); + let first = call( + &mut bridge, + &json!({ + "id": 20, "op": "start_install", "erase": "ERASE", + "final_confirm": true, "plan_digest": digest + }) + .to_string(), + ); + assert_eq!(response(&first)["ok"], json!(true)); + assert!(bridge.installed); + + // A second frontend (or a retry) re-approves and tries again: refused. + let (digest2, _) = approve(&mut bridge); + let second = call( + &mut bridge, + &json!({ + "id": 21, "op": "start_install", "erase": "ERASE", + "final_confirm": true, "plan_digest": digest2 + }) + .to_string(), + ); + assert_eq!(response(&second)["ok"], json!(false)); + assert!( + response(&second)["error"] + .as_str() + .unwrap() + .contains("already installed"), + "unexpected error: {}", + response(&second)["error"] + ); + } + + #[test] + fn oversized_request_line_is_refused() { + let mut bridge = test_bridge(); + let huge = format!( + r#"{{"id":1,"op":"handshake","pad":"{}"}}"#, + "x".repeat(MAX_LINE_BYTES) + ); + let lines = call(&mut bridge, &huge); + let resp = response(&lines); + assert_eq!(resp["ok"], json!(false)); + assert!(resp["error"].as_str().unwrap().contains("too large")); + } + + #[test] + fn oversized_secret_is_refused() { + let mut bridge = test_bridge(); + let secret = "x".repeat(MAX_SECRET_BYTES + 1); + let lines = call( + &mut bridge, + &json!({ "id": 22, "op": "set_secrets", "secrets": { "luks": secret } }).to_string(), + ); + assert_eq!(response(&lines)["ok"], json!(false)); + } + + #[test] + fn deeply_nested_json_is_rejected_without_panicking() { + let mut bridge = test_bridge(); + let depth = 300; + let nested = format!("{}{}{}", "[".repeat(depth), "0", "]".repeat(depth)); + let line = format!(r#"{{"id":23,"op":"handshake","config":{nested}}}"#); + let lines = call(&mut bridge, &line); + assert_eq!(response(&lines)["ok"], json!(false)); + } }