778 lines
31 KiB
Python
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()
|