From 88c2e9f6a529c8f067862e964af7845dfab00713 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 13:49:49 +0000 Subject: [PATCH 1/9] fix(pack): install only trusted packages and bind each app ID to its owner weft-pack install copied any package into the store: signatures were never checked, no key was trusted for anything, any publisher could install over another's app ID and reach its retained data, and the signing inventory followed symbolic links, so a package could sign and install files from outside itself. Installation now requires a signature by a key in the trust store ($XDG_CONFIG_HOME/weft/trusted-keys and /etc/weft/trusted-keys, or $WEFT_TRUSTED_KEYS alone). Unsigned or untrusted content installs only with --dev, recorded as development content. The package is copied into the store, checked and verified on that copy, and renamed into place, so the verified bytes are the installed bytes. The first installation of an app ID records its owner beside the app data; later installations must have the same owner, so neither another publisher nor a development build can take the ID over. The record outlives uninstall while app data remains. The content digest moves to weft_ipc_types::trust and refuses links, special files and non-UTF-8 paths; it keeps the existing inventory format, and both committed demo signatures still verify. Catalogs list only directories named after their package ID. The security guide described a signature over wapp.toml and app.wasm only; it now describes the full inventory and the trust and ownership rules. --- Cargo.lock | 3 + README.md | 2 +- crates/weft-appd/src/main.rs | 5 + crates/weft-ipc-types/Cargo.toml | 3 + crates/weft-ipc-types/src/lib.rs | 1 + crates/weft-ipc-types/src/package.rs | 4 +- crates/weft-ipc-types/src/trust.rs | 400 +++++++++++++++++ crates/weft-pack/src/main.rs | 616 +++++++++++++++++++-------- docs/architecture.md | 4 +- docs/building.md | 10 + docs/security.md | 12 +- 11 files changed, 880 insertions(+), 180 deletions(-) create mode 100644 crates/weft-ipc-types/src/trust.rs diff --git a/Cargo.lock b/Cargo.lock index 20cbbdf..bc4cf59 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10519,9 +10519,12 @@ dependencies = [ name = "weft-ipc-types" version = "0.1.0" dependencies = [ + "ed25519-dalek", + "hex", "rmp-serde", "rustix 1.1.4", "serde", + "sha2", "toml 0.8.23", ] diff --git a/README.md b/README.md index 022b3d0..f6a5c18 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ WEFT OS is a Wayland compositor and application runtime where every app is a Web **Runtime** — `weft-runtime` runs WASI Component Model binaries under Wasmtime 30 (`--features wasmtime-runtime`). Provides `weft:app/notify`, `weft:app/ipc`, `weft:app/fetch`, `weft:app/notifications`, and `weft:app/clipboard` host imports. Preopens filesystem paths according to declared capabilities. -**Package management** — `weft-pack` handles check, sign, verify, install, uninstall, list, build-image (EROFS dm-verity), and info. Validates capability strings at check time. App data is stored apart from packages and survives uninstall. +**Package management** — `weft-pack` handles check, sign, verify, install, uninstall, list, build-image (EROFS dm-verity), and info. Validates capability strings at check time. Installs only packages signed by a trusted key (or explicitly as development content) and binds each app ID to its first publisher. App data is stored apart from packages and survives uninstall. **File portal** — `weft-file-portal` is a per-session file proxy with a path allowlist and `..` blocking. diff --git a/crates/weft-appd/src/main.rs b/crates/weft-appd/src/main.rs index 433b0e8..4512211 100644 --- a/crates/weft-appd/src/main.rs +++ b/crates/weft-appd/src/main.rs @@ -634,6 +634,11 @@ fn scan_installed_apps() -> Vec { let Ok(m) = weft_ipc_types::manifest::Manifest::read(&entry.path()) else { continue; }; + // Only a directory named after the ID its manifest declares is an + // installed package; staging copies and stray directories are not. + if entry.file_name().to_str() != Some(m.package.id.as_str()) { + continue; + } if seen.insert(m.package.id.clone()) { apps.push(AppInfo { app_id: m.package.id, diff --git a/crates/weft-ipc-types/Cargo.toml b/crates/weft-ipc-types/Cargo.toml index 8b65cd3..b69064f 100644 --- a/crates/weft-ipc-types/Cargo.toml +++ b/crates/weft-ipc-types/Cargo.toml @@ -12,6 +12,9 @@ path = "src/lib.rs" serde = { version = "1", features = ["derive"] } rmp-serde = "1" toml = "0.8" +sha2 = "0.10" +hex = "0.4" +ed25519-dalek = "2" [lints] workspace = true diff --git a/crates/weft-ipc-types/src/lib.rs b/crates/weft-ipc-types/src/lib.rs index 0590c77..07e3583 100644 --- a/crates/weft-ipc-types/src/lib.rs +++ b/crates/weft-ipc-types/src/lib.rs @@ -1,6 +1,7 @@ pub mod capability; pub mod manifest; pub mod package; +pub mod trust; use serde::{Deserialize, Serialize}; diff --git a/crates/weft-ipc-types/src/package.rs b/crates/weft-ipc-types/src/package.rs index be2a170..6018c3a 100644 --- a/crates/weft-ipc-types/src/package.rs +++ b/crates/weft-ipc-types/src/package.rs @@ -180,13 +180,13 @@ pub fn migrate_app_data(legacy: &Path, target: &Path) -> Result std::io::Result<()> { +pub fn rename_no_replace(from: &Path, to: &Path) -> std::io::Result<()> { use rustix::fs::{CWD, RenameFlags, renameat_with}; renameat_with(CWD, from, CWD, to, RenameFlags::NOREPLACE).map_err(std::io::Error::from) } #[cfg(not(target_os = "linux"))] -fn rename_no_replace(from: &Path, to: &Path) -> std::io::Result<()> { +pub fn rename_no_replace(from: &Path, to: &Path) -> std::io::Result<()> { if std::fs::symlink_metadata(to).is_ok() { return Err(std::io::ErrorKind::AlreadyExists.into()); } diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs new file mode 100644 index 0000000..dc9dfd6 --- /dev/null +++ b/crates/weft-ipc-types/src/trust.rs @@ -0,0 +1,400 @@ +//! Package content identity, publisher keys and the trust decisions made +//! before a package is installed or launched. +//! +//! A package is signed over its content digest: the SHA-256 of a canonical +//! inventory listing every file except the root `signature.sig`, one +//! `\t\n` line per file, sorted by path. Paths use +//! `/` and must be UTF-8. Symbolic links and special files are refused, so the +//! signed bytes are exactly the files a package holds. + +use std::fmt; +use std::path::{Path, PathBuf}; + +use ed25519_dalek::{Signature, Verifier, VerifyingKey}; +use sha2::{Digest, Sha256}; + +/// The signature file at the root of a signed package. +pub const SIGNATURE_FILE: &str = "signature.sig"; + +/// Why a package's content or trust could not be established. +#[derive(Debug)] +pub enum TrustError { + /// The package holds a symbolic link. + Link(PathBuf), + /// The package holds something other than directories and regular files. + NotAFile(PathBuf), + /// A path in the package is not UTF-8. + NonUtf8(PathBuf), + /// A key, signature or owner record is malformed. + Malformed(PathBuf, String), + Io(PathBuf, std::io::Error), +} + +impl fmt::Display for TrustError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Link(p) => write!(f, "{} is a symbolic link", p.display()), + Self::NotAFile(p) => write!(f, "{} is not a regular file or directory", p.display()), + Self::NonUtf8(p) => write!(f, "{} is not a UTF-8 path", p.display()), + Self::Malformed(p, why) => write!(f, "{}: {why}", p.display()), + Self::Io(p, e) => write!(f, "{}: {e}", p.display()), + } + } +} + +impl std::error::Error for TrustError {} + +fn io(path: &Path) -> impl FnOnce(std::io::Error) -> TrustError + '_ { + move |e| TrustError::Io(path.to_path_buf(), e) +} + +/// The SHA-256 content digest a package signature covers. +pub fn content_digest(package_root: &Path) -> Result<[u8; 32], TrustError> { + let mut entries = Vec::new(); + collect(package_root, package_root, &mut entries)?; + entries.sort(); + let mut inventory = String::new(); + for (path, hash) in &entries { + inventory.push_str(path); + inventory.push('\t'); + inventory.push_str(&hex::encode(hash)); + inventory.push('\n'); + } + Ok(Sha256::digest(inventory.as_bytes()).into()) +} + +fn collect( + root: &Path, + dir: &Path, + entries: &mut Vec<(String, [u8; 32])>, +) -> Result<(), TrustError> { + for entry in std::fs::read_dir(dir).map_err(io(dir))? { + let path = entry.map_err(io(dir))?.path(); + let relative = path + .strip_prefix(root) + .expect("read_dir yields children of the directory it reads") + .to_str() + .ok_or_else(|| TrustError::NonUtf8(path.clone()))? + .to_owned(); + let kind = std::fs::symlink_metadata(&path) + .map_err(io(&path))? + .file_type(); + if kind.is_symlink() { + return Err(TrustError::Link(path)); + } else if kind.is_dir() { + collect(root, &path, entries)?; + } else if !kind.is_file() { + return Err(TrustError::NotAFile(path)); + } else if relative != SIGNATURE_FILE { + let bytes = std::fs::read(&path).map_err(io(&path))?; + entries.push((relative, Sha256::digest(&bytes).into())); + } + } + Ok(()) +} + +/// A publisher's Ed25519 public key. +#[derive(Clone, Copy, PartialEq, Eq)] +pub struct PublisherKey(VerifyingKey); + +impl fmt::Debug for PublisherKey { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "PublisherKey({})", self.to_hex()) + } +} + +impl PublisherKey { + /// Parses 64 hex digits, the format `weft-pack generate-key` writes. + pub fn from_hex(text: &str) -> Result { + let bytes: [u8; 32] = hex::decode(text.trim()) + .map_err(|_| "expected 64 hex digits".to_owned())? + .try_into() + .map_err(|_| "expected a 32-byte key".to_owned())?; + VerifyingKey::from_bytes(&bytes) + .map(Self) + .map_err(|_| "not a valid Ed25519 public key".to_owned()) + } + + pub fn from_file(path: &Path) -> Result { + let text = std::fs::read_to_string(path).map_err(io(path))?; + Self::from_hex(&text).map_err(|why| TrustError::Malformed(path.to_path_buf(), why)) + } + + /// The key as 64 lowercase hex digits; it also identifies the publisher. + pub fn to_hex(&self) -> String { + hex::encode(self.0.as_bytes()) + } + + /// Whether `signature` signs `digest` with this key. + pub fn signed(&self, digest: &[u8; 32], signature: &Signature) -> bool { + self.0.verify(digest, signature).is_ok() + } +} + +/// Reads the package's signature, or `None` when the package is unsigned. +pub fn read_signature(package_root: &Path) -> Result, TrustError> { + let path = package_root.join(SIGNATURE_FILE); + match std::fs::symlink_metadata(&path) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(e) => return Err(TrustError::Io(path, e)), + Ok(m) if !m.file_type().is_file() => return Err(TrustError::NotAFile(path)), + Ok(_) => {} + } + let text = std::fs::read_to_string(&path).map_err(io(&path))?; + let bytes: [u8; 64] = hex::decode(text.trim()) + .ok() + .and_then(|b| b.try_into().ok()) + .ok_or_else(|| TrustError::Malformed(path, "expected 128 hex digits".to_owned()))?; + Ok(Some(Signature::from_bytes(&bytes))) +} + +/// The publisher keys this host trusts to sign packages. +#[derive(Debug, Default)] +pub struct TrustStore { + keys: Vec, +} + +impl TrustStore { + /// The trust store directories, in order: `$WEFT_TRUSTED_KEYS` alone when + /// set; otherwise the user's `$XDG_CONFIG_HOME/weft/trusted-keys` (or + /// `~/.config/weft/trusted-keys`) and the system `/etc/weft/trusted-keys`. + pub fn directories() -> Vec { + if let Some(dir) = std::env::var_os("WEFT_TRUSTED_KEYS") { + return vec![PathBuf::from(dir)]; + } + let config = std::env::var_os("XDG_CONFIG_HOME") + .map(PathBuf::from) + .filter(|dir| dir.is_absolute()) + .or_else(|| { + std::env::var_os("HOME") + .map(PathBuf::from) + .filter(|home| home.is_absolute()) + .map(|home| home.join(".config")) + }); + let mut dirs: Vec = config + .map(|dir| dir.join("weft/trusted-keys")) + .into_iter() + .collect(); + dirs.push(PathBuf::from("/etc/weft/trusted-keys")); + dirs + } + + /// Loads every `*.pub` file in `directories`. A missing directory holds no + /// keys; a malformed key file is an error rather than silently ignored. + pub fn load(directories: &[PathBuf]) -> Result { + let mut keys = Vec::new(); + for dir in directories { + let entries = match std::fs::read_dir(dir) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue, + other => other.map_err(io(dir))?, + }; + let mut files: Vec = entries + .map(|e| e.map(|e| e.path()).map_err(io(dir))) + .collect::>()?; + files.sort(); + for file in files + .into_iter() + .filter(|f| f.extension().is_some_and(|e| e == "pub")) + { + keys.push(PublisherKey::from_file(&file)?); + } + } + Ok(Self { keys }) + } + + pub fn keys(&self) -> &[PublisherKey] { + &self.keys + } + + /// The trusted key that signed the package at `package_root`, if any. + pub fn signer(&self, package_root: &Path) -> Result, TrustError> { + let Some(signature) = read_signature(package_root)? else { + return Ok(None); + }; + let digest = content_digest(package_root)?; + Ok(self + .keys + .iter() + .copied() + .find(|k| k.signed(&digest, &signature))) + } +} + +/// Who an application ID belongs to on this host. The record outlives the +/// package while the app's data remains, so another publisher cannot take +/// over the ID, and the data with it, by reusing it. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Owner { + /// Installed from packages signed by this trusted key. + Verified(PublisherKey), + /// Installed as development content, without a trusted signature. + Development, +} + +impl fmt::Display for Owner { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Verified(key) => write!(f, "publisher {}", key.to_hex()), + Self::Development => f.write_str("development installation"), + } + } +} + +/// Where the owner of `app_id` is recorded, beside the app's data. +pub fn owner_record_path(data_home: &Path, app_id: &str) -> PathBuf { + data_home.join("weft/owners").join(app_id) +} + +/// Reads an owner record: `verified ` or `development`. +pub fn read_owner(record: &Path) -> Result, TrustError> { + let text = match std::fs::read_to_string(record) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None), + other => other.map_err(io(record))?, + }; + let malformed = |why: &str| TrustError::Malformed(record.to_path_buf(), why.to_owned()); + match text.trim().split_once(' ') { + Some(("verified", key)) => PublisherKey::from_hex(key) + .map(|k| Some(Owner::Verified(k))) + .map_err(|why| malformed(&why)), + None if text.trim() == "development" => Ok(Some(Owner::Development)), + _ => Err(malformed("expected 'verified ' or 'development'")), + } +} + +/// Records the owner of an app ID. An existing record is never replaced. +pub fn write_owner(record: &Path, owner: Owner) -> Result<(), TrustError> { + use std::io::Write; + let parent = record.parent().expect("owner records live in a directory"); + std::fs::create_dir_all(parent).map_err(io(parent))?; + let text = match owner { + Owner::Verified(key) => format!("verified {}\n", key.to_hex()), + Owner::Development => "development\n".to_owned(), + }; + let mut file = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(record) + .map_err(io(record))?; + file.write_all(text.as_bytes()).map_err(io(record))?; + file.sync_all().map_err(io(record)) +} + +#[cfg(test)] +mod tests { + use super::*; + use ed25519_dalek::{Signer, SigningKey}; + + fn dir(name: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("weft_trust_{name}_{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(dir.join("ui")).unwrap(); + std::fs::write(dir.join("wapp.toml"), b"[package]\n").unwrap(); + std::fs::write(dir.join("ui/index.html"), b"

").unwrap(); + dir + } + + fn sign(dir: &Path, seed: u8) -> PublisherKey { + let key = SigningKey::from_bytes(&[seed; 32]); + let signature = key.sign(&content_digest(dir).unwrap()); + std::fs::write(dir.join(SIGNATURE_FILE), hex::encode(signature.to_bytes())).unwrap(); + PublisherKey(key.verifying_key()) + } + + fn store(keys: &[PublisherKey]) -> TrustStore { + TrustStore { + keys: keys.to_vec(), + } + } + + #[test] + fn the_committed_demo_signatures_verify_with_the_demo_key() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let key = PublisherKey::from_file(&root.join("examples/keys/weft-sign.pub")).unwrap(); + for demo in ["org.weft.demo.counter", "org.weft.demo.notes"] { + let package = root.join("examples").join(demo); + assert_eq!(store(&[key]).signer(&package).unwrap(), Some(key), "{demo}"); + } + } + + #[test] + fn any_changed_file_breaks_the_signature() { + let dir = dir("tamper"); + let key = sign(&dir, 1); + assert_eq!(store(&[key]).signer(&dir).unwrap(), Some(key)); + std::fs::write(dir.join("ui/index.html"), b"

changed").unwrap(); + assert_eq!(store(&[key]).signer(&dir).unwrap(), None); + std::fs::write(dir.join("ui/index.html"), b"

