Overlord RAT Exploitation and Data Encryption

High severity TLP:CLEAR Part 2 of 2 Research by Cisco Talos Published 19 Nov 2026

Hypothesis

An adversary exploits a public-facing application to deploy the Overlord RAT and then encrypts data, bypassing traditional network blocks by resolving C2 coordinates via blockchain transactions.

Brief

Why now

Adversaries increasingly use public blockchains to host command-and-control (C2) instructions, a technique Cisco Talos describes in The challenge of defending against bulletproof dead drops on public blockchains. Because these transactions occur on legitimate decentralized ledgers like Solana or Ethereum, traditional domain or IP-based blocking often fails. This hunt focuses on the endpoint footprint of the Overlord RAT, which uses these blockchain dead drops after exploiting public-facing web applications.

How the hunt flows

The hunt begins with scoping. The first query searches software inventory to identify hosts running web server packages such as IIS, Apache, or Nginx. This limits the search to the primary attack surface and reduces noise in later steps.

Next, the hunt looks for application error logs. Specifically, it searches for access violation crashes (exception code c0000005) involving the identified web server binaries. An analyst evaluates these leads to determine if the crashes suggest a directed memory corruption exploit rather than routine software instability. This step acts as a gate for more expensive telemetry searches.

If the crash lead is suspicious, the hunt fans out into two parallel queries. The first query checks process activity for processes with no backing file on disk. This identifies the Overlord RAT's decrypter, which resides only in memory. The second query baselines file activity to find any process modifying more than 50 files in a short window, signaling the transition to ransomware encryption.

Finally, the analyst synthesizes the evidence. A successful hunt correlates the initial application crash, the presence of a fileless process, and high-volume file modifications on a single host. This combined evidence confirms a successful Overlord RAT intrusion and triggers isolation protocols.

What the hunt cannot see

This hunt depends on the exploit generating a detectable memory corruption event. If an adversary uses a logical exploit or a very stable memory exploit that does not crash the service, the hunt will not find the initial access lead. Additionally, if the endpoint agent truncates high-volume file events or does not monitor specific directories, the mass encryption phase may go undetected. The hunt also stays on the endpoint; it does not monitor the specific RPC calls to blockchain nodes.

In this series

Steps

  1. Query, scoping

    Identify internet-facing web assets

    Identify hosts running web server software to focus the hunt on the primary attack surface.

    sql, reads hb_software_inventory
    SELECT device_hostname, package_name, package_versionFROM hb_software_inventoryWHERE (instr(',' || '{{web_server_packages}}' || ',', ',' || LOWER(package_name) || ',') > 0 OR LOWER(package_name) LIKE '%web%server%')

    What a hit looks like. A list of hosts running web server packages. Silence implies no known web server software was found in inventory.

  2. Query, triage

    Web server memory corruption lead

    Find memory corruption events that likely represent exploitation attempts against web-facing services.

    sql, reads hb_application_error
    SELECT device_hostname, app_name, exception_code, message, timeFROM hb_application_errorWHERE exception_code = 'c0000005'  AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. Access violation crashes (c0000005) in web server binaries or their modules. Silence suggests no obvious memory-corruption exploits occurred.

  3. Agent triage

    Evaluate exploit crash lead

    Determine if observed application errors suggest a directed exploit rather than routine software instability.

  4. Decision

    Gate on exploit lead

    Gate expensive post-exploit searches behind a verified suspicious crash signal.

  5. Query, detection candidate

    Fileless process activity

    Detect the Overlord RAT by identifying processes that have no backing file on disk, signifying in-memory execution.

    sql, reads hb_process_activity
    SELECT device_hostname, process_name, process_cmd_line, on_disk, timeFROM hb_process_activityWHERE on_disk = 0  AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. A process running with on_disk = 0. This is the primary indicator of the Overlord RAT's in-memory decrypter.

  6. Query, baseline

    Rapid file modification baseline

    Identify ransomware behavior by stack-counting high-frequency file modifications per process.

    sql, reads hb_file_activity
    SELECT device_hostname, process_name, COUNT(DISTINCT file_path) AS unique_files, MIN(time) AS first_mod, MAX(time) AS last_modFROM hb_file_activityWHERE activity_id IN (1, 3, 5)  AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY device_hostname, process_nameHAVING unique_files > 50ORDER BY unique_files DESC

    What a hit looks like. A rare process modifying more than 50 files. Silence means no mass file changes were detected.

  7. Agent triage

    Synthesize exploit and impact evidence

    Combine exploitation signals with follow-on execution and disk activity to reach a final verdict.

  8. Decision

    Route on final verdict

    Direct the hunt based on the final synthesized verdict.

  9. Response action

    Isolate infected host

    Contain the threat and stop the spread of ransomware.

  10. Analyst task

    Analyst forensic review

    Confirm the infection details and identify the specific blockchain records used for C2 resolution.

  11. Analyst task

    Close out hunt

    Finalize documentation and record negative findings.

