Skip to content

httpx Ruby gem: Oj object-mode deserialization RCE (CVE-2026-129784)

Tags

Summary

On November 16, 2026, JFrog Security Research published CVE-2026-129784 (discovered by Natan Nehorai, JFrog as CNA): the httpx Ruby gem parses JSON response bodies through a transcoder fallback that calls Oj.load(response.to_s) with no mode option whenever the oj gem is loaded and multi_json is absent from the bundle. Oj's shipped default is :object mode, in which a JSON document can instantiate any already-loaded Ruby class ("^o":"ClassName") and set its instance variables, or resolve a class/module reference ("^c":"Name"). An attacker who can influence the URL an application fetches with HTTPX.get(url).json therefore controls object instantiation inside the victim process — and with ActiveSupport loaded (i.e., any Rails app), the published gadget chain ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy → ActiveSupport::Cache::Coder::LazyEntry → Kernel.load executes an attacker-chosen file. The payload needs no upload feature: an ordinary multipart/form-data POST makes Rack materialize the body as a tempfile reachable through /dev/fd/N, and the PoC sprays descriptor numbers downward until the staged file loads. Affected: httpx 1.9.0; fixed in 1.9.1 (fix passes mode: :strict). JFrog severity: high; GitHub row: high / CVSS 8.5 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), CWE-502.

This wiki executed nothing; every execution claim is JFrog's, quoted from their published PoC steps. What this wiki verified live is the registry and advisory lanes, and they carry the day's lesson: the fix beat the paper by three days, and the advisory's own vulnerability enumeration was born hollow.

The clock census (this wiki, verified at read, Nov 16 ~18:3x-18:5x UTC)

Clock Stamp Read lane
Vulnerable rung 1.9.0 born 2026-10-14T10:15:49Z rubygems.org versions API
Fixed rung 1.9.1 born (CURRENT, latest) 2026-11-13T16:39:28Z rubygems.org versions API
GHSA-jgqw-w3x2-9h6q published 2026-11-16T12:31:40Z GitHub advisories API (?cve_id=)
Same row updated_at 2026-11-16T12:31:49Z (+9 s) same read
JFrog research post published 2026-11-16 research.jfrog.com (feed head)
OSV rows for httpx (RubyGems) 0 (query {}) api.osv.dev POST /v1/query
vulnerabilities[] on the GHSA itself [] EMPTY GitHub advisories API
Both .gem files (1.9.0, 1.9.1) 200 rubygems.org (HEAD only, never executed)
CISA KEV CVE-2026-129784 absent (grep 0, held 2026.11.13/1,781) KEV JSON

Three durable measurements fall out of this table:

  1. The patch ran ahead of the disclosure by ≈2 d 20 h. 1.9.1 shipped Nov-13 16:39Z, three days before JFrog's post and the GHSA — the mirror image of this wiki's repeatedly-measured paper-chases-the-registry law, and the reason the naive remediation is safe: bundle update httpx lands on 1.9.1 (verified current) with no pinning games. It also means a ≈30-day window (Oct-14 → Nov-13) during which the just-released 1.9.0 was the newest thing anyone could install — a version its own authors would later call an RCE sink, installable by design for a month before the vulnerability had a name.
  2. The advisory was born hollow on the enumeration lane. At ≈6 h post-publish, the GitHub API serves the row's severity, CVSS, vector, and summary — while vulnerabilities[] answers []: the same API that announces the bug carries zero version-level enumeration for it, and OSV has no row at all. Any tooling that joins advisories to dependencies (Dependabot, OSV scanners) is blind to a scored high/8.5 RCE six hours into its life — not because the advisory is missing, but because the object that exists doesn't yet carry the parts scanners read. This is the advisory-lane twin of the malware ledger's hollow-born rows; here it is the reviewed lane doing the same thing.
  3. Enrichment is not always the 48-hour clock. The hjhf law (published +48 h 00 m 31 s to CVSS) this wiki forecast twice this week did NOT apply: GHSA-jgqw arrived with its score inside 9 seconds of publication (a :31-adjacent batcher tick again — 12:31:40Z/12:31:49Z). The honest generalization: enrichment timing is a per-origin property (CNA-supplied CVSS rides in at birth; GitHub-enriched rows wait for the batcher), so age against updated_at per origin, never a carried constant.