").unwrap(); + std::fs::write(dir.join("ui/extra.js"), b"").unwrap(); + assert_eq!(store(&[key]).signer(&dir).unwrap(), None); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[test] + fn only_trusted_keys_are_signers_and_unsigned_packages_have_none() { + let dir = dir("untrusted"); + assert_eq!(store(&[]).signer(&dir).unwrap(), None); + let key = sign(&dir, 2); + let other = PublisherKey(SigningKey::from_bytes(&[3; 32]).verifying_key()); + assert_eq!(store(&[other]).signer(&dir).unwrap(), None); + assert_eq!(store(&[other, key]).signer(&dir).unwrap(), Some(key)); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[cfg(target_os = "linux")] + #[test] + fn links_and_special_files_have_no_content_digest() { + let dir = dir("links"); + std::os::unix::fs::symlink("/etc/hostname", dir.join("ui/linked")).unwrap(); + assert!(matches!(content_digest(&dir), Err(TrustError::Link(_)))); + std::fs::remove_file(dir.join("ui/linked")).unwrap(); + std::os::unix::fs::symlink(dir.join("ui"), dir.join("view")).unwrap(); + assert!(matches!(content_digest(&dir), Err(TrustError::Link(_)))); + std::fs::remove_file(dir.join("view")).unwrap(); + rustix::fs::mknodat( + rustix::fs::CWD, + dir.join("fifo"), + rustix::fs::FileType::Fifo, + rustix::fs::Mode::from_raw_mode(0o600), + 0, + ) + .unwrap(); + assert!(matches!(content_digest(&dir), Err(TrustError::NotAFile(_)))); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[test] + fn trust_stores_load_pub_files_and_refuse_malformed_keys() { + let dir = dir("store"); + let keys = dir.join("keys"); + std::fs::create_dir_all(&keys).unwrap(); + let key = PublisherKey(SigningKey::from_bytes(&[4; 32]).verifying_key()); + std::fs::write(keys.join("a.pub"), key.to_hex()).unwrap(); + std::fs::write(keys.join("notes.txt"), "not a key").unwrap(); + let loaded = TrustStore::load(&[keys.clone(), dir.join("missing")]).unwrap(); + assert_eq!(loaded.keys(), [key]); + std::fs::write(keys.join("b.pub"), "zz").unwrap(); + assert!(matches!( + TrustStore::load(&[keys]), + Err(TrustError::Malformed(..)) + )); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[test] + fn owner_records_round_trip_and_are_never_replaced() { + let dir = dir("owners"); + let key = PublisherKey(SigningKey::from_bytes(&[5; 32]).verifying_key()); + let verified = owner_record_path(&dir, "org.weft.test.a"); + let development = owner_record_path(&dir, "org.weft.test.b"); + assert_eq!(read_owner(&verified).unwrap(), None); + write_owner(&verified, Owner::Verified(key)).unwrap(); + write_owner(&development, Owner::Development).unwrap(); + assert_eq!(read_owner(&verified).unwrap(), Some(Owner::Verified(key))); + assert_eq!(read_owner(&development).unwrap(), Some(Owner::Development)); + assert!(write_owner(&verified, Owner::Development).is_err()); + assert_eq!(read_owner(&verified).unwrap(), Some(Owner::Verified(key))); + std::fs::write(&development, "someone else\n").unwrap(); + assert!(read_owner(&development).is_err()); + std::fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 00ca0fc..df905d5 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -3,6 +3,7 @@ use std::path::{Path, PathBuf}; use anyhow::Context; use weft_ipc_types::manifest::{Manifest, entry_path}; use weft_ipc_types::package::ImageFiles; +use weft_ipc_types::trust::{Owner, PublisherKey, TrustStore}; fn main() -> anyhow::Result<()> { let args: Vec = std::env::args().collect(); @@ -19,8 +20,14 @@ fn main() -> anyhow::Result<()> { print_info(&manifest); } Some("install") => { - let dir = args.get(2).context("usage: weft-pack install

