---
analysis: This hunt pivots from vulnerability data to behavioral file and module loads,
  using stack-counting to identify rare drivers that hash-based rules would miss.
blind_spots:
- id: missing-vulnerability-telemetry
  question: Are all internet-facing servers covered by current vulnerability scans?
  requires: hb_vulnerability_finding with frequent scan cycles
  risk: An unmanaged or unscanned server might be exploited without appearing in the
    lead query.
  stage: initial-access-exploit
- id: no-kernel-visibility
  question: Can we confirm the driver was loaded into kernel space?
  requires: hb_module_activity with Sysmon Event ID 6
  risk: Without module load telemetry, we see the delivery but cannot verify successful
    escalation.
  stage: kernel-mode-escalation
coverage:
- stage: initial-access-exploit
  status: covered
  steps:
  - identify-vulnerable-hosts
  - detect-staging-traffic
- stage: vulnerable-driver-delivery
  status: covered
  steps:
  - detect-driver-staging
- stage: kernel-mode-escalation
  status: covered
  steps:
  - detect-rare-driver-loads
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: promote-to-detection
  justification: BYOVD allows attackers to disable endpoint security from the kernel.
    Detecting this chain from exposure to loading is critical for protecting server
    infrastructure.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An adversary has exploited a public-facing application to stage and load
  a vulnerable kernel driver, bypassing security controls to gain persistent high-integrity
  access to the host.
labels:
- hunt
- attack.t1190
- attack.t1105
- attack.t1068
name: Vulnerable Driver Exploitation and Kernel Escalation
parameters:
  loldrivers_domains:
    default:
    - loldrivers.io
    - api.loldrivers.io
    description: Domains associated with the LOLDrivers project used for staging or
      reference.
    from:
      kind: article
      observed: '2026-07-31'
      ref: elastic-security-labs-2026
    type: list[domain]
  lookback_days:
    default: '14'
    description: Days of history to examine.
    from:
      kind: manual
      observed: '2026-07-31'
      ref: hunt-standard
    type: number
  scope_hosts:
    default: []
    description: Limit the hunt to specific hosts; leave empty to run against the
      estate.
    from:
      kind: manual
      observed: '2026-07-31'
      ref: analyst-scoping
    type: list[host]
  staging_paths:
    default:
    - \temp\
    - \users\public\
    - \appdata\local\temp\
    - \windows\temp\
    description: Common paths where adversaries stage drivers.
    from:
      kind: manual
      observed: '2026-07-31'
      ref: common-knowledge
    type: list[path]
provenance:
  authors:
  - name: Huntbase hunt generation
    org: huntbase.io
  generated:
    by: huntbase-hunt-generation
    from: https://www.elastic.co/security-labs/blog/elastic-security-black-hat-defcon-2026
    gates:
    - dry-run
    - lint
    - critic
    model: hb_google/gemini-3-flash-preview
rationale: Focus the hunt on Windows servers with internet-facing web roles. Start
  with critical vulnerability findings (severity 4+) in web server software.
references:
- name: "Elastic Security Labs \u2014 Elastic goes all-in on Hacker Summer Camp"
  url: https://www.elastic.co/security-labs/blog/elastic-security-black-hat-defcon-2026
- name: LOLDrivers Project
  url: https://loldrivers.io/
related:
- hunt: web-shell-behavioral-detection
  reason: This hunt focuses on the driver follow-on; generic web shell behavior is
    a sibling hunt.
  relation: out-of-scope-alternative
scenario:
  stages:
  - name: Public-Facing Application Exploit
    observables:
    - Web shell execution from web server processes
    - Anomalous HTTP requests targeting known vulnerabilities
    - Vulnerability findings in publicly exposed web applications
    slug: initial-access-exploit
    tactic: initial-access
    techniques:
    - T1190
  - name: Vulnerable Driver Staging
    observables:
    - Creation of .sys driver files in temp or system directories
    - Driver files matching entries on loldrivers.io
    - Signed driver binaries with known CVEs or design flaws
    slug: vulnerable-driver-delivery
    tactic: execution
    techniques:
    - T1105
  - name: BYOVD Privilege Escalation
    observables:
    - Loading of vulnerable kernel modules or drivers
    - Driver signature verification for known-vulnerable signers
    - High-integrity processes interacting with newly loaded drivers
    - Attempts to disable security software via kernel-mode access
    slug: kernel-mode-escalation
    tactic: privilege-escalation
    techniques:
    - T1068
  summary: The campaign begins with the exploitation of a public-facing application
    to establish a foothold on a server. Adversaries then drop and load legitimate
    but vulnerable signed drivers to perform kernel-level operations, achieve privilege
    escalation, and evade endpoint security.
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
  web:
    category: siem
    name: Web server / proxy logs
    telemetry:
    - network
tlp: clear
type: investigation
---


# Vulnerable Driver Exploitation and Kernel Escalation

An adversary exploits an internet-facing application to stage a vulnerable driver and escalate to the kernel. The hunt first identifies hosts with critical web-server vulnerabilities through software findings. If vulnerable hosts are identified, the hunt fans out to look for behavioral indicators: the creation of .sys files in atypical paths, rare kernel module loads, and HTTP traffic to staging domains like LOLDrivers.io. A second agent evaluates the combined evidence to distinguish administrative maintenance from malicious kernel-mode escalation. The analyst reviews the final verdict and isolates any compromised endpoints.

