490 lines
17 KiB
Rust
490 lines
17 KiB
Rust
//! Unattended, fixed-role releases for installations made by the HTTPS installer.
|
|
use crate::release_platform::{TRIPLE, VERIFY};
|
|
use crate::{
|
|
certificate_rotation::{ProtectedKeyFiles, RotationStore},
|
|
job_binding, native,
|
|
};
|
|
use anyhow::{Context, Result, ensure};
|
|
use reqwest::{Client, Response};
|
|
use rmm_domain::agent_update::ReleaseEnvelope;
|
|
use rmm_updater::ReleaseManifest;
|
|
use rusqlite::{Connection, OpenFlags};
|
|
use serde::{Deserialize, Serialize};
|
|
use sha2::{Digest, Sha256};
|
|
use std::{
|
|
ffi::OsStr,
|
|
fs,
|
|
io::Write,
|
|
net::SocketAddr,
|
|
os::windows::ffi::OsStrExt,
|
|
path::{Path, PathBuf},
|
|
process::Command,
|
|
sync::atomic::{AtomicBool, Ordering},
|
|
time::Duration,
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
pub const SERVICE: &str = "RmmDiscoveryReleasePull";
|
|
const AGENT: &str = "rmm-agent-windows.exe";
|
|
const HELPER: &str = "rmm-helper-windows.exe";
|
|
const ACTIVE: &str = "installed-release.json";
|
|
const INTENT: &str = "release-transition.json";
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
struct Installed {
|
|
schema_version: u32,
|
|
tenant_id: Uuid,
|
|
release_id: Uuid,
|
|
release_sequence: u64,
|
|
manifest_sha256: String,
|
|
}
|
|
#[derive(Serialize, Deserialize)]
|
|
struct Transition {
|
|
old: Installed,
|
|
new: Installed,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct Endpoint {
|
|
server_name: String,
|
|
connect_address: SocketAddr,
|
|
transport: String,
|
|
state_directory: PathBuf,
|
|
ca_file: PathBuf,
|
|
#[serde(default)]
|
|
enable_jobs: bool,
|
|
#[serde(default)]
|
|
localservice_time_policy: Option<PathBuf>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct Health {
|
|
agent_id: Uuid,
|
|
agent_version: Option<String>,
|
|
connection_generation: u64,
|
|
last_contact_at: Option<chrono::DateTime<chrono::Utc>>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct Current {
|
|
status: String,
|
|
release: Option<Published>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct Published {
|
|
release_envelope: ReleaseEnvelope,
|
|
manifest: ReleaseManifest,
|
|
}
|
|
|
|
fn data(name: &str) -> PathBuf {
|
|
PathBuf::from(std::env::var_os("ProgramData").unwrap_or_else(|| r"C:\ProgramData".into()))
|
|
.join("RustDiscovery")
|
|
.join(name)
|
|
}
|
|
fn releases() -> PathBuf {
|
|
PathBuf::from(std::env::var_os("ProgramFiles").unwrap_or_else(|| r"C:\Program Files".into()))
|
|
.join("RustDiscovery")
|
|
.join("releases")
|
|
}
|
|
fn generation(id: Uuid) -> PathBuf {
|
|
releases().join(id.to_string())
|
|
}
|
|
|
|
fn protected(path: &Path, limit: usize) -> Result<Vec<u8>> {
|
|
job_binding::check_admin_readonly(path)?;
|
|
ensure!(
|
|
fs::metadata(path)?.len() <= limit as u64,
|
|
"protected file size"
|
|
);
|
|
Ok(fs::read(path)?)
|
|
}
|
|
fn read_record<T: serde::de::DeserializeOwned>(name: &str) -> Result<T> {
|
|
Ok(serde_json::from_slice(&protected(&data(name), 8192)?)?)
|
|
}
|
|
fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
|
|
let mut file = fs::File::create_new(path)?;
|
|
file.write_all(bytes)?;
|
|
file.sync_all()?;
|
|
Ok(())
|
|
}
|
|
fn write_record<T: Serialize>(name: &str, value: &T) -> Result<()> {
|
|
use windows_sys::Win32::Storage::FileSystem::{
|
|
MOVEFILE_REPLACE_EXISTING, MOVEFILE_WRITE_THROUGH, MoveFileExW,
|
|
};
|
|
let tmp = data(&format!(".release-{}", Uuid::new_v4()));
|
|
let wide = |p: &OsStr| p.encode_wide().chain(Some(0)).collect::<Vec<_>>();
|
|
let result = (|| -> Result<()> {
|
|
write_new(&tmp, &serde_json::to_vec(value)?)?;
|
|
let (from, to) = (wide(tmp.as_os_str()), wide(data(name).as_os_str()));
|
|
if unsafe {
|
|
MoveFileExW(
|
|
from.as_ptr(),
|
|
to.as_ptr(),
|
|
MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH,
|
|
)
|
|
} == 0
|
|
{
|
|
return Err(std::io::Error::last_os_error().into());
|
|
}
|
|
Ok(())
|
|
})();
|
|
let _ = fs::remove_file(tmp);
|
|
result
|
|
}
|
|
struct Device {
|
|
client: Client,
|
|
base: String,
|
|
id: Uuid,
|
|
}
|
|
impl Device {
|
|
fn open(config: &Endpoint) -> Result<Self> {
|
|
ensure!(
|
|
config.transport == "https"
|
|
&& config.ca_file == data("server-ca.pem")
|
|
&& config.state_directory == data("state"),
|
|
"installed HTTPS configuration"
|
|
);
|
|
let ca = protected(&config.ca_file, 32768)?;
|
|
let state = &config.state_directory;
|
|
let identity_path = state.join("identity.json");
|
|
native::private_path(&identity_path, false)?;
|
|
ensure!(
|
|
fs::metadata(&identity_path)?.len() <= 32768,
|
|
"identity size"
|
|
);
|
|
let identity: rmm_protocol::EnrollmentResponse =
|
|
serde_json::from_slice(&fs::read(identity_path)?)?;
|
|
let id = Uuid::parse_str(&identity.agent_id)?;
|
|
let db_path = state.join("telemetry.sqlite");
|
|
native::private_path(&db_path, false)?;
|
|
let db = Connection::open_with_flags(
|
|
db_path,
|
|
OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
|
|
)?;
|
|
db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?;
|
|
let keys = ProtectedKeyFiles::open(state)?;
|
|
let rotation = RotationStore::new(id, 1, ca.clone())?;
|
|
let tls = rotation.read_only_current(&db, &keys, chrono::Utc::now().timestamp())?;
|
|
let mut pem = tls.certificate_pem;
|
|
pem.push(b'\n');
|
|
pem.extend_from_slice(&tls.private_key_pem);
|
|
let base = reqwest::Url::parse(&format!(
|
|
"https://{}:{}",
|
|
config.server_name,
|
|
config.connect_address.port()
|
|
))?;
|
|
ensure!(
|
|
base.domain() == Some(config.server_name.as_str()),
|
|
"invalid gateway hostname"
|
|
);
|
|
let client = Client::builder()
|
|
.https_only(true)
|
|
.tls_built_in_root_certs(false)
|
|
.add_root_certificate(reqwest::Certificate::from_pem(&ca)?)
|
|
.identity(reqwest::Identity::from_pem(&pem)?)
|
|
.resolve(&config.server_name, config.connect_address)
|
|
.no_proxy()
|
|
.redirect(reqwest::redirect::Policy::none())
|
|
.connect_timeout(Duration::from_secs(10))
|
|
.timeout(Duration::from_secs(180))
|
|
.build()?;
|
|
Ok(Self {
|
|
client,
|
|
base: base.origin().ascii_serialization(),
|
|
id,
|
|
})
|
|
}
|
|
async fn get(&self, path: &str, timeout: Duration) -> Result<Response> {
|
|
let r = self
|
|
.client
|
|
.get(format!("{}{path}", self.base))
|
|
.timeout(timeout)
|
|
.send()
|
|
.await?;
|
|
ensure!(
|
|
r.status() == 200,
|
|
"device release service returned {}",
|
|
r.status()
|
|
);
|
|
Ok(r)
|
|
}
|
|
async fn json<T: serde::de::DeserializeOwned>(&self, path: &str) -> Result<T> {
|
|
let mut r = self.get(path, Duration::from_secs(10)).await?;
|
|
let mut body = Vec::new();
|
|
while let Some(chunk) = r.chunk().await? {
|
|
ensure!(
|
|
body.len() + chunk.len() <= 131072,
|
|
"release response too large"
|
|
);
|
|
body.extend_from_slice(&chunk);
|
|
}
|
|
Ok(serde_json::from_slice(&body)?)
|
|
}
|
|
async fn health(&self) -> Result<Health> {
|
|
let value: Health = self.json("/agent/v1/releases/installed").await?;
|
|
ensure!(value.agent_id == self.id, "device release identity changed");
|
|
Ok(value)
|
|
}
|
|
async fn download(&self, path: &Path, url: &str, limit: u64) -> Result<()> {
|
|
ensure!(
|
|
(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&limit),
|
|
"release size"
|
|
);
|
|
let mut r = self.get(url, Duration::from_secs(180)).await?;
|
|
ensure!(r.content_length() == Some(limit), "release length");
|
|
let mut file = fs::File::create_new(path)?;
|
|
let mut count = 0;
|
|
while let Some(chunk) = r.chunk().await? {
|
|
count += chunk.len() as u64;
|
|
ensure!(count <= limit, "release body too large");
|
|
file.write_all(&chunk)?;
|
|
}
|
|
ensure!(count == limit, "truncated release");
|
|
file.sync_all()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn local_manifest(installed: &Installed) -> Result<ReleaseManifest> {
|
|
let root = generation(installed.release_id);
|
|
let raw = protected(&root.join("manifest.json"), rmm_updater::MAX_MANIFEST_BYTES)?;
|
|
ensure!(
|
|
hex::encode(Sha256::digest(&raw)) == installed.manifest_sha256,
|
|
"changed installed manifest"
|
|
);
|
|
let m: ReleaseManifest = serde_json::from_slice(&raw)?;
|
|
ensure!(
|
|
installed.schema_version == 1
|
|
&& m.platform == VERIFY
|
|
&& m.release_id == installed.release_id
|
|
&& m.release_sequence == installed.release_sequence,
|
|
"installed release identity"
|
|
);
|
|
for (expected, name) in m.artifacts.iter().zip([AGENT, HELPER]) {
|
|
let path = root.join(name);
|
|
job_binding::check_admin_readonly(&path)?;
|
|
let mut digest = Sha256::new();
|
|
let count = std::io::copy(&mut fs::File::open(path)?, &mut digest)?;
|
|
ensure!(
|
|
expected.bytes == count && expected.sha256 == hex::encode(digest.finalize()),
|
|
"installed release component changed"
|
|
);
|
|
}
|
|
Ok(m)
|
|
}
|
|
|
|
// Only typed release UUIDs enter the fixed SCM command. The actual service path,
|
|
// LocalService account and absence of an independently provisioned helper are checked again on the target.
|
|
fn select(from: Uuid, to: Uuid) -> Result<()> {
|
|
let script = include_str!("release_service_switch.ps1")
|
|
.replace("FROM_UUID", &from.to_string())
|
|
.replace("TO_UUID", &to.to_string());
|
|
let windows = std::env::var_os("SystemRoot").context("Windows directory")?;
|
|
let ps = Path::new(&windows).join(r"System32\WindowsPowerShell\v1.0\powershell.exe");
|
|
let result = Command::new(ps)
|
|
.args([
|
|
"-NoLogo",
|
|
"-NoProfile",
|
|
"-NonInteractive",
|
|
"-Command",
|
|
&script,
|
|
])
|
|
.output()?;
|
|
ensure!(result.status.success(), "SCM release selection failed");
|
|
Ok(())
|
|
}
|
|
async fn rollback(t: &Transition) -> Result<()> {
|
|
local_manifest(&t.old)?;
|
|
select(t.new.release_id, t.old.release_id)?;
|
|
write_record("rejected-release.json", &t.new)?;
|
|
fs::remove_file(data(INTENT))?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn stage(device: &Device, release: &Published, active: &Installed) -> Result<Installed> {
|
|
let id = release.manifest.release_id;
|
|
let tmp = releases().join(format!(".stage-{}", Uuid::new_v4()));
|
|
fs::create_dir(&tmp)?;
|
|
let result = async {
|
|
let env_path = tmp.join("envelope.json");
|
|
write_new(&env_path, &serde_json::to_vec(&release.release_envelope)?)?;
|
|
for (entry, name) in release.manifest.artifacts.iter().zip([AGENT, HELPER]) {
|
|
device
|
|
.download(
|
|
&tmp.join(name),
|
|
&format!("/agent/v1/releases/{id}/artifacts/{}", entry.artifact_id),
|
|
entry.bytes,
|
|
)
|
|
.await?;
|
|
}
|
|
let paths = [
|
|
data("release-keyring.json"),
|
|
env_path,
|
|
tmp.join(AGENT),
|
|
tmp.join(HELPER),
|
|
]
|
|
.map(PathBuf::into_os_string);
|
|
let verified = rmm_updater::verify_bootstrap_files(VERIFY, &paths)?;
|
|
ensure!(
|
|
verified.manifest() == &release.manifest
|
|
&& verified.manifest().release_sequence > active.release_sequence,
|
|
"signed release identity"
|
|
);
|
|
let record = Installed {
|
|
schema_version: 1,
|
|
tenant_id: active.tenant_id,
|
|
release_id: id,
|
|
release_sequence: verified.manifest().release_sequence,
|
|
manifest_sha256: verified.manifest_sha256().into(),
|
|
};
|
|
write_new(
|
|
&tmp.join("manifest.json"),
|
|
&serde_json::to_vec(verified.manifest())?,
|
|
)?;
|
|
if !generation(id).try_exists()? {
|
|
fs::rename(&tmp, generation(id))?;
|
|
}
|
|
local_manifest(&record)?;
|
|
Ok::<_, anyhow::Error>(record)
|
|
}
|
|
.await;
|
|
if tmp.try_exists()? {
|
|
fs::remove_dir_all(tmp)?;
|
|
}
|
|
result
|
|
}
|
|
|
|
fn exclusive_job_gate() -> Result<Option<fs::File>> {
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
let path = data("release-job.lock");
|
|
job_binding::check_admin_readonly(&path)?;
|
|
match fs::OpenOptions::new().read(true).share_mode(0).open(path) {
|
|
Ok(file) => Ok(Some(file)),
|
|
Err(error) if error.raw_os_error() == Some(32) => Ok(None),
|
|
Err(error) => Err(error.into()),
|
|
}
|
|
}
|
|
|
|
async fn cycle() -> Result<()> {
|
|
let active: Installed = read_record(ACTIVE)?;
|
|
let config: Endpoint = serde_json::from_slice(&protected(&data("config.json"), 32768)?)?;
|
|
// Additional SYSTEM helper pins need their separately coordinated handoff.
|
|
ensure!(
|
|
!config.enable_jobs
|
|
|| config.localservice_time_policy.as_ref() == Some(&data("job-time.json")),
|
|
"job-enabled pair requires coordinated helper handoff"
|
|
);
|
|
if data(INTENT).try_exists()? {
|
|
let _job_gate = if config.enable_jobs {
|
|
let Some(file) = exclusive_job_gate()? else {
|
|
return Ok(());
|
|
};
|
|
Some(file)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let t: Transition = read_record(INTENT)?;
|
|
if active.release_id == t.new.release_id {
|
|
fs::remove_file(data(INTENT))?;
|
|
} else {
|
|
ensure!(
|
|
active.release_id == t.old.release_id,
|
|
"unexpected activation floor"
|
|
);
|
|
rollback(&t).await?;
|
|
}
|
|
}
|
|
let device = Device::open(&config)?;
|
|
let catalog: Current = device
|
|
.json(&format!("/agent/v1/releases/current?platform={TRIPLE}"))
|
|
.await?;
|
|
let Some(release) = catalog.release else {
|
|
ensure!(
|
|
catalog.status == "not_configured",
|
|
"unexpected release response"
|
|
);
|
|
return Ok(());
|
|
};
|
|
let decoded = release
|
|
.release_envelope
|
|
.decode()
|
|
.map_err(|_| anyhow::anyhow!("invalid release envelope"))?;
|
|
let candidate = &release.manifest;
|
|
ensure!(
|
|
catalog.status == "available"
|
|
&& candidate.platform == VERIFY
|
|
&& candidate.release_sequence >= active.release_sequence,
|
|
"invalid release sequence or platform"
|
|
);
|
|
if candidate.release_sequence == active.release_sequence {
|
|
ensure!(
|
|
candidate.release_id == active.release_id
|
|
&& hex::encode(Sha256::digest(decoded.payload_bytes)) == active.manifest_sha256,
|
|
"conflicting equal release"
|
|
);
|
|
return Ok(());
|
|
}
|
|
if data("rejected-release.json").try_exists()? {
|
|
let rejected: Installed = read_record("rejected-release.json")?;
|
|
ensure!(
|
|
candidate.release_sequence > rejected.release_sequence,
|
|
"previously failed release sequence"
|
|
);
|
|
}
|
|
let old = local_manifest(&active)?;
|
|
let before = device.health().await?;
|
|
ensure!(
|
|
before.agent_version.as_deref() == Some(&old.version),
|
|
"current agent version not confirmed"
|
|
);
|
|
let new = stage(&device, &release, &active).await?;
|
|
let _job_gate = if config.enable_jobs {
|
|
let Some(file) = exclusive_job_gate()? else {
|
|
return Ok(());
|
|
};
|
|
Some(file)
|
|
} else {
|
|
None
|
|
};
|
|
let t = Transition { old: active, new };
|
|
write_record(INTENT, &t)?;
|
|
let start = chrono::Utc::now();
|
|
let selected = select(t.old.release_id, t.new.release_id);
|
|
if selected.is_ok() {
|
|
for _ in 0..18 {
|
|
if let Ok(h) = device.health().await
|
|
&& h.connection_generation > before.connection_generation
|
|
&& h.agent_version.as_deref() == Some(&candidate.version)
|
|
&& h.last_contact_at.is_some_and(|v| v >= start)
|
|
{
|
|
write_record(ACTIVE, &t.new)?;
|
|
fs::remove_file(data(INTENT))?;
|
|
return Ok(());
|
|
}
|
|
tokio::time::sleep(Duration::from_secs(5)).await;
|
|
}
|
|
}
|
|
rollback(&t).await?;
|
|
anyhow::bail!("new release did not reconnect; previous release selected")
|
|
}
|
|
|
|
pub fn dispatch() -> Result<()> {
|
|
crate::service::dispatch_named(SERVICE, run)
|
|
}
|
|
fn run(stop: &'static AtomicBool) -> Result<()> {
|
|
let runtime = tokio::runtime::Runtime::new()?;
|
|
while !stop.load(Ordering::SeqCst) {
|
|
let result = runtime.block_on(cycle());
|
|
write_record(
|
|
"release-status.json",
|
|
&serde_json::json!({"observed_at": chrono::Utc::now(),
|
|
"status": if result.is_ok() { "ok" } else { "error" }, "detail": result.err().map(|e| e.to_string())}),
|
|
)?;
|
|
for _ in 0..300 {
|
|
if stop.load(Ordering::SeqCst) {
|
|
break;
|
|
}
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|