Back to Intelligence

China-Nexus 'Armory Castle' Targets VMware vCenter with Suspected Zero-Day — Detection and Hardening Guide

SA
Security Arsenal Team
November 21, 2026
12 min read

During the most recent wave of major VMware vCenter security updates, a China-nexus threat actor — tracked publicly as Armory Castle — appears to have already been holding its next unpatched vulnerability in reserve. That's the uncomfortable headline: by the time defenders were scrambling to apply the last round of vCenter patches, this actor was positioned to pivot to a fresh flaw, maintaining persistent access to virtualization management infrastructure across victim environments.

If you operate vCenter — and in enterprise virtualization, the majority of you do — this is not an abstract nation-state story. vCenter is the keys to the kingdom. An attacker sitting on your vCenter Server Appliance (VCSA) can snapshot VMs, steal virtual disks, deploy payloads across every ESXi host under management, and harvest credentials from guest memory. China-nexus espionage groups have repeatedly demonstrated both the capability and the patience to dwell on these appliances for months, precisely because VCSA sits outside most organizations' EDR coverage.

This post breaks down what defenders need to know, how to hunt for compromise on the appliance itself, and how to harden vCenter against this class of attack.

Technical Analysis

What's at Stake: The vCenter Attack Surface

The affected product is VMware vCenter Server — predominantly the Linux-based vCenter Server Appliance (VCSA) running the Photon OS. The components most consistently abused in vCenter intrusions are:

  • vpxd — the core vCenter Server daemon (Java-based). Remote code execution flaws against vCenter services typically result in code running as a child of vpxd or related service processes.
  • vsphere-ui / vsphere-client web services — the HTML5 client and its plugins, historically a rich target for arbitrary file upload and webshell deployment (JSP webshells dropped into Tomcat webapps directories are the canonical post-exploitation artifact).
  • Lookup Service / SSO (vmware-stsd) — identity and authentication services, abused for token forgery and unauthorized session establishment.
  • Analytics and CEIP services — have appeared in multiple prior vCenter remote code execution chains.

The "Reserve Zero-Day" Pattern

The critical intelligence takeaway from this reporting is the actor's operational model. Sophisticated China-nexus groups targeting infrastructure appliances do not burn their best vulnerabilities reactively. They stockpile. When a vendor patch wave forces them to re-tool — because defenders are finally closing a known door — they already have the next exploit staged. This is consistent with long-documented behavior against VPN concentrators, email gateways, and hypervisor management planes: a pipeline of N-day-to-zero-day rotation designed to outlast patching cycles.

For defenders, the implication is blunt: patching the disclosed vulnerabilities is necessary but not sufficient. If Armory Castle (or a peer group) accessed your vCenter before you patched, they may have already established persistence that survives the patch — rogue local accounts, SSH keys, scheduled tasks, or webshells. Remediation without compromise assessment is incomplete remediation.

