---
analysis: "A simple rule for 'shell from web worker' lacks the context of the unauthenticated\
  \ HTTP delivery and the precursor crashes. This hunt uses three surfaces\u2014inventory,\
  \ application errors, and process activity\u2014to prove a specific, unauthenticated\
  \ RCE chain against these CVEs."
blind_spots:
- id: no-endpoint-telemetry
  question: whether rare child processes are running on non-enrolled Linux servers
  requires: hb_process_activity on Linux servers
  risk: A compromised Linux web server without an endpoint agent will only show delivery
    and potential network activity, but successful code execution will be invisible.
  stage: rce-web-worker-execution
- id: http-body-visibility
  question: whether the multipart data specifically contains exploit shellcode
  requires: request body inspection
  risk: The hunt relies on the size of the request and session query parameters; a
    highly optimized exploit under 1MB might not trigger the delivery threshold.
  stage: exploit-delivery-http-request
coverage:
- stage: vulnerability-scanning-and-inventory
  status: covered
  steps:
  - inventory-vulnerable-php
- stage: exploit-delivery-http-request
  status: covered
  steps:
  - suspicious-http-delivery
- stage: memory-corruption-and-crash
  status: covered
  steps:
  - php-worker-crashes
- stage: rce-web-worker-execution
  status: covered
  steps:
  - rare-worker-children
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: keep-as-periodic-hunt
  justification: PHP vulnerabilities CVE-2026-109618/19 are critical unauthenticated
    RCEs with observed in-the-wild exploitation. Protecting web-facing assets from
    unauthenticated takeover is a core security requirement.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An adversary is exploiting unauthenticated RCE in PHP (CVE-2026-109618/19)
  by delivering crafted multipart requests that trigger memory corruption or stale-state
  access, confirmed by worker crashes and rare child processes.
labels:
- hunt
- attack.t1190
- execution
- initial access
name: PHP Unauthenticated RCE Exploitation
parameters:
  lookback_days:
    default: '14'
    description: Days of history to examine.
    from:
      kind: manual
      observed: '2026-10-21'
      ref: hunt-standard
    type: number
  scope_hosts:
    default: []
    description: Specific hosts to scope (leave empty for all).
    from:
      kind: manual
      observed: '2026-10-21'
      ref: hunt-standard
    type: list[host]
  vulnerable_version_prefixes:
    default:
    - 8.2.
    - 8.3.
    - 8.4.
    - 8.5.
    description: PHP versions prefixes affected; check against local inventory.
    from:
      kind: article
      observed: '2026-10-21'
      ref: Rapid7
    type: list[string]
  web_worker_names:
    default:
    - php-fpm
    - apache2
    - httpd
    - php-cgi
    - frankenphp
    - litespeed
    description: PHP worker and web server process names.
    from:
      kind: article
      observed: '2026-10-21'
      ref: Rapid7
    type: list[string]
provenance:
  authors:
  - name: Huntbase hunt generation
    org: huntbase.io
  generated:
    by: huntbase-hunt-generation
    from: https://www.rapid7.com/blog/post/etr-cve-2026-109618-and-cve-2026-109619-critical-unauthenticated-remote-code-execution-in-php
    gates:
    - dry-run
    - lint
    - critic
    model: hb_google/gemini-3-flash-preview
rationale: Begin with internet-exposed servers running PHP-FPM or Apache. Focus on
  hosts where HTTP POST traffic to .php endpoints is common.
references:
- name: "Rapid7 \u2014 CVE-2026-109618 and CVE-2026-109619: Critical RCE in PHP"
  url: https://www.rapid7.com/blog/post/etr-cve-2026-109618-and-cve-2026-109619-critical-unauthenticated-remote-code-execution-in-php
related:
- hunt: web-shell-detection-php
  reason: Detection of persistent web shells written to disk by an exploit is covered
    in a separate hunt focused on file-system activity.
  relation: sibling