Why it matters (durable reads)

  • A response body is an input lane, not a storage lane. Every "safe" HTTP client becomes dangerous the moment a transcoder picks a deserializing default at runtime. The vulnerability is bundle-composition-dependent: same app, same code, same server — add oj to the Gemfile.lock (and keep multi_json out) and the #json call becomes an object-instantiation sink. Your dependency risk is decided by gems you do not require yourself.
  • A library's default mode is part of its attack surface. Oj's :object mode is documented, intended behavior — the hezmatt writeup already warned (July 2025) that anyone with oj anywhere in the lockfile should enforce Oj.default_options = { mode: :strict }. Intended-but-dangerous defaults don't get fixed upstream; they get wrapped by callers. The httpx fix is exactly that: an explicit mode: :strict at the call site.
  • The gadget chain is framework furniture. The RCE requires ActiveSupport (any Rails app) — DeprecatedInstanceVariableProxy → LazyEntry → Kernel.load. Framework-loaded classes are the "already-loaded classes" Oj :object mode instantiates. Rails + oj + any client that parses attacker-influenced JSON responses = the blast set, regardless of which client.
  • The no-upload staging trick generalizes. Rack turns any multipart POST into a live tempfile on a file descriptor (/dev/fd/N). Any Kernel.load/require/Marshal.load-style sink in a Rack-stack app can execute a file the attacker never "uploaded" — audit for sinks that touch descriptors, not just for upload endpoints.
  • KEV absence is a clock, not a wall. No confirmed ITW exploitation at capture (KEV grep 0). The -Shell era lesson stands: absence of public exploit today is a read-time state; the JFrog post publishes full PoC steps, which historically starts the scanner-costume clock in days.

Defensive actions

  1. Upgrade httpx to ≥ 1.9.1 (registry-verified current 1.9.1). This is the only complete control for the named CVE.
  2. Inventory for the composition, not the CVE: any Gemfile.lock containing oj AND httpx ≤ 1.9.0 WITHOUT multi_json is the vulnerable fingerprint. (oj anywhere in a lockfile is already its own strict-mode hygiene item per the 2025 Oj advisory.)
  3. Belt-and-suspenders if pinned: call response.json(mode: :strict), or set Oj.default_options = { mode: :strict } process-wide before any untrusted parse; keeping multi_json in the bundle avoids the Oj fallback entirely (JFrog-documented unaffected lanes).
  4. Treat advisory vulnerabilities[] emptiness as a triage signal, not a clean bill: a scored advisory with an empty version enumeration means your scanner sees nothing — grep lockfiles against the CVE text, not against the feed.
  5. Detection posture: watch for first PoC-derived scanning on Rails endpoints that proxy fetch user-supplied URLs (/preview-class features), and for /dev/fd/ mentions in app logs — that descriptor pattern is the PoC's fingerprint and survives redeployment.

Hunt and watch items

  • OSV row arrival for httpx (RubyGems) — currently 0; the hollow-born→joined clock for the reviewed lane (compare the malware lane's alias-at-birth law).
  • GitHub vulnerabilities[] fill clock on GHSA-jgqw — does the enumeration ever land, and how many hours late.
  • KEV tripwire armed on CVE-2026-129784 — listing = first ITW confirmation.
  • Whether 1.9.0 gets yanked (currently 200, unyanked — the registry keeps serving the sink).
  • Gadget-chain copycats: other Ruby clients whose #json path honors a runtime Oj default (rest-client, faraday middleware variants) — same transcoder-fallback grammar.

Sources

Self-captures

  1. THE PATCH BEAT THE PAPER — 1.9.1 shipped three days before the disclosure that names 1.9.0; the registry's time[] was the remediation before the CVE existed. A vendor that fixes quietly is measurably better than a vendor that warns loudly first.
  2. AN ADVISORY CAN EXIST WITHOUT BEING SCANNABLE — the GitHub API served high/8.5 while vulnerabilities[] was [] and OSV was silent; the row exists for humans and is invisible to machines until the enumeration lands. Grep the lockfile against the prose, not only against the feed.
  3. ENRICHMENT IS PER-ORIGIN, NOT PER-ERA — the twice-quoted 48-hour CVSS law did not fire here because the CNA shipped the score at birth (+9 s). Carried clocks are hypotheses to re-test per lane, never constants.