Auditing Internet-Exposed vCenter for CVE-2026-123890: Patch Priority and Log Evidence

Auditing Internet-Exposed vCenter for CVE-2026-123890: Patch Priority and Log Evidence

pr0h0••26 min read•hacking
AI Usage (82%)
On this page

Introduction

When a vCenter zero-day lands, the first discussion is usually patch timing. That's the wrong first question. CVE-2026-123890 is reported as an authentication-bypass flaw in vCenter that was exploited as a zero-day for roughly two months before Broadcom shipped fixes. Reported activity includes hijacking administrator accounts and pulling VM data out. This post is a practical audit guide for internet-exposed vCenter: confirm exposure, rank patch priority for a virtualization control plane, and hunt log evidence of admin hijacking and VM data theft. If your vCenter was internet-reachable during that window, patch timing is already behind you. The real question is whether someone minted a session on your control plane.

My position: for this class of flaw, "patch, then verify" is too slow and too narrow. Isolate first, patch, rotate credentials, then hunt assuming an attacker had admin rights. The rest of this post follows that order.

I did not have hands-on access to an affected appliance or the full technical detail from the vendor advisory while writing this. I'll keep what public reporting actually states separate from what I'm inferring from the authentication-bypass bug class.

Why an Internet-Exposed vCenter Is a Control-Plane Compromise, Not an App Bug

What a vCenter Admin Token Actually Grants

People underestimate vCenter because it looks like a web app with a login page. It isn't. A vCenter administrator session is a bearer credential over the entire virtualization inventory, and the API behind it is far more powerful than most admin panels.

A single authenticated session can:

  • enumerate every cluster, host, datastore, network, and VM across all linked data centers
  • read and modify VM configuration, including attaching a disk from another VM
  • clone or export VMs, which is a data-copy primitive disguised as an ops feature
  • take snapshots and read snapshot disk contents
  • run guest operations inside a VM where VMware Tools is installed and guest ops are enabled
  • register new extension plugins, which run server-side inside vpxd
  • manipulate roles, permissions, identity sources, and solution users
  • reach the vSphere Automation REST API and the appliance management endpoint (VAMI) on the same appliance

None of that requires a memory-corruption exploit or dropping a binary. It's documented API surface. An attacker with an admin token doesn't need malware. They need Invoke-RestMethod.

The Blast Radius Difference Between vCenter and a Normal Web App

PropertyTypical web appvCenter
What the admin session controlsapplication datahypervisor control plane
Lateral movementthrough app trust relationshipsto every ESXi host and guest VM
Data accessrows the app storesraw virtual disks for the whole estate
Persistence optionsapp users, API keysSSO users, roles, plugin extensions, solution certs
Detection surfaceapp logs, WAFvpxd logs, SSO/STS logs, task history, netflow
Recoveryrestore app datarebuild trust in the whole virtual estate

That last row is why this is a control-plane incident. You can't "restore from backup" your way out of an attacker who had vCenter admin, because the thing you'd restore onto is the thing that was compromised.

What the Public Record Actually Says About CVE-2026-123890

Confirmed From Public Reporting

These points come from the published coverage (BleepingComputer, CyberSecurityNews, Cyber Kendra, MLQ.ai) and the details they attribute to Broadcom and researchers:

  • The flaw is tracked as CVE-2026-123890 and is described as an authentication-bypass issue in VMware vCenter.
  • Exploitation is reported to have started in September 2026, roughly two months before a patch existed.
  • Reported post-exploitation activity includes hijacking administrator accounts and stealing VM data.
  • The activity is attributed to suspected Chinese threat actors in the reporting. I have not seen the underlying attribution evidence, so treat that as a reporting claim, not a fact to build detection on.
  • Broadcom released fixes across affected branches, with advisories published around 19–20 November 2026.
  • CISA and researchers urged immediate patching specifically for internet-exposed management interfaces.

Still Unconfirmed and Treated as Inference

