pentool 1.0.0__py3-none-any.whl

pentool/api/proxy_api.py

@@ -0,0 +1,319 @@
+"""Публичный API прокси-модуля для TUI и CLI."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from pentool.modules.proxy import InterceptedRequest, MatchReplaceRule, ProxyServer
+from pentool.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+# Реэкспорт типов — TUI импортирует их отсюда, не из modules.proxy
+__all__ = ["ProxyAPI", "InterceptedRequest", "MatchReplaceRule", "ProxyServer"]
+
+
+class ProxyAPI:
+    """Публичный интерфейс прокси-модуля.
+
+    Тонкая обёртка над ProxyServer. Не знает о Textual.
+    ProxyServer инжектируется через set_proxy() после создания.
+    """
+
+    def __init__(self) -> None:
+        self._proxy: ProxyServer | None = None
+
+    def set_proxy(self, proxy: ProxyServer) -> None:
+        """Инжектировать экземпляр ProxyServer.
+
+        Args:
+            proxy: Запущенный экземпляр ProxyServer.
+
+        Returns:
+            None
+        """
+        logger.debug("ProxyAPI: set_proxy called, proxy=%s", proxy)
+        self._proxy = proxy
+
+    def get_proxy(self) -> ProxyServer | None:
+        """Вернуть внутренний ProxyServer (для обратной совместимости).
+
+        Returns:
+            ProxyServer или None.
+        """
+        return self._proxy
+
+    @property
+    def proxy(self) -> ProxyServer | None:
+        """Легитимный доступ к ProxyServer через API-слой.
+
+        Используется там где нужен прямой доступ к серверу
+        (proxy/screen.py для intercept, repeater/screen.py для scope).
+        """
+        return self._proxy
+
+    def create_proxy(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 8080,
+        cert_dir: str = "/tmp/pentool_certs",
+        db_path: str | None = None,
+    ) -> ProxyServer:
+        """Создать и инжектировать экземпляр ProxyServer.
+
+        Args:
+            host: Хост для прослушивания.
+            port: Порт прокси.
+            cert_dir: Директория для CA-сертификатов.
+            db_path: Путь к SQLite БД (опционально).
+
+        Returns:
+            ProxyServer: Созданный экземпляр (не запущен).
+        """
+        proxy = ProxyServer(host=host, port=port, cert_dir=cert_dir, db_path=db_path)
+        self._proxy = proxy
+        return proxy
+
+    def is_running(self) -> bool:
+        """Вернуть True если прокси запущен.
+
+        Returns:
+            bool: Состояние прокси.
+        """
+        return bool(self._proxy and self._proxy.is_running)
+
+    def get_port(self) -> int:
+        """Вернуть порт прокси.
+
+        Returns:
+            int: Номер порта (8080 по умолчанию если прокси не задан).
+        """
+        if self._proxy:
+            return self._proxy.port
+        return 8080
+
+    def get_host(self) -> str:
+        """Вернуть хост прокси.
+
+        Returns:
+            str: Хост (127.0.0.1 по умолчанию).
+        """
+        if self._proxy:
+            return self._proxy.host
+        return "127.0.0.1"
+
+    def get_status(self) -> dict:
+        """Вернуть словарь состояния прокси.
+
+        Returns:
+            dict: Ключи: running, host, port, intercept_enabled, scope,
+                  requests_count, rules_count, waiting_count.
+        """
+        if self._proxy is None:
+            return {
+                "running": False,
+                "host": "127.0.0.1",
+                "port": 8080,
+                "intercept_enabled": False,
+                "scope": [],
+                "rules_count": 0,
+                "requests_count": 0,
+                "waiting_count": 0,
+            }
+        return self._proxy.get_status()
+
+    def get_requests(
+        self,
+        limit: int = 100,
+        method: str | None = None,
+        host: str | None = None,
+    ) -> list[InterceptedRequest]:
+        """Вернуть список перехваченных запросов.
+
+        Args:
+            limit: Максимальное количество записей.
+            method: Фильтр по HTTP-методу (регистронезависимо).
+            host: Фильтр по хосту (подстрока, регистронезависимо).
+
+        Returns:
+            list[InterceptedRequest]: Список от новых к старым.
+        """
+        if self._proxy is None:
+            return []
+        return self._proxy.get_requests(limit=limit, method=method, host=host)
+
+    def find_request(self, req_id: str) -> InterceptedRequest | None:
+        """Найти запрос по ID.
+
+        Args:
+            req_id: UUID запроса (полный или частичный).
+
+        Returns:
+            InterceptedRequest или None.
+        """
+        if self._proxy is None:
+            return None
+        return self._proxy._find_request(req_id)
+
+    def clear_requests(self) -> None:
+        """Очистить историю запросов в памяти.
+
+        Returns:
+            None
+        """
+        if self._proxy:
+            self._proxy.clear_requests()
+
+    def forward(self, req_id: str, modified_raw: str | None = None) -> None:
+        """Переслать ожидающий запрос на целевой сервер.
+
+        Args:
+            req_id: ID перехваченного запроса.
+            modified_raw: Изменённый сырой HTTP-текст (опционально).
+
+        Returns:
+            None
+
+        Raises:
+            RuntimeError: Если прокси не инициализирован.
+        """
+        if self._proxy is None:
+            raise RuntimeError("ProxyAPI: прокси не инициализирован")
+        logger.debug("ProxyAPI: forward req_id=%s, has_modified=%s", req_id, bool(modified_raw))
+        self._proxy.forward(req_id, modified_raw)
+
+    def drop(self, req_id: str) -> None:
+        """Сбросить ожидающий запрос (вернуть браузеру 502).
+
+        Args:
+            req_id: ID перехваченного запроса.
+
+        Returns:
+            None
+
+        Raises:
+            RuntimeError: Если прокси не инициализирован.
+        """
+        if self._proxy is None:
+            raise RuntimeError("ProxyAPI: прокси не инициализирован")
+        logger.debug("ProxyAPI: drop req_id=%s", req_id)
+        self._proxy.drop(req_id)
+
+    def set_intercept(self, enabled: bool) -> None:
+        """Включить или выключить режим перехвата (thread-safe).
+
+        Args:
+            enabled: True — включить, False — выключить.
+
+        Returns:
+            None
+        """
+        if self._proxy:
+            # ProxyServer.set_intercept() использует call_soon_threadsafe —
+            # обязательно для безопасного изменения флага из TUI-треда,
+            # пока proxy-loop работает в своём asyncio-треде.
+            self._proxy.set_intercept(enabled)
+
+    def get_intercept(self) -> bool:
+        """Вернуть текущее состояние режима перехвата.
+
+        Returns:
+            bool: True если перехват включён.
+        """
+        return bool(self._proxy and self._proxy.intercept_enabled)
+
+    def set_scope(self, hosts: list[str]) -> None:
+        """Установить список хостов в scope.
+
+        Args:
+            hosts: Список паттернов хостов (поддерживается *.example.com).
+
+        Returns:
+            None
+        """
+        if self._proxy:
+            self._proxy.set_scope(hosts)
+
+    def get_scope(self) -> list[str]:
+        """Вернуть текущий список scope.
+
+        Returns:
+            list[str]: Активные паттерны хостов.
+        """
+        if self._proxy:
+            return list(self._proxy.scope)
+        return []
+
+    def get_match_replace_rules(self) -> list[MatchReplaceRule]:
+        """Вернуть список правил match/replace.
+
+        Returns:
+            list[MatchReplaceRule]: Копия текущих правил.
+        """
+        if self._proxy:
+            return list(self._proxy.match_replace_rules)
+        return []
+
+    def set_match_replace_rules(self, rules: list[MatchReplaceRule]) -> None:
+        """Заменить все правила match/replace.
+
+        Args:
+            rules: Новый список правил MatchReplaceRule.
+
+        Returns:
+            None
+        """
+        if self._proxy:
+            self._proxy.match_replace_rules = rules
+
+    def export_project_data(self) -> dict:
+        """Экспортировать данные прокси в сериализуемый dict для сохранения.
+
+        Returns:
+            dict: Ключи proxy (scope, match_replace) и http_history.
+        """
+        if self._proxy is None:
+            return {"proxy": {"scope": [], "match_replace": []}, "http_history": []}
+
+        return {
+            "proxy": {
+                "scope": list(self._proxy.scope),
+                "match_replace": [r.to_dict() for r in self._proxy.match_replace_rules],
+            },
+            "http_history": [r.to_dict() for r in self._proxy.get_requests(limit=10000)],
+        }
+
+    def import_project_data(self, data: dict) -> tuple[int, str]:
+        """Импортировать данные из загруженного dict проекта.
+
+        Args:
+            data: Словарь, возвращённый core.project.load_project().
+
+        Returns:
+            (count, error) — количество загруженных запросов, пустая строка если OK.
+        """
+        if self._proxy is None:
+            return 0, "Proxy not initialized"
+
+        from pentool.utils.parser import ParsedResponse
+        from datetime import datetime, timezone
+
+        # Scope
+        self._proxy.scope = data.get("proxy", {}).get("scope", [])
+
+        # Match/Replace
+        mr_data = data.get("proxy", {}).get("match_replace", [])
+        self._proxy.match_replace_rules = [MatchReplaceRule.from_dict(r) for r in mr_data]
+
+        # HTTP History
+        self._proxy.requests.clear()
+        loaded = 0
+        for req_data in data.get("http_history", []):
+            try:
+                req = InterceptedRequest.from_dict(req_data)
+                self._proxy.requests.append(req)
+                loaded += 1
+            except Exception as e:
+                logger.warning("import_project_data: failed to restore request: %s", e)
+
+        return loaded, ""

pentool/api/repeater_api.py

@@ -0,0 +1,118 @@
+"""Публичный API repeater-модуля для TUI и CLI."""
+
+from __future__ import annotations
+
+
+
+from pentool.modules.repeater import Repeater, RepeaterEntry
+from pentool.utils.parser import ParsedRequest, ParsedResponse
+
+# Реэкспорт типов
+__all__ = ["RepeaterAPI", "RepeaterEntry"]
+
+
+class RepeaterAPI:
+    """Публичный интерфейс repeater-модуля.
+
+    Тонкая асинхронная обёртка над Repeater.
+    Не знает о Textual.
+    """
+
+    def __init__(
+        self,
+        db_path: str,
+        project_id: int | None = None,
+        timeout: float = 30.0,
+        verify_ssl: bool = False,
+    ) -> None:
+        """Инициализировать RepeaterAPI.
+
+        Args:
+            db_path: Путь к SQLite-базе данных.
+            project_id: ID активного проекта (None — без фильтра).
+            timeout: Таймаут HTTP-запроса в секундах.
+            verify_ssl: Проверять ли SSL-сертификат сервера.
+        """
+        self._repeater = Repeater(
+            db_path=db_path,
+            project_id=project_id,
+            timeout=timeout,
+            verify_ssl=verify_ssl,
+        )
+
+    async def send(
+        self,
+        request: ParsedRequest,
+        tab_name: str = "Tab",
+        save: bool = True,
+    ) -> ParsedResponse:
+        """Отправить HTTP-запрос и опционально сохранить в историю.
+
+        Args:
+            request: Запрос для отправки (ParsedRequest).
+            tab_name: Метка для записи в историю.
+            save: Если True — сохранить в БД.
+
+        Returns:
+            ParsedResponse: Ответ сервера.
+
+        Raises:
+            Exception: Любая сетевая ошибка или ошибка парсинга из HTTPClient.
+        """
+        return await self._repeater.send(request, tab_name=tab_name, save=save)
+
+    async def save_to_history(
+        self,
+        request: ParsedRequest,
+        response: ParsedResponse,
+        tab_name: str = "Tab",
+    ) -> int:
+        """Сохранить пару запрос/ответ в таблицу repeater_entries.
+
+        Args:
+            request: Отправленный запрос.
+            response: Полученный ответ.
+            tab_name: Метка записи.
+
+        Returns:
+            int: ID созданной записи в БД.
+        """
+        return await self._repeater.save_to_history(request, response, tab_name)
+
+    async def get_history(
+        self,
+        limit: int = 50,
+        project_id: int | None = None,
+    ) -> list[RepeaterEntry]:
+        """Получить историю Repeater из БД.
+
+        Args:
+            limit: Максимальное количество записей.
+            project_id: Фильтр по проекту (None = использовать project_id экземпляра или все).
+
+        Returns:
+            list[RepeaterEntry]: Список от новых к старым.
+        """
+        return await self._repeater.get_history(limit=limit, project_id=project_id)
+
+    async def get_entry(self, entry_id: int) -> RepeaterEntry | None:
+        """Получить одну запись истории по ID.
+
+        Args:
+            entry_id: ID записи в БД.
+
+        Returns:
+            RepeaterEntry или None если не найдена.
+        """
+        return await self._repeater.get_entry(entry_id)
+
+    async def delete_entry(self, entry_id: int) -> None:
+        """Удалить запись из истории.
+
+        Args:
+            entry_id: ID записи в БД.
+
+        Returns:
+            None
+        """
+        return await self._repeater.delete_entry(entry_id)