Back to Intelligence

Slackware PHP Security Update: Defending Against Unauthenticated Remote Code Execution (SSA:2026-323-03)

SA
Security Arsenal Team
November 20, 2026
10 min read

The Slackware security team has released updated PHP packages for Slackware 15.0 and -current (advisory SSA:2026-323-03) to remediate security issues rated as critical, including an unauthenticated remote code execution path. Any organization running PHP on Slackware — particularly internet-facing web servers, application backends, or legacy LAMP/LEMP stacks — should treat this as a patch-now event, not a routine update.

Unauthenticated RCE in PHP is among the highest-severity vulnerability classes a defender can face. It requires no credentials, no user interaction, and typically no special position on the network. If the vulnerable component is reachable over HTTP/HTTPS, the attacker has a direct path to executing arbitrary code in the context of the web server or PHP interpreter — which in many environments runs with far more privilege than it should. Historically, these bugs are weaponized within days of disclosure, and opportunistic scanning follows within hours.

Why This Matters Right Now

Slackware maintains a loyal footprint in hosting, ISP infrastructure, embedded server roles, and long-lived internal applications — exactly the kinds of systems that get forgotten by patch cadences. PHP on these systems is often exposed through Apache's mod_php, PHP-FPM behind Nginx, or worst of all, PHP-CGI configurations, which have repeatedly been the vector for unauthenticated argument-injection and parameter-parsing RCE vulnerabilities in the PHP ecosystem.

If you are running PHP on Slackware 15.0 or -current and have not applied this update, assume your exposure is being enumerated by scanners already.


Technical Analysis

Affected Products and Platforms

  • Slackware Linux 15.0 — updated php package set
  • Slackware -current — updated php package set
  • Any deployment where PHP is reachable via a web server (Apache mod_php, PHP-FPM via FastCGI, or PHP-CGI)

The advisory (SSA:2026-323-03) was published via the standard Slackware security announcement channel and mirrored at linuxsecurity.com. The official advisory and package checksums are available from slackware.com and its mirrors under the patches/packages/ tree for each release.

Vulnerability Class: Unauthenticated Code Execution in PHP

Per the advisory language, the patched issues allow an unauthenticated remote attacker to execute code. In practical terms, vulnerabilities of this class in PHP typically fall into one of these patterns:

  1. CGI/FastCGI argument injection — the web server passes attacker-controlled request parameters to the PHP interpreter as command-line arguments, allowing option injection (e.g., forcing auto_prepend_file, allow_url_include, or code execution flags) without any authentication.
  2. Input parsing flaws in core PHP functions or bundled extensions — a malformed request body or header reaches a vulnerable parsing routine and corrupts memory or bypasses validation, yielding code execution.
  3. Deserialization or filter-chain abuse — attacker-controlled data passed through unserialize(), phar://, or PHP stream filters leads to arbitrary code execution without prior access.

Exploitation Requirements

  • Network reachability to the PHP application over HTTP/HTTPS
  • No authentication — this is the defining severity factor
  • No user interaction required
  • Code executes in the security context of the PHP/web server process (commonly apache, nginx, www-data, or a dedicated FPM pool user)

Exploitation Status

At time of publication, the Slackware advisory does not reference a specific CVE identifier or confirm in-the-wild exploitation in its summary text. However, defenders should operate under the standard assumption for this vulnerability class: public analysis and PoC development for unauthenticated PHP RCE issues historically move fast, and internet-wide scanning for vulnerable PHP configurations is continuous. Treat exposed instances as actively targeted until patched. Monitor CISA KEV and the PHP security feed for escalation in the coming days.


Detection & Response

The highest-fidelity post-exploitation signal for PHP RCE is consistent regardless of the specific bug: the web server or PHP process spawning a shell or unexpected child process. That is the detection primitive your SOC should anchor on. Below are field-ready rules and hunts.

Sigma Rules

YAML
---
title: Web Server or PHP Process Spawning Shell
description: Detects httpd, nginx, php-fpm, or php-cgi spawning a shell or command interpreter — a high-fidelity indicator of successful PHP remote code execution. Affected component aligns with the Slackware SSA:2026-323-03 PHP unauthenticated RCE advisory.
author: Security Arsenal
date: 2026/11/19
status: experimental
references:
  - https://linuxsecurity.com/advisories/slackware/slackware-2026-323-03-php
  - https://attack.mitre.org/techniques/T1059/004/
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/httpd'
      - '/apache2'
      - '/nginx'
      - '/php-fpm'
      - '/php-cgi'
      - '/php'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/ash'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
      - '/socat'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate application functionality that shells out (backup scripts, image processing via exec())
  - Monitoring agents invoked from application code