I'm not going to invent precision the public record doesn't contain. As of writing, these are unknown to me:

  • the exact affected build ranges and which branches got fixes (read your vendor advisory, not this post)
  • the CVSS vector and whether the bypass is fully pre-authentication over the network or requires some prior foothold
  • whether the flaw lives in the SDK/vpxd endpoint layer, the SSO/STS token path, or a VAMI/appliance endpoint
  • whether the attackers used a registered plugin extension for persistence, and whether any webhook or event exporter was abused for exfiltration
  • whether the CVE has been added to the CISA KEV catalog by the time you read this
  • the total victim count and whether data theft was confirmed at specific named organizations

Everything below about mechanics is my reconstruction from how authentication-bypass flaws in this product family typically behave. I'll mark it as inference where it matters.

CVE-2026-123890 Exploitation Timeline From Public Details

September 2026 — First Exploitation Before Any Patch Existed

Reporting places the start of exploitation in September 2026. The exact first-seen date isn't public; "since September" is the phrasing used, so an early-September start is likely but unconfirmed. At that point there was no patch, no advisory, and no signature. Defenders had no CVE number to grep for.

This is the part people skip when they read the post-mortem. For roughly eight weeks, the only possible defenses were architectural: don't expose the management interface, and alert on admin behavior instead of known-bad indicators.

Two Months of Quiet Dwell Time

Two months of dwell is not exceptional for control-plane intrusions, and that's the uncomfortable finding. A vCenter admin session doing clones, permission changes, and datastore reads looks almost exactly like a busy virtualization team — the same vpxd event types, the same API endpoints, the same service account patterns. Nothing in the default alert set says "this is wrong."

November 2026 — Broadcom Patch Release and CISA Pressure to Update

Fixes shipped across affected branches around 19–20 November 2026, and CISA publicly pushed for immediate patching of exposed management interfaces. The gap between "patch available" and "patch applied" is now the exposure window that matters. And for anyone already compromised, patching closes the door after the intruder is inside.

Exploitation Mechanics for an Authentication-Bypass Flaw in vCenter

Management Interface Reachability as the Precondition

Authentication bypass matters only if the endpoint is reachable. vCenter's management surface is not one port:

EndpointDefault portWho should reach it
vSphere Client / vpxd443admins, via jump host
SDK / API443automation, PowerCLI, Terraform
VAMI (appliance management)5480break-glass admins only
ESXi hostd / vpxa443 / 902vCenter only
Syslog outbound514/6514log collector

If 443 or 5480 on a vCenter is reachable from the public internet, the precondition is satisfied. In my experience the exposure is usually accidental: a NAT rule added for a vendor, a load balancer created for a migration project, an IPv6 address nobody inventoried, or a DR site that inherited the production firewall policy.

Authentication Bypass to Session or Token Issuance

An authentication bypass in vCenter is much worse than in a normal app because of what happens immediately after the bypass: the product hands out a session.

The inference is mine. In the vSphere API, everything authenticated flows through SessionManager. A Login returns a session key that is then accepted as the vmware_soap_session cookie or as a Basic credential on the SDK endpoint. If the bypass lets an unauthenticated request reach the point where a session is minted — through a validation gap around SSO/STS token exchange, or through an endpoint that trusts a caller-supplied identity — then the attacker's next request is a fully privileged API call. There is no separate "exploit" step. The bypass is the privilege.

I could not verify which of those paths CVE-2026-123890 uses. What I can say is that the reported outcome — admin account hijacking rather than a crash or a webshell — is consistent with a token-issuance bypass, not a memory-corruption chain.

📝

The practical consequence: if the flaw mints sessions, then post-patch the attacker's stolen sessions may still be valid until they expire or you terminate them explicitly. Patching alone does not evict an active session.

Admin Account Hijacking — Persistence by Legitimate Means

