Skip to content

Commit 71a1b57

Browse files
authored
Merge pull request #18 from timescale/feat/cross-language-conformance
2 parents 823bd62 + 039a5b7 commit 71a1b57

7 files changed

Lines changed: 830 additions & 16 deletions

File tree

‎crates/ressrf-core/tests/test_vectors.rs‎

Lines changed: 220 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,24 @@
22
33
use std::net::IpAddr;
44
use std::path::PathBuf;
5+
use std::sync::Arc;
56

7+
use ressrf_core::audit::{AuditEvent, AuditSink, CollectingSink};
68
use ressrf_core::cidr::Cidr;
9+
use ressrf_core::cloud::CloudProvider;
710
use ressrf_core::error::DataTier;
811
use ressrf_core::policy::{PolicyBuilder, Preset};
912
use ressrf_core::uri_validator::UriValidator;
1013
use ressrf_core::url_rules::UrlRuleset;
1114

15+
struct ArcSink(Arc<CollectingSink>);
16+
17+
impl AuditSink for ArcSink {
18+
fn emit(&self, event: &AuditEvent) {
19+
self.0.emit(event);
20+
}
21+
}
22+
1223
fn vectors_dir() -> PathBuf {
1324
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
1425
.parent()
@@ -106,6 +117,18 @@ fn policy_decision_vectors() {
106117
builder.add_allowed(&allows);
107118
}
108119

120+
if let Some(cloud_arr) = case.get("cloud_providers").and_then(|v| v.as_array()) {
121+
for provider_val in cloud_arr {
122+
let name = provider_val.as_str().unwrap();
123+
match name {
124+
"aws" => builder.with_cloud(CloudProvider::Aws),
125+
"azure" => builder.with_cloud(CloudProvider::Azure),
126+
"gcp" => builder.with_cloud(CloudProvider::Gcp),
127+
_ => panic!("Unknown cloud provider: {name}"),
128+
};
129+
}
130+
}
131+
109132
let policy = builder.build();
110133

111134
let ips: Vec<IpAddr> = ip_strs
@@ -218,3 +241,200 @@ fn url_rules_vectors() {
218241
}
219242
}
220243
}
244+
245+
fn parse_preset(s: &str) -> Preset {
246+
match s {
247+
"external_only" => Preset::ExternalOnly,
248+
"internal_only" => Preset::InternalOnly,
249+
"none" => Preset::None,
250+
_ => panic!("Unknown preset: {s}"),
251+
}
252+
}
253+
254+
#[test]
255+
fn audit_event_vectors() {
256+
let path = vectors_dir().join("audit_events.json");
257+
let content = std::fs::read_to_string(&path).unwrap();
258+
let data: serde_json::Value = serde_json::from_str(&content).unwrap();
259+
260+
for case in data["test_cases"].as_array().unwrap() {
261+
let name = case["name"].as_str().unwrap();
262+
let action = case["action"].as_str().unwrap();
263+
let config = &case["config"];
264+
265+
match action {
266+
"create_policy" => {
267+
let preset_str = config["preset"].as_str().unwrap();
268+
let preset = parse_preset(preset_str);
269+
let sink = Arc::new(CollectingSink::new());
270+
271+
let has_sink = !config
272+
.get("audit_sink")
273+
.is_some_and(serde_json::Value::is_null);
274+
275+
if !has_sink {
276+
let _policy = PolicyBuilder::new(preset).build();
277+
// no_event_when_no_sink: nothing to assert, just verify no panic
278+
continue;
279+
}
280+
281+
let mut builder = PolicyBuilder::new(preset);
282+
if let Some(cloud_arr) = config.get("cloud_modules").and_then(|v| v.as_array()) {
283+
for provider_val in cloud_arr {
284+
let pname = provider_val.as_str().unwrap();
285+
match pname {
286+
"aws" => builder.with_cloud(CloudProvider::Aws),
287+
"azure" => builder.with_cloud(CloudProvider::Azure),
288+
"gcp" => builder.with_cloud(CloudProvider::Gcp),
289+
_ => panic!("{name}: unknown cloud provider: {pname}"),
290+
};
291+
}
292+
}
293+
builder.audit_sink(Box::new(ArcSink(Arc::clone(&sink))));
294+
let _policy = builder.build();
295+
296+
let events = sink.events();
297+
let expected = &case["expected_event"];
298+
let variant = expected["variant"].as_str().unwrap();
299+
assert_eq!(variant, "PolicyCreated", "{name}: expected PolicyCreated");
300+
assert!(
301+
!events.is_empty(),
302+
"{name}: expected at least one audit event"
303+
);
304+
305+
let created = events
306+
.iter()
307+
.find(|e| matches!(e, AuditEvent::PolicyCreated { .. }))
308+
.unwrap_or_else(|| panic!("{name}: no PolicyCreated event found"));
309+
310+
if let AuditEvent::PolicyCreated {
311+
preset: p,
312+
deny_count,
313+
allow_count,
314+
..
315+
} = created
316+
{
317+
let fields = &expected["fields"];
318+
assert_eq!(
319+
p,
320+
fields["preset"].as_str().unwrap(),
321+
"{name}: preset mismatch"
322+
);
323+
if let Some(min) = fields
324+
.get("deny_count_min")
325+
.and_then(serde_json::Value::as_u64)
326+
{
327+
assert!(
328+
*deny_count >= usize::try_from(min).unwrap(),
329+
"{name}: deny_count {deny_count} < min {min}"
330+
);
331+
}
332+
assert_eq!(
333+
*allow_count,
334+
usize::try_from(fields["allow_count"].as_u64().unwrap()).unwrap(),
335+
"{name}: allow_count mismatch"
336+
);
337+
}
338+
}
339+
// UrlValidated, HostValidated, ConnectionAttempt, and RedirectIntercepted
340+
// events are not yet emitted by the core engine. These will be testable
341+
// once P6a (Detection-Grade AuditEvent Fields) lands the emission code.
342+
"validate_url" | "validate_host" | "connection_attempt" | "redirect_intercepted" => {}
343+
_ => panic!("{name}: unknown action: {action}"),
344+
}
345+
}
346+
}
347+
348+
#[test]
349+
fn redirect_chain_vectors() {
350+
let path = vectors_dir().join("redirect_chains.json");
351+
let content = std::fs::read_to_string(&path).unwrap();
352+
let data: serde_json::Value = serde_json::from_str(&content).unwrap();
353+
354+
for case in data["test_cases"].as_array().unwrap() {
355+
let name = case["name"].as_str().unwrap();
356+
let chain: Vec<&str> = case["chain"]
357+
.as_array()
358+
.unwrap()
359+
.iter()
360+
.map(|v| v.as_str().unwrap())
361+
.collect();
362+
let preset = parse_preset(case["policy_preset"].as_str().unwrap());
363+
let expected = case["expected"].as_str().unwrap();
364+
let max_redirects = case
365+
.get("max_redirects")
366+
.and_then(serde_json::Value::as_u64);
367+
368+
let mut builder = PolicyBuilder::new(preset);
369+
370+
if let Some(allow_arr) = case.get("allow_cidrs").and_then(|v| v.as_array()) {
371+
let allows: Vec<&str> = allow_arr.iter().map(|v| v.as_str().unwrap()).collect();
372+
builder.add_allowed(&allows);
373+
}
374+
375+
if case
376+
.get("allow_plaintext_http")
377+
.and_then(serde_json::Value::as_bool)
378+
.unwrap_or(false)
379+
{
380+
builder.protocol_rules(ressrf_core::policy::ProtocolRules {
381+
allow_plaintext_http: true,
382+
require_https: false,
383+
});
384+
}
385+
386+
let policy = builder.build();
387+
let validator = UriValidator::new();
388+
389+
let limit = max_redirects.map_or(usize::MAX, |m| usize::try_from(m).unwrap());
390+
let mut blocked_at: Option<usize> = None;
391+
392+
// Hop 0 is the origin URL; redirect targets start at hop 1.
393+
for (i, url) in chain.iter().enumerate().skip(1) {
394+
if i >= limit {
395+
blocked_at = Some(i);
396+
break;
397+
}
398+
399+
// Check scheme via protocol rules (plaintext HTTP, require_https).
400+
let scheme_blocked = url
401+
.find("://")
402+
.map(|pos| &url[..pos])
403+
.is_some_and(|scheme| policy.validate_scheme(scheme).is_err());
404+
405+
if scheme_blocked || validator.validate_url(url, Some(&policy)).is_err() {
406+
blocked_at = Some(i);
407+
break;
408+
}
409+
}
410+
411+
match expected {
412+
"allowed" => {
413+
assert!(
414+
blocked_at.is_none(),
415+
"{name}: expected allowed, but blocked at hop {}",
416+
blocked_at.unwrap_or(0)
417+
);
418+
}
419+
"blocked" => {
420+
let expected_hop = case
421+
.get("blocked_at_hop")
422+
.and_then(serde_json::Value::as_u64)
423+
.map(|h| usize::try_from(h).unwrap());
424+
assert!(
425+
blocked_at.is_some(),
426+
"{name}: expected blocked, got allowed"
427+
);
428+
if let Some(eh) = expected_hop {
429+
assert_eq!(
430+
blocked_at.unwrap(),
431+
eh,
432+
"{name}: expected blocked at hop {eh}, got {}",
433+
blocked_at.unwrap()
434+
);
435+
}
436+
}
437+
_ => panic!("{name}: unknown expected: {expected}"),
438+
}
439+
}
440+
}

0 commit comments

Comments
 (0)