Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
fix(cua-driver): allow reinstalling the trusted extension catalog after removal (#4212)
Francesco Bonacci0263cfebab9e
diff --git a/libs/cua-driver/rust/crates/cua-driver/src/extension_manager.rs b/libs/cua-driver/rust/crates/cua-driver/src/extension_manager.rsindex fe5659dcb2..398e85753d 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/extension_manager.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/extension_manager.rs@@ -44,6 +44,14 @@ const ACTIVE_NEW_NAME: &str = "active.new.json";const TRUST_NAME: &str = ".publisher-trust.json";const TRUST_NEW_NAME: &str = ".publisher-trust.new.json";const TRUST_BACKUP_NAME: &str = ".publisher-trust.backup.json";+// The accepted-catalog ledger lives beside, not inside, the publisher trust+// file so that trust files and install-record trust snapshots keep the exact+// schema that earlier drivers parse with `deny_unknown_fields`.+const CATALOG_LEDGER_NAME: &str = ".publisher-catalogs.json";+const CATALOG_LEDGER_NEW_NAME: &str = ".publisher-catalogs.new.json";+const CATALOG_LEDGER_BACKUP_NAME: &str = ".publisher-catalogs.backup.json";+const CATALOG_LEDGER_SCHEMA_VERSION: u32 = 1;+const MAX_CATALOG_LEDGER_ENTRIES: usize = 64;const MANIFEST_SCHEMA_VERSION: u32 = 1;const CATALOG_SCHEMA_VERSION: u32 = 1;// The initial lifecycle targets one executable plus a moderate model bundle.@@ -246,6 +254,32 @@ struct PublisherTrust {pending_key: Option<PublisherKey>,}+/// Signed catalog payloads accepted at the publisher's highest trusted+/// catalog version, one per `(extension_id, target)`.+///+/// Anti-rollback refuses every catalog older than the trusted version. A+/// catalog at exactly the trusted version is accepted only when this ledger+/// is bound to that version and either records the byte-identical signed+/// payload for the catalog's `(extension_id, target)` or has no entry for that+/// pair yet (another artifact of the same publisher release). A different+/// payload for an already-accepted pair at the same version is refused, so a+/// same-version catalog can never point to a different archive.+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]+#[serde(deny_unknown_fields)]+struct CatalogLedger {+ schema_version: u32,+ catalog_version: u64,+ accepted: Vec<AcceptedCatalog>,+}++#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)]+#[serde(deny_unknown_fields)]+struct AcceptedCatalog {+ extension_id: String,+ target: String,+ payload_sha256: String,+}+#[derive(Debug, Clone, Deserialize, Serialize)]#[serde(deny_unknown_fields)]struct CatalogPayload {@@ -1436,7 +1470,8 @@ fn resolve_install_source(let signed: SignedCatalog =serde_json::from_slice(&bytes).context("parse signed extension catalog")?;let trust = store.load_publisher_trust()?;- let trust_update = verify_catalog_at(entry, &signed, &trust, unix_now()?)?;+ let ledger = store.load_catalog_ledger();+ let trust_update = verify_catalog_at(entry, &signed, &trust, ledger.as_ref(), unix_now()?)?;let archive_rel = safe_relative_path(Path::new(&signed.payload.archive))?;if archive_rel.as_os_str().is_empty() || archive_rel != Path::new(&signed.payload.archive) {bail!("catalog archive path must be canonical and relative");@@ -1458,6 +1493,7 @@ fn verify_catalog_at(entry: &RegistryEntry,signed: &SignedCatalog,trust: &PublisherTrust,+ ledger: Option<&CatalogLedger>,now: u64,) -> Result<PublisherTrust> {validate_publisher_trust(trust)?;@@ -1478,13 +1514,18 @@ fn verify_catalog_at({bail!("catalog publisher identity is not trusted");}- if payload.catalog_version <= trust.highest_catalog_version {+ if payload.catalog_version < trust.highest_catalog_version {bail!(- "catalog anti-rollback version {} must be newer than trusted version {}",+ "catalog anti-rollback version {} is older than the trusted version {}; refusing to \+ roll back to an older signed catalog (use the catalog for version {} or newer)",payload.catalog_version,+ trust.highest_catalog_version,trust.highest_catalog_version);}+ if payload.catalog_version == trust.highest_catalog_version {+ verify_same_version_catalog(payload, trust, ledger)?;+ }if payload.extension_id != entry.id {bail!("catalog extension id does not match requested extension");}@@ -1570,6 +1611,124 @@ fn verify_catalog_at(Ok(updated)}+/// SHA-256 of the exact bytes the publisher signature covers.+fn catalog_payload_sha256(payload: &CatalogPayload) -> Result<String> {+ Ok(hex_sha256(&serde_json::to_vec(payload)?))+}++/// Admit a catalog at exactly the trusted anti-rollback version only when it+/// cannot substitute a different artifact for one already accepted at that+/// version. The signature is still verified by the caller afterwards.+fn verify_same_version_catalog(+ payload: &CatalogPayload,+ trust: &PublisherTrust,+ ledger: Option<&CatalogLedger>,+) -> Result<()> {+ let version = payload.catalog_version;+ let Some(ledger) = ledger.filter(|ledger| ledger.catalog_version == version) else {+ bail!(+ "catalog anti-rollback version {version} equals the trusted version {}, but this \+ extension store has no record of which signed catalog was accepted at that version \+ (the trust state predates same-version reinstall support, or its last update was \+ interrupted), so reinstalling from it cannot be proven safe; install from a catalog \+ newer than version {version} once one is published",+ trust.highest_catalog_version+ );+ };+ let digest = catalog_payload_sha256(payload)?;+ match ledger.accepted.iter().find(|accepted| {+ accepted.extension_id == payload.extension_id && accepted.target == payload.target+ }) {+ Some(accepted) if accepted.payload_sha256 == digest => Ok(()),+ Some(_) => bail!(+ "catalog anti-rollback version {version} equals the trusted version, but its signed \+ contents differ from the catalog already accepted for {} on {} at that version; \+ refusing a conflicting catalog (use the originally accepted catalog or a newer one)",+ payload.extension_id,+ payload.target+ ),+ // Another extension or target from the same publisher release.+ None => Ok(()),+ }+}++/// The ledger that results from accepting `payload`, whose signature and+/// anti-rollback position `verify_catalog_at` has already approved against+/// `trust` and `current`. Entries are kept only for the payload's version.+fn next_catalog_ledger(+ current: Option<&CatalogLedger>,+ trust: &PublisherTrust,+ payload: &CatalogPayload,+) -> Result<CatalogLedger> {+ let version = payload.catalog_version;+ let mut accepted = match current {+ Some(ledger)+ if ledger.catalog_version == version && trust.highest_catalog_version == version =>+ {+ ledger.accepted.clone()+ }+ _ => Vec::new(),+ };+ let digest = catalog_payload_sha256(payload)?;+ match accepted+ .iter()+ .find(|entry| entry.extension_id == payload.extension_id && entry.target == payload.target)+ {+ Some(existing) if existing.payload_sha256 != digest => {+ bail!("signed catalog conflicts with the catalog already accepted at its version")+ }+ Some(_) => {}+ None => accepted.push(AcceptedCatalog {+ extension_id: payload.extension_id.clone(),+ target: payload.target.clone(),+ payload_sha256: digest,+ }),+ }+ accepted.sort();+ let ledger = CatalogLedger {+ schema_version: CATALOG_LEDGER_SCHEMA_VERSION,+ catalog_version: version,+ accepted,+ };+ validate_catalog_ledger(&ledger)?;+ Ok(ledger)+}++fn validate_catalog_ledger(ledger: &CatalogLedger) -> Result<()> {+ if ledger.schema_version != CATALOG_LEDGER_SCHEMA_VERSION+ || ledger.catalog_version == 0+ || ledger.accepted.len() > MAX_CATALOG_LEDGER_ENTRIES+ || ledger.accepted.windows(2).any(|pair| {+ (&pair[0].extension_id, &pair[0].target) >= (&pair[1].extension_id, &pair[1].target)+ })+ || ledger.accepted.iter().any(|entry| {+ entry.extension_id.is_empty()+ || entry.target.is_empty()+ || validate_sha256("accepted catalog", &entry.payload_sha256).is_err()+ })+ {+ bail!("accepted catalog ledger is invalid");+ }+ Ok(())+}++/// Missing, interrupted, non-private, unreadable, or invalid ledgers read as+/// absent. The ledger only ever relaxes the same-version check, so treating+/// it as absent fails closed (same-version catalogs are refused) without+/// blocking newer catalogs.+fn load_catalog_ledger_at(root: &Dir) -> Option<CatalogLedger> {+ if !matches!(+ private_regular_file_or_missing_at(root, CATALOG_LEDGER_NAME),+ Ok(true)+ ) {+ return None;+ }+ let bytes = read_small_file_at(root, Path::new(CATALOG_LEDGER_NAME)).ok()?;+ serde_json::from_slice::<CatalogLedger>(&bytes)+ .ok()+ .filter(|ledger| validate_catalog_ledger(ledger).is_ok())+}+fn initial_publisher_trust() -> PublisherTrust {#[cfg(feature = "review-trust-root")]let (key_id, public_key_base64, valid_from_unix, valid_until_unix) = (@@ -1937,6 +2096,54 @@ impl ExtensionStore {sync_cap_dir(root)}+ fn load_catalog_ledger(&self) -> Option<CatalogLedger> {+ if !self.root.exists() {+ return None;+ }+ let root = open_directory_path_nofollow(&self.root).ok()?;+ verify_cap_directory_permissions_portable(&root).ok()?;+ load_catalog_ledger_at(&root)+ }++ /// Replace the accepted-catalog ledger. An interruption at any point+ /// leaves the ledger absent or bound to a superseded version, both of+ /// which `load_catalog_ledger_at` treats as "no same-version proof".+ fn commit_catalog_ledger_locked(&self, root: &Dir, ledger: &CatalogLedger) -> Result<()> {+ validate_catalog_ledger(ledger)?;+ for stale in [CATALOG_LEDGER_NEW_NAME, CATALOG_LEDGER_BACKUP_NAME] {+ match root.remove_file(stale) {+ Ok(()) => {}+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}+ Err(error) => {+ return Err(error).with_context(|| format!("remove stale {stale}"));+ }+ }+ }+ write_new_file_at(+ root,+ CATALOG_LEDGER_NEW_NAME,+ &serde_json::to_vec_pretty(ledger)?,+ )?;+ let had_active = match root.symlink_metadata(CATALOG_LEDGER_NAME) {+ Ok(_) => true,+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => false,+ Err(error) => return Err(error).context("inspect accepted catalog ledger"),+ };+ if had_active {+ root.rename(CATALOG_LEDGER_NAME, root, CATALOG_LEDGER_BACKUP_NAME)+ .context("back up accepted catalog ledger")?;+ }+ if let Err(error) = root.rename(CATALOG_LEDGER_NEW_NAME, root, CATALOG_LEDGER_NAME) {+ let _ = root.remove_file(CATALOG_LEDGER_NEW_NAME);+ return Err(error).context("activate accepted catalog ledger");+ }+ if had_active {+ root.remove_file(CATALOG_LEDGER_BACKUP_NAME)+ .context("remove accepted catalog ledger backup")?;+ }+ sync_cap_dir(root)+ }+fn recover_activation_locked(&self, root: &Dir, id: &str) -> Result<()> {let Some(extension) = open_private_subdirectory_if_present(root, id)? else {return Ok(());@@ -2179,13 +2386,30 @@ impl ExtensionStore {self.recover_publisher_trust_locked(&lock.root)?;self.recover_activation_locked(&lock.root, entry.id)?;self.recover_publisher_trust_from_active_locked(&lock.root, entry.id)?;+ let mut ledger_update = None;if let Some(signed) = &source.signed_catalog {let current_trust = load_publisher_trust_at(&lock.root)?;- let verified = verify_catalog_at(entry, signed, ¤t_trust, unix_now()?)- .context("signed catalog changed or became stale before mutation")?;+ let current_ledger = load_catalog_ledger_at(&lock.root);+ let verified = verify_catalog_at(+ entry,+ signed,+ ¤t_trust,+ current_ledger.as_ref(),+ unix_now()?,+ )+ .context("signed catalog changed or became stale before mutation")?;if source.trust_update.as_ref() != Some(&verified) {bail!("signed catalog trust decision changed before mutation; inspect it again");}+ // Derive the ledger now, under the lock and from the same state as+ // the trust decision, but persist it only once the artifact is+ // active: a refused or failed install must not discard the proof+ // for the catalog that is currently trusted.+ let next_ledger =+ next_catalog_ledger(current_ledger.as_ref(), ¤t_trust, &signed.payload)?;+ if current_ledger.as_ref() != Some(&next_ledger) {+ ledger_update = Some(next_ledger);+ }}let active = self.active_pointer_locked(&lock.root, entry.id)?;if is_update && active.is_none() {@@ -2212,7 +2436,14 @@ impl ExtensionStore {.as_ref().map(|catalog| catalog.catalog_version),) {- if next <= previous {+ if next == previous {+ bail!(+ "{} is already installed from catalog anti-rollback version {previous}; \+ an update requires a newer catalog",+ entry.id+ );+ }+ if next < previous {bail!("catalog anti-rollback version {next} must be newer than installed version {previous}");@@ -2354,6 +2585,12 @@ impl ExtensionStore {&version_text,ActivationFailpoint::None,)?;+ // The ledger is bound to its catalog version, so committing it before+ // the trust file is safe: until trust reaches that version it proves+ // nothing, and startup recovery raises trust from this install record.+ if let Some(ledger) = &ledger_update {+ self.commit_catalog_ledger_locked(&lock.root, ledger)?;+ }if let Some(trust) = &source.trust_update {self.commit_publisher_trust_locked(&lock.root, trust)?;}@@ -5791,8 +6028,20 @@ mod tests {#[cfg(feature = "review-trust-root")]fn review_fixture(directory: &Path) -> (PathBuf, PathBuf) {- use ring::signature::Ed25519KeyPair;+ let pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(&REVIEW_SEED).unwrap();+ let (archive, signed) = signed_fixture(directory, &pair, REVIEW_KEY_ID, 1);+ let catalog = directory.join("review-catalog.json");+ fs::write(&catalog, serde_json::to_vec_pretty(&signed).unwrap()).unwrap();+ (archive, catalog)+ }+ /// A publisher-verifiable extension archive and its signed catalog.+ fn signed_fixture(+ directory: &Path,+ pair: &ring::signature::Ed25519KeyPair,+ key_id: &str,+ catalog_version: u64,+ ) -> (PathBuf, SignedCatalog) {let worker = b"#!/bin/sh\nexit 0\n";let model = b"model";let notice = b"notice";@@ -5868,11 +6117,11 @@ mod tests {let archive_bytes = fs::read(&archive).unwrap();let payload = CatalogPayload {schema_version: 1,- catalog_version: 1,+ catalog_version,expires_unix: u64::MAX,- publisher_id: REVIEW_PUBLISHER_ID.to_owned(),- publisher_name: REVIEW_PUBLISHER_NAME.to_owned(),- key_id: REVIEW_KEY_ID.to_owned(),+ publisher_id: expected_publisher_id().to_owned(),+ publisher_name: expected_publisher_name().to_owned(),+ key_id: key_id.to_owned(),extension_id: PERCEPTION_ID.to_owned(),version: manifest.version.clone(),target: manifest.target.clone(),@@ -5887,11 +6136,7 @@ mod tests {provenance: manifest.provenance.clone(),next_key: None,};- let pair = Ed25519KeyPair::from_seed_unchecked(&REVIEW_SEED).unwrap();- let signed = sign_test_catalog(&pair, payload);- let catalog = directory.join("review-catalog.json");- fs::write(&catalog, serde_json::to_vec_pretty(&signed).unwrap()).unwrap();- (archive, catalog)+ (archive, sign_test_catalog(pair, payload))}fn append(builder: &mut tar::Builder<GzEncoder<fs::File>>, path: &str, bytes: &[u8]) {@@ -7158,12 +7403,12 @@ mod tests {let entry = registry_entry("cua-perception").unwrap();let valid = sign_test_catalog(¤t, test_catalog_payload("current", 1));- let accepted = verify_catalog_at(entry, &valid, &trust, 150).unwrap();+ let accepted = verify_catalog_at(entry, &valid, &trust, None, 150).unwrap();assert_eq!(accepted.highest_catalog_version, 1);let mut tampered = valid.clone();tampered.payload.archive_size = 2;- assert!(verify_catalog_at(entry, &tampered, &trust, 150)+ assert!(verify_catalog_at(entry, &tampered, &trust, None, 150).unwrap_err().to_string().contains("signature verification"));@@ -7171,7 +7416,7 @@ mod tests {let mut rotation_payload = test_catalog_payload("current", 2);rotation_payload.next_key = Some(next_key.clone());let rotation = sign_test_catalog(¤t, rotation_payload);- let pending = verify_catalog_at(entry, &rotation, &trust, 150).unwrap();+ let pending = verify_catalog_at(entry, &rotation, &trust, None, 150).unwrap();assert_eq!(pending.pending_key.as_ref().unwrap().key_id, "next");let mut retrograde_payload = test_catalog_payload("current", 2);@@ -7180,6 +7425,7 @@ mod tests {entry,&sign_test_catalog(¤t, retrograde_payload),&trust,+ None,150,).unwrap_err()@@ -7187,23 +7433,23 @@ mod tests {.contains("invalid rotation window"));let next_catalog = sign_test_catalog(&next, test_catalog_payload("next", 3));- assert!(verify_catalog_at(entry, &next_catalog, &pending, 199)+ assert!(verify_catalog_at(entry, &next_catalog, &pending, None, 199).unwrap_err().to_string().contains("not valid yet"));- let promoted = verify_catalog_at(entry, &next_catalog, &pending, 250).unwrap();+ let promoted = verify_catalog_at(entry, &next_catalog, &pending, None, 250).unwrap();assert_eq!(promoted.current_key.key_id, "next");assert_eq!(promoted.generation, 2);assert!(promoted.pending_key.is_none());let retired = sign_test_catalog(¤t, test_catalog_payload("current", 4));- assert!(verify_catalog_at(entry, &retired, &promoted, 300)+ assert!(verify_catalog_at(entry, &retired, &promoted, None, 300).unwrap_err().to_string().contains("retired"));let rollback = sign_test_catalog(&next, test_catalog_payload("next", 3));- assert!(verify_catalog_at(entry, &rollback, &promoted, 300)+ assert!(verify_catalog_at(entry, &rollback, &promoted, None, 300).unwrap_err().to_string().contains("anti-rollback"));@@ -7213,10 +7459,12 @@ mod tests {..trust};let expired = sign_test_catalog(¤t, test_catalog_payload("expired", 5));- assert!(verify_catalog_at(entry, &expired, &expired_trust, 200)- .unwrap_err()- .to_string()- .contains("expired"));+ assert!(+ verify_catalog_at(entry, &expired, &expired_trust, None, 200)+ .unwrap_err()+ .to_string()+ .contains("expired")+ );}#[test]@@ -7237,7 +7485,7 @@ mod tests {};let mut invalid_trust = trust.clone();invalid_trust.generation = 0;- assert!(verify_catalog_at(entry, &signed, &invalid_trust, 100)+ assert!(verify_catalog_at(entry, &signed, &invalid_trust, None, 100).unwrap_err().to_string().contains("trust state is invalid"));@@ -7246,7 +7494,7 @@ mod tests {let store = ExtensionStore::new(temp.path().join("extensions"));let root = ensure_private_directory_path(&store.root).unwrap();store.commit_publisher_trust_locked(&root, &trust).unwrap();- let decision = verify_catalog_at(entry, &signed, &trust, 100).unwrap();+ let decision = verify_catalog_at(entry, &signed, &trust, None, 100).unwrap();let mut advanced = trust.clone();advanced.highest_catalog_version = 2;store@@ -7282,6 +7530,294 @@ mod tests {assert!(!store.root.join(TRUST_NEW_NAME).exists());}+ fn test_trust(key: PublisherKey, highest_catalog_version: u64) -> PublisherTrust {+ PublisherTrust {+ schema_version: 1,+ publisher_id: expected_publisher_id().to_owned(),+ generation: 1,+ highest_catalog_version,+ current_key: key,+ pending_key: None,+ }+ }++ #[test]+ fn same_version_catalog_is_accepted_only_when_byte_identical() {+ let pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(&[21; 32]).unwrap();+ let key = test_publisher_key("current", &pair, 100, 800);+ let entry = registry_entry("cua-perception").unwrap();+ let initial = test_trust(key.clone(), 4);+ let catalog = sign_test_catalog(&pair, test_catalog_payload("current", 5));++ let trusted = verify_catalog_at(entry, &catalog, &initial, None, 150).unwrap();+ assert_eq!(trusted.highest_catalog_version, 5);+ let ledger = next_catalog_ledger(None, &initial, &catalog.payload).unwrap();+ assert_eq!(ledger.catalog_version, 5);+ assert_eq!(ledger.accepted.len(), 1);++ // Remove -> reinstall of the same signed catalog: the trust decision+ // is unchanged and the ledger does not grow.+ assert_eq!(+ verify_catalog_at(entry, &catalog, &trusted, Some(&ledger), 150).unwrap(),+ trusted+ );+ assert_eq!(+ next_catalog_ledger(Some(&ledger), &trusted, &catalog.payload).unwrap(),+ ledger+ );++ // A different signed payload at the same version for the same+ // extension and target is refused, even though it is validly signed.+ let mut conflicting = test_catalog_payload("current", 5);+ conflicting.archive_sha256 = "2".repeat(64);+ let conflicting = sign_test_catalog(&pair, conflicting);+ let error = verify_catalog_at(entry, &conflicting, &trusted, Some(&ledger), 150)+ .unwrap_err()+ .to_string();+ assert!(error.contains("signed contents differ"), "{error}");+ assert!(next_catalog_ledger(Some(&ledger), &trusted, &conflicting.payload).is_err());++ // Older catalogs stay refused regardless of the ledger.+ let older = sign_test_catalog(&pair, test_catalog_payload("current", 4));+ let error = verify_catalog_at(entry, &older, &trusted, Some(&ledger), 150)+ .unwrap_err()+ .to_string();+ assert!(+ error.contains("older than the trusted version 5"),+ "{error}"+ );++ // A ledger bound to another version proves nothing about version 5.+ let stale = CatalogLedger {+ catalog_version: 4,+ ..ledger.clone()+ };+ let error = verify_catalog_at(entry, &catalog, &trusted, Some(&stale), 150)+ .unwrap_err()+ .to_string();+ assert!(error.contains("no record"), "{error}");++ // Newer catalogs are accepted and reset the ledger to their version.+ let newer = sign_test_catalog(&pair, test_catalog_payload("current", 6));+ let advanced = verify_catalog_at(entry, &newer, &trusted, Some(&ledger), 150).unwrap();+ assert_eq!(advanced.highest_catalog_version, 6);+ let advanced_ledger = next_catalog_ledger(Some(&ledger), &trusted, &newer.payload).unwrap();+ assert_eq!(advanced_ledger.catalog_version, 6);+ assert_eq!(advanced_ledger.accepted.len(), 1);+ assert_eq!(+ advanced_ledger.accepted[0].payload_sha256,+ catalog_payload_sha256(&newer.payload).unwrap()+ );+ }++ #[test]+ fn same_version_catalogs_for_other_targets_do_not_corrupt_the_ledger() {+ let pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(&[23; 32]).unwrap();+ let key = test_publisher_key("current", &pair, 100, 800);+ let entry = registry_entry("cua-perception").unwrap();+ let initial = test_trust(key, 0);+ let native = sign_test_catalog(&pair, test_catalog_payload("current", 9));+ let trusted = verify_catalog_at(entry, &native, &initial, None, 150).unwrap();+ let ledger = next_catalog_ledger(None, &initial, &native.payload).unwrap();++ // The per-target catalog for another platform, signed at the same+ // release version, passes anti-rollback but is refused for this host+ // before any trust or ledger state is derived from it.+ let mut foreign_payload = test_catalog_payload("current", 9);+ foreign_payload.target = "other-os-other-arch".to_owned();+ let foreign = sign_test_catalog(&pair, foreign_payload);+ let error = verify_catalog_at(entry, &foreign, &trusted, Some(&ledger), 150)+ .unwrap_err()+ .to_string();+ assert!(error.contains("target does not match"), "{error}");++ // Even if a ledger records several targets of one release, each+ // (extension, target) keeps its own payload, entries stay sorted and+ // unique, and the native catalog remains reinstallable.+ let merged = next_catalog_ledger(Some(&ledger), &trusted, &foreign.payload).unwrap();+ assert_eq!(merged.accepted.len(), 2);+ validate_catalog_ledger(&merged).unwrap();+ assert_eq!(+ next_catalog_ledger(Some(&merged), &trusted, &native.payload).unwrap(),+ merged+ );+ assert_eq!(+ verify_catalog_at(entry, &native, &trusted, Some(&merged), 150).unwrap(),+ trusted+ );+ let mut conflicting = test_catalog_payload("current", 9);+ conflicting.version = "1.0.99".to_owned();+ let conflicting = sign_test_catalog(&pair, conflicting);+ assert!(+ verify_catalog_at(entry, &conflicting, &trusted, Some(&merged), 150)+ .unwrap_err()+ .to_string()+ .contains("signed contents differ")+ );++ // Duplicate or unsorted entries are rejected as an invalid ledger.+ let mut duplicate = merged.clone();+ duplicate.accepted.push(duplicate.accepted[0].clone());+ assert!(validate_catalog_ledger(&duplicate).is_err());+ }++ #[test]+ fn stores_without_a_catalog_ledger_keep_working() {+ let pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(&[25; 32]).unwrap();+ let key = test_publisher_key("current", &pair, 1, u64::MAX);+ let entry = registry_entry("cua-perception").unwrap();+ let temp = TempDir::new().unwrap();+ let store = ExtensionStore::new(temp.path().join("extensions"));+ let root = ensure_private_directory_path(&store.root).unwrap();++ // A trust file written by an earlier driver (same schema, no ledger).+ let legacy = test_trust(key, 7);+ write_new_file_at(+ &root,+ TRUST_NAME,+ &serde_json::to_vec_pretty(&legacy).unwrap(),+ )+ .unwrap();+ assert_eq!(store.load_publisher_trust().unwrap(), legacy);+ assert!(store.load_catalog_ledger().is_none());++ let mut same = test_catalog_payload("current", 7);+ same.expires_unix = u64::MAX;+ let same = sign_test_catalog(&pair, same);+ let error = verify_catalog_at(entry, &same, &legacy, None, 100)+ .unwrap_err()+ .to_string();+ assert!(error.contains("equals the trusted version 7"), "{error}");+ assert!(error.contains("newer than version 7"), "{error}");++ let mut newer = test_catalog_payload("current", 8);+ newer.expires_unix = u64::MAX;+ let newer = sign_test_catalog(&pair, newer);+ assert_eq!(+ verify_catalog_at(entry, &newer, &legacy, None, 100)+ .unwrap()+ .highest_catalog_version,+ 8+ );++ // The ledger round-trips, and a corrupt or non-private ledger reads as+ // absent (fails closed) instead of blocking every install.+ let ledger = next_catalog_ledger(None, &legacy, &newer.payload).unwrap();+ store.commit_catalog_ledger_locked(&root, &ledger).unwrap();+ assert_eq!(store.load_catalog_ledger(), Some(ledger.clone()));+ store.commit_catalog_ledger_locked(&root, &ledger).unwrap();+ assert_eq!(store.load_catalog_ledger(), Some(ledger));+ assert!(!store.root.join(CATALOG_LEDGER_NEW_NAME).exists());+ assert!(!store.root.join(CATALOG_LEDGER_BACKUP_NAME).exists());+ root.remove_file(CATALOG_LEDGER_NAME).unwrap();+ write_new_file_at(&root, CATALOG_LEDGER_NAME, b"{not json").unwrap();+ assert!(store.load_catalog_ledger().is_none());+ // The publisher trust file format itself is unchanged.+ let serialized: serde_json::Value =+ serde_json::from_slice(&serde_json::to_vec(&legacy).unwrap()).unwrap();+ assert_eq!(+ serialized.as_object().unwrap().keys().collect::<Vec<_>>(),+ [+ "current_key",+ "generation",+ "highest_catalog_version",+ "pending_key",+ "publisher_id",+ "schema_version"+ ]+ );+ }++ #[cfg(unix)]+ #[test]+ fn verified_extension_can_be_removed_and_reinstalled_from_the_same_catalog() {+ fn verified_source(+ store: &ExtensionStore,+ archive: &Path,+ signed: &SignedCatalog,+ ) -> Result<InstallSource> {+ let entry = registry_entry(PERCEPTION_ID).unwrap();+ let trust = store.load_publisher_trust()?;+ let ledger = store.load_catalog_ledger();+ let trust_update =+ verify_catalog_at(entry, signed, &trust, ledger.as_ref(), unix_now()?)?;+ Ok(InstallSource {+ archive: archive.to_owned(),+ trust: verified_trust_class(),+ catalog: Some(signed.payload.clone()),+ signed_catalog: Some(signed.clone()),+ trust_update: Some(trust_update),+ })+ }++ let pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(&[27; 32]).unwrap();+ let key = test_publisher_key("current", &pair, 1, u64::MAX);+ let entry = registry_entry(PERCEPTION_ID).unwrap();+ let temp = TempDir::new().unwrap();+ let store = ExtensionStore::new(temp.path().join("extensions"));+ let root = ensure_private_directory_path(&store.root).unwrap();+ store+ .commit_publisher_trust_locked(&root, &test_trust(key, 0))+ .unwrap();+ let (archive, catalog) = signed_fixture(temp.path(), &pair, "current", 2026092402);++ let source = verified_source(&store, &archive, &catalog).unwrap();+ store.install_source(entry, &source, false).unwrap();+ assert_eq!(+ store+ .load_publisher_trust()+ .unwrap()+ .highest_catalog_version,+ 2026092402+ );++ // `update` to the catalog that is already installed is a clear no-op+ // refusal rather than an anti-rollback failure.+ let source = verified_source(&store, &archive, &catalog).unwrap();+ let error = store.install_source(entry, &source, true).unwrap_err();+ assert!(+ format!("{error:#}").contains("already installed from catalog"),+ "{error:#}"+ );++ // D-MAC-9: remove, then reinstall the same signed catalog.+ store.remove(entry).unwrap();+ let source = verified_source(&store, &archive, &catalog).unwrap();+ store.install_source(entry, &source, false).unwrap();+ assert!(store.active_path(PERCEPTION_ID).unwrap().is_some());++ // A refused mutation with a newer catalog must not discard the proof+ // for the catalog that is currently trusted.+ let ledger = store.load_catalog_ledger().unwrap();+ let (_, newer) = signed_fixture(temp.path(), &pair, "current", 2026092403);+ let source = verified_source(&store, &archive, &newer).unwrap();+ assert!(store.install_source(entry, &source, false).is_err());+ assert_eq!(store.load_catalog_ledger(), Some(ledger));+ store.remove(entry).unwrap();+ let source = verified_source(&store, &archive, &catalog).unwrap();+ store.install_source(entry, &source, false).unwrap();++ // A different payload signed at the same version is still refused.+ store.remove(entry).unwrap();+ let mut conflicting = catalog.payload.clone();+ conflicting.expires_unix -= 1;+ let conflicting = sign_test_catalog(&pair, conflicting);+ let error = verified_source(&store, &archive, &conflicting)+ .err()+ .unwrap()+ .to_string();+ assert!(error.contains("signed contents differ"), "{error}");++ // A store that predates the ledger refuses the same-version reinstall+ // with guidance instead of silently weakening anti-rollback.+ fs::remove_file(store.root.join(CATALOG_LEDGER_NAME)).unwrap();+ let error = verified_source(&store, &archive, &catalog)+ .err()+ .unwrap()+ .to_string();+ assert!(error.contains("no record"), "{error}");+ }+#[test]fn model_hash_must_exactly_match_the_declared_file_hash() {let file_hash = hex_sha256(b"model");diff --git a/libs/cua-driver/rust/crates/cua-driver/tests/extension_manager_cli_test.rs b/libs/cua-driver/rust/crates/cua-driver/tests/extension_manager_cli_test.rsindex bc464ac78d..b4043b6c5e 100644--- a/libs/cua-driver/rust/crates/cua-driver/tests/extension_manager_cli_test.rs+++ b/libs/cua-driver/rust/crates/cua-driver/tests/extension_manager_cli_test.rs@@ -676,6 +676,46 @@ fn review_signed_lifecycle_is_distinct_fail_closed_and_rollback_safe() {);assert!(!replay.status.success());assert!(String::from_utf8_lossy(&replay.stderr).contains("anti-rollback"));++ // Removing the extension must not strand the user: the exact signed+ // catalog that is already trusted can be reinstalled, while the original,+ // older catalog stays refused.+ let remove = run(&home, &["extension", "remove", "perception"]);+ assert!(+ remove.status.success(),+ "{}",+ String::from_utf8_lossy(&remove.stderr)+ );+ let rollback_install = run(+ &home,+ &[+ "extension",+ "install",+ "perception",+ "--catalog",+ catalog.to_str().unwrap(),+ ],+ );+ assert!(!rollback_install.status.success());+ assert!(String::from_utf8_lossy(&rollback_install.stderr).contains("older than"));+ let reinstall = run(+ &home,+ &[+ "extension",+ "install",+ "perception",+ "--catalog",+ update_catalog.to_str().unwrap(),+ ],+ );+ assert!(+ reinstall.status.success(),+ "{}",+ String::from_utf8_lossy(&reinstall.stderr)+ );+ let status = run(&home, &["extension", "status", "perception", "--json"]);+ let status_json: Value = serde_json::from_slice(&status.stdout).unwrap();+ assert_eq!(status_json["active_version"], "1.2.4");}#[cfg(feature = "review-trust-root")]