← Back to Feed CACHED · 2026-10-08 01:31:24 · CACHE_KEY CVE-2026-65643
CVE-2026-65643 · CWE-95 · Disclosed 2026-09-01

cPanel Domain Parking / Addon Domain Eval Injection to Root Code Execution

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

Like handing every hotel guest a master key that also opens the vault

CVE-2026-65643 is an eval-injection flaw in cPanel's domain-parking and addon-domain functionality. When an authenticated cPanel user submits a parked-domain name containing backtick-delimited shell commands through the Park API — reachable via /cpsessXXXXX/json-api/domain, /cgi-sys/domainpark.cgi, or the API2 route — cPanel passes the unsanitized input into a code-evaluation context. The resulting arbitrary file write escalates to root-level code execution, giving the attacker full control of the server and every tenant on it. Affected versions span the entire supported tree: builds before 11.110.0.141, 11.112.0.0 through 11.134.0.52, 11.136.0.0 through 11.136.0.36, 11.138.0.0 through 11.138.0.1, and WP Squared 11.138.1.0 through 11.138.1.6.

The vendor rated this HIGH at 8.8 with PR:L (low privilege required), and that label under-sells the real risk. On shared hosting — which is cPanel's *canonical* deployment — 'low privilege' means 'anyone who bought a hosting plan.' That is not a security gate; it is a business transaction. A single compromised or malicious tenant gets root, reads every database, exfiltrates every email, and pivots into backend infrastructure. With ~1.5 million cPanel instances internet-exposed per Rapid7/Shodan data and a full weaponized PoC toolkit already public (tc4dy/CVE-2026-65643-PoC-Toolkit, including exploit.py with reverse shell, webshell, persistence, and log cleanup), this is a CRITICAL-class vulnerability wearing a HIGH label.

"Any $5 hosting customer can get root on the box and own every tenant on it."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Obtain cPanel credentials

The attacker acquires valid cPanel account credentials. On shared hosting, this is as simple as purchasing a $5/month plan from any provider running vulnerable cPanel. Alternatively, credentials from prior breaches, phishing, or credential-stuffing attacks against cPanel's port-2083 login work equally well. The tc4dy toolkit accepts username/password as arguments.
Conditions required:
  • Valid cPanel account on the target server
  • Network access to cPanel ports (2082/2083 or 2086/2087)
Where this breaks in practice:
  • On self-hosted enterprise cPanel, obtaining credentials requires prior compromise or insider access
  • Some providers enforce MFA on cPanel login, blocking stolen-credential reuse
Detection/coverage: Failed login attempts visible in /var/log/cPanel-login.log and /usr/local/cpanel/logs/login_log. Rate-limiting or cPHulk brute-force protection may trigger alerts.
STEP 02

Fingerprint cPanel version

The attacker identifies the running cPanel build to confirm vulnerability. The tc4dy toolkit's exploit.py includes automated version detection. cPanel's login page, /login/?login_only=1 JSON response, and UAPI version endpoints leak the build number. Builds below the patch thresholds (11.110.0.141, 11.134.0.53, 11.136.0.37, 11.138.0.2, 11.138.1.7) are targets.
Conditions required:
  • Authenticated session or access to login page
Where this breaks in practice:
  • Some hardened providers strip version banners, though this is uncommon
Detection/coverage: Version-probing requests are low-signal and blend with normal login traffic.
STEP 03

Inject backtick payload via Park API

The attacker submits a parked-domain name containing backtick-delimited shell commands (e.g., ` id > /tmp/pwned ) through one of several API routes: the JSON API (/cpsessXXXXX/json-api/domain), legacy CGI (/cgi-sys/domainpark.cgi`), or the API2 wrapper. cPanel's domain-parking code passes this input into an eval context without sanitization. The tc4dy exploit.py automates payload delivery across all three endpoints.
Conditions required:
  • Authenticated session with parked/addon domain creation permission (default for all cPanel accounts)
  • At least one of the three API routes is accessible
Where this breaks in practice:
  • If the hosting provider has disabled the Parked Domains / Addon Domains features via WHM Feature Manager, the endpoints reject the request
  • WAFs inspecting request bodies for backtick or command-injection patterns may block the payload, but cPanel traffic is typically TLS-terminated at the server, bypassing network WAFs
Detection/coverage: Domain-creation events logged in /var/cpanel/logs and /usr/local/cpanel/logs/error_log. A domain name containing backticks or shell metacharacters is a high-fidelity IOC.
STEP 04

Arbitrary file write with elevated privileges

