Files
crank/tests/unit/test_check_image_scan.py
bsodfather f685616ae8
CI / Rust Checks (pull_request) Successful in 23m1s
CI / UI Checks (pull_request) Successful in 6s
CI / Community Image Smoke (pull_request) Successful in 7m28s
CI / Frontend E2E (pull_request) Successful in 9m33s
CI / Deploy (pull_request) Skipped
fix(security): minimize runtime images and enforce complete vulnerability scans
2026-10-10 01:41:38 +03:00

778 lines
31 KiB
Python

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()