OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
#!/usr/bin/env python3
"""Stage the APKs from a verified apko builder lock for an offline Melange build."""
import argparse
import base64
import hashlib
import json
import re
import tempfile
from pathlib import Path
from urllib.request import HTTPRedirectHandler, build_opener
ARCH = "x86_64"
REPO = "https://packages.wolfi.dev/os/" + ARCH
class NoRedirect(HTTPRedirectHandler):
"""Keep the APK downloader on the exact URLs recorded in the builder lock."""
def redirect_request(self, *args):
return None # Only fetch the exact URLs in the lock.
def stage_package(pkg, directory, fetch):
"""Write one APK into the staging directory, checking each locked byte range.
Args:
pkg (dict): Package record from the apko lock, including component checksums.
directory (Path): Existing staging directory for x86_64 APKs.
fetch (callable): Open the package URL with a timeout and return a binary stream.
Raises:
ValueError: The source, architecture, byte ranges, or digests differ from the lock.
"""
name, version = pkg["name"], pkg["version"]
filename = f"{name}-{version}.apk"
if not all(re.fullmatch(r"[a-zA-Z0-9][a-zA-Z0-9.+_~-]*", s) for s in (name, version)):
raise ValueError(f"Invalid package name or version: {filename}")
if pkg["architecture"] != ARCH or pkg["url"] != f"{REPO}/{filename}":
raise ValueError(f"Unexpected package source or architecture: {filename}")
with (directory / filename).open("xb") as dest, fetch(pkg["url"], timeout=60) as source:
offset = 0
for part, algorithm in (("signature", "sha1"), ("control", "sha1"), ("data", "sha256")):
record = pkg[part]
if part == "signature" and record == {"range": "", "checksum": ""}:
continue
match = re.fullmatch(r"bytes=([0-9]+)-([0-9]+)", record["range"])
if not match or int(match[1]) != offset or int(match[2]) < offset:
raise ValueError(f"{filename}: invalid {part} range {record['range']!r}")
length = int(match[2]) + 1 - offset
block = source.read(length)
digest = base64.b64encode(hashlib.new(algorithm, block).digest()).decode("ascii")
if len(block) != length or f"{algorithm}-{digest}" != record["checksum"]:
raise ValueError(f"{filename}: {part} differs from builder lock")
dest.write(block)
offset += length
if source.read(1):
raise ValueError(f"{filename}: bytes beyond locked ranges")
def snapshot(lock, output, fetch):
"""Publish the locked APKs under output/x86_64 after every package verifies.
Args:
lock (dict): Nonempty apko v1 builder lock.
output (Path): New or empty repository directory.
fetch (callable): URL opener passed to stage_package for each locked package.
Raises:
ValueError: The lock or destination is invalid, or a package fails verification.
"""
if lock["version"] != "v1" or not lock["contents"]["packages"]:
raise ValueError("Expected a nonempty apko v1 builder lock")
output.mkdir(parents=True, exist_ok=True)
if output.is_symlink() or any(output.iterdir()):
raise ValueError("Builder repository must be a new or empty directory")
with tempfile.TemporaryDirectory(dir=output) as staging:
packages = Path(staging) / ARCH
packages.mkdir()
for pkg in lock["contents"]["packages"]:
stage_package(pkg, packages, fetch)
packages.rename(output / ARCH) # Publish only after the entire lock verifies.
if __name__ == "__main__":
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("lock", type=Path)
parser.add_argument("repository", type=Path)
args = parser.parse_args()
try:
snapshot(json.loads(args.lock.read_bytes()), args.repository, build_opener(NoRedirect()).open)
except (KeyError, ValueError, OSError) as exc:
parser.exit(1, f"Could not stage builder repository: {exc}\n")