WhatsApp VBScript Campaign → ManageEngine RMM Abuse

Compromised WhatsApp accounts DM heavily-obfuscated .vbs "documents" → WhatsApp.Root.exe (Desktop) spawns wscript.exe → secondary VBScript payloads (UAC tamper + ZIP fetch) → a legitimate ManageEngine RMM Central agent is installed as a covert backdoor. Infrastructure overlaps prior Gh0st RAT / ValleyRAT activity. Defensive hunt & harden pack — no malicious code.
Threat
WhatsApp VBScript campaign · ManageEngine RMM abuse
Severity
RMM-ABUSE BACKDOOR
Type
VBScript loader · RMM abuse · living off trusted tools
Attribution
UNATTRIBUTED · Gh0st RAT / ValleyRAT infra overlap
Delivery
WhatsApp DM (compromised accounts) — fake .vbs documents
Version
v0.2 · 2026-06-23
Author
HuntPack
01

Executive Summary

A campaign documented by Kaspersky (reported by The Hacker News, 2026-06-23) abuses compromised WhatsApp accounts to direct-message victims heavily-obfuscated VBScript files masquerading as business documents — names like Financial Reports.vbs and Account Statement.vbs, with localized variants in Portuguese, French, German and Malay. The scripts carry extensive Chinese-language comments crafted to falsely mimic Windows Update components.

Opening the file launches wscript.exe, which runs the malicious .vbs and fetches secondary VBScript payloads (one tampers with UAC; one downloads a ZIP archive). The execution path differs by client: WhatsApp Web requires the victim to manually run the downloaded file, while WhatsApp Desktop triggers execution through the background process WhatsApp.Root.exe — making WhatsApp.Root.exe → wscript.exe running a .vbs the flagship parent/child signal. The ZIP delivers a legitimate ManageEngine RMM Central agent, which the actor abuses as a remote-access backdoor — a textbook "living off trusted tools" play.

Kaspersky found infrastructure overlap (the IP 202.61.160[.]201) with prior Gh0st RAT and ValleyRAT activity, but the campaign remains UNATTRIBUTED. Highest victim concentration is in Malaysia, with activity also in Brazil, India, Mexico, Singapore, UK, Spain, Taiwan, Australia, Russia and Vietnam.

Defender priority: the durable signal is the process lineage, not the rotating infrastructure. Highest-fidelity: Q1 (WhatsApp.Root.exe/WhatsApp* → wscript.exe running a .vbs) and Q4 (a ManageEngine / RMM Central agent installed where no IT-sanctioned RMM is expected). Because ManageEngine RMM is legitimate software, every RMM hit MUST be correlated to the WhatsApp/wscript/.vbs lineage before escalation.
02

Source Review & Web Hunter Notes

TierSourceKey FindingCarry
1 · ReportingThe Hacker News — "WhatsApp VBScript Campaign Uses Fake Documents to Install ManageEngine RMM Tool" (2026-06-23, research by Kaspersky)WhatsApp-delivered obfuscated .vbs → wscript → secondary payloads (UAC tamper + ZIP) → ManageEngine RMM Central backdoor; WhatsApp.Root.exe Desktop trigger; C2 202.61.160[.]201; Gh0st/ValleyRAT overlap; UNATTRIBUTEDyes
1 · Vendor researchKaspersky (primary research behind the report)Heavily-obfuscated VBScript w/ Chinese comments faking Windows Update; per-client execution differences (Web manual vs Desktop process-driven); Malaysia-led targetingyes

Decisions: behavior-first (only one atomic network IOC is published and infra rotates); detection anchored on the WhatsApp → wscript.vbs lineage and the unsanctioned-RMM install; framed around dual-use risk (ManageEngine RMM is legitimate) so RMM hits are always correlated, not auto-escalated. Attribution left as UNATTRIBUTED with documented Gh0st RAT / ValleyRAT infra overlap — no over-claiming.

03

Hunt Brief & Attack Chain

