Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach loopback /valid_token/ API locally
-
ExploitInject shell metacharacters in 'user' parameter
-
ExecutionParameter passed unescaped to shell_exec()
-
ImpactArbitrary commands execute as root
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK
2 techniques across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The attacker must be able to send HTTP requests to the CWP loopback API endpoint /valid_token/, which is bound to the local loopback interface (hence CVSS AV:L) - this means local access to the host or an intermediary that reaches 127.0.0.1 (e.g., an SSRF primitive, a misconfigured reverse proxy, or a co-tenant process), not direct Internet access to the route. Once reachable, no authentication is enforced on the route (PR:N) and no user interaction is needed (UI:N); the attacker simply supplies shell metacharacters in the 'user' parameter, which is passed unescaped into shell_exec(). Limiting factors: exploitation is gated on reaching the loopback-bound endpoint, and hosts running webpanel_version 1.30 or later are not affected. |
| Impact | Signals point in two directions that must be reconciled. On the severity side, this is an unvalidated OS command injection (CWE-78) reaching a shell_exec() call that runs as root, yielding full compromise of the host - the CVSS 4.0 vector confirms maximal vulnerable-system impact (VC:H/VI:H/VA:H) with low complexity (AC:L) and no privileges or user interaction (PR:N/UI:N), producing a base score of 8.6. On the exploitability side, the single most important limiter is AV:L: the vulnerable /valid_token/ endpoint is explicitly described as a LOOPBACK API, so the attacker must already be able to reach 127.0.0.1 on the host (local shell, a co-resident process, or a pivot such as SSRF/an exposed proxy) rather than attack it directly across the network. This creates an apparent tension worth stating plainly: the description calls the attacker 'unauthenticated' and says they 'send a crafted request,' which reads like a network vector, but the CVSS vector and the 'loopback API' wording make clear the access is local - unauthenticated here means no credential is checked on the route, NOT that it is internet-reachable. The vuln.today decision label is 'this_week' (not 'act_now'/'emergency'), and there is no EPSS score, no CISA KEV listing, and no confirmed public exploit in the supplied data, all of which argue against treating this as an active mass-exploitation event. Net: a genuinely serious root-RCE primitive that warrants prompt patching (a vendor fix exists), but its real-world priority is tempered by the local attack surface and the absence of exploitation evidence - prioritize it where CWP hosts are multi-tenant or exposed to SSRF/local pivots. |
| Exploit ScenarioDerived | An attacker who can issue requests to the CWP host's loopback interface - for example via local access on a shared/VPS host or by abusing a server-side request forgery or proxy path that reaches 127.0.0.1 - sends a crafted request to the /valid_token/ route with shell metacharacters embedded in the 'user' parameter. Because the parameter is passed unescaped into shell_exec(), the injected command runs as root, giving full host takeover. No public exploit is identified in the supplied data, though a VulnCheck advisory documents the flaw. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
OS command injection in Control Web Panel (CWP) versions before 1.30 lets attackers who can reach the loopback-bound /valid_token/ API route run arbitrary commands as root by placing shell metacharacters in the unvalidated 'user' parameter, which is passed unescaped to shell_exec(). Reachability is the gating factor: the route is bound to the loopback interface, so exploitation requires local host access or an intermediary such as an SSRF primitive, a misconfigured reverse proxy, or a co-tenant process that can reach 127.0.0.1 - no authentication or user interaction is enforced once the endpoint is reachable. No public exploit code or CISA KEV entry is present in the available data; the vendor has published a fix in the 1.30 changelog and the vulnerability is tagged for remediation this week.
RemediationAI
Upgrade Control Web Panel to webpanel_version 1.30 or later; the vendor marks the fix as available and the 1.30 changelog at https://control-webpanel.com/changelog is the authoritative reference, with the VulnCheck advisory at https://www.vulncheck.com/advisories/control-web-panel-cwp-os-command-injection-via-valid-token describing the affected route. Vendor-released patch: 1.30. Because the exploit path is the loopback API, pair the upgrade with compensating controls that hold until it is applied: block or restrict proxied access to 127.0.0.1 endpoints at any reverse proxy or gateway in front of the panel so external requests cannot be rewritten onto the loopback route, and review SSRF-capable components on the same host for paths that reach the panel port - the trade-off is that internal integrations legitimately calling loopback APIs may break. Validate that the 'user' parameter is no longer interpolated into shell_exec() in the deployed build, and treat any pre-1.30 host as potentially compromised by auditing shell history, process accounting and panel logs for unexpected root-level command execution. There is no patch version earlier than 1.30 to backport, so upgrading 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
Control Web Panel is a Linux web hosting control panel that provisions and manages accounts, domains, mail and DNS; because it administers the server, its own processes run with root privileges, making any command-execution flaw in its web tier a full-host compromise. The root cause class is CWE-78 (Improper Neutralization of Special Elements used in an OS Command): the loopback API handler for /valid_token/ takes the 'user' parameter and interpolates it directly into a string handed to PHP's shell_exec() without escaping, so metacharacters such as command separators or substitution characters break out of the intended command and execute in the shell context of the panel process. CPE data (cpe:2.3:a:control_web_panel:control_web_panel) marks all versions before webpanel_version 1.30 as affected; hosts at 1.30 or later are not affected. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H - local because the route is loopback-bound, unauthenticated because no check is enforced on the route, and with high confidentiality, integrity and availability impact due to root-level execution; the supplied CVSS 4.0 vector describes the same prerequisites. The trigger mechanism is stated in the source material as unvalidated parameter interpolation into shell_exec(); the exact request syntax is not described in the available sources.
Know when Control Web Panel 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:L/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Loopback-bound endpoint forces AV:L; the route checks no credentials (PR:N) and injection is straightforward (AC:L); shell_exec as root gives full C/I/A impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Control Web Panel (CWP) before webpanel_version 1.30 contains an OS command injection vulnerability in the loopback API /valid_token/ route that allows unauthenticated attackers to execute arbitrary commands as root by injecting shell metacharacters into the unvalidated 'user' parameter. Attackers can send a crafted request to the /valid_token/ route, which passes the parameter unescaped into a shell_exec() call.
Executive ViewAI
CWP versions prior to 1.30 contain a high-severity OS command injection that, if reachable, allows arbitrary root-level commands. The loopback interface restricts exposure, but any SSRF, misconfigured proxy, or co-tenant process could break that boundary, putting all hosted services and data at risk. Leadership should prioritize patching to prevent potential full server compromise.
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
More in Control Web Panel
View allUnauthenticated blind SQL injection in Control Web Panel (CWP) before 0.9.8.1225 lets remote attackers inject arbitrary
Unauthenticated OS command injection in Control Web Panel (CWP) builds prior to webpanel_version 1.16 lets remote attack
Control Web Panel (CWP) releases before webpanel_version 1.16 expose an OS command injection in the loopback /newpass/ p
Missing authentication in the Control Web Panel (CWP) loopback API service allows anyone who can reach the localhost-bou
Authentication bypass in Control Web Panel (CWP) builds before webpanel_version 1.12 lets remote attackers who know a si
Remote code execution in Control Web Panel (CWP) installations running a webpanel_version earlier than 1.16 allows an au
An authenticated low-privileged Control Web Panel (CWP) user can abuse path traversal in the module parameter handled by
OS command injection in Control Web Panel (CWP) versions before webpanel_version 1.30 lets an attacker who can reach the
Unauthenticated SQL injection in Control Web Panel (CWP) before webpanel_version 1.16 allows attackers who can reach the
Time-based blind SQL injection in Control Web Panel (CWP) releases prior to webpanel_version 1.30 allows an attacker who
EUVD-2026-115249
GHSA-79c3-cwrw-p52v
NVD
CVE.org
Exploit-DB