Decentralized Blockchain C2 Resolution

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

Hypothesis

An adversary is using public blockchain ledgers as dead-drop resolvers for C2 configuration, identified by outbound RPC calls to node providers followed by rare network beaconing to resolved endpoints.

Brief

Resilience through Decentralization

Adversaries increasingly use public blockchains to host command-and-control (C2) configuration. As detailed in the Talos Intelligence article, The challenge of defending against bulletproof dead drops on public blockchains, attackers store C2 IP addresses or domains within immutable ledger transactions. Malware then queries these ledgers via legitimate RPC (Remote Procedure Call) providers to find its next hop. This technique makes traditional takedowns and sinkholing nearly impossible because the resolution mechanism relies on a globally distributed, permanent database.

How the Hunt Flows

The hunt begins by scoping hosts that resolve known blockchain RPC provider domains. The first query searches DNS logs for lookups to infrastructure like infura.io or solana.com. While developers and research teams frequently use these services, the goal here is to identify candidate systems that act as starting points for deeper inspection.

Next, the hunt narrows the focus to active communication. It examines HTTP POST activity from the candidate hosts to the identified RPC providers. Because retrieving data from a blockchain requires sending a JSON-RPC payload to an endpoint, these POST requests represent the actual data retrieval event. The hunt looks for unusual User-Agents or process names that do not match standard browser or developer tools.

Finally, the hunt correlates the RPC traffic with outbound network activity. It identifies rare connections to external IP addresses that follow the blockchain resolution event. The logic prioritizes connections to non-standard ports (excluding 80, 443, and 53). A high-confidence lead emerges when the same process that performed the RPC lookup, or a related child process, initiates a new connection to an external endpoint that has low prevalence across the rest of the environment.

Blind Spots

This hunt faces limitations due to encryption. Most RPC providers use HTTPS, which masks the specific JSON-RPC method call and the resulting payload from network-level inspection. Unless the environment employs TLS decryption, the hunt cannot verify if the malware is calling a specific transaction or simply checking the status of the node. Furthermore, if the malware uses a private or internal RPC gateway not included in the provider list, the initial scoping query will not flag the activity.

In this series