The eval injection causes cPanel's backend — running as root — to write attacker-controlled content to an arbitrary path on the filesystem. cPanel performs DNS zone writes and Apache vhost configuration changes with root privileges during domain provisioning. The attacker leverages this to write a PHP webshell, a cron entry, or an SSH authorized_keys file outside the tenant's home directory.
Conditions required:
  • Successful injection from step 3
Where this breaks in practice:
  • SELinux in enforcing mode *may* constrain write targets, but cPanel's own documentation recommends disabling SELinux, and most installations comply
Detection/coverage: File integrity monitoring (AIDE, OSSEC, Wazuh) on /etc/crontab, /root/.ssh/, and web-accessible directories outside tenant homedir would catch anomalous writes.
STEP 05

Root code execution and multi-tenant compromise

The written file executes in a root context — either via cron, Apache include, or direct invocation. The attacker now has unrestricted root access to the entire server. The tc4dy toolkit automates reverse shell, user creation, password changes, and log cleanup at this stage. Every tenant's files, databases (MySQL root), email, and SSL private keys are accessible. The attacker can pivot to backend networks, exfiltrate data, or deploy ransomware.
Conditions required:
  • Successful file write from step 4
Where this breaks in practice:
  • EDR agents (if present) may detect anomalous root process trees, but cPanel servers rarely run enterprise EDR
  • Network segmentation between the hosting server and backend infrastructure may limit lateral movement
Detection/coverage: Root process creation from unexpected parents (e.g., Apache child spawning bash) is detectable by auditd rules or EDR. Outbound reverse-shell connections to unusual ports are detectable by network monitoring.
03 · Compensating Control

1
CRITICAL 9.4→MEDIUM 5.5
SEVERITY REDUCED
Disable Parked Domains and Addon Domains features via WHM Feature Manager immediately — In WHM → Feature Manager, edit each feature list and uncheck *Parked Domains (Aliases)* and *Addon Domains*. This prevents tenant accounts from reaching the vulnerable Park API endpoints, breaking the attack chain at step 3. Deploy within the noisgate mitigation SLA of ≤3 days (CRITICAL). Note: this disrupts legitimate domain operations, so coordinate with hosting operations.
2
CRITICAL 9.4→HIGH 7.2
SEVERITY REDUCED
Restrict cPanel/WHM port access to trusted IPs — Firewall cPanel user ports (2082/2083) and WHM admin ports (2086/2087) to known management IPs only using iptables/firewalld or your cloud security group. This eliminates drive-by exploitation from arbitrary internet sources. Deploy within 3 days per noisgate mitigation SLA.
3
CRITICAL 9.4→HIGH 8.0
SEVERITY REDUCED
Enable cPHulk and enforce MFA on all cPanel accounts — cPHulk brute-force protection slows credential-stuffing. Enabling two-factor authentication (WHM → Security Center → Two-Factor Authentication) on all accounts raises the bar for credential-based exploitation from stolen or purchased accounts. Not a standalone fix — a legitimate tenant with MFA can still exploit the vuln — but blocks opportunistic reuse of breached credentials.
4
CRITICAL 9.4→CRITICAL 9.0
Deploy file integrity monitoring on critical paths — Configure OSSEC, Wazuh, or AIDE to monitor /etc/crontab, /etc/cron.d/, /root/.ssh/authorized_keys, /var/spool/cron/, and all web-accessible directories outside tenant homedirs. Alert on file creation by unexpected processes. This does not prevent exploitation but enables rapid detection and response.
5
CRITICAL 9.4→IGNORE 0.0
SEVERITY REDUCED
Apply vendor patch to fixed builds — Update cPanel to 11.110.0.141+, 11.134.0.53+, 11.136.0.37+, 11.138.0.2+, or WP Squared 11.138.1.7+ via /usr/local/cpanel/scripts/upcp --force. This is the definitive remediation. Deploy within the noisgate remediation SLA of ≤90 days, though given the CRITICAL rating and public PoC, treat this as urgent — aim for days, not weeks.
What doesn't work
  • Network WAF in front of cPanel — cPanel terminates TLS itself on ports 2082/2083; traffic between the client and cPanel is encrypted end-to-end and does not pass through a network WAF in most deployments. Even where a reverse proxy is used, the injection payload is a syntactically valid domain name and is unlikely to trigger generic WAF rules.
  • ModSecurity on Apache — The vulnerable code path is in cPanel's Perl backend, not in Apache request handling. ModSecurity rules do not inspect cPanel API requests.
  • CloudLinux CageFS tenant isolation — CageFS isolates tenants from each other at the filesystem level, but the vulnerability executes as root *before* CageFS boundaries apply. Root trivially escapes CageFS.
  • Disabling SSH for tenant accounts — The injection vector is the cPanel web interface (port 2083), not SSH. Disabling shell access does not prevent exploitation.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNo confirmed exploitation of CVE-2026-65643 specifically. However, cPanel was mass-exploited earlier in 2026 via CVE-2026-41940 (auth bypass, 44,000+ servers compromised, .sorry ransomware). The ecosystem is under active attacker attention.
