|
2 | 2 |
|
3 | 3 | use std::net::IpAddr; |
4 | 4 | use std::path::PathBuf; |
| 5 | +use std::sync::Arc; |
5 | 6 |
|
| 7 | +use ressrf_core::audit::{AuditEvent, AuditSink, CollectingSink}; |
6 | 8 | use ressrf_core::cidr::Cidr; |
| 9 | +use ressrf_core::cloud::CloudProvider; |
7 | 10 | use ressrf_core::error::DataTier; |
8 | 11 | use ressrf_core::policy::{PolicyBuilder, Preset}; |
9 | 12 | use ressrf_core::uri_validator::UriValidator; |
10 | 13 | use ressrf_core::url_rules::UrlRuleset; |
11 | 14 |
|
| 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 | + |
12 | 23 | fn vectors_dir() -> PathBuf { |
13 | 24 | PathBuf::from(env!("CARGO_MANIFEST_DIR")) |
14 | 25 | .parent() |
@@ -106,6 +117,18 @@ fn policy_decision_vectors() { |
106 | 117 | builder.add_allowed(&allows); |
107 | 118 | } |
108 | 119 |
|
| 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 | + |
109 | 132 | let policy = builder.build(); |
110 | 133 |
|
111 | 134 | let ips: Vec<IpAddr> = ip_strs |
@@ -218,3 +241,200 @@ fn url_rules_vectors() { |
218 | 241 | } |
219 | 242 | } |
220 | 243 | } |
| 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