Files
rust-discovery/crates/server/src/main.rs
T

288 lines
10 KiB
Rust

mod agent_artifacts;
mod agent_http;
mod agent_service;
mod agent_time;
mod agent_update_health;
mod agent_update_policy;
mod agent_updates;
mod api;
mod artifact_store;
mod auth;
mod catalog;
mod checkpoint_repair;
mod controls;
mod errors;
mod gateway;
mod job_gateway;
mod job_signer;
mod jobs;
mod mcp;
mod monitoring;
mod oidc;
mod pagination;
mod permissions;
mod root_policy;
mod scheduler;
mod script_library;
mod synchronization;
mod tls;
mod update_artifact_store;
mod windows_checkpoint_review;
mod windows_echo_probe;
mod windows_echo_completion;
mod windows_sync_alignment;
mod windows_system_nonstart;
mod windows_msi_catalog;
mod windows_policy;
use anyhow::{Context, Result, ensure};
use axum::{
Extension, Router,
extract::DefaultBodyLimit,
routing::{get, post},
};
use hyper_util::{
rt::{TokioExecutor, TokioIo},
server::conn::auto::Builder,
service::TowerToHyperService,
};
use rmm_domain::ServerRole;
use sha2::{Digest, Sha256};
use sqlx::postgres::PgPoolOptions;
use std::{env, fs, sync::Arc, time::Duration};
use tokio::{net::TcpListener, sync::Semaphore};
#[derive(Clone)]
pub struct State {
pool: sqlx::PgPool,
signer: Option<tls::Signer>,
viewer_a: [u8; 32],
viewer_b: [u8; 32],
auth: Arc<auth::Auth>,
job_signer: Arc<job_signer::JobSigner>,
}
#[derive(Clone)]
pub struct Peer(
pub Option<String>,
pub Option<chrono::DateTime<chrono::Utc>>,
);
fn secret_hash(name: &str) -> Result<[u8; 32]> {
let value = env::var(name).with_context(|| format!("missing {name}"))?;
ensure!(value.len() >= 32, "{name} too short");
Ok(Sha256::digest(value.as_bytes()).into())
}
#[tokio::main]
async fn main() -> Result<()> {
if env::args().nth(1).as_deref() == Some("migrate") {
return rmm_persistence::migrate(
&env::var("MIGRATION_DATABASE_URL").context("missing migration URL")?,
)
.await;
}
let profile = env::var("RMM_PROFILE").unwrap_or_default();
gateway::dev_delivery_faults::validate_environment()?;
let repair = env::args().nth(1).as_deref() == Some("repair-unsent-sync-request");
if repair {
ensure!(env::args().count() == 2, "REPAIR_NO_ARGUMENTS");
checkpoint_repair::closed_policy()?;
ensure!(
std::path::Path::new(&env::var("RMM_JOB_KEY_FILE")?).is_file(),
"REPAIR_EXISTING_KEY_REQUIRED"
);
}
let dev = env::var("RMM_DEV_AUTH").as_deref() == Ok("true");
ensure!(
matches!(
(profile.as_str(), dev),
("development", true) | ("production", false)
),
"explicit profile required; production forbids dev auth"
);
let auth = Arc::new(auth::Auth::from_env(&profile).await?);
let role = ServerRole::parse(&env::var("RMM_SERVER_ROLE").unwrap_or_else(|_| "all".into()))
.map_err(anyhow::Error::msg)?;
let pool = PgPoolOptions::new()
.max_connections(8)
.acquire_timeout(Duration::from_secs(5))
.connect(&env::var("DATABASE_URL").context("missing database URL")?)
.await
.map_err(|_| anyhow::anyhow!("database connection failed"))?;
rmm_persistence::verify_application_role(&pool).await?;
let dir = env::var("RMM_TLS_DIR").unwrap_or_else(|_| "devstate/pki".into());
let state = State {
pool,
signer: if role.gateway() {
Some(tls::Signer {
ca: openssl::x509::X509::from_pem(&fs::read(format!("{dir}/ca.pem"))?)?,
key: openssl::pkey::PKey::private_key_from_pem(&fs::read(format!(
"{dir}/ca.key"
))?)?,
})
} else {
None
},
viewer_a: if dev {
secret_hash("RMM_VIEWER_A")?
} else {
[0; 32]
},
viewer_b: if dev {
secret_hash("RMM_VIEWER_B")?
} else {
[0; 32]
},
auth,
job_signer: Arc::new(job_signer::JobSigner::load_or_create(
std::path::Path::new(
&env::var("RMM_JOB_KEY_FILE")
.unwrap_or_else(|_| "devstate/jobs/ed25519.pem".into()),
),
)?),
};
if dev {
ensure!(
state.viewer_a != state.viewer_b,
"viewer identities must be distinct"
);
state
.auth
.validate_separation(&state.viewer_a, &state.viewer_b)?;
}
if repair {
use std::io::{Read, Write};
let mut raw = Vec::new();
std::io::stdin()
.take(32 * 1024 * 1024 + 1)
.read_to_end(&mut raw)?;
ensure!(raw.len() <= 32 * 1024 * 1024, "REPAIR_INPUT_SIZE");
let evidence = serde_json::from_slice(&raw).context("REPAIR_EVIDENCE_JSON")?;
let receipt = checkpoint_repair::issue(&state, evidence).await?;
serde_json::to_writer(std::io::stdout().lock(), &receipt)?;
std::io::stdout().write_all(b"\n")?;
return Ok(());
}
if role.gateway() {
scheduler::start(state.clone());
}
let mut routes = Router::new().route("/healthz", get(|| async { "ok" }));
if role.gateway() {
routes = agent_updates::gateway_routes(routes);
routes = agent_update_health::gateway_routes(routes);
routes = agent_time::gateway_routes(routes);
routes = routes
.route("/agent/v1/enroll", post(gateway::enroll))
.route("/agent/v1/messages", post(agent_http::messages))
.route("/agent/v1/poll", post(agent_http::poll))
.route("/agent/v1/certificates/renew", post(agent_http::renew))
.route(
"/agent/v1/artifacts/{artifact}",
get(agent_artifacts::download),
);
// The deployed gateway delivers work only in HTTP responses to the agent.
// The combined local development fixture still exercises the historical wire codec.
if dev && role.api() {
routes = routes.route("/agent/v1/connect", get(gateway::connect));
}
if !role.api() {
// Public gateway never accepts browser or automation credentials.
routes = routes.route("/api/v1/job-signing-key", get(api::agent_job_signing_key));
}
}
if role.api() {
if dev {
routes = routes.route("/auth/dev/login", post(auth::login));
routes = windows_checkpoint_review::routes(routes);
routes = windows_echo_probe::routes(routes);
routes = windows_echo_completion::routes(routes);
routes = windows_sync_alignment::routes(routes);
routes = windows_system_nonstart::routes(routes);
}
routes = routes
.route("/auth/config", get(auth::configuration))
.route("/auth/oidc/login", get(auth::oidc_login))
.route("/auth/oidc/callback", get(auth::oidc_callback))
.route("/auth/session", get(auth::session))
.route("/auth/logout", post(auth::logout))
.route("/api/v1/job-signing-key", get(api::job_signing_key))
.route("/api/v1/tenants", get(api::tenants))
.route("/api/v1/tenants/{tenant}/devices", get(api::devices_page))
.route("/api/v1/tenants/{tenant}/devices/{asset}", get(api::device));
routes = jobs::routes(routes);
routes = script_library::routes(routes);
routes = controls::routes(routes);
routes = catalog::routes(routes);
routes = agent_updates::routes(routes);
routes = routes
.route("/api/v1/tenants/{tenant}/health", get(monitoring::health))
.route(
"/api/v1/tenants/{tenant}/log-queries",
post(monitoring::logs),
);
routes = routes.merge(mcp::routes(Router::new(), state.clone()));
let web = env::var("RMM_WEB_DIR").unwrap_or_else(|_| "web/dist".into());
if std::path::Path::new(&web).join("index.html").is_file() {
routes = routes
.route_service(
"/",
tower_http::services::ServeFile::new(format!("{web}/index.html")),
)
.nest_service(
"/assets",
tower_http::services::ServeDir::new(format!("{web}/assets")),
);
}
}
let app = routes
.layer(DefaultBodyLimit::max(rmm_domain::MAX_MESSAGE))
.layer(axum::middleware::map_response(errors::sanitize))
.layer(axum::middleware::from_fn(auth::context))
.with_state(state);
let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(tls::server_config(&dir)?));
let listener =
TcpListener::bind(env::var("RMM_LISTEN_ADDR").unwrap_or_else(|_| "0.0.0.0:18443".into()))
.await?;
let capacity = Arc::new(Semaphore::new(128));
eprintln!("TLS API/gateway listening; human browser authorization required for jobs");
loop {
let (tcp, _) = listener.accept().await?;
let Ok(permit) = capacity.clone().try_acquire_owned() else {
continue;
};
let acceptor = acceptor.clone();
let app = app.clone();
tokio::spawn(async move {
let _permit = permit;
let Ok(Ok(stream)) =
tokio::time::timeout(Duration::from_secs(5), acceptor.accept(tcp)).await
else {
return;
};
let leaf = stream
.get_ref()
.1
.peer_certificates()
.and_then(|chain| chain.first());
let expires = leaf
.and_then(|cert| openssl::x509::X509::from_der(cert.as_ref()).ok())
.and_then(|cert| {
chrono::NaiveDateTime::parse_from_str(
&cert.not_after().to_string(),
"%b %e %H:%M:%S %Y GMT",
)
.ok()
})
.map(|date| date.and_utc());
let peer = Peer(
leaf.map(|cert| hex::encode(Sha256::digest(cert.as_ref()))),
expires,
);
let service = TowerToHyperService::new(app.layer(Extension(peer)));
let _ = Builder::new(TokioExecutor::new())
.serve_connection_with_upgrades(TokioIo::new(stream), service)
.await;
});
}
}