[pitboss/grind] deferred session-0005 (20260522T163126Z-7d60)

tests/data_exfil_corpus.rs

@@ -13,6 +13,8 @@
 
 #![cfg(feature = "dynamic")]
 
+mod common;
+
 use nyx_scanner::dynamic::corpus::{payloads_for_lang, resolve_benign_control_lang};
 use nyx_scanner::dynamic::oracle::{Oracle, ProbePredicate, oracle_fired};
 use nyx_scanner::dynamic::probe::{ProbeKind, ProbeWitness, SinkProbe};
@@ -110,3 +112,145 @@ fn outbound_predicate_fires_off_allowlist() {
     ));
     assert!(!oracle_fired(&oracle, &outcome(), &[]));
 }
+
+/// Drives the per-language DATA_EXFIL fixtures through `run_spec` and
+/// asserts the vuln payload Confirms while the benign control does not.
+/// Both fixtures share a single entry function (`run`) and the harness
+/// monkey-patches `urllib.request.urlopen` so no real network egress
+/// happens — the probe captures the parsed host before the request is
+/// short-circuited.
+mod e2e_data_exfil {
+    use crate::common::fixture_harness::FIXTURE_LOCK;
+    use nyx_scanner::dynamic::runner::{RunError, RunOutcome, run_spec};
+    use nyx_scanner::dynamic::sandbox::{SandboxBackend, SandboxOptions};
+    use nyx_scanner::dynamic::spec::{
+        EntryKind, HarnessSpec, PayloadSlot, SpecDerivationStrategy, default_toolchain_id,
+    };
+    use nyx_scanner::evidence::DifferentialVerdict;
+    use nyx_scanner::labels::Cap;
+    use nyx_scanner::symbol::Lang;
+    use std::path::PathBuf;
+    use std::process::Command;
+    use tempfile::TempDir;
+
+    fn command_available(bin: &str) -> bool {
+        Command::new(bin)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+    }
+
+    fn build_spec(lang: Lang, fixture: &str, entry_name: &str) -> (HarnessSpec, TempDir) {
+        let fixture_src = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/dynamic_fixtures/data_exfil")
+            .join(match lang {
+                Lang::Python => "python",
+                _ => unreachable!("DATA_EXFIL e2e currently covers Python only"),
+            })
+            .join(fixture);
+        let tmp = TempDir::new().expect("create tempdir");
+        let dst = tmp.path().join(fixture);
+        std::fs::copy(&fixture_src, &dst).expect("copy fixture into tempdir");
+
+        let entry_file = dst.to_string_lossy().into_owned();
+        let mut digest = blake3::Hasher::new();
+        digest.update(b"e2e-data-exfil|");
+        digest.update(fixture.as_bytes());
+        let spec_hash = format!("{:016x}", {
+            let bytes = digest.finalize();
+            u64::from_le_bytes(bytes.as_bytes()[..8].try_into().unwrap())
+        });
+
+        let spec = HarnessSpec {
+            finding_id: spec_hash.clone(),
+            entry_file: entry_file.clone(),
+            entry_name: entry_name.to_owned(),
+            entry_kind: EntryKind::Function,
+            lang,
+            toolchain_id: default_toolchain_id(lang).into(),
+            payload_slot: PayloadSlot::Param(0),
+            expected_cap: Cap::DATA_EXFIL,
+            constraint_hints: vec![],
+            sink_file: entry_file,
+            sink_line: 1,
+            spec_hash: spec_hash.clone(),
+            derivation: SpecDerivationStrategy::FromFlowSteps,
+            stubs_required: vec![],
+            framework: None,
+            java_toolchain: nyx_scanner::dynamic::spec::JavaToolchain::default(),
+        };
+
+        (spec, tmp)
+    }
+
+    fn run(lang: Lang, fixture: &str, entry_name: &str) -> Option<RunOutcome> {
+        let required = match lang {
+            Lang::Python => "python3",
+            _ => unreachable!("DATA_EXFIL e2e currently covers Python only"),
+        };
+        if !command_available(required) {
+            eprintln!("SKIP {lang:?} {fixture}: missing toolchain {required}");
+            return None;
+        }
+        let _guard = FIXTURE_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let (spec, _tmp) = build_spec(lang, fixture, entry_name);
+        let opts = SandboxOptions {
+            backend: SandboxBackend::Process,
+            ..SandboxOptions::default()
+        };
+        match run_spec(&spec, &opts) {
+            Ok(outcome) => Some(outcome),
+            Err(RunError::BuildFailed { stderr, attempts }) => {
+                eprintln!(
+                    "SKIP {lang:?} {fixture}: harness build failed after {attempts} attempts: {stderr}",
+                );
+                None
+            }
+            Err(e) => panic!("run_spec({lang:?} {fixture}) errored: {e:?}"),
+        }
+    }
+
+    /// Pointed at the vuln fixture:
+    ///
+    /// * `attacker.test` → fixture sends to `attacker.test` → probe captures
+    ///   `host = "attacker.test"` → `OutboundHostNotIn` fires.
+    /// * `127.0.0.1` → fixture sends to loopback → probe captures
+    ///   `host = "127.0.0.1"` → predicate clears (loopback in allowlist).
+    ///
+    /// Differential lands at `Confirmed`.
+    #[test]
+    fn python_vuln_confirms_via_run_spec() {
+        let Some(outcome) = run(Lang::Python, "vuln.py", "run") else {
+            return;
+        };
+        assert!(
+            outcome.triggered_by.is_some(),
+            "Python DATA_EXFIL vuln must confirm via run_spec; got {outcome:?}",
+        );
+        let diff = outcome
+            .differential
+            .as_ref()
+            .expect("confirmed run must carry a DifferentialOutcome");
+        assert_eq!(diff.verdict, DifferentialVerdict::Confirmed);
+    }
+
+    /// Pointed at the benign fixture (which rejects non-allowlist hosts
+    /// before calling urlopen):
+    ///
+    /// * `attacker.test` → fixture rejects → no urlopen → no probe.
+    /// * `127.0.0.1` → fixture sends to loopback → probe(host = "127.0.0.1")
+    ///   → predicate clears.
+    ///
+    /// Neither payload fires; differential lands at `NotConfirmed`.
+    #[test]
+    fn python_benign_does_not_confirm_via_run_spec() {
+        let Some(outcome) = run(Lang::Python, "benign.py", "run") else {
+            return;
+        };
+        assert!(
+            outcome.triggered_by.is_none(),
+            "Python DATA_EXFIL benign control must not confirm via run_spec; got {outcome:?}",
+        );
+    }
+}