Working hypothesis: A victim receives a fake business "document" .vbs via WhatsApp DM from a compromised contact; wscript.exe (spawned by WhatsApp.Root.exe on Desktop, or manually on Web) runs the obfuscated script, fetches secondary VBScript that tampers with UAC and downloads a ZIP, then installs a ManageEngine RMM Central agent that the actor uses as a persistent backdoor.

StepBehaviorTelemetryHunt Angle
1 · DeliveryCompromised WhatsApp account DMs a fake *.vbs business documentFile write to Downloads; WhatsApp process treeN1
2 · ExecutionWhatsApp.Root.exe/WhatsApp* (Desktop) or user (Web) → wscript.exe runs the .vbsProcessRollup2Q1 / Q2
3 · Secondary fetchScript host reaches out for secondary VBScript payloads (UAC tamper + ZIP)NetworkConnectIP4 / DnsRequestQ3
4 · RMM installZIP delivers ManageEngine RMM Central; agent/service installed (msiexec / UEMS_Agent)ProcessRollup2; service installQ4
5 · C2 / backdoorOutbound to actor infrastructure (incl. 202.61.160.201) for remote controlNetworkConnectIP4Q5
6 · PersistenceScript-host → archive → new service / scheduled taskProcessRollup2; service / task createQ6

Affected surface & telemetry

SurfaceRequired TelemetryPriorityGap Risk
Windows user endpointsProcess lineage + command line (ProcessRollup2)CriticalLow — standard sensor
Script-host egressNetworkConnectIP4 / DnsRequest from wscript/cscriptHighLow — sensor-native
RMM install / serviceProcess + service create (msiexec, ManageEngine agent)HighMedium — needs RMM allowlist baseline
WhatsApp deliveryFile-write telemetry to Downloads; WhatsApp process treeMediumMedium — user-action dependent (Web)
04

Consolidated IOC Table

Behavioral IOCs lead — the WhatsApp → wscript.vbs lineage and unsanctioned-RMM install are the durable signals. Only one atomic network IOC (202.61.160.201) is published in the source; all other concrete hashes/domains are placeholders pending your own analysis. Copy-ready blocks in §9.
TypeValueConfActionContext
BehaviorWhatsApp.Root.exe → wscript.exe running a *.vbshighdetectDesktop-client execution — flagship signal
Behaviorwscript/cscript runs *.vbs from \Downloads\ or \Temp\highdetectBroader catch (Web client / missing parent)
Behaviorwscript/cscript outbound network / DNS shortly after .vbsmediumhuntSecondary-payload fetch
BehaviorManageEngine / RMM Central / UEMS_Agent install where no RMM is sanctionedmediumhuntLegit RMM abused as backdoor (dual-use)
File"Financial Reports.vbs", "Account Statement.vbs" (+ PT/FR/DE/MS variants)mediumhuntFake-document lure names
IP (atomic)202.61.160.201highblockC2 infra — overlaps prior Gh0st RAT / ValleyRAT (sourced)
HashREPLACE_WITH_VBS_LOADER_SHA256n/adetectPlaceholder — not published in source
DomainREPLACE_WITH_PAYLOAD_DOMAINn/adetectPlaceholder — secondary-payload host
05

ATT&CK Mapping

TacticTechniqueObserved BehaviorQuery / Control
Initial AccessT1566 — Phishing (via WhatsApp DM)Compromised account sends fake .vbs documentN1; user awareness (§10)
ExecutionT1059.005 — Visual Basic (wscript)Obfuscated .vbs run by wscript.exeQ1, Q2
Command & ControlT1105 — Ingress Tool TransferScript host fetches secondary VBScript + ZIPQ3
Defense EvasionT1548.002 — Bypass UACSecondary payload tampers with UACQ3 (correlate); §10
Persistence / C2T1219 — Remote Access Software (ManageEngine RMM)Legit RMM Central agent abused as backdoorQ4, Q5
PersistenceT1543.003 / T1053.005 — Service / Scheduled TaskScript-host → archive → new service / taskQ6
06

