/

CVE-2026-30120

Severity:

CRITICAL RISK

(9.8)

Code Injection (CWE-94) in remotion-dev remotion v4.0.409

CVE-2026-30120

Analyzed

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A code injection flaw in remotion-dev remotion v4.0.409 allows attackers to cause arbitrary code to be executed in the runtime environment.

When an attacker can influence code or templates that remotion evaluates, this vulnerability can lead to full remote code execution with the privileges of the affected process.

Affected context

This vulnerability affects applications and build pipelines that use remotion-dev remotion v4.0.409 to render or process media where dynamic code, configuration, or templates are evaluated.

Risk is elevated when untrusted or partially trusted input is incorporated into code strings, rendering logic, or configuration that remotion interprets at runtime.

Installations that run remotion as part of automated rendering workflows, CI/CD pipelines, or web-facing services may expose a broader attack surface if user-controlled data is passed through without strict validation and isolation.

Exploit preconditions

  • Attack surface: Interfaces where remotion consumes dynamic scripts, configuration, or templating logic (e.g., rendering parameters, project configuration, or hooks that execute code).
  • Required access: Ability to supply or modify data that remotion later treats as executable code or expressions.
  • Trigger point: Execution or evaluation of attacker-influenced code during rendering, build, or processing phases.
  • Why exploitation is possible: The affected component interprets or constructs code from input without adequate sanitization, validation, or separation between data and executable logic, enabling arbitrary commands or scripts to run.

Why this happens

The underlying issue corresponds to CWE-94: Improper Control of Generation of Code, where input is used to build or influence code that is then executed by the runtime.

Instead of treating external data as passive values, the vulnerable logic incorporates it into code paths (such as eval-like functionality, dynamic require/import, or templated code generation) without robust validation, whitelisting, or sandboxing.

This pattern allows attackers to inject additional operations, escape intended constraints, and execute arbitrary logic under the security context of the remotion process.

Potential impact

  • Remote execution of arbitrary code with the privileges of the remotion runtime.
  • Full compromise of the host running remotion, including lateral movement to adjacent services.
  • Access to sensitive data processed or stored on the system, such as media assets, source code, or credentials.
  • Manipulation or sabotage of rendered media output, leading to misinformation or branding damage.
  • Use of the compromised environment as a pivot point for broader infrastructure attacks.

General mitigation guidance

Mitigation typically centers on minimizing how and where code is dynamically generated or executed and strengthening trust boundaries around any data that could influence code paths.

Common defensive patterns include:

  • Eliminating or reducing the use of dynamic code evaluation APIs (e.g., eval-like constructs, Function constructors, dynamic imports from user-influenced strings).
  • Applying strict input validation and whitelisting for any configuration or parameters that can affect execution behavior, limiting to predefined, non-executable values.
  • Using structured configuration formats (e.g., JSON with fixed schemas) instead of ad hoc code-based configuration, so data cannot be misinterpreted as executable code.
  • Running remotion workloads with least-privilege accounts and applying OS/container sandboxing to contain potential compromise.
  • Isolating rendering workloads from critical infrastructure and sensitive secrets to reduce blast radius if code execution occurs.

How teams detect issues like this

Detection often involves a combination of code-level analysis and process-level monitoring:

  • Static analysis rules that flag dynamic code evaluation patterns, string-to-code constructions, and execution of untrusted data within remotion-related modules.
  • Code review checklists focusing on how rendering parameters, templates, and configuration values are used, ensuring they are never concatenated into executable code.
  • Policy enforcement in CI pipelines that blocks merges introducing new dynamic evaluation mechanisms or loosening input validation around execution hooks.
  • Runtime monitoring and logging to detect unusual command executions, outbound network connections, or filesystem access patterns originating from remotion processes.
  • Use of automated SAST/IAST tools to highlight CWE-94 style issues in the codebase, coupled with manual verification of high-risk findings.

Sources

SourceLink
github.comgithub.com/EaEa0001/security-advisories/blob/main/CVE-2026-30120.md

Frequently asked

questions

It can be, if remotion is exposed through a network-accessible interface or pipeline where remote users can influence the inputs that ultimately drive code execution. Otherwise, it may be restricted to local or internal actors who control those inputs.

The attacker must be able to supply or modify data that remotion later interprets as code or uses to construct executable expressions. This might be via web requests, configuration files, CI variables, or project assets, depending on the integration.

The most robust fix pattern is to remove dynamic code generation based on external input and replace it with predefined, declarative configuration options. Where dynamic behavior is required, enforce strict whitelisting, schema validation, and avoid eval-like mechanisms entirely.

Adopting a secure design approach that separates data from code, combined with defensive programming, helps prevent CWE-94. This includes banning dangerous evaluation APIs in coding standards, using automated tooling to flag violations, enforcing least privilege for rendering services, and performing security-focused reviews of any feature that constructs or runs code dynamically.

Find out what's already
exploitable in your codebase.