247 lines
8.9 KiB
Rust
247 lines
8.9 KiB
Rust
//! Development-only, exact-device WSS handshake rejection after normal mTLS
|
|
//! binding. HTTPS and every execution/approval path remain untouched.
|
|
use anyhow::{Context, Result, ensure};
|
|
use chrono::{DateTime, Duration, Utc};
|
|
use rmm_domain::jobs::hash;
|
|
use serde::Deserialize;
|
|
use serde_json::{Value, json};
|
|
use sqlx::PgPool;
|
|
use std::{fs, os::unix::fs::MetadataExt, path::PathBuf};
|
|
use uuid::Uuid;
|
|
|
|
#[derive(Clone, Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct Config {
|
|
schema_version: u32,
|
|
fault_id: Uuid,
|
|
tenant_id: Uuid,
|
|
agent_id: Uuid,
|
|
issued_at: DateTime<Utc>,
|
|
expires_at: DateTime<Utc>,
|
|
}
|
|
impl Config {
|
|
fn validate(&self) -> Result<()> {
|
|
ensure!(
|
|
self.schema_version == 1
|
|
&& !self.fault_id.is_nil()
|
|
&& !self.tenant_id.is_nil()
|
|
&& !self.agent_id.is_nil()
|
|
&& self.issued_at.timestamp() > 0
|
|
&& self.expires_at > self.issued_at
|
|
&& self.expires_at - self.issued_at <= Duration::minutes(15),
|
|
"DEV_TRANSPORT_FAULT_CONFIG"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn active(&self, tenant: Uuid, agent: Uuid, now: DateTime<Utc>) -> bool {
|
|
self.tenant_id == tenant
|
|
&& self.agent_id == agent
|
|
&& now >= self.issued_at
|
|
&& now < self.expires_at
|
|
}
|
|
}
|
|
fn configured_path(
|
|
flag: Option<&str>,
|
|
path: Option<&str>,
|
|
profile: &str,
|
|
dev: &str,
|
|
) -> Result<Option<PathBuf>> {
|
|
match (flag, path) {
|
|
(None | Some("false"), None) => Ok(None),
|
|
(Some("true"), Some("/root-policy/transport-fault.json")) => {
|
|
ensure!(
|
|
profile == "development" && dev == "true",
|
|
"DEV_TRANSPORT_FAULT_PROFILE"
|
|
);
|
|
Ok(Some(PathBuf::from("/root-policy/transport-fault.json")))
|
|
}
|
|
_ => anyhow::bail!("DEV_TRANSPORT_FAULT_EXPLICIT_OPT_IN"),
|
|
}
|
|
}
|
|
fn load() -> Result<Option<(Config, String)>> {
|
|
let flag = std::env::var("RMM_DEV_TRANSPORT_FAULTS").ok();
|
|
let path = std::env::var("RMM_DEV_TRANSPORT_FAULT_FILE").ok();
|
|
let profile = std::env::var("RMM_PROFILE").unwrap_or_default();
|
|
let dev = std::env::var("RMM_DEV_AUTH").unwrap_or_default();
|
|
let Some(path) = configured_path(flag.as_deref(), path.as_deref(), &profile, &dev)? else {
|
|
return Ok(None);
|
|
};
|
|
let directory = fs::symlink_metadata(path.parent().context("DEV_TRANSPORT_FAULT_PARENT")?)?;
|
|
let metadata = fs::symlink_metadata(&path)?;
|
|
ensure!(
|
|
directory.is_dir()
|
|
&& directory.uid() == 10001
|
|
&& directory.mode() & 0o777 == 0o700
|
|
&& metadata.is_file()
|
|
&& metadata.uid() == 10001
|
|
&& metadata.mode() & 0o777 == 0o600
|
|
&& metadata.nlink() == 1
|
|
&& metadata.len() <= 4096,
|
|
"DEV_TRANSPORT_FAULT_PRIVATE_CONFIG"
|
|
);
|
|
let raw = fs::read(path)?;
|
|
ensure!(raw.len() <= 4096, "DEV_TRANSPORT_FAULT_CONFIG_SIZE");
|
|
let config: Config = serde_json::from_slice(&raw)?;
|
|
config.validate()?;
|
|
Ok(Some((config, hash(&raw))))
|
|
}
|
|
pub(crate) fn validate_environment() -> Result<()> {
|
|
load().map(|_| ())
|
|
}
|
|
fn slot_id(fault: Uuid, slot: u8) -> Uuid {
|
|
use sha2::{Digest, Sha256};
|
|
let digest = Sha256::digest(format!("rmm.dev-transport-fault.v1:{fault}:{slot}"));
|
|
Uuid::from_slice(&digest[..16]).expect("fixed digest prefix")
|
|
}
|
|
fn same_configuration(value: &Value, sha256: &str) -> Result<()> {
|
|
ensure!(
|
|
value.get("config_sha256") == Some(&json!(sha256)),
|
|
"DEV_TRANSPORT_FAULT_ID_REUSED"
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
/// Caller has already checked certificate expiry and authoritative device_binding.
|
|
/// No upgrade/ClientHello/JobOffer occurs on this path. At most two narrow durable
|
|
/// observations are inserted; every matching WSS request stays denied until expiry.
|
|
pub(crate) async fn reject_wss(
|
|
pool: &PgPool,
|
|
tenant: Uuid,
|
|
agent: Uuid,
|
|
certificate_sha256: &str,
|
|
) -> Result<bool> {
|
|
let Some((config, sha256)) = load()? else {
|
|
return Ok(false);
|
|
};
|
|
if !config.active(tenant, agent, Utc::now()) {
|
|
return Ok(false);
|
|
}
|
|
ensure!(
|
|
certificate_sha256.len() == 64
|
|
&& certificate_sha256
|
|
.bytes()
|
|
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)),
|
|
"DEV_TRANSPORT_FAULT_PEER_FINGERPRINT"
|
|
);
|
|
let mut tx = rmm_persistence::tenant_tx(pool, tenant).await?;
|
|
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,0))")
|
|
.bind(format!("dev-transport-fault:{}", config.fault_id))
|
|
.execute(&mut *tx)
|
|
.await?;
|
|
for slot in 1..=2 {
|
|
let id = slot_id(config.fault_id, slot);
|
|
let existing: Option<Value> = sqlx::query_scalar(
|
|
"SELECT data FROM audit_events WHERE event_id=$1 AND principal='dev_transport_fault_adapter'",
|
|
)
|
|
.bind(id)
|
|
.fetch_optional(&mut *tx)
|
|
.await?;
|
|
if let Some(value) = existing {
|
|
same_configuration(&value, &sha256)?;
|
|
} else {
|
|
let value = json!({"schema_version":1,"testsimulation":true,"noProductionEvidence":true,
|
|
"fault_id":config.fault_id,"agent_id":agent,"tenant_id":tenant,"slot":slot,
|
|
"config_sha256":sha256,"certificate_sha256":certificate_sha256,
|
|
"handshake_id":Uuid::new_v4(),"status":503,
|
|
"detail":"authenticated_mtls_device_wss_rejected_before_upgrade"});
|
|
sqlx::query("INSERT INTO audit_events(tenant_id,event_id,principal,event_type,data) VALUES($1,$2,'dev_transport_fault_adapter','dev_transport_fault.wss_rejected',$3) ON CONFLICT(tenant_id,event_id) DO NOTHING")
|
|
.bind(tenant).bind(id).bind(value).execute(&mut *tx).await?;
|
|
break;
|
|
}
|
|
}
|
|
tx.commit().await?;
|
|
Ok(true)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn opt_in_is_explicit_and_production_activation_is_rejected() {
|
|
assert!(
|
|
configured_path(None, None, "production", "false")
|
|
.unwrap()
|
|
.is_none()
|
|
);
|
|
assert!(
|
|
configured_path(Some("false"), None, "production", "false")
|
|
.unwrap()
|
|
.is_none()
|
|
);
|
|
for (flag, path, profile, dev) in [
|
|
(
|
|
Some("true"),
|
|
Some("/root-policy/transport-fault.json"),
|
|
"production",
|
|
"true",
|
|
),
|
|
(
|
|
Some("true"),
|
|
Some("/root-policy/transport-fault.json"),
|
|
"development",
|
|
"false",
|
|
),
|
|
(
|
|
Some("false"),
|
|
Some("/root-policy/transport-fault.json"),
|
|
"development",
|
|
"true",
|
|
),
|
|
(Some("true"), None, "development", "true"),
|
|
(Some("true"), Some("/etc/passwd"), "development", "true"),
|
|
] {
|
|
assert!(configured_path(flag, path, profile, dev).is_err());
|
|
}
|
|
assert!(
|
|
configured_path(
|
|
Some("true"),
|
|
Some("/root-policy/transport-fault.json"),
|
|
"development",
|
|
"true"
|
|
)
|
|
.unwrap()
|
|
.is_some()
|
|
);
|
|
}
|
|
#[test]
|
|
fn exact_scope_and_bounded_window_never_affect_another_device() {
|
|
let now = Utc::now();
|
|
let mut config = Config {
|
|
schema_version: 1,
|
|
fault_id: Uuid::new_v4(),
|
|
tenant_id: Uuid::new_v4(),
|
|
agent_id: Uuid::new_v4(),
|
|
issued_at: now,
|
|
expires_at: now + Duration::minutes(15),
|
|
};
|
|
config.validate().unwrap();
|
|
assert!(config.active(config.tenant_id, config.agent_id, now));
|
|
assert!(!config.active(Uuid::new_v4(), config.agent_id, now));
|
|
assert!(!config.active(config.tenant_id, Uuid::new_v4(), now));
|
|
assert!(!config.active(
|
|
config.tenant_id,
|
|
config.agent_id,
|
|
now - Duration::seconds(1)
|
|
));
|
|
assert!(!config.active(config.tenant_id, config.agent_id, config.expires_at));
|
|
config.expires_at += Duration::milliseconds(1);
|
|
assert!(config.validate().is_err());
|
|
config.expires_at = now;
|
|
assert!(config.validate().is_err());
|
|
config.expires_at = now + Duration::minutes(1);
|
|
config.agent_id = Uuid::nil();
|
|
assert!(config.validate().is_err());
|
|
}
|
|
#[test]
|
|
fn slots_are_bounded_stable_and_cannot_change_configuration() {
|
|
let fault = Uuid::new_v4();
|
|
assert_eq!(slot_id(fault, 1), slot_id(fault, 1));
|
|
assert_ne!(slot_id(fault, 1), slot_id(fault, 2));
|
|
assert_ne!(slot_id(fault, 1), slot_id(Uuid::new_v4(), 1));
|
|
let value = json!({"config_sha256":"a".repeat(64)});
|
|
same_configuration(&value, &"a".repeat(64)).unwrap();
|
|
assert!(same_configuration(&value, &"b".repeat(64)).is_err());
|
|
assert!(same_configuration(&json!({}), &"a".repeat(64)).is_err());
|
|
}
|
|
}
|