scenario:
  stages:
  - name: PHP Vulnerability Identification
    observables:
    - PHP 8.2 < 8.2.35
    - PHP 8.3 < 8.3.36
    - PHP 8.4 < 8.4.27
    - PHP 8.5 < 8.5.12
    - Apache mod_php
    - PHP-FPM
    - php-cgi
    - FrankenPHP
    - LiteSpeed
    - rpms.remirepo.net
    slug: vulnerability-scanning-and-inventory
    tactic: initial-access
    techniques:
    - T1190
  - name: Exploit Delivery via Crafted Request
    observables:
    - multipart/form-data
    - large file uploads
    - session upload progress tracking
    - 'Content-Type: multipart/form-data'
    - requests triggering OOM conditions
    slug: exploit-delivery-http-request
    tactic: initial-access
    techniques:
    - T1190
  - name: Worker Memory Corruption
    observables:
    - PHP worker crash
    - Segmentation fault
    - longjmp() OOM error
    - fatal_error_backtraces enabled
    - PHP-FPM worker termination
    slug: memory-corruption-and-crash
    tactic: execution
    techniques:
    - T1190
  - name: Remote Code Execution
    observables:
    - Unexpected child processes of php-fpm
    - Unexpected child processes of httpd
    - Unexpected child processes of apache2
    - Spawning of /bin/sh or /bin/bash from web server
    - Web worker account privileges
    slug: rce-web-worker-execution
    tactic: execution
    techniques:
    - T1190
  summary: Critical unauthenticated remote code execution vulnerabilities in PHP (CVE-2026-109618
    and CVE-2026-109619) allow attackers to gain web worker privileges via memory
    corruption during out-of-memory handling or use-after-free flaws in global state.
    Exploitation typically involves crafted multipart HTTP requests or leveraging
    session upload tracking to access stale memory across requests.
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
  web:
    category: siem
    name: Web server / proxy logs
    telemetry:
    - network
tlp: clear
type: investigation
---


# PHP Unauthenticated RCE Exploitation

This hunt identifies the full exploitation chain for critical PHP vulnerabilities announced in October 2026. It begins by scoping vulnerable PHP installations, then correlates suspicious HTTP delivery attempts with concurrent application-layer crashes (segmentation faults). In the follow-on phase, it pivots to identify successful remote code execution by stack-counting child processes of PHP workers across the fleet to find rare or anomalous execution. An analyst then uses the combined context to isolate compromised hosts and apply emergency mitigations.

## inventory-vulnerable-php
<!-- Inventory vulnerable PHP installations -->
Identify hosts running PHP versions prior to the October 2026 security updates.

```sqlite target=endpoint role=scoping params=(vulnerable_version_prefixes=vulnerable_version_prefixes, scope_hosts=scope_hosts)
~~~yaml
expected: A list of hosts with affected PHP versions. Silence means no PHP was found
  in the inventory.
reads:
- device_hostname
- package_name
- package_version
- install_path
silence: not_evidence_of_absence
source: hb_software_inventory
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_hostname, package_name, package_version, install_path FROM hb_software_inventory WHERE LOWER(package_name) LIKE '%php%' AND (instr(',' || '{{vulnerable_version_prefixes}}' || ',', ',' || SUBSTR(package_version, 1, 4) || ',') > 0) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)
```

## early-precursors
<!-- Correlate delivery and crash evidence -->
parallel:
- → suspicious-http-delivery
- → php-worker-crashes
join: → precursor-triage

## suspicious-http-delivery
<!-- Suspicious multipart HTTP delivery -->
Identify large multipart POST requests or queries targeting session upload progress, which are common exploit triggers.

```sqlite target=web role=enrichment params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
expected: POST requests over 1MB or containing session tracking queries. Silence proves
  no such requests reached the logs.
reads:
- device_hostname
- url_path
- http_method
- request_body_len
- url_query
- time
silence: evidence_of_absence
source: hb_http_activity
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_hostname, url_path, http_method, request_body_len, url_query, time FROM hb_http_activity WHERE LOWER(url_path) LIKE '%.php%' AND http_method = 'POST' AND (request_body_len > 1048576 OR LOWER(url_query) LIKE '%progress%') AND time >= datetime('now', '-{{lookback_days}} days') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)
```

