/

CVE-2026-55565

Severity:

CRITICAL RISK

(9.9)

Code Injection (CWE-94) in Yamcs Archive LIKE Queries

CVE-2026-55565

Awaiting Analysis

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.9)

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 critical code injection vulnerability in Yamcs allows attacker-controlled LIKE patterns to be inserted into Java source code that is compiled by the server. If a user can submit SQL, event, table, or activity searches through an exposed API with the relevant read permissions, crafted pattern data may execute code with the privileges of the Yamcs server process.

Affected context

The vulnerability occurs in Yamcs archive and activity-search functionality when a LIKE expression is transformed into Java source for runtime compilation. It may affect deployments that expose SQL, stream SQL, table-row, event, or activity search APIs to users who have permissions such as ReadTables, ReadEvents, or ReadActivities. Risk depends on API exposure, authorization policy, and the privileges assigned to the Yamcs server process.

Exploit preconditions

  • Attack surface: Yamcs archive, stream SQL, table-row, event, or activity-search endpoints
  • Required access: Permission to submit or influence a query or search pattern through an exposed API
  • Trigger point: Evaluation of a LIKE expression during compiled expression generation
  • Why exploitation is possible: The LIKE pattern is inserted into generated Java source without escaping, allowing source syntax to be interpreted during compilation

Why this happens

The underlying bug is failure to apply Java string escaping before embedding a user-influenced LIKE pattern into dynamically compiled source code. Instead of treating the pattern strictly as data, the expression-building logic passes it to a compiler as part of Java source text. This behavior maps to CWE-94: Improper Control of Generation of Code, because untrusted input can alter generated code and cause execution in the server process.

Potential impact

  • Arbitrary code may execute with the privileges of the Yamcs server
  • Sensitive mission-control data may be disclosed or modified
  • Accounts, credentials, or configuration data accessible to the process could be compromised
  • The Yamcs instance may be disrupted or used for lateral movement
  • Operational integrity and mission workflows could be affected

General mitigation guidance

Mitigation centers on preventing user-controlled data from becoming executable source code.

Common defensive patterns include:

  • Escaping or parameterizing all values before they enter generated expressions
  • Replacing dynamic source compilation with an interpreter, validated query model, or allowlisted expression engine
  • Enforcing strict authorization and least privilege for archive and activity-search APIs
  • Limiting the Yamcs process account, filesystem access, network reachability, and secret exposure
  • Treating query patterns as data throughout parsing, validation, logging, and execution
  • Applying vendor-provided security fixes through the organization's normal patch-management process

How teams detect issues like this

Detection may include static analysis for concatenation of user-controlled values into Java source, compiler inputs, or expression templates. Code review should flag dynamic compilation, string-based query construction, missing escaping helpers, and authorization paths that expose search patterns. Runtime monitoring can look for unexpected compiler activity, anomalous archive queries, unusual child processes, and Yamcs processes accessing sensitive files or network destinations. CI policies can require approved parameterization or escaping utilities for generated expressions, with automated review tools used as an additional signal.

Sources

SourceLink
github.comgithub.com/yamcs/yamcs/commit/640e1598b7097b521692e89dd47a39b6cb1fc663
github.comgithub.com/yamcs/yamcs/commit/a8fb4a0693fa62a6eb729b26016d1090dd8b289c
github.comgithub.com/yamcs/yamcs/releases/tag/yamcs-5.12.8
github.comgithub.com/yamcs/yamcs/releases/tag/yamcs-5.13.2
github.comgithub.com/yamcs/yamcs/security/advisories/GHSA-c64q-hj4j-375f

Frequently asked

questions

It can be remotely exploitable when Yamcs APIs are network-accessible and an attacker has permission to submit affected queries or searches.

In typical deployments, access is constrained by Yamcs authorization. The relevant read permission or another route to influence a LIKE pattern may be required, although exposure and access-control configuration determine the exact scope.

Ensure LIKE patterns remain data by using proper Java escaping, parameterized expression handling, or a non-compiling query mechanism. Do not concatenate untrusted input into generated source code.

Minimize dynamic code generation, enforce allowlisted query constructs, review all compiler boundaries, apply least privilege, and use static-analysis or CI policies that detect untrusted data entering generated code.

Find out what's already
exploitable in your codebase.