CVE-2026-134704 in Video Editor
Summary
by MITRE • 11/22/2026
OpenShot Video Editor (openshot-qt) through 4.1.1 contains an unsafe deserialization vulnerability in ProjectDataStore.load() and read_legacy_project_file() that passes non-JSON project files to pickle.load() without restriction. Attackers can trick users into opening a crafted .osp project file containing a pickle __reduce__ gadget to execute code with the user's privileges.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/22/2026
The vulnerability identified in OpenShot Video Editor, specifically affecting versions through 4.1.1, represents a critical security flaw rooted in improper handling of serialized data within the application's core project management subsystem. The issue resides primarily in two functions: ProjectDataStore.load() and read_legacy_project_file(). These components are responsible for loading user-created video editing projects stored in the .osp file format. Instead of validating or sanitizing the input structure before processing, these methods directly pass non-JSON formatted content to Python's pickle module via the load() function. This architectural decision creates a direct pathway for arbitrary code execution if an attacker can induce a victim to open a maliciously crafted project file. The root cause is fundamentally a lack of strict type checking and format validation prior to deserialization, allowing untrusted data to be interpreted as executable Python objects rather than passive data structures.
From a technical perspective, the flaw exploits the inherent dangers associated with Python's pickle module when used for deserializing untrusted input. Pickle allows for the serialization of complex Python object graphs, including custom classes and functions. By embedding specific _reduce_ methods within serialized payloads, an attacker can define how objects are reconstructed during loading. When ProjectDataStore.load() or read_legacy_project_file() processes a crafted .osp file containing such gadgets, it inadvertently triggers the execution of arbitrary code defined in those methods. This occurs because pickle does not distinguish between safe data and executable logic unless explicitly restricted by the developer. In this case, no restrictions were implemented to filter out dangerous classes or functions before deserialization took place, effectively bypassing any implicit security boundaries within the application's runtime environment.
The operational impact of this vulnerability is severe, as it enables remote code execution with the privileges of the user running OpenShot Video Editor. An attacker can distribute a malicious .osp file through various vectors such as email attachments, social engineering campaigns, or compromised websites. When an unsuspecting victim opens the file within their local instance of OpenShot, the application will automatically attempt to load the project data. During this process, the embedded pickle gadget executes system commands, potentially allowing the attacker to install malware, exfiltrate sensitive files, pivot further into a network, or gain persistent access to the compromised machine. Since video editors are often used by professionals handling confidential media assets, the breach of integrity and confidentiality can have significant downstream consequences beyond simple system compromise.
This vulnerability aligns with CWE-502, which describes Deserialization of Untrusted Data, as well as CWE-94, Improper Control of Generation of Code (Code Injection). In terms of offensive security frameworks, this attack vector maps to the ATT&CK technique T1059, specifically Command and Scripting Interpreter sub-techniques like PowerShell or Python execution. The exploitation relies on social engineering tactics categorized under MITRE ATT&CK's Initial Access techniques such as Spearphishing Attachment (T1566.001) if delivered via email, or Drive-by Compromise (T1189) if hosted online. Defenders and users must recognize that any application performing automatic deserialization of user-supplied files without rigorous validation poses a significant risk profile in modern threat landscapes where file-based attacks remain prevalent.
Mitigation strategies for this vulnerability require both immediate patching by the vendor and proactive defensive measures by end-users. The primary remediation is to upgrade OpenShot Video Editor to version 4.1.2 or later, where developers have presumably implemented stricter input validation, restricted pickle usage to trusted sources only, or replaced pickle with safer serialization formats like JSON for project metadata. For organizations deploying this software, it is advisable to restrict the execution of untrusted scripts and enforce application control policies that prevent unauthorized binaries from running in user directories. Additionally, users should be educated on the risks associated with opening files from unknown origins, particularly those involving complex document or media formats that may contain embedded executable content. Regular security audits focusing on deserialization practices across all software components are essential to preventing similar vulnerabilities in future releases.