use std::collections::BTreeMap;
use std::io::Cursor;
use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use minisign::KeyPair;
use second_brain_api::self_update::{
self, Install, Outcome, RELEASE_PUBLIC_KEY, ReleaseSource, decide_install,
};
use semver::Version;
const TARGET: &str = "x86_64-unknown-linux-gnu";
const PACKAGES: [(&str, &[&str]); 3] = [
("second-brain-api", &["second-brain-api"]),
("second-brain-cli", &["sb"]),
("second-brain-mcp", &["second-brain-mcp"]),
];
struct FixtureReleases {
root: PathBuf,
latest: String,
fetched: Mutex<Vec<String>>,
}
impl FixtureReleases {
fn new(root: &Path, latest: &str) -> Self {
Self {
root: root.to_path_buf(),
latest: latest.to_string(),
fetched: Mutex::default(),
}
}
fn fetched(&self) -> Vec<String> {
self.fetched.lock().unwrap().clone()
}
}
impl ReleaseSource for FixtureReleases {
async fn latest_tag(&self) -> anyhow::Result<String> {
Ok(self.latest.clone())
}
async fn fetch(&self, tag: &str, asset: &str, limit: usize) -> anyhow::Result<Vec<u8>> {
self.fetched.lock().unwrap().push(format!("{tag}/{asset}"));
let bytes = std::fs::read(self.root.join(tag).join(asset))?;
anyhow::ensure!(bytes.len() <= limit, "{asset} is over {limit} bytes");
Ok(bytes)
}
}
enum Entry<'a> {
File(&'a str, Vec<u8>),
Symlink(&'a str, &'a str),
}
fn tar_xz(entries: &[Entry]) -> Vec<u8> {
let mut builder = tar::Builder::new(Vec::new());
for entry in entries {
let mut header = tar::Header::new_gnu();
match entry {
Entry::File(path, data) => {
header.set_entry_type(tar::EntryType::Regular);
header.set_mode(if path.ends_with(".md") { 0o644 } else { 0o755 });
header.set_size(data.len() as u64);
header.set_cksum();
builder
.append_data(&mut header, path, data.as_slice())
.unwrap();
}
Entry::Symlink(path, link) => {
header.set_entry_type(tar::EntryType::Symlink);
header.set_size(0);
builder.append_link(&mut header, path, link).unwrap();
}
}
}
let tar_bytes = builder.into_inner().unwrap();
let mut xz = Vec::new();
lzma_rs::xz_compress(&mut tar_bytes.as_slice(), &mut xz).unwrap();
xz
}
fn new_contents(version: &str, bin: &str) -> Vec<u8> {
format!("#!/bin/sh\necho {bin} {version}\n").into_bytes()
}
fn package_entries(version: &str, package: &str, bins: &[&str]) -> Vec<(String, Vec<u8>)> {
let top = format!("{package}-{TARGET}");
let mut files: Vec<(String, Vec<u8>)> = bins
.iter()
.map(|bin| (format!("{top}/{bin}"), new_contents(version, bin)))
.collect();
files.push((
format!("{top}/README.md"),
format!("readme for {package}\n").into_bytes(),
));
files
}
fn sign(key: &KeyPair, data: &[u8], comment: &str) -> String {
minisign::sign(
Some(&key.pk),
&key.sk,
Cursor::new(data),
Some(comment),
None,
)
.unwrap()
.into_string()
}
fn trusted_comment(version: &str, archive: &str) -> String {
format!("second-brain {version} {archive}")
}
fn archive_name(package: &str) -> String {
format!("{package}-{TARGET}.tar.xz")
}
struct Release<'a> {
root: &'a Path,
version: &'a str,
key: &'a KeyPair,
}
impl Release<'_> {
fn dir(&self) -> PathBuf {
let dir = self.root.join(format!("v{}", self.version));
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn publish(&self, package: &str, archive: &[u8], comment: &str) {
let name = archive_name(package);
let dir = self.dir();
std::fs::write(dir.join(&name), archive).unwrap();
std::fs::write(
dir.join(format!("{name}.minisig")),
sign(self.key, archive, comment),
)
.unwrap();
}
fn publish_good(&self) {
for (package, bins) in PACKAGES {
let entries = package_entries(self.version, package, bins);
let entries: Vec<Entry> = entries
.iter()
.map(|(p, d)| Entry::File(p, d.clone()))
.collect();
let archive = tar_xz(&entries);
self.publish(
package,
&archive,
&trusted_comment(self.version, &archive_name(package)),
);
}
}
fn archive_path(&self, package: &str) -> PathBuf {
self.dir().join(archive_name(package))
}
fn signature_path(&self, package: &str) -> PathBuf {
self.dir()
.join(format!("{}.minisig", archive_name(package)))
}
}
struct Fixture {
_tmp: tempfile::TempDir,
releases: PathBuf,
install: Install,
key: KeyPair,
verify_key: minisign_verify::PublicKey,
}
fn verify_key(key: &KeyPair) -> minisign_verify::PublicKey {
minisign_verify::PublicKey::from_base64(&key.pk.to_base64()).unwrap()
}
fn fixture(current: &str) -> Fixture {
let tmp = tempfile::tempdir().unwrap();
let releases = tmp.path().join("releases");
let dir = tmp.path().join("bin");
std::fs::create_dir_all(&releases).unwrap();
std::fs::create_dir_all(&dir).unwrap();
for (_, bins) in PACKAGES {
for bin in bins {
let path = dir.join(bin);
std::fs::write(&path, format!("old {bin}\n")).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap();
}
}
let key = KeyPair::generate_unencrypted_keypair().unwrap();
let verify_key = verify_key(&key);
Fixture {
_tmp: tmp,
releases,
install: Install {
dir,
current: Version::parse(current).unwrap(),
target: TARGET,
},
key,
verify_key,
}
}
fn snapshot(dir: &Path) -> BTreeMap<String, (u32, Vec<u8>)> {
std::fs::read_dir(dir)
.unwrap()
.map(|e| {
let e = e.unwrap();
let meta = std::fs::symlink_metadata(e.path()).unwrap();
let contents = if meta.is_file() {
std::fs::read(e.path()).unwrap()
} else {
Vec::new()
};
(
e.file_name().to_string_lossy().into_owned(),
(meta.permissions().mode(), contents),
)
})
.collect()
}
async fn expect_refused(fx: &Fixture, source: &FixtureReleases) -> String {
let before = snapshot(&fx.install.dir);
let outcome = self_update::check_once(source, &fx.install, &fx.verify_key)
.await
.unwrap();
assert_eq!(snapshot(&fx.install.dir), before, "install dir changed");
assert_eq!(
self_update::report(&outcome),
None,
"a refusal must not exit"
);
match outcome {
Outcome::Refused { version, reason } => {
assert_eq!(version.to_string(), source.latest.trim_start_matches('v'));
reason
}
other => panic!("expected Refused, got {other:?}"),
}
}
#[tokio::test]
async fn a_newer_good_release_installs() {
let fx = fixture("0.11.0");
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let outcome = self_update::check_once(&source, &fx.install, &fx.verify_key)
.await
.unwrap();
assert_eq!(
self_update::report(&outcome),
Some(self_update::EXIT_FOR_RESTART)
);
match outcome {
Outcome::Installed { version, replaced } => {
assert_eq!(version, Version::new(0, 12, 0));
let mut replaced = replaced;
replaced.sort();
assert_eq!(replaced, ["sb", "second-brain-api", "second-brain-mcp"]);
}
other => panic!("expected Installed, got {other:?}"),
}
let after = snapshot(&fx.install.dir);
let names: Vec<&String> = after.keys().collect();
assert_eq!(names, ["sb", "second-brain-api", "second-brain-mcp"]);
for (name, (mode, contents)) in &after {
assert_eq!(mode & 0o777, 0o755, "{name} mode");
assert_eq!(contents, &new_contents("0.12.0", name), "{name} contents");
}
}
#[tokio::test]
async fn files_missing_from_the_install_are_not_added() {
let fx = fixture("0.11.0");
std::fs::remove_file(fx.install.dir.join("second-brain-mcp")).unwrap();
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let outcome = self_update::check_once(&source, &fx.install, &fx.verify_key)
.await
.unwrap();
let Outcome::Installed { mut replaced, .. } = outcome else {
panic!("expected Installed, got {outcome:?}");
};
replaced.sort();
assert_eq!(replaced, ["sb", "second-brain-api"]);
let after = snapshot(&fx.install.dir);
assert_eq!(
after.keys().collect::<Vec<_>>(),
["sb", "second-brain-api"],
"no new files and no staging left"
);
}
#[tokio::test]
async fn only_executables_from_the_archives_are_installed() {
let fx = fixture("0.11.0");
std::fs::write(fx.install.dir.join("README.md"), "local notes\n").unwrap();
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let outcome = self_update::check_once(&source, &fx.install, &fx.verify_key)
.await
.unwrap();
let Outcome::Installed { mut replaced, .. } = outcome else {
panic!("expected Installed, got {outcome:?}");
};
replaced.sort();
assert_eq!(replaced, ["sb", "second-brain-api", "second-brain-mcp"]);
assert_eq!(
std::fs::read_to_string(fx.install.dir.join("README.md")).unwrap(),
"local notes\n"
);
}
#[tokio::test]
async fn an_install_without_the_daemon_is_refused_before_downloading() {
let fx = fixture("0.11.0");
std::fs::remove_file(fx.install.dir.join("second-brain-api")).unwrap();
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("second-brain-api"), "{reason}");
assert!(source.fetched().is_empty(), "{:?}", source.fetched());
}
#[tokio::test]
async fn an_unwritable_install_is_refused_before_downloading() {
let fx = fixture("0.11.0");
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let dir = &fx.install.dir;
std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o555)).unwrap();
let reason = expect_refused(&fx, &source).await;
std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o755)).unwrap();
assert!(reason.contains("cannot write"), "{reason}");
assert!(source.fetched().is_empty(), "{:?}", source.fetched());
}
#[tokio::test]
async fn a_release_signed_by_another_key_is_refused() {
let fx = fixture("0.11.0");
let other = KeyPair::generate_unencrypted_keypair().unwrap();
Release {
root: &fx.releases,
version: "0.12.0",
key: &other,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("signature verification"), "{reason}");
}
#[tokio::test]
async fn a_tampered_archive_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let path = release.archive_path("second-brain-cli");
let mut bytes = std::fs::read(&path).unwrap();
let mid = bytes.len() / 2;
bytes[mid] ^= 0x01;
std::fs::write(&path, bytes).unwrap();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("signature verification"), "{reason}");
let fetched = source.fetched();
assert!(
!fetched
.iter()
.any(|asset| asset.contains("second-brain-mcp")),
"kept downloading after a refusal: {fetched:?}"
);
}
#[tokio::test]
async fn an_oversized_signature_is_not_downloaded_whole() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
std::fs::write(
release.signature_path("second-brain-api"),
vec![b'a'; 64 * 1024],
)
.unwrap();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let before = snapshot(&fx.install.dir);
let result = self_update::check_once(&source, &fx.install, &fx.verify_key).await;
assert!(result.is_err(), "{result:?}");
assert_eq!(snapshot(&fx.install.dir), before);
let fetched = source.fetched();
assert!(
!fetched.iter().any(|asset| asset.ends_with(".tar.xz")),
"fetched an archive after an unusable signature: {fetched:?}"
);
}
#[tokio::test]
async fn a_garbled_signature_file_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
std::fs::write(
release.signature_path("second-brain-mcp"),
"not a signature\n",
)
.unwrap();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("does not parse"), "{reason}");
}
#[tokio::test]
async fn a_trusted_comment_naming_another_version_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let entries = package_entries("0.12.0", "second-brain-api", &["second-brain-api"]);
let entries: Vec<Entry> = entries
.iter()
.map(|(p, d)| Entry::File(p, d.clone()))
.collect();
let archive = tar_xz(&entries);
release.publish(
"second-brain-api",
&archive,
&trusted_comment("0.11.5", &archive_name("second-brain-api")),
);
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("trusted comment"), "{reason}");
}
#[tokio::test]
async fn a_trusted_comment_naming_another_file_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let cli = std::fs::read(release.archive_path("second-brain-cli")).unwrap();
release.publish(
"second-brain-cli",
&cli,
&trusted_comment("0.12.0", &archive_name("second-brain-api")),
);
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("trusted comment"), "{reason}");
}
#[tokio::test]
async fn an_api_archive_without_the_daemon_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let top = format!("second-brain-api-{TARGET}");
let archive = tar_xz(&[Entry::File(
&format!("{top}/README.md"),
b"readme\n".to_vec(),
)]);
release.publish(
"second-brain-api",
&archive,
&trusted_comment("0.12.0", &archive_name("second-brain-api")),
);
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("second-brain-api"), "{reason}");
}
#[tokio::test]
async fn an_archive_with_a_symlink_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let top = format!("second-brain-cli-{TARGET}");
let archive = tar_xz(&[
Entry::File(&format!("{top}/README.md"), b"readme\n".to_vec()),
Entry::Symlink(&format!("{top}/sb"), "/bin/sh"),
]);
release.publish(
"second-brain-cli",
&archive,
&trusted_comment("0.12.0", &archive_name("second-brain-cli")),
);
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("non-regular"), "{reason}");
}
#[tokio::test]
async fn an_archive_with_path_traversal_is_refused() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
let mut builder = tar::Builder::new(Vec::new());
let data = new_contents("0.12.0", "sb");
let mut header = tar::Header::new_gnu();
header.set_entry_type(tar::EntryType::Regular);
header.set_mode(0o755);
header.set_size(data.len() as u64);
let name = format!("second-brain-cli-{TARGET}/../sb");
header.as_gnu_mut().unwrap().name[..name.len()].copy_from_slice(name.as_bytes());
header.set_cksum();
builder.append(&header, data.as_slice()).unwrap();
let tar_bytes = builder.into_inner().unwrap();
let mut archive = Vec::new();
lzma_rs::xz_compress(&mut tar_bytes.as_slice(), &mut archive).unwrap();
release.publish(
"second-brain-cli",
&archive,
&trusted_comment("0.12.0", &archive_name("second-brain-cli")),
);
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let reason = expect_refused(&fx, &source).await;
assert!(reason.contains("outside its directory"), "{reason}");
}
#[tokio::test]
async fn an_equal_version_is_up_to_date_and_fetches_nothing() {
let fx = fixture("0.12.0");
Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let before = snapshot(&fx.install.dir);
let outcome = self_update::check_once(&source, &fx.install, &fx.verify_key)
.await
.unwrap();
assert!(
matches!(&outcome, Outcome::UpToDate { latest } if *latest == Version::new(0, 12, 0)),
"{outcome:?}"
);
assert_eq!(self_update::report(&outcome), None);
assert!(source.fetched().is_empty(), "{:?}", source.fetched());
assert_eq!(snapshot(&fx.install.dir), before);
}
#[tokio::test]
async fn an_older_version_is_up_to_date() {
let fx = fixture("0.12.0");
Release {
root: &fx.releases,
version: "0.11.0",
key: &fx.key,
}
.publish_good();
let source = FixtureReleases::new(&fx.releases, "v0.11.0");
let before = snapshot(&fx.install.dir);
let outcome = self_update::check_once(&source, &fx.install, &fx.verify_key)
.await
.unwrap();
assert!(
matches!(&outcome, Outcome::UpToDate { latest } if *latest == Version::new(0, 11, 0)),
"{outcome:?}"
);
assert!(source.fetched().is_empty(), "{:?}", source.fetched());
assert_eq!(snapshot(&fx.install.dir), before);
}
#[tokio::test]
async fn a_missing_asset_is_an_error_not_a_refusal() {
let fx = fixture("0.11.0");
let release = Release {
root: &fx.releases,
version: "0.12.0",
key: &fx.key,
};
release.publish_good();
std::fs::remove_file(release.signature_path("second-brain-mcp")).unwrap();
let source = FixtureReleases::new(&fx.releases, "v0.12.0");
let before = snapshot(&fx.install.dir);
let result = self_update::check_once(&source, &fx.install, &fx.verify_key).await;
assert!(result.is_err(), "{result:?}");
assert_eq!(snapshot(&fx.install.dir), before);
}
#[test]
fn only_release_builds_on_known_targets_own_their_install() {
let exe = Path::new("/opt/second-brain/bin/second-brain-api");
assert!(decide_install(false, exe, "linux", "x86_64").is_none());
assert!(decide_install(true, exe, "linux", "riscv64").is_none());
assert!(decide_install(true, exe, "macos", "x86_64").is_none());
assert!(decide_install(true, exe, "windows", "x86_64").is_none());
for (os, arch, target) in [
("linux", "x86_64", "x86_64-unknown-linux-gnu"),
("linux", "aarch64", "aarch64-unknown-linux-gnu"),
("macos", "aarch64", "aarch64-apple-darwin"),
] {
let install = decide_install(true, exe, os, arch).expect(target);
assert_eq!(install.target, target);
assert_eq!(install.dir, Path::new("/opt/second-brain/bin"));
assert_eq!(
install.current,
Version::parse(env!("CARGO_PKG_VERSION")).unwrap()
);
}
}
#[test]
fn the_release_public_key_decodes() {
minisign_verify::PublicKey::from_base64(RELEASE_PUBLIC_KEY).unwrap();
}
#[test]
fn the_release_source_is_this_repository_on_github() {
let source = self_update::GitHubReleases::from_repository(env!("CARGO_PKG_REPOSITORY"))
.expect("repository is a GitHub URL");
assert_eq!(
source.download_url("v0.12.0", "sb.tar.xz"),
format!(
"{}/releases/download/v0.12.0/sb.tar.xz",
env!("CARGO_PKG_REPOSITORY").trim_end_matches(".git")
)
);
assert!(self_update::GitHubReleases::from_repository("https://gitlab.com/a/b").is_none());
}