225 lines
7.9 KiB
Rust
225 lines
7.9 KiB
Rust
use axum::{
|
|
Extension, Json,
|
|
body::Bytes,
|
|
extract::State,
|
|
http::{HeaderMap, StatusCode},
|
|
response::{IntoResponse, Response},
|
|
};
|
|
use prost::Message;
|
|
use rmm_protocol::*;
|
|
use serde::Deserialize;
|
|
use uuid::Uuid;
|
|
pub(crate) async fn identity(
|
|
s: &crate::State,
|
|
peer: crate::Peer,
|
|
) -> Result<(Uuid, Uuid), StatusCode> {
|
|
if !peer.1.is_some_and(|expires| expires > chrono::Utc::now()) {
|
|
return Err(StatusCode::UNAUTHORIZED);
|
|
}
|
|
let f = peer.0.ok_or(StatusCode::UNAUTHORIZED)?;
|
|
crate::agent_service::binding(s, &f)
|
|
.await
|
|
.map_err(|_| StatusCode::UNAUTHORIZED)
|
|
}
|
|
fn content_type(h: &HeaderMap) -> Result<(), StatusCode> {
|
|
if h.get("content-type").and_then(|v| v.to_str().ok()) != Some("application/x-protobuf") {
|
|
return Err(StatusCode::UNSUPPORTED_MEDIA_TYPE);
|
|
}
|
|
Ok(())
|
|
}
|
|
fn response(messages: Vec<Envelope>) -> Response {
|
|
(
|
|
[("content-type", "application/x-protobuf")],
|
|
MessageBatch {
|
|
protocol_major: 1,
|
|
messages,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.into_response()
|
|
}
|
|
async fn append_work(
|
|
s: &crate::State,
|
|
tenant: Uuid,
|
|
agent: Uuid,
|
|
source: &Envelope,
|
|
payload: Payload,
|
|
generation: u64,
|
|
replies: &mut Vec<Envelope>,
|
|
) -> anyhow::Result<()> {
|
|
let reply = crate::agent_service::reply(source, payload, generation);
|
|
// Preserve the protocol's 16-envelope response limit. An offer that cannot
|
|
// fit twice is delivered normally without consuming the optional fault.
|
|
let claim = if replies.len() <= 14 {
|
|
crate::gateway::dev_delivery_faults::duplicate_offer(
|
|
&s.pool, tenant, agent, &reply, "https",
|
|
)
|
|
.await?
|
|
} else {
|
|
None
|
|
};
|
|
if claim.is_some() {
|
|
replies.push(reply.clone());
|
|
}
|
|
replies.push(reply);
|
|
if let Some(claim) = claim {
|
|
crate::gateway::dev_delivery_faults::duplicate_emitted(&s.pool, claim).await?;
|
|
}
|
|
Ok(())
|
|
}
|
|
pub async fn messages(
|
|
State(s): State<crate::State>,
|
|
Extension(peer): Extension<crate::Peer>,
|
|
h: HeaderMap,
|
|
bytes: Bytes,
|
|
) -> Result<Response, StatusCode> {
|
|
let (t, a) = identity(&s, peer).await?;
|
|
content_type(&h)?;
|
|
let b = MessageBatch::decode(bytes).map_err(|_| StatusCode::BAD_REQUEST)?;
|
|
if b.protocol_major != 1 || b.messages.is_empty() || b.messages.len() > 16 {
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
if b.messages
|
|
.iter()
|
|
.any(|e| matches!(e.payload, Some(Payload::ClientHello(_))))
|
|
&& b.messages.len() != 1
|
|
{
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
let mut replies = Vec::new();
|
|
if b.messages.len() > 1
|
|
&& b.messages.iter().any(|e| {
|
|
!matches!(
|
|
e.payload,
|
|
Some(
|
|
Payload::InventorySnapshot(_)
|
|
| Payload::JobAccepted(_)
|
|
| Payload::JobStateChanged(_)
|
|
| Payload::JobResult(_)
|
|
)
|
|
)
|
|
})
|
|
{
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
let last = b.messages.last().cloned().ok_or(StatusCode::BAD_REQUEST)?;
|
|
let mut generation = 0;
|
|
for e in b.messages {
|
|
let reply = if matches!(e.payload, Some(Payload::ClientHello(_))) {
|
|
crate::agent_service::open(&s, t, a, &e, "https").await
|
|
} else {
|
|
crate::agent_service::ingest(&s, t, a, &e, "https").await
|
|
}
|
|
.map_err(|_| StatusCode::CONFLICT)?;
|
|
generation = reply.connection_generation;
|
|
if !crate::gateway::dev_delivery_faults::after_ingest(&s.pool, t, a, &e, &reply, "https")
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?
|
|
{
|
|
replies.push(reply);
|
|
}
|
|
}
|
|
if replies.len() < 16
|
|
&& let Some(work) = crate::job_gateway::next(&s, t, a, generation)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?
|
|
{
|
|
append_work(&s, t, a, &last, work, generation, &mut replies)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
}
|
|
Ok(response(replies))
|
|
}
|
|
pub async fn poll(
|
|
State(s): State<crate::State>,
|
|
Extension(peer): Extension<crate::Peer>,
|
|
h: HeaderMap,
|
|
bytes: Bytes,
|
|
) -> Result<Response, StatusCode> {
|
|
let (t, a) = identity(&s, peer).await?;
|
|
content_type(&h)?;
|
|
let p = PollRequest::decode(bytes).map_err(|_| StatusCode::BAD_REQUEST)?;
|
|
if p.wait_seconds > 25 {
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
let e = p.envelope.ok_or(StatusCode::BAD_REQUEST)?;
|
|
if !matches!(e.payload, Some(Payload::Heartbeat(_))) {
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
let ack = crate::agent_service::ingest(&s, t, a, &e, "https")
|
|
.await
|
|
.map_err(|_| StatusCode::CONFLICT)?;
|
|
let deadline =
|
|
tokio::time::Instant::now() + std::time::Duration::from_secs(u64::from(p.wait_seconds));
|
|
loop {
|
|
if let Some(work) = crate::job_gateway::next(&s, t, a, e.connection_generation)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?
|
|
{
|
|
let mut replies = vec![ack];
|
|
append_work(&s, t, a, &e, work, e.connection_generation, &mut replies)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
return Ok(response(replies));
|
|
}
|
|
if tokio::time::Instant::now() >= deadline {
|
|
return Ok(response(vec![ack]));
|
|
}
|
|
tokio::time::sleep(std::time::Duration::from_millis(250)).await;
|
|
}
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Renewal {
|
|
csr_pem: String,
|
|
}
|
|
pub async fn renew(
|
|
State(s): State<crate::State>,
|
|
Extension(peer): Extension<crate::Peer>,
|
|
Json(input): Json<Renewal>,
|
|
) -> Result<Json<serde_json::Value>, StatusCode> {
|
|
if input.csr_pem.len() > 8192 {
|
|
return Err(StatusCode::BAD_REQUEST);
|
|
}
|
|
let fingerprint = peer.0.clone().ok_or(StatusCode::UNAUTHORIZED)?;
|
|
let (t, a) = identity(&s, peer).await?;
|
|
let mut tx = rmm_persistence::tenant_tx(&s.pool, t)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
let row=sqlx::query("SELECT certificate_sha256,renewal_csr_sha256,certificate_pem FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL FOR UPDATE").bind(a).fetch_optional(&mut *tx).await.map_err(|_|StatusCode::SERVICE_UNAVAILABLE)?.ok_or(StatusCode::UNAUTHORIZED)?;
|
|
use sqlx::Row;
|
|
let csr_hash = rmm_domain::jobs::hash(input.csr_pem.as_bytes());
|
|
if row
|
|
.get::<Option<String>, _>("renewal_csr_sha256")
|
|
.as_deref()
|
|
== Some(&csr_hash)
|
|
{
|
|
return Ok(Json(
|
|
serde_json::json!({"agent_id":a,"certificate_pem":row.get::<Option<String>,_>("certificate_pem"),"overlap_seconds":300}),
|
|
));
|
|
}
|
|
if row.get::<String, _>("certificate_sha256") != fingerprint {
|
|
return Err(StatusCode::CONFLICT);
|
|
}
|
|
let certificate =
|
|
crate::tls::issue(&s, &input.csr_pem, a).map_err(|_| StatusCode::BAD_REQUEST)?;
|
|
let hash = rmm_domain::jobs::hash(
|
|
&certificate
|
|
.to_der()
|
|
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?,
|
|
);
|
|
let pem = String::from_utf8(
|
|
certificate
|
|
.to_pem()
|
|
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?,
|
|
)
|
|
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
|
|
sqlx::query("UPDATE agent_installations SET previous_certificate_sha256=certificate_sha256,previous_certificate_until=now()+interval '5 minutes',certificate_sha256=$2,certificate_pem=$3,renewal_csr_sha256=$4,connection_generation=connection_generation+1 WHERE agent_id=$1").bind(a).bind(hash).bind(&pem).bind(csr_hash).execute(&mut *tx).await.map_err(|_|StatusCode::SERVICE_UNAVAILABLE)?;
|
|
tx.commit()
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
Ok(Json(
|
|
serde_json::json!({"agent_id":a,"certificate_pem":pem,"overlap_seconds":300}),
|
|
))
|
|
}
|