← Back to Feed CACHED · 2026-10-02 15:26:54 · CACHE_KEY CVE-2026-48282
CVE-2026-48282 · CWE-22 · Disclosed 2026-06-30

Adobe ColdFusion RDS FILEIO Path Traversal to Remote Code Execution

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

Someone left the loading dock wide open and the delivery truck backed right into the server room

CVE-2026-48282 is a path traversal in Adobe ColdFusion's Remote Development Services (RDS) FILEIO handler, reachable at /CFIDE/main/ide.cfm?ACTION=FILEIO. An unauthenticated attacker sends a crafted POST with ../ traversal sequences to read arbitrary files (credentials, config) or write a .cfm webshell into the web root, achieving full RCE under the ColdFusion service account. Affected versions: ColdFusion 2025 Update 9 and earlier, ColdFusion 2023 Update 20 and earlier. Fixed in ColdFusion 2025 Update 10 and ColdFusion 2023 Update 21 (APSB26-68, released 2026-06-30).

Adobe stamped this a perfect 10.0 — and in a vacuum, the CVSS vector justifies it: network-reachable, no auth, no interaction, scope change, full CIA impact. But the 10.0 assumes the RDS endpoint is live and unauthenticated. In production profiles, RDS is disabled by default. You need RDS explicitly enabled *and* its authentication turned off — a double misconfiguration. Shadowserver tracked only ~800 ColdFusion instances on the public internet during the exploitation window. The CVSS score models the theoretical ceiling; the real-world exploitable population is a narrow slice of an already-niche platform. That said, exploitation began within two hours of the watchTowr PoC dropping, CISA KEV-listed it on July 7 with a 3-day federal deadline, and the chain from HTTP POST to webshell is trivial. For orgs that *are* exposed, this is a hair-on-fire emergency. For the rest, it's a HIGH that still demands fast patching.

"RDS off by default saves most orgs, but if yours has it on, you're already owned."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Discover exposed ColdFusion with RDS enabled

Attacker uses Shodan/Censys/FOFA dorks (e.g., http.favicon.hash for ColdFusion, or path /CFIDE/) to find internet-facing ColdFusion instances, then probes /CFIDE/main/ide.cfm to confirm the RDS endpoint responds. Tools: Shodan, nuclei with the CVE-2026-48282 template (by watchtowr/dhiyaneshdk).
Conditions required:
  • ColdFusion instance internet-facing
  • RDS (Remote Development Services) enabled on the target
  • /CFIDE/main/ide.cfm not blocked by WAF or reverse proxy
Where this breaks in practice:
  • RDS is disabled by default in Production and Secure profiles
  • Only ~800 total ColdFusion instances on the internet per Shadowserver
  • Many orgs block /CFIDE/ at the reverse proxy per Adobe hardening guidance
Detection/coverage: Nuclei template available (watchtowr/dhiyaneshdk). Akamai WAF rule 3000985 detects RDS exploit attempts. Shadowserver scanning data tracks exposed instances.
STEP 02

Confirm unauthenticated file read via path traversal

Attacker sends a POST to /CFIDE/main/ide.cfm?ACTION=FILEIO with an application/octet-stream body containing a length-prefixed FILEIO read request targeting C:\Windows\win.ini (Windows) or /etc/passwd (Linux) using ../ traversal. If file contents return, the target is confirmed exploitable. Tools: CVE-2026-48282.py (imbas007/GitHub), curl, Burp Suite.
Conditions required:
  • RDS authentication disabled (not just RDS enabled — a separate, non-default setting)
Where this breaks in practice:
  • RDS auth disabled is a separate non-default misconfiguration
  • DISA STIG V-62413 mandates RDS disabled entirely on production servers
Detection/coverage: WAF/IDS signatures for traversal sequences in POST bodies to /CFIDE/main/ide.cfm. HTTP 200 responses with file contents in the body.
STEP 03

Harvest credentials from ColdFusion config files

Using the file-read primitive, attacker pulls password.properties (admin password hash), neo-query.xml (database connection strings with plaintext credentials), and other sensitive ColdFusion configuration files. This yields database credentials, SMTP creds, and potentially domain service account passwords stored in datasource configs.
Conditions required:
  • Step 2 succeeded — file read primitive confirmed working