")?; - install_package(Path::new(dir))?; + let usage = "usage: weft-pack install [--dev]"; + let dir = args.get(2).context(usage)?; + let mode = match args.get(3).map(String::as_str) { + None => InstallMode::Verified, + Some("--dev") => InstallMode::Development, + Some(other) => anyhow::bail!("unexpected argument '{other}'; {usage}"), + }; + install_package(Path::new(dir), mode)?; } Some("uninstall") => { let app_id = args.get(2).context("usage: weft-pack uninstall ")?; @@ -86,7 +93,7 @@ fn main() -> anyhow::Result<()> { .find(|w| w[0] == "--key") .map(|w| &w[1]) .context("missing --key ")?; - let ok = verify_package(Path::new(dir), Path::new(key))?; + let ok = verify_package(Path::new(dir), &PublisherKey::from_file(Path::new(key))?)?; if ok { println!("OK"); } else { @@ -98,7 +105,12 @@ fn main() -> anyhow::Result<()> { eprintln!("usage:"); eprintln!(" weft-pack check validate a package directory"); eprintln!(" weft-pack info print package metadata"); - eprintln!(" weft-pack install install package to app store"); + eprintln!( + " weft-pack install [--dev] install a package signed by a trusted key" + ); + eprintln!( + " (--dev: unsigned development content)" + ); eprintln!(" weft-pack uninstall remove installed package"); eprintln!(" weft-pack list list installed packages"); eprintln!( @@ -128,6 +140,12 @@ fn check_package(dir: &Path) -> anyhow::Result { } }; + // A package holds only directories and regular files: its signature + // covers exactly those, and installation copies exactly those. + if let Err(e) = weft_ipc_types::trust::content_digest(dir) { + errors.push(e.to_string()); + } + // Earlier versions kept app data in `/data`; the name stays // reserved so package content is never mistaken for user data. if std::fs::symlink_metadata(dir.join("data")).is_ok() { @@ -229,12 +247,22 @@ fn resolve_install_root() -> anyhow::Result { anyhow::bail!("cannot determine install root: HOME and WEFT_APP_STORE are both unset") } -fn install_package(path: &Path) -> anyhow::Result<()> { - let root = resolve_install_root()?; - install_package_to(path, &root) +/// How a package is admitted to the store. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum InstallMode { + /// The package must be signed by a key in the trust store. + Verified, + /// Unsigned or untrusted content, chosen explicitly by a developer and + /// recorded as development content. + Development, } -fn install_package_to(path: &Path, store_root: &Path) -> anyhow::Result<()> { +fn install_package(path: &Path, mode: InstallMode) -> anyhow::Result<()> { + let root = resolve_install_root()?; + install_package_to(path, &root, mode) +} + +fn install_package_to(path: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Result<()> { let dir_buf; let dir: &Path = if path.extension().is_some_and(|e| e == "zst" || e == "tar") || path.to_string_lossy().ends_with(".app.tar.zst") @@ -280,12 +308,78 @@ fn install_package_to(path: &Path, store_root: &Path) -> anyhow::Result<()> { dest.display() ); } - copy_dir(dir, &dest) - .with_context(|| format!("copy {} -> {}", dir.display(), dest.display()))?; - println!("installed {} -> {}", app_id, dest.display()); + + // The package is copied into the store first and every decision is made + // on that copy, so the bytes that are checked and trusted are the bytes + // that become installed. Only then does one rename make it available. + std::fs::create_dir_all(store_root) + .with_context(|| format!("create {}", store_root.display()))?; + let staging = store_root.join(format!( + ".staging-{app_id}-{}", + hex::encode(rand::random::<[u8; 8]>()) + )); + let staged = copy_dir(dir, &staging) + .with_context(|| format!("copy {} -> {}", dir.display(), staging.display())) + .and_then(|()| admit(&staging, app_id, mode)) + .and_then(|owner| { + weft_ipc_types::package::rename_no_replace(&staging, &dest) + .with_context(|| format!("move {} -> {}", staging.display(), dest.display()))?; + Ok(owner) + }); + let owner = match staged { + Ok(owner) => owner, + Err(e) => { + let _ = std::fs::remove_dir_all(&staging); + return Err(e); + } + }; + println!("installed {} -> {} ({owner})", app_id, dest.display()); Ok(()) } +/// Checks the staged copy of a package and establishes who owns its app ID: +/// the trusted publisher that signed it, or, only when asked, development. +/// The first installation of an ID records its owner, and every later one +/// must have the same owner. +fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result { + use weft_ipc_types::trust::{owner_record_path, read_owner, write_owner}; + check_package(staged)?; + let manifest = load_manifest(staged)?; + anyhow::ensure!( + manifest.package.id == app_id, + "the package changed while it was copied" + ); + let owner = match mode { + InstallMode::Development => Owner::Development, + InstallMode::Verified => { + let dirs = TrustStore::directories(); + let signer = TrustStore::load(&dirs)?.signer(staged)?; + Owner::Verified(signer.with_context(|| { + format!( + "{app_id} is not signed by a trusted key (trusted keys are read from {}); \ + install it with --dev to use it as development content", + dirs.iter() + .map(|d| d.display().to_string()) + .collect::>() + .join(", ") + ) + })?) + } + }; + let data_home = weft_ipc_types::package::data_home() + .context("cannot locate the data home to record who owns the app ID")?; + let record = owner_record_path(&data_home, app_id); + match read_owner(&record)? { + Some(existing) if existing == owner => {} + Some(existing) => anyhow::bail!( + "{app_id} belongs to {existing}; this package is {owner}. Its app data stays with \ + its owner, so another publisher or a development build cannot take the ID over" + ), + None => write_owner(&record, owner)?, + } + Ok(owner) +} + fn uninstall_package(app_id: &str) -> anyhow::Result<()> { let root = resolve_install_root()?; uninstall_package_from(app_id, &root) @@ -326,6 +420,14 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> } _ => {} } + // The owner record keeps the app ID, and the data with it, for its owner + // while the data remains; with no data left, the ID is free again. + if let Some(data_home) = weft_ipc_types::package::data_home() + && std::fs::symlink_metadata(weft_ipc_types::package::app_data_dir(&data_home, app_id)) + .is_err() + { + let _ = std::fs::remove_file(weft_ipc_types::trust::owner_record_path(&data_home, app_id)); + } println!("uninstalled {}", app_id); Ok(()) } @@ -416,6 +518,11 @@ fn list_installed() { let Ok(m) = Manifest::read(&entry.path()) else { continue; }; + // Only a directory named after the ID its manifest declares is an + // installed package; staging copies and stray directories are not. + if entry.file_name().to_str() != Some(m.package.id.as_str()) { + continue; + } if seen.insert(m.package.id.clone()) { pkgs.push((m.package.id, m.package.name, m.package.version)); } @@ -431,17 +538,26 @@ fn list_installed() { } } +/// Copies a package directory. Packages hold only directories and regular +/// files, so a symbolic link or special file stops the copy rather than +/// being followed. fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { - std::fs::create_dir_all(dst)?; + std::fs::create_dir(dst).with_context(|| format!("create {}", dst.display()))?; for entry in std::fs::read_dir(src)? { let entry = entry?; let src_path = entry.path(); let dst_path = dst.join(entry.file_name()); - if src_path.is_dir() { + let kind = std::fs::symlink_metadata(&src_path)?.file_type(); + if kind.is_dir() { copy_dir(&src_path, &dst_path)?; - } else { + } else if kind.is_file() { std::fs::copy(&src_path, &dst_path) .with_context(|| format!("copy {}", src_path.display()))?; + } else { + anyhow::bail!( + "{} is not a regular file or directory; packages cannot contain links", + src_path.display() + ); } } Ok(()) @@ -540,47 +656,6 @@ fn unbundle_package(archive: &Path, out_dir: &Path) -> anyhow::Result<()> { Ok(()) } -fn collect_bundle_files( - base: &Path, - dir: &Path, - entries: &mut Vec<(String, [u8; 32])>, -) -> anyhow::Result<()> { - use sha2::{Digest, Sha256}; - for entry in std::fs::read_dir(dir).with_context(|| format!("read dir {}", dir.display()))? { - let entry = entry?; - let path = entry.path(); - let rel = path - .strip_prefix(base) - .context("strip prefix")? - .to_string_lossy() - .into_owned(); - if rel == "signature.sig" { - continue; - } - if path.is_dir() { - collect_bundle_files(base, &path, entries)?; - } else { - let contents = - std::fs::read(&path).with_context(|| format!("read {}", path.display()))?; - let hash: [u8; 32] = Sha256::digest(&contents).into(); - entries.push((rel, hash)); - } - } - Ok(()) -} - -fn canonical_bundle_hash(dir: &Path) -> anyhow::Result<[u8; 32]> { - use sha2::{Digest, Sha256}; - let mut entries: Vec<(String, [u8; 32])> = Vec::new(); - collect_bundle_files(dir, dir, &mut entries)?; - entries.sort_by(|a, b| a.0.cmp(&b.0)); - let mut canonical = String::new(); - for (path, hash) in &entries { - canonical.push_str(&format!("{path}\t{}\n", hex::encode(hash))); - } - Ok(Sha256::digest(canonical.as_bytes()).into()) -} - fn generate_key(output_dir: &Path) -> anyhow::Result<()> { use ed25519_dalek::SigningKey; use rand::rngs::OsRng; @@ -614,34 +689,20 @@ fn sign_package(dir: &Path, key_file: &Path) -> anyhow::Result<()> { .try_into() .map_err(|_| anyhow::anyhow!("signing key must be 32 bytes"))?; let signing_key = SigningKey::from_bytes(&key_bytes); - let hash = canonical_bundle_hash(dir)?; - let signature = signing_key.sign(&hash); - let sig_path = dir.join("signature.sig"); + let digest = weft_ipc_types::trust::content_digest(dir)?; + let signature = signing_key.sign(&digest); + let sig_path = dir.join(weft_ipc_types::trust::SIGNATURE_FILE); std::fs::write(&sig_path, hex::encode(signature.to_bytes())) .with_context(|| format!("write {}", sig_path.display()))?; println!("signed: {}", sig_path.display()); Ok(()) } -fn verify_package(dir: &Path, pub_key_file: &Path) -> anyhow::Result { - use ed25519_dalek::{Signature, Verifier, VerifyingKey}; - let pub_hex = std::fs::read_to_string(pub_key_file) - .with_context(|| format!("read {}", pub_key_file.display()))?; - let pub_bytes: [u8; 32] = hex::decode(pub_hex.trim()) - .context("decode public key: expected 64 hex chars")? - .try_into() - .map_err(|_| anyhow::anyhow!("public key must be 32 bytes"))?; - let verifying_key = VerifyingKey::from_bytes(&pub_bytes).context("invalid public key bytes")?; - let sig_path = dir.join("signature.sig"); - let sig_hex = std::fs::read_to_string(&sig_path) - .with_context(|| format!("read {}", sig_path.display()))?; - let sig_bytes: [u8; 64] = hex::decode(sig_hex.trim()) - .context("decode signature: expected 128 hex chars")? - .try_into() - .map_err(|_| anyhow::anyhow!("signature must be 64 bytes"))?; - let signature = Signature::from_bytes(&sig_bytes); - let hash = canonical_bundle_hash(dir)?; - Ok(verifying_key.verify(&hash, &signature).is_ok()) +fn verify_package(dir: &Path, key: &PublisherKey) -> anyhow::Result { + let signature = weft_ipc_types::trust::read_signature(dir)? + .with_context(|| format!("{} is not signed", dir.display()))?; + let digest = weft_ipc_types::trust::content_digest(dir)?; + Ok(key.signed(&digest, &signature)) } #[cfg(test)] @@ -704,13 +765,187 @@ mod tests { const APP_DATA: &str = "\"fs:rw:app-data\""; + /// Runs `f` like `with_home`, with only the keys in `home/keys` trusted. + fn with_trust(home: &Path, f: impl FnOnce() -> T) -> T { + with_home(home, || { + let prior = std::env::var_os("WEFT_TRUSTED_KEYS"); + // SAFETY: with_home holds env_lock. + unsafe { std::env::set_var("WEFT_TRUSTED_KEYS", home.join("keys")) }; + let result = f(); + unsafe { + match prior { + Some(v) => std::env::set_var("WEFT_TRUSTED_KEYS", v), + None => std::env::remove_var("WEFT_TRUSTED_KEYS"), + } + } + result + }) + } + + /// Writes a signing key derived from `seed` to `home/.key` and + /// returns its path; with `trusted`, its public key joins `home/keys`. + fn key(home: &Path, name: &str, seed: u8, trusted: bool) -> PathBuf { + let signing = ed25519_dalek::SigningKey::from_bytes(&[seed; 32]); + std::fs::create_dir_all(home.join("keys")).unwrap(); + let path = home.join(format!("{name}.key")); + std::fs::write(&path, hex::encode(signing.to_bytes())).unwrap(); + if trusted { + std::fs::write( + home.join("keys").join(format!("{name}.pub")), + hex::encode(signing.verifying_key().to_bytes()), + ) + .unwrap(); + } + path + } + + fn owner_of(home: &Path, app_id: &str) -> Option { + weft_ipc_types::trust::read_owner(&weft_ipc_types::trust::owner_record_path( + &home.join("share"), + app_id, + )) + .unwrap() + } + + fn staging_left(store: &Path) -> bool { + std::fs::read_dir(store).is_ok_and(|entries| { + entries + .flatten() + .any(|e| e.file_name().to_string_lossy().starts_with(".staging-")) + }) + } + + #[test] + fn only_packages_signed_by_a_trusted_key_install_as_verified() { + let home = temp_root("verified"); + let store = home.join("store"); + let app_id = "org.weft.test.verified"; + write_package(&home.join("src"), app_id, ""); + let publisher = key(&home, "publisher", 1, true); + let stranger = key(&home, "stranger", 2, false); + + // Unsigned, then signed by a key the host does not trust. + let unsigned = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }); + sign_package(&home.join("src"), &stranger).unwrap(); + let untrusted = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }); + for refused in [&unsigned, &untrusted] { + let message = format!("{:#}", refused.as_ref().unwrap_err()); + assert!(message.contains("not signed by a trusted key"), "{message}"); + } + assert!(!store.join(app_id).exists()); + assert!(!staging_left(&store)); + assert_eq!(owner_of(&home, app_id), None); + + // Signed by a trusted key. + sign_package(&home.join("src"), &publisher).unwrap(); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }) + .unwrap(); + assert!(store.join(app_id).join("signature.sig").exists()); + let key = PublisherKey::from_file(&home.join("keys/publisher.pub")).unwrap(); + assert_eq!(owner_of(&home, app_id), Some(Owner::Verified(key))); + assert!(!staging_left(&store)); + let _ = std::fs::remove_dir_all(&home); + } + + #[test] + fn content_changed_after_signing_is_refused() { + let home = temp_root("tampered"); + let store = home.join("store"); + let app_id = "org.weft.test.tampered"; + write_package(&home.join("src"), app_id, ""); + sign_package(&home.join("src"), &key(&home, "publisher", 3, true)).unwrap(); + std::fs::write(home.join("src/ui/index.html"), "").unwrap(); + let refused = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }); + assert!(refused.is_err()); + assert!(!store.join(app_id).exists()); + assert!(!staging_left(&store)); + let _ = std::fs::remove_dir_all(&home); + } + + #[test] + fn an_app_id_stays_with_its_first_owner_while_its_data_remains() { + let home = temp_root("owner"); + let store = home.join("store"); + let app_id = "org.weft.test.owned"; + write_package(&home.join("src"), app_id, APP_DATA); + sign_package(&home.join("src"), &key(&home, "first", 4, true)).unwrap(); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }) + .unwrap(); + let data = weft_ipc_types::package::app_data_dir(&home.join("share"), app_id); + std::fs::create_dir_all(&data).unwrap(); + with_trust(&home, || uninstall_package_from(app_id, &store)).unwrap(); + + // Another trusted publisher, and a development build, cannot take the + // ID over while the first owner's data remains. + sign_package(&home.join("src"), &key(&home, "second", 5, true)).unwrap(); + let other_publisher = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }); + let development = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }); + for refused in [&other_publisher, &development] { + let message = format!("{:#}", refused.as_ref().unwrap_err()); + assert!(message.contains("belongs to publisher"), "{message}"); + } + assert!(!store.join(app_id).exists()); + assert!(!staging_left(&store)); + + // With no data left, uninstall frees the ID. + std::fs::remove_dir_all(&data).unwrap(); + sign_package(&home.join("src"), &home.join("first.key")).unwrap(); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }) + .unwrap(); + with_trust(&home, || uninstall_package_from(app_id, &store)).unwrap(); + assert_eq!(owner_of(&home, app_id), None); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); + assert_eq!(owner_of(&home, app_id), Some(Owner::Development)); + let _ = std::fs::remove_dir_all(&home); + } + + #[cfg(unix)] + #[test] + fn packages_with_links_are_refused() { + let home = temp_root("links"); + let store = home.join("store"); + let app_id = "org.weft.test.links"; + write_package(&home.join("src"), app_id, ""); + std::os::unix::fs::symlink("/etc/hostname", home.join("src/ui/host.txt")).unwrap(); + assert!(check_package(&home.join("src")).is_err()); + let refused = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }); + assert!(refused.is_err()); + assert!(!store.join(app_id).exists()); + assert!(sign_package(&home.join("src"), &key(&home, "publisher", 6, true)).is_err()); + let _ = std::fs::remove_dir_all(&home); + } + #[test] fn uninstall_keeps_app_data_from_the_user_store() { let home = temp_root("keep"); let app_id = "com.example.keep"; write_package(&home.join("src"), app_id, APP_DATA); let store = home.join(".local/share/weft/apps"); - install_package_to(&home.join("src"), &store).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); let legacy = store.join(app_id).join("data"); std::fs::create_dir_all(&legacy).unwrap(); std::fs::write(legacy.join("notes.txt"), "first\nsecond").unwrap(); @@ -730,7 +965,10 @@ mod tests { } // A second copy cannot be merged: uninstall refuses and removes nothing. - install_package_to(&home.join("src"), &store).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); std::fs::create_dir_all(&legacy).unwrap(); assert!(with_home(&home, || uninstall_package_from(app_id, &store)).is_err()); assert!(legacy.is_dir() && kept.is_dir()); @@ -744,7 +982,10 @@ mod tests { // No app-data capability: the data directory is left and uninstall stops. write_package(&home.join("src"), app_id, ""); let store = home.join(".local/share/weft/apps"); - install_package_to(&home.join("src"), &store).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); std::fs::create_dir_all(store.join(app_id).join("data")).unwrap(); std::fs::write(store.join(app_id).join("data/x"), "x").unwrap(); assert!(with_home(&home, || uninstall_package_from(app_id, &store)).is_err()); @@ -757,11 +998,14 @@ mod tests { // Another store: earlier versions never kept data there, so it stops too. write_package(&home.join("src2"), app_id, APP_DATA); let other = home.join("other-store"); - install_package_to(&home.join("src2"), &other).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src2"), &other, InstallMode::Development) + }) + .unwrap(); std::fs::create_dir_all(other.join(app_id).join("data")).unwrap(); assert!(with_home(&home, || uninstall_package_from(app_id, &other)).is_err()); assert!(other.join(app_id).join("data").is_dir()); - assert!(!home.join("share").exists()); + assert!(!home.join("share/weft/app-data").exists()); let _ = std::fs::remove_dir_all(&home); } @@ -808,15 +1052,21 @@ mod tests { #[test] fn packages_cannot_ship_a_top_level_data_entry() { - let root = temp_root("ships-data"); - let src = root.join("src"); - write_package(&src, "com.example.ships", ""); - std::fs::create_dir_all(src.join("data")).unwrap(); - std::fs::write(src.join("data/asset.json"), "{}").unwrap(); - let err = check_package(&src).unwrap_err().to_string(); - assert!(err.contains("'data'"), "{err}"); - assert!(install_package_to(&src, &root.join("store")).is_err()); - let _ = std::fs::remove_dir_all(&root); + let home = temp_root("packages_cannot_ship_a_top_level_data_entry"); + with_home(&home.clone(), move || { + let root = temp_root("ships-data"); + let src = root.join("src"); + write_package(&src, "com.example.ships", ""); + std::fs::create_dir_all(src.join("data")).unwrap(); + std::fs::write(src.join("data/asset.json"), "{}").unwrap(); + let err = check_package(&src).unwrap_err().to_string(); + assert!(err.contains("'data'"), "{err}"); + assert!( + install_package_to(&src, &root.join("store"), InstallMode::Development).is_err() + ); + let _ = std::fs::remove_dir_all(&root); + }); + let _ = std::fs::remove_dir_all(&home); } #[test] @@ -828,7 +1078,10 @@ mod tests { std::fs::create_dir_all(store.join(app_id).join("data")).unwrap(); std::fs::write(store.join(app_id).join("data/x"), "x").unwrap(); - with_home(&home, || install_package_to(&home.join("src"), &store)).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); assert!(store.join(app_id).join("wapp.toml").exists()); assert!(!store.join(app_id).join("data").exists()); let kept = weft_ipc_types::package::app_data_dir(&home.join("share"), app_id); @@ -837,7 +1090,10 @@ mod tests { // An empty directory left behind does not block installation either. with_home(&home, || uninstall_package_from(app_id, &store)).unwrap(); std::fs::create_dir_all(store.join(app_id)).unwrap(); - with_home(&home, || install_package_to(&home.join("src"), &store)).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); let _ = std::fs::remove_dir_all(&home); } @@ -970,60 +1226,68 @@ entry = "ui/index.html" #[test] fn install_package_copies_to_store() { - use std::fs; - let id = format!("weft.pack.install{}", std::process::id()); - let src = std::env::temp_dir().join(format!("weft_pack_install_src_{}", id)); - let store = std::env::temp_dir().join(format!("weft_pack_install_store_{}", id)); - let ui_dir = src.join("ui"); - let _ = fs::create_dir_all(&ui_dir); - fs::write(src.join("app.wasm"), b"\0asm").unwrap(); - fs::write(ui_dir.join("index.html"), b"").unwrap(); - let app_id = format!("com.example.t{}", std::process::id()); - fs::write( - src.join("wapp.toml"), - format!( - "[package]\nid = \"{app_id}\"\nname = \"Test\"\nversion = \"1.0.0\"\n\n\ - [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" - ), - ) - .unwrap(); - let result = install_package_to(&src, &store); - assert!(result.is_ok(), "{result:?}"); - assert!(store.join(&app_id).join("app.wasm").exists()); - assert!(store.join(&app_id).join("wapp.toml").exists()); - assert!(store.join(&app_id).join("ui").join("index.html").exists()); - assert!(install_package_to(&src, &store).is_err()); - let _ = fs::remove_dir_all(&src); - let _ = fs::remove_dir_all(&store); + let home = temp_root("install_package_copies_to_store"); + with_home(&home.clone(), move || { + use std::fs; + let id = format!("weft.pack.install{}", std::process::id()); + let src = std::env::temp_dir().join(format!("weft_pack_install_src_{}", id)); + let store = std::env::temp_dir().join(format!("weft_pack_install_store_{}", id)); + let ui_dir = src.join("ui"); + let _ = fs::create_dir_all(&ui_dir); + fs::write(src.join("app.wasm"), b"\0asm").unwrap(); + fs::write(ui_dir.join("index.html"), b"").unwrap(); + let app_id = format!("com.example.t{}", std::process::id()); + fs::write( + src.join("wapp.toml"), + format!( + "[package]\nid = \"{app_id}\"\nname = \"Test\"\nversion = \"1.0.0\"\n\n\ + [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" + ), + ) + .unwrap(); + let result = install_package_to(&src, &store, InstallMode::Development); + assert!(result.is_ok(), "{result:?}"); + assert!(store.join(&app_id).join("app.wasm").exists()); + assert!(store.join(&app_id).join("wapp.toml").exists()); + assert!(store.join(&app_id).join("ui").join("index.html").exists()); + assert!(install_package_to(&src, &store, InstallMode::Development).is_err()); + let _ = fs::remove_dir_all(&src); + let _ = fs::remove_dir_all(&store); + }); + let _ = std::fs::remove_dir_all(&home); } #[test] fn uninstall_package_removes_directory() { - use std::fs; - let id = format!("weft.pack.uninstall{}", std::process::id()); - let src = std::env::temp_dir().join(format!("weft_pack_uninstall_src_{}", id)); - let store = std::env::temp_dir().join(format!("weft_pack_uninstall_store_{}", id)); - let ui_dir = src.join("ui"); - let _ = fs::create_dir_all(&ui_dir); - fs::write(src.join("app.wasm"), b"\0asm").unwrap(); - fs::write(ui_dir.join("index.html"), b"").unwrap(); - let app_id = format!("com.example.u{}", std::process::id()); - fs::write( - src.join("wapp.toml"), - format!( - "[package]\nid = \"{app_id}\"\nname = \"U\"\nversion = \"1.0.0\"\n\n\ - [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" - ), - ) - .unwrap(); - install_package_to(&src, &store).unwrap(); - assert!(store.join(&app_id).exists()); - let result = uninstall_package_from(&app_id, &store); - assert!(result.is_ok(), "{result:?}"); - assert!(!store.join(&app_id).exists()); - assert!(uninstall_package_from(&app_id, &store).is_err()); - let _ = fs::remove_dir_all(&src); - let _ = fs::remove_dir_all(&store); + let home = temp_root("uninstall_package_removes_directory"); + with_home(&home.clone(), move || { + use std::fs; + let id = format!("weft.pack.uninstall{}", std::process::id()); + let src = std::env::temp_dir().join(format!("weft_pack_uninstall_src_{}", id)); + let store = std::env::temp_dir().join(format!("weft_pack_uninstall_store_{}", id)); + let ui_dir = src.join("ui"); + let _ = fs::create_dir_all(&ui_dir); + fs::write(src.join("app.wasm"), b"\0asm").unwrap(); + fs::write(ui_dir.join("index.html"), b"").unwrap(); + let app_id = format!("com.example.u{}", std::process::id()); + fs::write( + src.join("wapp.toml"), + format!( + "[package]\nid = \"{app_id}\"\nname = \"U\"\nversion = \"1.0.0\"\n\n\ + [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" + ), + ) + .unwrap(); + install_package_to(&src, &store, InstallMode::Development).unwrap(); + assert!(store.join(&app_id).exists()); + let result = uninstall_package_from(&app_id, &store); + assert!(result.is_ok(), "{result:?}"); + assert!(!store.join(&app_id).exists()); + assert!(uninstall_package_from(&app_id, &store).is_err()); + let _ = fs::remove_dir_all(&src); + let _ = fs::remove_dir_all(&store); + }); + let _ = std::fs::remove_dir_all(&home); } #[test] @@ -1089,36 +1353,40 @@ entry = "ui/index.html" #[test] fn install_package_from_archive() { - use std::fs; - let id = format!("instarch_{}", std::process::id()); - let src = std::env::temp_dir().join(&id); - let ui = src.join("ui"); - let _ = fs::create_dir_all(&ui); - fs::write(src.join("app.wasm"), b"\0asm\x01\0\0\0").unwrap(); - fs::write(ui.join("index.html"), b"").unwrap(); - let app_id = format!("com.example.ia{}", std::process::id()); - fs::write( - src.join("wapp.toml"), - format!( - "[package]\nid = \"{app_id}\"\nname = \"IA\"\nversion = \"1.0.0\"\n\n\ - [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" - ), - ) - .unwrap(); + let home = temp_root("install_package_from_archive"); + with_home(&home.clone(), move || { + use std::fs; + let id = format!("instarch_{}", std::process::id()); + let src = std::env::temp_dir().join(&id); + let ui = src.join("ui"); + let _ = fs::create_dir_all(&ui); + fs::write(src.join("app.wasm"), b"\0asm\x01\0\0\0").unwrap(); + fs::write(ui.join("index.html"), b"").unwrap(); + let app_id = format!("com.example.ia{}", std::process::id()); + fs::write( + src.join("wapp.toml"), + format!( + "[package]\nid = \"{app_id}\"\nname = \"IA\"\nversion = \"1.0.0\"\n\n\ + [runtime]\nmodule = \"app.wasm\"\n\n[ui]\nentry = \"ui/index.html\"\n" + ), + ) + .unwrap(); - let bundle_dir = std::env::temp_dir().join(format!("{id}_bnd")); - let _ = fs::create_dir_all(&bundle_dir); - bundle_package(&src, Some(&bundle_dir)).unwrap(); - let archive = bundle_dir.join(format!("{app_id}.app.tar.zst")); + let bundle_dir = std::env::temp_dir().join(format!("{id}_bnd")); + let _ = fs::create_dir_all(&bundle_dir); + bundle_package(&src, Some(&bundle_dir)).unwrap(); + let archive = bundle_dir.join(format!("{app_id}.app.tar.zst")); - let store = std::env::temp_dir().join(format!("{id}_store")); - let _ = fs::create_dir_all(&store); - install_package_to(&archive, &store).unwrap(); - assert!(store.join(&app_id).join("app.wasm").exists()); + let store = std::env::temp_dir().join(format!("{id}_store")); + let _ = fs::create_dir_all(&store); + install_package_to(&archive, &store, InstallMode::Development).unwrap(); + assert!(store.join(&app_id).join("app.wasm").exists()); - let _ = fs::remove_dir_all(&src); - let _ = fs::remove_dir_all(&bundle_dir); - let _ = fs::remove_dir_all(&store); + let _ = fs::remove_dir_all(&src); + let _ = fs::remove_dir_all(&bundle_dir); + let _ = fs::remove_dir_all(&store); + }); + let _ = std::fs::remove_dir_all(&home); } #[test] @@ -1181,7 +1449,7 @@ entry = "ui/index.html" sign_package(&dir, &key_file).unwrap(); assert!(dir.join("signature.sig").exists()); - let ok = verify_package(&dir, &pub_file).unwrap(); + let ok = verify_package(&dir, &PublisherKey::from_file(&pub_file).unwrap()).unwrap(); assert!(ok, "signature should verify"); let _ = fs::remove_dir_all(&dir); @@ -1210,7 +1478,11 @@ entry = "ui/index.html" fs::write(dir.join("app.wasm"), b"\0asm\x01\0\0\x01").unwrap(); - let ok = verify_package(&dir, &key_dir.join("weft-sign.pub")).unwrap(); + let ok = verify_package( + &dir, + &PublisherKey::from_file(&key_dir.join("weft-sign.pub")).unwrap(), + ) + .unwrap(); assert!(!ok, "tampered bundle should not verify"); let _ = fs::remove_dir_all(&dir); diff --git a/docs/architecture.md b/docs/architecture.md index ee92a31..4a94562 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -28,7 +28,7 @@ WASI Preview 2 + Component Model execution host (Wasmtime 30). Runs the componen ### weft-pack -Package management CLI. Subcommands: `check` (validate wapp.toml + wasm module), `sign` (Ed25519 signature), `verify` (verify signature), `generate-key`, `install`, `uninstall`, `list`, `build-image` (EROFS dm-verity), `info`. +Package management CLI. Subcommands: `check` (validate wapp.toml, entries and package content), `sign` (Ed25519 signature over every file), `verify` (verify signature), `generate-key`, `install` (requires a signature by a trusted key unless `--dev`; records the app ID's owner), `uninstall`, `list`, `build-image` (EROFS dm-verity), `info`. ### weft-file-portal @@ -102,7 +102,7 @@ Fetch grants name hosts, not addresses: ports are not restricted, and a host tha app.wasm — WASI Component Model binary ui/ index.html — entry point served by weft-app-shell - signature.sig — Ed25519 signature over SHA-256 of (wapp.toml + app.wasm) + signature.sig — Ed25519 signature over the content digest of every other file (see security.md) ``` Package store roots (in priority order): diff --git a/docs/building.md b/docs/building.md index fca337a..141b217 100644 --- a/docs/building.md +++ b/docs/building.md @@ -125,6 +125,16 @@ weft-pack sign ./examples/org.weft.demo.counter --key ./keys/weft-sign.key weft-pack verify ./examples/org.weft.demo.counter --key ./keys/weft-sign.pub ``` +Installation requires a signature by a trusted key. To install the demos with the demo key, trust it for your user (the key is a test fixture; do not trust it on a system you depend on): + +```sh +mkdir -p ~/.config/weft/trusted-keys +cp examples/keys/weft-sign.pub ~/.config/weft/trusted-keys/weft-demo.pub +weft-pack install examples/org.weft.demo.notes +``` + +Unsigned packages under development install with `weft-pack install --dev`, recorded as development content. See `docs/security.md` for the trust store and app ID ownership. + ## NixOS VM (requires Nix with flakes) Build the VM image: diff --git a/docs/security.md b/docs/security.md index 09a6b4a..cd25cc1 100644 --- a/docs/security.md +++ b/docs/security.md @@ -18,11 +18,17 @@ Each app session runs as a separate OS process (`weft-runtime`). When systemd is Apps access the filesystem only through WASI preopened directories. Each capability maps to a specific host path preopened at a fixed guest path. The `weft-file-portal` process applies the same directory grants and access modes, but checks paths lexically: it blocks `..` traversal, not symbolic links. Components cannot currently reach its socket, since the runtime grants them no socket access. -## Package Signing +## Package Signing and Trust -Packages are signed with Ed25519 (`ed25519-dalek`). The signature covers the SHA-256 hash of `wapp.toml` and `app.wasm`. `weft-pack verify` checks the signature before installation. +Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -For verified read-only package storage, `weft-pack build-image` produces an EROFS image protected with dm-verity. Mounting requires the setuid `weft-mount-helper` which calls `veritysetup`. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. + +The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. The demo key in `examples/keys` is a test fixture, not a signing authority. + +Not yet covered: `weft-appd` does not check signatures or owners at launch, so the installed directory is trusted as installed; key revocation, rotation and ownership transfer have no workflow; and capabilities are granted at launch without asking the user, independently of the signature. + +For verified read-only package storage, `weft-pack build-image` produces an EROFS image protected with dm-verity. Mounting requires the setuid `weft-mount-helper` which calls `veritysetup`. The image's root hash is not yet authenticated (see `architecture.md`). ## Seccomp From d175bf012e574e4dd47d75457c921fa90317ba0f Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 13:59:54 +0000 Subject: [PATCH 2/9] fix(pack): normalize installed modes and never leave a partial or orphaned owner record Installed files take fixed modes (0644, or 0755 when executable) and directories 0755, so a world-writable source cannot install as such. An owner record created by an installation whose package then fails to be placed is removed, and records are written under a temporary name and linked into place, so they are never partial. Archives unpack into a random private directory that is always removed. Uninstall frees an ID only when the app data is truly absent, signatures are checked with verify_strict, and list marks development installs. --- crates/weft-ipc-types/src/trust.rs | 36 +++- crates/weft-pack/src/main.rs | 288 ++++++++++++++++++++++++----- docs/building.md | 2 +- docs/security.md | 4 +- 4 files changed, 268 insertions(+), 62 deletions(-) diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs index dc9dfd6..7c00111 100644 --- a/crates/weft-ipc-types/src/trust.rs +++ b/crates/weft-ipc-types/src/trust.rs @@ -10,7 +10,7 @@ use std::fmt; use std::path::{Path, PathBuf}; -use ed25519_dalek::{Signature, Verifier, VerifyingKey}; +use ed25519_dalek::{Signature, VerifyingKey}; use sha2::{Digest, Sha256}; /// The signature file at the root of a signed package. @@ -127,7 +127,7 @@ impl PublisherKey { /// Whether `signature` signs `digest` with this key. pub fn signed(&self, digest: &[u8; 32], signature: &Signature) -> bool { - self.0.verify(digest, signature).is_ok() + self.0.verify_strict(digest, signature).is_ok() } } @@ -261,7 +261,9 @@ pub fn read_owner(record: &Path) -> Result, TrustError> { } } -/// Records the owner of an app ID. An existing record is never replaced. +/// Records the owner of an app ID. An existing record is never replaced, and +/// a record is either absent or complete: it is written and synced under a +/// temporary name, then linked into place. pub fn write_owner(record: &Path, owner: Owner) -> Result<(), TrustError> { use std::io::Write; let parent = record.parent().expect("owner records live in a directory"); @@ -270,13 +272,27 @@ pub fn write_owner(record: &Path, owner: Owner) -> Result<(), TrustError> { Owner::Verified(key) => format!("verified {}\n", key.to_hex()), Owner::Development => "development\n".to_owned(), }; - let mut file = std::fs::OpenOptions::new() - .write(true) - .create_new(true) - .open(record) - .map_err(io(record))?; - file.write_all(text.as_bytes()).map_err(io(record))?; - file.sync_all().map_err(io(record)) + let name = record + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or("record"); + let temp = parent.join(format!(".{name}.{}.tmp", std::process::id())); + let _ = std::fs::remove_file(&temp); + let written = (|| { + let mut file = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(&temp)?; + file.write_all(text.as_bytes())?; + file.sync_all() + })() + .map_err(io(&temp)); + let linked = written.and_then(|()| std::fs::hard_link(&temp, record).map_err(io(record))); + let _ = std::fs::remove_file(&temp); + linked?; + std::fs::File::open(parent) + .and_then(|dir| dir.sync_all()) + .map_err(io(parent)) } #[cfg(test)] diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index df905d5..38131f6 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -263,31 +263,44 @@ fn install_package(path: &Path, mode: InstallMode) -> anyhow::Result<()> { } fn install_package_to(path: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Result<()> { - let dir_buf; - let dir: &Path = if path.extension().is_some_and(|e| e == "zst" || e == "tar") - || path.to_string_lossy().ends_with(".app.tar.zst") + std::fs::create_dir_all(store_root) + .with_context(|| format!("create {}", store_root.display()))?; + if !(path.extension().is_some_and(|e| e == "zst" || e == "tar") + || path.to_string_lossy().ends_with(".app.tar.zst")) { - let tmp = std::env::temp_dir().join(format!( - "weft-install-{}", - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .subsec_nanos() - )); - std::fs::create_dir_all(&tmp) - .with_context(|| format!("create temp dir {}", tmp.display()))?; - unbundle_package(path, &tmp)?; - let name = path - .file_name() - .and_then(|n| n.to_str()) - .and_then(|n| n.strip_suffix(".app.tar.zst")) - .context("cannot determine app_id from archive filename")?; - dir_buf = tmp.join(name); - &dir_buf - } else { - path - }; + return install_dir(path, store_root, mode); + } + let name = path + .file_name() + .and_then(|n| n.to_str()) + .and_then(|n| n.strip_suffix(".app.tar.zst")) + .context("cannot determine app_id from archive filename")?; + // A fresh private directory in the store, removed whatever happens, so + // nothing can be planted in it and nothing is left behind. + let unpacked = private_scratch_dir(store_root, ".unpack")?; + let result = unbundle_package(path, &unpacked) + .and_then(|()| install_dir(&unpacked.join(name), store_root, mode)); + let _ = std::fs::remove_dir_all(&unpacked); + result +} +/// Creates a new directory with a random name in `parent`, accessible only to +/// the user. +fn private_scratch_dir(parent: &Path, prefix: &str) -> anyhow::Result { + let dir = parent.join(format!( + "{prefix}-{}", + hex::encode(rand::random::<[u8; 8]>()) + )); + let mut builder = std::fs::DirBuilder::new(); + #[cfg(unix)] + std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o700); + builder + .create(&dir) + .with_context(|| format!("create {}", dir.display()))?; + Ok(dir) +} + +fn install_dir(dir: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Result<()> { check_package(dir)?; let manifest = load_manifest(dir)?; let app_id = &manifest.package.id; @@ -312,36 +325,53 @@ fn install_package_to(path: &Path, store_root: &Path, mode: InstallMode) -> anyh // The package is copied into the store first and every decision is made // on that copy, so the bytes that are checked and trusted are the bytes // that become installed. Only then does one rename make it available. - std::fs::create_dir_all(store_root) - .with_context(|| format!("create {}", store_root.display()))?; let staging = store_root.join(format!( ".staging-{app_id}-{}", hex::encode(rand::random::<[u8; 8]>()) )); - let staged = copy_dir(dir, &staging) + let admitted = copy_dir(dir, &staging) .with_context(|| format!("copy {} -> {}", dir.display(), staging.display())) - .and_then(|()| admit(&staging, app_id, mode)) - .and_then(|owner| { - weft_ipc_types::package::rename_no_replace(&staging, &dest) - .with_context(|| format!("move {} -> {}", staging.display(), dest.display()))?; - Ok(owner) - }); - let owner = match staged { - Ok(owner) => owner, + .and_then(|()| admit(&staging, app_id, mode)); + let admission = match admitted { + Ok(admission) => admission, Err(e) => { let _ = std::fs::remove_dir_all(&staging); return Err(e); } }; + let owner = admission.owner; + place(&staging, &dest, admission)?; println!("installed {} -> {} ({owner})", app_id, dest.display()); Ok(()) } +/// The owner a staged package was admitted under, and the owner record this +/// installation created, if any. +struct Admission { + owner: Owner, + created_record: Option, +} + +/// Makes the staged package available at `dest`. If that fails, the staging +/// copy is removed, and so is an owner record this installation created, so +/// a failed first installation leaves no claim on the app ID. +fn place(staging: &Path, dest: &Path, admission: Admission) -> anyhow::Result<()> { + if let Err(e) = weft_ipc_types::package::rename_no_replace(staging, dest) { + let _ = std::fs::remove_dir_all(staging); + if let Some(record) = &admission.created_record { + let _ = std::fs::remove_file(record); + } + return Err(e).with_context(|| format!("move {} -> {}", staging.display(), dest.display())); + } + Ok(()) +} + /// Checks the staged copy of a package and establishes who owns its app ID: /// the trusted publisher that signed it, or, only when asked, development. /// The first installation of an ID records its owner, and every later one -/// must have the same owner. -fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result { +/// must have the same owner. The record is written before the package is +/// placed, so concurrent installations by different owners cannot both win. +fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result { use weft_ipc_types::trust::{owner_record_path, read_owner, write_owner}; check_package(staged)?; let manifest = load_manifest(staged)?; @@ -369,15 +399,21 @@ fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result {} + let created_record = match read_owner(&record)? { + Some(existing) if existing == owner => None, Some(existing) => anyhow::bail!( "{app_id} belongs to {existing}; this package is {owner}. Its app data stays with \ its owner, so another publisher or a development build cannot take the ID over" ), - None => write_owner(&record, owner)?, - } - Ok(owner) + None => { + write_owner(&record, owner)?; + Some(record) + } + }; + Ok(Admission { + owner, + created_record, + }) } fn uninstall_package(app_id: &str) -> anyhow::Result<()> { @@ -424,7 +460,7 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> // while the data remains; with no data left, the ID is free again. if let Some(data_home) = weft_ipc_types::package::data_home() && std::fs::symlink_metadata(weft_ipc_types::package::app_data_dir(&data_home, app_id)) - .is_err() + .is_err_and(|e| e.kind() == std::io::ErrorKind::NotFound) { let _ = std::fs::remove_file(weft_ipc_types::trust::owner_record_path(&data_home, app_id)); } @@ -524,7 +560,20 @@ fn list_installed() { continue; } if seen.insert(m.package.id.clone()) { - pkgs.push((m.package.id, m.package.name, m.package.version)); + let development = weft_ipc_types::package::data_home().is_some_and(|home| { + matches!( + weft_ipc_types::trust::read_owner( + &weft_ipc_types::trust::owner_record_path(&home, &m.package.id) + ), + Ok(Some(Owner::Development)) + ) + }); + let version = if development { + format!("{} (development)", m.package.version) + } else { + m.package.version + }; + pkgs.push((m.package.id, m.package.name, version)); } } pkgs.sort_by(|a, b| a.0.cmp(&b.0)); @@ -540,18 +589,25 @@ fn list_installed() { /// Copies a package directory. Packages hold only directories and regular /// files, so a symbolic link or special file stops the copy rather than -/// being followed. +/// being followed. Modes are not copied: the signature does not cover them, +/// so installed directories are 0755 and files 0644, or 0755 when the source +/// is executable, and nothing installed is writable by other users. fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { - std::fs::create_dir(dst).with_context(|| format!("create {}", dst.display()))?; + let mut builder = std::fs::DirBuilder::new(); + #[cfg(unix)] + std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o755); + builder + .create(dst) + .with_context(|| format!("create {}", dst.display()))?; for entry in std::fs::read_dir(src)? { let entry = entry?; let src_path = entry.path(); let dst_path = dst.join(entry.file_name()); - let kind = std::fs::symlink_metadata(&src_path)?.file_type(); - if kind.is_dir() { + let metadata = std::fs::symlink_metadata(&src_path)?; + if metadata.is_dir() { copy_dir(&src_path, &dst_path)?; - } else if kind.is_file() { - std::fs::copy(&src_path, &dst_path) + } else if metadata.is_file() { + copy_file(&src_path, &dst_path, &metadata) .with_context(|| format!("copy {}", src_path.display()))?; } else { anyhow::bail!( @@ -563,6 +619,22 @@ fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { Ok(()) } +fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::Result<()> { + let mut options = std::fs::OpenOptions::new(); + options.write(true).create_new(true); + #[cfg(unix)] + { + use std::os::unix::fs::{OpenOptionsExt, PermissionsExt}; + let executable = metadata.permissions().mode() & 0o111 != 0; + options.mode(if executable { 0o755 } else { 0o644 }); + } + #[cfg(not(unix))] + let _ = metadata; + let mut target = options.open(dst)?; + std::io::copy(&mut std::fs::File::open(src)?, &mut target)?; + Ok(()) +} + fn build_image(dir: &Path, out_path: Option<&Path>) -> anyhow::Result<()> { let manifest = load_manifest(dir)?; let app_id = &manifest.package.id; @@ -936,6 +1008,119 @@ mod tests { let _ = std::fs::remove_dir_all(&home); } + #[test] + fn a_development_id_does_not_become_verified() { + let home = temp_root("dev_owned"); + let store = home.join("store"); + let app_id = "org.weft.test.devowned"; + write_package(&home.join("src"), app_id, APP_DATA); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); + let data = weft_ipc_types::package::app_data_dir(&home.join("share"), app_id); + std::fs::create_dir_all(&data).unwrap(); + with_trust(&home, || uninstall_package_from(app_id, &store)).unwrap(); + + sign_package(&home.join("src"), &key(&home, "publisher", 7, true)).unwrap(); + let refused = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Verified) + }); + let message = format!("{:#}", refused.unwrap_err()); + assert!(message.contains("belongs to development"), "{message}"); + assert!(!store.join(app_id).exists()); + assert_eq!(owner_of(&home, app_id), Some(Owner::Development)); + let _ = std::fs::remove_dir_all(&home); + } + + #[test] + fn a_failed_placement_leaves_no_claim_on_the_id() { + let home = temp_root("placement"); + let staging = home.join(".staging-x"); + let dest = home.join("org.weft.test.placed"); + std::fs::create_dir_all(&staging).unwrap(); + std::fs::create_dir_all(dest.join("ui")).unwrap(); + let record = home.join("owners/org.weft.test.placed"); + weft_ipc_types::trust::write_owner(&record, Owner::Development).unwrap(); + + let admission = Admission { + owner: Owner::Development, + created_record: Some(record.clone()), + }; + assert!(place(&staging, &dest, admission).is_err()); + assert!(!staging.exists()); + assert!(!record.exists()); + assert!( + dest.join("ui").is_dir(), + "the existing package is untouched" + ); + + // A record that existed before this installation is kept. + std::fs::create_dir_all(&staging).unwrap(); + weft_ipc_types::trust::write_owner(&record, Owner::Development).unwrap(); + let admission = Admission { + owner: Owner::Development, + created_record: None, + }; + assert!(place(&staging, &dest, admission).is_err()); + assert!(record.exists()); + let _ = std::fs::remove_dir_all(&home); + } + + #[cfg(unix)] + #[test] + fn installed_files_are_not_writable_by_others() { + use std::os::unix::fs::PermissionsExt; + let home = temp_root("modes"); + let store = home.join("store"); + let app_id = "org.weft.test.modes"; + write_package(&home.join("src"), app_id, ""); + let set = |rel: &str, mode: u32| { + std::fs::set_permissions( + home.join("src").join(rel), + std::fs::Permissions::from_mode(mode), + ) + .unwrap() + }; + set("ui/index.html", 0o666); + set("app.wasm", 0o777); + set("ui", 0o777); + with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }) + .unwrap(); + let mode = |rel: &str| { + std::fs::metadata(store.join(app_id).join(rel)) + .unwrap() + .permissions() + .mode() + & 0o777 + }; + assert_eq!(mode("ui/index.html"), 0o644); + assert_eq!(mode("app.wasm"), 0o755); + assert_eq!(mode("ui"), 0o755); + let _ = std::fs::remove_dir_all(&home); + } + + #[cfg(target_os = "linux")] + #[test] + fn packages_with_non_utf8_names_are_refused() { + use std::os::unix::ffi::OsStrExt; + let home = temp_root("non_utf8"); + let store = home.join("store"); + let app_id = "org.weft.test.nonutf8"; + write_package(&home.join("src"), app_id, ""); + let name = std::ffi::OsStr::from_bytes(b"ui/\xff.html"); + std::fs::write(home.join("src").join(name), b"").unwrap(); + let refused = with_trust(&home, || { + install_package_to(&home.join("src"), &store, InstallMode::Development) + }); + assert!(refused.is_err()); + assert!(!store.join(app_id).exists()); + assert!(!staging_left(&store)); + let _ = std::fs::remove_dir_all(&home); + } + #[test] fn uninstall_keeps_app_data_from_the_user_store() { let home = temp_root("keep"); @@ -1381,6 +1566,11 @@ entry = "ui/index.html" let _ = fs::create_dir_all(&store); install_package_to(&archive, &store, InstallMode::Development).unwrap(); assert!(store.join(&app_id).join("app.wasm").exists()); + let scratch_left = fs::read_dir(&store).unwrap().flatten().any(|e| { + let name = e.file_name().to_string_lossy().into_owned(); + name.starts_with(".unpack") || name.starts_with(".staging-") + }); + assert!(!scratch_left, "archive install left scratch directories"); let _ = fs::remove_dir_all(&src); let _ = fs::remove_dir_all(&bundle_dir); diff --git a/docs/building.md b/docs/building.md index 141b217..5afe1d9 100644 --- a/docs/building.md +++ b/docs/building.md @@ -133,7 +133,7 @@ cp examples/keys/weft-sign.pub ~/.config/weft/trusted-keys/weft-demo.pub weft-pack install examples/org.weft.demo.notes ``` -Unsigned packages under development install with `weft-pack install --dev`, recorded as development content. See `docs/security.md` for the trust store and app ID ownership. +Unsigned packages under development install with `weft-pack install --dev`, recorded as development content and marked `(development)` by `weft-pack list`. See `docs/security.md` for the trust store and app ID ownership. ## NixOS VM (requires Nix with flakes) diff --git a/docs/security.md b/docs/security.md index cd25cc1..deba623 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,9 +22,9 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. -The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. The demo key in `examples/keys` is a test fixture, not a signing authority. +The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. The demo key in `examples/keys` is a test fixture, not a signing authority. Not yet covered: `weft-appd` does not check signatures or owners at launch, so the installed directory is trusted as installed; key revocation, rotation and ownership transfer have no workflow; and capabilities are granted at launch without asking the user, independently of the signature. From 39f7ca2a3f016fc6099cafa802fe5cb2ff24b329 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:04:53 +0000 Subject: [PATCH 3/9] fix(pack): close inventory forgery, serialize ownership changes and refuse to follow links Names with control characters have no content digest, so a crafted name can no longer reproduce other inventory lines and drop signed files. Installs and uninstalls of an ID hold a per-ID lock, so a failed concurrent install cannot remove the record of the one that won. App data without a recorded owner goes to a new owner only with --claim-data. Uninstall releases a record left by an interrupted install once no data remains. Files are opened without following links and, on Linux, must be the file that was listed. --- Cargo.lock | 1 + crates/weft-ipc-types/src/trust.rs | 62 ++++++++- crates/weft-pack/Cargo.toml | 1 + crates/weft-pack/src/main.rs | 193 +++++++++++++++++++++++++---- docs/security.md | 6 +- 5 files changed, 232 insertions(+), 31 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bc4cf59..65456f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10542,6 +10542,7 @@ dependencies = [ "anyhow", "ed25519-dalek", "hex", + "libc", "rand 0.8.5", "sha2", "tar", diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs index 7c00111..0d52d8e 100644 --- a/crates/weft-ipc-types/src/trust.rs +++ b/crates/weft-ipc-types/src/trust.rs @@ -4,8 +4,9 @@ //! A package is signed over its content digest: the SHA-256 of a canonical //! inventory listing every file except the root `signature.sig`, one //! `\t\n` line per file, sorted by path. Paths use -//! `/` and must be UTF-8. Symbolic links and special files are refused, so the -//! signed bytes are exactly the files a package holds. +//! `/` and must be UTF-8 without control characters, so no name can imitate +//! the separators of other lines. Symbolic links and special files are +//! refused, so the signed bytes are exactly the files a package holds. use std::fmt; use std::path::{Path, PathBuf}; @@ -25,6 +26,8 @@ pub enum TrustError { NotAFile(PathBuf), /// A path in the package is not UTF-8. NonUtf8(PathBuf), + /// A name in the package holds a control character. + ControlCharacter(PathBuf), /// A key, signature or owner record is malformed. Malformed(PathBuf, String), Io(PathBuf, std::io::Error), @@ -36,6 +39,9 @@ impl fmt::Display for TrustError { Self::Link(p) => write!(f, "{} is a symbolic link", p.display()), Self::NotAFile(p) => write!(f, "{} is not a regular file or directory", p.display()), Self::NonUtf8(p) => write!(f, "{} is not a UTF-8 path", p.display()), + Self::ControlCharacter(p) => { + write!(f, "{:?} has a control character in its name", p.display()) + } Self::Malformed(p, why) => write!(f, "{}: {why}", p.display()), Self::Io(p, e) => write!(f, "{}: {e}", p.display()), } @@ -76,6 +82,9 @@ fn collect( .to_str() .ok_or_else(|| TrustError::NonUtf8(path.clone()))? .to_owned(); + if relative.chars().any(char::is_control) { + return Err(TrustError::ControlCharacter(path)); + } let kind = std::fs::symlink_metadata(&path) .map_err(io(&path))? .file_type(); @@ -295,6 +304,22 @@ pub fn write_owner(record: &Path, owner: Owner) -> Result<(), TrustError> { .map_err(io(parent)) } +/// Takes the lock that serialises every change to the installation and +/// owner record of `app_id`, held until the returned file is dropped. +pub fn lock_owner(data_home: &Path, app_id: &str) -> Result { + let dir = data_home.join("weft/owners"); + std::fs::create_dir_all(&dir).map_err(io(&dir))?; + let path = dir.join(format!(".{app_id}.lock")); + let file = std::fs::OpenOptions::new() + .write(true) + .create(true) + .truncate(false) + .open(&path) + .map_err(io(&path))?; + file.lock().map_err(io(&path))?; + Ok(file) +} + #[cfg(test)] mod tests { use super::*; @@ -356,6 +381,39 @@ mod tests { std::fs::remove_dir_all(&dir).unwrap(); } + #[cfg(unix)] + #[test] + fn names_cannot_imitate_other_inventory_lines() { + // With files ui/policy.txt and ui/z.css signed, a directory named + // "ui/policy.txt\t\nui" holding z.css would reproduce the + // inventory without policy.txt. Such names have no digest. + let dir = dir("forged"); + std::fs::write(dir.join("ui/policy.txt"), b"default-src 'self'").unwrap(); + std::fs::write(dir.join("ui/z.css"), b"p{}").unwrap(); + let signed = content_digest(&dir).unwrap(); + let policy_hash = hex::encode(Sha256::digest(b"default-src 'self'")); + std::fs::remove_file(dir.join("ui/policy.txt")).unwrap(); + let forged = dir.join(format!("ui/policy.txt\t{policy_hash}\nui")); + std::fs::create_dir_all(&forged).unwrap(); + std::fs::rename(dir.join("ui/z.css"), forged.join("z.css")).unwrap(); + let refused = content_digest(&dir); + assert!(matches!(refused, Err(TrustError::ControlCharacter(_)))); + assert_ne!(refused.ok(), Some(signed)); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[test] + fn owner_locks_exclude_each_other() { + let home = std::env::temp_dir().join(format!("weft_trust_lock_{}", std::process::id())); + let held = lock_owner(&home, "org.weft.test.lock").unwrap(); + let path = home.join("weft/owners/.org.weft.test.lock.lock"); + let other = std::fs::OpenOptions::new().write(true).open(&path).unwrap(); + assert!(other.try_lock().is_err()); + drop(held); + assert!(other.try_lock().is_ok()); + std::fs::remove_dir_all(&home).unwrap(); + } + #[cfg(target_os = "linux")] #[test] fn links_and_special_files_have_no_content_digest() { diff --git a/crates/weft-pack/Cargo.toml b/crates/weft-pack/Cargo.toml index c580df4..ab8db04 100644 --- a/crates/weft-pack/Cargo.toml +++ b/crates/weft-pack/Cargo.toml @@ -15,5 +15,6 @@ ed25519-dalek = { version = "2", features = ["rand_core"] } sha2 = "0.10" rand = "0.8" hex = "0.4" +libc = "0.2" tar = "0.4" zstd = "0.13" diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 38131f6..b3f5ee7 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -20,14 +20,18 @@ fn main() -> anyhow::Result<()> { print_info(&manifest); } Some("install") => { - let usage = "usage: weft-pack install [--dev]"; + let usage = "usage: weft-pack install [--dev] [--claim-data]"; let dir = args.get(2).context(usage)?; - let mode = match args.get(3).map(String::as_str) { - None => InstallMode::Verified, - Some("--dev") => InstallMode::Development, - Some(other) => anyhow::bail!("unexpected argument '{other}'; {usage}"), - }; - install_package(Path::new(dir), mode)?; + let mut mode = InstallMode::Verified; + let mut claim_data = false; + for arg in &args[3..] { + match arg.as_str() { + "--dev" => mode = InstallMode::Development, + "--claim-data" => claim_data = true, + other => anyhow::bail!("unexpected argument '{other}'; {usage}"), + } + } + install_package(Path::new(dir), mode, claim_data)?; } Some("uninstall") => { let app_id = args.get(2).context("usage: weft-pack uninstall ")?; @@ -109,7 +113,10 @@ fn main() -> anyhow::Result<()> { " weft-pack install [--dev] install a package signed by a trusted key" ); eprintln!( - " (--dev: unsigned development content)" + " (--dev: unsigned development content;" + ); + eprintln!( + " --claim-data: adopt app data with no owner)" ); eprintln!(" weft-pack uninstall remove installed package"); eprintln!(" weft-pack list list installed packages"); @@ -257,18 +264,32 @@ enum InstallMode { Development, } -fn install_package(path: &Path, mode: InstallMode) -> anyhow::Result<()> { +fn install_package(path: &Path, mode: InstallMode, claim_data: bool) -> anyhow::Result<()> { let root = resolve_install_root()?; - install_package_to(path, &root, mode) + install_into(path, &root, mode, claim_data) } +#[cfg(test)] fn install_package_to(path: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Result<()> { + install_into(path, store_root, mode, false) +} + +/// Installs the package at `path` into `store_root`. App data that exists +/// for the ID without a recorded owner, as left by an installation that +/// predates owner records, goes to this package's owner only with +/// `claim_data`. +fn install_into( + path: &Path, + store_root: &Path, + mode: InstallMode, + claim_data: bool, +) -> anyhow::Result<()> { std::fs::create_dir_all(store_root) .with_context(|| format!("create {}", store_root.display()))?; if !(path.extension().is_some_and(|e| e == "zst" || e == "tar") || path.to_string_lossy().ends_with(".app.tar.zst")) { - return install_dir(path, store_root, mode); + return install_dir(path, store_root, mode, claim_data); } let name = path .file_name() @@ -279,7 +300,7 @@ fn install_package_to(path: &Path, store_root: &Path, mode: InstallMode) -> anyh // nothing can be planted in it and nothing is left behind. let unpacked = private_scratch_dir(store_root, ".unpack")?; let result = unbundle_package(path, &unpacked) - .and_then(|()| install_dir(&unpacked.join(name), store_root, mode)); + .and_then(|()| install_dir(&unpacked.join(name), store_root, mode, claim_data)); let _ = std::fs::remove_dir_all(&unpacked); result } @@ -300,11 +321,21 @@ fn private_scratch_dir(parent: &Path, prefix: &str) -> anyhow::Result { Ok(dir) } -fn install_dir(dir: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Result<()> { +fn install_dir( + dir: &Path, + store_root: &Path, + mode: InstallMode, + claim_data: bool, +) -> anyhow::Result<()> { check_package(dir)?; let manifest = load_manifest(dir)?; let app_id = &manifest.package.id; let dest = store_root.join(app_id); + let data_home = weft_ipc_types::package::data_home() + .context("cannot locate the data home to record who owns the app ID")?; + // Installations and uninstallations of one ID run one at a time, so the + // owner record always describes the package that is placed. + let _lock = weft_ipc_types::trust::lock_owner(&data_home, app_id)?; // An earlier weft-appd could leave only app data, or an empty directory, // where the package now goes; move the data to its own location so it // neither blocks nor joins the package. @@ -329,9 +360,14 @@ fn install_dir(dir: &Path, store_root: &Path, mode: InstallMode) -> anyhow::Resu ".staging-{app_id}-{}", hex::encode(rand::random::<[u8; 8]>()) )); - let admitted = copy_dir(dir, &staging) + // Copied from the resolved source path, which every file opened during + // the copy is checked against. + let admitted = dir + .canonicalize() + .with_context(|| format!("resolve {}", dir.display())) + .and_then(|source| copy_dir(&source, &staging)) .with_context(|| format!("copy {} -> {}", dir.display(), staging.display())) - .and_then(|()| admit(&staging, app_id, mode)); + .and_then(|()| admit(&staging, app_id, mode, &data_home, claim_data)); let admission = match admitted { Ok(admission) => admission, Err(e) => { @@ -371,7 +407,13 @@ fn place(staging: &Path, dest: &Path, admission: Admission) -> anyhow::Result<() /// The first installation of an ID records its owner, and every later one /// must have the same owner. The record is written before the package is /// placed, so concurrent installations by different owners cannot both win. -fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result { +fn admit( + staged: &Path, + app_id: &str, + mode: InstallMode, + data_home: &Path, + claim_data: bool, +) -> anyhow::Result { use weft_ipc_types::trust::{owner_record_path, read_owner, write_owner}; check_package(staged)?; let manifest = load_manifest(staged)?; @@ -396,9 +438,7 @@ fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result None, Some(existing) => anyhow::bail!( @@ -406,6 +446,14 @@ fn admit(staged: &Path, app_id: &str, mode: InstallMode) -> anyhow::Result { + let data = weft_ipc_types::package::app_data_dir(data_home, app_id); + if std::fs::symlink_metadata(&data).is_ok() && !claim_data { + anyhow::bail!( + "{} holds app data for {app_id} with no recorded owner; install with \ + --claim-data to give it to {owner}, or move it aside", + data.display() + ); + } write_owner(&record, owner)?; Some(record) } @@ -425,8 +473,22 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> if !weft_ipc_types::package::is_valid_app_id(app_id) { anyhow::bail!("'{}' is not a valid app ID", app_id); } + let data_home = weft_ipc_types::package::data_home(); + let _lock = match &data_home { + Some(home) => Some(weft_ipc_types::trust::lock_owner(home, app_id)?), + None => None, + }; let target = store_root.join(app_id); if !target.exists() { + // An installation interrupted between recording its owner and placing + // the package leaves a record with nothing installed; with no data + // either, it holds the ID for nothing and is released. + if let Some(home) = &data_home + && release_owner_without_data(home, app_id) + { + println!("released {app_id}, which was not installed"); + return Ok(()); + } anyhow::bail!( "package '{}' is not installed at {}", app_id, @@ -458,16 +520,23 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> } // The owner record keeps the app ID, and the data with it, for its owner // while the data remains; with no data left, the ID is free again. - if let Some(data_home) = weft_ipc_types::package::data_home() - && std::fs::symlink_metadata(weft_ipc_types::package::app_data_dir(&data_home, app_id)) - .is_err_and(|e| e.kind() == std::io::ErrorKind::NotFound) - { - let _ = std::fs::remove_file(weft_ipc_types::trust::owner_record_path(&data_home, app_id)); + if let Some(home) = &data_home { + release_owner_without_data(home, app_id); } println!("uninstalled {}", app_id); Ok(()) } +/// Removes the owner record of `app_id` when the app has no data, and +/// reports whether a record was removed. +fn release_owner_without_data(data_home: &Path, app_id: &str) -> bool { + let no_data = + std::fs::symlink_metadata(weft_ipc_types::package::app_data_dir(data_home, app_id)) + .is_err_and(|e| e.kind() == std::io::ErrorKind::NotFound); + no_data + && std::fs::remove_file(weft_ipc_types::trust::owner_record_path(data_home, app_id)).is_ok() +} + /// Whether a package directory is empty or contains nothing but `data`. fn only_holds_app_data(package_dir: &Path) -> anyhow::Result { let entries = std::fs::read_dir(package_dir) @@ -620,6 +689,7 @@ fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { } fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::Result<()> { + let source = open_regular_file(src)?; let mut options = std::fs::OpenOptions::new(); options.write(true).create_new(true); #[cfg(unix)] @@ -631,10 +701,36 @@ fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::R #[cfg(not(unix))] let _ = metadata; let mut target = options.open(dst)?; - std::io::copy(&mut std::fs::File::open(src)?, &mut target)?; + std::io::copy(&mut &source, &mut target)?; Ok(()) } +/// Opens `src` for reading only if it is still the regular file it was when +/// listed: the last component is not followed, and on Linux the opened file +/// must be at `src` itself, so a link swapped in for any directory on the way +/// cannot redirect the copy outside the package. +fn open_regular_file(src: &Path) -> std::io::Result { + let mut options = std::fs::OpenOptions::new(); + options.read(true); + #[cfg(unix)] + std::os::unix::fs::OpenOptionsExt::custom_flags(&mut options, libc::O_NOFOLLOW); + let file = options.open(src)?; + let changed = + || std::io::Error::other(format!("{} changed while it was copied", src.display())); + if !file.metadata()?.is_file() { + return Err(changed()); + } + #[cfg(target_os = "linux")] + { + use std::os::fd::AsRawFd; + let opened = std::fs::read_link(format!("/proc/self/fd/{}", file.as_raw_fd()))?; + if opened != src { + return Err(changed()); + } + } + Ok(file) +} + fn build_image(dir: &Path, out_path: Option<&Path>) -> anyhow::Result<()> { let manifest = load_manifest(dir)?; let app_id = &manifest.package.id; @@ -1121,6 +1217,43 @@ mod tests { let _ = std::fs::remove_dir_all(&home); } + #[test] + fn uninstall_releases_a_record_left_by_an_interrupted_install() { + let home = temp_root("interrupted"); + let store = home.join("store"); + let app_id = "org.weft.test.interrupted"; + let record = weft_ipc_types::trust::owner_record_path(&home.join("share"), app_id); + weft_ipc_types::trust::write_owner(&record, Owner::Development).unwrap(); + let data = weft_ipc_types::package::app_data_dir(&home.join("share"), app_id); + std::fs::create_dir_all(&data).unwrap(); + + // While data remains the record stays, and uninstall reports nothing + // installed. + assert!(with_home(&home, || uninstall_package_from(app_id, &store)).is_err()); + assert!(record.exists()); + std::fs::remove_dir_all(&data).unwrap(); + with_home(&home, || uninstall_package_from(app_id, &store)).unwrap(); + assert!(!record.exists()); + let _ = std::fs::remove_dir_all(&home); + } + + #[cfg(target_os = "linux")] + #[test] + fn copies_never_follow_links_swapped_in() { + let home = temp_root("swapped"); + std::fs::create_dir_all(home.join("outside")).unwrap(); + std::fs::write(home.join("outside/secret"), b"secret").unwrap(); + std::fs::create_dir_all(home.join("pkg")).unwrap(); + let root = home.canonicalize().unwrap(); + // A file replaced by a link, and a directory replaced by a link. + std::os::unix::fs::symlink(root.join("outside/secret"), root.join("pkg/file")).unwrap(); + std::os::unix::fs::symlink(root.join("outside"), root.join("pkg/dir")).unwrap(); + assert!(open_regular_file(&root.join("pkg/file")).is_err()); + assert!(open_regular_file(&root.join("pkg/dir/secret")).is_err()); + assert!(open_regular_file(&root.join("outside/secret")).is_ok()); + let _ = std::fs::remove_dir_all(&home); + } + #[test] fn uninstall_keeps_app_data_from_the_user_store() { let home = temp_root("keep"); @@ -1263,8 +1396,16 @@ mod tests { std::fs::create_dir_all(store.join(app_id).join("data")).unwrap(); std::fs::write(store.join(app_id).join("data/x"), "x").unwrap(); - with_home(&home, || { + // The moved data has no recorded owner, so it is given to this + // package only when asked. + let unclaimed = with_home(&home, || { install_package_to(&home.join("src"), &store, InstallMode::Development) + }); + let message = format!("{:#}", unclaimed.unwrap_err()); + assert!(message.contains("--claim-data"), "{message}"); + assert!(!store.join(app_id).join("wapp.toml").exists()); + with_home(&home, || { + install_into(&home.join("src"), &store, InstallMode::Development, true) }) .unwrap(); assert!(store.join(app_id).join("wapp.toml").exists()); diff --git a/docs/security.md b/docs/security.md index deba623..6fcab73 100644 --- a/docs/security.md +++ b/docs/security.md @@ -20,11 +20,11 @@ Apps access the filesystem only through WASI preopened directories. Each capabil ## Package Signing and Trust -Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. +Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Files are copied without following links, and on Linux each opened file must be the file the copy listed. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. -The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. The demo key in `examples/keys` is a test fixture, not a signing authority. +The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID hold a per-ID lock, so the record always describes the package placed. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. The demo key in `examples/keys` is a test fixture, not a signing authority. Not yet covered: `weft-appd` does not check signatures or owners at launch, so the installed directory is trusted as installed; key revocation, rotation and ownership transfer have no workflow; and capabilities are granted at launch without asking the user, independently of the signature. From c64ee531ee3db6dcaa10a57e5fdd775d8d60a503 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:13:18 +0000 Subject: [PATCH 4/9] fix(pack): take the app ID from the staged copy and check copied file identity The app ID now comes from the staged copy, so a source changed after validation cannot steer paths outside the store or the owners directory, and lock_owner refuses invalid IDs. Copied files must keep the device and inode they were listed with, and are opened without following links or blocking on FIFOs, which no longer depends on /proc. Uninstall keeps an owner record while another known store holds the package, and a failure to inspect app data refuses rather than counting as no data. --- Cargo.lock | 1 + crates/weft-ipc-types/src/trust.rs | 9 +- crates/weft-pack/Cargo.toml | 3 + crates/weft-pack/src/main.rs | 202 +++++++++++++++++++---------- docs/security.md | 4 +- 5 files changed, 150 insertions(+), 69 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 65456f1..d3077df 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10544,6 +10544,7 @@ dependencies = [ "hex", "libc", "rand 0.8.5", + "rustix 1.1.4", "sha2", "tar", "weft-ipc-types", diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs index 0d52d8e..a6e8c45 100644 --- a/crates/weft-ipc-types/src/trust.rs +++ b/crates/weft-ipc-types/src/trust.rs @@ -249,7 +249,8 @@ impl fmt::Display for Owner { } } -/// Where the owner of `app_id` is recorded, beside the app's data. +/// Where the owner of `app_id` is recorded, beside the app's data. Callers +/// pass a valid app ID, which cannot leave the owners directory. pub fn owner_record_path(data_home: &Path, app_id: &str) -> PathBuf { data_home.join("weft/owners").join(app_id) } @@ -308,6 +309,12 @@ pub fn write_owner(record: &Path, owner: Owner) -> Result<(), TrustError> { /// owner record of `app_id`, held until the returned file is dropped. pub fn lock_owner(data_home: &Path, app_id: &str) -> Result { let dir = data_home.join("weft/owners"); + if !crate::package::is_valid_app_id(app_id) { + return Err(TrustError::Malformed( + dir, + format!("'{app_id}' is not a valid app ID"), + )); + } std::fs::create_dir_all(&dir).map_err(io(&dir))?; let path = dir.join(format!(".{app_id}.lock")); let file = std::fs::OpenOptions::new() diff --git a/crates/weft-pack/Cargo.toml b/crates/weft-pack/Cargo.toml index ab8db04..deacf4e 100644 --- a/crates/weft-pack/Cargo.toml +++ b/crates/weft-pack/Cargo.toml @@ -18,3 +18,6 @@ hex = "0.4" libc = "0.2" tar = "0.4" zstd = "0.13" + +[target.'cfg(target_os = "linux")'.dev-dependencies] +rustix = { version = "1", features = ["fs"] } diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index b3f5ee7..454073f 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -110,7 +110,7 @@ fn main() -> anyhow::Result<()> { eprintln!(" weft-pack check validate a package directory"); eprintln!(" weft-pack info print package metadata"); eprintln!( - " weft-pack install [--dev] install a package signed by a trusted key" + " weft-pack install [--dev] [--claim-data] install a package signed by a trusted key" ); eprintln!( " (--dev: unsigned development content;" @@ -328,7 +328,34 @@ fn install_dir( claim_data: bool, ) -> anyhow::Result<()> { check_package(dir)?; - let manifest = load_manifest(dir)?; + // The package is copied into the store first and every decision, the app + // ID included, is made on that copy, so the bytes that are checked and + // trusted are the bytes that become installed. Only then does one rename + // make it available. + let staging = store_root.join(format!( + ".staging-{}", + hex::encode(rand::random::<[u8; 8]>()) + )); + let result = dir + .canonicalize() + .with_context(|| format!("resolve {}", dir.display())) + .and_then(|source| copy_dir(&source, &staging)) + .with_context(|| format!("copy {} -> {}", dir.display(), staging.display())) + .and_then(|()| install_staged(&staging, store_root, mode, claim_data)); + if result.is_err() { + let _ = std::fs::remove_dir_all(&staging); + } + result +} + +fn install_staged( + staging: &Path, + store_root: &Path, + mode: InstallMode, + claim_data: bool, +) -> anyhow::Result<()> { + check_package(staging)?; + let manifest = load_manifest(staging)?; let app_id = &manifest.package.id; let dest = store_root.join(app_id); let data_home = weft_ipc_types::package::data_home() @@ -352,31 +379,9 @@ fn install_dir( dest.display() ); } - - // The package is copied into the store first and every decision is made - // on that copy, so the bytes that are checked and trusted are the bytes - // that become installed. Only then does one rename make it available. - let staging = store_root.join(format!( - ".staging-{app_id}-{}", - hex::encode(rand::random::<[u8; 8]>()) - )); - // Copied from the resolved source path, which every file opened during - // the copy is checked against. - let admitted = dir - .canonicalize() - .with_context(|| format!("resolve {}", dir.display())) - .and_then(|source| copy_dir(&source, &staging)) - .with_context(|| format!("copy {} -> {}", dir.display(), staging.display())) - .and_then(|()| admit(&staging, app_id, mode, &data_home, claim_data)); - let admission = match admitted { - Ok(admission) => admission, - Err(e) => { - let _ = std::fs::remove_dir_all(&staging); - return Err(e); - } - }; + let admission = admit(staging, app_id, mode, &data_home, claim_data)?; let owner = admission.owner; - place(&staging, &dest, admission)?; + place(staging, &dest, admission)?; println!("installed {} -> {} ({owner})", app_id, dest.display()); Ok(()) } @@ -402,7 +407,7 @@ fn place(staging: &Path, dest: &Path, admission: Admission) -> anyhow::Result<() Ok(()) } -/// Checks the staged copy of a package and establishes who owns its app ID: +/// Establishes who owns the app ID of a checked, staged package: /// the trusted publisher that signed it, or, only when asked, development. /// The first installation of an ID records its owner, and every later one /// must have the same owner. The record is written before the package is @@ -415,12 +420,6 @@ fn admit( claim_data: bool, ) -> anyhow::Result { use weft_ipc_types::trust::{owner_record_path, read_owner, write_owner}; - check_package(staged)?; - let manifest = load_manifest(staged)?; - anyhow::ensure!( - manifest.package.id == app_id, - "the package changed while it was copied" - ); let owner = match mode { InstallMode::Development => Owner::Development, InstallMode::Verified => { @@ -447,7 +446,12 @@ fn admit( ), None => { let data = weft_ipc_types::package::app_data_dir(data_home, app_id); - if std::fs::symlink_metadata(&data).is_ok() && !claim_data { + let no_data = match std::fs::symlink_metadata(&data) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => true, + Err(e) => return Err(e).with_context(|| format!("inspect {}", data.display())), + Ok(_) => false, + }; + if !no_data && !claim_data { anyhow::bail!( "{} holds app data for {app_id} with no recorded owner; install with \ --claim-data to give it to {owner}, or move it aside", @@ -484,6 +488,7 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> // the package leaves a record with nothing installed; with no data // either, it holds the ID for nothing and is released. if let Some(home) = &data_home + && !installed_in_another_store(app_id, store_root) && release_owner_without_data(home, app_id) { println!("released {app_id}, which was not installed"); @@ -520,13 +525,31 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> } // The owner record keeps the app ID, and the data with it, for its owner // while the data remains; with no data left, the ID is free again. - if let Some(home) = &data_home { + if let Some(home) = &data_home + && !installed_in_another_store(app_id, store_root) + { release_owner_without_data(home, app_id); } println!("uninstalled {}", app_id); Ok(()) } +/// Whether `app_id` is installed in a known store other than `store_root`. +/// Owner records belong to the data home, not to a store, so a record stays +/// while any store this host knows holds the package. +fn installed_in_another_store(app_id: &str, store_root: &Path) -> bool { + let mut roots = list_installed_roots(); + roots.extend( + ["/usr/share/weft/apps"].iter().map(PathBuf::from).chain( + std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".local/share/weft/apps")), + ), + ); + roots + .iter() + .filter(|root| root.as_path() != store_root) + .any(|root| std::fs::symlink_metadata(root.join(app_id)).is_ok()) +} + /// Removes the owner record of `app_id` when the app has no data, and /// reports whether a record was removed. fn release_owner_without_data(data_home: &Path, app_id: &str) -> bool { @@ -625,7 +648,9 @@ fn list_installed() { }; // Only a directory named after the ID its manifest declares is an // installed package; staging copies and stray directories are not. - if entry.file_name().to_str() != Some(m.package.id.as_str()) { + if entry.file_name().to_str() != Some(m.package.id.as_str()) + || !weft_ipc_types::package::is_valid_app_id(&m.package.id) + { continue; } if seen.insert(m.package.id.clone()) { @@ -689,7 +714,7 @@ fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { } fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::Result<()> { - let source = open_regular_file(src)?; + let source = open_regular_file(src, metadata)?; let mut options = std::fs::OpenOptions::new(); options.write(true).create_new(true); #[cfg(unix)] @@ -698,35 +723,38 @@ fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::R let executable = metadata.permissions().mode() & 0o111 != 0; options.mode(if executable { 0o755 } else { 0o644 }); } - #[cfg(not(unix))] - let _ = metadata; let mut target = options.open(dst)?; std::io::copy(&mut &source, &mut target)?; Ok(()) } -/// Opens `src` for reading only if it is still the regular file it was when -/// listed: the last component is not followed, and on Linux the opened file -/// must be at `src` itself, so a link swapped in for any directory on the way -/// cannot redirect the copy outside the package. -fn open_regular_file(src: &Path) -> std::io::Result { +/// Opens `src` for reading only if it is still the regular file that was +/// listed as `listed`: the last component is not followed, a FIFO or device +/// swapped in is not waited on, and the opened file must have the listed +/// device and inode, so a link swapped in for any directory on the way, or +/// another file renamed into place, cannot redirect the copy. +fn open_regular_file(src: &Path, listed: &std::fs::Metadata) -> std::io::Result { let mut options = std::fs::OpenOptions::new(); options.read(true); #[cfg(unix)] - std::os::unix::fs::OpenOptionsExt::custom_flags(&mut options, libc::O_NOFOLLOW); + std::os::unix::fs::OpenOptionsExt::custom_flags( + &mut options, + libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_NOCTTY, + ); let file = options.open(src)?; - let changed = - || std::io::Error::other(format!("{} changed while it was copied", src.display())); - if !file.metadata()?.is_file() { - return Err(changed()); - } - #[cfg(target_os = "linux")] - { - use std::os::fd::AsRawFd; - let opened = std::fs::read_link(format!("/proc/self/fd/{}", file.as_raw_fd()))?; - if opened != src { - return Err(changed()); - } + let opened = file.metadata()?; + #[cfg(unix)] + let same = { + use std::os::unix::fs::MetadataExt; + opened.dev() == listed.dev() && opened.ino() == listed.ino() + }; + #[cfg(not(unix))] + let same = listed.is_file(); + if !opened.is_file() || !same { + return Err(std::io::Error::other(format!( + "{} changed while it was copied", + src.display() + ))); } Ok(file) } @@ -1237,20 +1265,62 @@ mod tests { let _ = std::fs::remove_dir_all(&home); } + #[test] + fn a_record_stays_while_another_store_holds_the_package() { + let home = temp_root("other_store"); + let app_id = "org.weft.test.otherstore"; + write_package(&home.join("src"), app_id, ""); + let user_store = home.join(".local/share/weft/apps"); + let elsewhere = home.join("elsewhere"); + with_home(&home, || { + install_package_to(&home.join("src"), &user_store, InstallMode::Development) + }) + .unwrap(); + assert!(with_home(&home, || uninstall_package_from(app_id, &elsewhere)).is_err()); + assert_eq!(owner_of(&home, app_id), Some(Owner::Development)); + with_home(&home, || uninstall_package_from(app_id, &user_store)).unwrap(); + assert_eq!(owner_of(&home, app_id), None); + let _ = std::fs::remove_dir_all(&home); + } + #[cfg(target_os = "linux")] #[test] fn copies_never_follow_links_swapped_in() { let home = temp_root("swapped"); - std::fs::create_dir_all(home.join("outside")).unwrap(); + for dir in ["outside", "pkg/dir", "pkg/held"] { + std::fs::create_dir_all(home.join(dir)).unwrap(); + } std::fs::write(home.join("outside/secret"), b"secret").unwrap(); - std::fs::create_dir_all(home.join("pkg")).unwrap(); - let root = home.canonicalize().unwrap(); - // A file replaced by a link, and a directory replaced by a link. - std::os::unix::fs::symlink(root.join("outside/secret"), root.join("pkg/file")).unwrap(); - std::os::unix::fs::symlink(root.join("outside"), root.join("pkg/dir")).unwrap(); - assert!(open_regular_file(&root.join("pkg/file")).is_err()); - assert!(open_regular_file(&root.join("pkg/dir/secret")).is_err()); - assert!(open_regular_file(&root.join("outside/secret")).is_ok()); + std::fs::write(home.join("pkg/file"), b"listed").unwrap(); + std::fs::write(home.join("pkg/dir/secret"), b"listed").unwrap(); + let listed = |rel: &str| std::fs::symlink_metadata(home.join(rel)).unwrap(); + let (file, in_dir) = (listed("pkg/file"), listed("pkg/dir/secret")); + assert!(open_regular_file(&home.join("pkg/file"), &file).is_ok()); + + // The listed file moved aside and replaced by a link, then by a hard + // link to another existing file. + std::fs::rename(home.join("pkg/file"), home.join("pkg/held/file")).unwrap(); + std::os::unix::fs::symlink(home.join("outside/secret"), home.join("pkg/file")).unwrap(); + assert!(open_regular_file(&home.join("pkg/file"), &file).is_err()); + std::fs::remove_file(home.join("pkg/file")).unwrap(); + std::fs::hard_link(home.join("outside/secret"), home.join("pkg/file")).unwrap(); + assert!(open_regular_file(&home.join("pkg/file"), &file).is_err()); + + // A listed directory replaced by a link to one holding the same name. + std::fs::rename(home.join("pkg/dir"), home.join("pkg/held/dir")).unwrap(); + std::os::unix::fs::symlink(home.join("outside"), home.join("pkg/dir")).unwrap(); + assert!(open_regular_file(&home.join("pkg/dir/secret"), &in_dir).is_err()); + + // A FIFO swapped in is refused without waiting for a writer. + rustix::fs::mknodat( + rustix::fs::CWD, + home.join("pkg/fifo"), + rustix::fs::FileType::Fifo, + rustix::fs::Mode::from_raw_mode(0o600), + 0, + ) + .unwrap(); + assert!(open_regular_file(&home.join("pkg/fifo"), &file).is_err()); let _ = std::fs::remove_dir_all(&home); } diff --git a/docs/security.md b/docs/security.md index 6fcab73..c2a9110 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,9 +22,9 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Files are copied without following links, and on Linux each opened file must be the file the copy listed. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Files are copied without following links or waiting on special files, and each opened file must have the device and inode the copy listed, so a link or another existing file swapped in during the copy is refused. The app ID is read from the staged copy. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. -The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID hold a per-ID lock, so the record always describes the package placed. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. The demo key in `examples/keys` is a test fixture, not a signing authority. +The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID under one data home hold a per-ID lock, so concurrent installations cannot leave a placed package without its record. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. A record is only released while no known store (the user store, the system store and `$WEFT_APP_STORE`) holds the package; a package installed into another custom store is uninstalled with that store selected. The demo key in `examples/keys` is a test fixture, not a signing authority. Not yet covered: `weft-appd` does not check signatures or owners at launch, so the installed directory is trusted as installed; key revocation, rotation and ownership transfer have no workflow; and capabilities are granted at launch without asking the user, independently of the signature. From 181aa0fefa05d107eed6e8df6c9b157de4117d19 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:17:09 +0000 Subject: [PATCH 5/9] fix(pack): copy packages by directory descriptor so swapped links cannot redirect the copy Checking each file's device and inode against a path-based listing still followed a directory replaced by a link after it was listed. The copy now holds each source directory open and opens its entries relative to it with O_NOFOLLOW, checking type, device and inode against the listing. Only real packages in other stores keep an owner record, the store list is deduplicated, archive names must be valid app IDs, and the help text is wrapped. --- Cargo.lock | 1 - crates/weft-ipc-types/src/trust.rs | 2 + crates/weft-pack/Cargo.toml | 3 +- crates/weft-pack/src/main.rs | 249 +++++++++++++++++------------ docs/security.md | 2 +- 5 files changed, 154 insertions(+), 103 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d3077df..c42e600 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10542,7 +10542,6 @@ dependencies = [ "anyhow", "ed25519-dalek", "hex", - "libc", "rand 0.8.5", "rustix 1.1.4", "sha2", diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs index a6e8c45..2f3ea9f 100644 --- a/crates/weft-ipc-types/src/trust.rs +++ b/crates/weft-ipc-types/src/trust.rs @@ -418,6 +418,8 @@ mod tests { assert!(other.try_lock().is_err()); drop(held); assert!(other.try_lock().is_ok()); + assert!(lock_owner(&home, "../outside").is_err()); + assert!(!home.join("weft/outside.lock").exists()); std::fs::remove_dir_all(&home).unwrap(); } diff --git a/crates/weft-pack/Cargo.toml b/crates/weft-pack/Cargo.toml index deacf4e..8890949 100644 --- a/crates/weft-pack/Cargo.toml +++ b/crates/weft-pack/Cargo.toml @@ -15,9 +15,8 @@ ed25519-dalek = { version = "2", features = ["rand_core"] } sha2 = "0.10" rand = "0.8" hex = "0.4" -libc = "0.2" tar = "0.4" zstd = "0.13" -[target.'cfg(target_os = "linux")'.dev-dependencies] +[target.'cfg(unix)'.dependencies] rustix = { version = "1", features = ["fs"] } diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 454073f..1823865 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -109,14 +109,15 @@ fn main() -> anyhow::Result<()> { eprintln!("usage:"); eprintln!(" weft-pack check validate a package directory"); eprintln!(" weft-pack info print package metadata"); + eprintln!(" weft-pack install [--dev] [--claim-data]"); eprintln!( - " weft-pack install [--dev] [--claim-data] install a package signed by a trusted key" + " install a package signed by a trusted key" ); eprintln!( - " (--dev: unsigned development content;" + " --dev: as unsigned development content" ); eprintln!( - " --claim-data: adopt app data with no owner)" + " --claim-data: adopt app data with no owner" ); eprintln!(" weft-pack uninstall remove installed package"); eprintln!(" weft-pack list list installed packages"); @@ -295,7 +296,8 @@ fn install_into( .file_name() .and_then(|n| n.to_str()) .and_then(|n| n.strip_suffix(".app.tar.zst")) - .context("cannot determine app_id from archive filename")?; + .filter(|n| weft_ipc_types::package::is_valid_app_id(n)) + .context("the archive must be named .app.tar.zst")?; // A fresh private directory in the store, removed whatever happens, so // nothing can be planted in it and nothing is left behind. let unpacked = private_scratch_dir(store_root, ".unpack")?; @@ -539,15 +541,16 @@ fn uninstall_package_from(app_id: &str, store_root: &Path) -> anyhow::Result<()> /// while any store this host knows holds the package. fn installed_in_another_store(app_id: &str, store_root: &Path) -> bool { let mut roots = list_installed_roots(); - roots.extend( - ["/usr/share/weft/apps"].iter().map(PathBuf::from).chain( - std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".local/share/weft/apps")), - ), - ); + roots.push(PathBuf::from("/usr/share/weft/apps")); + roots.extend(std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".local/share/weft/apps"))); + roots.sort(); + roots.dedup(); + // Only a package counts, as in `list`: a leftover empty or data-only + // directory does not hold the ID. roots .iter() .filter(|root| root.as_path() != store_root) - .any(|root| std::fs::symlink_metadata(root.join(app_id)).is_ok()) + .any(|root| Manifest::read(&root.join(app_id)).is_ok_and(|m| m.package.id == app_id)) } /// Removes the owner record of `app_id` when the app has no data, and @@ -683,82 +686,94 @@ fn list_installed() { /// Copies a package directory. Packages hold only directories and regular /// files, so a symbolic link or special file stops the copy rather than -/// being followed. Modes are not copied: the signature does not cover them, -/// so installed directories are 0755 and files 0644, or 0755 when the source -/// is executable, and nothing installed is writable by other users. +/// being followed. The walk holds each directory open and opens its entries +/// relative to it without following links, checking that each opened entry +/// has the device and inode it was listed with, so a link or another file +/// swapped in anywhere in the source during the copy cannot redirect it. +/// Modes are not copied: the signature does not cover them, so installed +/// directories are 0755 and files 0644, or 0755 when the source is +/// executable, and nothing installed is writable by other users. +#[cfg(unix)] fn copy_dir(src: &Path, dst: &Path) -> anyhow::Result<()> { - let mut builder = std::fs::DirBuilder::new(); - #[cfg(unix)] - std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o755); - builder + use rustix::fs::{CWD, Mode, OFlags}; + let root = rustix::fs::openat( + CWD, + src, + OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::empty(), + ) + .with_context(|| format!("open {}", src.display()))?; + copy_tree(&root, src, dst) +} + +#[cfg(not(unix))] +fn copy_dir(_src: &Path, _dst: &Path) -> anyhow::Result<()> { + anyhow::bail!("installing packages requires a Unix host") +} + +#[cfg(unix)] +fn copy_tree(dir: &rustix::fd::OwnedFd, shown: &Path, dst: &Path) -> anyhow::Result<()> { + use rustix::fs::{AtFlags, FileType, Mode, OFlags}; + use std::os::unix::ffi::OsStrExt; + use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt}; + + std::fs::DirBuilder::new() + .mode(0o755) .create(dst) .with_context(|| format!("create {}", dst.display()))?; - for entry in std::fs::read_dir(src)? { - let entry = entry?; - let src_path = entry.path(); - let dst_path = dst.join(entry.file_name()); - let metadata = std::fs::symlink_metadata(&src_path)?; - if metadata.is_dir() { - copy_dir(&src_path, &dst_path)?; - } else if metadata.is_file() { - copy_file(&src_path, &dst_path, &metadata) - .with_context(|| format!("copy {}", src_path.display()))?; - } else { - anyhow::bail!( + let mut entries = + rustix::fs::Dir::read_from(dir).with_context(|| format!("read {}", shown.display()))?; + while let Some(entry) = entries.read() { + let entry = entry.with_context(|| format!("read {}", shown.display()))?; + let name = entry.file_name(); + if matches!(name.to_bytes(), b"." | b"..") { + continue; + } + let src_path = shown.join(std::ffi::OsStr::from_bytes(name.to_bytes())); + let dst_path = dst.join(std::ffi::OsStr::from_bytes(name.to_bytes())); + let listed = rustix::fs::statat(dir, name, AtFlags::SYMLINK_NOFOLLOW) + .with_context(|| format!("inspect {}", src_path.display()))?; + let kind = FileType::from_raw_mode(listed.st_mode); + let flags = match kind { + FileType::Directory => OFlags::DIRECTORY, + FileType::RegularFile => OFlags::NONBLOCK | OFlags::NOCTTY, + _ => anyhow::bail!( "{} is not a regular file or directory; packages cannot contain links", src_path.display() - ); + ), + }; + let opened = rustix::fs::openat( + dir, + name, + flags | OFlags::RDONLY | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::empty(), + ) + .with_context(|| format!("open {}", src_path.display()))?; + let found = rustix::fs::fstat(&opened)?; + anyhow::ensure!( + FileType::from_raw_mode(found.st_mode) == kind + && found.st_dev == listed.st_dev + && found.st_ino == listed.st_ino, + "{} changed while it was copied", + src_path.display() + ); + if kind == FileType::Directory { + copy_tree(&opened, &src_path, &dst_path)?; + } else { + let executable = found.st_mode & 0o111 != 0; + let mut target = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .mode(if executable { 0o755 } else { 0o644 }) + .open(&dst_path) + .with_context(|| format!("create {}", dst_path.display()))?; + std::io::copy(&mut std::fs::File::from(opened), &mut target) + .with_context(|| format!("copy {}", src_path.display()))?; } } Ok(()) } -fn copy_file(src: &Path, dst: &Path, metadata: &std::fs::Metadata) -> std::io::Result<()> { - let source = open_regular_file(src, metadata)?; - let mut options = std::fs::OpenOptions::new(); - options.write(true).create_new(true); - #[cfg(unix)] - { - use std::os::unix::fs::{OpenOptionsExt, PermissionsExt}; - let executable = metadata.permissions().mode() & 0o111 != 0; - options.mode(if executable { 0o755 } else { 0o644 }); - } - let mut target = options.open(dst)?; - std::io::copy(&mut &source, &mut target)?; - Ok(()) -} - -/// Opens `src` for reading only if it is still the regular file that was -/// listed as `listed`: the last component is not followed, a FIFO or device -/// swapped in is not waited on, and the opened file must have the listed -/// device and inode, so a link swapped in for any directory on the way, or -/// another file renamed into place, cannot redirect the copy. -fn open_regular_file(src: &Path, listed: &std::fs::Metadata) -> std::io::Result { - let mut options = std::fs::OpenOptions::new(); - options.read(true); - #[cfg(unix)] - std::os::unix::fs::OpenOptionsExt::custom_flags( - &mut options, - libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_NOCTTY, - ); - let file = options.open(src)?; - let opened = file.metadata()?; - #[cfg(unix)] - let same = { - use std::os::unix::fs::MetadataExt; - opened.dev() == listed.dev() && opened.ino() == listed.ino() - }; - #[cfg(not(unix))] - let same = listed.is_file(); - if !opened.is_file() || !same { - return Err(std::io::Error::other(format!( - "{} changed while it was copied", - src.display() - ))); - } - Ok(file) -} - fn build_image(dir: &Path, out_path: Option<&Path>) -> anyhow::Result<()> { let manifest = load_manifest(dir)?; let app_id = &manifest.package.id; @@ -1283,44 +1298,80 @@ mod tests { let _ = std::fs::remove_dir_all(&home); } - #[cfg(target_os = "linux")] + #[test] + fn uninstalling_one_of_two_copies_keeps_the_record() { + let home = temp_root("two_copies"); + let app_id = "org.weft.test.twocopies"; + write_package(&home.join("src"), app_id, ""); + let user_store = home.join(".local/share/weft/apps"); + let other = home.join("other"); + for store in [&user_store, &other] { + with_home(&home, || { + install_package_to(&home.join("src"), store, InstallMode::Development) + }) + .unwrap(); + } + with_home(&home, || uninstall_package_from(app_id, &other)).unwrap(); + assert_eq!(owner_of(&home, app_id), Some(Owner::Development)); + + // A leftover directory that is not a package does not hold the ID. + std::fs::remove_dir_all(user_store.join(app_id)).unwrap(); + std::fs::create_dir_all(user_store.join(app_id)).unwrap(); + with_home(&home, || { + install_package_to(&home.join("src"), &other, InstallMode::Development) + }) + .unwrap(); + with_home(&home, || uninstall_package_from(app_id, &other)).unwrap(); + assert_eq!(owner_of(&home, app_id), None); + let _ = std::fs::remove_dir_all(&home); + } + + #[cfg(unix)] #[test] fn copies_never_follow_links_swapped_in() { + use rustix::fs::{CWD, Mode, OFlags}; let home = temp_root("swapped"); - for dir in ["outside", "pkg/dir", "pkg/held"] { + for dir in ["outside", "pkg/dir", "held"] { std::fs::create_dir_all(home.join(dir)).unwrap(); } - std::fs::write(home.join("outside/secret"), b"secret").unwrap(); - std::fs::write(home.join("pkg/file"), b"listed").unwrap(); + std::fs::write(home.join("outside/secret"), b"outside").unwrap(); std::fs::write(home.join("pkg/dir/secret"), b"listed").unwrap(); - let listed = |rel: &str| std::fs::symlink_metadata(home.join(rel)).unwrap(); - let (file, in_dir) = (listed("pkg/file"), listed("pkg/dir/secret")); - assert!(open_regular_file(&home.join("pkg/file"), &file).is_ok()); + let open_dir = |path: &Path| { + rustix::fs::openat( + CWD, + path, + OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW, + Mode::empty(), + ) + .unwrap() + }; - // The listed file moved aside and replaced by a link, then by a hard - // link to another existing file. - std::fs::rename(home.join("pkg/file"), home.join("pkg/held/file")).unwrap(); - std::os::unix::fs::symlink(home.join("outside/secret"), home.join("pkg/file")).unwrap(); - assert!(open_regular_file(&home.join("pkg/file"), &file).is_err()); - std::fs::remove_file(home.join("pkg/file")).unwrap(); - std::fs::hard_link(home.join("outside/secret"), home.join("pkg/file")).unwrap(); - assert!(open_regular_file(&home.join("pkg/file"), &file).is_err()); - - // A listed directory replaced by a link to one holding the same name. - std::fs::rename(home.join("pkg/dir"), home.join("pkg/held/dir")).unwrap(); + // A directory replaced by a link after it was opened, before its + // entries are read: the copy reads the directory that was opened. + let dir = open_dir(&home.join("pkg/dir")); + std::fs::rename(home.join("pkg/dir"), home.join("held/dir")).unwrap(); std::os::unix::fs::symlink(home.join("outside"), home.join("pkg/dir")).unwrap(); - assert!(open_regular_file(&home.join("pkg/dir/secret"), &in_dir).is_err()); + copy_tree(&dir, &home.join("pkg/dir"), &home.join("copied")).unwrap(); + assert_eq!( + std::fs::read(home.join("copied/secret")).unwrap(), + b"listed" + ); - // A FIFO swapped in is refused without waiting for a writer. + // A link where an entry is listed is refused, and so is a FIFO, + // without waiting for a writer. + let pkg = open_dir(&home.join("pkg")); + assert!(copy_tree(&pkg, &home.join("pkg"), &home.join("copied_link")).is_err()); + std::fs::remove_file(home.join("pkg/dir")).unwrap(); rustix::fs::mknodat( - rustix::fs::CWD, + CWD, home.join("pkg/fifo"), rustix::fs::FileType::Fifo, - rustix::fs::Mode::from_raw_mode(0o600), + Mode::from_raw_mode(0o600), 0, ) .unwrap(); - assert!(open_regular_file(&home.join("pkg/fifo"), &file).is_err()); + let pkg = open_dir(&home.join("pkg")); + assert!(copy_tree(&pkg, &home.join("pkg"), &home.join("copied_fifo")).is_err()); let _ = std::fs::remove_dir_all(&home); } diff --git a/docs/security.md b/docs/security.md index c2a9110..ce71b88 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,7 +22,7 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. Files are copied without following links or waiting on special files, and each opened file must have the device and inode the copy listed, so a link or another existing file swapped in during the copy is refused. The app ID is read from the staged copy. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, without following links or waiting on special files, and each opened entry must have the device and inode the copy listed, so a link or another existing file swapped in during the copy is refused. The app ID is read from the staged copy. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID under one data home hold a per-ID lock, so concurrent installations cannot leave a placed package without its record. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. A record is only released while no known store (the user store, the system store and `$WEFT_APP_STORE`) holds the package; a package installed into another custom store is uninstalled with that store selected. The demo key in `examples/keys` is a test fixture, not a signing authority. From 8221e6fc3dd829e7a2491106d2d49a8bc9410323 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:20:35 +0000 Subject: [PATCH 6/9] fix(pack): set installed modes regardless of umask and hold one descriptor per level Modes requested at creation were masked by the umask, so a root install under umask 077 produced system packages other users could not read. They are now set explicitly after creation. The copy reads each directory's names and closes the listing before recursing, so deep trees hold one descriptor per level. The owner-lock test now uses an ID that would otherwise open, and the docs describe the copy check and its device-node residual precisely. --- crates/weft-ipc-types/src/trust.rs | 5 +++-- crates/weft-pack/src/main.rs | 34 ++++++++++++++++++++++++------ docs/security.md | 2 +- 3 files changed, 31 insertions(+), 10 deletions(-) diff --git a/crates/weft-ipc-types/src/trust.rs b/crates/weft-ipc-types/src/trust.rs index 2f3ea9f..79143b5 100644 --- a/crates/weft-ipc-types/src/trust.rs +++ b/crates/weft-ipc-types/src/trust.rs @@ -418,8 +418,9 @@ mod tests { assert!(other.try_lock().is_err()); drop(held); assert!(other.try_lock().is_ok()); - assert!(lock_owner(&home, "../outside").is_err()); - assert!(!home.join("weft/outside.lock").exists()); + // A name that would open fine but is not an app ID is refused. + assert!(lock_owner(&home, "Org.weft.test").is_err()); + assert!(!home.join("weft/owners/.Org.weft.test.lock").exists()); std::fs::remove_dir_all(&home).unwrap(); } diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 1823865..cbdc516 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -715,20 +715,32 @@ fn copy_dir(_src: &Path, _dst: &Path) -> anyhow::Result<()> { fn copy_tree(dir: &rustix::fd::OwnedFd, shown: &Path, dst: &Path) -> anyhow::Result<()> { use rustix::fs::{AtFlags, FileType, Mode, OFlags}; use std::os::unix::ffi::OsStrExt; - use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt}; + use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt}; + // Modes are set explicitly rather than requested at creation, so the + // installer's umask cannot make an installed package unreadable. + let set_mode = |path: &Path, mode: u32| { + std::fs::set_permissions(path, std::fs::Permissions::from_mode(mode)) + .with_context(|| format!("set the mode of {}", path.display())) + }; std::fs::DirBuilder::new() - .mode(0o755) + .mode(0o700) .create(dst) .with_context(|| format!("create {}", dst.display()))?; + set_mode(dst, 0o755)?; + // The names are read first and the listing closed, so the walk holds one + // descriptor per directory level. + let mut names = Vec::new(); let mut entries = rustix::fs::Dir::read_from(dir).with_context(|| format!("read {}", shown.display()))?; while let Some(entry) = entries.read() { let entry = entry.with_context(|| format!("read {}", shown.display()))?; - let name = entry.file_name(); - if matches!(name.to_bytes(), b"." | b"..") { - continue; + if !matches!(entry.file_name().to_bytes(), b"." | b"..") { + names.push(entry.file_name().to_owned()); } + } + drop(entries); + for name in &names { let src_path = shown.join(std::ffi::OsStr::from_bytes(name.to_bytes())); let dst_path = dst.join(std::ffi::OsStr::from_bytes(name.to_bytes())); let listed = rustix::fs::statat(dir, name, AtFlags::SYMLINK_NOFOLLOW) @@ -764,11 +776,18 @@ fn copy_tree(dir: &rustix::fd::OwnedFd, shown: &Path, dst: &Path) -> anyhow::Res let mut target = std::fs::OpenOptions::new() .write(true) .create_new(true) - .mode(if executable { 0o755 } else { 0o644 }) + .mode(0o600) .open(&dst_path) .with_context(|| format!("create {}", dst_path.display()))?; std::io::copy(&mut std::fs::File::from(opened), &mut target) .with_context(|| format!("copy {}", src_path.display()))?; + target + .set_permissions(std::fs::Permissions::from_mode(if executable { + 0o755 + } else { + 0o644 + })) + .with_context(|| format!("set the mode of {}", dst_path.display()))?; } } Ok(()) @@ -1334,7 +1353,7 @@ mod tests { for dir in ["outside", "pkg/dir", "held"] { std::fs::create_dir_all(home.join(dir)).unwrap(); } - std::fs::write(home.join("outside/secret"), b"outside").unwrap(); + std::fs::write(home.join("outside/other"), b"outside").unwrap(); std::fs::write(home.join("pkg/dir/secret"), b"listed").unwrap(); let open_dir = |path: &Path| { rustix::fs::openat( @@ -1356,6 +1375,7 @@ mod tests { std::fs::read(home.join("copied/secret")).unwrap(), b"listed" ); + assert!(!home.join("copied/other").exists()); // A link where an entry is listed is refused, and so is a FIFO, // without waiting for a writer. diff --git a/docs/security.md b/docs/security.md index ce71b88..b9f7a2a 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,7 +22,7 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, without following links or waiting on special files, and each opened entry must have the device and inode the copy listed, so a link or another existing file swapped in during the copy is refused. The app ID is read from the staged copy. Installed files take fixed modes, 0644, or 0755 when the source is executable, and directories 0755, so no installed file is writable by other users whatever the source modes were. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, never following links, so replacing a directory with a link while the copy runs cannot redirect it. Each entry must keep the type, device and inode it had when it was examined just before it was opened, and a FIFO is never waited on. A device node hard-linked in place of a file in that interval is opened before it is refused; `fs.protected_hardlinks`, on by default, prevents such links to devices the attacker does not own. Installed files are set to 0644, or 0755 when the source is executable, and directories to 0755, whatever the umask, so no installed file is writable by other users. The app ID is read from the staged copy. Archives are unpacked into a fresh private directory in the store, which is always removed. The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID under one data home hold a per-ID lock, so concurrent installations cannot leave a placed package without its record. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. A record is only released while no known store (the user store, the system store and `$WEFT_APP_STORE`) holds the package; a package installed into another custom store is uninstalled with that store selected. The demo key in `examples/keys` is a test fixture, not a signing authority. From d67ea24004fe174c2c5308c6c993c3f68ddec9c1 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:22:37 +0000 Subject: [PATCH 7/9] fix(pack): create a missing store at 0755 regardless of umask A first root install under a restrictive umask created the store and its parents unreadable to other users even though the package inside was 0755/0644. Missing store directories are now created and set to 0755. The copy comment and the hard-link note in the security docs describe exactly what is checked and what the kernel enforces. --- crates/weft-pack/src/main.rs | 33 +++++++++++++++++++++++++++++---- docs/security.md | 2 +- 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index cbdc516..97719ce 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -285,8 +285,7 @@ fn install_into( mode: InstallMode, claim_data: bool, ) -> anyhow::Result<()> { - std::fs::create_dir_all(store_root) - .with_context(|| format!("create {}", store_root.display()))?; + create_store(store_root)?; if !(path.extension().is_some_and(|e| e == "zst" || e == "tar") || path.to_string_lossy().ends_with(".app.tar.zst")) { @@ -307,6 +306,31 @@ fn install_into( result } +/// Creates the store and any missing parents at 0755 whatever the umask, so +/// a store created by a root install is readable by every user. +fn create_store(store_root: &Path) -> anyhow::Result<()> { + let mut missing: Vec<&Path> = store_root + .ancestors() + .take_while(|dir| std::fs::symlink_metadata(dir).is_err()) + .collect(); + missing.reverse(); + for dir in missing { + match std::fs::create_dir(dir) { + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, + other => other.with_context(|| format!("create {}", dir.display()))?, + } + #[cfg(unix)] + std::fs::set_permissions(dir, std::os::unix::fs::PermissionsExt::from_mode(0o755)) + .with_context(|| format!("set the mode of {}", dir.display()))?; + } + anyhow::ensure!( + store_root.is_dir(), + "{} is not a directory", + store_root.display() + ); + Ok(()) +} + /// Creates a new directory with a random name in `parent`, accessible only to /// the user. fn private_scratch_dir(parent: &Path, prefix: &str) -> anyhow::Result { @@ -688,8 +712,9 @@ fn list_installed() { /// files, so a symbolic link or special file stops the copy rather than /// being followed. The walk holds each directory open and opens its entries /// relative to it without following links, checking that each opened entry -/// has the device and inode it was listed with, so a link or another file -/// swapped in anywhere in the source during the copy cannot redirect it. +/// has the type, device and inode it had when examined just before the +/// open, so a link or another file swapped in anywhere in the source during +/// the copy cannot redirect it. /// Modes are not copied: the signature does not cover them, so installed /// directories are 0755 and files 0644, or 0755 when the source is /// executable, and nothing installed is writable by other users. diff --git a/docs/security.md b/docs/security.md index b9f7a2a..8b99453 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,7 +22,7 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, never following links, so replacing a directory with a link while the copy runs cannot redirect it. Each entry must keep the type, device and inode it had when it was examined just before it was opened, and a FIFO is never waited on. A device node hard-linked in place of a file in that interval is opened before it is refused; `fs.protected_hardlinks`, on by default, prevents such links to devices the attacker does not own. Installed files are set to 0644, or 0755 when the source is executable, and directories to 0755, whatever the umask, so no installed file is writable by other users. The app ID is read from the staged copy. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, never following links, so replacing a directory with a link while the copy runs cannot redirect it. Each entry must keep the type, device and inode it had when it was examined just before it was opened, and a FIFO is never waited on. A device node hard-linked in place of a file in that interval is opened before it is refused; `fs.protected_hardlinks`, on by default, prevents such links to devices the attacker cannot both read and write. Installed files are set to 0644, or 0755 when the source is executable, and directories to 0755, whatever the umask, so no installed file is writable by other users; a store that does not exist yet is created at 0755. The app ID is read from the staged copy. Archives are unpacked into a fresh private directory in the store, which is always removed. The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID under one data home hold a per-ID lock, so concurrent installations cannot leave a placed package without its record. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. A record is only released while no known store (the user store, the system store and `$WEFT_APP_STORE`) holds the package; a package installed into another custom store is uninstalled with that store selected. The demo key in `examples/keys` is a test fixture, not a signing authority. From 025388f84e7ca278092beaa167338e477dbc2462 Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:25:09 +0000 Subject: [PATCH 8/9] fix(pack): create relative stores and set new store modes through a no-follow descriptor A relative store none of whose components existed failed, because the empty ancestor was treated as a directory to create. New store directories are now created private and set to 0755 through a descriptor opened without following links, so a swapped path cannot redirect the mode change. The security docs state the hard-link protection as the kernel enforces it. --- crates/weft-pack/src/main.rs | 50 +++++++++++++++++++++++++++++++++--- docs/security.md | 2 +- 2 files changed, 47 insertions(+), 5 deletions(-) diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 97719ce..73a5497 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -307,21 +307,37 @@ fn install_into( } /// Creates the store and any missing parents at 0755 whatever the umask, so -/// a store created by a root install is readable by every user. +/// a store created by a root install is readable by every user. Each new +/// directory is created private and its mode set through a descriptor that +/// does not follow links, so only the directory just created is changed. fn create_store(store_root: &Path) -> anyhow::Result<()> { let mut missing: Vec<&Path> = store_root .ancestors() + .filter(|dir| !dir.as_os_str().is_empty()) .take_while(|dir| std::fs::symlink_metadata(dir).is_err()) .collect(); missing.reverse(); for dir in missing { - match std::fs::create_dir(dir) { + let mut builder = std::fs::DirBuilder::new(); + #[cfg(unix)] + std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o700); + match builder.create(dir) { Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, other => other.with_context(|| format!("create {}", dir.display()))?, } #[cfg(unix)] - std::fs::set_permissions(dir, std::os::unix::fs::PermissionsExt::from_mode(0o755)) - .with_context(|| format!("set the mode of {}", dir.display()))?; + { + use rustix::fs::{CWD, Mode, OFlags}; + let created = rustix::fs::openat( + CWD, + dir, + OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, + Mode::empty(), + ) + .with_context(|| format!("open {}", dir.display()))?; + rustix::fs::fchmod(&created, Mode::from_raw_mode(0o755)) + .with_context(|| format!("set the mode of {}", dir.display()))?; + } } anyhow::ensure!( store_root.is_dir(), @@ -1342,6 +1358,32 @@ mod tests { let _ = std::fs::remove_dir_all(&home); } + #[cfg(unix)] + #[test] + fn a_missing_store_is_created_readable_by_everyone() { + use std::os::unix::fs::PermissionsExt; + let home = temp_root("new_store"); + std::fs::create_dir_all(&home).unwrap(); + let mode = |p: &Path| std::fs::metadata(p).unwrap().permissions().mode() & 0o777; + // An absolute store with missing parents. + let absolute = home.join("a/b/store"); + create_store(&absolute).unwrap(); + for dir in [home.join("a"), home.join("a/b"), absolute.clone()] { + assert_eq!(mode(&dir), 0o755, "{}", dir.display()); + } + // A relative store none of whose components exist yet. + let relative = PathBuf::from(format!("weft-pack-store-{}/sub", std::process::id())); + let _ = std::fs::remove_dir_all(relative.parent().unwrap()); + create_store(&relative).unwrap(); + assert_eq!(mode(&relative), 0o755); + std::fs::remove_dir_all(relative.parent().unwrap()).unwrap(); + // An existing store is left as it is. + std::fs::set_permissions(&absolute, std::fs::Permissions::from_mode(0o750)).unwrap(); + create_store(&absolute).unwrap(); + assert_eq!(mode(&absolute), 0o750); + let _ = std::fs::remove_dir_all(&home); + } + #[test] fn uninstalling_one_of_two_copies_keeps_the_record() { let home = temp_root("two_copies"); diff --git a/docs/security.md b/docs/security.md index 8b99453..5ac7ff2 100644 --- a/docs/security.md +++ b/docs/security.md @@ -22,7 +22,7 @@ Apps access the filesystem only through WASI preopened directories. Each capabil Packages are signed with Ed25519 over their content digest: the SHA-256 of an inventory listing every file in the package except the root `signature.sig`, one `\t` line per file sorted by path. Every file is covered, including the UI. Names must be UTF-8 without control characters, so no name can imitate other inventory lines. Packages may hold only directories and regular files; a symbolic link or special file makes `weft-pack check`, `sign`, `verify` and `install` refuse the package. The committed demo signatures verify under this rule. -`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, never following links, so replacing a directory with a link while the copy runs cannot redirect it. Each entry must keep the type, device and inode it had when it was examined just before it was opened, and a FIFO is never waited on. A device node hard-linked in place of a file in that interval is opened before it is refused; `fs.protected_hardlinks`, on by default, prevents such links to devices the attacker cannot both read and write. Installed files are set to 0644, or 0755 when the source is executable, and directories to 0755, whatever the umask, so no installed file is writable by other users; a store that does not exist yet is created at 0755. The app ID is read from the staged copy. Archives are unpacked into a fresh private directory in the store, which is always removed. +`weft-pack install` admits a package only when its signature verifies with a key in the trust store: `*.pub` files (64 hex digits) in `$XDG_CONFIG_HOME/weft/trusted-keys` and `/etc/weft/trusted-keys`, or only in `$WEFT_TRUSTED_KEYS` when that is set. A malformed key file is an error, not skipped. An unsigned or untrusted package is refused unless the developer passes `--dev`, which installs it as development content. The package is copied into the store first and checked on that copy, which is then renamed into place, so the bytes that are verified are the bytes that are installed. The copy holds each source directory open and opens its entries relative to it, never following links, so replacing a directory with a link while the copy runs cannot redirect it. Each entry must keep the type, device and inode it had when it was examined just before it was opened, and a FIFO is never waited on. A device node hard-linked in place of a file in that interval is opened before it is refused; `fs.protected_hardlinks`, on by default, prevents such links to devices unless the attacker owns them or holds CAP_FOWNER. Installed files are set to 0644, or 0755 when the source is executable, and directories to 0755, whatever the umask, so no installed file is writable by other users; a store, and any of its parents, that does not exist yet is created at 0755. The app ID is read from the staged copy. Archives are unpacked into a fresh private directory in the store, which is always removed. The first installation of an app ID records its owner in `$XDG_DATA_HOME/weft/owners/`: the publisher key, or development. Installations and uninstallations of one ID under one data home hold a per-ID lock, so concurrent installations cannot leave a placed package without its record. Every later installation of that ID must have the same owner, so neither another trusted publisher nor a development build can take over an ID, and with it the app's data. The record survives uninstall while the app's data remains; uninstalling with no data left frees the ID. App data with no recorded owner, as left by installations from before owner records, is given to a new owner only with `--claim-data`. A record is written under a temporary name and linked into place, so it is never partial, and a record created by an installation that then fails to place its package is removed. A record left by an installation that was killed before placing its package is released by `weft-pack uninstall ` once no data remains. A record is only released while no known store (the user store, the system store and `$WEFT_APP_STORE`) holds the package; a package installed into another custom store is uninstalled with that store selected. The demo key in `examples/keys` is a test fixture, not a signing authority. From fb13a99e1731266e92c9ae70445f53cb1271dfcc Mon Sep 17 00:00:00 2001 From: Marco Allegretti Date: Fri, 9 Oct 2026 14:26:43 +0000 Subject: [PATCH 9/9] fix(pack): remove a new store directory whose mode cannot be set A directory left private after a failed mode change would stay unreadable to other users on every later install, since existing directories are not touched. It is now removed again. The test's relative store is cleaned up even when an assertion fails. --- crates/weft-pack/src/main.rs | 37 +++++++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/crates/weft-pack/src/main.rs b/crates/weft-pack/src/main.rs index 73a5497..b76cbd1 100644 --- a/crates/weft-pack/src/main.rs +++ b/crates/weft-pack/src/main.rs @@ -308,8 +308,9 @@ fn install_into( /// Creates the store and any missing parents at 0755 whatever the umask, so /// a store created by a root install is readable by every user. Each new -/// directory is created private and its mode set through a descriptor that -/// does not follow links, so only the directory just created is changed. +/// directory is created private and its mode set through a descriptor opened +/// without following a link in its last component; a directory whose mode +/// cannot be set is removed again rather than left private. fn create_store(store_root: &Path) -> anyhow::Result<()> { let mut missing: Vec<&Path> = store_root .ancestors() @@ -328,15 +329,18 @@ fn create_store(store_root: &Path) -> anyhow::Result<()> { #[cfg(unix)] { use rustix::fs::{CWD, Mode, OFlags}; - let created = rustix::fs::openat( + let opened = rustix::fs::openat( CWD, dir, OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC, Mode::empty(), - ) - .with_context(|| format!("open {}", dir.display()))?; - rustix::fs::fchmod(&created, Mode::from_raw_mode(0o755)) - .with_context(|| format!("set the mode of {}", dir.display()))?; + ); + if let Err(e) = + opened.and_then(|created| rustix::fs::fchmod(&created, Mode::from_raw_mode(0o755))) + { + let _ = std::fs::remove_dir(dir); + return Err(e).with_context(|| format!("set the mode of {}", dir.display())); + } } } anyhow::ensure!( @@ -1371,12 +1375,23 @@ mod tests { for dir in [home.join("a"), home.join("a/b"), absolute.clone()] { assert_eq!(mode(&dir), 0o755, "{}", dir.display()); } - // A relative store none of whose components exist yet. - let relative = PathBuf::from(format!("weft-pack-store-{}/sub", std::process::id())); - let _ = std::fs::remove_dir_all(relative.parent().unwrap()); + // A relative store none of whose components exist yet, removed even + // if an assertion fails. + struct Removed(PathBuf); + impl Drop for Removed { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } + } + let top = Removed(PathBuf::from(format!( + "weft-pack-store-{}", + std::process::id() + ))); + let _ = std::fs::remove_dir_all(&top.0); + let relative = top.0.join("sub"); create_store(&relative).unwrap(); assert_eq!(mode(&relative), 0o755); - std::fs::remove_dir_all(relative.parent().unwrap()).unwrap(); + drop(top); // An existing store is left as it is. std::fs::set_permissions(&absolute, std::fs::Permissions::from_mode(0o750)).unwrap(); create_store(&absolute).unwrap();