## identify-vulnerable-hosts
<!-- Identify vulnerable internet-facing servers -->
Find hosts with high-severity vulnerabilities in web server packages to focus the hunt.

```sqlite target=endpoint role=scoping
~~~yaml
expected: A list of host IDs and CVEs. Silence indicates no known critical web-facing
  vulnerabilities exist in the current scan results.
reads:
- device_uid
- cve_uid
- severity
- affected_package_name
silence: not_evidence_of_absence
source: hb_vulnerability_finding
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_uid, cve_uid, severity, affected_package_name FROM hb_vulnerability_finding WHERE (severity_id >= 4 OR is_kev = 1) AND (LOWER(affected_package_name) LIKE '%http%' OR LOWER(affected_package_name) LIKE '%server%' OR LOWER(affected_package_name) LIKE '%iis%' OR LOWER(affected_package_name) LIKE '%apache%')
```

## assess-vulnerability-lead
<!-- Assess vulnerability lead -->
```agent target=hunter
cite: required
context:
- identify-vulnerable-hosts
max_iterations: 3
objective: Evaluate whether the identified vulnerabilities in identify-vulnerable-hosts
  represent a plausible entry point for an adversary seeking kernel escalation.
success_criteria: A risk-ranked list of hosts to carry into the behavioral phase.
tools:
- endpoint
- web
```

## gate-on-risk
<!-- Gate on vulnerability risk -->
if~: "the assess-vulnerability-lead verdict identifies at least one host with critical web-server exposure" (confidence: high, judge=hunter)
then: → investigation-fan-out
indeterminate: → manual-validation
unavailable: → manual-validation (blind_spot: missing-vulnerability-telemetry)
else: → close-out-hunt

## investigation-fan-out
<!-- Investigate staging and execution -->
parallel:
- → detect-driver-staging
- → detect-rare-driver-loads
- → detect-staging-traffic
join: → triage-byovd-intrusion

## detect-driver-staging
<!-- Driver file staging -->
Find .sys files created in user-writable or temporary directories.

```sqlite target=endpoint role=detection-candidate params=(lookback_days=lookback_days, staging_paths=staging_paths, scope_hosts=scope_hosts)
~~~yaml
expected: Driver files in temporary paths; these are anomalies compared to standard
  System32 drivers.
reads:
- device_hostname
- file_name
- file_path
- process_name
- time
silence: not_evidence_of_absence
source: hb_file_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, file_name, file_path, process_name, time FROM hb_file_activity WHERE LOWER(file_name) LIKE '%.sys' AND (instr(',' || '{{staging_paths}}' || ',', ',' || LOWER(file_path) || ',') > 0 OR LOWER(file_path) LIKE '%\temp\%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## detect-rare-driver-loads
<!-- Rare kernel module loads -->
Stack-count driver loads to identify rare modules that may be vulnerable drivers.

```sqlite target=endpoint role=baseline params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: Drivers loaded on very few hosts. Legitimate OS drivers appear fleet-wide.
prevalence:
  by: device_hostname
  key:
  - module_name
  rare_below: 3
reads:
- module_name
- device_hostname
- time
silence: not_evidence_of_absence
source: hb_module_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT module_name, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_seen FROM hb_module_activity WHERE ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY module_name HAVING host_count <= 3
```

## detect-staging-traffic
<!-- HTTP traffic to staging domains -->
Identify hosts reaching out to repositories like LOLDrivers.io.

```sqlite target=web role=enrichment params=(lookback_days=lookback_days, loldrivers_domains=loldrivers_domains, scope_hosts=scope_hosts)
~~~yaml
expected: Direct network contact with driver documentation or staging sites from the
  server.
reads:
- device_hostname
- url_hostname
- url_path
- src_endpoint_ip
- time
silence: not_evidence_of_absence
source: hb_http_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, url_hostname, url_path, src_endpoint_ip, time FROM hb_http_activity WHERE instr(',' || '{{loldrivers_domains}}' || ',', ',' || LOWER(url_hostname) || ',') > 0 AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## triage-byovd-intrusion
<!-- Triage BYOVD intrusion -->
```agent target=hunter
cite: required
context:
- assess-vulnerability-lead
- detect-driver-staging
- detect-rare-driver-loads
- detect-staging-traffic
max_iterations: 6
objective: Determine if an adversary exploited a host and escalated to the kernel.
  Correlate vulnerable server findings with driver file creation, rare module loads,
  and staging traffic.
success_criteria: A final verdict of malicious, suspicious, or benign per host.
tools:
- endpoint
- web
```

## route-on-verdict
<!-- Route on BYOVD verdict -->
if~: "the triage verdict is malicious for at least one host" (confidence: high, judge=hunter)
then: → contain-host
indeterminate: → manual-validation
unavailable: → manual-validation (blind_spot: no-kernel-visibility)
else: → close-out-hunt

## contain-host
<!-- Isolate host -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host immediately. Collect the suspicious driver file and the current kernel memory map.
```
→ manual-validation

## manual-validation
<!-- Manual validation -->
```manual target=analyst
Verify the relationship between the web server process and the driver creation. Cross-reference the driver hash with known vulnerable driver databases.
```
→ close-out-hunt

## close-out-hunt
<!-- Close out hunt -->
```manual target=analyst
Record all examined hosts. Document any confirmed infections or false positives for future tuning.
```
→ end