rullst-security 12.3.0

Runtime application security, RASP, OWASP headers, Login Jail, and WAF middleware for Rullst.
Documentation
use super::*;
use std::io::{Read, Seek, SeekFrom, Write};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};

fn temporary_spool(label: &str) -> PathBuf {
    let nonce = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock should follow epoch")
        .as_nanos();
    std::env::temp_dir().join(format!(
        "rullst-security-siem-{label}-{}-{nonce}.spool",
        std::process::id()
    ))
}

#[test]
fn restart_replays_exact_normalized_unsigned_events() {
    let path = temporary_spool("restart");
    let first_offset;
    {
        let spool = DurableSiemSpool::try_open(&path).expect("create spool");
        let mut event = LiveSecurityEvent::local("RBAC_DENIAL", "denied", "192.0.2.1");
        event.verified_hmac = true;
        let receipt = spool.append_local(event).expect("append first event");
        assert_eq!(receipt.sequence(), 1);
        first_offset = receipt.end_offset();
        let second = spool
            .append_local(LiveSecurityEvent::local(
                "RASP_PAYLOAD_INTERCEPTED",
                "body=true",
                "invalid-ip",
            ))
            .expect("append second event");
        assert_eq!(second.sequence(), 2);
        assert!(second.end_offset() > first_offset);
    }

    let reopened = DurableSiemSpool::try_open(&path).expect("reopen valid spool");
    let events = reopened.read_local().expect("read valid events");
    assert_eq!(events.len(), 2);
    assert_eq!(events[0].event_type, "RBAC_DENIAL");
    assert!(!events[0].verified_hmac);
    assert_eq!(events[1].client_ip, "unknown");
    assert_eq!(reopened.snapshot().expect("snapshot").records(), 2);
    std::fs::remove_file(path).expect("remove test spool");
}

#[test]
fn quota_rejection_preserves_the_previous_file() {
    let path = temporary_spool("quota");
    let spool =
        DurableSiemSpool::try_open_with_max_bytes(&path, 1_024).expect("create bounded spool");
    spool
        .append_local(LiveSecurityEvent::local(
            "SECURITY_EVENT",
            "x".repeat(600),
            "192.0.2.2",
        ))
        .expect("first event fits");
    let before = spool.snapshot().expect("snapshot before rejection");
    assert_eq!(
        spool.append_local(LiveSecurityEvent::local(
            "SECURITY_EVENT",
            "y".repeat(600),
            "192.0.2.3",
        )),
        Err(SiemSpoolError::CapacityExceeded)
    );
    assert_eq!(spool.snapshot().expect("snapshot after rejection"), before);
    assert_eq!(spool.read_local().expect("read original").len(), 1);
    std::fs::remove_file(path).expect("remove test spool");
}

#[test]
fn corruption_and_external_changes_fail_closed() {
    let path = temporary_spool("corrupt");
    let spool = DurableSiemSpool::try_open(&path).expect("create spool");
    spool
        .append_local(LiveSecurityEvent::local(
            "SECURITY_EVENT",
            "original",
            "192.0.2.4",
        ))
        .expect("append event");
    let mut external = OpenOptions::new()
        .append(true)
        .open(&path)
        .expect("open spool externally");
    external.write_all(b"broken\n").expect("append corruption");
    external.sync_data().expect("sync corruption");
    assert_eq!(
        spool.read_local(),
        Err(SiemSpoolError::ExternalModification)
    );
    drop(spool);

    assert!(matches!(
        DurableSiemSpool::try_open(&path),
        Err(SiemSpoolError::CorruptRecord { record: 2, .. })
    ));
    std::fs::remove_file(path).expect("remove test spool");
}

#[test]
fn same_length_payload_tampering_is_detected_on_restart() {
    let path = temporary_spool("digest");
    {
        let spool = DurableSiemSpool::try_open(&path).expect("create spool");
        spool
            .append_local(LiveSecurityEvent::local(
                "SECURITY_EVENT",
                "original",
                "192.0.2.5",
            ))
            .expect("append event");
    }

    let mut file = OpenOptions::new()
        .read(true)
        .write(true)
        .open(&path)
        .expect("open spool for tampering");
    let mut bytes = Vec::new();
    file.read_to_end(&mut bytes).expect("read spool");
    let position = bytes
        .windows(b"original".len())
        .position(|window| window == b"original")
        .expect("fixture payload should exist");
    bytes[position] = b'O';
    file.seek(SeekFrom::Start(0)).expect("seek spool");
    file.write_all(&bytes).expect("rewrite same-length spool");
    file.sync_data().expect("sync tampering");
    drop(file);

    assert!(matches!(
        DurableSiemSpool::try_open(&path),
        Err(SiemSpoolError::CorruptRecord {
            record: 1,
            reason: "digest mismatch"
        })
    ));
    std::fs::remove_file(path).expect("remove test spool");
}

#[test]
fn concurrent_in_process_appends_are_serialized() {
    let path = temporary_spool("concurrency");
    let spool = Arc::new(DurableSiemSpool::try_open(&path).expect("create spool"));
    let handles = (0..32)
        .map(|index| {
            let spool = Arc::clone(&spool);
            std::thread::spawn(move || {
                spool
                    .append_local(LiveSecurityEvent::local(
                        "SECURITY_EVENT",
                        format!("event-{index}"),
                        "192.0.2.6",
                    ))
                    .expect("concurrent append")
                    .sequence()
            })
        })
        .collect::<Vec<_>>();
    let mut sequences = handles
        .into_iter()
        .map(|handle| handle.join().expect("append thread"))
        .collect::<Vec<_>>();
    sequences.sort_unstable();
    assert_eq!(sequences, (1..=32).collect::<Vec<_>>());
    assert_eq!(spool.read_local().expect("read events").len(), 32);
    assert_eq!(spool.snapshot().expect("snapshot").records(), 32);
    drop(spool);
    std::fs::remove_file(path).expect("remove test spool");
}

#[cfg(unix)]
#[test]
fn symlink_targets_are_rejected() {
    use std::os::unix::fs::symlink;

    let target = temporary_spool("target");
    let link = temporary_spool("link");
    File::create(&target).expect("create target");
    symlink(&target, &link).expect("create symlink");
    assert!(matches!(
        DurableSiemSpool::try_open(&link),
        Err(SiemSpoolError::UnsafeFileType)
    ));
    std::fs::remove_file(link).expect("remove link");
    std::fs::remove_file(target).expect("remove target");
}