## php-worker-crashes
<!-- PHP worker application faults -->
Find segmentation faults or OOM errors in PHP workers indicating successful memory corruption.

```sqlite target=endpoint role=triage params=(lookback_days=lookback_days, web_worker_names=web_worker_names, scope_hosts=scope_hosts)
~~~yaml
expected: Faults in web worker processes. Silence means no worker crashes were recorded.
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-18'
~~~
SELECT device_hostname, app_name, exception_code, message, time FROM hb_application_error WHERE (instr(',' || '{{web_worker_names}}' || ',', ',' || LOWER(app_name) || ',') > 0 OR LOWER(message) LIKE '%php%') AND (exception_code = 'c0000005' OR LOWER(message) LIKE '%segmentation fault%' OR LOWER(message) LIKE '%out of memory%') AND time >= datetime('now', '-{{lookback_days}} days') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)
```

## precursor-triage
<!-- Early stage exploit triage -->
```agent target=hunter
cite: required
context:
- inventory-vulnerable-php
- suspicious-http-delivery
- php-worker-crashes
max_iterations: 3
objective: Determine which hosts show coincident exploit delivery patterns and application
  crashes, signifying exploit attempts.
success_criteria: A risk-ranked list of hosts with delivery-to-crash correlation.
tools:
- endpoint
- web
```

## rare-worker-children
<!-- Rare child processes of web workers -->
Identify successful RCE by finding rare or unexpected child processes spawned by web workers across the fleet.

```sqlite target=endpoint role=detection-candidate params=(lookback_days=lookback_days, web_worker_names=web_worker_names, scope_hosts=scope_hosts)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: Rare binaries or shells spawned by web workers. Silence means no anomalous
  children were observed.
prevalence:
  by: device_hostname
  key:
  - process_name
  rare_below: 3
reads:
- device_hostname
- parent_process_name
- process_name
- time
silence: evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT LOWER(process_name) AS child_proc, parent_process_name, COUNT(DISTINCT device_hostname) AS hosts, COUNT(*) AS occurrences, MIN(time) AS first_seen FROM hb_process_activity WHERE (instr(',' || '{{web_worker_names}}' || ',', ',' || LOWER(parent_process_name) || ',') > 0 OR parent_process_name LIKE '%php%' OR parent_process_name LIKE '%httpd%') AND time >= datetime('now', '-{{lookback_days}} days') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) GROUP BY LOWER(process_name), parent_process_name HAVING hosts <= 3 ORDER BY hosts, occurrences
```

## impact-verdict
<!-- Final exploitation verdict -->
```agent target=hunter
cite: required
context:
- precursor-triage
- rare-worker-children
max_iterations: 3
objective: Identify successful RCE on at-risk hosts by correlating previously triaged
  crashes and delivery with rare process execution.
success_criteria: A verdict of malicious for hosts showing the full exploitation chain.
tools:
- endpoint
- web
```

## route-impact
<!-- Route on verdict -->
if~: "the impact-verdict is malicious for at least one host" (confidence: high, judge=hunter)
then: → isolate-host
indeterminate: → forensic-review
unavailable: → forensic-review (blind_spot: no-endpoint-telemetry)
else: → patching-audit

## isolate-host
<!-- Isolate host and apply mitigations -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host immediately. Apply emergency mitigations in php.ini: set memory_limit=-1 and session.upload_progress.enabled=0, then restart the worker service. Update PHP to fixed versions (8.2.35+, 8.3.36+, 8.4.27+, or 8.5.12+).
```
→ forensic-review

## forensic-review
<!-- Forensic investigation -->
```manual target=analyst
Investigate the anomalous child processes identified in the follow-on phase. Correlate the timing with the source IPs from the HTTP delivery query to trace the actor.
```
→ patching-audit

## patching-audit
<!-- Remediation and patching audit -->
```manual target=analyst
Perform a final audit using the inventory query to ensure all vulnerable PHP versions have been updated. Ensure configuration hardening (memory_limit and upload_progress) is enforced by default.
```
→ end
