Skip to main content

Kobako EUVDEUVD-2026-90197

| CVE-2026-55107 CRITICAL
Code Injection (CWE-94)
2026-08-18 https://github.com/elct9620/kobako GHSA-7pwq-q9jf-539h
10.0
CVSS 3.1 · Vendor: https://github.com/elct9620/kobako
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Submit untrusted mruby script to sandbox
  2. Delivery
    Dispatch method='send' with args [:eval, ruby]
  3. Exploit
    public_send pivots into Kernel#eval
  4. Execution
    Execute arbitrary Ruby in host process
  5. Impact
    Read/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 Service.send(:eval, "<arbitrary host ruby>"), which the dispatcher runs on the host, giving the attacker arbitrary Ruby execution to read/modify host state or spawn processes. The advisory publishes this exact proof-of-concept, and with low attack complexity and no authentication the attack is straightforward for anyone able to supply a guest script.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
Patch available 0.9% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

kobako 0.1.0, < 0.9.1

Affected Packages

rubygems kobako fix: 0.9.1

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

Vendor (https://github.com/elct9620/kobako) PRIMARY 10.0 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 10.0 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H

Primary rating from Vendor (https://github.com/elct9620/kobako).

CVSS VectorVendor: https://github.com/elct9620/kobako

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

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:

ruby
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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.9%
Top 42% exploitable
Prevalence
Rare
niche single-maintainer mruby sandbox gem, tiny production footprint
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.9%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Out-of-Cycle
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Very High

Priority Score

71
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +50
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy