File size: 5,836 Bytes
cad04d1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | """Prepare and run pip-audit against every installable runtime extra."""
from __future__ import annotations
import argparse
from collections.abc import Sequence
from pathlib import Path
import re
import subprocess
import sys
import tomllib
from packaging.requirements import InvalidRequirement, Requirement
VULNERABILITY_ID_RE = re.compile(
r"(?:"
r"CVE-[0-9]{4}-[0-9]{4,}"
r"|GHSA-[23456789cfghjmpqrvwx]{4}-[23456789cfghjmpqrvwx]{4}-"
r"[23456789cfghjmpqrvwx]{4}"
r"|PYSEC-[0-9]{4}-[0-9]+"
r")"
)
class AuditInputError(ValueError):
"""Raised when audit input is unsafe or malformed."""
def _validate_requirement(value: object, source: str) -> str:
if not isinstance(value, str):
raise AuditInputError(f"{source} must be a requirement string")
requirement = value.strip()
if not requirement:
raise AuditInputError(f"{source} must not be empty")
if any(character in requirement for character in ("\0", "\r", "\n")):
raise AuditInputError(f"{source} must contain exactly one requirement")
if requirement.startswith("-"):
raise AuditInputError(f"{source} must not contain a requirement-file directive")
try:
parsed = Requirement(requirement)
except InvalidRequirement as exc:
raise AuditInputError(f"{source} is not a valid packaging requirement") from exc
if parsed.url is not None:
raise AuditInputError(f"{source} must not use a direct URL reference")
return requirement
def _requirement_list(value: object, source: str) -> tuple[str, ...]:
if not isinstance(value, list):
raise AuditInputError(f"{source} must be an array")
return tuple(
_validate_requirement(requirement, f"{source}[{index}]")
for index, requirement in enumerate(value)
)
def collect_runtime_requirements(manifest_path: Path) -> tuple[str, ...]:
"""Return validated base dependencies plus every optional extra except dev."""
with manifest_path.open("rb") as stream:
document = tomllib.load(stream)
project = document.get("project")
if not isinstance(project, dict):
raise AuditInputError("pyproject.toml must contain a [project] table")
requirements = list(_requirement_list(project.get("dependencies", []), "project.dependencies"))
optional = project.get("optional-dependencies", {})
if not isinstance(optional, dict):
raise AuditInputError("project.optional-dependencies must be a table")
if any(not isinstance(name, str) for name in optional):
raise AuditInputError("optional dependency names must be strings")
for extra in sorted(name for name in optional if name != "dev"):
requirements.extend(
_requirement_list(optional[extra], f"project.optional-dependencies.{extra}")
)
if not requirements:
raise AuditInputError("runtime dependency manifest is empty")
return tuple(dict.fromkeys(requirements))
def parse_ignore_file(ignore_path: Path | None) -> tuple[str, ...]:
"""Parse an optional comments-friendly vulnerability ignore file."""
if ignore_path is None or not ignore_path.exists():
return ()
if not ignore_path.is_file():
raise AuditInputError(f"{ignore_path} must be a regular file")
identifiers: list[str] = []
for line_number, raw_line in enumerate(
ignore_path.read_text(encoding="utf-8").splitlines(),
start=1,
):
identifier = raw_line.partition("#")[0].strip()
if not identifier:
continue
if VULNERABILITY_ID_RE.fullmatch(identifier) is None:
raise AuditInputError(f"{ignore_path}:{line_number}: invalid vulnerability ID")
identifiers.append(identifier)
return tuple(dict.fromkeys(identifiers))
def build_pip_audit_argv(
requirements_path: Path,
ignore_ids: Sequence[str],
) -> tuple[str, ...]:
"""Build a subprocess argv without shell interpolation."""
argv = [
sys.executable,
"-m",
"pip_audit",
"--strict",
"--progress-spinner",
"off",
"--requirement",
str(requirements_path),
]
for identifier in ignore_ids:
if VULNERABILITY_ID_RE.fullmatch(identifier) is None:
raise AuditInputError("invalid vulnerability ID passed to pip-audit")
argv.extend(("--ignore-vuln", identifier))
return tuple(argv)
def prepare_audit(
manifest_path: Path,
requirements_output: Path,
ignore_path: Path | None,
) -> tuple[str, ...]:
"""Write validated requirements and return the pip-audit argv."""
requirements = collect_runtime_requirements(manifest_path)
requirements_output.write_text(
"".join(f"{requirement}\n" for requirement in requirements),
encoding="utf-8",
)
ignore_ids = parse_ignore_file(ignore_path)
return build_pip_audit_argv(requirements_output, ignore_ids)
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--manifest", type=Path, default=Path("pyproject.toml"))
parser.add_argument("--requirements-output", type=Path, required=True)
parser.add_argument(
"--ignore-file",
type=Path,
help="optional UTF-8 file containing one CVE, GHSA, or PYSEC ID per line",
)
return parser
def main(argv: Sequence[str] | None = None) -> int:
parser = _parser()
args = parser.parse_args(argv)
try:
command = prepare_audit(
args.manifest,
args.requirements_output,
args.ignore_file,
)
except (AuditInputError, OSError, tomllib.TOMLDecodeError) as exc:
parser.error(str(exc))
return subprocess.run(command, check=False).returncode
if __name__ == "__main__":
raise SystemExit(main())
|