Back to Intelligence

Fedora 43 DokuWiki Object Injection RCE: Detection and Remediation Guide (Advisory 2026-046b69d591)

SA
Security Arsenal Team
September 11, 2026
10 min read

Fedora has issued security advisory 2026-046b69d591 for Fedora 43, shipping a backported fix for a critical PHP object injection vulnerability in DokuWiki that leads to remote code execution. The underlying issue is tracked upstream in the DokuWiki project as GitHub issue #4752. Object injection — insecure deserialization of attacker-controlled PHP serialized data — is one of the most reliably exploitable vulnerability classes in the PHP ecosystem. When a wiki application passes untrusted input into unserialize(), an attacker who can supply a crafted serialized object chain (a "POP chain" or gadget chain) can achieve arbitrary code execution in the context of the web server, typically as the apache or nginx service account.

DokuWiki is widely deployed for internal documentation, knowledge bases, and team wikis — frequently on internal networks with weak authentication assumptions, and frequently internet-facing for public documentation. That deployment profile makes this a high-priority patch: a successful exploit converts a documentation server into an initial-access beachhead inside your environment. If you run DokuWiki on Fedora 43 — or any DokuWiki instance that ingests serialized data — treat this as urgent.

Technical Analysis

Affected Products and Platforms

  • Product: DokuWiki (PHP-based wiki engine)
  • Platform: Fedora 43 (per advisory 2026-046b69d591), and by extension any DokuWiki installation running a build prior to the upstream fix referenced in dokuwiki/dokuwiki#4752
  • Fix mechanism: The Fedora package maintainer has backported the upstream patch into the Fedora 43 package. Backporting matters here: it means the vulnerability affects a DokuWiki version already in circulation, and the fix was grafted onto that version rather than requiring a full major upgrade. Administrators should not assume their version number alone tells them whether they are safe — check for the patched package build from the Fedora update.

Vulnerability Class: PHP Object Injection via Insecure Deserialization

Object injection (CWE-502, Deserialization of Untrusted Data) occurs when an application deserializes attacker-controlled input using PHP's unserialize() without integrity or type validation. A typical exploitation chain looks like this from a defender's vantage point:

  1. Input vector: The attacker locates a DokuWiki endpoint, parameter, cookie, or stored data field whose contents are passed to unserialize().
  2. Payload construction: The attacker crafts a serialized PHP object whose class exists in the DokuWiki codebase (or its bundled libraries). When the object is instantiated and later destroyed or used, "magic methods" such as __wakeup(), __destruct(), or __toString() execute attacker-influenced logic.
  3. Gadget chain execution: Chaining one or more of these magic methods across available classes allows the attacker to reach a dangerous sink — file_put_contents(), include, eval(), or a command execution primitive.
  4. Code execution: The attacker's payload executes with the privileges of the PHP-FPM or web server process. On a default Fedora deployment that means the apache user — enough to write a web shell into the DokuWiki data directory, read conf/local.php (which contains credentials), and pivot.

No authentication requirement or specific affected endpoint has been detailed in the public summary; defenders should assume the worst case — unauthenticated exploitation — until the upstream issue confirms otherwise. At the time of this writing, the Fedora advisory does not reference a CVE identifier or CVSS score, and there is no confirmed public reporting of in-the-wild exploitation or CISA KEV listing. However, object injection flaws in widely deployed PHP applications historically attract rapid PoC development once patched, because the patch itself reveals the vulnerable code path. The patch window is the exploitation window.

Detection & Response

The highest-fidelity detections for post-exploitation of a PHP RCE focus on what the attacker must do next: cause the web server process to execute commands, write executable content, or make unexpected outbound connections. These behaviors are observable regardless of the exact gadget chain used.

SIGMA Rules

YAML
---
title: Web Server Process Spawning Shell or Command Interpreter (Linux)
id: 3f7a2b91-4c5e-4d8a-b6f2-9a1c3e5d7f90
status: experimental
description: Detects httpd, nginx, or php-fpm spawning a shell or command interpreter, consistent with post-exploitation of a web application RCE such as the DokuWiki object injection flaw (Fedora advisory 2026-046b69d591).
references:
  - https://linuxsecurity.com/advisories/fedora/fedora-43-dokuwiki-2026-046b69d591
  - https://github.com/dokuwiki/dokuwiki/issues/4752
  - https://attack.mitre.org/techniques/T1059/004/
author: Security Arsenal
date: 2026/02/12
tags:
  - attack.execution
  - attack.t1059.004
  - attack.t1190
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/httpd'
      - '/nginx'
      - '/php-fpm'
      - '/php-fpm8.3'
      - '/php-cgi'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
      - '/base64'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate wiki plugins invoking system utilities (e.g., PDF renderers, mailers) - tune per environment baseline
