From 94fd5fb5b9d234bbb31df7d42a1f8d0543c5f850 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9?= Date: Sat, 10 Oct 2026 12:05:14 +0500 Subject: [PATCH] Resolve signed immutable server update channels --- .../20261010-immutable-update-channels.md | 7 ++ crates/coa-core/src/channels.rs | 86 +++++++++++++++++++ crates/coa-core/src/lib.rs | 1 + crates/coa-release/src/main.rs | 10 +++ src-tauri/src/lib.rs | 20 +++-- 5 files changed, 117 insertions(+), 7 deletions(-) create mode 100644 changelog.d/20261010-immutable-update-channels.md create mode 100644 crates/coa-core/src/channels.rs diff --git a/changelog.d/20261010-immutable-update-channels.md b/changelog.d/20261010-immutable-update-channels.md new file mode 100644 index 0000000..eb7e414 --- /dev/null +++ b/changelog.d/20261010-immutable-update-channels.md @@ -0,0 +1,7 @@ +--- +area: manager +type: added +audience: admins +title: Updates can follow signed channels that select a complete server release +--- +The Manager checks the channel signature and downloads every package part from the same release. Existing installations continue using the previous download source until the new channel is published. diff --git a/crates/coa-core/src/channels.rs b/crates/coa-core/src/channels.rs new file mode 100644 index 0000000..53d787a --- /dev/null +++ b/crates/coa-core/src/channels.rs @@ -0,0 +1,86 @@ +//! Signed channel pointers select one immutable package for an entire transaction. +use serde::{Deserialize, Serialize}; +use crate::{Error, Result}; +use crate::pkgsource::{fetch_small, Source}; + +#[derive(Debug, Serialize, Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct Pointer { + pub schema: u32, + pub channel: String, + pub version: String, + pub release_tag: String, + pub snapshot: String, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct Envelope { + pub payload: String, + pub signature: String, +} + +pub fn verify(bytes: &[u8], channel: &str, key: &str) -> Result { + let envelope: Envelope = serde_json::from_slice(bytes).map_err(|e| Error::InvalidManifest(e.to_string()))?; + crate::signing::verify(envelope.payload.as_bytes(), &envelope.signature, key)?; + let pointer: Pointer = serde_json::from_str(&envelope.payload).map_err(|e| Error::InvalidManifest(e.to_string()))?; + if pointer.schema != 1 || pointer.channel != channel + || pointer.release_tag != format!("server-{}", pointer.version) + || pointer.version.is_empty() + || !pointer.version.bytes().all(|b| b.is_ascii_digit() || b == b'.') + || pointer.snapshot.len() != 64 + || !pointer.snapshot.bytes().all(|b| b.is_ascii_hexdigit()) { + return Err(Error::InvalidManifest("Invalid channel pointer".into())); + } + Ok(pointer) +} + +pub fn resolve(channel: &str) -> Result { + if channel != "stable" && channel != "edge" { + return Err(Error::InvalidManifest("Unknown release channel".into())); + } + let source = Source::Url("https://raw.githubusercontent.com/Corfirean/coa-server-build/channels".into()); + let bytes = fetch_small(&source, &format!("{channel}.json"))?; + let pointer = verify(&bytes, channel, crate::signing::EMBEDDED_PUBLIC_KEY)?; + Ok(Source::Url(format!("https://github.com/Corfirean/coa-server-build/releases/download/{}", pointer.release_tag))) +} + +pub fn sign(pointer: &Pointer, seed: &str) -> Result> { + use base64::{engine::general_purpose::STANDARD, Engine}; + use ed25519_dalek::{Signer, SigningKey}; + let seed: [u8; 32] = STANDARD.decode(seed.trim()).map_err(|_| Error::Invalid("Invalid signing key".into()))? + .try_into().map_err(|_| Error::Invalid("Invalid signing key length".into()))?; + let payload = serde_json::to_string(pointer).map_err(|e| Error::Invalid(e.to_string()))?; + let signature = STANDARD.encode(SigningKey::from_bytes(&seed).sign(payload.as_bytes()).to_bytes()); + let bytes = serde_json::to_vec(&Envelope { payload, signature }).map_err(|e| Error::Invalid(e.to_string()))?; + verify(&bytes, &pointer.channel, crate::signing::EMBEDDED_PUBLIC_KEY)?; + Ok(bytes) +} + +#[cfg(test)] +mod tests { + use super::*; + use base64::{engine::general_purpose::STANDARD, Engine}; + use ed25519_dalek::{Signer, SigningKey}; + + fn signed(pointer: &Pointer) -> (Vec, String) { + let sk = SigningKey::from_bytes(&[17; 32]); + let payload = serde_json::to_string(pointer).unwrap(); + let signature = STANDARD.encode(sk.sign(payload.as_bytes()).to_bytes()); + (serde_json::to_vec(&Envelope { payload, signature }).unwrap(), STANDARD.encode(sk.verifying_key().to_bytes())) + } + + #[test] + fn verifies_identity_signature_and_immutable_tag() { + let mut p = Pointer { schema: 1, channel: "stable".into(), version: "0.261010.40".into(), release_tag: "server-0.261010.40".into(), snapshot: "a".repeat(64) }; + let (bytes, key) = signed(&p); + assert_eq!(verify(&bytes, "stable", &key).unwrap().version, p.version); + assert!(verify(&bytes, "edge", &key).is_err()); + let mut changed: Envelope = serde_json::from_slice(&bytes).unwrap(); + changed.payload = changed.payload.replace("40", "41"); + assert!(verify(&serde_json::to_vec(&changed).unwrap(), "stable", &key).is_err()); + p.release_tag = "stable".into(); + let (bytes, key) = signed(&p); + assert!(verify(&bytes, "stable", &key).is_err()); + } +} diff --git a/crates/coa-core/src/lib.rs b/crates/coa-core/src/lib.rs index e276e03..18d2b35 100644 --- a/crates/coa-core/src/lib.rs +++ b/crates/coa-core/src/lib.rs @@ -47,6 +47,7 @@ pub mod update; pub mod wine; pub mod upnp; pub mod signing; +pub mod channels; pub mod srp6; pub use error::{Error, ErrorCode, Result}; diff --git a/crates/coa-release/src/main.rs b/crates/coa-release/src/main.rs index 7551547..604359b 100644 --- a/crates/coa-release/src/main.rs +++ b/crates/coa-release/src/main.rs @@ -112,6 +112,16 @@ fn run() -> Result<(), String> { coa_core::release_schema::verify_package(&dir, coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?; println!("signature, archive contents and database schema contract OK"); } + "sign-channel" => { + let pointer = coa_core::channels::Pointer { + schema: 1, channel: need(&a, "channel")?.clone(), + version: need(&a, "version")?.clone(), + release_tag: format!("server-{}", need(&a, "version")?), + snapshot: need(&a, "snapshot")?.clone(), + }; + let bytes = coa_core::channels::sign(&pointer, &signing_key()?).map_err(e)?; + coa_core::fsx::atomic_write(&PathBuf::from(need(&a, "out")?), &bytes).map_err(e)?; + } other => return Err(format!("unknown command {other}")), } Ok(()) diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 1d9ade2..1110b03 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -39,12 +39,16 @@ struct AppState { /// Where signed update packages are published; override with COA_UPDATE_SOURCE (URL or local package folder). const DEFAULT_UPDATE_URL: &str = "https://github.com/Corfirean/coa-server-build/releases/download/stable"; -fn update_source(custom: Option) -> Source { +fn update_source(custom: Option) -> Result { let pick = custom.filter(|s| !s.trim().is_empty()).or_else(|| std::env::var("COA_UPDATE_SOURCE").ok()); match pick { - Some(p) if p.to_ascii_lowercase().starts_with("http") => Source::Url(p), - Some(p) => Source::Dir(PathBuf::from(p)), - None => Source::Url(DEFAULT_UPDATE_URL.into()), + Some(p) if p.to_ascii_lowercase().starts_with("http") => Ok(Source::Url(p)), + Some(p) => Ok(Source::Dir(PathBuf::from(p))), + None => match coa_core::channels::resolve("stable") { + Ok(source) => Ok(source), + Err(Error::PackageNotPublished(_)) => Ok(Source::Url(DEFAULT_UPDATE_URL.into())), + Err(error) => Err(error), + }, } } @@ -645,7 +649,7 @@ async fn repair_server(app: AppHandle, state: State<'_, AppState>, id: String) - let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { let dir = meta_dir(&root)?; - coa_core::repair::run(&root, &dir, &package_source(None), &update_source(None), coa_core::signing::EMBEDDED_PUBLIC_KEY, &|step,percent| { + coa_core::repair::run(&root, &dir, &package_source(None), &update_source(None)?, coa_core::signing::EMBEDDED_PUBLIC_KEY, &|step,percent| { let _ = app.emit("repair-progress", serde_json::json!({ "id": id, "step": step, "percent": percent })); }) }).await @@ -797,11 +801,12 @@ fn install_meta(root: &std::path::Path) -> Result<(PathBuf, InstallMeta)> { #[tauri::command] async fn check_update(state: State<'_, AppState>, id: String, source: Option, background: Option) -> std::result::Result { let root = path_of(&state, &id)?; - let src = update_source(source); + // The check that repeats every few minutes must not start and stop the database of a stopped server. let access = if background.unwrap_or(false) { update::DatabaseAccess::OnlyIfRunning } else { update::DatabaseAccess::Start }; blocking(move || { let (_, meta) = install_meta(&root)?; + let src = update_source(source)?; update::preview_with(&root, &meta, &src, coa_core::signing::EMBEDDED_PUBLIC_KEY, &Default::default(), access) }) .await @@ -822,9 +827,10 @@ async fn apply_update( resolutions: BTreeMap, ) -> std::result::Result { let root = path_of(&state, &id)?; - let src = update_source(source); + let _guard = BusyGuard::acquire(&state, &id)?; blocking(move || { + let src = update_source(source)?; let (dir, _) = install_meta(&root)?; // Files cannot be replaced while the server runs: stop it first (gracefully), like the Stop button. let observed = coa_core::process::observe(&root, &layout::read_ports(&root));