Skip to main content

Elo EUVDEUVD-2026-116110

| CVE-2026-44266 CRITICAL
Code Injection (CWE-94)
2026-11-03 GitHub_M GHSA-7w38-ggh5-v542
9.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted Elo program to Ruby target
  2. Exploit
    Compiler emits unescaped #{...} into Ruby string literal
  3. Execution
    Backtick interpolation executes when compiled Ruby runs
  4. Impact
    Arbitrary 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 '#{id}' and submits it to the elo-lang.org /try playground with the Ruby target selected, or to any service that compiles attacker-supplied Elo to Ruby and runs it. Because the Ruby emitter does not escape '#', the emitted double-quoted Ruby string interpolates the attacker's '#{...}' expression and its backticks execute a shell command on the host at runtime. A working proof-of-concept for both sinks is published in the GHSA advisory and was verified against Ruby 3.x, and exploitation needs no authentication or user interaction against the network playground surface.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
Patch available

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

Alert me

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

elo < 1.0.1

Affected Packages

euvd elo fix: 1.0.1

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

Vendor (GitHub_M) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/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:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Nov 03, 2026 - 19:18 EUVD
CVE Published
Nov 03, 2026 - 17:51 cve.org
CRITICAL 9.8

DescriptionCVE.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.

Technical POC Analysis

CWE-94: improper neutralization of Ruby interpolation metacharacters in generated code.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

Prevalence
Rare
niche no-code expression-language DSL, tiny @enspirit/elo npm footprint
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Social Media
2
Sightings
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org Vulnrichment GHSA CIRCL GitHub

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 N/A
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

Priority Score

69
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +49
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.

More in Ruby

View all
CVE-2017-17405 HIGH POC
8.8 Dec 15

Ruby before 2.4.3 allows Net::FTP command injection. Rated high severity (CVSS 8.8), this vulnerability is remotely expl

CVE-2017-17790 CRITICAL POC
9.8 Dec 20

The lazy_initialize function in lib/resolv.rb in Ruby through 2.4.3 uses Kernel#open, which might allow Command Injectio

CVE-2017-14064 CRITICAL POC
9.8 Aug 31

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

CVE-2016-2336 CRITICAL POC
9.8 Jan 06

Type confusion exists in two methods of Ruby's WIN32OLE class, ole_invoke and ole_query_interface. Rated critical severi

CVE-2026-77602 CRITICAL POC
9.9 Sep 23

Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in

CVE-2016-2337 CRITICAL POC
9.8 Jan 06

Type confusion exists in _cancel_eval Ruby's TclTkIp class method. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2016-2339 CRITICAL POC
9.8 Jan 06

An exploitable heap overflow vulnerability exists in the Fiddle::Function.new "initialize" function functionality of Rub

CVE-2017-9225 CRITICAL POC
9.8 May 24

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

CVE-2026-27614 CRITICAL POC
9.3 Feb 25

Stored XSS in Bugsink error tracking tool before 2.0.13 allows unauthenticated attackers to inject persistent scripts th

CVE-2017-0898 CRITICAL POC
9.1 Sep 15

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

CVE-2013-4164 MEDIUM POC
6.8 Nov 23

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

CVE-2026-71847 HIGH POC
8.7 Aug 07

Heap-use-after-free in the Ruby json gem's native C extension (versions 2.20.0 through 2.21.1) allows an unauthenticated

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