Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted Elo program to Ruby target
-
ExploitCompiler emits unescaped #{...} into Ruby string literal
-
ExecutionBacktick interpolation executes when compiled Ruby runs
-
ImpactArbitrary shell command runs on host
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 attacker-controlled Elo source be compiled to the Ruby target specifically AND that the emitted Ruby then be executed: the /try playground runs it server-side (0-click from a shared PoC URL), bin/eloc -t ruby -x compiles and runs it, and a library integrator must call a Ruby emission step on parsed input and execute the result. The malicious payload is an Elo string literal or a single-quoted subtype-constraint label containing a Ruby interpolation form (#{...}, #@ivar, #@@cvar, #$gvar), with backticks inside #{...} providing shell execution; the subtype sink additionally requires the crafted constraint to fail so its message is evaluated. The key limiting factor is the target language: the identical Elo source compiled to JavaScript, Python, or SQL is benign, so only pipelines that emit and run Ruby from untrusted Elo are exploitable; no authentication or user interaction is needed on the network playground surface (PR:N/UI:N), while the CLI surface is local. |
| Impact | All severity signals point the same direction for the network-facing surfaces. The input CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) describes unauthenticated, low-complexity, no-interaction remote code execution, and the vuln.today decision label is act_now, so this should be treated as a real priority rather than a high-CVSS-but-low-risk issue. A PoC is not merely theoretical: the GHSA advisory publishes working reproduction code for both the string-literal sink and the subtype-constraint-label sink and states it was verified against Ruby 3.x, which materially raises exploitability. Two signals are missing and must be stated explicitly: no EPSS exploitation-probability score was supplied, and there is no CISA KEV listing in the input, so there is no confirmation of active in-the-wild exploitation - the elevated urgency rests on the act_now decision label, the 9.8 vector, and the verified PoC, not on observed attacks. One nuance tempers raw CVSS: the AV:N/PR:N/UI:N rating fits the /try playground (0-click server-side RCE from a shared URL) and the library-integration path, but the CLI surface (bin/eloc -t ruby -x) is a local vector and the library path requires an integrator to both emit Ruby and execute it, so real-world reach depends on which entry point a given deployment exposes. |
| Exploit ScenarioDerived | An attacker crafts an Elo program containing a string literal or single-quoted subtype-constraint label such as '#{ |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Ruby code execution in Elo (npm @enspirit/elo) through 1.0.0 lets an attacker who controls Elo source gain arbitrary Ruby and shell command execution whenever that source is compiled to the Ruby target and the emitted code is run. The Ruby backend in src/compilers/ruby.ts inserts string literals and labelled subtype-constraint messages into Ruby double-quoted strings without escaping '#', so payloads such as 'RES=#{id}' survive compilation intact and execute when the generated Ruby is evaluated; the server-side /try playground with the Ruby target, bin/eloc -t ruby -x, and library integrations that call a Ruby emission step on parsed input are all exposed. The network-facing playground surface needs no authentication or user interaction (CVSS 3.1 AV:N/AC:L/PR:N/UI:N, 9.8), and the advisory ships working proof-of-concept Elo snippets; the same Elo source compiled to JavaScript, Python, or SQL is harmless, so only pipelines that emit and execute Ruby from untrusted Elo are exploitable, and no CISA KEV listing or independent confirmation of exploitation in the wild is present in the available data.
RemediationAI
Upgrade @enspirit/elo to 1.0.1, the vendor-released fix version that adds escapeRubyDQ() and applies it to both the string-literal emitter and the labelled subtype-constraint message branch (https://github.com/enspirit/elo/security/advisories/GHSA-7w38-ggh5-v542; commits 51b869963fbe445c18328714a7ccfbd76b21ba38 and d2a89a8db76a244eb740687524a7e8529b7554b5). Until every consumer is upgraded, treat untrusted Elo as executable code only where Ruby is the target: disable or restrict the Ruby target on any hosted playground or compilation service (removing that target eliminates the RCE surface but also removes Ruby output for legitimate users), avoid running bin/eloc -t ruby -x on input from untrusted authors on CI or DevOps hosts (compile to JavaScript, Python, or SQL instead, which is unaffected), and in library integrations stop piping defaultFormats.elo.parse() output into a Ruby emission step that is then executed, or sandbox/containerize that execution with a restricted filesystem and no network egress. Note that these are compensating controls only and do not correct the unescaped '#' in emitted Ruby; the 1.0.1 upgrade is the complete fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Elo is a purely functional expression language used as a rule engine and configuration/form DSL, compiled from a TypeScript codebase into multiple targets. The flaw is CWE-94 code injection arising from improper neutralization of special elements (CWE-116) in generated output, a variant of the Ruby-specific template injection class tracked as CWE-1336: the Ruby emitter treated double-quoted string content as inert text, but in Ruby '#{' opens interpolation, '#@ivar' and '#@@cvar' expand instance/class variables, and '#$gvar' expands globals, and any interpolated expression may use backticks for shell execution. Two sinks existed in src/compilers/ruby.ts at commit 749af7b: the string-literal emitter (lines ~180-184) escaped backslash, double quote and control characters but not '#', and the labelled subtype-constraint branch (lines ~405-412) wrapped its error message in a double-quoted string with no escape pass at all, reachable because src/parser.ts accepts single-quoted Elo constraint labels verbatim. JavaScript, Python, and SQL emitters were unaffected, which also broke Elo's cross-target portability guarantee. The fix introduces a shared escapeRubyDQ() helper that escapes backslash, '#', double quote, newline, tab and carriage return, and routes both sinks through it; the accompanying test fixtures assert that sequences like '#{1+1}', '#{id}', '#@x', '#@@x' and '#$x' remain literal in the Ruby output and equal their concatenated forms.
Know when Ruby gets its next vulnerability
- 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:U/C:H/I:H/A:H
The /try playground accepts untrusted Elo over the network and executes emitted Ruby with no auth or interaction, yielding unauthenticated low-complexity RCE with full host CIA impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Elo is a purely functional expression language for no-code tools. Prior to 1.0.1, the Ruby backend in src/compilers/ruby.ts embeds attacker-controlled text in Ruby double-quoted strings without escaping #, so Ruby interpolation forms in the string-literal emitter or the labelled subtype-constraint branch become executable Ruby. The affected entry points include the /try playground with the Ruby target, bin/eloc -t ruby -x, and defaultFormats.elo.parse() followed by Ruby emission. A failing labelled subtype constraint evaluates its message, while an ordinary string literal is evaluated when the compiled Ruby runs, allowing Ruby code and shell command execution through backticks. JavaScript, Python, and SQL emission are not affected by this Ruby-specific path. This issue is fixed in version 1.0.1.
Executive ViewAI
The Elo compiler library for Ruby (npm @enspirit/elo) contains a critical code injection flaw that allows untrusted Elo source to execute arbitrary Ruby and shell commands when compiled to Ruby and run. This impacts any team using the library, particularly the public /try playground and CLI, potentially leading to system compromise and data breach. Leadership should prioritize immediate assessment and mitigation.
Disable or restrict the Ruby target in the playground and any library integration that compiles untrusted Elo to Ruby; validate and sanitize Elo source input; run Ruby execution in a sandboxed environment with minimal privileges.
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.
Ruby before 2.4.3 allows Net::FTP command injection. Rated high severity (CVSS 8.8), this vulnerability is remotely expl
The lazy_initialize function in lib/resolv.rb in Ruby through 2.4.3 uses Kernel#open, which might allow Command Injectio
Ruby through 2.2.7, 2.3.x through 2.3.4, and 2.4.x through 2.4.1 can expose arbitrary memory during a JSON.generate call
Type confusion exists in two methods of Ruby's WIN32OLE class, ole_invoke and ole_query_interface. Rated critical severi
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
Type confusion exists in _cancel_eval Ruby's TclTkIp class method. Rated critical severity (CVSS 9.8), this vulnerabilit
An exploitable heap overflow vulnerability exists in the Fiddle::Function.new "initialize" function functionality of Rub
An issue was discovered in Oniguruma 6.2.0, as used in Oniguruma-mod in Ruby through 2.4.1 and mbstring in PHP through 7
Stored XSS in Bugsink error tracking tool before 2.0.13 allows unauthenticated attackers to inject persistent scripts th
Ruby before 2.4.2, 2.3.5, and 2.2.8 is vulnerable to a malicious format string which contains a precious specifier (*) w
Heap-based buffer overflow in Ruby 1.8, 1.9 before 1.9.3-p484, 2.0 before 2.0.0-p353, 2.1 before 2.1.0 preview2, and tru
Heap-use-after-free in the Ruby json gem's native C extension (versions 2.20.0 through 2.21.1) allows an unauthenticated
EUVD-2026-116110
GHSA-7w38-ggh5-v542
NVD
CVE.org
Exploit-DB