/

CVE-2026-18287

Severity:

HIGH RISK

(7.8)

Code Injection (CWE-94) in aeon Benchmark Loader

CVE-2026-18287

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution

Severity:

HIGH RISK

(7.8)

CVSS version:

3.0

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 vulnerability in aeon's load_time_series_segmentation_benchmark method allows a user-supplied string to be executed as Python code without adequate validation. Exploitation may enable arbitrary code execution in the context of the current process when a target visits a malicious page or opens a malicious file.

Affected context

The vulnerability occurs in installations of aeon that use the load_time_series_segmentation_benchmark method to process user-influenced input. Risk depends on a vulnerable execution path being reached and on the target interacting with attacker-controlled content, such as a malicious page or file.

Exploit preconditions

  • Attack surface: The aeon time-series segmentation benchmark loading functionality
  • Required access: Ability to provide or influence the string processed by the vulnerable method
  • User interaction: The target must visit a malicious page or open a malicious file
  • Trigger point: Processing the attacker-influenced string by load_time_series_segmentation_benchmark
  • Why exploitation is possible: The string is used in a Python code execution path without sufficient validation or isolation

Why this happens

The underlying flaw is the treatment of a user-supplied string as executable Python code rather than as inert data. Because validation and trust-boundary controls are insufficient before execution, attacker-controlled content can alter program behavior and execute in the current process context. This behavior maps to CWE-94: Improper Control of Generation of Code, commonly known as code injection.

Potential impact

  • An attacker may execute arbitrary code in the affected process
  • The application may disclose, modify, or delete accessible data
  • A compromised process could be used to access connected services or resources
  • The host environment could be affected according to the process's permissions

General mitigation guidance

Mitigation generally focuses on ensuring that input is handled strictly as data and never interpreted as executable Python code.

Common defensive patterns include:

  • Replacing dynamic evaluation or code-generation behavior with explicit parsing and data-oriented APIs
  • Applying allowlisted schemas, types, and values before processing benchmark inputs
  • Treating files and content received from external sources as untrusted by default
  • Separating parsing from execution and avoiding implicit evaluation during loading
  • Running the affected process with least privilege and limiting access to sensitive resources
  • Using isolation boundaries where processing untrusted content is necessary

How teams detect issues like this

Organizations can look for code injection risks through:

  • Static analysis rules targeting eval, exec, dynamic compilation, reflective execution, and equivalent APIs
  • Code review signals showing user-controlled strings flowing into interpreters or code-generation functions
  • Data-flow analysis across file, web, and deserialization inputs into benchmark-loading routines
  • Runtime monitoring for unexpected child processes, filesystem changes, or outbound connections
  • Policy enforcement that blocks dynamic code execution in components intended only to parse data

Automated security review tools may help identify suspicious input-to-execution flows, but findings should be validated against the application's trust boundaries.

Sources

SourceLink
github.comgithub.com/aeon-toolkit/aeon/commit/751918052c0cce266b4f7cd4b084408526efc015
zerodayinitiative.comzerodayinitiative.com/advisories/ZDI-26-470/

Frequently asked

questions

It may be remotely triggered through attacker-controlled content, but exploitation requires the target to visit a malicious page or open a malicious file and reach the vulnerable aeon functionality.

The attacker generally needs a way to supply or influence the string processed by the benchmark-loading method. Direct access to the host is not necessarily required when malicious content can reach the target through an application workflow.

Remove dynamic Python code execution from the input-processing path and replace it with strict, allowlisted parsing that treats supplied values as data.

Enforce input trust boundaries, review all data-to-code flows, use static analysis for dynamic execution APIs, and operate content-processing processes with minimal privileges.

Find out what's already
exploitable in your codebase.