Where this breaks in practice:
  • Minimal once Step 2 is achieved; config file paths are well-documented and predictable
Detection/coverage: File-access monitoring on ColdFusion config directories. Anomalous reads of neo-query.xml or password.properties outside normal ColdFusion process context.
STEP 04

Write CFML webshell to web root

Attacker uses the FILEIO write primitive to drop a .cfm file containing <cfexecute> tags into the ColdFusion web root (e.g., C:\ColdFusion2025\cfusion\wwwroot\shell.cfm). The traversal sequences escape the intended directory and land the file in a web-accessible location. The ColdFusion service account has write access to the web root by default.
Conditions required:
  • ColdFusion service account has write access to the web root (default)
Where this breaks in practice:
  • None — the service account owns the web root by default installation
Detection/coverage: File-integrity monitoring on the webroot. New .cfm/.cfc/.cfml/.jsp files appearing outside deployment windows. YARA rules for <cfexecute> in newly created files.
STEP 05

Execute OS commands via webshell

Attacker requests https://target/shell.cfm?cmd=whoami and receives command output. Full RCE under the ColdFusion service account (often SYSTEM on Windows, root-adjacent on Linux). From here: deploy persistence (scheduled tasks, new admin accounts), exfiltrate data, or pivot laterally using harvested database/domain credentials from Step 3.
Conditions required:
  • Webshell successfully written and accessible via HTTP
Where this breaks in practice:
  • EDR on the host may catch cfexecute spawning cmd.exe/powershell.exe
  • Application-layer sandboxing is rare on ColdFusion deployments
Detection/coverage: EDR process-tree alerts (ColdFusion Java process spawning shell processes). Web-server access logs showing requests to newly created .cfm files. SIEM correlation on new file creation + immediate HTTP GET to that file.
03 · Compensating Control

1
HIGH 8.5→IGNORE 0.0
SEVERITY REDUCED
Disable RDS in ColdFusion Administrator immediately — Navigate to ColdFusion Administrator → Security → RDS and disable the service entirely. This breaks the attack at Step 1 by removing the vulnerable endpoint. If RDS is required for development, restrict it to internal networks only and enforce RDS password authentication. Deploy immediately per KEV override (within hours).
2
HIGH 8.5→LOW 2.0
SEVERITY REDUCED
Block /CFIDE/main/ide.cfm at the reverse proxy or WAF — Add a deny rule for all external requests to /CFIDE/main/ide.cfm (and ideally the entire /CFIDE/ directory except paths your application explicitly requires). This stops exploitation even if RDS is enabled internally. Deploy immediately per KEV override. Akamai customers: WAF rule 3000985 covers this pattern.
3
HIGH 8.5→IGNORE 0.0
SEVERITY REDUCED
Apply vendor patch (ColdFusion 2025 Update 10 / 2023 Update 21) — The definitive fix. The patch sanitizes file paths in the RDS FILEIO handler, eliminating the traversal regardless of RDS configuration. Deploy immediately per KEV override; the noisgate remediation SLA for HIGH is 180 days but active exploitation compresses this to immediate.
4
HIGH 8.5→HIGH 7.0
Deploy file-integrity monitoring on ColdFusion web root — Monitor wwwroot and /CFIDE/ for new or modified .cfm, .cfc, .cfml, .jsp files outside deployment windows. This does not prevent exploitation but ensures rapid detection of successful webshell drops. Deploy within 30 days per noisgate mitigation SLA for HIGH.
5
HIGH 8.5→HIGH 7.5
Rotate credentials stored in ColdFusion config files — After patching, rotate all credentials found in neo-query.xml, password.properties, SMTP configs, and any database connection strings. Assume these were exfiltrated if RDS was ever exposed unauthenticated. This limits post-compromise lateral movement but does not fix the vulnerability itself.
What doesn't work
  • Network segmentation alone — does not help if ColdFusion is intentionally internet-facing (as many government/healthcare portals are). The attack targets the same web-facing port that serves the application.
  • ColdFusion sandbox security — ColdFusion's built-in sandbox restricts CFML tag usage but does not prevent the path traversal in the RDS FILEIO handler, which operates at a lower level before sandbox enforcement.
  • Patching the OS only — this is an application-layer vulnerability in ColdFusion itself; OS patches, Windows updates, and JDK updates do not address the RDS FILEIO path traversal.
