External risk intelligence

JSON::XS Stack Memory Read Vulnerability

CVE advisorySeverity: CRITICAL (CVSS 9.1)

CVE-2026-129115

This vulnerability exists within a Perl module library (JSON::XS) used for data serialization. It is a build-time or application-level dependency rather than an internet-facing service, appliance, or gateway. It operates as a component within software packages and lacks independent public network exposure.

Use After Free

Halo Surface Signal: 1 out of 5 — much less likely to be public-facing.

External exposure likelihood

Horizon Alert

Summary of the vulnerability and why it matters

A vulnerability has been identified in a Perl software library that handles data serialization. This issue could potentially allow for the reading of freed memory, which may lead to unexpected application behavior. The primary concern at this stage is to determine if this specific library is used within your environment and, if so, to what extent.

  • Software library flaw allows memory reading.
  • Check if this specific library is used.
  • Confirm relevance and potential exposure.

Attack Path

How an attacker could exploit the issue

An attacker could exploit this vulnerability by sending specially crafted serialized data to a Perl application that uses a vulnerable version of the JSON::XS library. This data could cause the application to read from freed memory, potentially leading to information disclosure or denial of service.

  • Unauthenticated network access required.
  • Triggered by serialized data processing.
  • Risk of information disclosure or denial of service.

Live Threat

Current exploitation, exposure, and threat context

When a FREEZE method serializes data using the `allow_tags` option in JSON::XS, and this serialization causes the Perl stack to grow, a reallocated stack pointer could lead to reading freed memory. This may result in the `encode` function returning `undef` without an error.

  • System data could be exposed.
  • Stack corruption occurs during serialization.
  • Undef value returned without error.

Operational Fix

Recommended remediation, mitigation, and detection steps

This vulnerability impacts the JSON::XS Perl module, a common serialization library. Responsibility for addressing this likely falls to the teams managing Perl applications and their dependencies, potentially including application owners, platform teams, or development teams who integrate this module. The first step is to identify all instances of JSON::XS within your environment, determine their business criticality, and confirm if they are exposed externally or used in critical processes. This will help prioritize remediation efforts.

  • Application owners should own this issue.
  • Verify all JSON::XS deployments.
  • Plan remediation based on risk.

Supplementary metadata

Validate whether this threat affects your internet-facing exposure.

Halo Threat Intelligence helps prioritize remediation with Halo Surface Signal and H/A/L/O context. Start exposure validation with a free external attack surface trial.

Frequently asked questions

What is JSON::XS and how is it used?

JSON::XS is a Perl module library designed for high-performance JSON serialization and deserialization. Developers use it within their applications to convert complex Perl data structures into JSON format for storage or transmission, and vice versa. It serves as a foundational dependency within many Perl-based software packages rather than acting as a standalone, user-facing application.

What does CVE-2026-129115 mean for memory safety?

This vulnerability is classified as CWE-416, a Use After Free weakness. It occurs when the library accidentally retains and uses a reference to a memory block that the Perl engine has already reallocated. This specific defect triggers when the serialization process expands the Perl stack, causing the application to interact with invalid memory locations instead of the newly allocated ones.

How is this memory error triggered?

The issue is triggered when an application uses the allow_tags option during serialization. It does not occur if allow_tags is disabled or if the serialization process does not force a stack expansion. The flaw is specifically tied to complex object serialization where internal methods call back into Perl, causing the stack pointer to become inconsistent while the software attempts to read data.

Is this CVE likely to be exploited externally?

According to Halo Surface Signal, this vulnerability is considered very unlikely to be exploited via direct external network access. Because JSON::XS operates as an internal library dependency rather than an internet-facing gateway or appliance, it lacks the independent public exposure required for common remote exploitation scenarios.

How should I respond to this vulnerability?

Begin by auditing your software stack to identify if any applications rely on JSON::XS versions 3.0 through 4.04. Focus your efforts on internal applications that process untrusted or serialized input from external sources. Coordinate with your development or platform teams to prioritize updates for systems where this specific library configuration is actively handling data.

References