level: high
---
title: Web Shell Written to DokuWiki Data Directory
id: 8c1e4d62-7b3a-4f95-a2c8-1e6b9d0f4a27
status: experimental
description: Detects PHP files created in DokuWiki data or media directories, which should contain content files rather than executable code - a strong indicator of web shell deployment following RCE exploitation.
references:
  - https://linuxsecurity.com/advisories/fedora/fedora-43-dokuwiki-2026-046b69d591
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/02/12
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: linux
detection:
  selection_path:
    TargetFilename|contains:
      - '/dokuwiki/data/'
      - '/dokuwiki/lib/plugins/'
      - '/var/lib/dokuwiki/data/'
  selection_ext:
    TargetFilename|endswith:
      - '.php'
      - '.phtml'
      - '.phar'
  condition: selection_path and selection_ext
falsepositives:
  - Plugin installation or updates by an administrator through the DokuWiki extension manager
level: high
---
title: PHP unserialize Gadget Chain Artifact in Web Access Log
id: 5b9f0e73-2a6d-4c81-b3e4-7d2a8c1f6e39
status: experimental
description: Detects serialized PHP object payloads (O: and a: serialized structure markers) in web server access log URIs, a hallmark of PHP object injection probing and exploitation attempts against applications like DokuWiki.
references:
  - https://linuxsecurity.com/advisories/fedora/fedora-43-dokuwiki-2026-046b69d591
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/02/12
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
detection:
  selection:
    c-uri|contains:
      - 'O%3A'
      - '%3AO%3A'
      - 'O:+'
      - 'a%3A2%3A%7B'
      - '__wakeup'
      - '__destruct'
  condition: selection
falsepositives:
  - Rare; serialized data in URLs is not typical of legitimate DokuWiki traffic
level: high

KQL (Microsoft Sentinel / Defender)

The following query hunts for deserialization exploit patterns in web logs ingested into Sentinel via Syslog/CEF connectors, plus web-server-spawned child processes on endpoints monitored by Defender for Endpoint on Linux.

KQL — Microsoft Sentinel / Defender
// Hunt 1: Serialized PHP object injection patterns in web requests (Syslog/CEF ingestion of httpd/nginx logs)
Syslog
| where TimeGenerated > ago(7d)
| where ProcessName has_any ("httpd", "apache2", "nginx")
| where SyslogMessage has_any ("O%3A", "%3AO%3A", "O:+", "a%3A2%3A%7B", "__wakeup", "__destruct", "unserialize")
| extend RequestUri = extract(@'"(?:GET|POST|PUT)\s+([^\s]+)', 1, SyslogMessage)
| where isnotempty(RequestUri)
| summarize RequestCount = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated) by RequestUri, SourceIP = Computer, HostIP
| order by RequestCount desc;

// Hunt 2: Web server or PHP-FPM spawning shells/interpreters (Defender for Endpoint on Linux)
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName has_any ("httpd", "nginx", "php-fpm", "php-cgi")
| where FileName has_any ("sh", "bash", "dash", "curl", "wget", "python", "python3", "perl", "nc", "ncat", "base64")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, FileName, ProcessCommandLine, AccountName, InitiatingProcessCommandLine
| order by TimeGenerated desc;

// Hunt 3: Outbound connections from the web server process to unusual destinations
DeviceNetworkEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName has_any ("httpd", "nginx", "php-fpm")
| where RemoteIPType == "Public"
| summarize ConnectionCount = count(), RemoteIPs = make_set(RemoteIP, 20) by DeviceName, InitiatingProcessFileName, RemotePort
| where ConnectionCount > 50 or array_length(RemoteIPs) > 10
| order by ConnectionCount desc

Velociraptor VQL

Use this hunt artifact across your Linux fleet to identify web shells planted in DokuWiki directories and shell processes parented to the web server — the two most reliable post-exploitation artifacts.

VQL — Velociraptor
-- DokuWiki post-exploitation hunt: web shells in data dirs and suspicious child processes
-- Fedora advisory 2026-046b69d591 (object injection RCE)

-- Part A: PHP files inside DokuWiki data/media directories (should be content-only)
LET shell_files = SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=['/var/www/html/dokuwiki/data/**/*.php',
                 '/var/www/html/dokuwiki/lib/plugins/**/*.php',
                 '/var/lib/dokuwiki/data/**/*.php',
                 '/usr/share/dokuwiki/data/**/*.php'])
WHERE Mtime > now() - 1209600

-- Part B: Shells/interpreters parented to web server processes
LET suspicious_procs = SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ 'sh |bash|curl |wget |python|nc |ncat|base64'
  AND Username =~ 'apache|nginx|www-data'