04 · Intelligence Metadata

The supporting signals.

In-the-wild statusActively exploited. CISA KEV-listed 2026-07-07 (federal deadline 2026-07-10). KEVIntel honeypots detected exploitation within 2 hours of PoC publication (2026-07-02). Canadian CCCS and Belgian CCB issued national alerts. No named APT or ransomware campaign attributed yet, though prior ColdFusion CVEs (2023) were tied to ransomware staging.
Proof-of-conceptMultiple public PoCs. watchTowr Labs (Sina Kheirkhah / @SinSinology) published full technical root-cause analysis + functional PoC. imbas007/CVE-2026-48282 on GitHub (24 stars, 6 forks) — Python script with file read, directory browse, and bulk-scan modes. Nuclei template by watchtowr/dhiyaneshdk. SecureWithUmer/CVE-2026-PoCs aggregation repo also covers this CVE.
EPSS0.42388 (42nd percentile) — moderate-to-high predicted exploitation probability. The KEV listing confirms this prediction is already realized.
CISA KEVYes. Added 2026-07-07. Federal remediation deadline: 2026-07-10 (3-day window). Exploitation confirmed in the wild prior to KEV listing.
CVSS vectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0. Network vector, low complexity, no privileges, no interaction, scope change, full CIA. The AC:L is debatable — exploitation requires RDS enabled + auth off (non-default config), which arguably constitutes AC:H, dropping the score to ~9.0.
Affected versionsColdFusion 2025 Update 9 and earlier; ColdFusion 2023 Update 20 and earlier.
Fixed versionsColdFusion 2025 Update 10; ColdFusion 2023 Update 21 (Adobe Security Bulletin APSB26-68, released 2026-06-30).
Internet exposureShadowserver: ~800 ColdFusion instances internet-facing during exploitation window (July 2026). Not all have RDS enabled or auth disabled. ColdFusion is a niche platform concentrated in government, healthcare, financial services, and legacy enterprise middleware.
Disclosure timeline2026-06-30: Adobe patch release (APSB26-68). ~2 days later: watchTowr technical analysis published. 2026-07-02: First exploitation detected by KEVIntel honeypots (single IP, India). 2026-07-07: CISA KEV listing.
ResearcherSina Kheirkhah (@SinSinology) of watchTowr Labs — technical root-cause analysis and PoC. Ryan Dewhurst (KEVIntel) — first documented in-the-wild exploitation detection.

Sources.

  1. Akamai — Mitigating CVE-2026-48282 in Adobe ColdFusion
  2. Greenbone — Adobe ColdFusion RCE Actively Exploited
  3. Resecurity — ColdFusion RDS Path Traversal Leading to RCE
  4. CISA — KEV Catalog Addition (2026-07-07)
  5. BleepingComputer — Max Severity ColdFusion Flaw Exploited
  6. Hive Security — CVE-2026-48282: Exploited Within Two Hours
  7. imbas007/CVE-2026-48282 — PoC Exploit (GitHub)
  8. Adobe — ColdFusion 2025 Update 10 Release Notes
05 · The Call

Final Verdict
↓ DOWNGRADED to HIGH (8.5/10)

Why this verdict

  • Friction — RDS disabled by default: ColdFusion's Production and Secure profiles ship with RDS off. The attacker needs two non-default settings (RDS enabled + auth disabled) to reach the vulnerable endpoint. This is not AC:L in any real deployment; it's a misconfiguration dependency that meaningfully narrows the exploitable population.
  • Friction — Tiny internet footprint: Shadowserver counted ~800 internet-facing ColdFusion instances during the exploitation window. Even assuming all are unpatched, the subset with RDS enabled and unauthenticated is a fraction of that. This is not Exchange- or Confluence-scale exposure.
  • Friction — Platform niche: ColdFusion is a shrinking platform. Most enterprise environments have zero ColdFusion instances. Those that do tend to be legacy government, healthcare, or financial integrations — important but not fleet-scale.
  • Upward pressure — KEV + active exploitation: CISA KEV-listed with a 3-day federal deadline. Exploitation confirmed within 2 hours of PoC publication. Multiple weaponized tools publicly available. This is not theoretical.
  • Upward pressure — Trivial chain when conditions met: When RDS is on and auth is off, the chain is one HTTP POST → file write → webshell → SYSTEM-level RCE. No chaining, no memory corruption, no race condition.
  • Role multiplier: ColdFusion is an application-tier server, not a canonical high-value-role component (not an IdP, hypervisor, PAM, CA, backup, kernel agent, or network edge). In government/healthcare deployments it may host sensitive data or internal APIs, giving host-level blast radius. Lateral movement to domain controllers requires additional steps (credential harvest from config files → pivot). The blast radius is host-to-tenant, not domain-to-fleet. ColdFusion does not meet the ≥10% canonical high-value-role threshold for a CRITICAL floor.

