Skip to content
Python
5.0 KB
Raw Blame
//! Opt-in SIEM delivery, separate from agent work and observer callbacks.
use anyhow::{ensure, Result};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Sink {
    pub name: String,
    pub endpoint: String,
    pub credential_env: String,
    #[serde(default)]
    pub allow_loopback_http: bool,
}
impl Sink {
    pub fn validate(&self) -> Result<()> {
        ensure!(
            crate::compliance::identifier(&self.name) && self.name.len() <= 80,
            "Invalid SIEM sink name"
        );
        ensure!(
            !self.credential_env.is_empty()
                && self.credential_env.len() <= 128
                && self
                    .credential_env
                    .bytes()
                    .all(|c| c.is_ascii_alphanumeric() || c == b'_'),
            "Invalid SIEM credential reference"
        );
        let url = reqwest::Url::parse(&self.endpoint)
            .map_err(|_| anyhow::anyhow!("Invalid SIEM endpoint"))?;
        ensure!(
            url.username().is_empty()
                && url.password().is_none()
                && url.query().is_none()
                && url.fragment().is_none(),
            "Invalid SIEM endpoint"
        );
        let local = url
            .host_str()
            .is_some_and(|v| matches!(v, "127.0.0.1" | "[::1]"));
        ensure!(
            url.scheme() == "https"
                || (self.allow_loopback_http && local && url.scheme() == "http"),
            "SIEM requires HTTPS (or explicit loopback fixture)"
        );
        Ok(())
    }
    pub fn binding(&self) -> Result<String> {
        self.validate()?;
        Ok(crate::bundle::digest(&serde_json::to_vec(self)?))
    }
}
#[cfg(feature = "compliance-export")]
pub fn start(
    store: crate::store::SharedStore,
    sinks: Vec<Sink>,
    stop: tokio_util::sync::CancellationToken,
) -> Result<()> {
    use serde_json::json;
    use std::time::Duration;
    ensure!(sinks.len() <= 16, "Too many SIEM sinks");
    let mut names = std::collections::BTreeSet::new();
    for sink in &sinks {
        sink.validate()?;
        ensure!(names.insert(&sink.name), "Duplicate SIEM sink name");
    }
    if sinks.is_empty() {
        return Ok(());
    }
    let client = reqwest::Client::builder()
        .redirect(reqwest::redirect::Policy::none())
        .no_proxy()
        .timeout(Duration::from_secs(20))
        .build()?;
    tokio::spawn(async move {
        let mut after = String::new();
        loop {
            if stop.is_cancelled() {
                break;
            }
            let sessions = store
                .lock()
                .unwrap()
                .compliance_sessions(&after)
                .unwrap_or_default();
            if sessions.len() < 100 {
                after.clear()
            } else if let Some(s) = sessions.last() {
                after = s.id.clone()
            }
            for s in sessions.into_iter().filter(|s| s.compliance.is_some()) {
                for sink in &sinks {
                    let token = crate::id("export");
                    let binding = sink.binding().expect("validated sink");
                    let batch = store
                        .lock()
                        .unwrap()
                        .claim_compliance_export(&s.id, &sink.name, &binding, &token);
                    let Ok(Some(batch)) = batch else { continue };
                    let secret = std::env::var(&sink.credential_env)
                        .ok()
                        .filter(|k| !k.is_empty() && k.len() <= 8192)
                        .map(zeroize::Zeroizing::new);
                    let success = if let Some(secret) = secret {
                        // Stable per-event IDs survive batches, retries and worker
                        // takeover. Receiver acknowledgement is only HTTP success;
                        // a lost acknowledgement retries delivery, never execution.
                        let request=client.post(&sink.endpoint).bearer_auth(secret.as_str()).json(&json!({"schemaVersion":1,"sink":sink.name,"sessionId":s.id,"activities":batch.activities})).send();
                        tokio::select! {_=stop.cancelled()=>return,result=request=>result.is_ok_and(|r|r.status().is_success())}
                    } else {
                        false
                    };
                    let _ = store
                        .lock()
                        .unwrap()
                        .settle_compliance_export(&s.id, &sink.name, &token, success);
                }
            }
            tokio::select! {_=stop.cancelled()=>break,_=tokio::time::sleep(Duration::from_secs(1))=>{}}
        }
    });
    Ok(())
}
#[cfg(not(feature = "compliance-export"))]
pub fn start(
    _store: crate::store::SharedStore,
    sinks: Vec<Sink>,
    _stop: tokio_util::sync::CancellationToken,
) -> Result<()> {
    ensure!(
        sinks.is_empty(),
        "Compliance exporter not included in this build"
    );
    Ok(())
}