PoC / exploit availabilityPublic weaponized toolkit: tc4dy/CVE-2026-65643-PoC-Toolkit (13 stars, 4 forks) — includes exploit.py (full chain: auth → version detect → injection → webshell → reverse shell → persistence → log cleanup) and verifier.py (safe blue-team checker). Published ~Sep 3, 2026.
EPSS0.00875 (0.875%), approximately 58th percentile. Moderate probability of exploitation in the next 30 days, but this metric lags behind PoC publication.
CISA KEVNot listed as of 2026-10-08. Given no confirmed in-the-wild exploitation, KEV addition is not imminent but the weaponized PoC increases the likelihood.
CVSS vectorCVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H — 8.8 HIGH. Note: S:U (Scope Unchanged) understates multi-tenant impact. CVSS 4.0 scores this at 8.7. Neither captures the shared-hosting reality where PR:L ≈ unauthenticated.
Affected versionscPanel & WHM: <11.110.0.141, 11.112.0.0–<11.134.0.53, 11.136.0.0–<11.136.0.37, 11.138.0.0–<11.138.0.2. WP Squared: 11.138.1.0–<11.138.1.7. Essentially all supported release lines.
Fixed versions11.110.0.141, 11.134.0.53, 11.136.0.37, 11.138.0.2, 11.138.1.7 — released as unscheduled security update on 2026-08-27.
Internet exposure~1.5 million cPanel/WHM instances internet-exposed per Rapid7/Shodan. Earlier CVE-2026-41940 campaign demonstrated mass exploitation feasibility across this surface.
Disclosure date2026-08-27 (unscheduled advisory), CVE published 2026-09-01. No researcher credit published by WebPros.
DiscovererNot credited. WebPros published no researcher name, CVSS score, or CWE in their original advisory — an unusually thin disclosure for a root-RCE flaw.

Sources.

  1. The Hacker News — Critical cPanel Flaw Could Let One Hosting Customer Take Root Control
  2. tc4dy/CVE-2026-65643-PoC-Toolkit — GitHub
  3. Mallory.ai — Root Code Execution in cPanel Domain Parking (CVE-2026-65643)
  4. Offseq Threat Radar — CVE-2026-65643 Live Threat Intelligence
  5. Cyber Kendra — cPanel Patches CVE-2026-65643 Root Code Execution Flaw
  6. SupportPro — CVE-2026-65643 cPanel Domain Parking Vulnerability and Patch Guide
  7. Censys — The cPanel Situation (CVE-2026-41940 exposure context)
  8. PK Sharma — cPanel CVE-2026-65643: one tenant to root, and a thin advisory
05 · The Call

Final Verdict
↑ UPGRADED to CRITICAL (9.4/10)

Why this verdict

  • PR:L is fiction on shared hosting. cPanel's canonical deployment is shared hosting. 'Low privilege required' means 'buy a hosting plan' — a $5 transaction, not a security barrier. This makes the effective attack vector unauthenticated-equivalent for the majority of the ~1.5M exposed instances.
  • Full weaponized PoC eliminates attacker development cost. The tc4dy toolkit provides a turnkey exploit chain from authentication through root shell to log cleanup. The window between PoC publication (~Sep 3) and now (~5 weeks) is more than enough for integration into automated scanning frameworks.
  • Role multiplier: cPanel is canonically a multi-tenant management plane. ≥90% of cPanel installations serve shared hosting — multiple tenants per server. Root compromise means full access to every website, database, email account, and SSL private key on the box. This is analogous to a hypervisor escape: one tenant breaks isolation for all. The blast radius is tenant→server→all-tenants, which maps to 'mass data egress' outcome. Per the floor rule, this sets a CRITICAL floor because the affected component *is* the multi-tenant management component by definition.
  • Attack surface is massive and attacker-familiar. 1.5M internet-exposed instances per Shodan/Rapid7. cPanel was already mass-exploited via CVE-2026-41940 earlier this year (44K servers, ransomware). Attackers have tooling, target lists, and operational playbooks for this ecosystem.
  • CVSS Scope:Unchanged is wrong for multi-tenant. The CVSS 3.1 vector uses S:U, which means the score does not reflect cross-tenant impact. Correcting to S:C would push the base score above 9.0, aligning with our reassessment.

Why not higher?

