hexproxy 0.2.2__py3-none-any.whl

hexproxy/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("hexproxy")
+except PackageNotFoundError:
+    # Cuando se ejecuta en desarrollo sin instalar
+    __version__ = "0.0.0"

hexproxy/__main__.py

@@ -0,0 +1,5 @@
+from .app import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hexproxy/app.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+from pathlib import Path
+import sys
+import threading
+
+from .certs import CertificateAuthority, default_certificate_dir
+from .extensions import PluginManager
+from .preferences import ApplicationPreferences
+from .proxy import HttpProxyServer
+from .store import TrafficStore
+from .themes import ThemeManager
+
+try:
+    from .tui import ProxyTUI
+    _TUI_IMPORT_ERROR: Exception | None = None
+except ModuleNotFoundError as exc:
+    if exc.name not in {"curses", "_curses"}:
+        raise
+    ProxyTUI = None  # type: ignore[assignment]
+    _TUI_IMPORT_ERROR = exc
+
+
+class ProxyRuntime:
+    def __init__(self, proxy: HttpProxyServer) -> None:
+        self.proxy = proxy
+        self._thread = threading.Thread(target=self._run, name="hexproxy-runtime", daemon=True)
+        self._ready = threading.Event()
+        self._stopped = threading.Event()
+        self._shutdown_requested = threading.Event()
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._error: Exception | None = None
+
+    def start(self) -> None:
+        self._thread.start()
+        self._ready.wait()
+        if self._error is not None:
+            raise RuntimeError("failed to start proxy runtime") from self._error
+
+    def stop(self) -> None:
+        self._shutdown_requested.set()
+        self._thread.join(timeout=5)
+
+    def run_coroutine(self, coro):
+        if self._loop is None:
+            raise RuntimeError("proxy runtime loop is not available")
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result()
+
+    def _run(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        try:
+            self._loop.run_until_complete(self._runner())
+        except Exception as exc:
+            self._error = exc
+            self._ready.set()
+        finally:
+            pending = [task for task in asyncio.all_tasks(self._loop) if not task.done()]
+            for task in pending:
+                task.cancel()
+            if pending:
+                self._loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+            self._loop.run_until_complete(self._loop.shutdown_default_executor(timeout=1))
+            self._loop.close()
+            self._stopped.set()
+
+    async def _runner(self) -> None:
+        try:
+            await self.proxy.start()
+        finally:
+            self._ready.set()
+        while not self._shutdown_requested.is_set():
+            await asyncio.sleep(0.1)
+        await self.proxy.stop()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="HTTP interception proxy with a terminal UI.")
+    parser.add_argument("--listen-host", default="127.0.0.1", help="Host interface to bind the proxy to.")
+    parser.add_argument("--listen-port", default=8080, type=int, help="Port to bind the proxy to.")
+    parser.add_argument(
+        "--project",
+        type=Path,
+        help="Project file used to load and autosave captured traffic.",
+    )
+    parser.add_argument(
+        "--plugin-dir",
+        type=Path,
+        action="append",
+        default=[],
+        help="Directory that contains HexProxy extension plugins.",
+    )
+    parser.add_argument(
+        "--cert-dir",
+        type=Path,
+        default=default_certificate_dir(),
+        help="Directory used to store the generated local CA and leaf certificates.",
+    )
+    parser.add_argument(
+        "--config-file",
+        type=Path,
+        help="Global configuration file used for persistent application preferences.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if ProxyTUI is None:
+        if sys.platform.startswith("win"):
+            print(
+                "hexproxy: terminal UI is unavailable. Install the Windows TUI dependency with "
+                "`pip install windows-curses` and try again.",
+                file=sys.stderr,
+            )
+        else:
+            print(f"hexproxy: failed to import curses support: {_TUI_IMPORT_ERROR}", file=sys.stderr)
+        return 1
+    store = TrafficStore()
+    preferences = ApplicationPreferences(args.config_file)
+    try:
+        preferences.load()
+    except Exception as exc:
+        print(f"hexproxy: failed to load config: {exc}", file=sys.stderr)
+    plugin_manager = PluginManager()
+    plugin_dirs = [Path("plugins"), *args.plugin_dir]
+    plugin_manager.load_from_dirs(plugin_dirs)
+    theme_manager = ThemeManager()
+    theme_manager.load()
+    certificate_authority = CertificateAuthority(args.cert_dir)
+    if args.project is not None:
+        if args.project.exists():
+            store.load(args.project)
+        else:
+            store.set_project_path(args.project)
+            store.save()
+    proxy = HttpProxyServer(
+        store=store,
+        listen_host=args.listen_host,
+        listen_port=args.listen_port,
+        plugins=plugin_manager,
+        certificate_authority=certificate_authority,
+    )
+    plugin_manager.bind_runtime(
+        store=store,
+        preferences=preferences,
+        theme_manager=theme_manager,
+    )
+    runtime = ProxyRuntime(proxy)
+    try:
+        runtime.start()
+    except Exception as exc:
+        print(f"hexproxy: {exc}", file=sys.stderr)
+        return 1
+
+    tui = ProxyTUI(
+        store=store,
+        listen_host=proxy.listen_host,
+        listen_port=proxy.listen_port,
+        certificate_authority=certificate_authority,
+        plugin_manager=plugin_manager,
+        theme_manager=theme_manager,
+        repeater_sender=lambda raw_request: runtime.run_coroutine(proxy.replay_request(raw_request)),
+        initial_keybindings=preferences.keybindings(),
+        keybinding_saver=lambda bindings: (preferences.set_keybindings(bindings), preferences.save()),
+        initial_theme_name=preferences.theme_name(),
+        theme_saver=lambda theme_name: (preferences.set_theme_name(theme_name), preferences.save()),
+    )
+    if proxy.startup_notice:
+        tui._set_status(proxy.startup_notice)
+    try:
+        tui.run()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        try:
+            runtime.stop()
+        except KeyboardInterrupt:
+            pass
+        try:
+            preferences.set_keybindings(tui.custom_keybindings())
+            preferences.set_theme_name(tui.theme_name())
+            preferences.save()
+            if args.project is not None:
+                store.save()
+        except KeyboardInterrupt:
+            pass
+    return 0

hexproxy/bodyview.py

@@ -0,0 +1,435 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import gzip
+import json
+import re
+import zlib
+from urllib.parse import parse_qsl
+from xml.dom import minidom
+
+from .models import HeaderList
+
+try:
+    import brotli  # type: ignore
+except ImportError:
+    brotli = None
+
+
+@dataclass(slots=True)
+class BodyDocument:
+    media_type: str
+    kind: str
+    display_name: str
+    raw_text: str
+    pretty_text: str | None
+    pretty_available: bool
+    is_binary: bool
+    encoding_summary: str
+
+
+def build_body_document(headers: HeaderList, body: bytes) -> BodyDocument:
+    if not body:
+        return BodyDocument(
+            media_type="-",
+            kind="empty",
+            display_name="Empty",
+            raw_text="No body.",
+            pretty_text=None,
+            pretty_available=False,
+            is_binary=False,
+            encoding_summary="identity",
+        )
+
+    media_type = _extract_media_type(headers)
+    charset = _extract_charset(headers)
+    transfer_encodings = _extract_transfer_encodings(headers)
+    content_encodings = _extract_content_encodings(headers)
+    normalized_body, encoding_summary, fully_decoded = _normalize_body(body, transfer_encodings, content_encodings)
+    kind = _detect_kind(media_type, normalized_body if fully_decoded else b"")
+    display_name = _display_name(kind, media_type)
+
+    if not fully_decoded and content_encodings:
+        raw_text = _hexdump(body)
+        return BodyDocument(
+            media_type=media_type or "application/octet-stream",
+            kind="binary",
+            display_name=f"{display_name} (encoded)",
+            raw_text=raw_text,
+            pretty_text=None,
+            pretty_available=False,
+            is_binary=True,
+            encoding_summary=encoding_summary,
+        )
+
+    if kind == "binary":
+        raw_text = _hexdump(normalized_body)
+        return BodyDocument(
+            media_type=media_type or "application/octet-stream",
+            kind=kind,
+            display_name=display_name,
+            raw_text=raw_text,
+            pretty_text=None,
+            pretty_available=False,
+            is_binary=True,
+            encoding_summary=encoding_summary,
+        )
+
+    text = _decode_body(normalized_body, charset)
+    pretty_text = _pretty_text(kind, text)
+    return BodyDocument(
+        media_type=media_type or "text/plain",
+        kind=kind,
+        display_name=display_name,
+        raw_text=text,
+        pretty_text=pretty_text,
+        pretty_available=pretty_text is not None and pretty_text != text,
+        is_binary=False,
+        encoding_summary=encoding_summary,
+    )
+
+
+def normalize_http_body(headers: HeaderList, body: bytes) -> tuple[bytes, str, bool]:
+    transfer_encodings = _extract_transfer_encodings(headers)
+    content_encodings = _extract_content_encodings(headers)
+    return _normalize_body(body, transfer_encodings, content_encodings)
+
+
+def _extract_media_type(headers: HeaderList) -> str:
+    for name, value in headers:
+        if name.lower() != "content-type":
+            continue
+        return value.split(";", 1)[0].strip().lower()
+    return ""
+
+
+def _extract_charset(headers: HeaderList) -> str | None:
+    for name, value in headers:
+        if name.lower() != "content-type":
+            continue
+        for part in value.split(";")[1:]:
+            key, _, raw_value = part.partition("=")
+            if key.strip().lower() == "charset" and raw_value.strip():
+                return raw_value.strip().strip('"').strip("'")
+    return None
+
+
+def _extract_transfer_encodings(headers: HeaderList) -> list[str]:
+    for name, value in headers:
+        if name.lower() != "transfer-encoding":
+            continue
+        return [item.strip().lower() for item in value.split(",") if item.strip()]
+    return []
+
+
+def _extract_content_encodings(headers: HeaderList) -> list[str]:
+    for name, value in headers:
+        if name.lower() != "content-encoding":
+            continue
+        return [item.strip().lower() for item in value.split(",") if item.strip()]
+    return []
+
+
+def _detect_kind(media_type: str, body: bytes) -> str:
+    if media_type in {"application/json", "text/json"} or media_type.endswith("+json"):
+        return "json"
+    if media_type in {"application/xml", "text/xml"} or media_type.endswith("+xml"):
+        return "xml"
+    if media_type == "text/html":
+        return "html"
+    if media_type == "application/x-www-form-urlencoded":
+        return "form"
+    if media_type in {"application/javascript", "text/javascript"}:
+        return "javascript"
+    if media_type == "text/css":
+        return "css"
+    if media_type.startswith("text/"):
+        return "text"
+
+    sample = body[:512].lstrip()
+    if sample.startswith((b"{", b"[")):
+        return "json"
+    if sample.startswith((b"<?xml", b"<")):
+        lowered = sample.lower()
+        if lowered.startswith((b"<!doctype html", b"<html")):
+            return "html"
+        return "xml"
+    if _looks_like_text(body):
+        return "text"
+    return "binary"
+
+
+def _display_name(kind: str, media_type: str) -> str:
+    mapping = {
+        "empty": "Empty",
+        "json": "JSON",
+        "xml": "XML",
+        "html": "HTML",
+        "form": "Form URL Encoded",
+        "javascript": "JavaScript",
+        "css": "CSS",
+        "text": "Text",
+        "binary": "Binary",
+    }
+    return mapping.get(kind, media_type or "Unknown")
+
+
+def _decode_body(body: bytes, charset: str | None) -> str:
+    if charset:
+        try:
+            return body.decode(charset, errors="replace")
+        except LookupError:
+            pass
+    try:
+        return body.decode("utf-8")
+    except UnicodeDecodeError:
+        return body.decode("iso-8859-1", errors="replace")
+
+
+def _normalize_body(body: bytes, transfer_encodings: list[str], content_encodings: list[str]) -> tuple[bytes, str, bool]:
+    normalized = body
+    notes: list[str] = []
+    fully_decoded = True
+
+    if "chunked" in transfer_encodings:
+        try:
+            normalized = _decode_chunked_body(normalized)
+            notes.append("chunked decoded")
+        except Exception:
+            notes.append("chunked undecoded")
+            fully_decoded = False
+
+    for encoding in reversed(content_encodings):
+        try:
+            normalized = _decode_content_encoding(normalized, encoding)
+            notes.append(f"{encoding} decoded")
+        except Exception:
+            notes.append(f"{encoding} unsupported")
+            fully_decoded = False
+            break
+
+    if not notes:
+        notes.append("identity")
+    return normalized, ", ".join(notes), fully_decoded
+
+
+def _decode_content_encoding(body: bytes, encoding: str) -> bytes:
+    if encoding in {"gzip", "x-gzip"}:
+        return gzip.decompress(body)
+    if encoding == "deflate":
+        try:
+            return zlib.decompress(body)
+        except zlib.error:
+            return zlib.decompress(body, -zlib.MAX_WBITS)
+    if encoding == "br":
+        if brotli is None:
+            raise ValueError("brotli dependency is not installed")
+        return brotli.decompress(body)
+    if encoding in {"identity", ""}:
+        return body
+    raise ValueError(f"unsupported content encoding: {encoding}")
+
+
+def _decode_chunked_body(body: bytes) -> bytes:
+    decoded = bytearray()
+    index = 0
+    total = len(body)
+
+    while True:
+        line_end = body.find(b"\r\n", index)
+        if line_end < 0:
+            raise ValueError("invalid chunked body: missing chunk size delimiter")
+        size_line = body[index:line_end]
+        chunk_size = int(size_line.split(b";", 1)[0].strip(), 16)
+        index = line_end + 2
+        if chunk_size == 0:
+            trailer_end = body.find(b"\r\n", index)
+            if trailer_end < 0:
+                raise ValueError("invalid chunked body: missing chunk trailer terminator")
+            break
+        if index + chunk_size + 2 > total:
+            raise ValueError("invalid chunked body: truncated chunk")
+        decoded.extend(body[index : index + chunk_size])
+        index += chunk_size
+        if body[index : index + 2] != b"\r\n":
+            raise ValueError("invalid chunked body: missing chunk terminator")
+        index += 2
+    return bytes(decoded)
+
+
+def _pretty_text(kind: str, text: str) -> str | None:
+    try:
+        if kind == "json":
+            return json.dumps(json.loads(text), indent=2, ensure_ascii=False)
+        if kind == "xml":
+            parsed = minidom.parseString(text.encode("utf-8"))
+            return parsed.toprettyxml(indent="  ")
+        if kind == "html":
+            return _pretty_html(text)
+        if kind == "javascript":
+            return _pretty_javascript(text)
+        if kind == "css":
+            return _pretty_css(text)
+        if kind == "form":
+            pairs = parse_qsl(text, keep_blank_values=True)
+            if not pairs:
+                return None
+            return "\n".join(f"{key} = {value}" for key, value in pairs)
+    except Exception:
+        return None
+    return None
+
+
+def _looks_like_text(body: bytes) -> bool:
+    sample = body[:512]
+    if not sample:
+        return True
+    allowed = 0
+    for byte in sample:
+        if byte in {9, 10, 13} or 32 <= byte <= 126:
+            allowed += 1
+    return (allowed / len(sample)) >= 0.85
+
+
+def _pretty_html(text: str) -> str | None:
+    tokens = re.findall(r"<!--.*?-->|<![^>]*>|</?[^>]+>|[^<]+", text, flags=re.DOTALL)
+    if len(tokens) <= 1:
+        return None
+
+    lines: list[str] = []
+    indent = 0
+    current_embedded_kind: str | None = None
+    void_tags = {
+        "area",
+        "base",
+        "br",
+        "col",
+        "embed",
+        "hr",
+        "img",
+        "input",
+        "link",
+        "meta",
+        "param",
+        "source",
+        "track",
+        "wbr",
+    }
+
+    for token in tokens:
+        stripped = token.strip()
+        if not stripped:
+            continue
+
+        if stripped.startswith("</"):
+            indent = max(0, indent - 1)
+            current_embedded_kind = None
+            lines.append(f"{'  ' * indent}{stripped}")
+            continue
+
+        if stripped.startswith("<"):
+            lines.append(f"{'  ' * indent}{stripped}")
+            tag_name = _html_tag_name(stripped)
+            if tag_name in {"script", "style"} and not stripped.endswith("/>"):
+                current_embedded_kind = tag_name
+            if tag_name and not stripped.endswith("/>") and tag_name not in void_tags and not stripped.startswith("<!"):
+                indent += 1
+            continue
+
+        embedded_pretty = _pretty_embedded_block(current_embedded_kind, stripped)
+        if embedded_pretty is not None:
+            for embedded_line in embedded_pretty.splitlines():
+                if embedded_line.strip():
+                    lines.append(f"{'  ' * indent}{embedded_line}")
+            continue
+
+        collapsed = " ".join(part for part in stripped.split())
+        if collapsed:
+            lines.append(f"{'  ' * indent}{collapsed}")
+
+    pretty = "\n".join(lines)
+    if pretty == text:
+        return None
+    return pretty
+
+
+def _html_tag_name(tag: str) -> str:
+    match = re.match(r"</?\s*([a-zA-Z0-9:_-]+)", tag)
+    if match is None:
+        return ""
+    return match.group(1).lower()
+
+
+def _pretty_embedded_block(kind: str | None, text: str) -> str | None:
+    if kind == "script":
+        return _pretty_javascript(text)
+    if kind == "style":
+        return _pretty_css(text)
+    return None
+
+
+def _pretty_javascript(text: str) -> str | None:
+    normalized = _pretty_braced_text(text, keep_space_before_brace=True)
+    if normalized == text:
+        return None
+    return normalized
+
+
+def _pretty_css(text: str) -> str | None:
+    normalized = _pretty_braced_text(text, keep_space_before_brace=False)
+    normalized = re.sub(r"\s*\{\s*", " {\n", normalized)
+    normalized = re.sub(r";\s*", ";\n", normalized)
+    normalized = re.sub(r"\n\s*\}", "\n}", normalized)
+    normalized = _normalize_indentation(normalized)
+    if normalized == text:
+        return None
+    return normalized
+
+
+def _pretty_braced_text(text: str, keep_space_before_brace: bool) -> str:
+    compact = re.sub(r"\s+", " ", text.strip())
+    if not compact:
+        return text
+
+    pieces: list[str] = []
+    indent = 0
+    index = 0
+    while index < len(compact):
+        character = compact[index]
+        if character == "{":
+            prefix = " {" if keep_space_before_brace and pieces and not pieces[-1].endswith((" ", "\n")) else "{"
+            if keep_space_before_brace and pieces and pieces[-1].endswith(" "):
+                pieces[-1] = pieces[-1].rstrip()
+            pieces.append(prefix)
+            indent += 1
+            pieces.append("\n" + "  " * indent)
+        elif character == "}":
+            indent = max(0, indent - 1)
+            pieces.append("\n" + "  " * indent + "}")
+            if index + 1 < len(compact) and compact[index + 1] not in ";,)}":
+                pieces.append("\n" + "  " * indent)
+        elif character == ";":
+            pieces.append(";")
+            if index + 1 < len(compact):
+                pieces.append("\n" + "  " * indent)
+        else:
+            pieces.append(character)
+        index += 1
+
+    return _normalize_indentation("".join(pieces))
+
+
+def _normalize_indentation(text: str) -> str:
+    lines = [line.rstrip() for line in text.splitlines()]
+    compact_lines = [line for line in lines if line.strip()]
+    return "\n".join(compact_lines)
+
+
+def _hexdump(body: bytes, chunk_size: int = 16) -> str:
+    lines: list[str] = []
+    for offset in range(0, len(body), chunk_size):
+        chunk = body[offset : offset + chunk_size]
+        hex_part = " ".join(f"{byte:02x}" for byte in chunk)
+        ascii_part = "".join(chr(byte) if 32 <= byte <= 126 else "." for byte in chunk)
+        lines.append(f"{offset:08x}  {hex_part:<47}  {ascii_part}")
+    return "\n".join(lines)