Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix(plugin): validate canonical code-evidence and deferred paths (#1522)

Peter442ecd3dabf2
diff --git a/plugins/codex-security/scripts/finalize_scan_contract.py b/plugins/codex-security/scripts/finalize_scan_contract.py
index 37a853765..999c9ec56 100644
--- a/plugins/codex-security/scripts/finalize_scan_contract.py
+++ b/plugins/codex-security/scripts/finalize_scan_contract.py
@@ -1298,6 +1298,8 @@ def _recover_unsealed_coverage(
item["disposition"] = "needs_follow_up"
partial = True
+ if field == "deferred":
+ _validate_deferred_paths(item, context)
_validate_schema_node(item, item_schema, context)
except ContractError as exc:
warnings.append(f"Skipped malformed {label} {index + 1}: {exc}.")
@@ -1595,6 +1597,11 @@ def _validate_finding(finding: dict[str, Any], context: str) -> None:
raise ContractError(f"{evidence_context}.id: duplicate code-evidence id")
evidence_ids.add(evidence_id)
_require_str(evidence, "code", evidence_context)
+ if evidence_key == "codeEvidence":
+ _require_safe_relative_path(
+ _require_str(evidence, "path", evidence_context),
+ f"{evidence_context}.path",
+ )
referenced_sections = [
(section_name, finding.get(section_name))
@@ -1655,6 +1662,15 @@ def _validate_resolved_deferred(coverage: dict[str, Any]) -> None:
resolved.add(closure_id)
+def _validate_deferred_paths(deferred: dict[str, Any], context: str) -> None:
+ if "paths" not in deferred:
+ return
+ for index, path in enumerate(_require_list(deferred, "paths", context)):
+ if not isinstance(path, str):
+ raise ContractError(f"{context}.paths[{index}]: expected a string")
+ _require_safe_relative_path(path, f"{context}.paths[{index}]", allow_dot=True)
+
+
def _validate_coverage(manifest: dict[str, Any], coverage: dict[str, Any], scan_dir: Path) -> None:
scan = _require_dict(manifest, "scan", "manifest")
scan_id = _require_str(scan, "id", "manifest.scan")
@@ -1703,6 +1719,9 @@ def _validate_coverage(manifest: dict[str, Any], coverage: dict[str, Any], scan_
for field in ("explicitExclusions", "deferred"):
if not isinstance(coverage.get(field, []), list):
raise ContractError(f"coverage.{field}: expected an array")
+ for index, deferred in enumerate(coverage.get("deferred", [])):
+ if isinstance(deferred, dict):
+ _validate_deferred_paths(deferred, f"coverage.deferred[{index}]")
_validate_resolved_deferred(coverage)
if completeness == "complete" and (has_needs_follow_up or coverage.get("deferred")):
raise ContractError("coverage.completeness: complete coverage cannot have deferred work")
diff --git a/plugins/codex-security/tests/test_finalize_scan_contract.py b/plugins/codex-security/tests/test_finalize_scan_contract.py
index 03a2e5416..6f280a3b9 100644
--- a/plugins/codex-security/tests/test_finalize_scan_contract.py
+++ b/plugins/codex-security/tests/test_finalize_scan_contract.py
@@ -1844,6 +1844,17 @@ The extraction root is not enforced.
with self.preserving_sealed_findings(findings):
self.assertNotIn("code_evidence", self.compatible_finding(findings))
+ def test_sealed_rerun_and_export_preserve_nullable_legacy_evidence_path(self) -> None:
+ self.write_sealed_scan()
+ findings = self.read_json("findings.json")
+ findings["findings"][0]["code_evidence"] = [
+ {"id": "legacy-source", "code": "legacy_source()", "path": None}
+ ]
+ with self.preserving_sealed_findings(findings):
+ result = self.run_finalizer("--export-format", "json")
+ self.assertEqual(result.returncode, 0, result.stderr)
+ self.assertEqual(json.loads(result.stdout), findings)
+
def test_sealed_rerun_accepts_empty_legacy_root_cause(self) -> None:
self.write_sealed_scan()
findings = self.read_json("findings.json")
@@ -2182,7 +2193,7 @@ The extraction root is not enforced.
"code": "canonical_source()",
"explanation": "Canonical snippet.",
}
- legacy_evidence = {"id": "legacy-source", "code": "legacy_source()"}
+ legacy_evidence = {"id": "legacy-source", "code": "legacy_source()", "path": None}
for evidence_field, evidence in (
("codeEvidence", canonical_evidence),
("code_evidence", legacy_evidence),
@@ -2311,6 +2322,36 @@ The extraction root is not enforced.
)
self.assertFalse(warnings)
+ def test_recovery_publishes_findings_without_unsafe_deferred_paths(self) -> None:
+ valid = {"id": "review", "reason": "Repository review is incomplete.", "paths": ["."]}
+ self.coverage["deferred"] = [
+ {"id": "invalid", "reason": "Invalid scope.", "paths": ["../outside.py"]},
+ valid,
+ ]
+ for status in ("completed", "interrupted"):
+ with self.subTest(status=status):
+ self.write_scan()
+ binding = {**self.completion_binding(), "status": status}
+ warnings: list[str] = []
+ prepared = FINALIZER._prepare_scan_finalization(
+ self.scan_dir, completion_binding=binding, completion_warnings=warnings
+ )
+ manifest, findings, coverage = FINALIZER._write_prepared_scan_finalization(prepared)
+
+ self.assertEqual(manifest["scan"]["status"], status)
+ self.assertEqual(len(findings["findings"]), 1)
+ self.assertEqual(findings["findings"][0]["title"], self.finding["title"])
+ self.assertEqual(coverage["deferred"], [valid])
+ self.assertEqual(coverage["completeness"], "partial")
+ self.assertTrue(
+ any(
+ "Skipped malformed deferred coverage item 1" in warning
+ for warning in warnings
+ )
+ )
+ self.assertEqual(self.read_json("findings.json"), findings)
+ self.assertEqual(self.read_json("coverage.json"), coverage)
+
def test_sealed_findings_keep_authored_identity_mismatches_strict(self) -> None:
self.write_sealed_scan()
findings = self.read_json("findings.json")
@@ -2421,6 +2462,64 @@ The extraction root is not enforced.
with self.assertRaisesRegex(FINALIZER.ContractError, "cannot have deferred work"):
FINALIZER.finalize_scan(self.scan_dir)
+ def test_rejects_unsafe_code_evidence_paths(self) -> None:
+ for path in ("../../outside.ts", "/outside.ts", r"C:\outside.ts"):
+ with self.subTest(path=path):
+ self.findings["findings"][0]["codeEvidence"] = [
+ {
+ "id": "source",
+ "label": "Source",
+ "path": path,
+ "startLine": 1,
+ "code": "source()",
+ "explanation": "Synthetic source evidence.",
+ }
+ ]
+ self.write_scan()
+ with self.assertRaisesRegex(
+ FINALIZER.ContractError,
+ r"codeEvidence\[0\]\.path: expected a safe repository-relative POSIX path",
+ ):
+ FINALIZER.finalize_scan(self.scan_dir)
+
+ def test_rejects_unsafe_deferred_paths(self) -> None:
+ self.coverage["completeness"] = "partial"
+ for path in ("../../outside.ts", "/outside.ts", r"C:\outside.ts"):
+ with self.subTest(path=path):
+ self.coverage["deferred"] = [
+ {"id": "review", "reason": "Review is incomplete.", "paths": [path]}
+ ]
+ self.write_scan()
+ with self.assertRaisesRegex(
+ FINALIZER.ContractError,
+ r"deferred\[0\]\.paths\[0\]: expected a safe repository-relative POSIX path",
+ ):
+ FINALIZER.finalize_scan(self.scan_dir)
+
+ def test_accepts_safe_code_evidence_and_deferred_paths(self) -> None:
+ self.findings["findings"][0]["codeEvidence"] = [
+ {
+ "id": "source",
+ "label": "Source",
+ "path": "src/extract.py",
+ "startLine": 41,
+ "code": "source()",
+ "explanation": "Repository-relative evidence.",
+ }
+ ]
+ self.coverage["completeness"] = "partial"
+ for path in (".", "src", "src/extract.py", "src/a:b.py"):
+ with self.subTest(path=path):
+ self.coverage["deferred"] = [
+ {"id": "review", "reason": "Review is incomplete.", "paths": [path]}
+ ]
+ self.write_scan()
+ _, findings, coverage = FINALIZER.finalize_scan(self.scan_dir)
+ self.assertEqual(
+ findings["findings"][0]["codeEvidence"][0]["path"], "src/extract.py"
+ )
+ self.assertEqual(coverage["deferred"][0]["paths"], [path])
+
def test_rejects_non_rfc3339_timestamps(self) -> None:
for timestamp in ("2026-W22-7T18:09:00+00:00", "2026-05-31T18:09:00+0000"):
with self.subTest(timestamp=timestamp):