CVE-2026-129784 in httpxinfo

Summary

by MITRE • 11/16/2026

The httpx Ruby gem parses JSON response bodies through its transcoder layer. HTTPX::Response#json delegates to Transcoder::JSON.decode, and when the oj gem is loaded and multi_json is absent, the decoder falls back to json_load, which calls Oj.load(response.to_s) with no mode option. Oj.load defaults to :object mode, in which a response document can allocate any already-loaded Ruby class ("^o":"ClassName") and set its instance variables, or resolve a class or module reference ("^c":"Name"). An attacker who controls, or can influence, the URL an application fetches with HTTPX.get(url).json therefore controls object instantiation in the victim process. With a matching gadget chain, this issue can potentially cause remote code execution. Affects httpx 1.9.0; fixed in 1.9.1.

If you want to get the best quality for vulnerability data then you always have to consider VulDB.

Analysis

by VulDB Data Team • 11/16/2026

The vulnerability resides within the Ruby gem httpx, specifically in its JSON parsing mechanism which relies on an internal transcoder layer to deserialize HTTP response bodies into Ruby objects. When a developer invokes the json method on an HTTPX::Response object, the library delegates this task to Transcoder::JSON.decode. The security flaw emerges under specific dependency conditions: if the high-performance Oj gem is loaded and the multi_json gem is absent, the decoder defaults to using Oj.load for deserialization without specifying a safety mode. This configuration allows an attacker who can influence or control the URL targeted by an HTTPX.get request with subsequent JSON parsing to execute arbitrary code on the victim's system through object injection attacks.

The core technical flaw stems from the default behavior of the Oj library when invoked in its standard :object mode. In this mode, Oj.load is capable of instantiating any Ruby class that has already been loaded into the application's memory space by interpreting special JSON keys such as ^o for class instantiation and instance variable assignment, or ^c for resolving class and module references. This functionality is designed to preserve object identity during serialization but becomes a critical security risk when processing untrusted input from external sources like HTTP responses. An attacker can craft a malicious JSON response containing these control sequences, effectively forcing the victim application to instantiate arbitrary classes with controlled instance variables.

This vulnerability maps directly to CWE-502, which describes Deserialization of Untrusted Data. By allowing an untrusted server's response to dictate object creation within the client process, httpx exposes applications to severe integrity violations. The operational impact is profound because it enables Remote Code Execution if a suitable gadget chain exists within the victim application or its dependencies. A gadget chain consists of a sequence of method calls that can be triggered through the instantiated objects, ultimately leading to arbitrary command execution on the host system. This transforms what appears as a simple HTTP request into a potent attack vector capable of compromising the entire server environment hosting the Ruby application.

The risk is particularly acute in applications that fetch data from third-party APIs or user-controlled endpoints and subsequently process those responses using httpx's json method without additional validation layers. Since Oj.load does not restrict which classes can be instantiated by default, any class available to the running Ruby interpreter becomes a potential entry point for exploitation. This includes standard library classes as well as gems used by the application, significantly expanding the attack surface beyond just custom business logic objects.

To mitigate this vulnerability, applications using httpx version 1.9.0 or earlier should immediately upgrade to version 1.9.1 where the issue has been resolved. For environments unable to update immediately, developers can implement a workaround by explicitly configuring Oj to use safer deserialization modes such as :strict or :custom, which restrict class instantiation and prevent arbitrary object creation from untrusted JSON input. Additionally, implementing strict allowlists for expected response structures using schema validation libraries before passing data to the transcoder layer provides an additional defense-in-depth measure against injection attacks.

From a threat intelligence perspective, this vulnerability aligns with MITRE ATT&CK technique T1059, Command and Scripting Interpreter, specifically through object instantiation mechanisms that allow lateral movement or privilege escalation within the application runtime. It also relates to T1203, Exploitation for Client Execution, if the attack targets client-side Ruby applications using httpx. Security teams should monitor for unusual network traffic patterns involving JSON payloads with special control characters and ensure that all dependencies are kept up-to-date to prevent exploitation of known deserialization flaws in widely used libraries like Oj.

Responsible

JFROG

Reservation

11/16/2026

Disclosure

11/16/2026

Moderation

accepted

CPE

ready

EPSS

0.00000

KEV

no

Activities

very low

Sources

Want to know what is going to be exploited?

We predict KEV entries!