Coverage

3 of 5 stages covered

Stage and ATT&CK techniqueCoveredHow, or why not
Exploitation of Public-Facing Application
T1190
Yes scope-web-assets, exploit-crash-lead
Overlord RAT Execution Yes fileless-execution-rat
Data Encrypted for Impact
T1486
Yes rapid-file-encryption
Blockchain RPC Dead-Drop Resolution
T1090.004
Out of scope Belongs to another part of the 'The challenge of defending against bulletproof dead drops on public blockchains' series.
C2 Infrastructure Beaconing Out of scope Belongs to another part of the 'The challenge of defending against bulletproof dead drops on public blockchains' series.

Blind spots

  • Needs hb_application_error for all web server service accounts. A quiet exploit that achieves code execution without an access violation will bypass the gated logic. It would answer: whether the exploit succeeded without generating a crash event
  • Needs hb_file_activity with low-latency collection. If the agent truncates file events or does not monitor specific directories, the encryption phase may go undetected. It would answer: whether the EDR captures the speed and volume of file modifications

Parameters and data

Parameters

ParameterTypeDefaultWhat it is
lookback_daysnumber14Days of history to examine.
scope_hostslist[host]noneOptional list of hostnames to focus the hunt on; if empty, the entire estate is checked.
web_server_packageslist[string]iis, apache, nginx, tomcat, httpdCommon web server package names to identify the attack surface.

Data sources

SourceCategoryTelemetry
Endpoint telemetry (hb_ surfaces)endpointendpoint

Source

An open hunt.md file. It runs anywhere that reads the format.

hunt.md
---
analysis: A single rule may detect a crash or a fileless process, but this hunt correlates
  instability, in-memory execution, and rapid disk activity across three different
  surfaces to provide a high-confidence forensic picture of a ransomware intrusion.
blind_spots:
- id: no-crash-telemetry
  question: whether the exploit succeeded without generating a crash event
  requires: hb_application_error for all web server service accounts
  risk: A quiet exploit that achieves code execution without an access violation will
    bypass the gated logic.
  stage: initial-access-exploit
- id: no-file-telemetry
  question: whether the EDR captures the speed and volume of file modifications
  requires: hb_file_activity with low-latency collection
  risk: If the agent truncates file events or does not monitor specific directories,
    the encryption phase may go undetected.
  stage: impact-data-encryption
coverage:
- stage: initial-access-exploit
  status: covered
  steps:
  - scope-web-assets
  - exploit-crash-lead
- stage: execution-overlord-rat
  status: covered
  steps:
  - fileless-execution-rat
- stage: impact-data-encryption
  status: covered
  steps:
  - rapid-file-encryption
- reason: Belongs to another part of the 'The challenge of defending against bulletproof
    dead drops on public blockchains' series.
  stage: c2-blockchain-dead-drop-resolution
  status: out_of_scope
- reason: Belongs to another part of the 'The challenge of defending against bulletproof
    dead drops on public blockchains' series.
  stage: c2-primary-beaconing
  status: out_of_scope
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: promote-to-detection
  justification: Public-facing applications remain a primary intrusion vector. This
    hunt addresses the risk of blockchain-backed malware that evades traditional infrastructure
    blocks by focusing on the local endpoint footprint of exploitation and impact.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An adversary exploits a public-facing application to deploy the Overlord
  RAT and then encrypts data, bypassing traditional network blocks by resolving C2
  coordinates via blockchain transactions.
labels:
- hunt
- attack.t1190
- attack.t1486
- command and control
- execution
- impact
- initial access
name: Overlord RAT Exploitation and Data Encryption
parameters:
  lookback_days:
    default: '14'
    description: Days of history to examine.
    from:
      kind: article
      observed: '2026-11-18'
      ref: https://blog.talosintelligence.com/the-challenge-of-defending-against-bulletproof-dead-drops-on-public-blockchains/
    type: number
  scope_hosts:
    default: []
    description: Optional list of hostnames to focus the hunt on; if empty, the entire
      estate is checked.
    from:
      kind: manual
      observed: '2026-11-18'
      ref: scoping-step
    type: list[host]
  web_server_packages:
    default:
    - iis
    - apache
    - nginx
    - tomcat
    - httpd
    description: Common web server package names to identify the attack surface.
    from:
      kind: article
      observed: '2026-11-18'
      ref: https://blog.talosintelligence.com/the-challenge-of-defending-against-bulletproof-dead-drops-on-public-blockchains/
    type: list[string]