Steps

  1. Query, scoping

    DNS lookups to blockchain RPC nodes

    Identify hosts and processes resolving known blockchain RPC provider domains as a lead for potential dead-drop resolution.

    sql, reads hb_dns_activity
    SELECT device_hostname, process_name, pid, query_hostname, COUNT(*) AS lookup_count, MIN(time) AS first_lookupFROM hb_dns_activityWHERE (instr(',' || '{{rpc_providers}}' || ',', ',' || LOWER(query_hostname) || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY device_hostname, process_name, pid, query_hostname

    What a hit looks like. Hosts and specific processes resolving blockchain domains. Legitimate developer activity will show high volume across multiple distinct providers; malicious resolution is typically low volume and tied to unusual processes.

  2. Query, enrichment

    HTTP POST activity to RPC endpoints

    Focus on the HTTP POST requests that carry JSON-RPC payloads, which are required for querying specific blockchain data like transactions or logs.

    sql, reads hb_http_activity
    SELECT device_hostname, url_hostname, url_path, http_method, user_agent, timeFROM hb_http_activityWHERE (instr(',' || '{{rpc_providers}}' || ',', ',' || LOWER(url_hostname) || ',') > 0)  AND http_method = 'POST'  AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. POST requests to RPC providers from the scoping hosts. Analysts should look for unusual User-Agents or paths that do not match standard browser or developer tool patterns.

  3. Query, baseline

    Rare outbound connections from RPC hosts

    Identify non-standard outbound connections occurring on hosts that have also performed blockchain RPC lookups, prioritizing non-standard ports.

    sql, reads hb_network_connection
    SELECT device_hostname, dst_endpoint_ip, dst_endpoint_port, process_name, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_seenFROM hb_network_connectionWHERE direction = 'outbound'  AND disposition = 'Allowed'  AND (dst_endpoint_port NOT IN (80, 443, 53))  AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)  AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY dst_endpoint_ip, dst_endpoint_port, process_nameHAVING host_count <= 3ORDER BY host_count ASC

    What a hit looks like. A connection to a rare external IP address on a non-standard port. Correlation is strongest when this connection follows an RPC lookup by the same host.

  4. Agent triage

    Evaluate blockchain-to-C2 sequence

    Analyze the temporal and behavioural relationship between blockchain interaction and rare network egress.

  5. Decision

    Route on triage verdict

    Direct the hunt based on the agent's correlation of blockchain resolution and beaconing behaviour.

  6. Response action

    Isolate host and capture memory

    Neutralize the threat and preserve the in-memory artifacts characteristic of Overlord RAT and similar blockchain-backed malware.

  7. Analyst task

    Analyst forensic review

    Verify the agent's findings and investigate the origin of the malicious process.

  8. Analyst task

    Hunt closure and tuning

    Record findings and update exclusions to reduce false positives for legitimate developer activity.

Coverage

2 of 5 stages covered

Stage and ATT&CK techniqueCoveredHow, or why not
Blockchain RPC Dead-Drop Resolution
T1090.004
Yes dns-to-blockchain-rpc, http-rpc-post-activity
C2 Infrastructure Beaconing Yes rare-outbound-beacons
Exploitation of Public-Facing Application
T1190
Out of scope Belongs to another part of the 'The challenge of defending against bulletproof dead drops on public blockchains' series.
Overlord RAT Execution Out of scope Belongs to another part of the 'The challenge of defending against bulletproof dead drops on public blockchains' series.
Data Encrypted for Impact
T1486
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_http_activity with full JSON-RPC body capture. Without the POST body, we cannot distinguish between a legitimate node status check and a specific coordinate retrieval call. It would answer: Which specific JSON-RPC methods (eth_call, getSignaturesForAddress) were called?
  • Needs TLS inspection at the gateway or endpoint. HTTPS to standard providers like Infura masks the malicious payload from traditional NIDS/DPI. It would answer: Is the content of the RPC call an encrypted C2 URL?

Parameters and data

Parameters

ParameterTypeDefaultWhat it is
lookback_daysnumber14History in days to examine for RPC activity and subsequent beaconing.
rpc_providerslist[domain]infura.io, quicnode.pro, tatum.io, mainnet.solana.com, api.mainnet-beta.solana.com, ethereum.publicnode.comPublic blockchain RPC and node provider domains used as dead drops.
scope_hostslist[host]nonePaste the hostnames identified in the lead query here to focus the subsequent analysis.

Data sources

SourceCategoryTelemetry
Endpoint telemetry (hb_ surfaces)endpointendpoint
Network telemetrynetworknetwork
Web server / proxy logssiemnetwork

Source

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

hunt.md
---
analysis: A static rule for blockchain domains triggers too many false positives from
  developer activity. This hunt uses multi-surface correlation (DNS -> HTTP -> Network)
  and a temporal constraint to isolate the automated resolution-to-beaconing sequence.
blind_spots:
- id: incomplete-rpc-telemetry
  question: Which specific JSON-RPC methods (eth_call, getSignaturesForAddress) were
    called?
  requires: hb_http_activity with full JSON-RPC body capture
  risk: Without the POST body, we cannot distinguish between a legitimate node status
    check and a specific coordinate retrieval call.
  stage: c2-blockchain-dead-drop-resolution
- id: tls-encrypted-rpc-payloads
  question: Is the content of the RPC call an encrypted C2 URL?
  requires: TLS inspection at the gateway or endpoint
  risk: HTTPS to standard providers like Infura masks the malicious payload from traditional
    NIDS/DPI.
  stage: c2-blockchain-dead-drop-resolution
coverage:
- stage: c2-blockchain-dead-drop-resolution
  status: covered
  steps:
  - dns-to-blockchain-rpc
  - http-rpc-post-activity
- stage: c2-primary-beaconing
  status: covered
  steps:
  - rare-outbound-beacons
- reason: Belongs to another part of the 'The challenge of defending against bulletproof
    dead drops on public blockchains' series.
  stage: initial-access-exploit
  status: out_of_scope
- reason: Belongs to another part of the 'The challenge of defending against bulletproof
    dead drops on public blockchains' series.
  stage: execution-overlord-rat
  status: out_of_scope
- reason: Belongs to another part of the 'The challenge of defending against bulletproof
    dead drops on public blockchains' series.
  stage: impact-data-encryption
  status: out_of_scope
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: keep-as-periodic-hunt
  justification: Blockchain dead-drops remove the single point of failure (DNS/Hosting)
    that defenders traditionally rely on for takedowns. A negative result confirms
    this resilient channel is not currently active.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An adversary is using public blockchain ledgers as dead-drop resolvers
  for C2 configuration, identified by outbound RPC calls to node providers followed
  by rare network beaconing to resolved endpoints.
labels:
- hunt
- attack.t1090.004
- attack.t1102.001
- command and control
- execution
- impact
- initial access
name: Decentralized Blockchain C2 Resolution
parameters:
  lookback_days:
    default: '14'
    description: History in days to examine for RPC activity and subsequent beaconing.
    type: number
  rpc_providers:
    default:
    - infura.io
    - quicnode.pro
    - tatum.io
    - mainnet.solana.com
    - api.mainnet-beta.solana.com
    - ethereum.publicnode.com
    description: Public blockchain RPC and node provider domains used as dead drops.
    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[domain]
  scope_hosts:
    default: []
    description: Paste the hostnames identified in the lead query here to focus the
      subsequent analysis.
    type: list[host]
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
    model: hb_google/gemini-3-flash-preview
rationale: Start by identifying all hosts interacting with public blockchain RPC providers.
  Widen the search if initial results are concentrated in developer or research departments
  where such traffic is baseline.
references:
- name: 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: initial-access-via-web-exploitation
  reason: This hunt focuses on the C2 resilience phase; initial entry into the environment
    via vulnerability exploitation is a separate hypothesis.
  relation: out-of-scope-alternative
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: 1
  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
  network:
    category: network
    name: Network telemetry
    telemetry:
    - network
  web:
    category: siem
    name: Web server / proxy logs
    telemetry:
    - network
tlp: clear
type: investigation
---


# Decentralized Blockchain C2 Resolution

This hunt identifies attempts to resolve command-and-control infrastructure using Web3 nodes. It looks for DNS and HTTP traffic directed at public blockchain RPC providers that correlate with rare outbound network connections. By abusing immutable ledgers like Solana and Ethereum, attackers bypass traditional domain sinkholing. The hunt baselines typical developer RPC usage and highlights hosts that reach out to the blockchain and then initiate unique outbound sessions, often targeting non-standard ports within a narrow temporal window.

## dns-to-blockchain-rpc
<!-- DNS lookups to blockchain RPC nodes -->
Identify hosts and processes resolving known blockchain RPC provider domains as a lead for potential dead-drop resolution.

```sqlite target=endpoint role=scoping params=(lookback_days=lookback_days, rpc_providers=rpc_providers)
~~~yaml
expected: Hosts and specific processes resolving blockchain domains. Legitimate developer
  activity will show high volume across multiple distinct providers; malicious resolution
  is typically low volume and tied to unusual processes.
reads:
- device_hostname
- pid
- process_name
- query_hostname
- time
silence: not_evidence_of_absence
source: hb_dns_activity
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, process_name, pid, query_hostname, COUNT(*) AS lookup_count, MIN(time) AS first_lookup FROM hb_dns_activity WHERE (instr(',' || '{{rpc_providers}}' || ',', ',' || LOWER(query_hostname) || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY device_hostname, process_name, pid, query_hostname
```

## corroborate-activity
<!-- Corroborate RPC traffic and beaconing -->
parallel:
- → http-rpc-post-activity
- → rare-outbound-beacons
join: → triage-rpc-behavior

## http-rpc-post-activity
<!-- HTTP POST activity to RPC endpoints -->
Focus on the HTTP POST requests that carry JSON-RPC payloads, which are required for querying specific blockchain data like transactions or logs.

```sqlite target=web role=enrichment params=(lookback_days=lookback_days, rpc_providers=rpc_providers, scope_hosts=scope_hosts)
~~~yaml
expected: POST requests to RPC providers from the scoping hosts. Analysts should look
  for unusual User-Agents or paths that do not match standard browser or developer
  tool patterns.
reads:
- device_hostname
- http_method
- time
- url_hostname
- url_path
- user_agent
silence: not_evidence_of_absence
source: hb_http_activity
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, url_hostname, url_path, http_method, user_agent, time FROM hb_http_activity WHERE (instr(',' || '{{rpc_providers}}' || ',', ',' || LOWER(url_hostname) || ',') > 0) AND http_method = 'POST' AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## rare-outbound-beacons
<!-- Rare outbound connections from RPC hosts -->
Identify non-standard outbound connections occurring on hosts that have also performed blockchain RPC lookups, prioritizing non-standard ports.

```sqlite target=network role=baseline params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: A connection to a rare external IP address on a non-standard port. Correlation
  is strongest when this connection follows an RPC lookup by the same host.
prevalence:
  by: device_hostname
  key:
  - dst_endpoint_ip
  - dst_endpoint_port
  rare_below: 3
reads:
- device_hostname
- direction
- disposition
- dst_endpoint_ip
- dst_endpoint_port
- process_name
- time
silence: not_evidence_of_absence
source: hb_network_connection
verified: dry-run
verified_at: '2026-11-19'
~~~
SELECT device_hostname, dst_endpoint_ip, dst_endpoint_port, process_name, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_seen FROM hb_network_connection WHERE direction = 'outbound' AND disposition = 'Allowed' AND (dst_endpoint_port NOT IN (80, 443, 53)) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY dst_endpoint_ip, dst_endpoint_port, process_name HAVING host_count <= 3 ORDER BY host_count ASC
```

## triage-rpc-behavior
<!-- Evaluate blockchain-to-C2 sequence -->
```agent target=hunter
cite: required
context:
- dns-to-blockchain-rpc
- http-rpc-post-activity
- rare-outbound-beacons
max_iterations: 6
objective: Determine if a host is resolving C2 coordinates via blockchain. Specifically
  look for rare outbound network connections that occur shortly after (within 5-10
  minutes) the identified RPC activity on the same host. Evaluate if the processes
  involved in both steps are consistent or related.
success_criteria: A per-host verdict of malicious, suspicious, or benign citing the
  specific correlated RPC and beaconing rows.
tools:
- endpoint
- network
- web
```

## route-on-verdict
<!-- Route on triage verdict -->
if~: "The triage-rpc-behavior verdict is malicious for at least one host." (confidence: high, judge=hunter)
then: → isolate-infected-host
indeterminate: → analyst-review
unavailable: → analyst-review (blind_spot: incomplete-rpc-telemetry)
else: → close-out

## isolate-infected-host
<!-- Isolate host and capture memory -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host from the network. Capture a full memory dump before rebooting or shutting down to preserve in-memory decrypters and the resolved C2 coordinates.
```
→ analyst-review

## analyst-review
<!-- Analyst forensic review -->
```manual target=analyst
Review the process tree for the processes identified in the RPC lookups and outbound connections. Inspect any available HTTP payload data for Base64 or hex-encoded C2 strings. Validate if the activity matches the Overlord RAT's Solana-based dead-drop pattern.
```
→ close-out

## close-out
<!-- Hunt closure and tuning -->
```manual target=analyst
Document all confirmed malicious hosts and the resolved C2 IP addresses. If legitimate developer workstations were flagged, record their hostnames and typical RPC patterns for inclusion in the scope_hosts exclusion list for future runs.
```
→ 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, then reviewed by a person.

Content pack

Sign up to open

Pack contents open in Huntbase.