Integrate signed agent catalog, tenant enrollment and HTTPS installers
This commit is contained in:
@@ -0,0 +1,459 @@
|
||||
//! 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,
|
||||
}
|
||||
#[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
|
||||
}
|
||||
|
||||
async fn cycle() -> Result<()> {
|
||||
let active: Installed = read_record(ACTIVE)?;
|
||||
let config: Endpoint = serde_json::from_slice(&protected(&data("config.json"), 32768)?)?;
|
||||
// Installed passive pairs only. A separately provisioned SYSTEM helper and
|
||||
// privileged time/profile pins need the existing coordinated handoff.
|
||||
ensure!(
|
||||
!config.enable_jobs,
|
||||
"job-enabled pair requires coordinated helper handoff"
|
||||
);
|
||||
if data(INTENT).try_exists()? {
|
||||
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 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(())
|
||||
}
|
||||
Reference in New Issue
Block a user