provenance:
  authors:
  - name: Huntbase hunt generation
    org: huntbase.io
  generated:
    by: huntbase-hunt-generation
    from: https://blog.talosintelligence.com/the-challenge-of-defending-against-bulletproof-dead-drops-on-public-blockchains/
    gates:
    - dry-run
    - lint
    - critic
    model: hb_google/gemini-3-flash-preview
rationale: The hunt begins by identifying web server infrastructure; ensure the web_server_packages
  parameter is tailored to your environment.
references:
- name: "Cisco Talos \u2014 The challenge of defending against bulletproof dead drops\
    \ on public blockchains"
  url: https://blog.talosintelligence.com/the-challenge-of-defending-against-bulletproof-dead-drops-on-public-blockchains/
related:
- hunt: c2-blockchain-dead-drop-resolution
  reason: That hunt focuses on outbound network RPC calls to blockchain nodes, while
    this hunt focuses on the endpoint execution and resulting impact.
  relation: out-of-scope-alternative
- hunt: decentralized-blockchain-c2-resolution
  relation: follows
scenario:
  stages:
  - name: Exploitation of Public-Facing Application
    observables:
    - anomalous web server errors
    - unexpected inbound traffic to public-facing web applications
    slug: initial-access-exploit
    tactic: initial-access
    techniques:
    - T1190
  - name: Overlord RAT Execution
    observables:
    - Overlord RAT binary
    - in-memory decryption of C2 configurations
    - lightweight decrypter process activity
    slug: execution-overlord-rat
    tactic: execution
  - name: Blockchain RPC Dead-Drop Resolution
    observables:
    - outbound JSON-RPC queries to Infura (infura.io)
    - outbound JSON-RPC queries to QuickNode (quicnode.pro)
    - outbound JSON-RPC queries to Tatum (tatum.io)
    - 'JSON-RPC methods: eth_call, getTransaction, getSignaturesForAddress'
    - base-encoded data in HTTP POST request bodies
    - DNS resolution for public blockchain node providers
    slug: c2-blockchain-dead-drop-resolution
    tactic: command-and-control
    techniques:
    - T1090.004
  - name: C2 Infrastructure Beaconing
    observables:
    - outbound connections to dynamically resolved C2 IP addresses
    - beaconing traffic to previously unknown domains
    slug: c2-primary-beaconing
    tactic: command-and-control
  - name: Data Encrypted for Impact
    observables:
    - rapid file modification and encryption
    - ransomware notes on system drives
    slug: impact-data-encryption
    tactic: impact
    techniques:
    - T1486
  summary: The threat actor UAT-12643 utilizes the Overlord RAT to retrieve encrypted
    command-and-control configurations from public blockchains including Bitcoin,
    Ethereum, and Solana. By using JSON-RPC queries to public node providers like
    Infura and QuickNode, the malware resolves its C2 infrastructure through immutable
    ledger data such as Solana Memo transactions or Ethereum smart contracts.
series:
  index: 2
  slug: the-challenge-of-defending-against-bulletproof-dead-drops-on-public-blockchains
  title: The challenge of defending against bulletproof dead drops on public blockchains
  total: 2
severity: high
targets:
  analyst:
    name: Tier-2 analyst
    role: analyst
  endpoint:
    category: endpoint
    name: Endpoint telemetry (hb_ surfaces)
    telemetry:
    - endpoint
  hunter:
    agent: true
    name: Hunt agent
tlp: clear
type: investigation
---


# Overlord RAT Exploitation and Data Encryption

By correlating application instability with subsequent fileless activity and mass encryption, the hunt identifies the full intrusion lifecycle. The adversary exploits internet-facing web assets to achieve initial access, often leaving a trail of memory-corruption crashes. The hunt first isolates these crash leads before deploying a fan-out of queries to find fileless execution and rapid file modifications. Finally, the analyst confirms the presence of the Overlord RAT by weighing the combined evidence from application errors, endpoint process state, and disk activity.

## scope-web-assets
<!-- Identify internet-facing web assets -->
Identify hosts running web server software to focus the hunt on the primary attack surface.

```sqlite target=endpoint role=scoping params=(web_server_packages=web_server_packages)
~~~yaml
expected: A list of hosts running web server packages. Silence implies no known web
  server software was found in inventory.
reads:
- device_hostname
- package_name
- package_version
silence: not_evidence_of_absence
source: hb_software_inventory
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, package_name, package_version FROM hb_software_inventory WHERE (instr(',' || '{{web_server_packages}}' || ',', ',' || LOWER(package_name) || ',') > 0 OR LOWER(package_name) LIKE '%web%server%')
```

