Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
Proxy tool sweep: drop send_request, fix Caido SDK gotchas
0xallam5921fec16c94
diff --git a/docs/tools/proxy.mdx b/docs/tools/proxy.mdxindex ea023c72..2c920c31 100644--- a/docs/tools/proxy.mdx+++ b/docs/tools/proxy.mdx@@ -66,9 +66,13 @@ asyncio.run(main())| `list_requests()` | Query captured traffic with HTTPQL filters || `view_request()` | Get full request/response details || `repeat_request()` | Replay a request with modifications |-| `send_request()` | Send a new HTTP request || `scope_rules()` | Manage proxy scope (allowlist/denylist) |+For one-off arbitrary requests, use shell tooling like `curl` — the+sandbox's `HTTP_PROXY` env routes the traffic through Caido+automatically, so it lands in `list_requests` and can be replayed via+`repeat_request`.+### Example: Automated IDOR Testing```pythondiff --git a/strix/agents/factory.py b/strix/agents/factory.pyindex 218f5689..2e6ff5fc 100644--- a/strix/agents/factory.py+++ b/strix/agents/factory.py@@ -48,7 +48,6 @@ from strix.tools.proxy.tools import (list_requests,repeat_request,scope_rules,- send_request,view_request,)from strix.tools.reporting.tool import create_vulnerability_report@@ -268,7 +267,6 @@ _BASE_TOOLS: tuple[Tool, ...] = (# Caido HTTP/HTTPS proxylist_requests,view_request,- send_request,repeat_request,scope_rules,# Multi-agent graph tools (the coordinator is in ctx.context)diff --git a/strix/agents/prompts/system_prompt.jinja b/strix/agents/prompts/system_prompt.jinjaindex bcc192db..09dbceda 100644--- a/strix/agents/prompts/system_prompt.jinja+++ b/strix/agents/prompts/system_prompt.jinja@@ -171,7 +171,7 @@ EFFICIENCY TACTICS:`python3 -c` or a here-document is acceptable.- For Caido proxy automation inside Python, explicitly import from`caido_api`:- `from caido_api import list_requests, view_request, send_request, repeat_request, scope_rules`+ `from caido_api import list_requests, view_request, repeat_request, scope_rules`- Prefer established fuzzers/scanners where applicable: ffuf, sqlmap, zaproxy, nuclei, wapiti, arjun, httpx, katana, semgrep, bandit, trufflehog, nmap. Use scripts mainly to coordinate or validate around them, not to replace them without reason- For trial-heavy vectors (SQLi, XSS, XXE, SSRF, RCE, auth/JWT, deserialization), DO NOT iterate payloads manually in the browser. Always spray payloads via Python scripts through `exec_command` or terminal tools.- When using established fuzzers/scanners, use the proxy for inspection where helpfuldiff --git a/strix/interface/tui/renderers/proxy_renderer.py b/strix/interface/tui/renderers/proxy_renderer.pyindex 3297d2b5..5723a57e 100644--- a/strix/interface/tui/renderers/proxy_renderer.py+++ b/strix/interface/tui/renderers/proxy_renderer.py@@ -195,80 +195,6 @@ class ViewRequestRenderer(BaseToolRenderer):return Static(text, classes=css_classes)-@register_tool_renderer-class SendRequestRenderer(BaseToolRenderer):- tool_name: ClassVar[str] = "send_request"- css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]-- @classmethod- def render(cls, tool_data: dict[str, Any]) -> Static: # noqa: PLR0912, PLR0915- args = tool_data.get("args", {})- result = tool_data.get("result")- status = tool_data.get("status", "running")-- method = args.get("method", "GET")- url = args.get("url", "")- req_headers = args.get("headers")- req_body = args.get("body", "")-- text = Text()- text.append(PROXY_ICON, style="dim")- text.append(" sending request", style="#06b6d4")-- text.append("\n")- text.append(" >> ", style="#3b82f6")- text.append(method, style="#a78bfa")- text.append(f" {_truncate(url, 180)}", style="dim")-- if req_headers and isinstance(req_headers, dict):- for k, v in list(req_headers.items())[:5]:- text.append("\n")- text.append(" >> ", style="#3b82f6")- text.append(f"{k}: ", style="dim")- text.append(_sanitize(str(v), 150), style="dim")-- if req_body and isinstance(req_body, str):- text.append("\n")- text.append(" >> ", style="#3b82f6")- body_lines = req_body.split("\n")[:4]- for i, line in enumerate(body_lines):- if i > 0:- text.append("\n")- text.append(" ", style="dim")- text.append(_truncate(line, MAX_LINE_LENGTH), style="dim")- if len(req_body.split("\n")) > 4:- text.append(" ...", style="dim italic")-- if status == "completed" and isinstance(result, dict):- if "error" in result:- text.append(f"\n error: {_sanitize(str(result['error']), 150)}", style="#ef4444")- else:- code = result.get("status_code")- time_ms = result.get("response_time_ms")-- text.append("\n")- text.append(" << ", style="#22c55e")- if code:- text.append(f"{code}", style=_status_style(code))- if time_ms:- text.append(f" ({time_ms}ms)", style="dim")-- body = result.get("body", "")- if body and isinstance(body, str):- lines = body.split("\n")[:6]- for line in lines:- text.append("\n")- text.append(" << ", style="#22c55e")- text.append(_truncate(line, MAX_LINE_LENGTH - 5), style="dim")-- if len(body.split("\n")) > 6:- text.append("\n")- text.append(" ...", style="dim italic")-- css_classes = cls.get_css_classes(status)- return Static(text, classes=css_classes)--@register_tool_rendererclass RepeatRequestRenderer(BaseToolRenderer):tool_name: ClassVar[str] = "repeat_request"diff --git a/strix/skills/tooling/python.md b/strix/skills/tooling/python.mdindex c4278ef7..b47ff768 100644--- a/strix/skills/tooling/python.md+++ b/strix/skills/tooling/python.md@@ -21,7 +21,6 @@ from caido_api import (list_requests,repeat_request,scope_rules,- send_request,view_request,)```@@ -59,10 +58,15 @@ Available helpers:- `list_requests(httpql_filter=, first=50, after=, sort_by=, sort_order=, scope_id=)` returns a cursor-paginated Caido SDK `Connection`.- `view_request(request_id, part="request")` returns a Caido SDK request object with raw request/response bytes.-- `send_request(method, url, headers=None, body="")` sends an arbitrary raw request through Caido Replay.- `repeat_request(request_id, modifications={...})` replays a captured request after modifying `url`, `params`, `headers`, `body`, or `cookies`.- `scope_rules(action, allowlist=, denylist=, scope_id=, scope_name=)` manages Caido scopes.+For one-off arbitrary requests (e.g. probing a fresh endpoint, hitting an+external API), use `exec_command` with `curl` / `httpx` / `requests`. The+sandbox's `HTTP_PROXY` env routes all such traffic through Caido+automatically, so it shows up in `list_requests` and you can use+`repeat_request` to replay-and-modify any of it.+## WorkflowFor iterative exploit work, put code in a file:diff --git a/strix/tools/proxy/caido_api.py b/strix/tools/proxy/caido_api.pyindex d7aa9d60..fd02f8f1 100644--- a/strix/tools/proxy/caido_api.py+++ b/strix/tools/proxy/caido_api.py@@ -13,8 +13,6 @@ from urllib.parse import parse_qs, urlencode, urlparse, urlunparsefrom caido_sdk_client import Client, TokenAuthOptionsfrom caido_sdk_client.types import (ConnectionInfoInput,- CreateReplaySessionFromRaw,- CreateReplaySessionOptions,CreateScopeOptions,ReplaySendOptions,RequestGetOptions,@@ -130,10 +128,13 @@ async def get_request_with_client(*,part: RequestPart = "request",) -> Any:- opts = RequestGetOptions(- request_raw=(part == "request"),- response_raw=(part == "response"),- )+ # The Caido SDK's generated pydantic model marks Request.raw and+ # Response.raw as required strings even though the GraphQL fragment+ # makes them conditional via `@include(if: $includeRequestRaw)`.+ # Passing False for either causes pydantic validation to fail with+ # "Field required" on the missing raw field. Always request both —+ # the caller picks which one to surface via ``part``.+ opts = RequestGetOptions(request_raw=True, response_raw=True)return await client.request.get(request_id, opts)@@ -236,6 +237,15 @@ def apply_modifications(}+# Hard wall-clock bound on a single replay dispatch. Caido's Replay+# API has no built-in send-side timeout, so a stalled connection+# (unroutable target, slow loopback, etc.) hangs the caller until the+# function_tool wrapper's 120s budget expires — by which point we've+# lost any useful error context. 30s is generous for legitimate HTTP+# and short enough that the model can decide to retry rather than wait.+_REPLAY_SEND_TIMEOUT_SECONDS = 30.0++async def replay_send_raw(client: CaidoClient,*,@@ -243,17 +253,42 @@ async def replay_send_raw(connection: ConnectionInfoInput,) -> dict[str, Any]:started = time.time()- session = await client.replay.sessions.create(- CreateReplaySessionOptions(- request_source=CreateReplaySessionFromRaw(raw=raw, connection=connection),- ),- )- result = await client.replay.send(- session.id,- ReplaySendOptions(raw=raw, connection=connection),- )+ # Create an empty replay session, then dispatch via ``send()``.+ # Passing ``CreateReplaySessionFromRaw`` here would also seed a stored+ # entry on the server side, leading the caller to observe two history+ # rows per call (one without response from the create-step seed, one+ # with response from the actual send). The empty-create + send flow+ # produces exactly one dispatched request.+ session = await client.replay.sessions.create()+ try:+ result = await asyncio.wait_for(+ client.replay.send(+ session.id,+ ReplaySendOptions(raw=raw, connection=connection),+ ),+ timeout=_REPLAY_SEND_TIMEOUT_SECONDS,+ )+ except TimeoutError:+ elapsed_ms = int((time.time() - started) * 1000)+ return {+ "session_id": str(session.id),+ "status": "ERROR",+ "error": (+ f"Caido replay dispatch did not complete within "+ f"{_REPLAY_SEND_TIMEOUT_SECONDS:.0f}s. The target may be "+ "unroutable from the sandbox, or Caido's outbound HTTP client "+ "is stalled. Check the target host/port and retry."+ ),+ "elapsed_ms": elapsed_ms,+ "response_raw": None,+ }elapsed_ms = int((time.time() - started) * 1000)- response_raw = result.entry.response_raw if hasattr(result.entry, "response_raw") else None+ # ``result.entry.response`` is the parsed Response (with ``.raw`` bytes+ # when ``includeResponseRaw`` was True, which is the entries SDK's+ # default). The previous ``result.entry.response_raw`` lookup matched+ # no attribute on ReplayEntry and silently returned ``None``.+ response = getattr(result.entry, "response", None)+ response_raw = getattr(response, "raw", None) if response is not None else Nonereturn {"session_id": str(session.id),"status": result.status,@@ -335,23 +370,6 @@ async def view_request(request_id: str, *, part: RequestPart = "request") -> Anyreturn await get_request_with_client(await get_client(), request_id, part=part)-async def send_request(- method: str,- url: str,- *,- headers: dict[str, str] | None = None,- body: str = "",-) -> dict[str, Any]:- """Send an arbitrary raw HTTP request through Caido Replay."""- connection, raw = build_raw_request(- method=method,- url=url,- headers=headers or {},- body=body,- )- return await replay_send_raw(await get_client(), raw=raw, connection=connection)--async def repeat_request(request_id: str,*,@@ -432,6 +450,5 @@ __all__ = ["list_requests","repeat_request","scope_rules",- "send_request","view_request",]diff --git a/strix/tools/proxy/tools.py b/strix/tools/proxy/tools.pyindex beb09195..8b3465a1 100644--- a/strix/tools/proxy/tools.py+++ b/strix/tools/proxy/tools.py@@ -1,12 +1,15 @@"""Caido proxy tools — host-side ``@function_tool`` wrappers.-The five tools delegate to :mod:`strix.tools.proxy.caido_api` for the actual+The four tools delegate to :mod:`strix.tools.proxy.caido_api` for the actualcaido-sdk-client work and add LLM-friendly JSON serialization + errorwrapping on top. The delegated ``caido_api.py`` module is also copied intothe sandbox image as the importable ``caido_api`` Python module.-Tools: ``list_requests``, ``view_request``, ``send_request``,-``repeat_request``, ``scope_rules``.+Tools: ``list_requests``, ``view_request``, ``repeat_request``,+``scope_rules``. Arbitrary one-off requests should be made through+``exec_command`` (e.g. ``curl``) — they're captured automatically via+the sandbox's ``HTTP_PROXY`` env, so wrapping them in a Strix tool only+adds an extra layer of indirection."""from __future__ import annotations@@ -160,6 +163,21 @@ async def list_requests(for edge in connection.edges:req = edge.node.requestresp = edge.node.response+ response_payload: dict[str, Any] | None = None+ if resp is not None:+ response_payload = {+ "id": resp.id,+ "status_code": resp.status_code,+ "length": resp.length,+ "created_at": resp.created_at.isoformat(),+ }+ # Caido populates ``roundtripTime`` for some traffic sources+ # and leaves it as ``0`` for others (notably proxy captures+ # of upstream env-routed traffic). Surface the value only+ # when it's actually measured so the model doesn't waste+ # tokens reading a zero field on every entry.+ if resp.roundtrip_time:+ response_payload["roundtrip_ms"] = resp.roundtrip_timeentries.append({"cursor": edge.cursor,@@ -173,17 +191,7 @@ async def list_requests("is_tls": req.is_tls,"created_at": req.created_at.isoformat(),},- "response": (- {- "id": resp.id,- "status_code": resp.status_code,- "length": resp.length,- "roundtrip_ms": resp.roundtrip_time,- "created_at": resp.created_at.isoformat(),- }- if resp is not None- else None- ),+ "response": response_payload,},)@@ -326,47 +334,6 @@ def _format_text_page(content: str, *, page: int, page_size: int) -> dict[str, A}-# -----------------------------------------------------------------------# send_request-# -----------------------------------------------------------------------@function_tool(timeout=120, strict_mode=False)-async def send_request(- ctx: RunContextWrapper,- method: str,- url: str,- headers: dict[str, str] | None = None,- body: str = "",- timeout: int = 30,-) -> str:- """Send an arbitrary HTTP request through the Caido proxy.-- Use this for one-off probes (test endpoints, reach external APIs).- For modifying-and-replaying a request you've already captured, use- ``repeat_request`` instead — it inherits the original headers /- cookies / auth and only patches the fields you specify.-- Args:- method: ``"GET"`` / ``"POST"`` / ``"PUT"`` / ``"DELETE"`` / etc.- url: Full URL with protocol.- headers: Optional header dict.- body: Optional request body string.- timeout: Per-request timeout in seconds (default 30).- """- del timeout # The SDK applies its own timeout via the GraphQL settings.- client = _ctx_client(ctx)- if client is None:- return _no_client()-- try:- connection, raw = caido_api.build_raw_request(- method=method, url=url, headers=headers or {}, body=body- )- result = await caido_api.replay_send_raw(client, raw=raw, connection=connection)- return _format_replay_tool_result(result)- except Exception as exc: # noqa: BLE001- return _err("send_request", exc)--# ----------------------------------------------------------------------# repeat_request# ----------------------------------------------------------------------