Native Audit-Log Hunts

HuntSourceLogicResponse
N1 · Fake .vbs deliveredFile-write telemetry / browser download history*.vbs written to \Downloads\ with a document-like name (Financial/Account/Statement + localized)Pull the script; sweep host (pairs with Q1)
N2 · wscript .vbs executionEID 4688 / Sysmon EID 1wscript.exe with a .vbs arg; parent WhatsApp.Root.exe or from \Downloads\/\Temp\Isolate; capture script (pairs with Q1/Q2)
N3 · UAC tamperSecurity 4657 / Sysmon EID 13 (registry)Changes to UAC keys (EnableLUA, ConsentPromptBehaviorAdmin) shortly after a wscript hitTreat host as compromised; reset state
N4 · Unsanctioned RMMService install (7045) / software inventoryManageEngine / RMM Central / UEMS agent on a host with no IT-sanctioned RMMValidate against RMM allowlist; remove if rogue
07

CrowdStrike LogScale CQL Hunt Queries

Pick your tenant's cloud first — every "Open in Falcon" button below uses this selection.
Field names validated against the Falcon event reference; process hunts include SyntheticProcessRollup2. Q1 (WhatsApp parent) and Q4 (unsanctioned RMM) are the strongest keepers; Q3/Q5/Q6 should be correlated to a same-host Q1/Q2 hit before escalation.
Q1 · WhatsApp* → wscript.exe running a .vbs (flagship)
CONF HIGHFP LOWCOST LOW

Looks for: wscript.exe/cscript.exe running a .vbs whose parent is a WhatsApp process (notably WhatsApp.Root.exe on Desktop). Accomplishes: catches the campaign at execution with the highest-fidelity lineage — WhatsApp has no business spawning a script host.