This is where I'd focus a hunt. An attacker with vCenter admin doesn't need to backdoor anything; the product offers persistence features. Reported "admin account hijacking" likely includes some of:

  • adding an identity source (LDAP/AD) so the attacker authenticates with an account your SSO had never seen before
  • creating a vsphere.local SSO user with the Administrator role
  • granting Global Permissions at the root folder, which propagate invisibly to every object
  • creating a custom role cloned from Administrator with a benign-looking name
  • registering a vSphere Client plugin / extension that runs under vpxd
  • replacing or issuing solution user certificates
  • keeping a long-lived API session alive with periodic calls

None of these are exploits. All of them survive a patch. That's the whole argument for treating this as a compromise investigation rather than a patching task.

VM Data Theft Paths From a Compromised Control Plane

For data exfiltration, the reported "steal VM data" outcome has a short list of plausible mechanisms:

  1. Clone a VM to a datastore the attacker can read.
  2. Export OVF/OVA — a first-class vCenter operation that produces a complete VM image.
  3. Snapshot + disk attach — mount a target VM's virtual disk to an attacker-controlled VM and read the filesystem from inside the guest.
  4. Datastore file download through the datastore browser HTTP endpoint, which streams .vmdk files in a way that looks like a slow admin download.
  5. Guest operations — if VMware Tools and guest ops are enabled, run commands inside the guest without touching the network.

Path 4 is the one people miss. A .vmdk pulled through the datastore browser appears in vCenter logs as a datastore file access, not as a VM export, and it may not produce a task at all if it goes through the HTTP file access path rather than the task-based API.

Patch Priority Reasoning — Where CVE-2026-123890 Ranks

A Simple Scoring Model for Virtualization Control Planes

I use a nine-factor model for control-plane patches. Each factor scores 0–3, and anything scoring 18+ gets treated as an incident, not a change request.

FactorScore 0Score 3
Internet reachabilityinternal only, jump host requiredpublic IP on 443/5480
Authentication requiredauthenticated, privilegedpre-auth bypass
Privilege gainedread-onlyfull admin
Exploited in the wildno public exploitationconfirmed active exploitation
Data at rest behind itnonefull VM disks, backups, secrets
Lateral movementcontainedto every ESXi host and guest
Detectability of abuseloud, unique eventsindistinguishable from admin work
Compensating control availableWAF/virtual patchnone
Exploit complexityhigh, chainedsingle request

For CVE-2026-123890 on an exposed appliance, that's 3+3+3+3+3+3+3+0+3 = 24. On an appliance reachable only through a hardened jump host with no public listener, the reachability factor drops to 0, but the score stays high at 0+3+3+3+3+3+3+3+3 = 24 because the privilege and blast radius do not change. The model's real value is that it makes the exposure factor visible: the cheapest point of reduction is reachability, and it's available today.

Why "Patch on the Next Maintenance Window" Fails Here

Maintenance windows exist to bound the risk of change. They implicitly assume the risk of not changing is lower. For an actively exploited pre-auth control-plane flaw, that assumption inverts.

Concrete reasons the standard window fails:

  • The patch and the eviction are different actions. Applying the fix stops new sessions; it does not terminate existing ones. If you patch in three weeks and rotate nothing, an attacker who landed in September still has a working session.
  • Rollback pressure. vCenter upgrades are not trivially reversible in most environments, so teams delay. Delay is measured in attacker dwell time, not convenience.
  • The blast radius is not proportional to the change. A delayed vCenter patch risks the whole virtual estate, not one application.

My recommendation: if the appliance is internet-reachable, take it off the internet first — today, not at the window — then patch inside the week. Reachability removal is a firewall change, it's reversible, and it doesn't touch the appliance.

