Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
220 changes: 220 additions & 0 deletions crates/ressrf-core/tests/test_vectors.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2,13 +2,24 @@

use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::Arc;

use ressrf_core::audit::{AuditEvent, AuditSink, CollectingSink};
use ressrf_core::cidr::Cidr;
use ressrf_core::cloud::CloudProvider;
use ressrf_core::error::DataTier;
use ressrf_core::policy::{PolicyBuilder, Preset};
use ressrf_core::uri_validator::UriValidator;
use ressrf_core::url_rules::UrlRuleset;

struct ArcSink(Arc<CollectingSink>);

impl AuditSink for ArcSink {
fn emit(&self, event: &AuditEvent) {
self.0.emit(event);
}
}

fn vectors_dir() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.parent()
Expand Down Expand Up @@ -106,6 +117,18 @@ fn policy_decision_vectors() {
builder.add_allowed(&allows);
}

if let Some(cloud_arr) = case.get("cloud_providers").and_then(|v| v.as_array()) {
for provider_val in cloud_arr {
let name = provider_val.as_str().unwrap();
match name {
"aws" => builder.with_cloud(CloudProvider::Aws),
"azure" => builder.with_cloud(CloudProvider::Azure),
"gcp" => builder.with_cloud(CloudProvider::Gcp),
_ => panic!("Unknown cloud provider: {name}"),
};
}
}

let policy = builder.build();

let ips: Vec<IpAddr> = ip_strs
Expand Down Expand Up @@ -218,3 +241,200 @@ fn url_rules_vectors() {
}
}
}

fn parse_preset(s: &str) -> Preset {
match s {
"external_only" => Preset::ExternalOnly,
"internal_only" => Preset::InternalOnly,
"none" => Preset::None,
_ => panic!("Unknown preset: {s}"),
}
}

#[test]
fn audit_event_vectors() {
let path = vectors_dir().join("audit_events.json");
let content = std::fs::read_to_string(&path).unwrap();
let data: serde_json::Value = serde_json::from_str(&content).unwrap();

for case in data["test_cases"].as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let action = case["action"].as_str().unwrap();
let config = &case["config"];

match action {
"create_policy" => {
let preset_str = config["preset"].as_str().unwrap();
let preset = parse_preset(preset_str);
let sink = Arc::new(CollectingSink::new());

let has_sink = !config
.get("audit_sink")
.is_some_and(serde_json::Value::is_null);

if !has_sink {
let _policy = PolicyBuilder::new(preset).build();
// no_event_when_no_sink: nothing to assert, just verify no panic
continue;
}

let mut builder = PolicyBuilder::new(preset);
if let Some(cloud_arr) = config.get("cloud_modules").and_then(|v| v.as_array()) {
for provider_val in cloud_arr {
let pname = provider_val.as_str().unwrap();
match pname {
"aws" => builder.with_cloud(CloudProvider::Aws),
"azure" => builder.with_cloud(CloudProvider::Azure),
"gcp" => builder.with_cloud(CloudProvider::Gcp),
_ => panic!("{name}: unknown cloud provider: {pname}"),
};
}
}
builder.audit_sink(Box::new(ArcSink(Arc::clone(&sink))));
let _policy = builder.build();

let events = sink.events();
let expected = &case["expected_event"];
let variant = expected["variant"].as_str().unwrap();
assert_eq!(variant, "PolicyCreated", "{name}: expected PolicyCreated");
assert!(
!events.is_empty(),
"{name}: expected at least one audit event"
);

let created = events
.iter()
.find(|e| matches!(e, AuditEvent::PolicyCreated { .. }))
.unwrap_or_else(|| panic!("{name}: no PolicyCreated event found"));

if let AuditEvent::PolicyCreated {
preset: p,
deny_count,
allow_count,
..
} = created
{
let fields = &expected["fields"];
assert_eq!(
p,
fields["preset"].as_str().unwrap(),
"{name}: preset mismatch"
);
if let Some(min) = fields
.get("deny_count_min")
.and_then(serde_json::Value::as_u64)
{
assert!(
*deny_count >= usize::try_from(min).unwrap(),
"{name}: deny_count {deny_count} < min {min}"
);
}
assert_eq!(
*allow_count,
usize::try_from(fields["allow_count"].as_u64().unwrap()).unwrap(),
"{name}: allow_count mismatch"
);
}
}
// UrlValidated, HostValidated, ConnectionAttempt, and RedirectIntercepted
// events are not yet emitted by the core engine. These will be testable
// once P6a (Detection-Grade AuditEvent Fields) lands the emission code.
"validate_url" | "validate_host" | "connection_attempt" | "redirect_intercepted" => {}
_ => panic!("{name}: unknown action: {action}"),
}
}
}

#[test]
fn redirect_chain_vectors() {
let path = vectors_dir().join("redirect_chains.json");
let content = std::fs::read_to_string(&path).unwrap();
let data: serde_json::Value = serde_json::from_str(&content).unwrap();

for case in data["test_cases"].as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let chain: Vec<&str> = case["chain"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap())
.collect();
let preset = parse_preset(case["policy_preset"].as_str().unwrap());
let expected = case["expected"].as_str().unwrap();
let max_redirects = case
.get("max_redirects")
.and_then(serde_json::Value::as_u64);

let mut builder = PolicyBuilder::new(preset);

if let Some(allow_arr) = case.get("allow_cidrs").and_then(|v| v.as_array()) {
let allows: Vec<&str> = allow_arr.iter().map(|v| v.as_str().unwrap()).collect();
builder.add_allowed(&allows);
}

if case
.get("allow_plaintext_http")
.and_then(serde_json::Value::as_bool)
.unwrap_or(false)
{
builder.protocol_rules(ressrf_core::policy::ProtocolRules {
allow_plaintext_http: true,
require_https: false,
});
}

let policy = builder.build();
let validator = UriValidator::new();

let limit = max_redirects.map_or(usize::MAX, |m| usize::try_from(m).unwrap());
let mut blocked_at: Option<usize> = None;

// Hop 0 is the origin URL; redirect targets start at hop 1.
for (i, url) in chain.iter().enumerate().skip(1) {
if i >= limit {
blocked_at = Some(i);
break;
}

// Check scheme via protocol rules (plaintext HTTP, require_https).
let scheme_blocked = url
.find("://")
.map(|pos| &url[..pos])
.is_some_and(|scheme| policy.validate_scheme(scheme).is_err());

if scheme_blocked || validator.validate_url(url, Some(&policy)).is_err() {
blocked_at = Some(i);
break;
}
}

match expected {
"allowed" => {
assert!(
blocked_at.is_none(),
"{name}: expected allowed, but blocked at hop {}",
blocked_at.unwrap_or(0)
);
}
"blocked" => {
let expected_hop = case
.get("blocked_at_hop")
.and_then(serde_json::Value::as_u64)
.map(|h| usize::try_from(h).unwrap());
assert!(
blocked_at.is_some(),
"{name}: expected blocked, got allowed"
);
if let Some(eh) = expected_hop {
assert_eq!(
blocked_at.unwrap(),
eh,
"{name}: expected blocked at hop {eh}, got {}",
blocked_at.unwrap()
);
}
}
_ => panic!("{name}: unknown expected: {expected}"),
}
}
}
Loading
Loading