Back to Intelligence

ROMULUS ClickFix Campaign Delivers CNCMachineRMS-Like RAT: Detection, Hunting, and Hardening Guide

SA
Security Arsenal Team
November 20, 2026
14 min read

Threat actors are actively using the ROMULUS ClickFix malicious software delivery platform to distribute a previously undocumented remote access trojan (RAT) that shares significant code and behavioral similarities with CNCMachineRMS. According to Blackpoint's analysis, ROMULUS appears to operate as a delivery-as-a-service platform, pushing both the new RAT and Legion Loader through separate infection chains while retaining two hallmark techniques: the ClickFix social engineering lure and signed binary DLL sideloading.

This matters to every defender reading this because ClickFix bypasses the control layer most organizations rely on hardest: the email gateway and the file-based AV stack. There is no malicious attachment to sandbox and no exploit to patch. The victim is tricked into running the malware themselves — typically by copying a command from a fake CAPTCHA or "browser verification" page and pasting it into the Windows Run dialog (Win+R) or a terminal. Once executed, the chain sideloads a malicious DLL through a legitimately signed binary, and the RAT establishes full remote control: screen surveillance, keystroke capture, file access, and command execution.

If your users can open a browser and press Win+R, you are in scope. Let's break the chain down and build detections for every stage.


Technical Analysis

What ROMULUS Is

ROMULUS is best understood as a malware delivery platform — infrastructure and tooling sold or rented to threat actors — rather than a single malware family. Blackpoint's assessment is that ROMULUS distributes at least two distinct payloads through separate chains:

  1. The new CNCMachineRMS-like RAT — previously undocumented, with remote surveillance (screen/webcam spying) and full system control capabilities.
  2. Legion Loader — a known loader used to stage follow-on payloads (infostealers, additional RATs, ransomware precursors).

Both chains retain the same delivery tradecraft, which is what ties them to the ROMULUS platform.

