CVE-2026-55107: 
Ruby vulnerability analysis and mitigation

CVE-2026-55107 is a critical sandbox escape vulnerability in the Kobako Ruby gem that allows a guest mruby script to execute arbitrary Ruby code in the host process, fully bypassing the sandbox isolation guarantee. It affects all released versions of kobako from 0.1.0 through 0.9.0 (RubyGems/bundler package). The vulnerability was originally reported and fixed by Ahmed Al Hafoudh, first published on June 11, 2026, and added to the GitHub Advisory Database on August 18, 2026. It carries a CVSS v3.1 base score of 10.0 (Critical) (GitHub Advisory, Kobako Advisory).

The root cause is improper control of code generation (CWE-94) combined with unsafe reflection (CWE-470). Kobako's transport dispatcher passes guest-supplied method names directly to Object#public_send on bound host Service objects without any allowlist or ownership check:

target.public_send(method.to_sym, *args, **kwargs, &block)

Because public_send can invoke any public method — including Ruby's ambient reflection surface — a guest script can craft a dispatch request with method = "send" and args = [:eval, "<arbitrary ruby>"], which resolves to target.send(:eval, "<ruby>") and executes attacker-controlled code in the host process. The flaw existed under three successive internal names (registry → rpc → transport) across all versions 0.1.0–0.9.0, and any bound Service object is sufficient to trigger it — no Service-specific behavior is required (GitHub Advisory, Fix Commit).

Successful exploitation results in a complete sandbox escape, granting the attacker full remote code execution (RCE) in the host Ruby process. An attacker can read or modify host state, access sensitive data, spawn arbitrary system processes, and potentially pivot to other systems accessible from the host. This defeats the central security guarantee of the Kobako gem — isolation of untrusted mruby scripts — and any deployment running untrusted or attacker-influenced scripts is fully compromised (GitHub Advisory, Kobako Advisory).

No public proof-of-concept exploit code has been observed beyond the minimal PoC included in the advisory itself (Service.send(:eval, "<arbitrary host ruby>")), and there is no evidence of in-the-wild exploitation at this time (GitHub Advisory). The vulnerability requires no authentication, no privileges, and no user interaction, making it trivially exploitable by any guest script that can submit a crafted dispatch request. No threat actor attribution or CISA KEV catalog listing has been identified. The EPSS score is not yet published for this CVE.

1. Identify a target: Locate a Ruby application using the kobako gem (versions 0.1.0–0.9.0) that accepts and executes untrusted or attacker-influenced mruby scripts within the Kobako sandbox.
2. Craft a malicious dispatch request: Prepare a transport dispatch request targeting any bound Service object with method = "send" and args = [:eval, "<arbitrary ruby code>"].
3. Submit the request: Deliver the crafted request across the wasm boundary to the Kobako transport dispatcher — this can be done by any guest mruby script running inside the sandbox.
4. Trigger unsafe reflection: The dispatcher calls target.public_send(:send, :eval, "<arbitrary ruby code>"), which resolves to target.send(:eval, "<arbitrary ruby code>"), executing the payload in the host Ruby process.
5. Achieve host RCE: The attacker's Ruby code runs in the host process with full access to host state, file system, environment variables, and the ability to spawn system processes (e.g., system("id"), exec("/bin/bash")) (GitHub Advisory, Fix Commit).

• Logs: Unexpected Ruby eval calls or Kernel#system/exec invocations originating from the Kobako transport dispatcher in application logs; errors or stack traces referencing Kobako::Transport::Dispatcher#invoke with method names such as send, __send__, public_send, instance_eval, or eval.
• Process: Unusual child processes spawned by the Ruby host process (e.g., /bin/bash, sh, curl, wget, python) that are not part of normal application behavior.
• Network: Unexpected outbound connections from the Ruby host process to external IPs, particularly following mruby script execution events.
• File System: New or modified files in the application directory or system temp directories created by the Ruby process at unexpected times; new cron jobs or scheduled tasks created under the application's service account (GitHub Advisory).

Upgrade the kobako gem to version 0.9.1, which introduces a reject_meta_method! guard that checks the resolved method owner against a META_OWNERS blocklist (BasicObject, Kernel, Object, Module, Class) before dispatching, blocking all ambient reflection methods (Fix Commit). There is no effective workaround within affected versions 0.1.0–0.9.0; the only interim mitigation is to not bind any host Service object into a sandbox that executes untrusted scripts until the upgrade can be applied (Kobako Advisory).