263 lines
9.1 KiB
Rust
263 lines
9.1 KiB
Rust
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_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 = 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;
|
|
});
|
|
}
|
|
}
|