tests/unauthorized_id_corpus.rs

@@ -11,6 +11,8 @@
 
 #![cfg(feature = "dynamic")]
 
+mod common;
+
 use nyx_scanner::dynamic::corpus::{payloads_for_lang, resolve_benign_control_lang};
 use nyx_scanner::dynamic::oracle::{Oracle, ProbePredicate, oracle_fired};
 use nyx_scanner::dynamic::probe::{ProbeKind, ProbeWitness, SinkProbe};
@@ -102,3 +104,146 @@ fn idor_predicate_fires_on_boundary_crossing() {
     ));
     assert!(!oracle_fired(&oracle, &outcome(), &[]));
 }
+
+/// Drives the per-language UNAUTHORIZED_ID fixtures through `run_spec`
+/// and asserts the vuln payload Confirms while the benign control does
+/// not.  Each fixture pair shares a single entry function (`run`); the
+/// harness emitter resolves the payload-vs-record boundary via the
+/// hard-coded `caller_id = "alice"` it embeds in the probe shim.
+mod e2e_unauthorized_id {
+    use crate::common::fixture_harness::FIXTURE_LOCK;
+    use nyx_scanner::dynamic::runner::{RunError, RunOutcome, run_spec};
+    use nyx_scanner::dynamic::sandbox::{SandboxBackend, SandboxOptions};
+    use nyx_scanner::dynamic::spec::{
+        EntryKind, HarnessSpec, PayloadSlot, SpecDerivationStrategy, default_toolchain_id,
+    };
+    use nyx_scanner::evidence::DifferentialVerdict;
+    use nyx_scanner::labels::Cap;
+    use nyx_scanner::symbol::Lang;
+    use std::path::PathBuf;
+    use std::process::Command;
+    use tempfile::TempDir;
+
+    fn command_available(bin: &str) -> bool {
+        Command::new(bin)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+    }
+
+    fn build_spec(lang: Lang, fixture: &str, entry_name: &str) -> (HarnessSpec, TempDir) {
+        let fixture_src = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/dynamic_fixtures/unauthorized_id")
+            .join(match lang {
+                Lang::Python => "python",
+                _ => unreachable!("UNAUTHORIZED_ID e2e currently covers Python only"),
+            })
+            .join(fixture);
+        let tmp = TempDir::new().expect("create tempdir");
+        let dst = tmp.path().join(fixture);
+        std::fs::copy(&fixture_src, &dst).expect("copy fixture into tempdir");
+
+        let entry_file = dst.to_string_lossy().into_owned();
+        let mut digest = blake3::Hasher::new();
+        digest.update(b"e2e-unauthorized-id|");
+        digest.update(fixture.as_bytes());
+        let spec_hash = format!("{:016x}", {
+            let bytes = digest.finalize();
+            u64::from_le_bytes(bytes.as_bytes()[..8].try_into().unwrap())
+        });
+
+        let spec = HarnessSpec {
+            finding_id: spec_hash.clone(),
+            entry_file: entry_file.clone(),
+            entry_name: entry_name.to_owned(),
+            entry_kind: EntryKind::Function,
+            lang,
+            toolchain_id: default_toolchain_id(lang).into(),
+            payload_slot: PayloadSlot::Param(0),
+            expected_cap: Cap::UNAUTHORIZED_ID,
+            constraint_hints: vec![],
+            sink_file: entry_file,
+            sink_line: 1,
+            spec_hash: spec_hash.clone(),
+            derivation: SpecDerivationStrategy::FromFlowSteps,
+            stubs_required: vec![],
+            framework: None,
+            java_toolchain: nyx_scanner::dynamic::spec::JavaToolchain::default(),
+        };
+
+        (spec, tmp)
+    }
+
+    fn run(lang: Lang, fixture: &str, entry_name: &str) -> Option<RunOutcome> {
+        let required = match lang {
+            Lang::Python => "python3",
+            _ => unreachable!("UNAUTHORIZED_ID e2e currently covers Python only"),
+        };
+        if !command_available(required) {
+            eprintln!("SKIP {lang:?} {fixture}: missing toolchain {required}");
+            return None;
+        }
+        let _guard = FIXTURE_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let (spec, _tmp) = build_spec(lang, fixture, entry_name);
+        let opts = SandboxOptions {
+            backend: SandboxBackend::Process,
+            ..SandboxOptions::default()
+        };
+        match run_spec(&spec, &opts) {
+            Ok(outcome) => Some(outcome),
+            Err(RunError::BuildFailed { stderr, attempts }) => {
+                eprintln!(
+                    "SKIP {lang:?} {fixture}: harness build failed after {attempts} attempts: {stderr}",
+                );
+                None
+            }
+            Err(e) => panic!("run_spec({lang:?} {fixture}) errored: {e:?}"),
+        }
+    }
+
+    /// The runner draws the curated payload pair (vuln "bob" + benign "alice")
+    /// from `payloads_for_lang(Cap::UNAUTHORIZED_ID, Lang::Python)`.  Pointed at
+    /// the vuln fixture:
+    ///
+    /// * `bob` → fixture returns bob's record → probe(caller=alice, owner=bob)
+    ///   → `IdorBoundaryCrossed` fires.
+    /// * `alice` → fixture returns alice's record → probe(caller=alice,
+    ///   owner=alice) → predicate clears.
+    ///
+    /// The vuln-vs-benign differential lands at `Confirmed`.
+    #[test]
+    fn python_vuln_confirms_via_run_spec() {
+        let Some(outcome) = run(Lang::Python, "vuln.py", "run") else {
+            return;
+        };
+        assert!(
+            outcome.triggered_by.is_some(),
+            "Python UNAUTHORIZED_ID vuln must confirm via run_spec; got {outcome:?}",
+        );
+        let diff = outcome
+            .differential
+            .as_ref()
+            .expect("confirmed run must carry a DifferentialOutcome");
+        assert_eq!(diff.verdict, DifferentialVerdict::Confirmed);
+    }
+
+    /// Pointed at the benign fixture:
+    ///
+    /// * `bob` → fixture rejects (returns None) → no probe.
+    /// * `alice` → fixture returns alice's record → probe(alice, alice) →
+    ///   predicate clears.
+    ///
+    /// Neither payload fires the predicate; the differential lands at
+    /// `NotConfirmed`.
+    #[test]
+    fn python_benign_does_not_confirm_via_run_spec() {
+        let Some(outcome) = run(Lang::Python, "benign.py", "run") else {
+            return;
+        };
+        assert!(
+            outcome.triggered_by.is_none(),
+            "Python UNAUTHORIZED_ID benign control must not confirm via run_spec; got {outcome:?}",
+        );
+    }
+}