Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(hopper): bound bridge request frames like the Cutter bridge (#5262)
Dery Ferdika26573c3aa41e
diff --git a/bridge/cutter/rea_bridge.py b/bridge/cutter/rea_bridge.pyindex be229f081..adaaa20ef 100644--- a/bridge/cutter/rea_bridge.py+++ b/bridge/cutter/rea_bridge.py@@ -625,12 +625,14 @@ class _BridgeServer(threading.Thread):data = bytearray()deadline = time.monotonic() + AUTH_FRAME_TIMEOUT_SECONDSwhile b"\n" not in data:- if len(data) >= MAX_FRAME_BYTES:+ if len(data) > MAX_FRAME_BYTES:raise ValueError("frame-limit-exceeded")remaining = deadline - time.monotonic()if remaining <= 0:raise socket.timeout("authentication frame timed out")connection.settimeout(remaining)+ # MAX_FRAME_BYTES limits the JSON payload; the terminating LF is+ # framing and may be the one byte beyond that payload budget.part = connection.recv(min(65536, MAX_FRAME_BYTES + 1 - len(data)))if not part:raise ValueError("incomplete authentication frame")diff --git a/bridge/hopper_bridge.py b/bridge/hopper_bridge.pyindex 73504b620..3636c6b44 100644--- a/bridge/hopper_bridge.py+++ b/bridge/hopper_bridge.py@@ -14,6 +14,9 @@ from typing import Any, Optional, Protocol, SequenceBAD_ADDRESSES = (-1, 0xFFFFFFFFFFFFFFFF, None)# The native label setter truncates NSString names at this UTF-16 extent.HOPPER_SYMBOL_NAME_UTF16_UNITS = 1024+# Maximum request JSON payload size in bytes, excluding its trailing LF.+# Matches the Cutter bridge's MAX_FRAME_BYTES payload ceiling.+MAX_REQUEST_BYTES = 16 * 1024 * 1024_rea_session_document = None_search_inventory_cache = {}_pseudocode_cache = {}@@ -1060,9 +1063,23 @@ def _serve_connection(connection):should_stop = Falsetry:while True:- line = file.readline()+ # Bound the read itself. The payload budget excludes LF, so permit+ # one additional byte for the delimiter while still refusing an+ # oversized unterminated peer without waiting for EOF.+ line = file.readline(MAX_REQUEST_BYTES + 1)if not line:break+ if not line.endswith(b"\n"):+ message = (+ "Bridge request exceeds the %d-byte payload limit"+ % MAX_REQUEST_BYTES+ if len(line) > MAX_REQUEST_BYTES+ else "Incomplete bridge request frame"+ )+ _write_message(file, {"id": 0, "error": _safe_diagnostic(+ InvalidRequestError(message)+ )})+ breakrequest_id = Noneauthenticated = Falseshould_stop = Falsediff --git a/docs/reverse-engineering-tools.md b/docs/reverse-engineering-tools.mdindex ab2e0c83e..8b2ad94af 100644--- a/docs/reverse-engineering-tools.md+++ b/docs/reverse-engineering-tools.md@@ -71,7 +71,11 @@ Cutter commands use the local REA Python bridge and authenticated loopback messaThe client and plugin must support the current v2 handshake; older peers arerejected before dispatch because they cannot preserve cross-caller recovery proof.The client checks the final encoded request against the bridge's 16 MiB frame-limit before dispatch; an oversized command does not retain a cleanup owner.+limit before dispatch; the 16 MiB budget applies to request payload bytes and+excludes the terminating LF. The bridge accepts that full payload size and+rejects larger or incomplete frames while bounding the read; an oversized+command does not retain a cleanup owner. Hopper uses the same request payload+budget.Each bridge request waits 25000 ms. Discovery admits at most 256 descriptorcandidates and reads and probes at most eight concurrently. A larger directoryreports `bridge_directory_capacity_exceeded`. This release has no runtimediff --git a/tests/boundary/providers/hopper/hopperBridgeFrameLimit.test.ts b/tests/boundary/providers/hopper/hopperBridgeFrameLimit.test.tsnew file mode 100644index 000000000..f07264b86--- /dev/null+++ b/tests/boundary/providers/hopper/hopperBridgeFrameLimit.test.ts@@ -0,0 +1,87 @@+import { execFile } from "node:child_process";+import { fileURLToPath } from "node:url";+import { promisify } from "node:util";++import { expect, it } from "vitest";+import { z } from "zod";++const execute = promisify(execFile);++const bridgePath = new URL(+ "../../../../bridge/hopper_bridge.py",+ import.meta.url,+);+const probePath = new URL(+ "../../../fixtures/hopperBridgeFrameLimitProbe.py",+ import.meta.url,+);++/** Mirrors the Cutter bridge's frame ceiling so both bridges bound identically. */+const MAX_REQUEST_BYTES = 16 * 1024 * 1024;++const exchangeSchema = z.strictObject({+ reply: z.unknown(),+ next: z.unknown().optional(),+ thread_released: z.boolean(),+ dispatch_calls: z.number().int().nonnegative(),+});++const probeResultSchema = z.strictObject({+ limit: z.number().int().positive(),+ legit: exchangeSchema,+ at_limit: exchangeSchema,+ past_limit: exchangeSchema,+ stalled_line: exchangeSchema,+ eof_partial: exchangeSchema,+});++it("serves requests up to the frame limit and refuses a line that exceeds it", async () => {+ const { stdout } = await execute("python3", [+ fileURLToPath(probePath),+ fileURLToPath(bridgePath),+ ]);+ const result = probeResultSchema.parse(JSON.parse(stdout));+ expect(result.limit).toBe(MAX_REQUEST_BYTES);++ // Legitimate traffic is unaffected, including a request that fills the limit.+ for (const exchange of [result.legit, result.at_limit])+ expect(exchange.reply).toMatchObject({+ result: { run_id: "owned-run", ready: true },+ });++ // A peer that keeps a line open past the limit is answered without reading+ // the line to completion. The refusal can be consumed by the peer's own+ // reset, so this asserts boundedness rather than the diagnostic's arrival.+ expect(result.past_limit.reply).not.toEqual({+ socket_error: "TimeoutError",+ });+ expect(result.past_limit.thread_released).toBe(true);++ // An unterminated payload one byte over the limit is refused with a typed+ // diagnostic naming the limit and the connection is closed, instead of+ // resynchronizing mid-line. The peer stays connected, so this pins the+ // payload ceiling without charging the LF against it.+ expect(result.stalled_line.reply).toMatchObject({+ error: {+ code: -32000,+ type: "invalid_request",+ message: expect.stringContaining(String(MAX_REQUEST_BYTES)),+ },+ });+ expect(result.stalled_line.next).toEqual({ closed: true });+ expect(result.stalled_line.thread_released).toBe(true);++ // A valid authenticated payload without LF is still an incomplete frame.+ // Half-closing the write side supplies EOF; the bridge rejects without+ // dispatching the operation, then closes its response connection.+ expect(result.eof_partial.reply).toMatchObject({+ error: {+ code: -32000,+ type: "invalid_request",+ message: "Incomplete bridge request frame",+ },+ });+ expect(result.eof_partial.next).toEqual({ closed: true });+ expect(result.eof_partial.dispatch_calls).toBe(0);+ expect(result.eof_partial.thread_released).toBe(true);+});diff --git a/tests/fixtures/cutter_bridge_protocol_test.py b/tests/fixtures/cutter_bridge_protocol_test.pyindex d6ea183ea..af6b50218 100644--- a/tests/fixtures/cutter_bridge_protocol_test.py+++ b/tests/fixtures/cutter_bridge_protocol_test.py@@ -592,6 +592,27 @@ class ProtocolProducerTest(unittest.TestCase):receiver.close()+class RequestFrameLimitTest(unittest.TestCase):+ def test_payload_limit_excludes_the_line_terminator(self):+ class BufferedSocket:+ def __init__(self, data):+ self.data = data++ def settimeout(self, _timeout):+ pass++ def recv(self, count):+ part, self.data = self.data[:count], self.data[count:]+ return part++ payload = b"{}" + b" " * (bridge.MAX_FRAME_BYTES - 2)+ self.assertEqual(+ bridge._BridgeServer._receive_frame(BufferedSocket(payload + b"\n")), {}+ )+ with self.assertRaisesRegex(ValueError, "frame-limit-exceeded"):+ bridge._BridgeServer._receive_frame(BufferedSocket(payload + b" " + b"\n"))++if __name__ == "__main__":if sys.argv[1:] == ["--serve"]:run_serve_mode()diff --git a/tests/fixtures/hopperBridgeFrameLimitProbe.py b/tests/fixtures/hopperBridgeFrameLimitProbe.pynew file mode 100644index 000000000..e59b68a56--- /dev/null+++ b/tests/fixtures/hopperBridgeFrameLimitProbe.py@@ -0,0 +1,132 @@+"""Exercise the shipped bridge's request-frame bound over real socket pairs.++Four cases share one loaded bridge module:++- ``legit``: an ordinary authenticated request is served.+- ``at_limit``: a request with an exactly-limit JSON payload plus LF is served,+ so framing does not consume a payload byte.+- ``past_limit``: a peer writes one byte past the limit and never terminates the+ line. An unbounded line read cannot answer this at all, which is what makes+ Hopper allocate for as long as the peer keeps writing.+- ``stalled_line``: a peer exceeds the payload limit without a terminator,+ stops writing, and keeps the connection open. The bridge must refuse it+ without waiting for EOF, then close.+- ``eof_partial``: an authenticated, otherwise valid short JSON request has no+ LF and the peer half-closes its write side. The bridge must reject the+ incomplete frame without dispatching it, then close.+"""+import json+import socket+import sys+import threading++from hopperBridgeFacadeProbe import load_bridge++READ_TIMEOUT_SECONDS = 5+++def _next_response(file):+ while True:+ line = file.readline()+ if not line:+ return {"closed": True}+ value = json.loads(line.decode("utf-8"))+ if "event" not in value:+ return value+++def serve(bridge, line, read_after, half_close_write=False):+ """Send one raw line and record the bridge's answer."""+ server, client = socket.socketpair()+ worker = threading.Thread(target=bridge["_serve_connection"], args=(server,))+ worker.daemon = True+ worker.start()+ file = client.makefile("rwb")+ client.settimeout(READ_TIMEOUT_SECONDS)+ outcome = {}+ dispatch_count = len(bridge["_probe_dispatches"])+ try:+ file.write(line)+ file.flush()+ if half_close_write:+ client.shutdown(socket.SHUT_WR)+ outcome["reply"] = _next_response(file)+ if read_after:+ outcome["next"] = _next_response(file)+ except OSError as error:+ outcome["reply"] = {"socket_error": type(error).__name__}+ finally:+ try:+ file.close()+ finally:+ client.close()+ worker.join(2)+ outcome["thread_released"] = not worker.is_alive()+ outcome["dispatch_calls"] = (+ len(bridge["_probe_dispatches"]) - dispatch_count+ )+ return outcome+++def request_line(bridge, params):+ request = {+ "id": 1,+ "token": bridge["REA_TOKEN"],+ "method": "health",+ "params": params,+ }+ return json.dumps(request, separators=(",", ":")).encode("utf-8")+++def main():+ bridge = load_bridge(sys.argv[1])+ bridge.update(REA_TOKEN="owned-token", REA_RUN_ID="owned-run")+ bridge["_probe_dispatches"] = []++ def dispatch(method, params):+ bridge["_probe_dispatches"].append((method, params))+ return {"run_id": bridge["REA_RUN_ID"], "ready": True}++ bridge["_dispatch"] = dispatch+ limit = bridge.get("MAX_REQUEST_BYTES")+ if not isinstance(limit, int) or isinstance(limit, bool) or limit <= 0:+ json.dump({"limit": limit}, sys.stdout)+ return++ legit = serve(bridge, request_line(bridge, {}) + b"\n", False)++ # The payload may fill the limit; the framing LF is additional.+ padding = limit - len(request_line(bridge, {"padding": ""}))+ at_limit_line = request_line(bridge, {"padding": "p" * padding}) + b"\n"+ assert len(at_limit_line) == limit + 1, len(at_limit_line)+ at_limit = serve(bridge, at_limit_line, False)++ # One byte past the limit, still unterminated and still open.+ past_limit = serve(bridge, b"x" * (limit + 1), False)++ # The payload limit plus one byte, without a terminator. The peer stays+ # connected so the bounded read must reject it without waiting for EOF.+ stalled_line = serve(bridge, b"x" * (limit + 1), True)++ # This is a valid authenticated request, but omitting LF makes it an+ # incomplete frame. EOF must terminate the read and produce a rejection;+ # the application dispatch must never see it.+ eof_partial = serve(+ bridge, request_line(bridge, {}), True, half_close_write=True+ )++ json.dump(+ {+ "limit": limit,+ "legit": legit,+ "at_limit": at_limit,+ "past_limit": past_limit,+ "stalled_line": stalled_line,+ "eof_partial": eof_partial,+ },+ sys.stdout,+ )+++if __name__ == "__main__":+ main()