import hashlib import importlib.util import io import json import os import shutil import subprocess import tarfile import tempfile import unittest from unittest import mock from datetime import datetime, timedelta, timezone from pathlib import Path SCRIPT = Path(__file__).parents[2] / "scripts" / "check-image-scan.py" def load_checker(): spec = importlib.util.spec_from_file_location("check_image_scan", SCRIPT) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module IMAGE_ID = "sha256:" + "a" * 64 CID = "0123456789ab" EXPECTED_PACKAGES = ( "base-files", "libc6", "libgcc-s1", "gcc-12-base", "bash", "dash", "libtinfo6", "libselinux1", "libpcre2-8-0", "coreutils", ) MANIFEST_PATH = "/usr/share/crank/runtime-inventory.tsv" DPKG_STATUS_PATH = "/var/lib/dpkg/status" FAKE_DOCKER = '''#!/usr/bin/env python3 import json import os import sys args = sys.argv[1:] log = os.environ.get("FAKE_DOCKER_LOG") if log: with open(log, "a", encoding="utf-8") as stream: stream.write(json.dumps(args) + "\\n") if not args: sys.exit(2) command = args[0] if command == "create": rc = int(os.environ.get("FAKE_DOCKER_CREATE_RC", "0")) if rc != 0: sys.stderr.write("create failed\\n") sys.exit(rc) sys.stdout.write(os.environ.get("FAKE_DOCKER_CID", "deadbeefcafe") + "\\n") sys.exit(0) if command == "export": rc = int(os.environ.get("FAKE_DOCKER_EXPORT_RC", "0")) if rc != 0: sys.stderr.write("export failed\\n") sys.exit(rc) with open(os.environ["FAKE_DOCKER_TAR"], "rb") as stream: sys.stdout.buffer.write(stream.read()) sys.exit(0) if command == "rm": sys.exit(0) sys.exit(2) ''' def sha256(data: bytes) -> str: return hashlib.sha256(data).hexdigest() def build_tar(entries) -> bytes: buffer = io.BytesIO() with tarfile.open(fileobj=buffer, mode="w") as archive: for kind, path, value in entries: info = tarfile.TarInfo(path.lstrip("/")) info.mode = 0o644 info.uid = 0 info.gid = 0 if kind == "file": data = value if isinstance(value, bytes) else value.encode("utf-8") info.type = tarfile.REGTYPE info.size = len(data) archive.addfile(info, io.BytesIO(data)) elif kind == "symlink": info.type = tarfile.SYMTYPE info.linkname = value info.size = 0 archive.addfile(info) elif kind == "dir": # Emulate Go's tar writer, which marks directories with a slash. info.name = path.lstrip("/") + "/" info.type = tarfile.DIRTYPE info.size = 0 archive.addfile(info) else: raise AssertionError(f"unknown entry kind {kind}") return buffer.getvalue() def build_status(packages, versions=None) -> str: versions = versions or {} blocks = [] for name in packages: blocks.append( "Package: {name}\n" "Status: install ok installed\n" "Architecture: amd64\n" "Version: {version}\n" "Description: test package\n".format( name=name, version=versions.get(name, "6.4-4" if name == "libtinfo6" else "1.2.3-1") ) ) return "\n".join(blocks) def runtime_image( *, manifest_text=None, status_text=None, extra_entries=(), drop_manifest=False, drop_status=False, drop_files=(), ): entries = [] manifest_lines = [] for package in EXPECTED_PACKAGES: path = f"/usr/share/crank/{package}.payload" data = f"{package} payload\n".encode("utf-8") entries.append(("file", path, data)) manifest_lines.append(f"{package}\t{path}\t{sha256(data)}") entries.append(("symlink", "/usr/bin/sh", "dash")) manifest_lines.append("dash\t/usr/bin/sh\tdash") entries.append(("dir", "/usr/bin", None)) entries.append(("dir", "/usr/share/crank", None)) for path in ("/etc/passwd", "/etc/group", "/etc/nsswitch.conf"): data = f"{path} generated\n".encode("utf-8") entries.append(("file", path, data)) manifest_lines.append(f"runtime-generated\t{path}\t{sha256(data)}") entries.extend(tuple(extra_entries)) if manifest_text is None: manifest_text = "".join(line + "\n" for line in manifest_lines) if not drop_manifest: entries.append(("file", MANIFEST_PATH, manifest_text.encode("utf-8"))) if status_text is None: status_text = build_status(EXPECTED_PACKAGES) if not drop_status: entries.append(("file", DPKG_STATUS_PATH, status_text.encode("utf-8"))) kept = set(drop_files) return [entry for entry in entries if entry[1] not in kept] def vulnerability( vulnerability_id="CVE-2024-9999", package="libc6", installed="1.2.3-1", severity="HIGH", fixed=None, status="affected", ): record = { "VulnerabilityID": vulnerability_id, "PkgName": package, "InstalledVersion": installed, "Severity": severity, "Status": status, "Title": "test finding", } if fixed is not None: record["FixedVersion"] = fixed return record def make_report( *, image_id=IMAGE_ID, artifact_type="container_image", os_family="debian", os_name="12.11", include_os=True, include_metadata=True, include_results=True, packages=None, vulnerabilities=None, results=None, ): if packages is None: packages = [ {"ID": f"{name}@1.2.3-1", "Name": name, "Version": "6.4-4" if name == "libtinfo6" else "1.2.3-1", "Arch": "amd64"} for name in EXPECTED_PACKAGES ] result = { "Target": "crank/test", "Class": "os-pkgs", "Type": os_family, "Packages": packages, } if vulnerabilities is not None: result["Vulnerabilities"] = vulnerabilities report = { "SchemaVersion": 2, "ArtifactName": "crank/test", "ArtifactType": artifact_type, } if include_metadata: metadata = {"ImageID": image_id, "RepoTags": ["crank/test:ci"]} if include_os: metadata["OS"] = {"Family": os_family, "Name": os_name} report["Metadata"] = metadata if include_results: report["Results"] = [result] if results is None else results return report class ImageScanCheckerTests(unittest.TestCase): def run_check( self, *, report=None, report_raw=None, db_updated=None, db_raw=None, tar_bytes=None, image_id=IMAGE_ID, extra_env=None, decision_alias=None, ): root = Path(tempfile.mkdtemp()) self.addCleanup(shutil.rmtree, root, ignore_errors=True) report_path = root / "report.json" if report_raw is not None: report_path.write_text(report_raw, encoding="utf-8") else: report_path.write_text(json.dumps(report), encoding="utf-8") db_path = root / "db.json" if db_raw is not None: db_path.write_text(db_raw, encoding="utf-8") else: updated = db_updated if db_updated is not None else datetime.now(timezone.utc) db_path.write_text( json.dumps({"Version": 2, "UpdatedAt": updated.isoformat()}), encoding="utf-8", ) tar_path = root / "image.tar" if tar_bytes is None: tar_bytes = build_tar(runtime_image()) tar_path.write_bytes(tar_bytes) bin_dir = root / "bin" bin_dir.mkdir() docker = bin_dir / "docker" docker.write_text(FAKE_DOCKER, encoding="utf-8") docker.chmod(0o755) log = root / "docker.jsonl" env = os.environ.copy() env["PATH"] = f"{bin_dir}:{env['PATH']}" env["FAKE_DOCKER_TAR"] = str(tar_path) env["FAKE_DOCKER_CID"] = CID env["FAKE_DOCKER_LOG"] = str(log) if extra_env: env.update(extra_env) decision_path = root / "decision.json" if decision_alias == "report": decision_path = report_path elif decision_alias == "db": decision_path = db_path elif decision_alias == "symlink": decision_path.symlink_to(report_path) result = subprocess.run( [ "python3", str(SCRIPT), "--report", str(report_path), "--image-id", image_id, "--db-metadata", str(db_path), "--decision", str(decision_path), ], text=True, capture_output=True, env=env, check=False, ) decision = None if decision_path.exists(): decision = json.loads(decision_path.read_text(encoding="utf-8")) calls = [] if log.exists(): calls = [ json.loads(line) for line in log.read_text(encoding="utf-8").splitlines() if line.strip() ] return result, decision, root, calls # ------------------------------------------------------------------ pass def test_decision_alias_never_changes_protected_input(self): report = make_report() for alias in ("report", "db", "symlink"): with self.subTest(alias=alias): result, _, root, _ = self.run_check(report=report, decision_alias=alias) self.assertEqual(result.returncode, 2) self.assertEqual(json.loads((root / "report.json").read_text()), report) self.assertEqual(json.loads((root / "db.json").read_text())["Version"], 2) def test_malformed_package_records_are_evidence_errors(self): for package in (None, {}, {"Name": ""}, {"Name": "bash"}, {"Name": "bash", "Version": 3}): with self.subTest(package=package): result, decision, _, _ = self.run_check(report=make_report(os_family="alpine", os_name="3.23", packages=[package])) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_package_versions_must_match_exported_status(self): report = make_report() report["Results"][0]["Packages"][0]["Version"] = "999.0" result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_exception_requires_actual_libtinfo_version(self): report = make_report(vulnerabilities=[vulnerability(vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4")]) report["Results"][0]["Packages"] = [dict(p, Version="9.9") if p["Name"] == "libtinfo6" else p for p in report["Results"][0]["Packages"]] tar = build_tar(runtime_image(status_text=build_status(EXPECTED_PACKAGES, {"libtinfo6": "9.9"}))) result, decision, _, _ = self.run_check(report=report, tar_bytes=tar) self.assertEqual(result.returncode, 1) self.assertEqual(decision["exceptions"], []) def test_debian_129_is_not_the_debian12_exception(self): report = make_report(os_name="129", vulnerabilities=[vulnerability(vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4")]) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 1) self.assertEqual(decision["exceptions"], []) def test_duplicate_json_keys_are_evidence_errors(self): payload = json.dumps(make_report()) payload = payload[:-1] + ',"ArtifactType":"container_image"}' result, decision, _, _ = self.run_check(report_raw=payload) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_invalid_timezone_produces_error_decision(self): result, decision, _, _ = self.run_check(report=make_report(), db_raw='{"Version":2,"UpdatedAt":"2026-10-10T00:00:00+99:99"}') self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_unsupported_db_schema_is_evidence_error(self): for version in (None, True, "2", 3): with self.subTest(version=version): metadata = {"Version": version, "UpdatedAt": datetime.now(timezone.utc).isoformat()} result, decision, _, _ = self.run_check(report=make_report(), db_raw=json.dumps(metadata)) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_manifest_cannot_omit_a_transferred_file(self): entries = runtime_image() changed = [] for kind, path, value in entries: if path == MANIFEST_PATH: value = "\n".join(value.decode().splitlines()[1:]).encode() + b"\n" changed.append((kind, path, value)) result, decision, _, _ = self.run_check(report=make_report(), tar_bytes=build_tar(changed)) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_undeclared_runtime_file_is_evidence_error(self): tar = build_tar(runtime_image(extra_entries=[("file", "/usr/lib/undeclared.so", b"file")])) result, decision, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2) self.assertEqual(decision["status"], "error") def test_unexpected_dpkg_package_is_evidence_error(self): tar = build_tar(runtime_image(status_text=build_status(EXPECTED_PACKAGES + ("unexpected",)))) result, decision, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) self.assertEqual(decision["status"], "error") def test_unexpected_trivy_package_is_evidence_error(self): report = make_report() report["Results"][0]["Packages"].append({"Name": "unexpected", "Version": "1"}) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 2, result.stderr) self.assertEqual(decision["status"], "error") def test_stalled_export_has_a_deadline(self): module = load_checker() with tempfile.TemporaryDirectory() as directory: docker = Path(directory) / "docker" docker.write_text("#!/usr/bin/env python3\nimport time\ntime.sleep(2)\n") docker.chmod(0o755) with mock.patch.dict(os.environ, {"PATH": directory + ":" + os.environ["PATH"]}), \ mock.patch.object(module, "DOCKER_TIMEOUT_SECONDS", 0.1): with self.assertRaisesRegex(module.EvidenceError, "timed out"): module._docker_export(CID) def test_clean_runtime_image_passes_and_verifies_real_files(self): result, decision, _, calls = self.run_check(report=make_report()) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(decision["status"], "pass") self.assertEqual(decision["exit_code"], 0) self.assertIn(["create", "--entrypoint", "/bin/sh", IMAGE_ID], calls) self.assertIn(["export", CID], calls) self.assertIn(["rm", CID], calls) self.assertGreater(decision["runtime_inventory"]["manifest_entries"], 0) def test_narrow_libtinfo_exception_passes_with_image_bound_justification(self): report = make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4", severity="HIGH", ) ] ) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(decision["status"], "pass") self.assertEqual(len(decision["exceptions"]), 1) exception = decision["exceptions"][0] self.assertEqual(exception["vulnerability_id"], "CVE-2025-69720") self.assertEqual(exception["image_id"], IMAGE_ID) self.assertTrue(exception["justification"]) self.assertEqual(decision["high_critical"][0]["disposition"], "excepted") def test_absent_vulnerabilities_with_packages_is_a_valid_empty_result(self): result, decision, _, _ = self.run_check(report=make_report()) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(decision["severity_counts"]["HIGH"], 0) def test_only_medium_low_unknown_findings_pass_and_are_counted(self): report = make_report( vulnerabilities=[ vulnerability(package="libc6", severity="MEDIUM"), vulnerability(package="bash", severity="LOW"), vulnerability(package="dash", severity="UNKNOWN"), ] ) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(decision["severity_counts"]["MEDIUM"], 1) self.assertEqual(decision["severity_counts"]["LOW"], 1) self.assertEqual(decision["severity_counts"]["UNKNOWN"], 1) self.assertEqual(decision["blocking"], []) def test_non_debian_image_skips_runtime_manifest(self): report = make_report( os_family="alpine", os_name="3.24", packages=[{"ID": "musl@1.2", "Name": "musl", "Version": "1.2"}], ) result, decision, _, calls = self.run_check( report=report, tar_bytes=build_tar([("file", "/bin/sh", b"busybox")]) ) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(calls, []) # --------------------------------------------------------------- blocked def test_unfixed_high_is_blocked(self): report = make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2024-0001", package="libc6", severity="HIGH", fixed=None, ) ] ) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 1) self.assertEqual(decision["status"], "blocked") self.assertEqual(len(decision["blocking"]), 1) self.assertEqual(decision["blocking"][0]["vulnerability_id"], "CVE-2024-0001") def test_critical_is_blocked(self): report = make_report( vulnerabilities=[vulnerability(package="bash", severity="CRITICAL")] ) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 1) self.assertEqual(decision["status"], "blocked") def test_libtinfo_exception_is_guarded_by_version_package_and_state(self): guarded_reports = { "wrong_version": make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-3", severity="HIGH", ) ] ), "wrong_package": make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libselinux1", installed="6.4-4", severity="HIGH", ) ] ), "wrong_distribution": make_report( os_name="11.9", vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4", severity="HIGH", ) ] ), } for label, report in guarded_reports.items(): with self.subTest(label=label): result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 1, result.stderr) self.assertEqual(decision["exceptions"], []) def test_libtinfo_exception_blocked_when_ncurses_bin_present(self): report = make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4", severity="HIGH", ) ] ) tar = build_tar( runtime_image(status_text=build_status(EXPECTED_PACKAGES + ("ncurses-bin",))) ) result, decision, _, _ = self.run_check(report=report, tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) self.assertEqual(decision["status"], "error") def test_libtinfo_exception_blocked_when_infocmp_present(self): report = make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4", severity="HIGH", ) ] ) tar = build_tar( runtime_image(extra_entries=[("file", "/usr/bin/infocmp", b"infocmp\n")]) ) result, decision, _, _ = self.run_check(report=report, tar_bytes=tar) self.assertIn(result.returncode, (1, 2), result.stderr) self.assertEqual(decision.get("exceptions", []), []) def test_exception_not_trusted_from_trivy_report_alone(self): report = make_report( vulnerabilities=[ vulnerability( vulnerability_id="CVE-2025-69720", package="libtinfo6", installed="6.4-4", severity="HIGH", ) ] ) tar = build_tar( runtime_image(extra_entries=[("file", "/usr/bin/infocmp", b"infocmp\n")]) ) result, _, _, _ = self.run_check(report=report, tar_bytes=tar) self.assertIn(result.returncode, (1, 2), result.stderr) # ------------------------------------------------------- evidence errors def test_wrong_image_id_is_evidence_error(self): report = make_report(image_id="sha256:" + "b" * 64) result, decision, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 2, result.stderr) self.assertEqual(decision["status"], "error") def test_wrong_artifact_type_is_evidence_error(self): result, _, _, _ = self.run_check(report=make_report(artifact_type="filesystem")) self.assertEqual(result.returncode, 2, result.stderr) def test_malformed_report_is_evidence_error(self): result, _, _, _ = self.run_check(report_raw="{not json") self.assertEqual(result.returncode, 2, result.stderr) def test_missing_results_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(include_results=False) ) self.assertEqual(result.returncode, 2, result.stderr) def test_empty_results_is_evidence_error(self): result, _, _, _ = self.run_check(report=make_report(results=[])) self.assertEqual(result.returncode, 2, result.stderr) def test_missing_os_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(include_os=False) ) self.assertEqual(result.returncode, 2, result.stderr) def test_empty_packages_without_vulnerabilities_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(packages=[], vulnerabilities=None) ) self.assertEqual(result.returncode, 2, result.stderr) def test_missing_packages_key_is_evidence_error(self): report = make_report() del report["Results"][0]["Packages"] result, _, _, _ = self.run_check(report=report) self.assertEqual(result.returncode, 2, result.stderr) def test_unknown_severity_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(vulnerabilities=[vulnerability(severity="MODERATE")]) ) self.assertEqual(result.returncode, 2, result.stderr) def test_stale_db_is_evidence_error(self): updated = datetime.now(timezone.utc) - timedelta(hours=26) result, _, _, _ = self.run_check( report=make_report(), db_updated=updated ) self.assertEqual(result.returncode, 2, result.stderr) def test_future_db_is_evidence_error(self): updated = datetime.now(timezone.utc) + timedelta(minutes=10) result, _, _, _ = self.run_check( report=make_report(), db_updated=updated ) self.assertEqual(result.returncode, 2, result.stderr) def test_malformed_db_metadata_is_evidence_error(self): result, _, _, _ = self.run_check(report=make_report(), db_raw="{") self.assertEqual(result.returncode, 2, result.stderr) def test_missing_manifest_is_evidence_error(self): tar = build_tar(runtime_image(drop_manifest=True)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_missing_dpkg_status_is_evidence_error(self): tar = build_tar(runtime_image(drop_status=True)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_manifest_hash_mismatch_is_evidence_error(self): manifest = ( "base-files\t/usr/share/crank/base-files.payload\t" + "0" * 64 + "\n" ) tar = build_tar(runtime_image(manifest_text=manifest)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_manifest_missing_image_file_is_evidence_error(self): tar = build_tar(runtime_image(drop_files=["/usr/share/crank/bash.payload"])) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_manifest_duplicate_or_unnormalized_paths_are_evidence_errors(self): base = ( "base-files\t/etc/passwd\t" + sha256(b"/etc/passwd generated\n") + "\n" ) cases = { "duplicate": base + base, "unnormalized": "base-files\t/etc/../etc/passwd\t" + "0" * 64 + "\n", "relative": "base-files\tetc/passwd\t" + "0" * 64 + "\n", } for label, manifest in cases.items(): with self.subTest(label=label): tar = build_tar(runtime_image(manifest_text=manifest)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_manifest_with_unexpected_package_label_is_evidence_error(self): manifest = "linux-image\t/usr/bin/bash\t" + "0" * 64 + "\n" tar = build_tar(runtime_image(manifest_text=manifest)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_manifest_listing_its_own_path_is_evidence_error(self): manifest = f"runtime-generated\t{MANIFEST_PATH}\t{'0' * 64}\n" tar = build_tar(runtime_image(manifest_text=manifest)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_missing_expected_package_in_dpkg_is_evidence_error(self): status = build_status( [name for name in EXPECTED_PACKAGES if name != "libgcc-s1"] ) tar = build_tar(runtime_image(status_text=status)) result, _, _, _ = self.run_check(report=make_report(), tar_bytes=tar) self.assertEqual(result.returncode, 2, result.stderr) def test_missing_expected_package_in_trivy_report_is_evidence_error(self): packages = [ {"ID": f"{name}@1.2.3-1", "Name": name, "Version": "1.2.3-1"} for name in EXPECTED_PACKAGES if name != "coreutils" ] result, _, _, _ = self.run_check(report=make_report(packages=packages)) self.assertEqual(result.returncode, 2, result.stderr) def test_docker_create_failure_is_evidence_error(self): result, decision, _, _ = self.run_check( report=make_report(), extra_env={"FAKE_DOCKER_CREATE_RC": "1"} ) self.assertEqual(result.returncode, 2, result.stderr) self.assertEqual(decision["status"], "error") def test_docker_export_failure_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(), extra_env={"FAKE_DOCKER_EXPORT_RC": "1"} ) self.assertEqual(result.returncode, 2, result.stderr) def test_docker_export_malformed_archive_is_evidence_error(self): result, _, _, _ = self.run_check( report=make_report(), tar_bytes=b"not a tar archive" ) self.assertEqual(result.returncode, 2, result.stderr) # ------------------------------------------------------------ assurance def test_tar_path_normalization_handles_directory_slashes_and_traversal(self): module = load_checker() self.assertEqual(module.normalize_tar_path("usr/bin/"), "/usr/bin") self.assertEqual(module.normalize_tar_path("./etc/passwd"), "/etc/passwd") self.assertEqual(module.normalize_tar_path("/lib64"), "/lib64") self.assertIsNone(module.normalize_tar_path("./")) self.assertIsNone(module.normalize_tar_path("/")) for unsafe in ("etc/../../etc/passwd", "usr//bin", "a/./b"): with self.assertRaises(module.EvidenceError): module.normalize_tar_path(unsafe) def test_raw_report_is_not_modified_by_the_gate(self): report = make_report() payload = json.dumps(report) result, _, root, _ = self.run_check(report_raw=payload) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual((root / "report.json").read_text(encoding="utf-8"), payload) def test_decision_written_separately_on_error(self): result, decision, root, _ = self.run_check(report_raw="{broken") self.assertEqual(result.returncode, 2) self.assertTrue((root / "decision.json").exists()) self.assertEqual(decision["status"], "error") self.assertTrue(decision["errors"]) if __name__ == "__main__": unittest.main()