PHP Unauthenticated RCE Exploitation
High severity TLP:CLEAR Research by Rapid7 Published 18 Nov 2026
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.
Brief
Why this hunt
Rapid7 recently detailed two critical vulnerabilities in PHP, CVE-2026-109618 and CVE-2026-109619, that allow unauthenticated remote code execution. These flaws stem from how PHP handles multipart requests and session upload progress. Because these vulnerabilities trigger memory corruption, traditional signature-based detections often fail to catch the nuance of the exploitation process. We developed this hunt to provide a reliable path for identifying both exploit attempts and successful post-exploitation activity.
How the hunt flows
The hunt begins by identifying vulnerable PHP installations. It queries the software inventory surface to find hosts running affected versions, specifically focusing on the 8.2 through 8.5 release branches. This narrows the scope to only the assets at risk before moving into more intensive telemetry searches.
Next, the hunt enters a parallel phase to find precursors of exploitation. It searches HTTP activity logs for large multipart POST requests and specific session tracking queries that indicate exploit delivery. Simultaneously, it looks for application-level faults in PHP workers. Finding a segmentation fault or an out-of-memory error shortly after a suspicious HTTP request provides high-confidence evidence of an exploitation attempt.
An analyst then triages these precursors to identify hosts with high temporal correlation between the delivery and the crash. This reduces the noise generated by routine web traffic and focuses the investigation on hosts where the memory corruption likely occurred.
To confirm successful code execution, the hunt pivots to process activity. It counts child processes of web workers like php-fpm or apache2 across the entire fleet. By looking for rare or unique child processes that appear on only a few hosts, the hunt isolates the specific commands or shells the adversary executed after compromising the PHP worker. A final verdict combines the delivery, the crash, and the rare execution into a confirmed case of unauthenticated RCE.
What this hunt cannot see
This hunt has two primary blind spots. First, it requires endpoint telemetry from the web servers. If a Linux server is not enrolled in the monitoring platform, successful code execution remains invisible even if the delivery is logged at the network layer. Second, the hunt uses a size threshold for multipart requests to filter noise. A highly optimized exploit payload smaller than 1MB might bypass the initial delivery query.
Running the hunt
This hunt is available as an open hunt.md playbook. It is designed to be imported into Huntbase or any runtime environment that supports the hunt.md standard. The playbook includes parameters to adjust lookback periods and specific worker names to match your local environment. Because this identifies a critical unauthenticated threat, we recommend running this as a periodic hunt until all vulnerable PHP instances are patched.
Steps
-
Query, scoping
Inventory vulnerable PHP installations
Identify hosts running PHP versions prior to the October 2026 security updates.
sql, reads hb_software_inventorySELECT device_hostname, package_name, package_version, install_pathFROM hb_software_inventoryWHERE 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)What a hit looks like. A list of hosts with affected PHP versions. Silence means no PHP was found in the inventory.
-
Query, enrichment
Suspicious multipart HTTP delivery
Identify large multipart POST requests or queries targeting session upload progress, which are common exploit triggers.
sql, reads hb_http_activitySELECT device_hostname, url_path, http_method, request_body_len, url_query, timeFROM hb_http_activityWHERE 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)What a hit looks like. POST requests over 1MB or containing session tracking queries. Silence proves no such requests reached the logs.
-
Query, triage
PHP worker application faults
Find segmentation faults or OOM errors in PHP workers indicating successful memory corruption.
sql, reads hb_application_errorSELECT device_hostname, app_name, exception_code, message, timeFROM hb_application_errorWHERE (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)What a hit looks like. Faults in web worker processes. Silence means no worker crashes were recorded.
-
Agent triage
Early stage exploit triage
Identify hosts showing a temporal correlation between suspicious HTTP delivery and worker crashes.
-
Query, detection candidate
Rare child processes of web workers
Identify successful RCE by finding rare or unexpected child processes spawned by web workers across the fleet.
sql, reads hb_process_activitySELECT LOWER(process_name) AS child_proc, parent_process_name, COUNT(DISTINCT device_hostname) AS hosts, COUNT(*) AS occurrences, MIN(time) AS first_seenFROM hb_process_activityWHERE (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_nameHAVING hosts <= 3ORDER BY hosts, occurrencesWhat a hit looks like. Rare binaries or shells spawned by web workers. Silence means no anomalous children were observed.
-
Agent triage
Final exploitation verdict
Combine the precursor triage with the rare process evidence to confirm successful unauthenticated RCE.
-
Decision
Route on verdict
Direct the response based on the final impact verdict.
-
Response action
Isolate host and apply mitigations
Terminate adversary access and apply immediate configuration hardening.
-
Analyst task
Forensic investigation
Manually review the anomalous child processes and identify the source of the exploit attempts.
-
Analyst task
Remediation and patching audit
Verify all vulnerable instances are patched and monitor for remaining exposure.
Coverage
4 of 4 stages covered
| Stage and ATT&CK technique | Covered | How, or why not |
|---|---|---|
| PHP Vulnerability Identification T1190 |
Yes | inventory-vulnerable-php |
| Exploit Delivery via Crafted Request T1190 |
Yes | suspicious-http-delivery |
| Worker Memory Corruption T1190 |
Yes | php-worker-crashes |
| Remote Code Execution T1190 |
Yes | rare-worker-children |
Blind spots
- Needs hb_process_activity on Linux servers. A compromised Linux web server without an endpoint agent will only show delivery and potential network activity, but successful code execution will be invisible. It would answer: whether rare child processes are running on non-enrolled Linux servers
- Needs request body inspection. 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. It would answer: whether the multipart data specifically contains exploit shellcode
Parameters and data
Parameters
| Parameter | Type | Default | What it is |
|---|---|---|---|
lookback_days | number | 14 | Days of history to examine. |
scope_hosts | list[host] | none | Specific hosts to scope (leave empty for all). |
vulnerable_version_prefixes | list[string] | 8.2., 8.3., 8.4., 8.5. | PHP versions prefixes affected; check against local inventory. |
web_worker_names | list[string] | php-fpm, apache2, httpd, php-cgi, frankenphp, litespeed | PHP worker and web server process names. |
Data sources
| Source | Category | Telemetry |
|---|---|---|
| Endpoint telemetry (hb_ surfaces) | endpoint | endpoint |
| Web server / proxy logs | siem | network |
Source
An open hunt.md file. It runs anywhere that reads the format.
---
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
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.