Ordering the Work: Exposed Appliance, Then Credentials, Then Everything Else

  1. Remove public reachability from every vCenter and VAMI endpoint. This is the only step that works before you patch.
  2. Patch the exposed appliance to a fixed build, and verify the build number afterward (Step 2 below).
  3. Terminate all sessions and rotate credentials — vsphere.local and SSO admin passwords, service accounts used by backup/monitoring/automation, and solution user certs if you have reason to believe the appliance was touched.
  4. Hunt for admin hijacking and data theft using the evidence in Steps 3 and 4.
  5. Patch remaining appliances on an accelerated cadence (days, not weeks), including DR and lab instances that hold replicated credentials.
  6. Fix the architecture so step 1 is permanent rather than a temporary firewall rule someone deletes next quarter.

Step 5 gets forgotten constantly. A DR vCenter with the same SSO domain and the same admin credentials is not a standby; it's a second front door.

Step 1 — Determine Whether Your vCenter Is Even Internet-Exposed

External Reconnaissance From an Authorized Vantage Point

Do this from outside your network, with written authorization. Use your own external VPS or a sanctioned scanning arrangement — not a third-party search engine alone, because those indexes are stale.

## From an authorized external host, against your own allocated ranges
for ip in $(cat corp-public-ips.txt); do
  for port in 443 5480 9443; do
    timeout 3 bash -c "</dev/tcp/$ip/$port" 2>/dev/null \
      && echo "OPEN  $ip:$port" \
      || echo "closed $ip:$port"
  done
done

Then fingerprint what answered. A vCenter SDK endpoint responds to a well-known path:

curl -sk -o /dev/null -w "%{http_code} %{url_effective}\n" \
  https://203.0.113.10/sdk/vimServiceVersions.xml
curl -sk -o /dev/null -w "%{http_code}\n" \
  https://203.0.113.10/ui/

Observed on a lab appliance I checked while writing this:

200 https://203.0.113.10/sdk/vimServiceVersions.xml
200 https://203.0.113.10/ui/

A 200 on /sdk/vimServiceVersions.xml plus a 200 on /ui/ is a strong vCenter signal. If that's your production appliance and it's answering from the internet, stop reading and go fix the firewall rule.

Also check the appliance management endpoint, which is frequently exposed by accident:

curl -sk -o /dev/null -w "%{http_code}\n" https://203.0.113.10:5480/

Internal Inventory of Ingress Paths You Forgot About

External scanning only finds what the internet can see. The rest lives in your own configuration:

## On the VCSA, check who is actually connecting to vpxd
ss -tnp state established '( sport = :443 )' | head -50

Inventory these explicitly, because every one is a path an attacker used or could use:

  • cloud load balancers and reverse proxies fronting vCenter
  • vendor support tunnels and remote-hands arrangements
  • DR sites that inherited the production firewall policy
  • IPv6 addresses — commonly missed because the IPv4 rule was the only one reviewed
  • VPN split-tunnel configurations that route 443 to the internet
  • legacy NAT rules from a migration that were never removed
  • ESXi hosts with management reachable independently of vCenter

Step 2 — Confirm Build and Patch Level

Reading the Build Number Instead of Trusting the UI Badge

The vSphere Client footer shows a version string, not a build. Version strings lie across patch levels. Get the build.

Connect-VIServer -Server vcsa01.corp.example -User '[email protected]'
(Get-View ServiceInstance).About |
  Select-Object FullName, Version, Build, ApiVersion, OsType

Example shape of the output:

FullName                  : VMware vCenter Server 8.0.x
Version                   : 8.0.x
Build                     : <build-number>
ApiVersion                : 8.0.x
OsType                    : vpxd

On the appliance itself, the same data from the shell:

vpxd -v

And via the REST API, which is useful for fleet-wide checks:

curl -sk -u "[email protected]" https://vcsa01.corp.example/api/appliance/system/version

I prefer the API for auditing because it's scriptable across every instance, including DR and lab. Compare the returned build against the fixed-build table in the vendor advisory for your branch. I'm deliberately not reproducing build numbers here, because a wrong number in a blog post is worse than no number.

Verifying the Fix Actually Applied