level: high
---
title: PHP CGI Argument Injection Attempt in Query String
description: Detects HTTP requests carrying PHP-CGI argument injection patterns (e.g., -d auto_prepend_file, allow_url_include, %ADd-encoded dashes) associated with unauthenticated PHP code execution attempts. Relevant to PHP-CGI deployments flagged by SSA:2026-323-03.
author: Security Arsenal
date: 2026/11/19
status: experimental
references:
  - https://linuxsecurity.com/advisories/slackware/slackware-2026-323-03-php
  - https://attack.mitre.org/techniques/T1190/
logsource:
  category: webserver
detection:
  selection:
    cs-uri-query|contains:
      - 'auto_prepend_file'
      - 'allow_url_include'
      - '%2dd%20'
      - '%add'
      - '-d+'
      - 'php://input'
      - 'data://'
  condition: selection
falsepositives:
  - Rare; some developer tooling may reference these strings, but not in production query strings
level: high
---
title: Outbound Connection From PHP or Web Server Process
description: Detects PHP interpreter or web server processes initiating outbound network connections, consistent with post-exploitation callback, reverse shell, or payload retrieval following PHP RCE exploitation.
author: Security Arsenal
date: 2026/11/19
status: experimental
references:
  - https://linuxsecurity.com/advisories/slackware/slackware-2026-323-03-php
  - https://attack.mitre.org/techniques/T1071/
logsource:
  category: network_connection
  product: linux
detection:
  selection:
    Image|endswith:
      - '/php'
      - '/php-cgi'
      - '/php-fpm'
      - '/httpd'
    Initiated: 'true'
  filter_update:
    DestinationPort:
      - 80
      - 443
  condition: selection and not filter_update
falsepositives:
  - Applications making outbound API calls on non-standard ports
  - Composer or package operations executed interactively
level: medium

KQL — Microsoft Sentinel / Defender Hunt

PHP exploitation on Linux servers reaches Sentinel through Syslog/CEF ingestion from auditd, or via Defender for Endpoint on Linux. This query hunts the core post-exploitation behavior — web/PHP processes spawning shells — and a secondary query looks for anomalous child processes in Defender process telemetry.

KQL — Microsoft Sentinel / Defender
// Hunt 1: Web server / PHP spawning shells via Syslog (auditd EXECVE)
Syslog
| where TimeGenerated > ago(7d)
| where ProcessName in ("httpd", "apache2", "nginx", "php-fpm", "php-cgi", "php")
   or SyslogMessage has_any ("php-fpm", "httpd", "php-cgi")
| where SyslogMessage has_any ("/bin/sh", "/bin/bash", "/usr/bin/python", "/usr/bin/perl", "nc -", "ncat", "socat")
| project TimeGenerated, Computer, ProcessName, SyslogMessage, SeverityLevel
| order by TimeGenerated desc;

// Hunt 2: Defender for Endpoint on Linux — suspicious child processes of PHP/web servers
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName has_any ("php-fpm", "php-cgi", "httpd", "nginx", "php")
| where FileName in~ ("sh", "bash", "dash", "python", "python3", "perl", "nc", "ncat", "socat", "curl", "wget")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine,
          FileName, ProcessCommandLine, AccountName, RemoteIP
| order by TimeGenerated desc;

// Hunt 3: Outbound connections from PHP interpreters (non-standard ports)
DeviceNetworkEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName has_any ("php", "php-cgi", "php-fpm")
| where RemotePort !in (80, 443, 3306, 5432, 6379, 11211)
| where RemoteIPType == "Public"
| summarize ConnectionCount = count(), Ports = make_set(RemotePort), Destinations = make_set(RemoteIP)
  by DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine
| order by ConnectionCount desc

Velociraptor VQL

Use this hunt artifact across Linux endpoints to identify PHP or web server processes with suspicious child processes or shell histories — the primary forensic footprint of successful PHP RCE.

VQL — Velociraptor
-- Hunt: PHP/web server processes with suspicious command lines or shell children
-- Targets post-exploitation activity following unauthenticated PHP RCE (SSA:2026-323-03)
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE (Name =~ '^(sh|bash|dash|python|python3|perl|nc|ncat|socat)$'
       AND CommandLine =~ 'sh|bash|python|perl|nc|socat')
   OR Exe =~ '/(sh|bash|dash|nc|ncat|socat)$'