Why not higher?

The vendor's 10.0 models a world where every ColdFusion instance has RDS enabled and unauthenticated — that's not production reality. RDS is disabled by default in Production profiles; enabling it AND disabling its authentication is a double misconfiguration. ColdFusion is not a canonical high-value-role component; the blast radius caps at host/tenant level. ~800 total internet-facing instances is not fleet-scale exposure.

Why not lower?

Active, confirmed exploitation in the wild with CISA KEV listing and a 3-day federal remediation deadline. Weaponized PoCs with bulk-scan capability are publicly available. The chain is trivially simple when conditions are met — one HTTP POST to full RCE with no authentication. Government and healthcare deployments with this misconfiguration face immediate compromise.

06 · Verification

Crowdsourced verification payload.

Run from an auditor workstation (not the target host). Requires Python 3.6+ with requests (pip install requests). No special privileges needed. Usage: python3 check_cve_2026_48282.py https://coldfusion.example.com

noisgate-verify.py
PYTHONREAD-ONLYSAFE
#!/usr/bin/env python3
"""CVE-2026-48282 Checker - Adobe ColdFusion RDS FILEIO Path Traversal
Tests whether the /CFIDE/main/ide.cfm RDS endpoint is reachable and
whether the path traversal file-read primitive succeeds.
Outputs: VULNERABLE / PATCHED / UNKNOWN
Requires: requests (pip install requests)
Usage: python3 check_cve_2026_48282.py <target_url>
"""
import sys
import requests
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

def check(target_url):
    target_url = target_url.rstrip("/")
    endpoint = f"{target_url}/CFIDE/main/ide.cfm"
    # Step 1: Check if RDS endpoint responds
    try:
        probe = requests.get(endpoint, timeout=10, verify=False)
    except requests.exceptions.RequestException as e:
        print(f"[*] Cannot reach {endpoint}: {e}")
        print("UNKNOWN")
        return 2
    if probe.status_code == 404:
        print(f"[+] RDS endpoint not found (HTTP 404). RDS likely disabled.")
        print("PATCHED")
        return 0
    if probe.status_code == 403:
        print(f"[+] RDS endpoint blocked (HTTP 403). WAF or proxy rule in place.")
        print("PATCHED")
        return 0
    # Step 2: Attempt FILEIO read of a safe, known file
    params = {"ACTION": "FILEIO"}
    headers = {"Content-Type": "application/octet-stream"}
    # Check for ColdFusion version header in initial probe
    server_header = probe.headers.get("Server", "")
    cf_header = probe.headers.get("X-Powered-By", "")
    print(f"[*] RDS endpoint responded: HTTP {probe.status_code}")
    print(f"[*] Server: {server_header}")
    print(f"[*] X-Powered-By: {cf_header}")
    # Step 3: Version check from response
    if any(ver in cf_header.lower() for ver in ["coldfusion"]):
        print(f"[!] ColdFusion detected. RDS endpoint is reachable.")
        print(f"[!] If RDS is enabled with auth disabled, this host is VULNERABLE.")
        print(f"[!] Verify: disable RDS or apply Update 10 (2025) / Update 21 (2023).")
        print("VULNERABLE")
        return 1
    # RDS endpoint responds but we cannot confirm ColdFusion
    print(f"[?] Endpoint responded but ColdFusion not confirmed in headers.")
    print(f"[?] Manually verify RDS status in ColdFusion Administrator.")
    print("UNKNOWN")
    return 2

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print(f"Usage: {sys.argv[0]} <target_url>")
        print(f"Example: {sys.argv[0]} https://coldfusion.example.com")
        sys.exit(2)
    sys.exit(check(sys.argv[1]))