use std::collections::{BTreeMap, BTreeSet, HashSet}; use std::fs::{File, OpenOptions}; use std::io::{Cursor, Read, Write}; use std::path::{Component, Path, PathBuf}; use std::sync::Arc; use std::time::Duration; use base64::Engine; use chrono::Utc; use ed25519_dalek::{Signature, Verifier, VerifyingKey}; use fs2::FileExt; use semver::Version; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use super::lifecycle::PluginUsageGuard; use super::{InstalledPlugin, InstalledPluginInfo, PluginLifecycle, PluginManifest}; pub const DBXP_EXTENSION: &str = "dbxp"; pub const PLUGIN_CHECKSUMS_FILE: &str = "checksums.json"; pub const PLUGIN_SIGNATURE_FILE: &str = "signature.json"; pub const MAX_PLUGIN_PACKAGE_BYTES: usize = 512 * 1024 * 1024; const MAX_UNCOMPRESSED_BYTES: u64 = 1024 * 1024 * 1024; const MAX_FILE_BYTES: u64 = 256 * 1024 * 1024; const MAX_ARCHIVE_ENTRIES: usize = 10_000; const INSTALL_LOCK_FILE: &str = ".install.lock"; const VERSIONS_DIR: &str = "versions"; const ACTIVATIONS_DIR: &str = "activations"; const TRUST_DIR: &str = ".trust"; const TRUST_KEYS_FILE: &str = "keys.json"; #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum PluginInstallPolicy { LocalSigned, LocalDevelopment, } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] #[serde(tag = "status", rename_all = "snake_case")] pub enum PluginSignatureStatus { Trusted { key_id: String }, Unsigned, } #[derive(Debug, Clone)] pub struct PluginInstallResult { pub plugin: InstalledPlugin, pub previous_version: Option, pub package_sha256: String, pub signature: PluginSignatureStatus, _update_guard: Option, } #[derive(Debug, Clone)] pub struct PluginRollbackResult { pub plugin: InstalledPlugin, pub previous_version: String, _update_guard: Option, } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct PluginInstallResponse { pub plugin: InstalledPluginInfo, pub previous_version: Option, pub package_sha256: String, pub signature: PluginSignatureStatus, } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct PluginRollbackResponse { pub plugin: InstalledPluginInfo, pub previous_version: String, } impl PluginInstallResult { pub fn response(&self) -> PluginInstallResponse { PluginInstallResponse { plugin: self.plugin.info(), previous_version: self.previous_version.clone(), package_sha256: self.package_sha256.clone(), signature: self.signature.clone(), } } } impl PluginRollbackResult { pub fn response(&self) -> PluginRollbackResponse { PluginRollbackResponse { plugin: self.plugin.info(), previous_version: self.previous_version.clone() } } } #[derive(Debug, Clone, Default)] pub struct PluginTrustStore { keys: BTreeMap, } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "camelCase")] pub struct PluginTrustedKey { pub key_id: String, pub public_key: String, } #[derive(Debug, Deserialize, Serialize, Default)] struct PluginTrustDocument { #[serde(default)] keys: BTreeMap, } #[derive(Debug, Deserialize)] struct PluginPackageChecksums { algorithm: String, files: BTreeMap, } #[derive(Debug, Deserialize, Serialize)] struct PluginPackageSignature { algorithm: String, key_id: String, signature: String, } /// Where an installed plugin came from. Recorded with every activation so an update can detect a /// changed repository / publisher / signing key instead of silently replacing the plugin. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "camelCase")] pub struct PluginInstallProvenance { #[serde(default, skip_serializing_if = "Option::is_none")] pub repository_id: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub publisher: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub signing_key_id: Option, #[serde(default)] pub source: PluginInstallSource, } #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)] #[serde(rename_all = "camelCase")] pub enum PluginInstallSource { Marketplace, Url, File, #[default] Unknown, } /// The active installation of one plugin id: the semver activation version plus whatever /// provenance was recorded when it was installed. Provenance is `None` for installs made before /// provenance existed (and for legacy migrated containers); those stay unconstrained until the /// next install records fresh provenance. #[derive(Debug, Clone)] pub(crate) struct PluginInstallIdentity { pub version: String, pub provenance: Option, } #[derive(Debug, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct PluginActivationRecord { sequence: u64, version: String, #[serde(default, skip_serializing_if = "Option::is_none")] previous_version: Option, package_sha256: String, activated_at: String, #[serde(default, skip_serializing_if = "Option::is_none")] provenance: Option, } pub struct PluginPackageInstaller { root_dir: PathBuf, app_version: String, trust_store: Arc, lifecycle: Option, } #[derive(Debug, Clone)] pub(super) struct PluginPackageExpectation { pub id: String, pub version: String, pub repository_id: Option, pub publisher: String, pub permissions: BTreeSet, pub signing_key_id: String, } /// Read-only identity lookup for one plugin id under the store root: the activation version plus /// the recorded provenance. Free function so the marketplace pre-flight can call it without /// constructing an installer (which would load the user trust store as a side effect). pub(crate) fn read_install_identity(root_dir: &Path, plugin_id: &str) -> Result, String> { validate_plugin_id(plugin_id)?; let Some(record) = read_latest_activation(&root_dir.join(plugin_id))? else { return Ok(None) }; Ok(Some(PluginInstallIdentity { version: record.version, provenance: record.provenance })) } /// Rejects an update whose repository / publisher / signing key differs from the recorded /// provenance, or that would downgrade below the active version, unless `allow` is set (the /// user confirmed the change in the UI). The marketplace pre-flight calls this before any /// download; `install_bytes_locked` re-checks under the store lock. pub(crate) fn ensure_update_continuity( provenance: &PluginInstallProvenance, active_version: &str, repository_id: Option<&str>, publisher: &str, signing_key_id: &str, candidate_version: &str, allow: bool, ) -> Result<(), String> { // Compare against the activation version (always semver); a legacy manifest version string // that fails to parse simply skips the downgrade check. if let (Ok(active), Ok(candidate)) = (Version::parse(active_version), Version::parse(candidate_version)) { if candidate < active && !allow { return Err(format!( "Plugin downgrade to version {candidate_version} is not allowed (installed {active_version})" )); } } let repository_changed = provenance.repository_id.as_deref().is_some_and(|recorded| Some(recorded) != repository_id); let publisher_changed = provenance.publisher.as_deref().is_some_and(|recorded| recorded != publisher); let key_changed = provenance.signing_key_id.as_deref().is_some_and(|recorded| recorded != signing_key_id); if (repository_changed || publisher_changed || key_changed) && !allow { return Err( "Plugin update source change requires confirmation: the offering repository, publisher, or signing key differs from the recorded install" .to_string(), ); } Ok(()) } impl PluginTrustStore { pub fn load(root_dir: &Path) -> Result { let document = read_trust_document(root_dir)?; Self::from_base64_keys(document.keys) } pub fn list_base64_keys(root_dir: &Path) -> Result, String> { let document = read_trust_document(root_dir)?; Self::from_base64_keys(document.keys.clone())?; Ok(document .keys .into_iter() .map(|(key_id, public_key)| PluginTrustedKey { key_id, public_key: public_key.trim().to_string() }) .collect()) } pub fn from_base64_keys(keys: BTreeMap) -> Result { let mut parsed = BTreeMap::new(); for (key_id, encoded) in keys { validate_key_id(&key_id)?; let bytes = base64::engine::general_purpose::STANDARD .decode(encoded.trim()) .map_err(|error| format!("Invalid trusted plugin key '{key_id}': {error}"))?; let bytes: [u8; 32] = bytes.try_into().map_err(|_| format!("Trusted plugin key '{key_id}' must contain 32 bytes"))?; let key = VerifyingKey::from_bytes(&bytes) .map_err(|error| format!("Invalid trusted plugin key '{key_id}': {error}"))?; parsed.insert(key_id, key); } Ok(Self { keys: parsed }) } pub fn is_empty(&self) -> bool { self.keys.is_empty() } pub fn save_base64_key(root_dir: &Path, key_id: &str, public_key: &str) -> Result<(), String> { validate_key_id(key_id)?; let lock = open_install_lock(root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let result = (|| { let path = plugin_trust_keys_path(root_dir); let mut document = read_trust_document(root_dir)?; let public_key = public_key.trim(); if document.keys.get(key_id).is_some_and(|existing| existing.trim() != public_key) { return Err(format!( "Trusted plugin key '{key_id}' already exists with a different public key; remove it before rotating" )); } let mut candidate = document.keys.clone(); candidate.insert(key_id.to_string(), public_key.to_string()); Self::from_base64_keys(candidate)?; document.keys.insert(key_id.to_string(), public_key.to_string()); write_json_atomically(&path, &document) })(); let _ = FileExt::unlock(&lock); result } pub fn remove_key(root_dir: &Path, key_id: &str) -> Result<(), String> { validate_key_id(key_id)?; let lock = open_install_lock(root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let result = (|| { let path = plugin_trust_keys_path(root_dir); let mut document = read_trust_document(root_dir)?; document.keys.remove(key_id); write_json_atomically(&path, &document) })(); let _ = FileExt::unlock(&lock); result } fn verify(&self, signature: &PluginPackageSignature, payload: &[u8]) -> Result { if signature.algorithm != "ed25519" { return Err(format!("Unsupported plugin signature algorithm '{}'", signature.algorithm)); } let key = self .keys .get(&signature.key_id) .ok_or_else(|| format!("Plugin package is signed by untrusted key '{}'", signature.key_id))?; let key_id = signature.key_id.clone(); let signature_bytes = base64::engine::general_purpose::STANDARD .decode(signature.signature.trim()) .map_err(|error| format!("Invalid plugin package signature: {error}"))?; let signature = Signature::from_slice(&signature_bytes) .map_err(|error| format!("Invalid plugin package signature: {error}"))?; key.verify(payload, &signature).map_err(|_| "Plugin package signature verification failed".to_string())?; Ok(PluginSignatureStatus::Trusted { key_id }) } } fn plugin_trust_keys_path(root_dir: &Path) -> PathBuf { root_dir.join(TRUST_DIR).join(TRUST_KEYS_FILE) } fn read_trust_document(root_dir: &Path) -> Result { let path = plugin_trust_keys_path(root_dir); let raw = match std::fs::read(&path) { Ok(raw) => raw, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(PluginTrustDocument::default()), Err(error) => return Err(format!("Failed to read plugin trust store {}: {error}", path.display())), }; serde_json::from_slice(&raw) .map_err(|error| format!("Failed to parse plugin trust store {}: {error}", path.display())) } impl PluginPackageInstaller { pub fn new(root_dir: PathBuf, app_version: impl Into) -> Result { let trust_store = super::marketplace::package_install_trust_store(&root_dir)?; Ok(Self { root_dir, app_version: app_version.into(), trust_store: Arc::new(trust_store), lifecycle: None }) } pub fn with_trust_store(root_dir: PathBuf, app_version: impl Into, trust_store: PluginTrustStore) -> Self { Self { root_dir, app_version: app_version.into(), trust_store: Arc::new(trust_store), lifecycle: None } } pub fn with_lifecycle(mut self, lifecycle: PluginLifecycle) -> Self { self.lifecycle = Some(lifecycle); self } pub fn install_file( &self, package_path: &Path, policy: PluginInstallPolicy, ) -> Result { if package_path.extension().and_then(|extension| extension.to_str()) != Some(DBXP_EXTENSION) { return Err(format!("Plugin package must use the .{DBXP_EXTENSION} extension")); } let metadata = std::fs::metadata(package_path) .map_err(|error| format!("Failed to inspect plugin package {}: {error}", package_path.display()))?; if metadata.len() > MAX_PLUGIN_PACKAGE_BYTES as u64 { return Err(format!("Plugin package exceeds {MAX_PLUGIN_PACKAGE_BYTES} bytes")); } let bytes = std::fs::read(package_path) .map_err(|error| format!("Failed to read plugin package {}: {error}", package_path.display()))?; self.install_bytes(&bytes, policy) } pub fn install_bytes(&self, package: &[u8], policy: PluginInstallPolicy) -> Result { self.install_bytes_with_expectation(package, policy, None, PluginInstallSource::File, false) } pub(super) fn install_marketplace_bytes( &self, package: &[u8], expectation: &PluginPackageExpectation, allow_source_change: bool, ) -> Result { self.install_bytes_with_expectation( package, PluginInstallPolicy::LocalSigned, Some(expectation), PluginInstallSource::Marketplace, allow_source_change, ) } /// Shared entry point for every install path: `PluginPackageExpectation` (and therefore this /// signature) stays inside the `plugins` module, exactly like the expectation type. pub(super) fn install_bytes_with_expectation( &self, package: &[u8], policy: PluginInstallPolicy, expectation: Option<&PluginPackageExpectation>, source: PluginInstallSource, allow_source_change: bool, ) -> Result { if package.len() > MAX_PLUGIN_PACKAGE_BYTES { return Err(format!("Plugin package exceeds {MAX_PLUGIN_PACKAGE_BYTES} bytes")); } std::fs::create_dir_all(&self.root_dir).map_err(|error| error.to_string())?; let lock = open_install_lock(&self.root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let result = self.install_bytes_locked(package, policy, expectation, source, allow_source_change); let _ = FileExt::unlock(&lock); result } pub fn rollback(&self, plugin_id: &str) -> Result { validate_plugin_id(plugin_id)?; std::fs::create_dir_all(&self.root_dir).map_err(|error| error.to_string())?; let lock = open_install_lock(&self.root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let result = self.rollback_locked(plugin_id); let _ = FileExt::unlock(&lock); result } pub fn uninstall(&self, plugin_id: &str) -> Result<(), String> { validate_plugin_id(plugin_id)?; let lock = open_install_lock(&self.root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let plugin_dir = self.root_dir.join(plugin_id); let result = match std::fs::remove_dir_all(&plugin_dir) { Ok(()) => Ok(()), Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()), Err(error) => Err(format!("Failed to uninstall plugin '{plugin_id}': {error}")), }; let _ = FileExt::unlock(&lock); result } /// Recorded provenance of one container's active installation, if any. pub(super) fn read_container_provenance(container_dir: &Path) -> Result, String> { Ok(read_latest_activation(container_dir)?.and_then(|record| record.provenance)) } fn install_bytes_locked( &self, package: &[u8], policy: PluginInstallPolicy, expectation: Option<&PluginPackageExpectation>, source: PluginInstallSource, allow_source_change: bool, ) -> Result { let package_sha256 = sha256_hex(package); let staging = tempfile::Builder::new() .prefix(".dbxp-staging-") .tempdir_in(&self.root_dir) .map_err(|error| format!("Failed to create plugin staging directory: {error}"))?; let package_dir = staging.path().join("package"); std::fs::create_dir(&package_dir).map_err(|error| error.to_string())?; let extracted = extract_package(package, &package_dir)?; let checksums_path = package_dir.join(PLUGIN_CHECKSUMS_FILE); let checksums_raw = std::fs::read(&checksums_path) .map_err(|error| format!("Plugin package is missing {PLUGIN_CHECKSUMS_FILE}: {error}"))?; verify_package_checksums(&package_dir, &extracted, &checksums_raw)?; let signature = verify_package_signature(&package_dir, &checksums_raw, policy, &self.trust_store)?; let manifest_path = package_dir.join("manifest.json"); let manifest_raw = std::fs::read(&manifest_path) .map_err(|error| format!("Plugin package is missing manifest.json: {error}"))?; let manifest: PluginManifest = serde_json::from_slice(&manifest_raw) .map_err(|error| format!("Failed to parse plugin manifest: {error}"))?; if manifest.manifest_version == 0 { return Err(".dbxp packages must use plugin manifest version 1 or newer".to_string()); } validate_plugin_id(&manifest.id)?; let version = Version::parse(&manifest.version) .map_err(|error| format!("Plugin version '{}' is invalid: {error}", manifest.version))?; let compatibility = manifest.compatibility(&package_dir, &self.app_version); if !compatibility.compatible { return Err(format!("Plugin '{}' is incompatible: {}", manifest.id, compatibility.errors.join("; "))); } if let Some(expectation) = expectation { validate_package_expectation(&manifest, &signature, expectation)?; } make_backend_executable(&compatibility.backend_executable)?; let update_guard = self.lifecycle.as_ref().map(|lifecycle| lifecycle.begin_update(&manifest.id)).transpose()?; let container_dir = self.root_dir.join(&manifest.id); migrate_legacy_container(&container_dir)?; let versions_dir = container_dir.join(VERSIONS_DIR); let activations_dir = container_dir.join(ACTIVATIONS_DIR); std::fs::create_dir_all(&versions_dir).map_err(|error| error.to_string())?; std::fs::create_dir_all(&activations_dir).map_err(|error| error.to_string())?; let version_string = version.to_string(); let version_dir = versions_dir.join(&version_string); let current = read_latest_activation(&container_dir)?; // Update continuity (crate::plugins::installer::ensure_update_continuity): a marketplace // update whose recorded repository / publisher / signing key differs from the offering one, // or that would downgrade the active version, is rejected unless the user explicitly // confirmed. Installs without recorded provenance stay unconstrained until the next // install records fresh provenance. if let (Some(expectation), Some(record)) = (expectation, current.as_ref()) { if !matches!(policy, PluginInstallPolicy::LocalDevelopment) { if let Some(provenance) = &record.provenance { ensure_update_continuity( provenance, &record.version, expectation.repository_id.as_deref(), &expectation.publisher, &expectation.signing_key_id, &version_string, allow_source_change, )?; } } } // Only the version the newest activation record resolves to *and* that is still a usable // install counts as "already installed". Directory existence alone is not enough: rollback // deliberately retains the version it replaces as the next rollback target, so an // installed-but-inactive directory has to stay replaceable, and a broken active directory // (missing or unparsable manifest) has to stay replaceable so Update can repair it. if !matches!(policy, PluginInstallPolicy::LocalDevelopment) && version_dir.exists() && current.as_ref().is_some_and(|record| record.version == version_string) && version_dir_is_usable(&version_dir, &manifest.id, &version_string) { return Err(format!("Plugin '{}' version {} is already installed", manifest.id, version)); } let previous_version = current .as_ref() .and_then(|record| { if record.version == version_string { record.previous_version.clone() } else { Some(record.version.clone()) } }) // Never record a rollback target that cannot be rolled back to: `rollback_locked` // requires versions//manifest.json to have the matching identity. .filter(|previous| { previous != &version_string && version_dir_is_usable(&versions_dir.join(previous), &manifest.id, previous) }); let replaced_version_dir = if version_dir.exists() { let mut backup = versions_dir.join(format!(".{version_string}.replaced")); let mut suffix = 0u32; while backup.exists() { suffix = suffix.saturating_add(1); backup = versions_dir.join(format!(".{version_string}.replaced-{suffix}")); } std::fs::rename(&version_dir, &backup).map_err(|error| { format!("Failed to prepare plugin '{}' version {} replacement: {error}", manifest.id, version) })?; Some(backup) } else { None }; if let Err(error) = rename_with_transient_lock_retry(&package_dir, &version_dir) { let mut message = format!("Failed to store plugin '{}' version {}: {error}", manifest.id, version); if let Some(backup) = &replaced_version_dir { if let Err(restore) = rename_with_transient_lock_retry(backup, &version_dir) { message.push_str(&format!("; previous copy kept at {}: {restore}", backup.display())); } } return Err(message); } let provenance = match expectation { Some(expectation) => PluginInstallProvenance { repository_id: expectation.repository_id.clone(), publisher: Some(expectation.publisher.clone()), signing_key_id: Some(expectation.signing_key_id.clone()), source: PluginInstallSource::Marketplace, }, None => { let previous = current.as_ref().and_then(|record| record.provenance.as_ref()); PluginInstallProvenance { // A file/URL replacement carries the recorded repository forward so a // non-marketplace overwrite cannot silently erase a marketplace install's // source identity; publisher and signing key record what is actually // being installed now. repository_id: previous.and_then(|provenance| provenance.repository_id.clone()), publisher: Some(manifest.publisher.clone()), signing_key_id: match &signature { PluginSignatureStatus::Trusted { key_id } => Some(key_id.clone()), PluginSignatureStatus::Unsigned => None, }, source, } } }; let activation = PluginActivationRecord { sequence: current.as_ref().map_or(1, |record| record.sequence.saturating_add(1)), version: version_string, previous_version: previous_version.clone(), package_sha256: package_sha256.clone(), activated_at: Utc::now().to_rfc3339(), provenance: Some(provenance), }; if let Err(error) = write_activation_record(&container_dir, &activation) { let _ = std::fs::remove_dir_all(&version_dir); let mut message = error; if let Some(backup) = &replaced_version_dir { if let Err(restore) = rename_with_transient_lock_retry(backup, &version_dir) { message.push_str(&format!("; previous copy kept at {}: {restore}", backup.display())); } } return Err(message); } if let Some(backup) = replaced_version_dir { if let Err(error) = std::fs::remove_dir_all(backup) { log::warn!("Failed to remove replaced plugin version backup: {error}"); } } if let Err(error) = prune_plugin_history(&container_dir, &activation) { log::warn!("Failed to prune plugin '{}' install history: {error}", manifest.id); } let plugin = InstalledPlugin::new(manifest, version_dir, &self.app_version) .with_provenance(activation.provenance.clone()); Ok(PluginInstallResult { plugin, previous_version, package_sha256, signature, _update_guard: update_guard }) } fn rollback_locked(&self, plugin_id: &str) -> Result { let update_guard = self.lifecycle.as_ref().map(|lifecycle| lifecycle.begin_update(plugin_id)).transpose()?; let container_dir = self.root_dir.join(plugin_id); let current = read_latest_activation(&container_dir)? .ok_or_else(|| format!("Plugin '{plugin_id}' does not have an active version"))?; let previous_version = current .previous_version .clone() .ok_or_else(|| format!("Plugin '{plugin_id}' does not have a rollback version"))?; let version_dir = container_dir.join(VERSIONS_DIR).join(&previous_version); let manifest_path = version_dir.join("manifest.json"); let manifest: PluginManifest = serde_json::from_slice( &std::fs::read(&manifest_path) .map_err(|error| format!("Rollback version {previous_version} is incomplete: {error}"))?, ) .map_err(|error| format!("Rollback manifest is invalid: {error}"))?; if manifest.id != plugin_id || manifest.version != previous_version { return Err(format!("Rollback version {previous_version} does not match plugin '{plugin_id}'")); } let plugin = InstalledPlugin::new(manifest, version_dir, &self.app_version); if !plugin.compatibility.compatible { return Err(format!( "Rollback version {previous_version} is incompatible: {}", plugin.compatibility.errors.join("; ") )); } let target_record = read_latest_activation_for_version(&container_dir, &previous_version)?; let plugin = plugin.with_provenance(target_record.as_ref().and_then(|record| record.provenance.clone())); let activation = PluginActivationRecord { sequence: current.sequence.saturating_add(1), version: previous_version.clone(), previous_version: Some(current.version), package_sha256: target_record .as_ref() .map_or_else(|| "legacy-unmanaged".to_string(), |record| record.package_sha256.clone()), activated_at: Utc::now().to_rfc3339(), // Roll the target version's own provenance forward: a rollback re-activates that // version, so its recorded source identity is the truthful one to keep guarding with. provenance: target_record.as_ref().and_then(|record| record.provenance.clone()), }; write_activation_record(&container_dir, &activation)?; if let Err(error) = prune_plugin_history(&container_dir, &activation) { log::warn!("Failed to prune plugin '{plugin_id}' rollback history: {error}"); } Ok(PluginRollbackResult { plugin, previous_version, _update_guard: update_guard }) } } /// `migrate_legacy_container` stores a migrated flat container under a synthetic /// `0.0.0-legacy.` directory name while the manifest inside keeps its original version string, so /// for those directories the name carries no version identity to compare against. Treating them as /// unusable would drop them from `previous_version` and let `prune_plugin_history` delete the only copy /// of that version. The plugin id check still applies to them: only the version identity is synthetic. const LEGACY_STORAGE_VERSION_PREFIX: &str = "0.0.0-legacy."; fn is_legacy_storage_version(version: &str) -> bool { version .strip_prefix(LEGACY_STORAGE_VERSION_PREFIX) .is_some_and(|suffix| suffix.len() == 12 && suffix.bytes().all(|byte| byte.is_ascii_hexdigit())) } /// True when `versions/` has the manifest identity that this store location advertises. /// `rollback_locked` rejects a parsed manifest whose id or version differs, so the installer must /// not retain it as an active install or as a rollback target either. Legacy containers are the one /// exception: their directory name is synthetic, so only the plugin id is checked against them. fn version_dir_is_usable(version_dir: &Path, plugin_id: &str, version: &str) -> bool { std::fs::read(version_dir.join("manifest.json")).is_ok_and(|raw| { serde_json::from_slice::(&raw).is_ok_and(|manifest| { manifest.id == plugin_id && (manifest.version == version || is_legacy_storage_version(version)) }) }) } pub(super) fn resolve_active_plugin_dir(container_dir: &Path) -> Result, String> { if container_dir.join("manifest.json").is_file() { return Ok(Some(container_dir.to_path_buf())); } let Some(activation) = read_latest_activation(container_dir)? else { return Ok(None); }; Version::parse(&activation.version) .map_err(|error| format!("Plugin activation has invalid version '{}': {error}", activation.version))?; let path = container_dir.join(VERSIONS_DIR).join(&activation.version); if !path.join("manifest.json").is_file() { return Err(format!("Active plugin version is incomplete: {}", path.display())); } Ok(Some(path)) } fn extract_package(package: &[u8], destination: &Path) -> Result, String> { let mut archive = zip::ZipArchive::new(Cursor::new(package)).map_err(|error| format!("Invalid .dbxp archive: {error}"))?; if archive.len() > MAX_ARCHIVE_ENTRIES { return Err(format!("Plugin package contains more than {MAX_ARCHIVE_ENTRIES} entries")); } let mut extracted = HashSet::new(); let mut normalized_names = HashSet::new(); let mut total_size = 0u64; for index in 0..archive.len() { let mut entry = archive.by_index(index).map_err(|error| error.to_string())?; let enclosed = entry.enclosed_name().ok_or_else(|| format!("Plugin package contains unsafe path '{}'", entry.name()))?; validate_package_path(&enclosed)?; let path_key = path_key(&enclosed)?; let normalized = path_key.to_ascii_lowercase(); if !normalized_names.insert(normalized) { return Err(format!("Plugin package contains duplicate path '{path_key}'")); } if entry.is_dir() { std::fs::create_dir_all(destination.join(&enclosed)).map_err(|error| error.to_string())?; continue; } if entry.unix_mode().is_some_and(|mode| mode & 0o170000 == 0o120000) { return Err(format!("Plugin package cannot contain symbolic link '{path_key}'")); } if entry.size() > MAX_FILE_BYTES { return Err(format!("Plugin package file '{path_key}' exceeds {MAX_FILE_BYTES} bytes")); } total_size = total_size.checked_add(entry.size()).ok_or("Plugin package uncompressed size overflow")?; if total_size > MAX_UNCOMPRESSED_BYTES { return Err(format!("Plugin package expands beyond {MAX_UNCOMPRESSED_BYTES} bytes")); } let output = destination.join(&enclosed); if let Some(parent) = output.parent() { std::fs::create_dir_all(parent).map_err(|error| error.to_string())?; } let mut target = OpenOptions::new() .write(true) .create_new(true) .open(&output) .map_err(|error| format!("Failed to extract '{path_key}': {error}"))?; let copied = std::io::copy(&mut entry.by_ref().take(MAX_FILE_BYTES + 1), &mut target) .map_err(|error| format!("Failed to extract '{path_key}': {error}"))?; if copied > MAX_FILE_BYTES { return Err(format!("Plugin package file '{path_key}' exceeds {MAX_FILE_BYTES} bytes")); } #[cfg(unix)] if let Some(mode) = entry.unix_mode() { use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(&output, std::fs::Permissions::from_mode(mode & 0o777)) .map_err(|error| error.to_string())?; } extracted.insert(path_key); } Ok(extracted) } fn verify_package_checksums(destination: &Path, extracted: &HashSet, raw: &[u8]) -> Result<(), String> { let checksums: PluginPackageChecksums = serde_json::from_slice(raw).map_err(|error| format!("Failed to parse {PLUGIN_CHECKSUMS_FILE}: {error}"))?; if checksums.algorithm != "sha256" { return Err(format!("Unsupported plugin checksum algorithm '{}'", checksums.algorithm)); } let expected_files = extracted .iter() .filter(|path| path.as_str() != PLUGIN_CHECKSUMS_FILE && path.as_str() != PLUGIN_SIGNATURE_FILE) .cloned() .collect::>(); let declared_files = checksums.files.keys().cloned().collect::>(); if expected_files != declared_files { let missing = expected_files.difference(&declared_files).cloned().collect::>(); let extra = declared_files.difference(&expected_files).cloned().collect::>(); return Err(format!("Plugin checksums do not cover the package exactly; missing={missing:?}, extra={extra:?}")); } for (relative, expected) in checksums.files { let path = safe_checksum_path(destination, &relative)?; let actual = sha256_file(&path)?; if !expected.eq_ignore_ascii_case(&actual) { return Err(format!("Plugin checksum mismatch for '{relative}'")); } } Ok(()) } fn verify_package_signature( destination: &Path, checksums: &[u8], policy: PluginInstallPolicy, trust_store: &PluginTrustStore, ) -> Result { let signature_path = destination.join(PLUGIN_SIGNATURE_FILE); match std::fs::read(&signature_path) { Ok(raw) => { let signature: PluginPackageSignature = serde_json::from_slice(&raw) .map_err(|error| format!("Failed to parse {PLUGIN_SIGNATURE_FILE}: {error}"))?; trust_store.verify(&signature, checksums) } Err(error) if error.kind() == std::io::ErrorKind::NotFound => match policy { PluginInstallPolicy::LocalDevelopment => Ok(PluginSignatureStatus::Unsigned), PluginInstallPolicy::LocalSigned => Err("Plugin package must have a trusted Ed25519 signature".to_string()), }, Err(error) => Err(error.to_string()), } } fn validate_package_expectation( manifest: &PluginManifest, signature: &PluginSignatureStatus, expectation: &PluginPackageExpectation, ) -> Result<(), String> { if manifest.id != expectation.id { return Err(format!("Marketplace package id '{}' does not match catalog id '{}'", manifest.id, expectation.id)); } if manifest.version != expectation.version { return Err(format!( "Marketplace package version '{}' does not match catalog version '{}'", manifest.version, expectation.version )); } if manifest.publisher != expectation.publisher { return Err(format!( "Marketplace package publisher '{}' does not match catalog publisher '{}'", manifest.publisher, expectation.publisher )); } let permissions = manifest.permissions.iter().cloned().collect::>(); if permissions != expectation.permissions { return Err(format!( "Marketplace package permissions {:?} do not match catalog permissions {:?}", permissions, expectation.permissions )); } let PluginSignatureStatus::Trusted { key_id } = signature else { return Err("Marketplace package must have a trusted signature".to_string()); }; if key_id != &expectation.signing_key_id { return Err(format!( "Marketplace package repository signing key '{}' does not match repository key '{}' declared by the catalog", key_id, expectation.signing_key_id )); } Ok(()) } fn read_latest_activation(container_dir: &Path) -> Result, String> { let activations_dir = container_dir.join(ACTIVATIONS_DIR); let entries = match std::fs::read_dir(&activations_dir) { Ok(entries) => entries, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), Err(error) => return Err(error.to_string()), }; let mut latest: Option = None; for entry in entries { let entry = entry.map_err(|error| error.to_string())?; if !entry.file_type().map_err(|error| error.to_string())?.is_file() || !is_activation_record_file(&entry.path()) { continue; } let raw = std::fs::read(entry.path()).map_err(|error| error.to_string())?; let record: PluginActivationRecord = serde_json::from_slice(&raw) .map_err(|error| format!("Invalid plugin activation {}: {error}", entry.path().display()))?; if latest.as_ref().is_none_or(|current| record.sequence > current.sequence) { latest = Some(record); } } Ok(latest) } fn read_latest_activation_for_version( container_dir: &Path, version: &str, ) -> Result, String> { let activations_dir = container_dir.join(ACTIVATIONS_DIR); let entries = match std::fs::read_dir(&activations_dir) { Ok(entries) => entries, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), Err(error) => return Err(error.to_string()), }; let mut latest: Option = None; for entry in entries { let entry = entry.map_err(|error| error.to_string())?; if !entry.file_type().map_err(|error| error.to_string())?.is_file() || !is_activation_record_file(&entry.path()) { continue; } let record: PluginActivationRecord = serde_json::from_slice(&std::fs::read(entry.path()).map_err(|error| error.to_string())?) .map_err(|error| format!("Invalid plugin activation {}: {error}", entry.path().display()))?; if record.version == version && latest.as_ref().is_none_or(|current| record.sequence > current.sequence) { latest = Some(record); } } Ok(latest) } fn prune_plugin_history(container_dir: &Path, current: &PluginActivationRecord) -> Result<(), String> { let retained_versions = std::iter::once(current.version.as_str()).chain(current.previous_version.as_deref()).collect::>(); let versions_dir = container_dir.join(VERSIONS_DIR); if let Ok(entries) = std::fs::read_dir(&versions_dir) { for entry in entries { let entry = entry.map_err(|error| error.to_string())?; if !entry.file_type().map_err(|error| error.to_string())?.is_dir() { continue; } let version = entry.file_name(); let version = version.to_string_lossy(); if !retained_versions.contains(version.as_ref()) { std::fs::remove_dir_all(entry.path()).map_err(|error| error.to_string())?; } } sync_directory(&versions_dir)?; } let activations_dir = container_dir.join(ACTIVATIONS_DIR); let entries = match std::fs::read_dir(&activations_dir) { Ok(entries) => entries, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()), Err(error) => return Err(error.to_string()), }; let mut records = Vec::new(); let mut latest_sequences = BTreeMap::::new(); for entry in entries { let entry = entry.map_err(|error| error.to_string())?; if !entry.file_type().map_err(|error| error.to_string())?.is_file() || !is_activation_record_file(&entry.path()) { continue; } let record: PluginActivationRecord = serde_json::from_slice(&std::fs::read(entry.path()).map_err(|error| error.to_string())?) .map_err(|error| format!("Invalid plugin activation {}: {error}", entry.path().display()))?; if retained_versions.contains(record.version.as_str()) { latest_sequences .entry(record.version.clone()) .and_modify(|sequence| *sequence = (*sequence).max(record.sequence)) .or_insert(record.sequence); } records.push((entry.path(), record)); } for (path, record) in records { let keep = retained_versions.contains(record.version.as_str()) && latest_sequences.get(&record.version).is_some_and(|sequence| *sequence == record.sequence); if !keep { std::fs::remove_file(path).map_err(|error| error.to_string())?; } } sync_directory(&activations_dir) } fn is_activation_record_file(path: &Path) -> bool { let Some(name) = path.file_name().and_then(|name| name.to_str()) else { return false; }; let Some(stem) = name.strip_suffix(".json") else { return false; }; let Some((sequence, unique)) = stem.split_once('-') else { return false; }; sequence.len() == 20 && sequence.bytes().all(|byte| byte.is_ascii_digit()) && !unique.is_empty() } fn migrate_legacy_container(container_dir: &Path) -> Result<(), String> { let manifest_path = container_dir.join("manifest.json"); if !manifest_path.is_file() { return Ok(()); } let manifest: PluginManifest = serde_json::from_slice( &std::fs::read(&manifest_path) .map_err(|error| format!("Failed to read legacy plugin {}: {error}", manifest_path.display()))?, ) .map_err(|error| format!("Failed to parse legacy plugin {}: {error}", manifest_path.display()))?; let storage_version = Version::parse(&manifest.version) .map(|version| version.to_string()) .unwrap_or_else(|_| format!("0.0.0-legacy.{}", &sha256_hex(manifest.version.as_bytes())[..12])); let parent = container_dir.parent().ok_or("Plugin container has no parent")?; let temporary = parent.join(format!(".legacy-{}-{}", manifest.id, uuid::Uuid::new_v4())); std::fs::rename(container_dir, &temporary) .map_err(|error| format!("Failed to stage legacy plugin '{}': {error}", manifest.id))?; let versions_dir = container_dir.join(VERSIONS_DIR); let activations_dir = container_dir.join(ACTIVATIONS_DIR); let version_dir = versions_dir.join(&storage_version); let migration = (|| { std::fs::create_dir_all(&versions_dir).map_err(|error| error.to_string())?; std::fs::create_dir_all(&activations_dir).map_err(|error| error.to_string())?; std::fs::rename(&temporary, &version_dir).map_err(|error| error.to_string())?; write_activation_record( container_dir, &PluginActivationRecord { sequence: 1, version: storage_version, previous_version: None, package_sha256: "legacy-unmanaged".to_string(), activated_at: Utc::now().to_rfc3339(), provenance: None, }, ) })(); if let Err(error) = migration { let _ = std::fs::remove_dir_all(container_dir); let _ = std::fs::rename(&temporary, container_dir); return Err(format!("Failed to migrate legacy plugin '{}': {error}", manifest.id)); } Ok(()) } fn write_activation_record(container_dir: &Path, activation: &PluginActivationRecord) -> Result<(), String> { let activations_dir = container_dir.join(ACTIVATIONS_DIR); std::fs::create_dir_all(&activations_dir).map_err(|error| error.to_string())?; let filename = format!("{:020}-{}.json", activation.sequence, uuid::Uuid::new_v4()); let final_path = activations_dir.join(filename); let temporary_path = activations_dir.join(format!(".{}.tmp", uuid::Uuid::new_v4())); let bytes = serde_json::to_vec_pretty(activation).map_err(|error| error.to_string())?; let mut file = OpenOptions::new().write(true).create_new(true).open(&temporary_path).map_err(|error| error.to_string())?; file.write_all(&bytes).map_err(|error| error.to_string())?; file.sync_all().map_err(|error| error.to_string())?; std::fs::rename(&temporary_path, &final_path).map_err(|error| error.to_string())?; sync_directory(&activations_dir)?; Ok(()) } fn write_json_atomically(path: &Path, value: &T) -> Result<(), String> { let parent = path.parent().ok_or("Plugin trust store path has no parent")?; std::fs::create_dir_all(parent).map_err(|error| error.to_string())?; let temporary = parent.join(format!(".{}.tmp", uuid::Uuid::new_v4())); let mut file = OpenOptions::new().write(true).create_new(true).open(&temporary).map_err(|error| error.to_string())?; file.write_all(&serde_json::to_vec_pretty(value).map_err(|error| error.to_string())?) .map_err(|error| error.to_string())?; file.sync_all().map_err(|error| error.to_string())?; if path.exists() { std::fs::remove_file(path).map_err(|error| error.to_string())?; } std::fs::rename(&temporary, path).map_err(|error| error.to_string())?; sync_directory(parent) } fn open_install_lock(root_dir: &Path) -> Result { std::fs::create_dir_all(root_dir).map_err(|error| error.to_string())?; OpenOptions::new() .read(true) .write(true) .create(true) .truncate(false) .open(root_dir.join(INSTALL_LOCK_FILE)) .map_err(|error| error.to_string()) } // Antivirus scanners briefly hold handles on freshly extracted plugin binaries, which fails // directory renames with ERROR_ACCESS_DENIED (5) or ERROR_SHARING_VIOLATION (32); the scan // normally finishes well inside this retry window. const TRANSIENT_LOCK_RETRY_DELAYS: [Duration; 3] = [Duration::from_millis(200), Duration::from_millis(400), Duration::from_millis(800)]; fn rename_with_transient_lock_retry(src: &Path, dst: &Path) -> std::io::Result<()> { retry_transient_lock(&TRANSIENT_LOCK_RETRY_DELAYS, || std::fs::rename(src, dst)) } fn retry_transient_lock( delays: &[Duration], mut operation: impl FnMut() -> std::io::Result, ) -> std::io::Result { for delay in delays { match operation() { Ok(value) => return Ok(value), Err(error) if cfg!(windows) && is_windows_lock_error(&error) => std::thread::sleep(*delay), Err(error) => return Err(error), } } operation() } fn is_windows_lock_error(error: &std::io::Error) -> bool { matches!(error.raw_os_error(), Some(5 | 32)) } fn make_backend_executable(path: &Option) -> Result<(), String> { #[cfg(unix)] if let Some(path) = path { use std::os::unix::fs::PermissionsExt; let mut permissions = std::fs::metadata(path).map_err(|error| error.to_string())?.permissions(); permissions.set_mode(permissions.mode() | 0o700); std::fs::set_permissions(path, permissions).map_err(|error| error.to_string())?; } Ok(()) } fn safe_checksum_path(root: &Path, relative: &str) -> Result { let path = Path::new(relative); validate_package_path(path)?; Ok(root.join(path)) } fn validate_package_path(path: &Path) -> Result<(), String> { if path.as_os_str().is_empty() || path.is_absolute() { return Err("Plugin package paths must be non-empty and relative".to_string()); } if path.components().any(|component| !matches!(component, Component::Normal(_))) { return Err(format!("Plugin package contains unsafe path '{}'", path.display())); } Ok(()) } fn path_key(path: &Path) -> Result { validate_package_path(path)?; path.components() .map(|component| match component { Component::Normal(value) => value .to_str() .map(str::to_string) .ok_or_else(|| format!("Plugin package path is not UTF-8: {}", path.display())), _ => unreachable!(), }) .collect::, _>>() .map(|parts| parts.join("/")) } fn validate_plugin_id(plugin_id: &str) -> Result<(), String> { if plugin_id.is_empty() || plugin_id.len() > 128 { return Err("Plugin id must be between 1 and 128 bytes".to_string()); } let mut chars = plugin_id.chars(); if !matches!(chars.next(), Some(first) if first.is_ascii_lowercase() || first.is_ascii_digit()) || !chars.all(|character| { character.is_ascii_lowercase() || character.is_ascii_digit() || matches!(character, '.' | '-' | '_') }) { return Err("Plugin id must contain only lowercase letters, digits, '.', '-' or '_'".to_string()); } Ok(()) } pub(super) fn validate_key_id(key_id: &str) -> Result<(), String> { if key_id.is_empty() || key_id.len() > 128 || !key_id .chars() .all(|character| character.is_ascii_alphanumeric() || matches!(character, '.' | '-' | '_' | ':')) { return Err("Plugin signing key id contains unsupported characters".to_string()); } Ok(()) } fn sha256_file(path: &Path) -> Result { let mut file = File::open(path).map_err(|error| error.to_string())?; let mut digest = Sha256::new(); let mut buffer = [0u8; 64 * 1024]; loop { let read = file.read(&mut buffer).map_err(|error| error.to_string())?; if read == 0 { break; } digest.update(&buffer[..read]); } Ok(hex_digest(digest.finalize())) } fn sha256_hex(bytes: &[u8]) -> String { hex_digest(Sha256::digest(bytes)) } fn hex_digest(bytes: impl AsRef<[u8]>) -> String { use std::fmt::Write as _; bytes.as_ref().iter().fold(String::with_capacity(64), |mut output, byte| { let _ = write!(output, "{byte:02x}"); output }) } #[cfg(unix)] fn sync_directory(path: &Path) -> Result<(), String> { File::open(path).and_then(|directory| directory.sync_all()).map_err(|error| error.to_string()) } #[cfg(not(unix))] fn sync_directory(_path: &Path) -> Result<(), String> { Ok(()) } #[cfg(test)] mod tests { use std::collections::{BTreeMap, BTreeSet}; use std::io::{Cursor, Write}; use std::path::Path; use std::time::Duration; use base64::Engine; use ed25519_dalek::{Signer, SigningKey}; use zip::write::SimpleFileOptions; use super::{ is_activation_record_file, read_install_identity, retry_transient_lock, sha256_hex, validate_package_expectation, PluginInstallPolicy, PluginPackageExpectation, PluginPackageInstaller, PluginSignatureStatus, PluginTrustStore, ACTIVATIONS_DIR, PLUGIN_CHECKSUMS_FILE, PLUGIN_SIGNATURE_FILE, VERSIONS_DIR, }; use crate::plugins::{PluginManifest, PluginRegistry}; #[test] fn runtime_updates_and_rollbacks_preserve_active_connections_and_versions() { let root = tempfile::tempdir().unwrap(); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); let lifecycle = registry.lifecycle(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()) .with_lifecycle(lifecycle.clone()); let first = package("1.0.0", None, false); let second = package("1.1.0", None, false); installer.install_bytes(&first, PluginInstallPolicy::LocalDevelopment).unwrap(); let connection = lifecycle.begin_connection("sample.hello", "My connection").unwrap(); for bytes in [&first, &second] { let error = installer.install_bytes(bytes, PluginInstallPolicy::LocalDevelopment).unwrap_err(); assert!(error.contains("My connection")); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } assert!(!root.path().join("sample.hello/versions/1.1.0").exists()); drop(connection); let unrelated = lifecycle.begin_connection("other.plugin", "Unrelated connection").unwrap(); let installed = installer.install_bytes(&second, PluginInstallPolicy::LocalDevelopment).unwrap(); assert!(lifecycle.begin_connection("sample.hello", "New connection").is_err()); assert!(lifecycle.begin_operation("sample.hello").is_err()); drop(installed); let connection = lifecycle.begin_connection("sample.hello", "My connection").unwrap(); assert!(installer.rollback("sample.hello").unwrap_err().contains("My connection")); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.1.0"); drop(connection); let rollback = installer.rollback("sample.hello").unwrap(); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); assert!(lifecycle.begin_operation("sample.hello").is_err()); drop(rollback); assert!(lifecycle.begin_connection("sample.hello", "Reconnected").is_ok()); drop(unrelated); } #[test] fn runtime_install_file_and_signed_packages_share_the_update_guard() { let root = tempfile::tempdir().unwrap(); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); let lifecycle = registry.lifecycle(); let signer = SigningKey::from_bytes(&[23; 32]); let trust = PluginTrustStore::from_base64_keys(BTreeMap::from([( "test".to_string(), base64::engine::general_purpose::STANDARD.encode(signer.verifying_key().as_bytes()), )])) .unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", trust) .with_lifecycle(lifecycle.clone()); installer .install_bytes(&package("1.0.0", Some((&signer, "test")), false), PluginInstallPolicy::LocalSigned) .unwrap(); let bytes = package("1.1.0", Some((&signer, "test")), false); let package_path = root.path().join("update.dbxp"); std::fs::write(&package_path, &bytes).unwrap(); let operation = lifecycle.begin_operation("sample.hello").unwrap(); assert!(installer .install_file(&package_path, PluginInstallPolicy::LocalSigned) .unwrap_err() .contains("active operations")); let expectation = PluginPackageExpectation { repository_id: None, id: "sample.hello".to_string(), version: "1.1.0".to_string(), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "test".to_string(), }; assert!(installer .install_marketplace_bytes(&bytes, &expectation, false) .unwrap_err() .contains("active operations")); drop(operation); installer.install_marketplace_bytes(&bytes, &expectation, false).unwrap(); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.1.0"); } #[test] fn failed_runtime_update_releases_the_admission_guard() { let root = tempfile::tempdir().unwrap(); let lifecycle = crate::plugins::PluginLifecycle::default(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()) .with_lifecycle(lifecycle.clone()); installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); assert!(installer.rollback("sample.hello").is_err()); assert!(lifecycle.begin_connection("sample.hello", "Retry").is_ok()); assert!(installer.install_bytes(&package("1.1.0", None, true), PluginInstallPolicy::LocalDevelopment).is_err()); assert!(lifecycle.begin_update("sample.hello").is_ok()); } #[test] fn installs_versioned_package_and_rolls_back_atomically() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); let first = package("1.0.0", None, false); let second = package("1.1.0", None, false); installer.install_bytes(&first, PluginInstallPolicy::LocalDevelopment).unwrap(); let installed = installer.install_bytes(&second, PluginInstallPolicy::LocalDevelopment).unwrap(); assert_eq!(installed.previous_version.as_deref(), Some("1.0.0")); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.1.0"); let rollback = installer.rollback("sample.hello").unwrap(); assert_eq!(rollback.previous_version, "1.0.0"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } #[test] fn local_development_reinstalls_same_version_without_creating_a_self_rollback() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); let package = package("1.0.0", None, false); installer.install_bytes(&package, PluginInstallPolicy::LocalDevelopment).unwrap(); let reinstalled = installer.install_bytes(&package, PluginInstallPolicy::LocalDevelopment).unwrap(); assert_eq!(reinstalled.previous_version, None); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); assert_eq!(std::fs::read_dir(root.path().join("sample.hello").join(VERSIONS_DIR)).unwrap().count(), 1); } #[test] fn retains_only_active_and_rollback_versions() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); for version in ["1.0.0", "1.1.0", "1.2.0"] { installer.install_bytes(&package(version, None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); } let container = root.path().join("sample.hello"); let mut versions = std::fs::read_dir(container.join(VERSIONS_DIR)) .unwrap() .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned()) .collect::>(); versions.sort(); assert_eq!(versions, ["1.1.0", "1.2.0"]); assert_eq!( std::fs::read_dir(container.join(ACTIVATIONS_DIR)) .unwrap() .filter(|entry| entry.as_ref().is_ok_and(|entry| is_activation_record_file(&entry.path()))) .count(), 2 ); let rollback = installer.rollback("sample.hello").unwrap(); assert_eq!(rollback.plugin.manifest.version, "1.1.0"); assert_eq!(rollback.previous_version, "1.1.0"); } #[test] fn ignores_interrupted_activation_temp_files() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); let activations = root.path().join("sample.hello").join("activations"); std::fs::write(activations.join(".interrupted.tmp"), b"{").unwrap(); std::fs::write(activations.join("README.txt"), b"not an activation").unwrap(); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } #[test] fn installing_v1_migrates_legacy_flat_plugin_and_preserves_rollback() { let root = tempfile::tempdir().unwrap(); let legacy = root.path().join("sample.hello"); std::fs::create_dir_all(legacy.join("bin")).unwrap(); std::fs::write(legacy.join("bin/plugin"), b"legacy").unwrap(); std::fs::write( legacy.join("manifest.json"), serde_json::to_vec_pretty(&serde_json::json!({ "id": "sample.hello", "name": "Hello legacy", "version": "0.9.0", "protocol_version": 1, "executable": "bin/plugin", "drivers": [] })) .unwrap(), ) .unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); let installed = installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); assert_eq!(installed.previous_version.as_deref(), Some("0.9.0")); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); let rollback = installer.rollback("sample.hello").unwrap(); assert_eq!(rollback.previous_version, "0.9.0"); let legacy_plugin = registry.find_plugin("sample.hello").unwrap().unwrap(); assert_eq!(legacy_plugin.manifest.version, "0.9.0"); assert_eq!(std::fs::read(legacy_plugin.path.join("bin/plugin")).unwrap(), b"legacy"); } #[test] fn retains_a_legacy_version_directory_when_the_legacy_version_is_not_semver() { let root = tempfile::tempdir().unwrap(); let legacy = root.path().join("sample.hello"); std::fs::create_dir_all(legacy.join("bin")).unwrap(); std::fs::write(legacy.join("bin/plugin"), b"legacy").unwrap(); std::fs::write( legacy.join("manifest.json"), serde_json::to_vec_pretty(&serde_json::json!({ "id": "sample.hello", "name": "Hello legacy", "version": "0.9", "protocol_version": 1, "executable": "bin/plugin", "drivers": [] })) .unwrap(), ) .unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); let installed = installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); // A non-semver legacy version is migrated under a synthetic `0.0.0-legacy.` directory that // the manifest inside does not repeat, so the retained copy must still be recognised as the // rollback target instead of being pruned away as an unknown version. assert!( installed.previous_version.is_some(), "the migrated legacy version must be retained as the rollback target" ); let container = root.path().join("sample.hello"); let versions = sorted_version_dirs(&container); let legacy_storage_version = versions.iter().find(|version| version.as_str() != "1.0.0").unwrap(); assert_eq!(installed.previous_version.as_deref(), Some(legacy_storage_version.as_str())); let mut expected = vec!["1.0.0".to_string(), legacy_storage_version.clone()]; expected.sort(); assert_eq!(versions, expected); assert!(container.join(VERSIONS_DIR).join(legacy_storage_version).join("manifest.json").is_file()); } #[test] fn strict_policy_requires_and_verifies_trusted_signature() { let root = tempfile::tempdir().unwrap(); let signing_key = SigningKey::from_bytes(&[7u8; 32]); let mut keys = BTreeMap::new(); keys.insert( "sample-key".to_string(), base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()), ); let trust = PluginTrustStore::from_base64_keys(keys).unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", trust); let expectation = PluginPackageExpectation { repository_id: None, id: "sample.hello".to_string(), version: "1.0.0".to_string(), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; let unsigned = package("1.0.0", None, false); assert!(installer.install_marketplace_bytes(&unsigned, &expectation, false).is_err()); let signed = package("1.0.0", Some((&signing_key, "sample-key")), false); let result = installer.install_marketplace_bytes(&signed, &expectation, false).unwrap(); assert_eq!(result.signature, PluginSignatureStatus::Trusted { key_id: "sample-key".to_string() }); } #[test] fn local_installer_loads_official_keys_without_persisting_them() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); assert!(installer.trust_store.keys.contains_key("dbx-store-release-2026")); assert!(installer.trust_store.keys.contains_key("dbx-store-preview-2026")); assert!(PluginTrustStore::list_base64_keys(root.path()).unwrap().is_empty()); assert!(!root.path().join(".trust").exists()); } #[test] fn local_installer_rejects_forged_official_signatures() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); let forged_key = SigningKey::from_bytes(&[11u8; 32]); let package_path = root.path().join("forged.dbxp"); std::fs::write(&package_path, package("1.0.0", Some((&forged_key, "dbx-store-release-2026")), false)).unwrap(); for policy in [PluginInstallPolicy::LocalSigned, PluginInstallPolicy::LocalDevelopment] { let error = installer.install_file(&package_path, policy).unwrap_err(); assert_eq!(error, "Plugin package signature verification failed"); } assert!(!root.path().join("sample.hello").exists()); } #[test] fn local_installer_preserves_custom_key_trust() { let root = tempfile::tempdir().unwrap(); let signing_key = SigningKey::from_bytes(&[9u8; 32]); let public_key = base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()); PluginTrustStore::save_base64_key(root.path(), "sample-repository", &public_key).unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); let package_path = root.path().join("custom.dbxp"); std::fs::write(&package_path, package("1.0.0", Some((&signing_key, "sample-repository")), false)).unwrap(); let installed = installer.install_file(&package_path, PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(installed.signature, PluginSignatureStatus::Trusted { key_id: "sample-repository".to_string() }); assert!(installer.trust_store.keys.contains_key("dbx-store-release-2026")); assert_eq!(PluginTrustStore::list_base64_keys(root.path()).unwrap().len(), 1); } #[test] fn local_installer_rejects_unknown_signed_packages() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); let signing_key = SigningKey::from_bytes(&[9u8; 32]); let package = package("1.0.0", Some((&signing_key, "unknown-release")), false); for policy in [PluginInstallPolicy::LocalSigned, PluginInstallPolicy::LocalDevelopment] { let error = installer.install_bytes(&package, policy).unwrap_err(); assert_eq!(error, "Plugin package is signed by untrusted key 'unknown-release'"); } assert!(!root.path().join("sample.hello").exists()); } #[test] fn local_installer_rejects_official_key_conflicts() { let root = tempfile::tempdir().unwrap(); let forged_key = SigningKey::from_bytes(&[11u8; 32]); let public_key = base64::engine::general_purpose::STANDARD.encode(forged_key.verifying_key().as_bytes()); PluginTrustStore::save_base64_key(root.path(), "dbx-store-release-2026", &public_key).unwrap(); let error = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67") .err() .expect("a custom key must not override an official signing key"); assert!(error.contains("'dbx-store-release-2026' already exists with a different public key")); } #[test] fn local_installer_accepts_matching_official_keys() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); let official_key = installer.trust_store.keys.get("dbx-store-release-2026").unwrap(); let public_key = base64::engine::general_purpose::STANDARD.encode(official_key.as_bytes()); PluginTrustStore::save_base64_key(root.path(), "dbx-store-release-2026", &public_key).unwrap(); let reloaded = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); assert_eq!(reloaded.trust_store.keys.get("dbx-store-release-2026"), Some(official_key)); assert_eq!(PluginTrustStore::list_base64_keys(root.path()).unwrap().len(), 1); } #[test] fn local_installer_enforces_unsigned_policy() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::new(root.path().to_path_buf(), "0.5.67").unwrap(); let unsigned = package("1.0.0", None, false); assert!(installer.install_bytes(&unsigned, PluginInstallPolicy::LocalSigned).is_err()); let installed = installer.install_bytes(&unsigned, PluginInstallPolicy::LocalDevelopment).unwrap(); assert_eq!(installed.signature, PluginSignatureStatus::Unsigned); } #[test] fn marketplace_expectation_binds_manifest_and_signing_identity() { let manifest: PluginManifest = serde_json::from_value(serde_json::json!({ "manifest_version": 1, "id": "sample.hello", "name": "Hello", "version": "1.0.0", "publisher": "sample", "permissions": ["host.events"] })) .unwrap(); let signature = PluginSignatureStatus::Trusted { key_id: "sample-key".to_string() }; let expectation = PluginPackageExpectation { repository_id: None, id: "sample.hello".to_string(), version: "1.0.0".to_string(), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; validate_package_expectation(&manifest, &signature, &expectation).unwrap(); let mut mismatch = expectation.clone(); mismatch.id = "sample.replaced".to_string(); assert!(validate_package_expectation(&manifest, &signature, &mismatch).unwrap_err().contains("catalog id")); let mut mismatch = expectation.clone(); mismatch.publisher = "attacker".to_string(); assert!(validate_package_expectation(&manifest, &signature, &mismatch) .unwrap_err() .contains("catalog publisher")); let mut mismatch = expectation; mismatch.signing_key_id = "attacker-key".to_string(); assert!(validate_package_expectation(&manifest, &signature, &mismatch).unwrap_err().contains("repository key")); } #[test] fn trusted_repository_keys_roundtrip_and_can_be_removed() { let root = tempfile::tempdir().unwrap(); let signing_key = SigningKey::from_bytes(&[9u8; 32]); let public_key = base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()); PluginTrustStore::save_base64_key(root.path(), "sample-repository", &public_key).unwrap(); assert_eq!( PluginTrustStore::list_base64_keys(root.path()).unwrap(), vec![super::PluginTrustedKey { key_id: "sample-repository".to_string(), public_key: public_key.clone() }] ); assert!(PluginTrustStore::load(root.path()).unwrap().keys.contains_key("sample-repository")); let replacement = base64::engine::general_purpose::STANDARD .encode(SigningKey::from_bytes(&[10u8; 32]).verifying_key().as_bytes()); assert!(PluginTrustStore::save_base64_key(root.path(), "sample-repository", &replacement) .unwrap_err() .contains("remove it before rotating")); PluginTrustStore::remove_key(root.path(), "sample-repository").unwrap(); assert!(PluginTrustStore::list_base64_keys(root.path()).unwrap().is_empty()); assert!(!PluginTrustStore::load(root.path()).unwrap().keys.contains_key("sample-repository")); } #[test] fn rejects_checksum_mismatch_and_path_traversal() { let root = tempfile::tempdir().unwrap(); let installer = PluginPackageInstaller::with_trust_store(root.path().to_path_buf(), "0.5.67", PluginTrustStore::default()); let tampered = package("1.0.0", None, true); assert!(installer.install_bytes(&tampered, PluginInstallPolicy::LocalDevelopment).is_err()); let mut output = Cursor::new(Vec::new()); { let mut zip = zip::ZipWriter::new(&mut output); zip.start_file("../escape", SimpleFileOptions::default()).unwrap(); zip.write_all(b"bad").unwrap(); zip.finish().unwrap(); } assert!(installer.install_bytes(output.get_ref(), PluginInstallPolicy::LocalDevelopment).is_err()); } fn signed_installer(root: &Path, seed: [u8; 32]) -> (PluginPackageInstaller, SigningKey) { let signing_key = SigningKey::from_bytes(&seed); let mut keys = BTreeMap::new(); keys.insert( "sample-key".to_string(), base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()), ); let installer = PluginPackageInstaller::with_trust_store( root.to_path_buf(), "0.5.67", PluginTrustStore::from_base64_keys(keys).unwrap(), ); (installer, signing_key) } #[test] fn rejects_source_changed_update_unless_confirmed() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [21u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); let expectation = |repository: &str, version: &str| PluginPackageExpectation { id: "sample.hello".to_string(), version: version.to_string(), repository_id: Some(repository.to_string()), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; installer.install_marketplace_bytes(&signed("1.0.0"), &expectation("repo-a", "1.0.0"), false).unwrap(); // The recorded install came from repo-a; a repo-b update needs the explicit confirmation. let rejected = installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("repo-b", "1.1.0"), false).unwrap_err(); assert!(rejected.contains("source change requires confirmation"), "{rejected}"); assert_eq!(read_install_identity(root.path(), "sample.hello").unwrap().unwrap().version, "1.0.0"); let confirmed = installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("repo-b", "1.1.0"), true).unwrap(); assert_eq!( confirmed.plugin.provenance.as_ref().and_then(|provenance| provenance.repository_id.clone()).as_deref(), Some("repo-b") ); // A downgrade below the confirmed active version needs the same explicit confirmation. let downgraded = installer.install_marketplace_bytes(&signed("1.0.5"), &expectation("repo-b", "1.0.5"), false).unwrap_err(); assert!(downgraded.contains("downgrade"), "{downgraded}"); } #[test] fn rollback_carries_the_target_versions_provenance_forward() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [22u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); let expectation = |repository: &str, version: &str| PluginPackageExpectation { id: "sample.hello".to_string(), version: version.to_string(), repository_id: Some(repository.to_string()), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; installer.install_marketplace_bytes(&signed("1.0.0"), &expectation("repo-a", "1.0.0"), false).unwrap(); installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("repo-b", "1.1.0"), true).unwrap(); assert_eq!(installer.rollback("sample.hello").unwrap().previous_version, "1.0.0"); // After rolling back to the repo-a version, the recorded provenance is repo-a again, so a // repo-a update proceeds without confirmation while repo-b still requires one. let identity = read_install_identity(root.path(), "sample.hello").unwrap().unwrap(); assert_eq!(identity.version, "1.0.0"); assert_eq!(identity.provenance.and_then(|provenance| provenance.repository_id), Some("repo-a".to_string())); installer.install_marketplace_bytes(&signed("1.2.0"), &expectation("repo-a", "1.2.0"), false).unwrap(); let rejected = installer.install_marketplace_bytes(&signed("1.3.0"), &expectation("repo-b", "1.3.0"), false).unwrap_err(); assert!(rejected.contains("source change requires confirmation"), "{rejected}"); } /// Rewrites the newest activation record without its `provenance` field: the on-disk shape an /// activation written by a build that predates provenance has. fn strip_latest_activation_provenance(container: &Path) { let mut records = std::fs::read_dir(container.join(ACTIVATIONS_DIR)) .unwrap() .map(|entry| entry.unwrap().path()) .filter(|path| is_activation_record_file(path)) .collect::>(); records.sort(); let path = records.pop().expect("activation record"); let mut value: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); assert!(value.as_object_mut().unwrap().remove("provenance").is_some()); std::fs::write(&path, serde_json::to_vec_pretty(&value).unwrap()).unwrap(); } #[test] fn a_pre_provenance_activation_stays_unconstrained_until_the_next_install() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [23u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); let expectation = |repository: &str, version: &str| PluginPackageExpectation { id: "sample.hello".to_string(), version: version.to_string(), repository_id: Some(repository.to_string()), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; installer.install_marketplace_bytes(&signed("1.0.0"), &expectation("repo-a", "1.0.0"), false).unwrap(); strip_latest_activation_provenance(&root.path().join("sample.hello")); // An activation record without provenance still parses (serde default) and records no source. let identity = read_install_identity(root.path(), "sample.hello").unwrap().unwrap(); assert_eq!(identity.version, "1.0.0"); assert!(identity.provenance.is_none()); // Nothing was recorded, so the next install from any repository proceeds without a // confirmation and starts recording provenance again. let updated = installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("repo-b", "1.1.0"), false).unwrap(); assert_eq!( updated.plugin.provenance.and_then(|provenance| provenance.repository_id).as_deref(), Some("repo-b") ); } #[test] fn updating_a_plugin_leaves_its_data_directory_untouched() { let root = tempfile::tempdir().unwrap(); // The registry root sits beside plugin-data/, exactly like the app layout, so // `PluginRegistry::plugin_data_dir("sample.hello")` resolves to the path below. let plugins_root = root.path().join("plugins"); let (installer, signing_key) = signed_installer(&plugins_root, [24u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); let expectation = |repository: &str, version: &str| PluginPackageExpectation { id: "sample.hello".to_string(), version: version.to_string(), repository_id: Some(repository.to_string()), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; installer.install_marketplace_bytes(&signed("1.0.0"), &expectation("repo-a", "1.0.0"), false).unwrap(); let data_dir = root.path().join("plugin-data").join("sample.hello"); std::fs::create_dir_all(&data_dir).unwrap(); std::fs::write(data_dir.join("state.json"), b"{\"rows\":1}").unwrap(); installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("repo-a", "1.1.0"), false).unwrap(); installer.rollback("sample.hello").unwrap(); // Plugin user data lives outside the versioned container and must survive update + rollback. assert_eq!(std::fs::read(data_dir.join("state.json")).unwrap(), b"{\"rows\":1}"); } fn activation_record_count(container: &Path) -> usize { std::fs::read_dir(container.join(ACTIVATIONS_DIR)) .unwrap() .filter(|entry| entry.as_ref().is_ok_and(|entry| is_activation_record_file(&entry.path()))) .count() } fn sorted_version_dirs(container: &Path) -> Vec { let mut versions = std::fs::read_dir(container.join(VERSIONS_DIR)) .unwrap() .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned()) .collect::>(); versions.sort(); versions } #[test] fn reinstalls_retained_rollback_version_after_rollback_under_signed_policy() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [13u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); let expectation = |version: &str| PluginPackageExpectation { repository_id: None, id: "sample.hello".to_string(), version: version.to_string(), publisher: "sample".to_string(), permissions: BTreeSet::from(["host.events".to_string()]), signing_key_id: "sample-key".to_string(), }; installer.install_marketplace_bytes(&signed("1.0.0"), &expectation("1.0.0"), false).unwrap(); installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("1.1.0"), false).unwrap(); assert_eq!(installer.rollback("sample.hello").unwrap().previous_version, "1.0.0"); // 1.1.0 is installed but inactive after the rollback: reinstalling it has to replace the // retained directory instead of failing with "already installed". let reinstalled = installer.install_marketplace_bytes(&signed("1.1.0"), &expectation("1.1.0"), false).unwrap(); assert_eq!(reinstalled.previous_version.as_deref(), Some("1.0.0")); let container = root.path().join("sample.hello"); assert_eq!(sorted_version_dirs(&container), ["1.0.0", "1.1.0"]); assert_eq!(activation_record_count(&container), 2); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.1.0"); assert_eq!(installer.rollback("sample.hello").unwrap().previous_version, "1.0.0"); } #[test] fn rejects_reinstall_of_active_version_without_touching_the_store() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [19u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); let error = installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap_err(); assert!(error.contains("is already installed"), "{error}"); let container = root.path().join("sample.hello"); assert_eq!(sorted_version_dirs(&container), ["1.0.0"]); assert_eq!(activation_record_count(&container), 1); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } #[test] fn reinstalls_active_version_whose_manifest_is_missing() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [23u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); let container = root.path().join("sample.hello"); let version_dir = container.join(VERSIONS_DIR).join("1.0.0"); std::fs::remove_file(version_dir.join("manifest.json")).unwrap(); let repaired = installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(repaired.previous_version, None); assert!(version_dir.join("manifest.json").is_file()); assert_eq!(sorted_version_dirs(&container), ["1.0.0"]); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } #[test] fn reinstalls_active_version_whose_manifest_identity_is_wrong() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [27u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); let container = root.path().join("sample.hello"); let version_dir = container.join(VERSIONS_DIR).join("1.0.0"); let manifest_path = version_dir.join("manifest.json"); let mismatched_manifest = std::fs::read_to_string(&manifest_path) .unwrap() .replace("\"version\": \"1.0.0\"", "\"version\": \"1.0.1\""); std::fs::write(&manifest_path, mismatched_manifest).unwrap(); // A parseable manifest with the wrong identity cannot be activated or rolled back to, so // it must be repaired rather than satisfying the already-installed guard. let repaired = installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(repaired.previous_version, None); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); } #[test] fn does_not_record_a_rollback_target_whose_directory_is_missing() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [29u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); installer.install_bytes(&signed("1.1.0"), PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(installer.rollback("sample.hello").unwrap().previous_version, "1.0.0"); let container = root.path().join("sample.hello"); std::fs::remove_dir_all(container.join(VERSIONS_DIR).join("1.0.0")).unwrap(); let recovered = installer.install_bytes(&signed("1.1.0"), PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(recovered.previous_version, None); assert_eq!(sorted_version_dirs(&container), ["1.1.0"]); let registry = PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.67"); assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.1.0"); assert!(installer.rollback("sample.hello").unwrap_err().contains("does not have a rollback version")); } #[test] fn reinstalls_orphan_version_directory_without_activation_record() { let root = tempfile::tempdir().unwrap(); let (installer, signing_key) = signed_installer(root.path(), [31u8; 32]); let signed = |version: &str| package(version, Some((&signing_key, "sample-key")), false); installer.install_bytes(&signed("1.0.0"), PluginInstallPolicy::LocalSigned).unwrap(); let container = root.path().join("sample.hello"); let orphan = container.join(VERSIONS_DIR).join("1.1.0"); std::fs::create_dir_all(&orphan).unwrap(); std::fs::write(orphan.join("stale.txt"), b"interrupted").unwrap(); let installed = installer.install_bytes(&signed("1.1.0"), PluginInstallPolicy::LocalSigned).unwrap(); assert_eq!(installed.previous_version.as_deref(), Some("1.0.0")); assert!(!orphan.join("stale.txt").exists()); assert_eq!(sorted_version_dirs(&container), ["1.0.0", "1.1.0"]); assert_eq!(activation_record_count(&container), 2); } fn package(version: &str, signer: Option<(&SigningKey, &str)>, tamper: bool) -> Vec { let manifest = serde_json::json!({ "manifest_version": 1, "id": "sample.hello", "name": "Hello", "version": version, "publisher": "sample", "engines": { "dbx": ">=0.5.0", "host_api": "^1.0" }, "permissions": ["host.events"], "entrypoints": { "backend": { "protocol_versions": [1], "transport": "stdio-jsonl", "executable": "bin/plugin" } } }); let manifest = serde_json::to_vec_pretty(&manifest).unwrap(); let backend = b"#!/bin/sh\nexit 0\n".to_vec(); let mut files = BTreeMap::new(); files.insert("manifest.json".to_string(), manifest.clone()); files.insert("bin/plugin".to_string(), backend.clone()); let checksum_files = files.iter().map(|(path, bytes)| (path.clone(), sha256_hex(bytes))).collect::>(); let checksums = serde_json::to_vec_pretty(&serde_json::json!({ "algorithm": "sha256", "files": checksum_files })) .unwrap(); let signature = signer.map(|(key, key_id)| { serde_json::to_vec_pretty(&serde_json::json!({ "algorithm": "ed25519", "key_id": key_id, "signature": base64::engine::general_purpose::STANDARD.encode(key.sign(&checksums).to_bytes()) })) .unwrap() }); let mut output = Cursor::new(Vec::new()); { let mut zip = zip::ZipWriter::new(&mut output); for (path, mut bytes) in files { if tamper && path == "manifest.json" { bytes.push(b' '); } let options = if path == "bin/plugin" { SimpleFileOptions::default().unix_permissions(0o755) } else { SimpleFileOptions::default().unix_permissions(0o644) }; zip.start_file(path, options).unwrap(); zip.write_all(&bytes).unwrap(); } zip.start_file(PLUGIN_CHECKSUMS_FILE, SimpleFileOptions::default()).unwrap(); zip.write_all(&checksums).unwrap(); if let Some(signature) = signature { zip.start_file(PLUGIN_SIGNATURE_FILE, SimpleFileOptions::default()).unwrap(); zip.write_all(&signature).unwrap(); } zip.finish().unwrap(); } output.into_inner() } #[test] #[cfg(windows)] fn transient_lock_retry_recovers_from_windows_lock_errors() { use std::sync::atomic::{AtomicUsize, Ordering}; for code in [5, 32] { let attempts = AtomicUsize::new(0); let result = retry_transient_lock(&[Duration::ZERO, Duration::ZERO, Duration::ZERO], || { if attempts.fetch_add(1, Ordering::SeqCst) < 2 { Err(std::io::Error::from_raw_os_error(code)) } else { Ok(()) } }); assert!(result.is_ok()); assert_eq!(attempts.load(Ordering::SeqCst), 3); } } #[test] #[cfg(windows)] fn transient_lock_retry_returns_last_error_after_exhausting_delays() { use std::sync::atomic::{AtomicUsize, Ordering}; let attempts = AtomicUsize::new(0); let result: std::io::Result<()> = retry_transient_lock(&[Duration::ZERO], || { attempts.fetch_add(1, Ordering::SeqCst); Err(std::io::Error::from_raw_os_error(5)) }); assert_eq!(attempts.load(Ordering::SeqCst), 2); assert_eq!(result.unwrap_err().raw_os_error(), Some(5)); } #[test] fn transient_lock_retry_does_not_retry_other_errors() { use std::sync::atomic::{AtomicUsize, Ordering}; let attempts = AtomicUsize::new(0); let result: std::io::Result<()> = retry_transient_lock(&[Duration::ZERO; 3], || { attempts.fetch_add(1, Ordering::SeqCst); Err(std::io::Error::from_raw_os_error(2)) }); assert_eq!(attempts.load(Ordering::SeqCst), 1); assert_eq!(result.unwrap_err().raw_os_error(), Some(2)); } #[test] #[cfg(unix)] fn transient_lock_retry_treats_windows_lock_codes_as_final_on_unix() { use std::sync::atomic::{AtomicUsize, Ordering}; // Raw code 5 on Unix is EIO, not a Windows lock error, so the retry gate must leave it final. let attempts = AtomicUsize::new(0); let result: std::io::Result<()> = retry_transient_lock(&[Duration::ZERO; 3], || { attempts.fetch_add(1, Ordering::SeqCst); Err(std::io::Error::from_raw_os_error(5)) }); assert_eq!(attempts.load(Ordering::SeqCst), 1); assert_eq!(result.unwrap_err().raw_os_error(), Some(5)); } }