Technical assessment
The artifact is a Python script (poc/poc.py) that generates a crafted AVI file and executes it against a vulnerable FFmpeg build to trigger a heap out-of-bounds write in the CFHD decoder. The script constructs a malicious CFHD bitstream with an oversized band width, writes it to an AVI file, and then runs FFmpeg via Docker to probe the file, confirming the crash via AddressSanitizer output. This constitutes an exploit as it exercises the vulnerability to cause a deterministic heap buffer overflow.
Backdoor review
No backdoor observed in reviewed code
The PoC generates a crafted AVI file to trigger a documented heap out-of-bounds write in FFmpeg's CFHD decoder. The Python script (poc/poc.py) constructs the malicious bitstream and optionally runs it against a Dockerized vulnerable FFmpeg build to observe an AddressSanitizer crash. No concealed executable behavior, persistence, credential theft, or unrelated payload delivery is present. The code performs only the described vulnerability demonstration.
Model confidence95%
AuthenticationNot required
LanguagesPython
Target softwareFFmpeg
Attack typesHeap Out-of-Bounds Write
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidenceClassification basis and observed behavior
Classification basis
The Python script actively generates a malicious input and executes it against a vulnerable target to trigger a heap out-of-bounds write, which is the definition of an exploit. It does not merely scan for the vulnerability or describe it; it exercises the flaw to cause a crash.
poc/poc.py:18-28poc/poc.py:204-214poc/poc.py:217-258Requirements
- Docker with compose must be installed to build and run the vulnerable FFmpeg lab environment.
README.md:111 - The vulnerable FFmpeg Docker image must be built using 'docker compose build' before running the exploit.
README.md:116
Observed behavior
- Generates a minimal AVI file containing a crafted CFHD bitstream with an oversized band[4][1] width (288) for a 64x64 coded frame.
poc/poc.py:118-166poc/poc.py:204-214 - Executes the vulnerable FFmpeg build inside a Docker container to probe the generated AVI file, triggering the heap buffer overflow.
poc/poc.py:217-258 - Validates the exploit by checking for AddressSanitizer 'heap-buffer-overflow' signature in 'horiz_filter_clip' from 'cfhd_decode'.
poc/poc.py:247-253
Behaviors behind the backdoor verdict
Observables
- Command Execution
- docker compose run --rm -T target /src/ffmpeg/ffmpeg -v error -i /work/poc/poc.avi -f null -The PoC optionally executes a Docker container running a vulnerable FFmpeg build to validate the crash. This is the intended exploit demonstration and is not concealed or harmful beyond the stated purpose.
poc/poc.py:222-228 - File Write
- poc.aviThe script writes a crafted AVI file containing the malicious CFHD bitstream. This is the PoC payload, not a backdoor.
poc/poc.py:209-210
What the analysis did not establish
- The evidence does not include the Dockerfiles or lab environment files referenced by the PoC, so the exact build configuration and dependencies cannot be verified.
- The PoC only demonstrates a crash (DoS) and does not include the code execution escalation mentioned in the advisory.
- The analysis is based solely on the provided text files; the binary AVI output and Docker execution are not included in the evidence.
- Docker images and binary artifacts (e.g., the vulnerable FFmpeg build) are not included in the supplied text evidence; only the Python PoC script and documentation were reviewed.
- The verification report references external artifact files (poc_run.txt, crash-session.txt, etc.) that are not part of the supplied evidence.
Model interpretationThis review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.