A 9.4 is already near the ceiling. We stop short of 10.0 because the vulnerability *does* require a valid cPanel account (not truly unauthenticated), some providers have disabled domain-parking features or enforce MFA, and there is no confirmed in-the-wild exploitation of this specific CVE yet. A pre-auth variant or confirmed mass exploitation would push this to 9.8+.

Why not lower?

The authentication requirement is trivially met on shared hosting — cPanel's dominant deployment model — making downgrade for PR:L inappropriate. The full weaponized PoC, root-level impact, multi-tenant blast radius, and 1.5M exposed instances together mean that any severity below CRITICAL underestimates the real-world risk. The earlier CVE-2026-41940 mass-exploitation campaign proves this attack surface is actively targeted. Friction points (MFA, disabled features, EDR) apply to <5% of the installed base.

06 · Verification

Crowdsourced verification payload.

Run this script on each cPanel server as root (or any user that can read /usr/local/cpanel/version). Usage: bash check_cve_2026_65643.sh. No arguments needed. Outputs VULNERABLE, PATCHED, or UNKNOWN with the detected version.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_cve_2026_65643.sh — Verify patch status for CVE-2026-65643
# cPanel eval injection in domain parking / addon domain functionality
# Run on target cPanel server. No arguments required. Needs read access to /usr/local/cpanel/version.

set -euo pipefail

VERSION_FILE="/usr/local/cpanel/version"

if [[ ! -f "$VERSION_FILE" ]]; then
  echo "UNKNOWN — cPanel not detected (${VERSION_FILE} not found)"
  exit 2
fi

VERSION=$(cat "$VERSION_FILE" | tr -d '[:space:]')
echo "Detected cPanel version: ${VERSION}"

# Parse major.minor.patch.build
IFS='.' read -r V1 V2 V3 V4 <<< "$VERSION"

# Combine for numeric comparison: use V2 as release line, V3.V4 as build
RELEASE="${V2}"
BUILD_MAJOR="${V3}"
BUILD_MINOR="${V4}"

version_gte() {
  # Compare two dotted versions: returns 0 if $1 >= $2
  local IFS=.
  local i a=($1) b=($2)
  for ((i=0; i<${#b[@]}; i++)); do
    local ai=${a[i]:-0}
    local bi=${b[i]:-0}
    if ((10#$ai > 10#$bi)); then return 0; fi
    if ((10#$ai < 10#$bi)); then return 1; fi
  done
  return 0
}

# Determine patch status based on release line
# Fixed versions:
#   110 line: 11.110.0.141
#   112-134 line: 11.134.0.53
#   136 line: 11.136.0.37
#   138.0 line: 11.138.0.2
#   138.1 line (WP Squared): 11.138.1.7

RESULT="UNKNOWN"

case "$RELEASE" in
  110)
    if version_gte "${BUILD_MAJOR}.${BUILD_MINOR}" "0.141"; then
      RESULT="PATCHED"
    else
      RESULT="VULNERABLE"
    fi
    ;;
  112|114|116|118|120|122|124|126|128|130|132|134)
    if [[ "$RELEASE" -eq 134 ]] && version_gte "${BUILD_MAJOR}.${BUILD_MINOR}" "0.53"; then
      RESULT="PATCHED"
    elif [[ "$RELEASE" -lt 134 ]]; then
      RESULT="VULNERABLE"
    else
      RESULT="VULNERABLE"
    fi
    ;;
  136)
    if version_gte "${BUILD_MAJOR}.${BUILD_MINOR}" "0.37"; then
      RESULT="PATCHED"
    else
      RESULT="VULNERABLE"
    fi
    ;;
  138)
    if [[ "$BUILD_MAJOR" -eq 1 ]]; then
      # WP Squared line: 11.138.1.x
      if version_gte "${BUILD_MAJOR}.${BUILD_MINOR}" "1.7"; then
        RESULT="PATCHED"
      else
        RESULT="VULNERABLE"
      fi
    elif [[ "$BUILD_MAJOR" -eq 0 ]]; then
      if version_gte "${BUILD_MAJOR}.${BUILD_MINOR}" "0.2"; then
        RESULT="PATCHED"
      else
        RESULT="VULNERABLE"
      fi
    else
      # Build major > 1 implies newer than patched
      RESULT="PATCHED"
    fi
    ;;
  *)
    if [[ "$RELEASE" -lt 110 ]]; then
      RESULT="VULNERABLE"
    elif [[ "$RELEASE" -gt 138 ]]; then
      RESULT="PATCHED"
    else
      RESULT="UNKNOWN"
    fi
    ;;
esac

echo "${RESULT} — cPanel ${VERSION} (release line ${RELEASE})"

case "$RESULT" in
  VULNERABLE) exit 1 ;;
  PATCHED)    exit 0 ;;
  *)          exit 2 ;;
esac