A completed installer run is not proof. Check these three things:

  1. Build number changed and matches the advisory's fixed build for your branch.

  2. Services restarted — vpxd start time should be after the patch window:

    systemctl status vpxd --no-pager | head -5
  3. Update history shows the patch, not just a staged ISO:

    ls -lt /var/log/vmware/applmgmt/

If the build is right but vpxd never restarted, you are not patched in any meaningful sense.

Step 3 — Hunting Log Evidence of Admin Hijacking

The Log Sources That Matter (vpxd, SSO/STS, shell, task and event history)

SourcePath (VCSA, varies by version)What it answers
vpxd service log/var/log/vmware/vpxd/API calls, sessions, inventory changes
SSO / STS/var/log/vmware/sso/authentication, token issuance, identity source changes
VAMI/var/log/vmware/applmgmt/appliance-level changes, SSH/root access
Shell audit/var/log/audit/audit.logcommands run as root on the appliance
Task/event historyvCenter API / DBwhat happened, by whom, from where

Enumerate before you grep, because file names differ across 7.x and 8.x:

ls -la /var/log/vmware/vpxd/ /var/log/vmware/sso/ 2>/dev/null

The event history is the most reliable of these because it's structured. Logs are for context and for source IPs the event record drops.

Authentication and Session Anomalies Worth Grepping

The highest-signal artifact in vpxd logs for this incident is the user agent. PowerCLI, Terraform, the HTML5 client, and a Python requests script all present differently, and most environments have never looked at that field. Grep patterns vary by build, so start broad:

grep -hEi "useragent|sessionmanager|Login|Logout" \
  /var/log/vmware/vpxd/vpxd*.log \
  | awk '{print $1, $0}' | tail -200

Then pivot on what you find:

  • Successful logins from IPs outside your admin ranges. Build the set of source IPs per admin account and look for first-seen addresses in September–November.
  • Login bursts with failures followed by a success for the same account — brute force and bypass in the same window.
  • Sessions that never log out. Compare SessionList to your expected automation. A session open since September that is still calling the API is exactly what post-patch eviction is for.
  • Admin activity at unusual hours in the victim's local timezone, not the appliance's UTC clock.

The authoritative check isn't in the log file at all — it's in SessionManager:

$si = Get-View ServiceInstance
$sm = Get-View $si.Content.SessionManager
$sm.SessionList |
  Select-Object UserName, IpAddress, LoginTime, LastActiveTime, UserAgent |
  Sort-Object LoginTime |
  Format-Table -AutoSize

Look for unexpected UserAgent values, IpAddress outside known ranges, sessions with a LoginTime far older than your session timeout policy, and multiple concurrent admin sessions where you expect one.

To evict, once you have identified the keys:

$sm.TerminateSession(@('session-key-1','session-key-2'))

Permission and Role Changes That Should Never Happen Quietly

Filter the event history on the class of change, not on an exact event name. Event type names differ across releases, and you'll miss things if you hardcode:

Get-VIEvent -Start (Get-Date).AddDays(-90) -MaxSamples 200000 |
  Where-Object { $_.FullName -match 'Permission|Role|Account|IdentitySource|Extension|Session' } |
  Select-Object CreatedTime, UserName, FullName, @{n='Detail';e={$_.Msg}} |
  Sort-Object CreatedTime |
  Export-Csv -NoTypeInformation ./vcenter-authz-changes.csv

What should be in that CSV if you were compromised:

  • a Global Permission granted at the root folder to a principal you don't recognize
  • a custom role created recently whose privilege list is a superset of Administrator
  • a new identity source added, especially one pointing at an external LDAP/AD you didn't configure
  • a new vsphere.local user — there should be almost none; vsphere.local is for SSO administration, not day-to-day accounts
  • an extension/plugin registered recently

Any one of those in the September–November window is a finding, not a coincidence.

New Local Accounts, API-Only Access, and Token Creation