SELECT * FROM shell_files
UNION ALL
SELECT * FROM suspicious_procs

Verification and Hardening Script (Bash)

Bash / Shell
#!/usr/bin/env bash
# DokuWiki object injection remediation & verification - Fedora 43
# Advisory: 2026-046b69d591 | Upstream: dokuwiki/dokuwiki#4752
set -euo pipefail

echo "=== [1] Checking installed DokuWiki package ==="
if rpm -q dokuwiki &>/dev/null; then
    rpm -q dokuwiki
    echo "--> Package found. Applying patched update from Fedora advisory 2026-046b69d591..."
    sudo dnf update -y --advisory=FEDORA-2026-046b69d591 dokuwiki || \
      sudo dnf update -y dokuwiki
    echo "--> Post-update version:"
    rpm -q dokuwiki
else
    echo "--> No RPM-managed DokuWiki found. Checking for manual/source installs..."
    sudo find /var/www /srv/www /usr/share -maxdepth 3 -iname "doku.php" 2>/dev/null || true
    echo "--> If a source install exists, pull the fixed upstream commit referenced in"
    echo "    https://github.com/dokuwiki/dokuwiki/issues/4752 and redeploy."
fi

echo "=== [2] Auditing for object injection probing in access logs (last 30 days) ==="
for log in /var/log/httpd/access_log* /var/log/nginx/access.log*; do
    [ -f "$log" ] || continue
    hits=$(zgrep -hE 'O%3A|O:|a%3A[0-9]+%3A%7B|__wakeup|__destruct' "$log" 2>/dev/null | wc -l || true)
    [ "$hits" -gt 0 ] && echo "!! $log: $hits suspicious serialized-payload requests - INVESTIGATE"
done

echo "=== [3] Hunting for web shells in DokuWiki writable directories ==="
sudo find /var/lib/dokuwiki/data /usr/share/dokuwiki/data /var/www/html/dokuwiki/data \
    -type f \( -name '*.php' -o -name '*.phtml' -o -name '*.phar' \) \
    -mtime -30 -ls 2>/dev/null || echo "--> No recent PHP files in data directories."

echo "=== [4] Checking for web-server-spawned shells (current state) ==="
sudo ps -eo pid,ppid,user,comm,args | awk '$3=="apache"||$3=="nginx"||$3=="www-data"' | \
    grep -E 'bash|sh |curl|wget|python|perl|nc ' || echo "--> No suspicious web-server children."

echo "=== [5] Hardening: block PHP execution in DokuWiki data directory ==="
echo "    Apache (add to .htaccess or vhost for the data/ path):"
echo "      <Directory /var/lib/dokuwiki/data>"
echo "        php_flag engine off"
echo "        Require all denied"
echo "      </Directory>"
echo "    Nginx:"
echo "      location ~ /dokuwiki/data/.*\.php { deny all; }"

echo "=== Done. If steps 2-4 produced findings, isolate the host and begin IR. ==="

Remediation

  1. Patch immediately. On Fedora 43, apply the update via sudo dnf update --advisory=FEDORA-2026-046b69d591 or a full dnf update. Confirm the new package build is installed with rpm -q dokuwiki --changelog | head to verify the security backport is referenced.
  2. Patch non-Fedora deployments. Any DokuWiki instance installed from source, tarball, or another distribution must receive the upstream fix referenced in dokuwiki/dokuwiki#4752. Do not rely on the version string alone — the Fedora advisory backports the fix, meaning the vulnerable code exists in a currently shipped release line. Consult the Fedora advisory and the upstream issue for the exact patched commit.
  3. Assume exposure and hunt. Because the public summary does not confirm whether exploitation requires authentication, treat every reachable DokuWiki instance as potentially compromised prior to patching. Run the log audit and web-shell checks above before and after patching — patching does not evict an attacker who already landed.
  4. Reduce the attack surface. DokuWiki's data/, conf/, bin/, and inc/ directories should not be directly web-accessible, and PHP execution must be disabled under data/. DokuWiki ships .htaccess guidance for this — verify it is actually enforced on your web server configuration, not just present in the distribution.
  5. Restrict network reachability. Internal wikis should sit behind VPN or authenticated reverse proxies. If your DokuWiki is internet-facing and does not need to be, pull it back behind access controls today.
  6. Credential rotation on confirmed compromise. DokuWiki stores user credentials and configuration under conf/. Any instance showing post-exploitation indicators requires rotation of wiki user passwords, any SMTP/LDAP bind credentials in local.php, and a review of lateral movement from the host.

No CISA KEV deadline has been issued for this flaw as of publication, but the availability of a public patch with an upstream issue reference materially shortens the time-to-exploit. Patch within your emergency change window.

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.