2097 lines
97 KiB
Rust
2097 lines
97 KiB
Rust
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<String>,
|
|
pub package_sha256: String,
|
|
pub signature: PluginSignatureStatus,
|
|
_update_guard: Option<PluginUsageGuard>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct PluginRollbackResult {
|
|
pub plugin: InstalledPlugin,
|
|
pub previous_version: String,
|
|
_update_guard: Option<PluginUsageGuard>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct PluginInstallResponse {
|
|
pub plugin: InstalledPluginInfo,
|
|
pub previous_version: Option<String>,
|
|
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<String, VerifyingKey>,
|
|
}
|
|
|
|
#[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<String, String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct PluginPackageChecksums {
|
|
algorithm: String,
|
|
files: BTreeMap<String, String>,
|
|
}
|
|
|
|
#[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<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub publisher: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub signing_key_id: Option<String>,
|
|
#[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<PluginInstallProvenance>,
|
|
}
|
|
|
|
#[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<String>,
|
|
package_sha256: String,
|
|
activated_at: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
provenance: Option<PluginInstallProvenance>,
|
|
}
|
|
|
|
pub struct PluginPackageInstaller {
|
|
root_dir: PathBuf,
|
|
app_version: String,
|
|
trust_store: Arc<PluginTrustStore>,
|
|
lifecycle: Option<PluginLifecycle>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(super) struct PluginPackageExpectation {
|
|
pub id: String,
|
|
pub version: String,
|
|
pub repository_id: Option<String>,
|
|
pub publisher: String,
|
|
pub permissions: BTreeSet<String>,
|
|
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<Option<PluginInstallIdentity>, 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<Self, String> {
|
|
let document = read_trust_document(root_dir)?;
|
|
Self::from_base64_keys(document.keys)
|
|
}
|
|
|
|
pub fn list_base64_keys(root_dir: &Path) -> Result<Vec<PluginTrustedKey>, 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<String, String>) -> Result<Self, String> {
|
|
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<PluginSignatureStatus, String> {
|
|
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<PluginTrustDocument, String> {
|
|
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<String>) -> Result<Self, String> {
|
|
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<String>, 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<PluginInstallResult, String> {
|
|
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<PluginInstallResult, String> {
|
|
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<PluginInstallResult, String> {
|
|
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<PluginInstallResult, String> {
|
|
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<PluginRollbackResult, String> {
|
|
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<Option<PluginInstallProvenance>, 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<PluginInstallResult, String> {
|
|
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/<version>/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<PluginRollbackResult, String> {
|
|
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.<hash>` 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/<version>` 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::<PluginManifest>(&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<Option<PathBuf>, 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<HashSet<String>, 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<String>, 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::<HashSet<_>>();
|
|
let declared_files = checksums.files.keys().cloned().collect::<HashSet<_>>();
|
|
if expected_files != declared_files {
|
|
let missing = expected_files.difference(&declared_files).cloned().collect::<Vec<_>>();
|
|
let extra = declared_files.difference(&expected_files).cloned().collect::<Vec<_>>();
|
|
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<PluginSignatureStatus, String> {
|
|
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::<BTreeSet<_>>();
|
|
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<Option<PluginActivationRecord>, 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<PluginActivationRecord> = 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<Option<PluginActivationRecord>, 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<PluginActivationRecord> = 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::<HashSet<_>>();
|
|
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::<String, u64>::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<T: Serialize>(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<File, String> {
|
|
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<T>(
|
|
delays: &[Duration],
|
|
mut operation: impl FnMut() -> std::io::Result<T>,
|
|
) -> std::io::Result<T> {
|
|
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<PathBuf>) -> 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<PathBuf, String> {
|
|
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<String, String> {
|
|
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::<Result<Vec<_>, _>>()
|
|
.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<String, String> {
|
|
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::<Vec<_>>();
|
|
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.<hash>` 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::<Vec<_>>();
|
|
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<String> {
|
|
let mut versions = std::fs::read_dir(container.join(VERSIONS_DIR))
|
|
.unwrap()
|
|
.map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned())
|
|
.collect::<Vec<_>>();
|
|
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<u8> {
|
|
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::<BTreeMap<_, _>>();
|
|
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));
|
|
}
|
|
}
|