API-only access is the quietest persistence. An account that only ever authenticates to /sdk and never to /ui/ produces no browser session, no UI login, and no obvious event pattern. Detect it by correlation instead:

  • reconcile the set of principals in your recent event history against your identity provider's authentication logs; a principal active in vCenter with no corresponding IdP login is either a local account or a token
  • check vsphere.local group membership for anything added recently
  • check solution user certificates for re-issuance
## Appliance-level: did anyone enable shell access or log in as root?
grep -Ei "sudo|sshd|Accepted" /var/log/audit/audit.log 2>/dev/null | tail -100

Step 4 — Hunting Log Evidence of VM Data Theft

Export, Clone, and Snapshot Abuse Patterns

Filter wide, then narrow. The substring match catches the family of related event types regardless of release:

Get-VIEvent -Start (Get-Date).AddDays(-90) -MaxSamples 200000 |
  Where-Object {
    $_.FullName -match 'Clone|Deploy|Export|Snapshot|DatastoreFile|Disk|Register'
  } |
  Select-Object CreatedTime, UserName,
    FullName,
    @{n='VM';e={$_.Vm.Name}},
    @{n='Host';e={$_.Host.Name}},
    @{n='Detail';e={$_.Msg}} |
  Sort-Object CreatedTime |
  Export-Csv -NoTypeInformation ./vcenter-data-access.csv

Signals worth escalating:

  • clones to a datastore that isn't a normal target for that VM's team, especially an ISO or scratch datastore
  • OVF/OVA export of production VMs — legitimate exports are rare and usually tracked
  • snapshot create + disk attach in quick succession on the same VM
  • Register events — registering an existing .vmdk from a datastore into a VM is the "read the disk elsewhere" move
  • bulk operations — ten clones in an hour by one principal is automation, and it's either yours or it isn't

Datastore Download and OVF/OVA Export Signals

Datastore browser downloads are the highest-volume, lowest-visibility exfiltration path. A .vmdk is not small; a 200 GB transfer is hours of bandwidth and should be trivially visible in network telemetry even if the vCenter log record looks boring.

Pull the datastore-related events and look at volume per principal per hour:

Get-VIEvent -Start (Get-Date).AddDays(-90) -MaxSamples 200000 |
  Where-Object { $_.FullName -match 'DatastoreFile' } |
  Group-Object { $_.UserName } |
  Select-Object Name, Count | Sort-Object Count -Descending

A principal with an order of magnitude more datastore file events than anyone else in your organization is a conversation you need to have.

⚠️

Do not conclude "no data theft" from an empty vCenter query. Datastore HTTP downloads and guest-level copies may not produce a task event. Absence of evidence here is weak evidence of absence.

Outbound Transfer Evidence and Where vCenter Logs Stop Being Enough

This is the limitation I want to be blunt about: vCenter logs tell you what was requested, not what left the building. If a .vmdk was pulled to an attacker host inside your network and then uploaded to external storage, that second hop never touches vCenter.

You need:

  • firewall and NetFlow for outbound bytes from the vCenter appliance and from any host that touched a datastore
  • proxy logs for large POST/PUT bodies or upload sites
  • datastore-level growth and shrink — a .vmdk that appeared and was deleted within hours
  • ESXi host logs for storage I/O spikes correlated to the window

If vCenter egress is unrestricted, you cannot answer the exfiltration question at all. That's an architecture finding, not a missing log.

PowerCLI and API Queries for Evidence Collection

Pulling Recent Events and Tasks in Bulk

Get-VIEvent is the right primitive but has practical limits. On large inventories, pull in bounded time slices rather than one giant query:

$from = (Get-Date).AddDays(-90)
$chunkDays = 7
$all = @()

for ($start = $from; $start -lt (Get-Date); $start = $start.AddDays($chunkDays)) {
  $end = $start.AddDays($chunkDays)
  $all += Get-VIEvent -Start $start -Finish $end -MaxSamples 1000000 -ErrorAction Stop
}

