Rapid Vulnerability Exploitation and Remote Access
Medium severity TLP:CLEAR Research by Rapid7 Published 18 Nov 2026
Hypothesis
An intruder has exploited a high-severity vulnerability within the first 72 hours of disclosure to gain initial access, subsequently establishing RDP persistence or initiating ransomware encryption.
Brief
Why this hunt mattersaThe
Rapid7 Q3 2026 Threat Update (https://www.rapid7.com/blog/post/tr-q3-2026-threat-update-attackers-exploiting-vulnerabilities-within-3-days) highlights a dangerous trend: the mean time to exploit for new vulnerabilities has dropped to just three days. For many organizations, the traditional patching cycle takes weeks, leaving a massive window of exposure. We designed this hunt to help security teams look backward and determine if an adversary successfully exploited a critical vulnerability before it could be patched. This is a behavioral hunt, not a detection, because it correlates the vulnerable state of a machine with common post-exploit activities that might otherwise seem legitimate in isolation.aa
The
HypothesisaAn intruder exploits a high-severity vulnerability within the first 72 hours of its disclosure to gain initial access. They then establish RDP persistence for lateral movement or initiate ransomware encryption to impact the business.aa
How the hunt flowsaThe hunt starts by filtering the fleet for the highest-risk assets
Using the hb_vulnerability_finding surface, the first query identifies hosts currently reporting Severity 5 vulnerabilities. This initial scoping step ensures that the subsequent, more resource-intensive queries only run against the most likely targets of an exploit. It identifies device UIDs and hostnames for internet-facing assets that have not yet undergone patching.aaOnce the hunt identifies vulnerable hosts, an agent evaluates the risk. This process determines if the specific vulnerabilities found are exploitable without user interaction or if they allow remote code execution. If the risk is high, the hunt triggers a parallel fan-out to behavioral telemetry.aaThe behavioral analysis covers two key areas of the post-exploit lifecycle. The first path checks hb_auth_signin for rare external RDP connections. It specifically looks for Logon Type 10 (Remote Interactive) sessions originating from source IPs that have touched fewer than three hosts in the environment. This pattern is a strong indicator of an access broker or a ransomware affiliate using a newly acquired initial access point.aaIn parallel, the second path monitors hb_file_activity for abnormal spikes. Ransomware actors often perform high-volume file operations as they stage data for exfiltration or begin the encryption process. The query calculates the count of file activity events over a rolling window and flags any host from the scoping list that exceeds 1,000 file creations, deletions, or modifications within a short window. This volume exceeds normal administrative background noise, providing a high-confidence indicator of impact on vulnerable servers.aaThe final phase uses a triage agent to bring these data points together. The agent reviews the vulnerability status, the RDP login details, and the file activity logs to provide a final verdict. If the evidence suggests an active intrusion, the analyst can move immediately to host isolation.aa
What the hunt cannot seeaNo hunt is exhaustive
This playbook relies on the accuracy and frequency of vulnerability scanning. If a host has not been scanned since a new vulnerability was disclosed, the scoping phase will miss it. Furthermore, the hunt assumes that the adversary uses RDP or high-volume file encryption. If an attacker uses a more stealthy persistence mechanism or moves slowly through the file system to avoid detection, these behavioral queries may return no results.aa
How to run itaThis hunt is provided as an open hunt.md playbook
You can import it into Huntbase or any hunt.md-compatible runtime to execute the logic across the environment. Because it gates the heaviest queries behind an initial risk assessment, you can run it frequently as new critical vulnerabilities are disclosed without significant performance impact.
Steps
-
Query, scoping
Recently discovered critical vulnerabilities
Identify hosts currently reporting critical vulnerabilities (Severity 5) to prioritize the hunt on the most likely targets for rapid exploitation.
sql, reads hb_vulnerability_findingSELECT device_uid, resource_uid, cve_uid, title, severityFROM hb_vulnerability_findingWHERE severity_id = 5 AND status != 'suppressed' AND resource_type = 'host'What a hit looks like. A list of hosts and their associated critical vulnerabilities. Silence proves no critical vulnerabilities are currently detected on scanned assets.
-
Agent triage
Evaluate vulnerability risk
The agent reviews the lead findings to determine if any identified vulnerabilities pose an immediate risk that warrants expensive behavioral queries.
-
Decision
Gate on vulnerability risk
Avoid running high-volume behavioral queries across the entire estate if no critical vulnerability exposure is present.
-
Query, baseline
Rare external RDP logins
Search for RDP connections (Logon Type 10) from source IPs that are rare across the fleet, which may indicate unauthorized access sold on underground forums.
sql, reads hb_auth_signinSELECT src_endpoint_ip, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_seen, GROUP_CONCAT(DISTINCT device_hostname) AS affected_hostsFROM hb_auth_signinWHERE activity_id = 1 AND (logon_type_id = 10 OR logon_type = 'Remote Interactive') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY src_endpoint_ipHAVING host_count < 3What a hit looks like. A list of rare source IPs that have logged into vulnerable hosts. Silence proves no rare RDP activity occurred in the window.
-
Query, detection candidate
High-volume file activity
Detect potential ransomware impact by finding hosts with abnormal spikes in file creation, deletion, or modification events.
sql, reads hb_file_activitySELECT device_hostname, COUNT(*) AS file_ops, GROUP_CONCAT(DISTINCT LOWER(file_path)) AS sample_pathsFROM hb_file_activityWHERE activity_id IN (1, 4, 5) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY device_hostnameHAVING file_ops > 1000ORDER BY file_ops DESCWhat a hit looks like. Hosts performing high-volume file operations. Silence proves no massive destructive file activity occurred on vulnerable hosts.
-
Agent triage
Triage compromise evidence
A final agent evaluates the combined evidence of vulnerability exposure, rare RDP logins, and file spikes to determine if an intrusion is active.
-
Decision
Route on final verdict
Direct the hunt based on the triage agent's findings, prioritizing containment for malicious results.
-
Response action
Isolate compromised host
Immediately disconnect a malicious host to stop lateral movement or further data encryption.
-
Analyst task
Manual investigation
An analyst reviews the behavioral evidence to confirm the exploit path and assess for any missing telemetry.
-
Analyst task
Close out
Finalize the hunt, record findings, and recommend remediation for any unexploited vulnerabilities.
Coverage
3 of 3 stages covered
| Stage and ATT&CK technique | Covered | How, or why not |
|---|---|---|
| Exploitation of Public-Facing Applications T1190 |
Yes | vulnerability-lead, evaluate-lead |
| Unauthorized Remote Desktop Access T1021.001 |
Yes | rare-rdp-logins |
| Ransomware and Data Encryption T1486 |
Yes | file-activity-spikes |
Blind spots
- Needs hb_vulnerability_finding with comprehensive fleet coverage. A host without a recent scan may be exploited before its vulnerability is even known to this hunt. It would answer: Which hosts have critical vulnerabilities but have not been scanned recently?
- Needs hb_auth_signin retention longer than the exploit window. Attackers who established access several weeks ago through a vulnerability disclosure will not be seen if logs have rotated. It would answer: Did an RDP login occur before the current log retention window?
Parameters and data
Parameters
| Parameter | Type | Default | What it is |
|---|---|---|---|
lookback_days | number | 14 | Days of history to examine, covering the critical window after vulnerability disclosure. |
scope_hosts | list[host] | none | Specific hostnames identified in the scoping phase to focus the behavioral queries. |
Data sources
| Source | Category | Telemetry |
|---|---|---|
| Endpoint telemetry (hb_ surfaces) | endpoint | endpoint |
| Identity / sign-in telemetry | identity | identity |
Source
An open hunt.md file. It runs anywhere that reads the format.
---
analysis: A single detection rule triggers on an RDP login; this hunt correlates the
high-risk state of a host (critical vulnerability) with the subsequent behavioral
indicators of breach (rare IP login and file volume) across three surfaces, providing
context an automated rule lacks.
blind_spots:
- id: unscanned-assets
question: Which hosts have critical vulnerabilities but have not been scanned recently?
requires: hb_vulnerability_finding with comprehensive fleet coverage
risk: A host without a recent scan may be exploited before its vulnerability is
even known to this hunt.
stage: initial-access-exploit-public-facing
- id: rdp-log-retention
question: Did an RDP login occur before the current log retention window?
requires: hb_auth_signin retention longer than the exploit window
risk: Attackers who established access several weeks ago through a vulnerability
disclosure will not be seen if logs have rotated.
stage: lateral-movement-rdp-access
coverage:
- stage: initial-access-exploit-public-facing
status: covered
steps:
- vulnerability-lead
- evaluate-lead
- stage: lateral-movement-rdp-access
status: covered
steps:
- rare-rdp-logins
- stage: impact-data-encryption
status: covered
steps:
- file-activity-spikes
guardrails:
claims: no_unsupported
evidence: citation_required
missing_data: not_benign
telemetry: untrusted
hunt:
applicability: campaign-specific
handoff: promote-to-detection
justification: With exploitation occurring within three days of disclosure on average,
organizations cannot wait for a patching window; a negative result over vulnerable
assets is the only way to confirm a breach has not already occurred.
methodology: model-assisted
trigger: intel-report
hypothesis: An intruder has exploited a high-severity vulnerability within the first
72 hours of disclosure to gain initial access, subsequently establishing RDP persistence
or initiating ransomware encryption.
labels:
- hunt
- attack.t1190
- attack.t1021.001
- attack.t1486
- impact
- initial access
- lateral movement
name: Rapid Vulnerability Exploitation and Remote Access
parameters:
lookback_days:
default: '14'
description: Days of history to examine, covering the critical window after vulnerability
disclosure.
from:
kind: article
observed: '2026-10-21'
ref: rapid7-q3-2026
type: number
scope_hosts:
default: []
description: Specific hostnames identified in the scoping phase to focus the behavioral
queries.
from:
kind: manual
observed: '2026-10-21'
ref: analyst-defined
type: list[host]
provenance:
authors:
- name: Huntbase hunt generation
org: huntbase.io
generated:
by: huntbase-hunt-generation
from: https://www.rapid7.com/blog/post/tr-q3-2026-threat-update-attackers-exploiting-vulnerabilities-within-3-days
gates:
- dry-run
- lint
model: hb_google/gemini-3-flash-preview
rationale: Start with servers and internet-facing assets identified in hb_vulnerability_finding
with Severity 5. Use the device_uid to identify specific hosts and ensure their
hostnames are included in scope_hosts for the behavioral checks.
references:
- name: "Rapid7 \u2014 Q3 2026 Threat Update"
url: https://www.rapid7.com/blog/post/tr-q3-2026-threat-update-attackers-exploiting-vulnerabilities-within-3-days
related:
- hunt: unauthenticated-web-exploit-crashes
reason: This hunt focuses on access and encryption; monitoring for application crashes
(T1190) following unauthenticated requests is a sibling hunt.
relation: out-of-scope-alternative
scenario:
stages:
- name: Exploitation of Public-Facing Applications
observables:
- exploitation of high-severity vulnerabilities (CVSS 9+) within 3-7 days of disclosure
- unauthenticated access to internet-facing services
- exploit attempts targeting web servers or network devices
- application crashes following failed exploit attempts
slug: initial-access-exploit-public-facing
tactic: initial-access
techniques:
- T1190
- name: Unauthorized Remote Desktop Access
observables:
- Remote Desktop Protocol (RDP) connections on port 3389
- Logon Type 10 (Remote Interactive) events
- Internet-exposed RDP services
- authentication attempts following underground forum access sales
slug: lateral-movement-rdp-access
tactic: lateral-movement
techniques:
- T1021.001
- name: Ransomware and Data Encryption
observables:
- high-volume file modifications and renames
- creation of ransom notes
- deployment of encryption utilities
- anti-malware detections for ransomware families
slug: impact-data-encryption
tactic: impact
techniques:
- T1486
summary: Attackers are exploiting high-severity vulnerabilities in public-facing
applications within an average of three days of disclosure, with nearly 80% of
targets requiring no authentication. These campaigns frequently leverage Remote
Desktop Protocol (RDP) for lateral movement or access monetization, often resulting
in ransomware deployment and data encryption.
severity: medium
targets:
analyst:
name: Tier-2 analyst
role: analyst
endpoint:
category: endpoint
name: Endpoint telemetry (hb_ surfaces)
telemetry:
- endpoint
hunter:
agent: true
name: Hunt agent
identity:
category: identity
name: Identity / sign-in telemetry
telemetry:
- identity
tlp: clear
type: investigation
---
# Rapid Vulnerability Exploitation and Remote Access
Research indicates that attackers now exploit critical vulnerabilities within an average of three days from public disclosure. This hunt identifies hosts exposed to critical vulnerabilities and gates intensive behavioral monitoring for those specific assets. It monitors for rare external RDP connections—often sold on underground forums—and high-volume file modifications characteristic of early-stage ransomware impact.
## vulnerability-lead
<!-- Recently discovered critical vulnerabilities -->
Identify hosts currently reporting critical vulnerabilities (Severity 5) to prioritize the hunt on the most likely targets for rapid exploitation.
```sqlite target=endpoint role=scoping
~~~yaml
expected: A list of hosts and their associated critical vulnerabilities. Silence proves
no critical vulnerabilities are currently detected on scanned assets.
reads:
- device_uid
- resource_uid
- cve_uid
- title
- severity_id
- status
- resource_type
silence: evidence_of_absence
source: hb_vulnerability_finding
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_uid, resource_uid, cve_uid, title, severity FROM hb_vulnerability_finding WHERE severity_id = 5 AND status != 'suppressed' AND resource_type = 'host'
```
## evaluate-lead
<!-- Evaluate vulnerability risk -->
```agent target=hunter
cite: required
context:
- vulnerability-lead
max_iterations: 3
objective: Determine if any hosts in the vulnerability-lead results have critical,
unmitigated exposures that could be exploited without user interaction.
success_criteria: A recommendation to proceed to behavioral monitoring for specific
high-risk hosts.
tools:
- endpoint
- identity
```
## gate-on-risk
<!-- Gate on vulnerability risk -->
if~: "the evaluate-lead verdict identifies at least one host with critical exposure requiring behavioral monitoring" (confidence: high, judge=hunter)
then: → behavioral-fan-out
indeterminate: → manual-investigation
unavailable: → manual-investigation (blind_spot: unscanned-assets)
else: → close-out
## behavioral-fan-out
<!-- Fan-out to behavioral signals -->
parallel:
- → rare-rdp-logins
- → file-activity-spikes
join: → triage-compromise
## rare-rdp-logins
<!-- Rare external RDP logins -->
Search for RDP connections (Logon Type 10) from source IPs that are rare across the fleet, which may indicate unauthorized access sold on underground forums.
```sqlite target=identity role=baseline params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
baseline:
compare: first_seen
window: '{{lookback_days}}d'
expected: A list of rare source IPs that have logged into vulnerable hosts. Silence
proves no rare RDP activity occurred in the window.
prevalence:
by: device_hostname
key:
- src_endpoint_ip
rare_below: 3
reads:
- src_endpoint_ip
- device_hostname
- activity_id
- logon_type_id
- time
silence: evidence_of_absence
source: hb_auth_signin
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT src_endpoint_ip, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_seen, GROUP_CONCAT(DISTINCT device_hostname) AS affected_hosts FROM hb_auth_signin WHERE activity_id = 1 AND (logon_type_id = 10 OR logon_type = 'Remote Interactive') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY src_endpoint_ip HAVING host_count < 3
```
## file-activity-spikes
<!-- High-volume file activity -->
Detect potential ransomware impact by finding hosts with abnormal spikes in file creation, deletion, or modification events.
```sqlite target=endpoint role=detection-candidate params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
expected: Hosts performing high-volume file operations. Silence proves no massive
destructive file activity occurred on vulnerable hosts.
reads:
- device_hostname
- activity_id
- file_path
- time
silence: evidence_of_absence
source: hb_file_activity
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_hostname, COUNT(*) AS file_ops, GROUP_CONCAT(DISTINCT LOWER(file_path)) AS sample_paths FROM hb_file_activity WHERE activity_id IN (1, 4, 5) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY device_hostname HAVING file_ops > 1000 ORDER BY file_ops DESC
```
## triage-compromise
<!-- Triage compromise evidence -->
```agent target=hunter
cite: required
context:
- evaluate-lead
- rare-rdp-logins
- file-activity-spikes
max_iterations: 5
objective: Determine if the rare RDP logins or file spikes on vulnerable hosts constitute
an active breach or ransomware event.
success_criteria: A per-host verdict of malicious | suspicious | benign.
tools:
- endpoint
- identity
```
## route-on-verdict
<!-- Route on final verdict -->
if~: "the triage-compromise verdict is malicious for at least one host" (confidence: high, judge=hunter)
then: → isolate-host
indeterminate: → manual-investigation
unavailable: → manual-investigation (blind_spot: rdp-log-retention)
else: → close-out
## isolate-host
<!-- Isolate compromised host -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host(s) identified as malicious. Revoke active RDP sessions and reset credentials for any accounts logged into from rare external IPs.
```
→ manual-investigation
## manual-investigation
<!-- Manual investigation -->
```manual target=analyst
Review the cited rows from triage. Check hb_application_error for application crashes occurring near the logon times on vulnerable hosts to identify potential exploit attempts.
```
→ close-out
## close-out
<!-- Close out -->
```manual target=analyst
Document all findings. If critical vulnerabilities remain unpatched, prioritize their remediation within the 7-day window. Record any hosts identified in scoping that lacked endpoint telemetry.
```
→ 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.