// HUNT: WhatsApp Desktop spawns wscript running a .vbs (flagship lineage)
// MITRE: T1566, T1059.005 | CONF: high  FP: low  COST: low
// FP NOTES: WhatsApp never legitimately launches a script host - near-zero benign baseline
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| ParentBaseFileName=/^WhatsApp(\.Root)?\.exe$/i
| FileName=/^(wscript|cscript)\.exe$/i
| CommandLine=/\.vbe?("|\s|$)/i
| table([@timestamp, ComputerName, UserName, ParentBaseFileName, FileName, CommandLine], limit=200)
Q2 · wscript/cscript running a .vbs from Downloads/Temp (broad)
CONF MED-HIGHFP LOW-MEDCOST LOW

Looks for: a script host running a .vbs from a user download/temp path, regardless of parent. Accomplishes: catches the WhatsApp Web path (manual execution, no WhatsApp.Root.exe parent) and any case where the parent is missing.

// HUNT: script host runs a .vbs from a user download/temp path (Web client / no parent)
// MITRE: T1059.005 | CONF: med-high  FP: low-med  COST: low
// TUNING: baseline legit admin .vbs in your estate; correlate to a WhatsApp file-write / Q1
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| FileName=/^(wscript|cscript)\.exe$/i
| CommandLine=/\.vbe?("|\s|$)/i
| CommandLine=/\\(Downloads|Temp|AppData\\Local\\Temp)\\/i
| table([@timestamp, ComputerName, UserName, ParentBaseFileName, CommandLine], limit=200)
Q3 · Script host outbound network / DNS (secondary-payload fetch)
CONF MEDFP MEDCOST MED

Looks for: wscript/cscript making outbound connections to an external host shortly after running. Accomplishes: surfaces the secondary VBScript / ZIP fetch. FP: some logon/admin scripts reach internal hosts — exclude RFC1918 and correlate to a same-host Q1/Q2.

// HUNT: script host fetches secondary payload (outbound to external host)
// MITRE: T1105 | CONF: medium  FP: medium  COST: medium
// TUNING: exclude RFC1918 + sanctioned internal script destinations; correlate to Q1/Q2 on same aid
#event_simpleName=NetworkConnectIP4
| ContextBaseFileName=/^(wscript|cscript)\.exe$/i
| RemoteAddressIP4!=/^(10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[01])\.|169\.254\.|127\.)/
| table([@timestamp, ComputerName, ContextBaseFileName, RemoteAddressIP4, RemotePort], limit=200)
Q4 · ManageEngine / RMM Central install where no RMM is sanctioned
CONF MEDFP MEDCOST LOW

Looks for: msiexec installing a ManageEngine package, or a ManageEngine / RMM Central / UEMS agent binary executing. Accomplishes: catches the abused legitimate RMM. Dual-use: ManageEngine is legitimate — exclude IT-sanctioned RMM management subnets / installer hashes and correlate to the .vbs lineage.

// HUNT: ManageEngine RMM Central install/exec where no RMM is IT-sanctioned
// MITRE: T1219 | CONF: medium  FP: medium  COST: low
// TUNING: allow-list sanctioned RMM mgmt subnets + known installer SHA256; correlate to Q1/Q2
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| (CommandLine=/manageengine|rmm.?central|uems[_-]?agent|dcregister|dcconfig/i or FileName=/^(UEMS_Agent|dcagentservice|dcagenttrayicon)\.exe$/i)
| table([@timestamp, ComputerName, UserName, ParentBaseFileName, FileName, CommandLine], limit=200)
Q5 · Outbound connection to known C2 IP 202.61.160.201
CONF HIGHFP LOWCOST LOW

Looks for: any process connecting to the published C2 IP 202.61.160.201 (overlaps prior Gh0st RAT / ValleyRAT infra). Accomplishes: a high-confidence atomic catch. Note: single sourced IOC — infra rotates, so keep the behavioral queries as primary coverage.

// HUNT: connection to known campaign C2 (Gh0st/ValleyRAT infra overlap)
// MITRE: T1071 | CONF: high  FP: low  COST: low
// FP NOTES: atomic IOC from source; rotates - pair with behavioral Q1/Q4 for durable coverage
#event_simpleName=NetworkConnectIP4
| RemoteAddressIP4="202.61.160.201"
| table([@timestamp, ComputerName, ContextBaseFileName, RemoteAddressIP4, RemotePort], limit=200)
Q6 · Script-host → archive → new service / scheduled-task persistence
CONF MEDFP MEDCOST LOW

Looks for: service-control / scheduled-task creation parented by a script host (or its descendants) — the ZIP-to-persistence step. Accomplishes: catches the RMM agent or backdoor being made persistent. FP: legit software installs create services — correlate strictly to a same-host Q1/Q2.

// HUNT: script host establishes persistence (new service / scheduled task)
// MITRE: T1543.003, T1053.005 | CONF: medium  FP: medium  COST: low
// TUNING: scope to hosts with a recent Q1/Q2 hit; allow-list sanctioned software-install service creates
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| ParentBaseFileName=/^(wscript|cscript)\.exe$/i
| (FileName=/^(sc|schtasks)\.exe$/i or CommandLine=/sc(\.exe)?\s+create|schtasks(\.exe)?\s+\/create|New-Service|Register-ScheduledTask/i)
| table([@timestamp, ComputerName, UserName, ParentBaseFileName, FileName, CommandLine], limit=200)
08

CrowdStrike Custom IOA Recommendations

IOA NameField PatternsBenign ExclusionsDeployment Path
WhatsApp spawns a script hostParent *\WhatsApp.Root.exe (or *\WhatsApp.exe); Child wscript.exe/cscript.exeNone expected (WhatsApp never spawns a script host)Endpoint Security → Custom IOA → Process Creation, Detect+Block
wscript .vbs from Downloads/TempImage *\wscript.exe; CmdLine *.vbs + \Downloads\/\Temp\Rare legit admin .vbs from temp (allow-list)Custom IOA → Process Creation, Detect
Unsanctioned ManageEngine RMMCmdLine/Image manageengine/UEMS_Agent/RMM CentralIT-sanctioned RMM mgmt subnets + known installer hashes (allow-list)Custom IOA → Process Creation, Detect (alert, do not auto-block dual-use)
The WhatsApp→script-host IOA is a strong promotion (no benign baseline). The RMM IOA must stay alert-only and allow-listed against sanctioned RMM, because ManageEngine RMM Central is legitimate software in many estates.
09

Machine-Readable IOC Appendix

Grouped IOC Quick-Copy

One-click blocks for detection, IOC import, and hardening. Only 202.61.160.201 is a sourced atomic IOC — every other concrete value is a REPLACE_WITH_* placeholder pending your own analysis. Behavior is the durable signal.

Falcon IOC Management CSVbulk import (seed)
type,value,action,severity,expiration,description,tags
ipv4,202.61.160.201,detect,high,2026-09-23,WhatsApp-VBScript C2 (Gh0st/ValleyRAT infra overlap - sourced),campaign:WhatsApp-VBScript-RMM
domain,REPLACE_WITH_PAYLOAD_DOMAIN,detect,high,2026-09-23,Secondary VBScript/ZIP payload host (placeholder),campaign:WhatsApp-VBScript-RMM
sha256,REPLACE_WITH_VBS_LOADER_SHA256,detect,high,2026-12-23,Obfuscated VBScript loader (placeholder),campaign:WhatsApp-VBScript-RMM
sha256,REPLACE_WITH_RMM_INSTALLER_SHA256,detect,medium,2026-12-23,Rogue ManageEngine RMM installer (placeholder),campaign:WhatsApp-VBScript-RMM
Behavioral Signaturesdetection logic
WhatsApp.Root.exe (or WhatsApp.exe) spawns wscript.exe/cscript.exe running a *.vbs  (flagship)
wscript/cscript runs a *.vbs from \Downloads\ or \Temp\ (Web client / missing parent)
wscript/cscript makes outbound network/DNS shortly after the .vbs (secondary-payload fetch)
ManageEngine / RMM Central / UEMS_Agent installed where no RMM is IT-sanctioned (dual-use - correlate)
Outbound connection to 202.61.160.201 (sourced C2; Gh0st/ValleyRAT infra overlap)
script host -> sc.exe/schtasks.exe create (ZIP-to-persistence: new service / scheduled task)
Fake-document .vbs lure names: "Financial Reports.vbs", "Account Statement.vbs" (+ PT/FR/DE/MS)
Names / Linked Threatsattribution
Campaign: WhatsApp VBScript -> ManageEngine RMM abuse (Kaspersky, Jun-2026)  # UNATTRIBUTED
Delivery: compromised WhatsApp accounts DM obfuscated .vbs "documents"
Abused tool: ManageEngine RMM Central agent (legitimate RMM used as a backdoor)
Infra overlap: 202.61.160.201 -> prior Gh0st RAT and ValleyRAT activity (no firm attribution)
Top targeting: Malaysia (highest); also BR, IN, MX, SG, UK, ES, TW, AU, RU, VN
Tell: heavily-obfuscated VBScript w/ Chinese comments faking Windows Update components
Hardening / Blockbreak the chain
# Cut the VBScript-loader -> RMM chain:
Change default .vbs/.vbe/.js handler from WScript to Notepad (kills double-click execution)   # M1042
ASR D3E037E1-3EB8-44C8-A917-57927947596D   # Block JS/VBScript launching downloaded executables
ASR BE9BA2D9-53EA-4CDC-84E5-9B1EEEE46550   # Block executable content from email client and webmail
Disable / relocate Windows Script Host for standard users (WDAC/AppLocker)                    # M1042/M1038
RMM allowlist: alert on any unsanctioned RMM (ManageEngine / RMM Central / UEMS)              # M1038
Block outbound to 202.61.160.201; egress-filter script-host network access
User awareness: WhatsApp-delivered .vbs "documents" are never legitimate                      # M1017
10

Hardening — Tiered & Deployable

The campaign needs wscript to run the .vbs and an unmanaged RMM agent to persist — removing either breaks the chain. ManageEngine RMM is legitimate, so harden via an allowlist + alert model rather than a blanket block.

Immediate — Neuter the VBScript loader
  • Change the default .vbs/.vbe/.js handler from WScript to NotepadM1042. Double-clicking a fake-document .vbs opens it harmlessly instead of executing.
  • ASR: Block JS/VBScript from launching downloaded executablesM1042 (ID D3E037E1-3EB8-44C8-A917-57927947596D).
  • ASR: Block executable content from email client and webmail (ID BE9BA2D9-53EA-4CDC-84E5-9B1EEEE46550) — reduces adjacent document-lure delivery.
  • Block outbound to 202.61.160.201 and egress-filter script-host network access — M1037. Kills the known C2 and the secondary-payload fetch.
Near term — Constrain script hosts & RMM (pilot first)
  • Disable / relocate Windows Script Host for standard usersM1042 / M1038. WDAC/AppLocker block of wscript/cscript where automation does not require them.
  • RMM allowlist + alert on unsanctioned RMMM1038. Inventory all RMM agents; alert on any ManageEngine / RMM Central / UEMS instance outside the sanctioned set.
  • Enforce UAC at the highest prompt level + monitor UAC registry keysM1052. Blunts the secondary payload's UAC tampering (Q3 / N3).
Strategic — Default-deny & user resilience
  • Application allowlisting enterprise-wideM1038. Blocks unsigned loaders and unsanctioned RMM agents by default.
  • User-awareness on WhatsApp-delivered "documents"M1017. A .vbs sent over WhatsApp is never a legitimate business document, even from a known contact (accounts get compromised).
  • Egress filtering / proxy enforcementM1037. Default-deny outbound from workstations to unknown infrastructure.
11

Containment Runbook

PhaseActionsOwnerEvidence
IsolateNetwork-contain the host; preserve the delivered .vbs + any secondary scripts/ZIPSOC L2Containment timestamp; Q1/Q2 events
TriagePull the WhatsApp.Root.exe → wscript tree, secondary-payload egress, UAC reg changes, and the RMM agent; confirm RMM is rogue vs. sanctionedSOC L2Process tree; RMM inventory check
EradicateKill the ManageEngine RMM agent + remove its service/persistence; block 202.61.160.201; revert UAC tamperingIRService-removal log; firewall block
Hunt fleetwideSweep the WhatsApp.Root.exe → wscript lineage across all hosts (Q1); check for lateral RMM deploymentThreat HuntFleet query results
RecoverReset credentials used on the host; rebuild if backdoor dwelt; verify no further RMM footholdsIR + ITCred-reset record; rebuild ticket
HardenChange .vbs handler; ASR rules; disable WSH for standard users; RMM allowlist + alertDetection EngControl status; IOA enabled
12

Detection Coverage Map & Validation

TechniqueBehaviorCQLIOACoverage
T1566WhatsApp DM delivery of fake .vbsGAP file-write / user-awareness (N1)
T1059.005VBScript execution (WhatsApp parent)Q1IOA-1Good
T1059.005VBScript from Downloads/Temp (broad)Q2IOA-2Good
T1105 / T1548.002Secondary-payload fetch / UAC tamperQ3Partial correlate to Q1; + N3
T1219ManageEngine RMM abuseQ4, Q5IOA-3Partial allow-list dependent
T1543.003 / T1053.005Service / scheduled-task persistenceQ6Partial correlate to Q1/Q2

Validation gates: (1) confirm ProcessRollup2 w/ command line fleet-wide + NetworkConnectIP4 visibility for Q3/Q5; (2) baseline legit wscript automation and inventory all sanctioned RMM before promoting Q4; (3) lab-test a benign wscript benign.vbs from \Downloads\ (Q2) and a benign WhatsApp→child (Q1); (4) promote Q1 (and IOA-2) to Custom IOA Detect+Block; keep Q4 (RMM) alert-only with an allow-list; keep Q3/Q5/Q6 as correlated hunts.

13

Hunt Summary Ticket

TITLE:        Hunt — WhatsApp VBScript campaign -> ManageEngine RMM abuse
SEVERITY:     High (RMM-abuse backdoor; remote access via legit tooling)
SCOPE:        Windows user endpoints with WhatsApp Desktop/Web
HYPOTHESIS:   Compromised WhatsApp account DMs a fake .vbs document -> wscript runs it
              (WhatsApp.Root.exe parent on Desktop) -> secondary VBScript (UAC tamper + ZIP)
              -> ManageEngine RMM Central installed as a backdoor -> C2 202.61.160.201.
QUERIES RUN:  Q1 WhatsApp->wscript .vbs (IOA flagship) | Q2 wscript .vbs from Downloads (IOA) |
              Q3 script-host outbound (payload fetch) | Q4 unsanctioned ManageEngine RMM (IOA, alert) |
              Q5 C2 202.61.160.201 | Q6 script-host -> new service/scheduled task
              + Native N1-N4 (.vbs delivery, 4688 wscript, UAC reg, 7045 RMM service)
DO FIRST:     Q1, Q4 — but correlate every RMM hit to the .vbs lineage (RMM is dual-use)
FINDINGS:     <pending analyst execution>
GAPS:         WhatsApp delivery (Web manual path) needs file-write telemetry + user awareness
ACTIONS:      Change .vbs handler; ASR; disable WSH for std users; RMM allowlist+alert; block C2
ATTRIBUTION:  UNATTRIBUTED (Gh0st RAT / ValleyRAT infra overlap; do not over-claim)
OWNER:        HuntPack
VERSION:      v0.2 - 2026-06-23
14

Changelog

v0.22026-07-24CQL correctness pass. All table() calls now carry an explicit row limit: the default is 200 and truncation is silent, so a capped result was indistinguishable from a complete one. Atomic-IOC sweeps (filters over 5+ hashes or C2 IPs) use limit=max so a wide infection is never silently under-scoped; behavioural hunts use limit=200, where exceeding the cap indicates the query needs tuning. Where present, event names that do not exist in the Falcon data model were corrected (e.g. ServiceInstalled is a Sysmon concept, not a Falcon event; ElfFileWritten is ELFFileWritten) — such queries could never return a row. No detection logic, fields, or IOCs changed.
v0.12026-06-23Initial pack built to the review-v2 gold layout (fixed left-sidebar scrollspy TOC, collapsible, cloud selector inside the CQL section, per-card Copy/Open-in-Falcon, Grouped IOC Quick-Copy grid, coverage+validation, .ticket). Sourced from The Hacker News / Kaspersky (2026-06-23): WhatsApp-delivered obfuscated .vbs -> WhatsApp.Root.exe->wscript lineage, secondary VBScript (UAC tamper + ZIP) -> ManageEngine RMM Central backdoor; one atomic C2 IOC (202.61.160.201, Gh0st/ValleyRAT infra overlap); UNATTRIBUTED. 6 CQL + 4 native hunts, 3 IOA candidates.
15

References

TierSourceUsed For
1The Hacker News — "WhatsApp VBScript Campaign Uses Fake Documents to Install ManageEngine RMM Tool" (2026-06-23, research by Kaspersky)Full chain, WhatsApp.Root.exe lineage, secondary payloads (UAC tamper + ZIP), ManageEngine RMM Central abuse, C2 202.61.160.201, Gh0st/ValleyRAT overlap, targeting, UNATTRIBUTED

HuntPack v0.1 · WhatsApp VBScript → ManageEngine RMM abuse · Generated 2026-06-23 · Defensive use only. Campaign infrastructure rotates; only 202.61.160.201 is a sourced atomic IOC. The behavioral detections (WhatsApp → wscript → .vbs lineage + unsanctioned RMM) are the durable signal. ManageEngine RMM Central is legitimate software — correlate every RMM hit to the .vbs lineage and validate field names in your tenant before promoting any query.