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: complete Deep scans with missing optional writeups (#1624)

Michael D'Angelo6f1412a6ad6c
diff --git a/plugins/codex-security/scripts/finalize_scan_contract.py b/plugins/codex-security/scripts/finalize_scan_contract.py
index df8a11095..acafc41a7 100644
--- a/plugins/codex-security/scripts/finalize_scan_contract.py
+++ b/plugins/codex-security/scripts/finalize_scan_contract.py
@@ -19,7 +19,7 @@ import struct
import sys
from datetime import datetime, timezone
from pathlib import Path, PurePosixPath
-from typing import Any, TextIO
+from typing import Any, NamedTuple, TextIO
from urllib.parse import quote, urlsplit
# Keep sibling helpers importable when Python starts in isolated mode.
@@ -95,6 +95,10 @@ class ContractError(ValueError):
"""Raised when a completed scan does not satisfy the additive contract."""
+class MissingScanLocalFileError(ContractError):
+ """Raised when a scan-local file or its containing directory is absent."""
+
+
class RecoverableContractError(ContractError):
"""Raised when scan completion can safely be retried before publication."""
@@ -587,6 +591,9 @@ def _open_scan_local_file_with_path(
return backend.open_read_fd_with_path(scan_dir, relative_path, context)
return backend.open_read_fd(scan_dir, relative_path, context), relative_path
except OSError as exc:
+ # The Windows backend retains native ERROR_FILE/PATH_NOT_FOUND codes.
+ if exc.errno in {2, 3}:
+ raise MissingScanLocalFileError(str(exc)) from exc
raise ContractError(str(exc)) from exc
root_fd: int | None = None
parent_fd: int | None = None
@@ -602,6 +609,10 @@ def _open_scan_local_file_with_path(
dir_fd=parent_fd,
)
except OSError as exc:
+ if exc.errno == errno.ENOENT:
+ raise MissingScanLocalFileError(
+ f"{context}: expected a file inside the scan directory"
+ ) from exc
if exc.errno == errno.ELOOP:
try:
link_target = Path(os.readlink(parts[-1], dir_fd=parent_fd))
@@ -647,7 +658,13 @@ def _require_scan_local_file(scan_dir: Path, relative_path: str, context: str) -
os.close(descriptor)
-def _require_derived_writeup_files(scan_dir: Path, findings: dict[str, Any]) -> None:
+def _prepare_derived_writeups(
+ scan_dir: Path,
+ findings: dict[str, Any],
+ *,
+ allow_missing: bool = False,
+) -> list[str]:
+ warnings: list[str] = []
for index, finding in enumerate(findings.get("findings", [])):
if not isinstance(finding, dict):
continue
@@ -656,11 +673,18 @@ def _require_derived_writeup_files(scan_dir: Path, findings: dict[str, Any]) ->
continue
report_path = writeup.get("reportPath")
if isinstance(report_path, str):
- _require_scan_local_file(
- scan_dir,
- report_path,
- f"findings[{index}].writeup.reportPath",
- )
+ try:
+ _require_scan_local_file(
+ scan_dir,
+ report_path,
+ f"findings[{index}].writeup.reportPath",
+ )
+ except MissingScanLocalFileError as exc:
+ if not allow_missing:
+ raise
+ finding.pop("writeup")
+ warnings.append(f"Skipped missing writeup for finding {index + 1}: {exc}.")
+ return warnings
def _require_hardening_portfolio_file(scan_dir: Path, scan: dict[str, Any]) -> None:
@@ -2911,15 +2935,15 @@ def _write_sarif_projection_if_possible(
)
-PreparedScanFinalization = tuple[
- Path,
- Path,
- dict[str, Any],
- dict[str, Any],
- dict[str, Any],
- bool,
- bytes,
-]
+class PreparedScanFinalization(NamedTuple):
+ scan_dir: Path
+ schema_dir: Path
+ manifest: dict[str, Any]
+ findings: dict[str, Any]
+ coverage: dict[str, Any]
+ was_sealed: bool
+ report_markdown_bytes: bytes
+ warnings: list[str]
def _prepare_scan_finalization(
@@ -2928,12 +2952,14 @@ def _prepare_scan_finalization(
*,
expected_coverage_mode: str | None = None,
completion_binding: dict[str, Any] | None = None,
- completion_warnings: list[str] | None = None,
+ recover_unsealed: bool = False,
+ allow_missing_writeups: bool = False,
draft_documents: tuple[dict[str, Any], dict[str, Any], dict[str, Any]] | None = None,
finding_scope: list[tuple[str, bool]] | None = None,
) -> PreparedScanFinalization:
- """Read, populate, and validate a scan without writing any output files."""
+ """Prepare validated documents and warnings without writing any output files."""
+ warnings: list[str] = []
scan_dir = _require_scan_directory(scan_dir)
schema_dir = schema_dir or Path(__file__).resolve().parent.parent / "schemas"
manifest = (
@@ -2993,14 +3019,12 @@ def _prepare_scan_finalization(
findings_for_validation = (
_legacy_sealed_findings_for_validation(findings) if was_sealed else findings
)
- if not was_sealed and completion_warnings is not None:
+ if not was_sealed and recover_unsealed:
discarded_findings = _recover_unsealed_findings(
- manifest, findings, schema_dir, scan_dir, completion_warnings
- )
- _recover_unsealed_coverage(
- coverage, schema_dir, scan_dir, completion_warnings, discarded_findings
+ manifest, findings, schema_dir, scan_dir, warnings
)
- _recover_unsealed_hardening(manifest, scan_dir, completion_warnings)
+ _recover_unsealed_coverage(coverage, schema_dir, scan_dir, warnings, discarded_findings)
+ _recover_unsealed_hardening(manifest, scan_dir, warnings)
elif not was_sealed:
_populate_unsealed_finding_identities(manifest, findings)
_validate_findings(manifest, findings_for_validation)
@@ -3010,29 +3034,42 @@ def _prepare_scan_finalization(
_validate_canonical_schemas_before_projection(
manifest, findings_for_validation, coverage, schema_dir
)
- _require_derived_writeup_files(scan_dir, findings)
_require_hardening_portfolio_file(scan_dir, scan)
if finding_scope is not None:
# Accepted worker/reducer files remain immutable; only the new parent
# projection is scoped, after the existing validation of every finding.
- scoped_findings = [
- finding
- for finding in findings["findings"]
- if any(
+ scoped_findings = []
+ excluded_findings = []
+ for finding in findings["findings"]:
+ in_scope = any(
PurePosixPath(location["path"]) == PurePosixPath(path)
if is_file
else path_within_scope(location["path"], path)
for location in finding["locations"]
for path, is_file in finding_scope
)
- ]
+ (scoped_findings if in_scope else excluded_findings).append(finding)
if was_sealed and len(scoped_findings) != len(findings["findings"]):
raise ContractError(
"The sealed Deep scan contains findings outside its requested paths; "
"start a new scan to produce scoped results."
)
if not was_sealed:
+ # Excluded findings still require safe writeups, but missing optional
+ # links should only produce warnings for findings in the final report.
+ _prepare_derived_writeups(
+ scan_dir,
+ {"findings": excluded_findings},
+ allow_missing=allow_missing_writeups,
+ )
findings["findings"] = scoped_findings
+ warnings.extend(
+ _prepare_derived_writeups(
+ scan_dir,
+ findings,
+ allow_missing=allow_missing_writeups and not was_sealed,
+ )
+ )
if was_sealed:
_validate_sealed_coverage_receipts(scan, coverage)
_validate_manifest(manifest)
@@ -3055,14 +3092,15 @@ def _prepare_scan_finalization(
_validate_manifest(manifest)
validate_against_schema(manifest, schema_dir / "scan-manifest.schema.json")
_contract_json_bytes("scan-manifest.json", manifest)
- return (
- scan_dir,
- schema_dir,
- manifest,
- findings,
- coverage,
- was_sealed,
- report_markdown_bytes,
+ return PreparedScanFinalization(
+ scan_dir=scan_dir,
+ schema_dir=schema_dir,
+ manifest=manifest,
+ findings=findings,
+ coverage=coverage,
+ was_sealed=was_sealed,
+ report_markdown_bytes=report_markdown_bytes,
+ warnings=warnings,
)
@@ -3074,33 +3112,25 @@ def _write_prepared_scan_finalization(
) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:
"""Write a previously validated scan finalization result."""
- (
- scan_dir,
- schema_dir,
- manifest,
- findings,
- coverage,
- was_sealed,
- report_markdown_bytes,
- ) = prepared
- scan = _require_dict(manifest, "scan", "manifest")
- if not was_sealed:
- _write_scan_local_json(scan_dir, "findings.json", findings)
- _write_scan_local_json(scan_dir, "coverage.json", coverage)
- write_scan_local_bytes(scan_dir, "report.md", report_markdown_bytes)
+ scan_dir = prepared.scan_dir
+ scan = _require_dict(prepared.manifest, "scan", "manifest")
+ if not prepared.was_sealed:
+ _write_scan_local_json(scan_dir, "findings.json", prepared.findings)
+ _write_scan_local_json(scan_dir, "coverage.json", prepared.coverage)
+ write_scan_local_bytes(scan_dir, "report.md", prepared.report_markdown_bytes)
_remove_scan_local_file_if_exists(scan_dir, "report.html")
- if not was_sealed:
- _write_scan_local_json(scan_dir, "scan-manifest.json", manifest)
+ if not prepared.was_sealed:
+ _write_scan_local_json(scan_dir, "scan-manifest.json", prepared.manifest)
_validate_existing_seal(scan_dir, scan)
- _write_sarif_projection_if_possible(scan_dir, source_root, schema_dir)
- warning = write_threat_model_projection_if_possible(scan_dir, manifest)
+ _write_sarif_projection_if_possible(scan_dir, source_root, prepared.schema_dir)
+ warning = write_threat_model_projection_if_possible(scan_dir, prepared.manifest)
if (
warning is not None
and projection_warnings is not None
and warning not in projection_warnings
):
projection_warnings.append(warning)
- return manifest, findings, coverage
+ return prepared.manifest, prepared.findings, prepared.coverage
def finalize_scan(
diff --git a/plugins/codex-security/scripts/workbench_db.py b/plugins/codex-security/scripts/workbench_db.py
index 6fff8bc67..d2f93a80a 100644
--- a/plugins/codex-security/scripts/workbench_db.py
+++ b/plugins/codex-security/scripts/workbench_db.py
@@ -1552,11 +1552,23 @@ def complete_scan_locked(
scan_dir,
expected_coverage_mode=expected_coverage_mode(scan),
completion_binding=completion_binding,
- completion_warnings=warnings if scan["mode"] != "deep" else None,
+ recover_unsealed=scan["mode"] != "deep",
+ allow_missing_writeups=scan["mode"] == "deep",
draft_documents=draft_documents,
finding_scope=requested_finding_scope(scan) if scan["mode"] == "deep" else None,
)
+ if scan["mode"] != "deep":
+ warnings.extend(prepared.warnings)
add_warning()
+ if scan["mode"] == "deep" and prepared.warnings:
+ warnings.extend(warning for warning in prepared.warnings if warning not in warnings)
+ # Save the explanation before publication removes the broken reference,
+ # so a retry after an output-write failure retains it.
+ with connection:
+ connection.execute(
+ "UPDATE scans SET completion_warnings_json = ? WHERE id = ? AND status = 'running'",
+ (json.dumps(warnings), scan_id),
+ )
wrote = True
manifest, findings, _ = _write_prepared_scan_finalization(
prepared, projection_warnings=warnings
diff --git a/plugins/codex-security/scripts/workbench_saved_results.py b/plugins/codex-security/scripts/workbench_saved_results.py
index 97091bd6c..7206e2c79 100644
--- a/plugins/codex-security/scripts/workbench_saved_results.py
+++ b/plugins/codex-security/scripts/workbench_saved_results.py
@@ -2039,12 +2039,12 @@ def coverage_for_comparison(db: Any, scan: Any) -> dict[str, Any]:
scan_dir = db.require_canonical_scan_directory(Path(scan["scan_dir"]))
db.require_recorded_manifest_digest(scan, scan_dir)
try:
- _, _, manifest, _, coverage, was_sealed, _ = _prepare_scan_finalization(scan_dir)
+ prepared = _prepare_scan_finalization(scan_dir)
except ContractError as exc:
raise SystemExit(str(exc)) from exc
- if not was_sealed or manifest["scan"]["id"] != scan["id"]:
+ if not prepared.was_sealed or prepared.manifest["scan"]["id"] != scan["id"]:
raise SystemExit("Only sealed scans can be compared.")
- return coverage
+ return prepared.coverage
def _snapshot_published_outputs(scan_dir: Path) -> dict[str, bytes | None]:
@@ -2272,10 +2272,11 @@ def preserve_scan_results_locked(
scan_dir,
expected_coverage_mode=db.expected_coverage_mode(scan),
completion_binding=binding,
- completion_warnings=warnings,
+ recover_unsealed=True,
draft_documents=documents,
finding_scope=db.requested_finding_scope(scan) if scan["mode"] == "deep" else None,
)
+ warnings.extend(prepared.warnings)
snapshots = _snapshot_published_outputs(scan_dir)
try:
manifest, findings, _ = _write_prepared_scan_finalization(
diff --git a/plugins/codex-security/tests/test_deep_scan_successful_publication.py b/plugins/codex-security/tests/test_deep_scan_successful_publication.py
index 57e5d4d28..af8bb75b7 100644
--- a/plugins/codex-security/tests/test_deep_scan_successful_publication.py
+++ b/plugins/codex-security/tests/test_deep_scan_successful_publication.py
@@ -371,6 +371,118 @@ def test_deep_prepare_and_complete_preserve_the_same_aggregate(
assert_published_aggregate(scan)
[email protected]("scope", [".", "subdir"])
[email protected]("missing_parent", [False, True])
+def test_deep_completion_preserves_findings_with_missing_optional_writeups(
+ workbench_api, workbench_db, publication_scan, scope, missing_parent
+):
+ scan = publication_scan(scope=scope)
+ valid_path = "findings/valid/valid.md"
+ valid_file = scan.scan_dir / valid_path
+ valid_file.parent.mkdir(parents=True)
+ valid_file.write_text("# Retained writeup\n")
+ scan.findings[0]["writeup"] = {"reportPath": valid_path}
+ missing = copy.deepcopy(scan.findings[0])
+ missing["identity"]["anchor"] = "missing-writeup"
+ missing["summary"] = "A separate finding whose optional writeup was not transferred."
+ missing_path = "findings/missing/missing.md"
+ if not missing_parent:
+ (scan.scan_dir / missing_path).parent.mkdir()
+ missing["writeup"] = {"reportPath": missing_path}
+ scan.findings.append(missing)
+ if scope != ".":
+ excluded = copy.deepcopy(missing)
+ excluded["identity"]["anchor"] = "excluded-writeup"
+ excluded["locations"] = [{"path": "unrelated/extract.py", "startLine": 1}]
+ excluded["writeup"] = {"reportPath": "findings/excluded/excluded.md"}
+ scan.findings.insert(0, excluded)
+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))
+ original_files = {valid_file: valid_file.read_bytes()}
+ for kind in ("discovery", "dedup"):
+ result = add_worker(workbench_db, scan)
+ result.write_text(
+ json.dumps(saved_draft(scan.scan_id, findings=scan.findings, complete=True))
+ )
+ checkpoint = write_checkpoint(result.parent / "checkpoints", json.loads(result.read_text()))
+ original_files.update({path: path.read_bytes() for path in (result, checkpoint)})
+ with workbench_db:
+ workbench_db.execute(
+ "UPDATE deep_scan_workers SET kind = ?, merge_state = 'none' "
+ "WHERE result_manifest_path = ?",
+ (kind, str(result)),
+ )
+
+ # Preparing and then completing also exercises replay of the sealed parent.
+ prepared = complete(workbench_api, workbench_db, scan, prepare_only=True)
+ completed = complete(workbench_api, workbench_db, scan)
+
+ assert completed["progress"]["status"] == "complete"
+ assert completed["findingCount"] == 2
+ assert len(completed["warnings"]) == 1
+ assert completed["warnings"] == prepared["warnings"]
+ assert completed["warnings"][0].startswith("Skipped missing writeup for finding 2:")
+ assert "findings[1].writeup.reportPath" in completed["warnings"][0]
+ if scope != ".":
+ scan.findings.pop(0)
+ missing.pop("writeup")
+ assert_published_aggregate(scan)
+ assert {path: path.read_bytes() for path in original_files} == original_files
+ report = (scan.scan_dir / "report.md").read_text()
+ assert valid_path in report
+ assert missing_path not in report
+ assert missing["summary"] in report
+ manifest = json.loads((scan.scan_dir / "scan-manifest.json").read_text())
+ assert manifest["scan"]["status"] == "completed"
+ assert manifest["scan"]["sealedAt"]
+
+
[email protected]("invalid", ["unsafe-path", "directory"])
+def test_deep_scope_filter_does_not_hide_invalid_writeups(
+ workbench_api, workbench_db, publication_scan, invalid
+):
+ scan = publication_scan(scope="subdir")
+ finding = scan.findings[0]
+ finding["locations"] = [{"path": "unrelated/extract.py", "startLine": 1}]
+ report_path = "findings/invalid/invalid.md"
+ if invalid == "unsafe-path":
+ report_path = "../invalid.md"
+ else:
+ (scan.scan_dir / report_path).mkdir(parents=True)
+ finding["writeup"] = {"reportPath": report_path}
+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))
+
+ with pytest.raises(SystemExit, match="reportPath|regular non-symlink file"):
+ complete(workbench_api, workbench_db, scan)
+ assert (
+ workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]
+ != "complete"
+ )
+
+
[email protected]("invalid", ["finding", "coverage"])
+def test_missing_deep_writeup_does_not_enable_general_recovery(
+ workbench_api, workbench_db, publication_scan, invalid
+):
+ scan = publication_scan()
+ scan.findings[0]["writeup"] = {"reportPath": "findings/missing/missing.md"}
+ if invalid == "finding":
+ scan.findings[0]["severity"]["level"] = "invalid"
+ else:
+ scan.coverage["completeness"] = "invalid"
+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))
+ (scan.scan_dir / "coverage.json").write_text(json.dumps(scan.coverage))
+
+ with pytest.raises(SystemExit, match="severity|completeness"):
+ complete(workbench_api, workbench_db, scan)
+ assert (
+ workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]
+ != "complete"
+ )
+
+
@pytest.mark.parametrize(
("source", "scope", "has_parent"),
[
@@ -543,22 +655,35 @@ def test_standard_publication_preserves_deliberately_partial_coverage(
assert_published_aggregate(scan)
[email protected]("missing_writeup", [False, True])
[email protected]("interrupted_file", ["findings.json", "report.md"])
def test_deep_publication_write_failure_keeps_original_terminal_cause(
- workbench_api, workbench_db, publication_scan, monkeypatch
+ workbench_api, workbench_db, publication_scan, monkeypatch, missing_writeup, interrupted_file
):
scan = publication_scan()
+ if missing_writeup:
+ scan.findings[0]["writeup"] = {"reportPath": "findings/missing/missing.md"}
+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))
finalizer_globals = workbench_api["_write_prepared_scan_finalization"].__globals__
write_bytes = finalizer_globals["write_scan_local_bytes"]
def fail_report(scan_dir, relative_path, payload, **kwargs):
- if relative_path == "report.md":
+ if relative_path == interrupted_file:
raise finalizer_globals["ContractError"]("Synthetic report write interruption")
return write_bytes(scan_dir, relative_path, payload, **kwargs)
with monkeypatch.context() as patch:
patch.setitem(finalizer_globals, "write_scan_local_bytes", fail_report)
- with pytest.raises(SystemExit, match="Synthetic report write interruption"):
- complete(workbench_api, workbench_db, scan)
+ for _ in range(2):
+ with pytest.raises(SystemExit, match="Synthetic report write interruption"):
+ complete(workbench_api, workbench_db, scan)
+ warnings = json.loads(
+ workbench_db.execute(
+ "SELECT completion_warnings_json FROM scans WHERE id = ?", (scan.scan_id,)
+ ).fetchone()[0]
+ )
+ assert len(warnings) == int(missing_writeup)
assert (
workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]
@@ -568,7 +693,11 @@ def test_deep_publication_write_failure_keeps_original_terminal_cause(
"SELECT status, terminal_reason FROM deep_scan_runs WHERE scan_id = ?", (scan.scan_id,)
).fetchone()
assert tuple(run) == ("succeeded", "saturated")
- assert complete(workbench_api, workbench_db, scan)["progress"]["status"] == "complete"
+ completed = complete(workbench_api, workbench_db, scan)
+ assert completed["progress"]["status"] == "complete"
+ assert completed["warnings"] == warnings
+ if missing_writeup:
+ scan.findings[0].pop("writeup")
assert_published_aggregate(scan)
diff --git a/plugins/codex-security/tests/test_finalize_scan_contract.py b/plugins/codex-security/tests/test_finalize_scan_contract.py
index 1919dc4e9..b478941b7 100644
--- a/plugins/codex-security/tests/test_finalize_scan_contract.py
+++ b/plugins/codex-security/tests/test_finalize_scan_contract.py
@@ -672,6 +672,11 @@ The extraction root is not enforced.
with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):
FINALIZER.finalize_scan(self.scan_dir)
+ with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):
+ FINALIZER._prepare_scan_finalization(
+ self.scan_dir, finding_scope=[("unrelated", False)]
+ )
+
writeup_path = self.scan_dir / report_path
writeup_path.parent.mkdir(parents=True)
writeup_path.mkdir()
@@ -684,6 +689,12 @@ The extraction root is not enforced.
writeup_path.unlink()
with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):
FINALIZER.finalize_scan(self.scan_dir)
+ sealed_files = {name: (self.scan_dir / name).read_bytes() for name in CANONICAL_FILES}
+ with self.assertRaises(FINALIZER.ContractError):
+ FINALIZER._prepare_scan_finalization(self.scan_dir, allow_missing_writeups=True)
+ self.assertEqual(
+ {name: (self.scan_dir / name).read_bytes() for name in CANONICAL_FILES}, sealed_files
+ )
def test_finalize_requires_hardening_portfolio_to_be_regular_scan_local_file(self) -> None:
portfolio_path = "hardening/hardening.md"
@@ -2062,10 +2073,8 @@ The extraction root is not enforced.
with self.assertRaisesRegex(FINALIZER.ContractError, "missing from sealed artifacts"):
FINALIZER.finalize_scan(self.scan_dir)
- warnings: list[str] = []
with self.assertRaisesRegex(FINALIZER.ContractError, "missing from sealed artifacts"):
- FINALIZER._prepare_scan_finalization(self.scan_dir, completion_warnings=warnings)
- self.assertEqual(warnings, [])
+ FINALIZER._prepare_scan_finalization(self.scan_dir, recover_unsealed=True)
def test_fingerprint_survives_line_movement_and_file_rename(self) -> None:
renamed = copy.deepcopy(self.finding)
@@ -2160,18 +2169,19 @@ The extraction root is not enforced.
"Lower if the input is constrained before parsing.",
]
self.write_scan()
- warnings: list[str] = []
- prepared = FINALIZER._prepare_scan_finalization(self.scan_dir, completion_warnings=warnings)
+ prepared = FINALIZER._prepare_scan_finalization(self.scan_dir, recover_unsealed=True)
- finding = prepared[3]["findings"][0]
+ finding = prepared.findings["findings"][0]
self.assertEqual(
finding["severity"]["changeConditions"],
"Raise if the vulnerable path becomes internet-reachable. "
"Lower if the input is constrained before parsing.",
)
- self.assertEqual(warnings, ["Recovered finding 1: normalized severity change conditions."])
- self.assertEqual(prepared[4]["completeness"], "complete")
+ self.assertEqual(
+ prepared.warnings, ["Recovered finding 1: normalized severity change conditions."]
+ )
+ self.assertEqual(prepared.coverage["completeness"], "complete")
@pytest.mark.cross_platform
def test_recovery_ranks_legacy_and_canonical_code_evidence_equally(self) -> None:
@@ -2197,17 +2207,16 @@ The extraction root is not enforced.
second["root_cause"] = None
self.findings["findings"] = [first, second]
self.write_scan()
- warnings: list[str] = []
prepared = FINALIZER._prepare_scan_finalization(
- self.scan_dir, completion_warnings=warnings
+ self.scan_dir, recover_unsealed=True
)
- self.assertEqual(prepared[3]["findings"][0]["summary"], "SECOND")
- self.assertIsNone(prepared[3]["findings"][0]["root_cause"])
- self.assertEqual(prepared[3]["findings"][0][evidence_field], [evidence])
+ self.assertEqual(prepared.findings["findings"][0]["summary"], "SECOND")
+ self.assertIsNone(prepared.findings["findings"][0]["root_cause"])
+ self.assertEqual(prepared.findings["findings"][0][evidence_field], [evidence])
self.assertEqual(
- warnings,
+ prepared.warnings,
["Recovered finding 2: retained stronger duplicate logical finding."],
)
@@ -2235,15 +2244,14 @@ The extraction root is not enforced.
second["rootCause"] = root_cause
self.findings["findings"] = [first, second]
self.write_scan()
- warnings: list[str] = []
prepared = FINALIZER._prepare_scan_finalization(
- self.scan_dir, completion_warnings=warnings
+ self.scan_dir, recover_unsealed=True
)
- self.assertEqual(prepared[3]["findings"][0]["summary"], "SECOND")
+ self.assertEqual(prepared.findings["findings"][0]["summary"], "SECOND")
self.assertEqual(
- warnings,
+ prepared.warnings,
["Recovered finding 2: retained stronger duplicate logical finding."],
)
@@ -2252,16 +2260,15 @@ The extraction root is not enforced.
with self.subTest(change_conditions=repr(change_conditions)):
self.findings["findings"][0]["severity"]["changeConditions"] = change_conditions
self.write_scan()
- warnings: list[str] = []
prepared = FINALIZER._prepare_scan_finalization(
- self.scan_dir, completion_warnings=warnings
+ self.scan_dir, recover_unsealed=True
)
- self.assertEqual(prepared[3]["findings"], [])
- self.assertEqual(prepared[4]["completeness"], "partial")
- self.assertEqual(len(warnings), 1)
- self.assertIn("severity.changeConditions", warnings[0])
+ self.assertEqual(prepared.findings["findings"], [])
+ self.assertEqual(prepared.coverage["completeness"], "partial")
+ self.assertEqual(len(prepared.warnings), 1)
+ self.assertIn("severity.changeConditions", prepared.warnings[0])
def test_unsealed_invalid_anchor_stays_strict_without_recovery(self) -> None:
self.findings["findings"][0]["identity"]["anchor"] = "Invalid Anchor"
@@ -2279,18 +2286,20 @@ The extraction root is not enforced.
with self.subTest(field=field, value=value):
self.findings["findings"][0][field] = value
self.write_scan()
- warnings: list[str] = []
- _, _, _, findings, coverage, _, _ = FINALIZER._prepare_scan_finalization(
+ prepared = FINALIZER._prepare_scan_finalization(
self.scan_dir,
- completion_warnings=warnings,
+ recover_unsealed=True,
)
- self.assertEqual(len(findings["findings"]), 1)
- self.assertNotIn(field, findings["findings"][0])
- self.assertEqual(coverage["completeness"], "complete")
+ self.assertEqual(len(prepared.findings["findings"]), 1)
+ self.assertNotIn(field, prepared.findings["findings"][0])
+ self.assertEqual(prepared.coverage["completeness"], "complete")
self.assertTrue(
- any(warning.startswith(f"Skipped malformed {field}") for warning in warnings)
+ any(
+ warning.startswith(f"Skipped malformed {field}")
+ for warning in prepared.warnings
+ )
)
self.findings["findings"][0].pop(field)
@@ -2299,18 +2308,19 @@ The extraction root is not enforced.
finding["remediationTests"] = ["Reject unsafe archive paths."]
finding["preventiveControls"] = ["Validate every archive path."]
self.write_scan()
- warnings: list[str] = []
- _, _, _, findings, _, _, _ = FINALIZER._prepare_scan_finalization(
+ prepared = FINALIZER._prepare_scan_finalization(
self.scan_dir,
- completion_warnings=warnings,
+ recover_unsealed=True,
)
- self.assertEqual(findings["findings"][0]["remediationTests"], finding["remediationTests"])
self.assertEqual(
- findings["findings"][0]["preventiveControls"], finding["preventiveControls"]
+ prepared.findings["findings"][0]["remediationTests"], finding["remediationTests"]
)
- self.assertFalse(warnings)
+ self.assertEqual(
+ prepared.findings["findings"][0]["preventiveControls"], finding["preventiveControls"]
+ )
+ self.assertFalse(prepared.warnings)
def test_recovery_publishes_findings_without_unsafe_deferred_paths(self) -> None:
valid = {"id": "review", "reason": "Repository review is incomplete.", "paths": ["."]}
@@ -2322,9 +2332,8 @@ The extraction root is not enforced.
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
+ self.scan_dir, completion_binding=binding, recover_unsealed=True
)
manifest, findings, coverage = FINALIZER._write_prepared_scan_finalization(prepared)
@@ -2336,7 +2345,7 @@ The extraction root is not enforced.
self.assertTrue(
any(
"Skipped malformed deferred coverage item 1" in warning
- for warning in warnings
+ for warning in prepared.warnings
)
)
self.assertEqual(self.read_json("findings.json"), findings)
@@ -3143,6 +3152,61 @@ def test_schema_numeric_types_do_not_accept_booleans(expected, value) -> None:
FINALIZER._validate_schema_node(True, schema, "value")
[email protected](os.name == "nt", reason="POSIX symlinks and file permissions")
+ "kind", ["unsafe", "symlink", "dangling-symlink", "parent-symlink", "directory", "unreadable"]
+)
+def test_missing_writeup_recovery_rejects_other_file_errors(tmp_path, kind):
+ scan_dir = tmp_path / "scan"
+ scan_dir.mkdir()
+ report = scan_dir / "findings" / "report.md"
+ report.parent.mkdir()
+ outside = tmp_path / "outside.md"
+ outside.write_text("# Outside the scan\n")
+ report_path = "findings/report.md"
+ if kind == "unsafe":
+ report_path = "../outside.md"
+ elif kind == "symlink":
+ report.symlink_to(outside)
+ elif kind == "dangling-symlink":
+ report.symlink_to(report.parent / "missing.md")
+ elif kind == "parent-symlink":
+ report.parent.rmdir()
+ report.parent.symlink_to(tmp_path, target_is_directory=True)
+ elif kind == "directory":
+ report.mkdir()
+ else:
+ if os.geteuid() == 0:
+ pytest.skip("root can read files without permission bits")
+ report.write_text("# Unreadable writeup\n")
+ report.chmod(0)
+ findings = {"findings": [{"writeup": {"reportPath": report_path}}]}
+ original = copy.deepcopy(findings)
+ with pytest.raises(FINALIZER.ContractError):
+ FINALIZER._prepare_derived_writeups(scan_dir, findings, allow_missing=True)
+ assert findings == original
+
+
[email protected]("error_code", [2, 3, 5, 22, 32, 33])
+def test_windows_writeup_recovery_only_omits_missing_files(tmp_path, monkeypatch, error_code):
+ backend = windows_file_backend()
+ windows_error = load_script("windows_scan_local_files").WindowsScanLocalFileError
+ backend.open_read_fd.side_effect = windows_error(error_code, "Synthetic Windows file error")
+ monkeypatch.setattr(FINALIZER.os, "supports_dir_fd", set())
+ monkeypatch.setattr(FINALIZER, "_is_windows", lambda: True)
+ monkeypatch.setattr(FINALIZER, "_windows_scan_local_files", lambda: backend)
+ findings = {"findings": [{"writeup": {"reportPath": "findings/report.md"}}]}
+ if error_code in {2, 3}:
+ warnings = FINALIZER._prepare_derived_writeups(tmp_path, findings, allow_missing=True)
+ assert findings == {"findings": [{}]}
+ assert len(warnings) == 1
+ else:
+ with pytest.raises(FINALIZER.ContractError):
+ FINALIZER._prepare_derived_writeups(tmp_path, findings, allow_missing=True)
+ assert "writeup" in findings["findings"][0]
+
+
def test_schema_references_preserve_constraints_siblings_and_cycle_errors() -> None:
root = {"$defs": {"text": {"type": "string", "minLength": 1}}}
reference = {"$ref": "#/$defs/text"}
diff --git a/plugins/codex-security/tests/test_saved_deferred_identity.py b/plugins/codex-security/tests/test_saved_deferred_identity.py
index 31bfacf8e..031a09431 100644
--- a/plugins/codex-security/tests/test_saved_deferred_identity.py
+++ b/plugins/codex-security/tests/test_saved_deferred_identity.py
@@ -137,7 +137,7 @@ def cancel_and_preserve(monkeypatch, saved_results, state, codex_home, scan_dir,
prepared_coverage = []
def fail_publication(prepared, *, projection_warnings=None):
- prepared_coverage.append(prepared[4])
+ prepared_coverage.append(prepared.coverage)
raise OSError("injected publication failure")
with monkeypatch.context() as patch:
diff --git a/plugins/codex-security/tests/test_workbench_checkpoint_heads.py b/plugins/codex-security/tests/test_workbench_checkpoint_heads.py
index 633a8b237..5e6a8d006 100644
--- a/plugins/codex-security/tests/test_workbench_checkpoint_heads.py
+++ b/plugins/codex-security/tests/test_workbench_checkpoint_heads.py
@@ -913,7 +913,7 @@ def test_parent_head_selection_matches_frozen_publication_retry(
first = []
def fail_publication(prepared, *, projection_warnings=None):
- first.append(copy.deepcopy((prepared[3], prepared[4])))
+ first.append(copy.deepcopy((prepared.findings, prepared.coverage)))
raise OSError("injected stopped publication failure")
with monkeypatch.context() as patch:
diff --git a/plugins/codex-security/tests/test_workbench_standard_deep_results.py b/plugins/codex-security/tests/test_workbench_standard_deep_results.py
index d49a1fc91..0da4f6278 100644
--- a/plugins/codex-security/tests/test_workbench_standard_deep_results.py
+++ b/plugins/codex-security/tests/test_workbench_standard_deep_results.py
@@ -774,6 +774,7 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources(
state_dir, codex_home, target, scan_dir, scan_id = deep_scan_fixture(tmp_path)
worker_id, result_path = accepted_standard_worker(state_dir, codex_home, scan_dir, scan_id)
finding = standard_finding(tmp_path, scan_id, target)
+ finding["severity"]["changeConditions"] = ["Raise if the service becomes internet-reachable."]
checkpoint = saved_draft(scan_id, findings=[finding], completeness="partial")
write_checkpoint(result_path.parent / "checkpoints", checkpoint)
result_path.write_text("{incomplete")
@@ -816,6 +817,9 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources(
)["scan"]
assert preserved["findingCount"] == 1
assert preserved["findings"][0]["locations"][0]["startLine"] != 91
+ assert preserved["findings"][0]["severity"]["changeConditions"] == (
+ "Raise if the service becomes internet-reachable."
+ )
assert json.loads((scan_dir / "scan-manifest.json").read_text())["scan"]["status"] == "canceled"
with sqlite3.connect(state_dir / "workbench.sqlite3") as connection:
warnings = json.loads(
@@ -824,6 +828,8 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources(
).fetchone()[0]
)
assert not any("result publication needs follow-up" in warning for warning in warnings)
+ assert "Recovered finding 1: normalized severity change conditions." in warnings
+ assert preserved["warnings"] == warnings
@pytest.mark.parametrize("deep_status", ["failed", "interrupted"])
@@ -2466,7 +2472,7 @@ def test_recovery_rejects_closures_that_would_discard_saved_evidence(
)
assert documents is not None
prepared = workbench_saved_results._prepare_scan_finalization(
- scan_dir, completion_binding=binding, completion_warnings=[], draft_documents=documents
+ scan_dir, completion_binding=binding, recover_unsealed=True, draft_documents=documents
)
workbench_saved_results._write_prepared_scan_finalization(prepared)
recovered = json.loads((scan_dir / "coverage.json").read_text())