Attack Chain (Defender's View)

Stage 1 — ClickFix social engineering. The victim lands on a compromised or malicious site (via malvertising, SEO poisoning, phishing links, or forum posts) presenting a fake CAPTCHA, a fake "Verify you are human" check, or a bogus error message claiming the browser or a document failed to load. The page instructs the user to:

  1. Press Win+R to open the Run dialog
  2. Press Ctrl+V to paste (the page has silently copied a command to the clipboard via JavaScript)
  3. Press Enter

Key observable: a script interpreter (powershell.exe, mshta.exe, wscript.exe, or cmd.exe) is spawned directly by explorer.exe — because the Run dialog is an explorer.exe child — often with an obfuscated or download-cradle command line. Legitimate software almost never instructs users to paste commands into Run. This parent-child relationship is your highest-fidelity detection anchor.

Stage 2 — Staging and download. The pasted command is typically a PowerShell or mshta cradle that retrieves a second-stage payload from attacker infrastructure, frequently writing to user-writable directories (%TEMP%, %APPDATA%, %LOCALAPPDATA%, %PUBLIC%) and sometimes using curl.exe or certutil.exe as LOLBins.

Stage 3 — Signed binary sideloading. ROMULUS retains a signed-binary sideloading technique: a legitimately signed executable is dropped alongside a malicious DLL with the name the signed binary expects to load from its own directory. When the signed binary executes, it loads the attacker DLL, inheriting the signer reputation and evading naive application-whitelisting and reputation-based detections.

Key observable: a signed executable executing from an unusual path (user profile directories, ProgramData subfolders, temp paths) loading a DLL that is unsigned or has an anomalous hash, timestamp, or version metadata compared to the legitimate companion DLL.

Stage 4 — RAT execution and C2. The CNCMachineRMS-like payload establishes command-and-control, enabling screen capture, input surveillance, file manipulation, and arbitrary command execution — the classic full-featured RAT profile. Because Legion Loader is delivered in parallel chains, secondary payload staging (infostealers, credential theft) should be assumed on any confirmed hit.

Exploitation Status

  • Active in-the-wild distribution via the ROMULUS platform — confirmed by Blackpoint's observation of live campaigns.
  • No CVE is associated with this threat. ClickFix is pure social engineering; it exploits user trust and default Windows behavior, not a software vulnerability. There is nothing to patch — defense is entirely behavioral detection and hardening.
  • Not currently in CISA KEV (no CVE exists to list), but the technique family is well-documented under MITRE ATT&CK as T1204.002 (User Execution: Malicious File), T1059.001 (PowerShell), T1218.005 (Mshta), and T1574.002 (Hijack Execution Flow: DLL Side-Loading).

Why This Beats Traditional Controls

  • Email gateways: the lure often arrives via web, malvertising, or SEO poisoning — no attachment, no URL rewrite hit if the domain is fresh.
  • Signature AV: the initial stage is a user-typed command; the payload is sideloaded through a signed binary.
  • SmartScreen/reputation: signed binaries inherit signer reputation; fresh C2 domains have no history.

This is why the detections below focus on parent-child process relationships and behavioral anomalies, not indicators of compromise that will be rotated by tomorrow.


Detection & Response

Sigma Rules

The highest-fidelity detection in this chain is a script interpreter spawned by explorer.exe — the signature of a Run-dialog-pasted command. The second rule targets the mshta variant of the ClickFix lure, and the third targets the signed-binary sideloading stage.

YAML
---
title: ClickFix-Style Run Dialog Script Interpreter Execution
id: 3f8a2c41-7b1e-4d9a-b6c2-9e0f5a7d3c11
status: experimental
description: Detects script interpreters (PowerShell, mshta, wscript, cscript) spawned directly by explorer.exe, consistent with ClickFix lures that trick users into pasting commands into the Windows Run dialog. ROMULUS campaigns use this technique to deliver CNCMachineRMS-like RATs and Legion Loader.
references:
  - https://thehackernews.com/2026/11/romulus-clickfix-attacks-deliver-rat.html
  - https://attack.mitre.org/techniques/T1204/002/
  - https://attack.mitre.org/techniques/T1059/001/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.execution
  - attack.t1204.002
  - attack.t1059.001
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith: '\explorer.exe'
  selection_image:
    Image|endswith:
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\mshta.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\cmd.exe'
  selection_cli:
    CommandLine|contains:
      - 'http://'
      - 'https://'
      - '-enc'
      - '-e '
      - 'FromBase64String'
      - 'Invoke-Expression'
      - 'iex'
      - 'DownloadString'
      - 'Invoke-WebRequest'
      - 'iwr'
      - 'curl'
      - 'certutil'
  condition: selection_parent and selection_image and selection_cli
falsepositives:
  - Rare; some IT staff run ad-hoc download commands via Run dialog. Tune by user group.
level: high
---
title: Mshta Spawning Script or Download Child Process
id: 8c4d1e92-5a3b-4f7c-a1d6-2b9e8f0c4d55
status: experimental
description: Detects mshta.exe spawning PowerShell, cmd, or other script interpreters — a common second hop in ClickFix chains where the pasted Run-dialog command invokes an HTA that stages the ROMULUS payload.
references:
  - https://thehackernews.com/2026/11/romulus-clickfix-attacks-deliver-rat.html
  - https://attack.mitre.org/techniques/T1218/005/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.defense_evasion
  - attack.t1218.005
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    ParentImage|endswith: '\mshta.exe'
    Image|endswith:
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\cmd.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\curl.exe'
      - '\certutil.exe'
  condition: selection
falsepositives:
  - Very rare in hardened environments; some legacy enterprise HTA apps may trigger.
level: high
---
title: Signed Binary Executing From User-Writable Path (Potential DLL Sideload)
id: 5e2b7a14-9c6f-4d83-b8a1-4f0c6e2d9b77
status: experimental
description: Detects execution of binaries from user-writable directories that masquerade as legitimate signed applications, consistent with ROMULUS retaining signed-binary DLL sideloading. Correlate with unsigned or anomalous DLL loads (Sysmon EventID 7) from the same directory.
references:
  - https://thehackernews.com/2026/11/romulus-clickfix-attacks-deliver-rat.html
  - https://attack.mitre.org/techniques/T1574/002/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.defense_evasion
  - attack.persistence
  - attack.t1574.002
logsource:
  category: image_load
  product: windows
detection:
  selection_path:
    ImageLoad|startswith:
      - 'C:\Users\'
      - 'C:\ProgramData\'
  selection_unsigned:
    Signed: 'false'
  filter_system_paths:
    ImageLoad|contains:
      - '\Microsoft\Edge\'
      - '\Microsoft\Teams\'
      - '\AppData\Local\Microsoft\'
  condition: selection_path and selection_unsigned and not filter_system_paths
falsepositives:
  - Developer tooling, portable apps, some updaters. Tune aggressively per environment; enrich with parent process and signer metadata of the loading executable.
level: medium

A note on tuning: Rule 3 will need environment-specific filtering — unsigned DLLs in user paths are common with legitimate portable software. Its value is as a correlation pivot: when a Sysmon image-load event fires from the same directory and within seconds of a Rule 1 or Rule 2 process-creation alert, your confidence should go to near-certain. Don't deploy Rule 3 as a standalone high-severity alert.

KQL — Microsoft Sentinel / Defender

This query hunts the core ClickFix behavioral signature across Defender for Endpoint process telemetry, then enriches with any follow-on network connections from the same device — catching the RAT's C2 in the same pane.

KQL — Microsoft Sentinel / Defender
// Hunt: ClickFix-style Run-dialog execution and follow-on C2 (ROMULUS / CNCMachineRMS-like RAT)
let Lookback = 7d;
let SuspiciousChildren = dynamic(["powershell.exe", "pwsh.exe", "mshta.exe", "wscript.exe", "cscript.exe", "cmd.exe", "curl.exe", "certutil.exe", "rundll32.exe", "regsvr32.exe"]);
let ClickFixExec = DeviceProcessEvents
| where TimeGenerated > ago(Lookback)
| where InitiatingProcessFileName =~ "explorer.exe"
| where FileName in~ (SuspiciousChildren)
| where ProcessCommandLine has_any ("http://", "https://", "-enc", "FromBase64String", "Invoke-Expression", "DownloadString", "Invoke-WebRequest", "iwr ", "iex ", "certutil", "curl ")
| project DeviceId, DeviceName, ExecutionTime=TimeGenerated, FileName, ProcessCommandLine, AccountName, InitiatingProcessCommandLine, ReportId, SHA256;
ClickFixExec
| join kind=leftouter (
    DeviceNetworkEvents
    | where TimeGenerated > ago(Lookback)
    | where InitiatingProcessFileName in~ (SuspiciousChildren) or InitiatingProcessFileName =~ "powershell.exe"
    | where RemoteIPType == "Public"
    | summarize C2Connections=make_set(strcat(RemoteUrl, " (", RemoteIP, ":", RemotePort, ")"), 20) by DeviceId, TimeGenerated
    | extend TimeGenerated = bin(TimeGenerated, 5m)
) on DeviceId
| project DeviceName, AccountName, ExecutionTime, FileName, ProcessCommandLine, SHA256, C2Connections
| order by ExecutionTime desc

For environments without Defender for Endpoint, the same logic applies against SecurityEvent (4688 with command-line auditing enabled) or CommonSecurityLog if you're ingesting Sysmon via a collector — pivot on ParentProcessName endswith "explorer.exe".

Velociraptor VQL

This hunt artifact sweeps endpoints for the two forensic artifacts ClickFix leaves behind even after the window closes: RunMRU registry entries (the Run dialog's history, showing exactly what was pasted) and unsigned DLLs sitting beside executables in user-writable paths.

VQL — Velociraptor
-- Hunt: ClickFix RunMRU artifacts + unsigned DLLs beside EXEs in user paths (ROMULUS tradecraft)
LET RunMRU = SELECT
    Key.OSPath AS RegPath,
    Key.MTime AS LastWrite,
    { SELECT Name, Data FROM stat(filename=Key.OSPath) } AS Entry
FROM foreach(row={ SELECT OSPath FROM glob(globs="HKEY_USERS/*/Software/Microsoft/Windows/CurrentVersion/Explorer/RunMRU", accessor="registry") })

LET SuspiciousDLLs = SELECT
    FullPath,
    Mtime,
    Size,
    Authenticode
FROM glob(globs=[
    "C:/Users/*/AppData/**/*.dll",
    "C:/ProgramData/**/*.dll"
], accessor="ntfs")
WHERE Authenticode.Trusted =~ "untrusted|unsigned" OR Authenticode = NULL

SELECT * FROM RunMRU
UNION ALL
SELECT FullPath AS RegPath, Mtime AS LastWrite, Authenticode AS Entry FROM SuspiciousDLLs

Analyst note: RunMRU is the single most underutilized artifact in ClickFix investigations. When a user pastes into Win+R, the full pasted command is preserved in that key — you will often recover the exact obfuscated cradle, the C2 URL, and the staging path in one registry read. Scope the glob accessors to your environment and consider splitting the two queries into separate artifacts for performance on large fleets.

Hardening & Remediation Script

There is no patch for social engineering — but there is a great deal of policy surface to close. This PowerShell script (run elevated, suitable for Intune/GPO deployment adaptation) applies the highest-value mitigations: it restricts mshta via an ASR rule, enables script-block logging for forensic visibility, enables Constrained Language Mode support, and audits Run-dialog spawns.

PowerShell
# ROMULUS / ClickFix hardening - run as SYSTEM or elevated admin
# Test in Audit mode first, then switch to Block

# 1. ASR rule: Block executable content from email client and webmail (adjacent lure vector)
#    + Block process creations from PSExec/WMI is optional; the key ones here:
#    d4f940ab-401b-4efc-aadc-ad5f3c50688a = Block all Office apps from creating child processes
#    56a863a9-875e-4185-98a7-b882c64b5ce5 = Block abuse of exploited vulnerable signed drivers
#    7674ba52-37eb-4a4f-a9a1-f0f9a1619a2c = Block Adobe Reader child processes
# Most relevant for ClickFix staging: block Office/Adobe child procs; mshta restriction via WDAC/AppLocker below.
$asrRules = @{
    "d4f940ab-401b-4efc-aadc-ad5f3c50688a" = 1  # Office child processes - Block
    "7674ba52-37eb-4a4f-a9a1-f0f9a1619a2c" = 1  # Adobe Reader child processes - Block
    "be9ba2d9-53ea-4cdc-84e5-9b1eeee46550" = 1  # Block executable content from email/webmail - Block
}
foreach ($rule in $asrRules.GetEnumerator()) {
    Add-MpPreference -AttackSurfaceReductionRules_Ids $rule.Key -AttackSurfaceReductionRules_Actions $rule.Value
}

# 2. Block mshta.exe via AppLocker-style hash/path rule using WDAC is ideal;
#    quick win: deny mshta execution for standard users via software restriction registry policy
$mshtaPolicy = "HKLM:\SOFTWARE\Policies\Microsoft\Windows\Safer\CodeIdentifiers"
if (-not (Test-Path $mshtaPolicy)) { New-Item -Path $mshtaPolicy -Force | Out-Null }
Set-ItemProperty -Path $mshtaPolicy -Name "DefaultLevel" -Value 0x00040000  # Disallowed-by-default scaffolding
Write-Output "[!] SRP scaffold created. Deploy a path rule blocking %WINDIR%\System32\mshta.exe for non-admin groups via GPO."

# 3. PowerShell Script Block Logging + Module Logging (forensic visibility into ClickFix cradles)
$psLog = "HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging"
if (-not (Test-Path $psLog)) { New-Item -Path $psLog -Force | Out-Null }
Set-ItemProperty -Path $psLog -Name "EnableScriptBlockLogging" -Value 1
Set-ItemProperty -Path $psLog -Name "EnableScriptBlockInvocationLogging" -Value 1

# 4. Enable process creation command-line auditing (Event 4688 /cmdline) - required for the Sigma/KQL above
auditpol /set /subcategory:"Process Creation" /success:enable /failure:enable | Out-Null
$cmdlineReg = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Audit"
if (-not (Test-Path $cmdlineReg)) { New-Item -Path $cmdlineReg -Force | Out-Null }
Set-ItemProperty -Path $cmdlineReg -Name "ProcessCreationIncludeCmdLine_Enabled" -Value 1

# 5. Verify state
Get-MpPreference | Select-Object -ExpandProperty AttackSurfaceReductionRules_Ids
Get-ItemProperty -Path $psLog
Write-Output "[+] Hardening applied. Validate ASR events in Event Viewer (Microsoft-Windows-Windows Defender/Operational, IDs 1121/1122)."

Remediation & Defensive Priorities

Because this campaign exploits user behavior and default Windows functionality rather than a patchable vulnerability, remediation is layered. Prioritize in this order:

1. Break the ClickFix Interaction (Highest ROI)

  • User awareness with a specific rule: "No legitimate website will ever ask you to press Win+R, paste a command, or open a terminal to verify you are human." This single sentence, drilled into your workforce, neutralizes the entire technique family. Run a simulated ClickFix phishing exercise — standard attachment-based simulations don't train for this.
  • Consider disabling the Run dialog for standard users via GPO (User Configuration > Administrative Templates > Start Menu and Taskbar > Remove Run menu from Start Menu). Test against legitimate admin workflows first — helpdesk and power users will need exceptions.
  • Block JavaScript clipboard writes where feasible. Browser-level enterprise policies can restrict clipboard API access on untrusted sites; at minimum, ensure browser SmartScreen/Safe Browsing is enforced and cannot be bypassed by users.

2. Constrain the Execution Surface

  • Restrict mshta.exe, wscript.exe, and cscript.exe via AppLocker or WDAC for all users who don't have a documented business need. There is vanishingly little legitimate mshta usage in 2026.
  • Enforce PowerShell Constrained Language Mode (via WDAC/AppLocker enforced mode) and enable Script Block Logging fleet-wide — the obfuscated cradles used in these chains fail or become highly visible under CLM.
  • Deploy the ASR rules in the script above, starting in Audit mode for 7–14 days, then move to Block.

3. Defeat the Sideload

  • WDAC policies that trust by signer and path — a signed binary executing from %TEMP% should fail policy even if the signature is valid. Publisher-only rules are exactly what sideloading abuses.
  • Deploy Sysmon (or equivalent) with image-load logging (EventID 7) so the unsigned companion DLL is observable; alert on unsigned DLL loads from user-writable paths correlated with recent process creation (see Sigma Rule 3 and the tuning note).

4. Network Layer

  • Egress filtering: block outbound connections from script interpreters and unsigned binaries to the internet where feasible (proxy enforcement). The RAT and Legion Loader both need C2 — a restrictive egress policy converts a full compromise into a failed staging attempt.
  • Alert on newly observed domains and TLS sessions without DNS resolution (direct-IP C2) from endpoints.

5. If You Confirm a Hit

  • Isolate the host immediately. The RAT has surveillance capability — assume keystrokes, credentials, and on-screen data since execution are compromised.
  • Capture RunMRU before remediation (see the VQL artifact) — it preserves the exact pasted command and C2.
  • Hunt laterally for Legion Loader follow-on payloads: infostealers mean credential exposure — force resets for any account used on the affected host, including sessions/tokens, not just passwords.
  • Check persistence: Run keys, scheduled tasks, and services registered by the sideloaded DLL.

The Bottom Line

ROMULUS is a delivery platform doing what delivery platforms do: renting proven tradecraft to whoever pays. The ClickFix lure works because it routes around every control that inspects files and links and puts execution in the user's hands. Your defense has to move to the same layer: the parent-child process relationship, the RunMRU artifact, the unsigned DLL next to a trusted binary, and the one behavior no attacker can obfuscate — a website asking a human to paste a command into their operating system.

Deploy the Run-dialog detection today. It is high-fidelity, low-noise, and catches the entire technique family — not just this campaign.

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.