feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,232 @@
|
||||
mod agent_artifacts;
|
||||
mod agent_http;
|
||||
mod agent_service;
|
||||
mod api;
|
||||
mod artifact_store;
|
||||
mod auth;
|
||||
mod catalog;
|
||||
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;
|
||||
|
||||
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();
|
||||
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 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() {
|
||||
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;
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user