Exploitation Requirements and Attack Chain (Defender's View)

Based on the documented tradecraft for vCenter-targeting intrusions:

  1. Initial access: Exploitation of an internet-reachable or internally reachable vCenter service over HTTPS (TCP 443). vCenter instances exposed to the internet — a perennial Shodan problem — are at acute risk. Internally, an actor already in the network uses vCenter as a privilege-escalation and lateral-movement pivot.
  2. Code execution: A malformed request to a vulnerable service endpoint yields code execution in the context of the service (often a high-privilege account on the appliance).
  3. Webshell/persistence: JSP webshells written under Tomcat webapps paths (e.g., beneath /usr/lib/vmware-vsphere-ui/ or /usr/lib/vmware-sso/), creation of local users, enabling of SSH and the appliance shell, dropped SSH authorized_keys, or cron/systemd persistence.
  4. Espionage and lateral movement: Enumeration of managed ESXi hosts and VMs, credential harvesting from VM memory snapshots, and movement into guest workloads — often using legitimate vCenter APIs, which makes malicious activity blend into administrative noise.

Exploitation Status

Per the reporting, the vulnerability involved is unpatched at the time of the activity described — i.e., zero-day exploitation by a state-nexus actor against a known-target product. Organizations should treat internet-facing or broadly reachable vCenter instances as potentially compromised until proven otherwise and operate under an active-exploitation assumption: hunt first, patch and harden, then validate persistence is absent.

Detection & Response

A quick but vital framing note for your SOC: VCSA does not run Windows EDR agents. Your detection surface is log forwarding (configure remote syslog from VCSA to your SIEM — this is non-negotiable), network telemetry, and periodic forensic collection from the appliance. The detections below are engineered to fire on the post-exploitation behaviors these actors consistently exhibit, not on speculative signatures.

Sigma Rules

YAML
---
title: VCSA Service Process Spawning Shell or Command Interpreter
id: 3f8a1b62-7c94-4e21-b5d0-9a2e6f1c8d34
status: experimental
description: Detects vCenter core services (vpxd, vsphere-ui, Tomcat) spawning shells or scripting interpreters, consistent with post-exploitation of a vCenter remote code execution flaw.
references:
  - https://www.darkreading.com/cyberattacks-data-breaches/china-armory-castle-vmware-vcenter-zero-day
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/02/14
tags:
  - attack.execution
  - attack.t1059.004
  - attack.initial_access
  - attack.t1190
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentCommandLine|contains:
      - 'vpxd'
      - 'vsphere-ui'
      - 'vmware-stsd'
      - 'tomcat'
      - 'catalina'
  selection_child:
    CommandLine|contains:
      - '/bin/bash'
      - '/bin/sh'
      - 'appliancesh'
      - 'python'
      - 'perl'
      - 'curl'
      - 'wget'
      - 'base64'
  condition: selection_parent and selection_child
falsepositives:
  - Rare; legitimate vCenter service workflows occasionally invoke helper scripts, but interactive shells under vpxd or Tomcat warrant immediate investigation
level: high
---
title: JSP Webshell Dropped in vCenter Tomcat Webapps Directory
id: 8c2e7d41-5b06-4a38-9f17-2d4c8e6a1b90
status: experimental
description: Detects file creation of JSP content under vCenter web application directories, a hallmark persistence mechanism following vCenter exploitation.
references:
  - https://www.darkreading.com/cyberattacks-data-breaches/china-armory-castle-vmware-vcenter-zero-day
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/02/14
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: linux
detection:
  selection_path:
    TargetFilename|contains:
      - '/usr/lib/vmware-vsphere-ui/'
      - '/usr/lib/vmware-sso/'
      - '/usr/lib/vmware-lookupsvc/'
      - '/usr/lib/vmware-vsan/'
      - 'webapps'
  selection_ext:
    TargetFilename|endswith:
      - '.jsp'
      - '.jspx'
      - '.war'
  condition: selection_path and selection_ext
falsepositives:
  - vCenter patching and legitimate plugin deployment; correlate file writes with maintenance windows and authenticated admin sessions
level: high
---
title: vCenter Appliance SSH Enabled or Local Account Created
id: 5d91a3f7-2e48-4c6b-8a25-7f3c9d1e4b62
status: experimental
description: Detects activation of SSH or shell access and local account creation on the VCSA, techniques used by threat actors to establish durable appliance-level persistence.
references:
  - https://www.darkreading.com/cyberattacks-data-breaches/china-armory-castle-vmware-vcenter-zero-day
  - https://attack.mitre.org/techniques/T1136/
author: Security Arsenal
date: 2026/02/14
tags:
  - attack.persistence
  - attack.t1136.001
  - attack.t1078
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    CommandLine|contains:
      - 'useradd'
      - 'adduser'
      - 'shell.set --enabled'
      - 'ssh.set --enabled'
      - 'systemctl start sshd'
      - 'systemctl enable sshd'
  condition: selection
falsepositives:
  - Break-glass administrative procedures; verify against change records and investigate any account not in your baseline
level: high

KQL — Microsoft Sentinel Hunt (VCSA Syslog Ingestion)

This assumes VCSA remote syslog is flowing into Sentinel via a Linux collector (Syslog or CommonSecurityLog table). If your vCenter is not forwarding logs to a SIEM today, that gap is your first remediation item.

KQL — Microsoft Sentinel / Defender
// Hunt for post-exploitation indicators on vCenter Server Appliance
// Expected telemetry: VCSA remote syslog forwarded to Sentinel
let Lookback = 14d;
Syslog
| where TimeGenerated > ago(Lookback)
| where Computer has_any ("vcenter", "vcsa")  // adjust to your naming convention
| where SyslogMessage has_any (
    "useradd", "adduser",
    "authorized_keys",
    "shell.set", "ssh.set",
    "bash -i", "sh -i",
    "curl ", "wget ",
    "base64 -d",
    "/tmp/", "/var/tmp/"
  )
   or (SyslogMessage has "sshd" and SyslogMessage has "Accepted")
| project TimeGenerated, Computer, ProcessName, SyslogMessage, HostIP
| order by TimeGenerated desc
;
// Correlate: unexpected outbound connections FROM vCenter (management appliances
// should almost never initiate internet egress)
CommonSecurityLog
| where TimeGenerated > ago(Lookback)
| where SourceIP in ("<vCenter_IP_1>", "<vCenter_IP_2>")  // replace with your VCSA IPs
| where DeviceAction !in ("deny", "drop")
| where DestinationIP !startswith "10." 
  and DestinationIP !startswith "192.168." 
  and DestinationIP !startswith "172.16."
| summarize ConnectionCount = count(), Destinations = make_set(DestinationIP, 20), Ports = make_set(DestinationPort, 20) by SourceIP, bin(TimeGenerated, 1h)
| order by TimeGenerated desc

Velociraptor VQL — VCSA Forensic Triage

Velociraptor can be run against the Photon OS appliance for triage collection (or adapted to your appliance forensics tooling). This artifact hunts the exact persistence artifacts described above: recently modified JSP files in webapps paths, shell processes parented to Java/Tomcat services, and unexpected listeners or egress.

VQL — Velociraptor
-- Triage VCSA for webshells, rogue processes, and suspicious network state
-- Collect: modified webapp files, process tree, network connections

SELECT "jsp_file" AS ArtifactType,
       FullPath,
       Mtime AS ModifiedTime,
       Size
FROM glob(globs="/usr/lib/vmware-*/**/*.jsp")
WHERE Mtime > now() - (14 * 24 * 3600)
ORDER BY ModifiedTime DESC
VQL — Velociraptor
-- Shells or scripting interpreters spawned by vCenter service processes
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '^(bash|sh|python|perl|curl|wget|nc|ncat)$'
   OR CommandLine =~ 'bash -i|/dev/tcp/|base64 -d'
VQL — Velociraptor
-- Unexpected listening ports and outbound connections on the appliance
SELECT Pid, Name, Family, Type, LocalAddress, RemoteAddress, Status
FROM netstat()
WHERE Status =~ 'ESTABLISHED|LISTEN'
  AND NOT (RemoteAddress.Address =~ '^(10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[0-1])\.)' AND Status =~ 'ESTABLISHED')

Hardening & Verification Script — VCSA

Run from a jump box with SSH access to the appliance (enable SSH temporarily via the VAMI on port 5480, run, then disable). This checks build version against your expected patch baseline, audits local accounts, SSH keys, cron persistence, and recently modified webapp files — the exact artifacts Armory Castle-style actors leave behind.

Bash / Shell
#!/bin/bash
# vCenter Appliance compromise-assessment and hardening verification
# Run on the VCSA (Photon OS) via the appliance shell

set -u
OUT="/var/tmp/vcsa_triage_$(date +%Y%m%d_%H%M%S).txt"
{
  echo "=== BUILD VERSION ==="
  # Compare against Broadcom advisory fixed builds for the current patch wave
  /usr/lib/applmgmt/support/scripts/applmgmt.sh 2>/dev/null | head -5
  vpxd -v 2>/dev/null || true
  cat /etc/vmware/appliance/appliance-manifest.xml 2>/dev/null | grep -i -E 'version|build' | head -5

  echo "=== LOCAL ACCOUNTS (compare against baseline) ==="
  awk -F: '($3 >= 1000 || $1 == "root") {print $1 ":" $3 ":" $6 ":" $7}' /etc/passwd

  echo "=== SSH AUTHORIZED KEYS ==="
  find /root /home -name authorized_keys -exec ls -la {} \; -exec cat {} \; 2>/dev/null

  echo "=== SSHD STATUS (should be DISABLED in production) ==="
  systemctl is-enabled sshd 2>/dev/null; systemctl is-active sshd 2>/dev/null

  echo "=== CRON / SYSTEMD PERSISTENCE ==="
  ls -la /var/spool/cron/ /etc/cron.d/ 2>/dev/null
  systemctl list-unit-files --state=enabled | grep -v -E 'vmware|systemd|dbus|network|cron' 

  echo "=== RECENTLY MODIFIED WEBAPP FILES (last 14 days) ==="
  find /usr/lib/vmware-vsphere-ui /usr/lib/vmware-sso /usr/lib/vmware-lookupsvc \
       -name '*.jsp' -mtime -14 -exec ls -la {} \; 2>/dev/null

  echo "=== SUSPICIOUS PROCESSES (shells under service parents) ==="
  ps -eo pid,ppid,user,comm,args | grep -E 'bash|sh|python|perl|curl|wget' | grep -v grep

  echo "=== OUTBOUND CONNECTIONS ==="
  ss -tnp state established 2>/dev/null | grep -v -E '127\.0\.0\.1|::1'
} | tee "$OUT"

echo ""
echo "[+] Triage output saved to $OUT"
echo "[!] ACTION ITEMS:"
echo "    1. Confirm build matches the latest Broadcom/Broadcom Support Portal fixed release for your train"
echo "    2. Investigate ANY account, key, cron job, or JSP file not in your documented baseline"
echo "    3. Confirm remote syslog forwarding is active:  /etc/rsyslog.d/"
echo "    4. Disable SSH and appliance shell after triage:  shell.set --enabled false"

Remediation

Given that the flaw in this campaign is reportedly unpatched at time of exploitation, your remediation strategy is layered: contain, hunt, patch when available, and reduce the attack surface permanently.

  1. Eliminate internet exposure immediately. vCenter must never be reachable from the internet. Audit externally — scan your own perimeter for TCP 443/5480 on VCSA interfaces — and place vCenter behind a firewall allowing access only from a dedicated management VLAN and named admin jump hosts. This single control breaks the initial access vector for this class of attack.

  2. Apply the latest vCenter patch wave now, and monitor for the follow-on fix. Check your build against the current fixed releases on the Broadcom Support Portal / VMware Security Advisories. Subscribe to VMSA alerts so the patch addressing this suspected zero-day lands on your change calendar the day it ships — for actively exploited vCenter flaws, treat the vendor fix as a drop-everything emergency change. CISA has historically assigned aggressive remediation deadlines (often within days to weeks) for exploited vCenter vulnerabilities in the Known Exploited Vulnerabilities catalog; verify against CISA KEV and honor those timelines.

  3. Assume pre-patch compromise; hunt before you patch. Capture forensic state (run the triage script above, export syslog, snapshot the appliance) before patching, since a patch does not remove persistence. Validate the local account list, authorized_keys, cron/systemd units, and webapps directories against a known-good baseline. Any unexplained artifact on VCSA warrants a full IR engagement — do not clean and move on.

  4. Rotate credentials after patching. If compromise cannot be ruled out: rotate the vCenter SSO administrator password, all local appliance accounts, any AD/service accounts with vCenter privileges, and ESXi root credentials. Treat domain accounts used for vCenter-integrated authentication as exposed.

  5. Forward VCSA logs off-box — permanently. Configure remote syslog from the appliance to your SIEM. Without this, the Sigma/KQL detections above are dead letter. Also enable audit logging for vCenter authentication events and alert on SSO logins from non-management subnets.

  6. Harden the appliance posture: keep SSH and the appliance shell disabled by default (enable only for break-glass with change control), enforce MFA via your identity provider for vSphere Client access, and segment ESXi management interfaces so hosts accept connections only from vCenter and your management network.

  7. Watch the managed hosts, not just vCenter. After a vCenter intrusion, actors pivot to ESXi and guest VMs. Review ESXi shell/lockdown mode status, audit for unsigned VIBs, and validate VM inventory for unauthorized snapshots or newly created VMs — a classic espionage staging behavior.

The strategic lesson of the Armory Castle reporting is that vulnerability management against appliance-class infrastructure must be paired with continuous compromise assessment. Patch velocity alone will not beat an actor who keeps the next exploit in the chamber.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.