Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain account with custom_fields manage permission
-
DeliveryCreate select_eval custom field with malicious Ruby in command option
-
ExploitRender post edit page triggers instance_eval in ERB
-
ExecutionExecute arbitrary Ruby as web server process
-
ImpactFull server-side compromise
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 | Requires an authenticated account that has been granted the 'custom_fields manage' permission (in versions ≤2.9.1 the select_eval field type is not gated by a dedicated permission). The attacker must be able to create/edit a select_eval custom field and set its field options 'command' parameter; code execution fires when a post edit page containing that field is rendered (instance_eval within an ERB view). Limiting factors: exploitation is impossible without the manage permission (not exposed to anonymous/unauthenticated users), and the fix (2.9.2, PR #1136) adds an explicit 'select_eval' permission plus model-layer authorization so that only admins or explicitly-granted roles can use the field type. Not exploitable against default configurations where untrusted users lack custom-field management rights. |
| Impact | This is a genuine but access-gated code-execution flaw rather than a mass-exploitation crisis. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, VC/VI/VA:H, base 8.7) is internally consistent with the description: network-reachable, low complexity, but requiring low privileges (PR:L) because the attacker must hold the 'custom_fields manage' permission - this is an authenticated, privileged-user attack, not a drive-by. SSVC reinforces a measured priority: Exploitation=poc (not 'active'), Automatable=no (a valid account with a specific permission is a precondition that resists mass automation), Technical Impact=total (full RCE once triggered). EPSS is 0.74% at the 51st percentile - low absolute probability, consistent with a POC-but-not-widely-weaponized posture. There is NO CISA KEV listing and NO evidence of active exploitation. Public exploit code exists (theopaid PoC on GitHub plus two independent write-ups), so weaponization potential is real and the barrier to reproduction is low for anyone with the required account. Net: prioritize patching where Camaleon CMS grants non-admin users custom-field management, but treat this as an insider/privilege-escalation-chain risk (total impact behind a permission gate) rather than an unauthenticated internet-facing emergency. Signals are consistent, not conflicting. |
| Exploit ScenarioDerived | An attacker who holds (or has compromised) a Camaleon CMS account with the 'custom_fields manage' permission creates a select_eval custom field and stores a malicious Ruby expression in the field options 'command' parameter. When any post edit page bearing that field is rendered, the expression is evaluated via instance_eval inside an ERB view, running arbitrary Ruby as the web server process. A public PoC and multiple write-ups exist, so reproduction requires minimal skill once a suitable account is obtained. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Authenticated remote code execution in Camaleon CMS 2.1.1 through 2.9.1 lets users who hold the custom_fields manage permission store an arbitrary Ruby expression in the 'command' option of a select_eval custom field, which is then evaluated via instance_eval inside an ERB view whenever a post edit page is rendered, yielding code execution with web-server process privileges. Publicly available exploit code exists (including a public proof-of-concept repository and writeup), but the flaw is not listed in CISA KEV and EPSS is modest at 0.74% (51st percentile), so practical risk concentrates on installations that delegate custom-field management to non-administrative roles. The vulnerability requires an authenticated principal with that permission (CVSS vector PR:L), and is not reachable by anonymous users.
RemediationAI
Upgrade to Camaleon CMS 2.9.2, the vendor-released patch that fixes this issue via PR #1136 and commit 158823668e2e5c3114a69b34cf1c96cb41533c5f; release notes explicitly urge upgrading ASAP (https://github.com/owen2345/camaleon-cms/releases/tag/2.9.2). Because 2.9.2 ships BREAKING authorization changes alongside this fix, plan and test the upgrade: all plugin admin routes now require manage :plugins by default, and all MediaController endpoints (upload, download_private_file, crop, actions) now require :manage, :media, so third-party plugins and custom integrations that relied on the looser checks may need role or plugin adjustments. If immediate upgrade is not possible, remove the custom_fields manage permission from every non-administrator role so the select_eval field type becomes unreachable, accepting that legitimate custom-field administration workflows will break for those users; additionally audit and delete existing select_eval custom fields and inspect their stored options 'command' values in the database for injected Ruby payloads, since the payload persists and re-executes on every render of the affected post edit page. After upgrading, grant the new dedicated 'select_eval' permission only to trusted administrators via the User Roles UI (appears as 'Select Eval' under Manager Permissions) and review web-server and Rails logs for evidence of prior instance_eval payload execution. Public proof-of-concept material exists at https://github.com/theopaid/Camaleon-CMS---Authenticated-RCE-via-select_eval-Custom-Field and https://tpaidakis.com/writeups/camaleon-cms-rce-select-eval/, which defenders can use to validate detection coverage.
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
Camaleon CMS is a Ruby on Rails content management system whose extensibility model includes user-defined 'custom field' types attached to content models. One built-in field type, select_eval, is designed to evaluate a stored Ruby expression supplied through the field's options 'command' parameter; the stored string is passed to Ruby's instance_eval from within an ERB template at render time on the post edit page. Because the value is developer-controllable data rather than code, this is a textbook CWE-94 (Improper Control of Generation of Code / Code Injection) pattern: untrusted configuration data crosses into an eval sink without validation. In versions 2.1.1 through 2.9.1 the select_eval field type was gated only by the general custom_fields manage capability, so any role granted that capability could reach the eval sink. The upstream fix (release 2.9.2, PR #1136, commit 158823668e2e5c3114a69b34cf1c96cb41533c5f) introduces a dedicated select_eval permission surfaced in the Roles UI, enforces authorization at the model layer rather than relying on controller-level checks, and adds an ActiveSupport::CurrentAttributes-based CurrentRequest helper for thread-safe, request-scoped access to current_user and current_site. The same 2.9.2 release also bundles unrelated access-control hardening (MediaController authorization, centralized plugin admin authorization), indicating a broader authorization review in the codebase.
Know when Camaleon Cms 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable web app, low complexity, but requires a low-privileged account holding custom_fields manage permission (PR:L); RCE yields full C/I/A within the web process, no scope change.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Camaleon CMS versions 2.1.1 through 2.9.1 contains an authenticated remote code execution vulnerability that allows users with custom_fields manage permission to execute arbitrary Ruby code by supplying a malicious expression through the select_eval custom field type. Attackers can store an attacker-controlled Ruby expression in the field options command parameter, which is evaluated via instance_eval within an ERB view whenever a post edit page is rendered, achieving server-side code execution with web server process privileges.
Latest POC
1 PoC candidate from github (unverified)
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Camaleon CMS releases 2.1.1 through 2.9.1 are affected by an authenticated remote code execution flaw that lets any user holding custom-field management rights run arbitrary code on the web server hosting the site. The practical exposure is concentrated in organizations that delegate custom-field or content administration to editors, contractors, or other non-administrative accounts, because the attack requires only that permission rather than full administrative access. Leadership should care because successful exploitation yields code execution at web-server privilege, putting site content, customer data, and any credentials or integrations reachable from that host at risk, and publicly available exploit code exists.
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.
More in Camaleon Cms
View allCamaleon CMS is a dynamic and advanced content management system based on Ruby on Rails. Rated critical severity (CVSS 9
Camaleon CMS v2.7.0 was discovered to contain a Server-Side Template Injection (SSTI) vulnerability via the formats para
Camaleon CMS is a dynamic and advanced content management system based on Ruby on Rails. Rated high severity (CVSS 7.7),
Cross Site Scripting vulnerability in camaleon-cms v.2.7.5 allows remote attacker to execute arbitrary code via the cont
Camaleon CMS 0.1.7 to 2.6.0 doesn’t terminate the active session of the users, even after the admin changes the user’s p
Camaleon CMS releases before 2.9.3 let an authenticated user who holds only the 'media' permission escape the site's tem
Camaleon CMS releases before 2.9.2 enforce only authentication, not authorization, on the Admin::MediaController endpoin
In Camaleon CMS application, versions 0.0.1 to 2.6.0 are vulnerable to stored XSS, that allows an unauthenticated attack
In the 2.4 version of Camaleon CMS, Stored XSS has been discovered. Rated medium severity (CVSS 6.1), this vulnerability
Camaleon CMS versions 2.4.5.0 through 2.9.0, prior to commit f54a77e, contain a path traversal vulnerability in the AWS
Draft post creation in Camaleon CMS through 2.9.2 allows any authenticated low-privileged user to create and overwrite d
Category-management authorization bypass in Camaleon CMS before 2.9.2 lets an authenticated low-privileged user rename o
EUVD-2026-49871
GHSA-7xm9-634w-f5r7
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB