Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit untrusted mruby script to sandbox
-
DeliveryDispatch method='send' with args [:eval, ruby]
-
Exploitpublic_send pivots into Kernel#eval
-
ExecutionExecute arbitrary Ruby in host process
-
ImpactRead/modify host state or spawn processes
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the host application (1) runs untrusted or attacker-influenced mruby scripts inside the Kobako sandbox and (2) binds at least one host Service object that guest scripts can reference through the transport dispatcher - both are Kobako's intended usage, so no exotic configuration is needed. The attacker must be able to submit or influence a guest script; the escape then uses a single dispatch with method='send' and args=[:eval, '<ruby>']. What limits exploitation: if the deployment binds no Service objects, or never executes untrusted scripts, the sink is unreachable. The vulnerability exists in every released version 0.1.0 through 0.9.0 regardless of which of the three dispatcher names (registry/rpc/transport) is in use. |
| Impact | The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H, base 10.0) reflects a full-impact, scope-changing sandbox escape and is consistent with the described mechanism. The critical caveat is that 'network, no-privilege' exploitation assumes the deployment actually accepts remote, attacker-influenced mruby scripts and binds at least one host Service - Kobako's core use case, but still a deployment-dependent precondition rather than a flaw reachable against an idle install. No EPSS score or CISA KEV status was provided, so real-world exploitation cannot be confirmed; the 10.0 rating is a theoretical-maximum severity, and given Kobako's very small deployment footprint, widespread opportunistic exploitation is unlikely relative to targeted use. The exploit is trivial (single dispatch call) and publicly documented, so any environment running untrusted scripts on 0.1.0-0.9.0 should treat this as an urgent priority; environments that never bind Service objects or never run untrusted scripts are not exposed. |
| Exploit ScenarioDerived | An application uses Kobako to run user-submitted mruby scripts and binds a host Service (e.g. a config or theme object) for those scripts to call. An attacker submits a script that issues a dispatch equivalent to |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 18, 2026
Sandbox escape leading to host remote code execution in Kobako, a Ruby gem that runs untrusted mruby guest scripts in a WASM sandbox. The transport dispatcher forwarded guest-supplied method names directly to Object#public_send on host-bound Service objects without restricting them to the object's own methods, letting a guest pivot through the public send into private Kernel#eval and execute arbitrary Ruby in the host process. All released versions 0.1.0-0.9.0 are affected; the vendor advisory (GHSA-7pwq-q9jf-539h) documents a working proof-of-concept and CVSS is rated 10.0, though there is no CISA KEV listing or EPSS data provided.
RemediationAI
Vendor-released patch: upgrade to Kobako 0.9.1, which adds an owner-based rejection so any dispatched method whose resolved owner is a core/meta module (BasicObject, Kernel, Object, Module, Class) is refused, blocking send, __send__, public_send, instance_eval, instance_exec, method, and instance_variable_get while leaving genuine Service methods (and method_missing-handled dynamic Services) reachable. The fix is in commit 64f84700c81f44902bed9211318d5362f44987b3 and described at https://github.com/elct9620/kobako/security/advisories/GHSA-7pwq-q9jf-539h. There is no in-version workaround; if you cannot upgrade immediately, do not bind any host Service object into a sandbox that runs untrusted scripts - the trade-off is that removing all bound Services eliminates the host-callable functionality the sandbox provides, effectively disabling guest-to-host RPC until you patch.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in rubygems
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Kobako embeds untrusted mruby scripts and lets them call host-side 'Service' objects across the wasm boundary through a transport dispatcher (historically named registry → rpc → transport). The root cause is CWE-94 (Code Injection / Improper Control of Generation of Code): the dispatcher executed target.public_send(method.to_sym, *args, **kwargs, &block) where method is fully guest-controlled. Because public_send can reach any public method - including Ruby's ambient reflection surface inherited from BasicObject, Kernel, Object, Module, and Class - a guest can call the public send, which in turn reaches private methods like Kernel#eval and Kernel#system. The bound object's specific behavior is irrelevant; any Service instance exposes the same inherited reflection methods, making every binding an escape primitive. The affected package is pkg:rubygems/kobako.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
A guest script (unauthenticated input) trivially escapes the sandbox to run host code, changing scope with full host confidentiality/integrity/availability loss; AV:N holds where scripts arrive remotely.
Primary rating from Vendor (https://github.com/elct9620/kobako).
CVSS VectorVendor: https://github.com/elct9620/kobako
DescriptionCVE.org
Summary
A guest mruby script running inside the Kobako sandbox can execute arbitrary Ruby in the host process, fully escaping the sandbox.
Details
A host embeds bound "Service" objects that guest scripts call across the wasm boundary through the transport dispatcher. The dispatcher passed the guest-supplied method name straight to Object#public_send on the bound object, with no restriction to the object's own methods:
target.public_send(method.to_sym, *args, **kwargs, &block)public_send can invoke any public method, including Ruby's ambient reflection surface. A guest pivots through the public send into otherwise private Kernel methods: a dispatch request with method = "send" and args = [:eval, "<ruby>"] evaluates to target.send(:eval, "<ruby>"), running attacker-controlled Ruby in the host. Any bound Service object is sufficient - no Service-specific behavior is required.
Proof of Concept
A guest call equivalent to:
Service.send(:eval, "<arbitrary host ruby>")executes in the host process and can read or modify host state, spawn processes, and so on.
Impact
Complete sandbox escape leading to remote code execution in the host process, defeating the gem's central guarantee of isolating untrusted mruby scripts. Any deployment that runs untrusted or attacker-influenced scripts is affected. All released versions (0.1.0 through 0.9.0) are vulnerable; the dispatcher carried the same unguarded public_send sink under three successive names (registry → rpc → transport).
Patches
Fixed in 0.9.1. The dispatcher now rejects any method whose resolved owner is a core/meta module (BasicObject, Kernel, Object, Module, Class), so only methods the bound object itself defines - or dynamically handles via method_missing - remain reachable. The ambient reflection methods (send, __send__, public_send, instance_eval, instance_exec, method, instance_variable_get, …) are all owned by those modules and are blocked.
Workarounds
None within the affected versions. Until you can upgrade, do not bind any host Service object into a sandbox that runs untrusted scripts. Upgrade to 0.9.1.
References
- GHSA-7pwq-q9jf-539h
- Fix commit: 64f8470
Credits
Reported and fixed by Ahmed Al Hafoudh.
Executive ViewAI
Kobako (Ruby gem for sandboxed untrusted code execution) allows attackers to break out of the sandbox and gain complete control of the host server through arbitrary code execution. All released versions 0.1.0-0.9.0 are vulnerable with publicly available exploits documented in vendor advisory GHSA-7pwq-q9jf-539h. Organizations using this library face critical risk of infrastructure compromise and require immediate remediation.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-90197
GHSA-7pwq-q9jf-539h
NVD
CVE.org
EPSS
Exploit-DB