Bundle FFprobe for macOS in release v0.1.3

This commit is contained in:
Dandaedre 2026-10-20 18:11:41 +02:00
parent 867a7e0b95
commit 45faa4b536
14 changed files with 478 additions and 33 deletions

View File

@ -32,12 +32,14 @@ with quick-start examples and links to detailed documentation in `docs/`.
releases or uploads release binaries. Cross and `rust_realease` are separate,
manually invoked build/release preparation tools.
- `rust-release.toml` builds Windows/Linux with Cross and Apple Silicon/Intel
macOS 13+ with a pinned cargo-zigbuild container. macOS canonical archives
require external FFprobe; named portable bundles remain Windows/Linux only.
macOS 13+ with a pinned cargo-zigbuild container. Portable bundles include
FFprobe on every platform; canonical cargo-binstall archives require external FFprobe.
- `scripts/fetch_ffprobe.py` fetches checksum-verified target FFprobe builds into
ignored `downloads/`. Named release bundles use `scripts/prepare-release.py` with per-target
pins in `crates/pptx-reporter/ffprobe-pins.json`; the standalone packager retains
`--fetch-ffprobe`. Include upstream notices/provenance, never commit binaries.
`--fetch-ffprobe`. `scripts/build_macos_ffprobe.py` builds the macOS dependency
from pinned FFmpeg source, with source, LGPL notices and the recipe bundled.
Include upstream notices/provenance, never commit binaries.
## Repository layout

2
Cargo.lock generated
View File

@ -3190,7 +3190,7 @@ checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958"
[[package]]
name = "pptx-reporter"
version = "0.1.2"
version = "0.1.3"
dependencies = [
"anyhow",
"clap",

View File

@ -4,7 +4,7 @@ default-members = ["crates/pptx-reporter"]
resolver = "3"
[workspace.package]
version = "0.1.2"
version = "0.1.3"
edition = "2024"
license = "MIT"
repository = "https://proxy.dandaedre.com/gitea/Beffroi/beffroi-tools"

View File

@ -13,8 +13,8 @@ On Windows, extract the portable ZIP and open `pptx-reporter-gui.exe`.
Drop a presentation into the window, select report formats, and generate.
Keep the bundled `ffprobe.exe` beside the app.
On macOS 13+, extract the TGZ for Apple Silicon (`aarch64`) or Intel (`x86_64`)
and run `./pptx-reporter-gui`. Supply FFprobe beside the app or on PATH.
On macOS 13+, extract the portable ZIP for Apple Silicon (`aarch64`) or Intel
(`x86_64`) and run `./pptx-reporter-gui`. FFprobe is included; keep it beside the app.
See [macOS release details](docs/releases.md#macos).
To run from source:

View File

@ -8,5 +8,15 @@
"release": "autobuild-2026-10-20-13-08",
"asset": "ffmpeg-n9.0.2-29-g6dfaba896f-linux64-lgpl-9.0.tar.xz",
"sha256": "5ae5939260c72671383f0a0d8785695bfe06c94c27d4daac2e63eb8576417927"
},
"aarch64-apple-darwin": {
"release": "9.0.2",
"asset": "ffmpeg-9.0.2.tar.xz",
"sha256": "8c3850283eb25fa026482078a04051e0be17347b09ef81a0849bec15a96e002e"
},
"x86_64-apple-darwin": {
"release": "9.0.2",
"asset": "ffmpeg-9.0.2.tar.xz",
"sha256": "8c3850283eb25fa026482078a04051e0be17347b09ef81a0849bec15a96e002e"
}
}

View File