-- Correlate: enumerate running PHP-FPM / CGI pools and their binaries for version verification
SELECT Pid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ 'php'

-- Artifact: recently modified PHP files in web roots (webshell triage)
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=['/var/www/**/*.php', '/srv/http/**/*.php', '/home/*/public_html/**/*.php'])
WHERE Mtime > now() - 86400 * 3
ORDER BY Mtime DESC

Remediation and Verification Script

This Bash script identifies the installed PHP version, applies the Slackware security update, restarts the relevant services, and performs a basic post-patch hygiene check for dropped webshells and unexpected listening shells.

Bash / Shell
#!/usr/bin/env bash
# SSA:2026-323-03 — Slackware PHP security update verification & remediation
# Run as root. Test in staging before production rollout.

set -euo pipefail

echo "=== [1] Current PHP package status ==="
ls -la /var/log/packages/ | grep -i php || echo "No php package found in /var/log/packages"
php --version 2>/dev/null || echo "php binary not in PATH"

echo "=== [2] Sync and apply Slackware security patches ==="
# Ensure your mirror in /etc/slackpkg/mirrors points to an official Slackware mirror
slackpkg update gpg
slackpkg update
slackpkg upgrade php

echo "=== [3] Verify new package installed ==="
ls -la /var/log/packages/ | grep -i php
php --version

echo "=== [4] Restart affected services ==="
# Apache (mod_php or proxy to FPM)
if [ -x /etc/rc.d/rc.httpd ]; then /etc/rc.d/rc.httpd restart; fi
# PHP-FPM if present
if [ -x /etc/rc.d/rc.php-fpm ]; then /etc/rc.d/rc.php-fpm restart; fi
if [ -x /etc/rc.d/rc.nginx ]; then /etc/rc.d/rc.nginx restart; fi

echo "=== [5] Post-patch hygiene checks ==="
# Recently modified PHP files in common web roots (potential webshells)
find /var/www /srv/http /home/*/public_html -name '*.php' -mtime -3 2>/dev/null | head -50
# PHP/web processes with shell children — investigate any hits
ps -eo pid,ppid,user,comm,args | grep -E 'httpd|php-fpm|php-cgi' | grep -v grep
# Unexpected listeners spawned since boot by non-standard users
ss -tlnp
echo "=== Done. Review output above before returning host to service. ==="

Remediation

  1. Patch immediately. Apply the updated php packages for Slackware 15.0 or -current via slackpkg upgrade php after syncing with an official mirror. Confirm the package timestamp in /var/log/packages/ reflects the SSA:2026-323-03 build.
  2. Restart all PHP-touching services. Apache with mod_php, PHP-FPM pools, and Nginx (as the FastCGI proxy) must be restarted — the patched interpreter does not take effect until the process reloads.
  3. Eliminate PHP-CGI exposure. If you are still running PHP in CGI mode (rather than FPM or mod_php), migrate now. CGI-mode PHP has been the repeated vector for unauthenticated argument-injection RCE in the PHP ecosystem. At minimum, block query strings beginning with - or containing %2d at the web server or WAF layer as a compensating control.
  4. Constrain the interpreter. Harden php.ini: set disable_functions to include exec, shell_exec, system, passthru, proc_open, popen, set allow_url_include = Off and allow_url_fopen = Off unless strictly required, and enforce open_basedir per virtual host. These materially reduce post-exploitation blast radius even if a future RCE lands.
  5. Reduce external exposure. Inventory all internet-facing PHP endpoints. Place administrative or internal PHP applications behind VPN or allowlists. If the application does not need to be public, it should not be.
  6. Hunt before you patch. Run the detection content above against the last 7–14 days of telemetry before wiping evidence with a reboot. Unauthenticated RCE means exploitation could have already occurred; patching a compromised host without triage leaves webshells and persistence behind.
  7. Verify egress controls. PHP/web server service accounts should have no legitimate reason to initiate arbitrary outbound connections. Egress filtering blunts reverse shells and payload retrieval.
  8. Track escalation. Monitor the official advisory at https://linuxsecurity.com/advisories/slackware/slackware-2026-323-03-php, the Slackware security list, and CISA KEV for CVE assignment and confirmed-exploitation updates.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.