mod agent_artifacts; mod agent_http; mod agent_service; 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 synchronization; mod tls; 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, viewer_a: [u8; 32], viewer_b: [u8; 32], auth: Arc, job_signer: Arc, } #[derive(Clone)] pub struct Peer( pub Option, pub Option>, ); 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 = 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), ) .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 = 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 = controls::routes(routes); routes = catalog::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; }); } }