Files
rust-discovery/crates/agent-windows/src/release_service.rs
T

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(())
}