## exploit-crash-lead
<!-- Web server memory corruption lead -->
Find memory corruption events that likely represent exploitation attempts against web-facing services.

```sqlite target=endpoint role=triage params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
expected: Access violation crashes (c0000005) in web server binaries or their modules.
  Silence suggests no obvious memory-corruption exploits occurred.
reads:
- device_hostname
- app_name
- exception_code
- message
- time
silence: not_evidence_of_absence
source: hb_application_error
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, app_name, exception_code, message, time FROM hb_application_error WHERE exception_code = 'c0000005' AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## evaluate-lead-agent
<!-- Evaluate exploit crash lead -->
```agent target=hunter
cite: required
context:
- exploit-crash-lead
max_iterations: 3
objective: Determine whether the crashes in exploit-crash-lead suggest a directed
  memory corruption exploit against a web application.
success_criteria: A per-host verdict of suspicious | benign citing the crashed application
  and frequency.
tools:
- endpoint
```

## gate-decision
<!-- Gate on exploit lead -->
if~: "the evaluate-lead-agent verdict is suspicious for at least one host" (confidence: medium, judge=hunter)
then: → parallel-fan-out
indeterminate: → close-out
unavailable: → close-out (blind_spot: no-crash-telemetry)
else: → close-out

## parallel-fan-out
<!-- Fan-out to execution and impact -->
parallel:
- → fileless-execution-rat
- → rapid-file-encryption
join: → triage-agent

## fileless-execution-rat
<!-- Fileless process activity -->
Detect the Overlord RAT by identifying processes that have no backing file on disk, signifying in-memory execution.

```sqlite target=endpoint role=detection-candidate params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
expected: A process running with on_disk = 0. This is the primary indicator of the
  Overlord RAT's in-memory decrypter.
reads:
- device_hostname
- process_name
- process_cmd_line
- on_disk
- time
silence: not_evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, process_name, process_cmd_line, on_disk, time FROM hb_process_activity WHERE on_disk = 0 AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## rapid-file-encryption
<!-- Rapid file modification baseline -->
Identify ransomware behavior by stack-counting high-frequency file modifications per process.

```sqlite target=endpoint role=baseline params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: A rare process modifying more than 50 files. Silence means no mass file
  changes were detected.
prevalence:
  by: device_hostname
  key:
  - process_name
  rare_below: 3
reads:
- device_hostname
- process_name
- activity_id
- file_path
- time
silence: not_evidence_of_absence
source: hb_file_activity
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, process_name, COUNT(DISTINCT file_path) AS unique_files, MIN(time) AS first_mod, MAX(time) AS last_mod FROM hb_file_activity WHERE activity_id IN (1, 3, 5) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY device_hostname, process_name HAVING unique_files > 50 ORDER BY unique_files DESC
```

## triage-agent
<!-- Synthesize exploit and impact evidence -->
```agent target=hunter
cite: required
context:
- evaluate-lead-agent
- fileless-execution-rat
- rapid-file-encryption
max_iterations: 6
objective: Determine if the suspicious crash, fileless execution, and high-volume
  file modification together indicate a successful Overlord RAT intrusion and ransomware
  event.
success_criteria: A per-host verdict of malicious | suspicious | benign citing evidence
  from all stages.
tools:
- endpoint
```

## route-decision
<!-- Route on final verdict -->
if~: "the triage-agent verdict is malicious for at least one host" (confidence: high, judge=hunter)
then: → isolate-infected-host
indeterminate: → analyst-review
unavailable: → analyst-review (blind_spot: no-file-telemetry)
else: → close-out

## isolate-infected-host
<!-- Isolate infected host -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host from the network. Capture process memory for the fileless process before remediation to identify the C2 resolved via blockchain.
```
→ analyst-review

## analyst-review
<!-- Analyst forensic review -->
```manual target=analyst
Review the file modification paths to identify the ransomware extension. Examine the isolated process memory to find the Solana or Ethereum RPC calls used to retrieve the C2 coordinates.
```
→ end

## close-out
<!-- Close out hunt -->
```manual target=analyst
Record the hosts examined. If no suspicious activity was found, update the web server scoping lists for future hunts.
```
→ end

Run this hunt against your own data.

In Huntbase, Scout runs every step across the tools you already connect, checks back through your history and returns a verdict with the evidence. The hunt.md file is open, so you can also take it anywhere that reads the format.

Drafted by machine (huntbase-hunt-generation, hb_google/gemini-3-flash-preview), checked by dry-run, lint, critic, then reviewed by a person.

Content pack

Sign up to open

Pack contents open in Huntbase.