@ -0,0 +1,28 @@
PPTX Reporter — portable edition
Extract the entire archive before starting. Keep ffprobe beside the applications
and keep the LICENSES directory. No separate FFmpeg, Python, PowerPoint or PDF
compiler installation is needed.
Windows: open pptx-reporter-gui.exe.
Linux: run ./pptx-reporter-gui from the extracted folder.
macOS 13+: choose Apple Silicon (aarch64) or Intel (x86_64), then open Terminal
in the extracted folder and run ./pptx-reporter-gui.
Drop a PowerPoint presentation into the window, choose your report formats and
generate the reports. Original presentations are never modified.
Command line:
./pptx-reporter presentation.pptx --report all
On Windows, use pptx-reporter.exe instead.
macOS: if Gatekeeper blocks this unsigned download, verify that you trust the
release, open Terminal in the extracted folder, then run:
xattr -d com.apple.quarantine pptx-reporter pptx-reporter-gui ffprobe
chmod +x pptx-reporter pptx-reporter-gui ffprobe
./pptx-reporter-gui
An "attribute not found" message means that file is already unquarantined.
The quarantine commands do not require sudo for files you own.
Mac builds have not yet undergone native macOS acceptance testing.
License notices and dependency provenance are included under LICENSES.

View File

@ -58,7 +58,7 @@ Publication needs a clean checkout and a matching explicitly created/pushed
version tag. The existing local `v0.1.0` marks the original trial, not subsequent
changes; do not move it implicitly.
The `portable` named bundle adds a Windows ZIP and Linux `.tgz`, containing both
The `portable` named bundle adds Windows/macOS ZIPs and a Linux `.tgz`, containing both
Cargo binaries, adjacent FFprobe, quick-start instructions and licenses. Canonical
cargo-binstall `.tgz` archives remain unchanged and require external FFprobe.
Python 3.11+ is required on the build host only.
@ -70,7 +70,7 @@ archive validation, checksums and upload. See the upstream
[named-bundle contract](https://proxy.dandaedre.com/gitea/idle-org/rust_realease/raw/branch/main/docs/portable-bundles.md).
`crates/pptx-reporter/ffprobe-pins.json` pins a dated BtbN release, exact non-shared
LGPL 9.0 asset name and published SHA-256 digest per target. Dated assets have
LGPL 9.0 asset name and published SHA-256 digest per Windows/Linux target. Dated assets have
versioned names, unlike the downloader's default `latest` assets. To update,
review the provider release and its notices, then update all three fields together.
These dated releases are not marked immutable by GitHub; digest verification
@ -95,24 +95,56 @@ until those checks are complete. Jenkins remains checks/coverage/badges only.
## macOS
Release builds include `aarch64-apple-darwin` (Apple Silicon) and
`x86_64-apple-darwin` (Intel), with macOS 13.0 as the minimum. Each canonical
TGZ contains `pptx-reporter` and `pptx-reporter-gui`. Extract the matching archive
and run `./pptx-reporter-gui`, or:
`x86_64-apple-darwin` (Intel), with macOS 13.0 as the minimum. Choose the
**portable ZIP** for your Mac. It contains `pptx-reporter`, `pptx-reporter-gui`,
FFprobe, notices and a quick-start guide. Extract the entire archive, then run
`./pptx-reporter-gui` in Terminal, or:
```sh
./pptx-reporter presentation.pptx --report all
```
Supply a macOS FFprobe executable beside the reporter, under its `bin/`
directory, or on PATH. The pinned BtbN downloader and named portable bundle
currently cover Windows and Linux only. macOS archives contain no FFprobe.
PDF compilation and fonts remain embedded.
Keep FFprobe beside the applications. No separate FFmpeg, Python, PowerPoint
or PDF compiler is needed. The smaller canonical cargo-binstall TGZs contain
only the reporter applications and still require external FFprobe.
These are separate architecture-specific executables, not universal binaries
or Finder `.app` bundles. They are not Developer ID signed or notarized;
Gatekeeper may require user approval before launch. Native startup, file
dialogs, drag/drop, report generation and Gatekeeper behavior still require
testing on compatible Macs.
or Finder `.app` bundles. They are not Developer ID signed or notarized.
If macOS blocks a trusted release, open Terminal in the extracted folder:
```sh
xattr -d com.apple.quarantine pptx-reporter pptx-reporter-gui ffprobe
chmod +x pptx-reporter pptx-reporter-gui ffprobe
./pptx-reporter-gui
```
An attribute-not-found message means that file is already unquarantined.
Native startup, file dialogs, drag/drop, report generation and Gatekeeper
behavior still require testing on compatible Macs.
### Bundled macOS FFprobe
`scripts/build_macos_ffprobe.py` builds FFprobe from the exact official source
archive and SHA-256 pinned per Mac target in `ffprobe-pins.json`. It uses the
same digest-pinned cargo-zigbuild image as the reporter, enables local file
probing, and disables network input and external codec-library autodetection.
It does not enable GPL or nonfree components. The dependency is a separate
LGPL executable with statically linked FFmpeg libraries and only macOS system
libraries loaded dynamically.
The source build needs Linux, Python 3.11+, and Podman or Docker (selected via
`CROSS_CONTAINER_ENGINE`, or Podman if available). The image must be available
to the engine. Compilation runs with container networking disabled; downloading
the pinned source occurs first on the host. First preparation can take several
minutes. The cache identity covers the source pin, target, image and recipe;
reused payloads have their hashes and Mach-O compatibility checked. A warm
cache needs no dependency download.
Each Mac portable ZIP includes the complete FFmpeg source archive, LGPL license,
reproduction scripts and `BUILDING.txt` under `LICENSES/ffmpeg/`. The dependency
validator checks the CPU, macOS minimum and system-only library paths without
running foreign binaries. The publisher must include Mach-O support for named
bundle executables, in addition to its existing macOS build support.
On the Linux release host, the same publisher routes Apple targets through the
digest-pinned cargo-zigbuild image in `[build.apple]`; Cross remains responsible
@ -131,7 +163,7 @@ rust_realease . --package pptx-reporter \
rust_realease . --package pptx-reporter --compile-only
```
Review `SHA256SUMS` and archive executable modes. The publisher checks Mach-O
Review `SHA256SUMS` and archive executable modes, including the bundled FFprobe. The publisher checks Mach-O
architecture, the exact macOS deployment minimum and system-only dynamic
dependencies. Foreign cargo-binstall checks install files without executing
them; macOS runtime validation is explicitly skipped on Linux.

View File

@ -21,21 +21,21 @@ format = "tgz"
[[package.bundles]]
name = "portable"
targets = ["x86_64-pc-windows-gnu", "x86_64-unknown-linux-gnu"]
formats = { x86_64-pc-windows-gnu = "zip", x86_64-unknown-linux-gnu = "tgz" }
targets = ["x86_64-pc-windows-gnu", "x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "x86_64-apple-darwin"]
formats = { x86_64-pc-windows-gnu = "zip", x86_64-unknown-linux-gnu = "tgz", aarch64-apple-darwin = "zip", x86_64-apple-darwin = "zip" }
archive-name = "{name}-{bundle}-{target}-v{version}"
root = "{name}-{bundle}-{target}-v{version}"
cargo-binaries = "all"
files = [
{ source = "LICENSE", destination = "LICENSES/reporter-MIT.txt", workspace-relative = true },
{ source = "assets/fonts/LICENSE", destination = "LICENSES/DejaVu.txt" },
{ source = "docs/windows-quickstart.txt", destination = "README.txt", workspace-relative = true },
{ source = "docs/portable-quickstart.txt", destination = "README.txt", workspace-relative = true },
]
[package.bundles.prepare]
command = ["python3", "../../scripts/prepare-release.py", "--context", "{context-file}", "--manifest", "{manifest-file}"]
inputs = ["ffprobe-pins.json", "workspace:scripts/prepare-release.py", "workspace:scripts/fetch_ffprobe.py"]
timeout-seconds = 600
inputs = ["ffprobe-pins.json", "workspace:scripts/prepare-release.py", "workspace:scripts/fetch_ffprobe.py", "workspace:scripts/build_macos_ffprobe.py", "workspace:scripts/ffprobe-macos-cc.py", "workspace:scripts/macos_binary.py"]
timeout-seconds = 1800
required-destinations = ["ffprobe{binary-ext}", "LICENSES/ffmpeg/LICENSE.txt", "LICENSES/ffmpeg/provenance.json"]
[[repository.fallbacks]]

View File

@ -0,0 +1,176 @@
#!/usr/bin/env python3
"""Build standalone LGPL macOS FFprobe from checksum-pinned official source."""
import argparse
import hashlib
import json
import os
from pathlib import Path, PurePosixPath
import platform
import re
import shlex
import shutil
import subprocess
import tarfile
import tempfile
from fetch_ffprobe import download, sha256
from macos_binary import validate_macos
SCRIPTS = Path(__file__).resolve().parent
IMAGE = "ghcr.io/rust-cross/cargo-zigbuild@sha256:9b4f6b3eb9e8f9fefb3960fe288ddba576627d66d9eff851ce7f62d2455564a5"
TARGETS = {"aarch64-apple-darwin": "aarch64", "x86_64-apple-darwin": "x86_64"}
RECIPE_FILES = ("build_macos_ffprobe.py", "ffprobe-macos-cc.py", "fetch_ffprobe.py", "macos_binary.py")
FLAGS = [
"--target-os=darwin", "--enable-cross-compile", "--cc=python3 /work/cc.py",
"--ar=zig ar", "--ranlib=zig ranlib", "--disable-autodetect",
"--disable-network", "--disable-protocols", "--enable-protocol=file",
"--disable-programs", "--enable-ffprobe", "--disable-doc", "--disable-debug",
"--disable-asm", "--disable-encoders", "--disable-muxers", "--disable-filters",
"--disable-avdevice", "--disable-shared", "--enable-static", "--disable-stripping",
]
def regular_under(root, relative):
path = PurePosixPath(relative)
if (not path.parts or path.is_absolute() or any(p in ("", ".", "..") for p in relative.split("/"))
or "\\" in relative or ":" in relative):
raise ValueError("Unsafe FFprobe cache receipt path")
current = root
for part in path.parts:
current /= part
if current.is_symlink():
raise ValueError("Symlinked FFprobe cache input")
if not current.is_file():
raise ValueError(f"Missing cached FFprobe input: {relative}")
return current
def recipe_digest(pin, target):
identity = json.dumps({"pin": pin, "target": target, "image": IMAGE, "flags": FLAGS},
sort_keys=True).encode()
for name in RECIPE_FILES:
identity += (SCRIPTS / name).read_bytes()
return hashlib.sha256(identity).hexdigest()
def extract_source(archive, directory, release):
with tarfile.open(archive, "r:xz") as source:
for member in source.getmembers():
parts = PurePosixPath(member.name).parts
if (not parts or parts[0] != f"ffmpeg-{release}" or ".." in parts
or "\\" in member.name or not (member.isfile() or member.isdir())):
raise ValueError(f"Unsafe FFmpeg source member: {member.name}")
source.extractall(directory, filter="data")
return directory / f"ffmpeg-{release}"
def build(target, cache, pin):
if target not in TARGETS or not re.fullmatch(r"\d+\.\d+(?:\.\d+)?", pin["release"]):
raise ValueError("Unsupported macOS FFprobe target or source version")
if pin["asset"] != f"ffmpeg-{pin['release']}.tar.xz" or not re.fullmatch(r"[a-f0-9]{64}", pin["sha256"]):
raise ValueError("FFprobe requires an exact official source archive and SHA-256")
identity = recipe_digest(pin, target)
cache = Path(cache).resolve()
folder = cache / target / identity
binary, notices = folder / "ffprobe", folder / "licenses"
if folder.exists():
if folder.is_symlink() or folder.parent.is_symlink():
raise ValueError("Symlinked FFprobe cache")
receipt = json.loads(regular_under(folder, "licenses/provenance.json").read_text())
if (receipt["recipe_sha256"] != identity or receipt["source_sha256"] != pin["sha256"]
or "ffprobe" not in receipt["files"]
or "licenses/COPYING.LGPLv2.1" not in receipt["files"]
or f"licenses/{pin['asset']}" not in receipt["files"]):
raise ValueError("Invalid FFprobe cache receipt")
for name, digest in receipt["files"].items():
if sha256(regular_under(folder, name)) != digest:
raise ValueError("Corrupt macOS FFprobe cache; remove it and retry")
validate_macos(binary, target)
print(f"Using verified macOS FFprobe cache: {binary}", flush=True)
return binary, notices
engine = os.environ.get("CROSS_CONTAINER_ENGINE")
if engine is None:
engine = "podman" if shutil.which("podman") else "docker"
if engine not in ("podman", "docker"):
raise ValueError("Use podman or docker for the macOS FFprobe source build")
cache.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(prefix=".source-", dir=cache) as temporary:
work = Path(temporary)
archive = work / pin["asset"]
url = f"https://ffmpeg.org/releases/{pin['asset']}"
print(f"Downloading pinned FFmpeg source: {url}", flush=True)
download(url, archive)
if sha256(archive) != pin["sha256"]:
raise ValueError("FFmpeg source SHA-256 mismatch")
source = extract_source(archive, work, pin["release"])
shutil.copyfile(SCRIPTS / "ffprobe-macos-cc.py", work / "cc.py")
configure = ["./configure", "--arch=" + TARGETS[target], *FLAGS]
command = [
engine, "run", "--rm", "--network=none", "--user", f"{os.getuid()}:{os.getgid()}",
]
if engine == "podman":
command.append("--userns=keep-id")
command += [
"-v", f"{work}:/work", "-w", f"/work/ffmpeg-{pin['release']}",
"-e", "ZIG_GLOBAL_CACHE_DIR=/work/zig-cache", "-e", f"FFPROBE_ARCH={TARGETS[target]}",
IMAGE, "sh", "-c", shlex.join(configure) + " && make -j16 ffprobe",
]
print(f"Building LGPL FFprobe for {target}", flush=True)
subprocess.run(command, check=True, timeout=1500)
configuration = (source / "config.h").read_text()
for feature in ("GPL", "GPLV3", "NONFREE"):
if f"#define CONFIG_{feature} 0" not in configuration:
raise ValueError(f"Unexpected FFmpeg license configuration: {feature}")
checks = validate_macos(source / "ffprobe", target)
stage = work / "payload"
staged_notices = stage / "licenses"
staged_notices.mkdir(parents=True)
shutil.copyfile(source / "ffprobe", stage / "ffprobe")
(stage / "ffprobe").chmod(0o755)
for name in ("COPYING.LGPLv2.1", "LICENSE.md"):
shutil.copyfile(source / name, staged_notices / name)
shutil.copyfile(archive, staged_notices / pin["asset"])
for name in RECIPE_FILES:
shutil.copyfile(SCRIPTS / name, staged_notices / name)
(staged_notices / "ffprobe-pins.json").write_text(json.dumps({target: pin}, indent=2) + "\n")
(staged_notices / "BUILDING.txt").write_text(
"FFprobe is a separate LGPL-2.1-or-later executable built from unmodified FFmpeg source.\n"
"The complete source archive and build scripts are included here.\n"
"On a Linux host with Python 3.11+ and Podman/Docker, reproduce with:\n"
f"python3 build_macos_ffprobe.py --target {target} --pins ffprobe-pins.json --cache ./build-cache\n"
"The container image is pinned by digest in the build script.\n"
"Only local-file input is enabled; no separate third-party codec libraries are bundled.\n"
)
native_version = None
if platform.system() == "Darwin" and platform.machine().lower() == (
"arm64" if target.startswith("aarch64") else "x86_64"):
result = subprocess.run([str(stage / "ffprobe"), "-version"], check=True,
capture_output=True, text=True, timeout=30)
native_version = result.stdout.splitlines()[0]
if not native_version.startswith("ffprobe version "):
raise ValueError("Executable did not identify itself as FFprobe")
receipt = {
"provider": "https://ffmpeg.org", "release": pin["release"], "target": target,
"url": url, "source_sha256": pin["sha256"], "recipe_sha256": identity,
"image": IMAGE, "configure": configure, "checks": checks,
"native_version_check": native_version,
"files": {p.relative_to(stage).as_posix(): sha256(p) for p in stage.rglob("*") if p.is_file()},
}
(staged_notices / "provenance.json").write_text(json.dumps(receipt, indent=2) + "\n")
folder.parent.mkdir(parents=True, exist_ok=True)
stage.rename(folder)
return binary, notices
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--target", required=True, choices=TARGETS)
parser.add_argument("--cache", type=Path, required=True)
parser.add_argument("--pins", type=Path, required=True)
args = parser.parse_args()
build(args.target, args.cache, json.loads(args.pins.read_text())[args.target])
if __name__ == "__main__":
main()

View File

@ -0,0 +1,18 @@
#!/usr/bin/env python3
"""Adapt FFmpeg's Darwin driver flags to the pinned Zig compiler."""
import os
import sys
def main():
arch = os.environ["FFPROBE_ARCH"]
if arch not in ("aarch64", "x86_64"):
raise ValueError("Unsupported FFprobe architecture")
# Zig's Mach-O linker selects dynamic/system-library lookup itself.
arguments = [arg for arg in sys.argv[1:] if arg != "-Wl,-dynamic,-search_paths_first"]
os.execvp("zig", ["zig", "cc", "-target", f"{arch}-macos.13.0",
"-isysroot", "/opt/MacOSX11.3.sdk", *arguments])
if __name__ == "__main__":
main()

47
scripts/macos_binary.py Normal file
View File

@ -0,0 +1,47 @@
"""Inspect thin macOS executables without running foreign code."""
import struct
def validate_macos(path, target, maximum_minimum=(13, 0, 0)):
cpus = {"aarch64-apple-darwin": 0x100000C, "x86_64-apple-darwin": 0x1000007}
with path.open("rb") as stream:
header = stream.read(32)
if len(header) != 32:
raise ValueError("Truncated Mach-O header")
magic, cpu, _, kind, count, size, _, _ = struct.unpack("<8I", header)
if magic != 0xFEEDFACF or cpu != cpus.get(target) or kind != 2:
raise ValueError("Expected a matching thin 64-bit Mach-O executable")
if size > 16 * 1024 * 1024:
raise ValueError("Mach-O load commands exceed limit")
commands = stream.read(size)
if len(commands) != size:
raise ValueError("Truncated Mach-O load commands")
offset = 0
minimum = None
dependencies = []
for _ in range(count):
if offset + 8 > size:
raise ValueError("Truncated Mach-O command")
command, length = struct.unpack_from("<2I", commands, offset)
if length < 8 or offset + length > size:
raise ValueError("Invalid Mach-O command size")
data = commands[offset:offset + length]
if command == 0x32:
if length < 24 or struct.unpack_from("<I", data, 8)[0] != 1 or minimum is not None:
raise ValueError("Invalid macOS build version")
encoded = struct.unpack_from("<I", data, 12)[0]
minimum = (encoded >> 16, (encoded >> 8) & 255, encoded & 255)
elif command in (0xC, 0x80000018, 0x8000001F, 0x80000023):
if length < 24:
raise ValueError("Truncated Mach-O dependency")
start = struct.unpack_from("<I", data, 8)[0]
if start < 24 or start >= length or b"\0" not in data[start:]:
raise ValueError("Invalid Mach-O dependency name")
name = data[start:].split(b"\0", 1)[0].decode("utf-8")
if not name.startswith(("/usr/lib/", "/System/Library/")) or ".." in name.split("/"):
raise ValueError(f"Non-system macOS dependency: {name}")
dependencies.append(name)
offset += length
if offset != size or minimum is None or minimum > maximum_minimum or not dependencies:
raise ValueError("Invalid or incompatible macOS deployment/load commands")
return {"minimum_macos": ".".join(map(str, minimum)), "dependencies": dependencies}

View File

@ -9,6 +9,7 @@ import sys
sys.path.insert(0, str(Path(__file__).resolve().parent))
from fetch_ffprobe import fetch, sha256
from build_macos_ffprobe import build as build_macos
def prepare(context, manifest):
@ -20,10 +21,13 @@ def prepare(context, manifest):
pin = pins[context["target"]]
if pin["release"] == "latest" or not re.fullmatch(r"[0-9a-f]{64}", pin["sha256"]):
raise ValueError("FFprobe requires a dated release and SHA-256 pin")
binary, notices = fetch(
context["target"], Path(context["cache_directory"]),
pin["release"], pin["sha256"], asset_name=pin["asset"],
)
if context["target"].endswith("-apple-darwin"):
binary, notices = build_macos(context["target"], Path(context["cache_directory"]), pin)
else:
binary, notices = fetch(
context["target"], Path(context["cache_directory"]),
pin["release"], pin["sha256"], asset_name=pin["asset"],
)
out = Path(context["output_directory"])
files = []

122
tests/test_macos_ffprobe.py Normal file
View File

@ -0,0 +1,122 @@
import hashlib
import io
import json
from pathlib import Path
import struct
import sys
import tarfile
import tempfile
import unittest
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
import build_macos_ffprobe as builder
from macos_binary import validate_macos
def macho(cpu=0x100000C, minimum=13 << 16, dependency="/usr/lib/libSystem.B.dylib"):
name = dependency.encode() + b"\0"
length = (24 + len(name) + 7) // 8 * 8
version = struct.pack("<6I", 0x32, 24, 1, minimum, 0, 0)
dylib = struct.pack("<6I", 0xC, length, 24, 0, 0, 0) + name
dylib += b"\0" * (length - len(dylib))
return struct.pack("<8I", 0xFEEDFACF, cpu, 0, 2, 2, len(version + dylib), 0, 0) + version + dylib
def source_archive():
stream = io.BytesIO()
with tarfile.open(fileobj=stream, mode="w:xz") as archive:
for name, data in [("COPYING.LGPLv2.1", b"license"), ("LICENSE.md", b"notices")]:
entry = tarfile.TarInfo("ffmpeg-9.0.2/" + name)
entry.size = len(data)
archive.addfile(entry, io.BytesIO(data))
return stream.getvalue()
class MacosProbeTests(unittest.TestCase):
def test_macho_compatibility_and_dependency_checks(self):
with tempfile.TemporaryDirectory() as temp:
path = Path(temp) / "ffprobe"
for target, cpu in builder.TARGETS.items():
code = 0x100000C if cpu == "aarch64" else 0x1000007
path.write_bytes(macho(code))
self.assertEqual(validate_macos(path, target)["minimum_macos"], "13.0.0")
invalid = [
macho(0x1000007), macho(minimum=14 << 16),
macho(dependency="@rpath/libavcodec.dylib"), macho(dependency="/tmp/library"),
macho(dependency="/usr/lib/../../tmp/library"), macho()[:20], macho()[:-5],
]
for data in invalid:
with self.subTest(data=data[:32]):
path.write_bytes(data)
with self.assertRaises(ValueError):
validate_macos(path, "aarch64-apple-darwin")
data = bytearray(macho())
struct.pack_into("<I", data, 36, 0)
path.write_bytes(data)
with self.assertRaisesRegex(ValueError, "command size"):
validate_macos(path, "aarch64-apple-darwin")
def test_source_build_preserves_licenses_and_source_then_verifies_cache(self):
archive = source_archive()
pin = {"release": "9.0.2", "asset": "ffmpeg-9.0.2.tar.xz",
"sha256": hashlib.sha256(archive).hexdigest()}
def compile_fixture(command, **kwargs):
self.assertIn("--network=none", command)
self.assertIn(builder.IMAGE, command)
work = Path(command[command.index("-v") + 1].removesuffix(":/work"))
source = work / "ffmpeg-9.0.2"
(source / "config.h").write_text(
"#define CONFIG_GPL 0\n#define CONFIG_GPLV3 0\n#define CONFIG_NONFREE 0\n")
(source / "ffprobe").write_bytes(macho())
with tempfile.TemporaryDirectory() as temp, \
patch.object(builder, "download", side_effect=lambda url, path: path.write_bytes(archive)) as download, \
patch.object(builder.subprocess, "run", side_effect=compile_fixture) as run, \
patch.object(builder.platform, "system", return_value="Linux"), \
patch.dict("os.environ", {"CROSS_CONTAINER_ENGINE": "podman"}):
cache = Path(temp)
binary, notices = builder.build("aarch64-apple-darwin", cache, pin)
self.assertEqual(binary.read_bytes(), macho())
self.assertEqual((notices / pin["asset"]).read_bytes(), archive)
self.assertTrue((notices / "COPYING.LGPLv2.1").is_file())
self.assertTrue((notices / "BUILDING.txt").is_file())
receipt = json.loads((notices / "provenance.json").read_text())
self.assertIsNone(receipt["native_version_check"])
self.assertEqual(receipt["source_sha256"], pin["sha256"])
self.assertEqual(builder.build("aarch64-apple-darwin", cache, pin), (binary, notices))
self.assertEqual(run.call_count, 1)
self.assertEqual(download.call_count, 1)
(notices / "COPYING.LGPLv2.1").write_text("corrupted")
with self.assertRaisesRegex(ValueError, "Corrupt"):
builder.build("aarch64-apple-darwin", cache, pin)
def test_wrong_digest_never_compiles_or_installs(self):
with tempfile.TemporaryDirectory() as temp, \
patch.object(builder, "download", side_effect=lambda url, path: path.write_bytes(b"wrong")), \
patch.object(builder.subprocess, "run") as run:
with self.assertRaisesRegex(ValueError, "SHA-256"):
builder.build("x86_64-apple-darwin", Path(temp), {
"release": "9.0.2", "asset": "ffmpeg-9.0.2.tar.xz", "sha256": "0" * 64})
run.assert_not_called()
self.assertEqual(list(Path(temp).iterdir()), [])
def test_unsafe_source_and_cache_paths(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp)
archive = root / "source.tar.xz"
with tarfile.open(archive, "w:xz") as tar:
member = tarfile.TarInfo("ffmpeg-9.0.2/link")
member.type = tarfile.SYMTYPE
member.linkname = "/etc/passwd"
tar.addfile(member)
with self.assertRaisesRegex(ValueError, "Unsafe"):
builder.extract_source(archive, root, "9.0.2")
for relative in ("../escape", "/absolute", "a//b", "a/./b", "C:escape"):
with self.assertRaises(ValueError):
builder.regular_under(root, relative)
(root / "file").write_text("fixture")
(root / "link").symlink_to(root / "file")
with self.assertRaisesRegex(ValueError, "Symlinked"):
builder.regular_under(root, "link")

View File

@ -36,10 +36,16 @@ class PrepareReleaseTests(unittest.TestCase):
"output_directory": str(out), "cache_directory": str(root / "cache"),
"manifest_path": str(manifest),
}
with patch.object(adapter, "fetch", return_value=(binary, notices)) as fetch:
with patch.object(adapter, "fetch", return_value=(binary, notices)) as fetch, \
patch.object(adapter, "build_macos", return_value=(binary, notices)) as build:
adapter.prepare(context, manifest)
fetch.assert_called_once_with(target, root / "cache", pin["release"],
pin["sha256"], asset_name=pin["asset"])
if target.endswith("-apple-darwin"):
build.assert_called_once_with(target, root / "cache", pin)
fetch.assert_not_called()
else:
fetch.assert_called_once_with(target, root / "cache", pin["release"],
pin["sha256"], asset_name=pin["asset"])
build.assert_not_called()
result = json.loads(manifest.read_text())
self.assertEqual(result["target"], target)
files = {f["destination"]: f for f in result["files"]}