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

  1. Query, scoping

    Inventory vulnerable PHP installations

    Identify hosts running PHP versions prior to the October 2026 security updates.

    sql, reads hb_software_inventory
    SELECT 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.

  2. 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_activity
    SELECT 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.

  3. Query, triage

    PHP worker application faults

    Find segmentation faults or OOM errors in PHP workers indicating successful memory corruption.

    sql, reads hb_application_error
    SELECT 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.

  4. Agent triage

    Early stage exploit triage

    Identify hosts showing a temporal correlation between suspicious HTTP delivery and worker crashes.

  5. 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_activity
    SELECT 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, occurrences

    What a hit looks like. Rare binaries or shells spawned by web workers. Silence means no anomalous children were observed.

  6. Agent triage

    Final exploitation verdict

    Combine the precursor triage with the rare process evidence to confirm successful unauthenticated RCE.

  7. Decision

    Route on verdict

    Direct the response based on the final impact verdict.

  8. Response action

    Isolate host and apply mitigations

    Terminate adversary access and apply immediate configuration hardening.

  9. Analyst task

    Forensic investigation

    Manually review the anomalous child processes and identify the source of the exploit attempts.

  10. 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 techniqueCoveredHow, 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

ParameterTypeDefaultWhat it is
lookback_daysnumber14Days of history to examine.
scope_hostslist[host]noneSpecific hosts to scope (leave empty for all).
vulnerable_version_prefixeslist[string]8.2., 8.3., 8.4., 8.5.PHP versions prefixes affected; check against local inventory.
web_worker_nameslist[string]php-fpm, apache2, httpd, php-cgi, frankenphp, litespeedPHP worker and web server process names.

Data sources

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

Source

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

hunt.md
---
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.

Content pack

Sign up to open

Pack contents open in Huntbase.