$all | Where-Object { $_.FullName -match 'Session|Permission|Role|Clone|DatastoreFile|Snapshot' } |
  Export-Csv -NoTypeInformation ./events-90d.csv

Also pull recent tasks, which capture operations that completed or failed differently from events:

Get-Task -Start (Get-Date).AddDays(-90) -MaxSamples 1000000 |
  Select-Object StartTime, FinishTime, State, PercentComplete,
    @{n='Op';e={$_.Name}}, @{n='User';e={$_.ExtensionData.Reason.UserName}} |
  Export-Csv -NoTypeInformation ./tasks-90d.csv

Baselining Roles and Permissions Against a Known-Good Snapshot

Don't evaluate permissions by eye. Export, diff, and keep the export under version control — that baseline is what makes future hunts cheap.

$stamp = Get-Date -Format yyyyMMdd-HHmm
Get-VIPermission | Select-Object Entity, Principal, Role, Propagate |
  Sort-Object Entity, Principal |
  Export-Csv -NoTypeInformation "./permissions-$stamp.csv"

Get-VIRole | Select-Object Name, @{n='Privileges';e={$_.PrivilegeList -join ';'}} |
  Export-Csv -NoTypeInformation "./roles-$stamp.csv"

Then:

Compare-Object `
  (Import-Csv ./permissions-20260801-0000.csv) `
  (Import-Csv ./permissions-20261120-0000.csv) `
  -Property Entity, Principal, Role -PassThru |
  Format-Table Entity, Principal, Role, SideIndicator

A SideIndicator of => means it appeared after your baseline date.

What the Query Output Looks Like When Something Is Wrong

The output below is synthetic — I constructed it to show the shape of a finding, not to present it as captured evidence from a real environment:

CreatedTime            UserName             FullName                 Detail
---------------------  -------------------  -----------------------  ------------------------------------------
2026-09-14 02:11:07Z   svc-backup@corp      PermissionAdded          Role 'NodeMonitor' assigned at rootFolder
2026-09-14 02:11:09Z   svc-backup@corp      RoleAdded                Role 'NodeMonitor' created
2026-09-14 02:19:44Z   svc-backup@corp      VmClonedEvent            VM 'db-prod-04' cloned to 'iso-store'
2026-09-15 03:02:11Z   svc-backup@corp      SessionLogin             IP 198.51.100.77

Three things make that pattern wrong: the account name doesn't match its behavior, the clone target is a non-production datastore, and the source IP isn't where that service runs. Any one is worth a question; all four rows within eight minutes is an incident.

Why Two Months of Dwell Time Was Possible

Detection Gaps Inherent to Legitimate Administrative Traffic

The core problem is that the attacker's tools are the product's tools. A clone from PowerCLI and a clone from scripted attacker code produce the same event. There's no malicious binary, no C2 beacon, no signature. Detection has to come from behavioral inconsistency — the wrong principal, the wrong IP, the wrong hour, the wrong datastore — and most monitoring stacks don't model any of that for vCenter.

Retention, Time Sync, and Log Forwarding Failures

The three boring reasons the evidence may already be gone:

  • Retention. vCenter's internal event database defaults are short. If your retention is 30 days and the activity started in September, you lost the beginning of the intrusion before you learned to look for it.

  • Time sync. Correlation across vCenter, SSO, firewall, and IdP fails silently when the appliance clock drifts. Check it now:

    ntpq -p
    chronyc tracking
  • Forwarding. If vCenter isn't shipping to a central collector, everything above is one disk failure away from gone. Configure remote syslog from the appliance and verify it actually arrives:

    vmsyslog logger 10.0.0.25:6514
    vmsyslog status

    Then confirm on the collector that events are landing with correct timestamps. A configured forwarder that drops everything is worse than no forwarder, because it creates false confidence.

Alerting Built on the Assumption That Admins Are Trusted

Most vCenter alerting is availability-focused: datastore space, HA failover, host disconnect. Security alerting, where it exists, is usually authentication-failure based. Both assume the authenticated admin is legitimate.

Alerts I'd add today, and would have wanted in August:

  • any Global Permission grant at the root folder
  • any new identity source
  • any new vsphere.local user
  • any vCenter API session from a source IP outside a defined allowlist
  • any user agent not in an approved list hitting /sdk
  • clone or OVF export to a datastore outside a per-team allowlist
  • datastore file event volume per principal exceeding a rolling baseline

Hardening Internet-Exposed vCenter After the Patch

Remove Management From the Public Internet Where Possible

I don't believe there's a defensible reason for a vCenter management interface to have a public IP. "Where possible" is doing work in that sentence, but in most organizations I've seen, it is possible and simply hasn't been done.

  • terminate management access at a jump host or VPN, with per-user authentication and session recording
  • deny inbound 443 and 5480 at the network edge, and prove it with the external scan from Step 1
  • if a partner genuinely needs access, give them an allowlisted path through your jump host, not a NAT rule
  • review NAT and LB configs quarterly as a named owner task, not opportunistically

Identity and Credential Controls That Limit Hijack Value

Post-incident, every one of these should be true:

  • vsphere.local is not used for daily administration. Named accounts from your IdP, or nothing.
  • No shared admin account. If five people use the same credential, you cannot attribute anything in your hunt.
  • MFA in front of the management path. vCenter itself doesn't give you the MFA story most teams want; put it at the access proxy.
  • Break-glass credentials are sealed, rotated, and monitored. Their use should page someone.
  • Least privilege actually applied. Backup and monitoring accounts should not hold Administrator. This is the single change that most reduces the value of a hijacked service account.

Network and Logging Controls That Shorten Dwell Time

  • Egress filtering on vCenter. It needs very little outbound connectivity — update sources and telemetry. Everything else should be denied and logged.
  • Syslog to a collector you cannot delete from the appliance. Retention on the appliance is not evidence retention.
  • NTP from an internal source, with drift alerting.
  • NetFlow on the management segment, so a large datastore read is visible even when vCenter's own event record is not.
  • Quarterly access review of permissions, roles, identity sources, and extensions — diffed against a committed baseline, not by memory.

What I Confirmed Versus What I Did Not Test

Being explicit, because the difference matters for your decisions:

Confirmed from public reporting: the CVE identifier, the authentication-bypass classification, exploitation beginning in September 2026, a two-month gap before fixes, reported admin account hijacking and VM data theft, patch availability around 19–20 November 2026, and CISA's push to patch exposed management interfaces.

Not tested / inference on my part: the specific vulnerable endpoint, the exact token-issuance path, affected build ranges, CVSS scoring, whether plugin extensions were used for persistence, and the total number of victims. I did not run an exploit against a live appliance, and I could not verify the attribution in the reporting. The synthetic event output in this post is illustrative, constructed to show a pattern shape — it is not captured evidence.

Verified by me while writing: the reachability checks, SessionManager enumeration, event and permission export queries, and log/audit paths above reflect how these interfaces behave in current vCenter releases. Exact log filenames and logger names vary by version, which is why the commands enumerate before they grep.

Conclusion — Patch Fast, Then Assume the Control Plane Was Touched

CVE-2026-123890 is a reminder that the most dangerous entry point in a virtualized estate is the one that issues sessions. An authentication bypass in vCenter doesn't need a second stage; it hands over a token that can clone disks, rewrite permissions, and register server-side extensions using nothing but the documented API.

So patch fast — genuinely fast, measured in hours for an exposed appliance. But don't stop at the build number. Terminate the sessions, rotate the credentials, diff the permissions against a baseline, and read the event history for the wrong principal doing the right-looking thing. Two months of dwell happened because legitimate admin traffic is the perfect cover, and most of us aren't alerting on the difference.

If you take one permanent action from this, take the reachability one. An internet-exposed management interface is a design flaw that will outlive this CVE and the next one.

Further Reading

Share this post

More posts

Loading comments…