pentool 0.1.0__py3-none-any.whl

pentool/__init__.py

@@ -0,0 +1,4 @@
+"""Pentool — консольный аналог Burp Suite с TUI на Textual."""
+
+__version__ = "0.1.0"
+__author__ = "pentool"

pentool/__main__.py

@@ -0,0 +1,16 @@
+"""Точка входа: без аргументов — TUI, с аргументами — CLI."""
+
+import sys
+
+
+def main() -> None:
+    if len(sys.argv) > 1:
+        from pentool.cli.main import cli
+        cli()
+    else:
+        from pentool.tui.app import PentoolApp
+        PentoolApp().run()
+
+
+if __name__ == "__main__":
+    main()

pentool/api/__init__.py

@@ -0,0 +1,41 @@
+"""API-слой pentool — публичный интерфейс между modules/ и TUI/CLI."""
+
+from pentool.api.proxy_api     import ProxyAPI, InterceptedRequest, MatchReplaceRule
+from pentool.api.repeater_api  import RepeaterAPI
+from pentool.api.scanner_api   import ScannerAPI
+from pentool.api.intruder_api  import IntruderAPI, IntruderConfig, IntruderAttack
+from pentool.api.spider_api    import SpiderAPI
+from pentool.api.target_api    import TargetAPI
+# Decoder/Comparer/Sequencer — функциональные API без класса-обёртки
+from pentool.api.decoder_api   import (  # noqa: F401
+    OPERATIONS, OP_LABELS, DecoderChain,
+    decode_op, decode_smart, encode_op, run_chain,
+)
+from pentool.api.comparer_api  import (  # noqa: F401
+    compare, compare_lines, CompareStats, DiffLine, DiffResult,
+)
+from pentool.api.sequencer_api import (  # noqa: F401
+    Sequencer, SequencerReport, token_entropy, charset_size,
+)
+
+__all__ = [
+    # Proxy
+    "ProxyAPI", "InterceptedRequest", "MatchReplaceRule",
+    # Repeater
+    "RepeaterAPI",
+    # Scanner
+    "ScannerAPI",
+    # Intruder
+    "IntruderAPI", "IntruderConfig", "IntruderAttack",
+    # Spider
+    "SpiderAPI",
+    # Target
+    "TargetAPI",
+    # Decoder
+    "OPERATIONS", "OP_LABELS", "DecoderChain",
+    "decode_op", "decode_smart", "encode_op", "run_chain",
+    # Comparer
+    "compare", "compare_lines", "CompareStats", "DiffLine", "DiffResult",
+    # Sequencer
+    "Sequencer", "SequencerReport", "token_entropy", "charset_size",
+]

pentool/api/base_api.py

@@ -0,0 +1,48 @@
+"""ExportableAPI — base mixin for API classes supporting project persistence."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class ExportableAPI(ABC):
+    """Mixin for API classes that support project data export/import.
+
+    Subclasses must implement export_project_data and import_project_data.
+    These methods are called by core.project.save_project/load_project.
+
+    Usage::
+
+        class MyAPI(ExportableAPI):
+            def export_project_data(self) -> dict:
+                return {"my_data": [...]}
+
+            def import_project_data(self, data: dict) -> int:
+                items = data.get("my_data", [])
+                # restore items
+                return len(items)
+    """
+
+    @abstractmethod
+    def export_project_data(self) -> dict:
+        """Export module state to a serializable dict.
+
+        Returns:
+            dict: Module-specific data structure (e.g., {"results": [...]}).
+                  Must be JSON-serializable (no datetime, use .isoformat()).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def import_project_data(self, data: dict) -> int | tuple[int, str]:
+        """Import module state from a loaded project dict.
+
+        Args:
+            data: The module's block from project.json (e.g., data["intruder"]).
+
+        Returns:
+            int: Number of items loaded successfully.
+            OR
+            tuple[int, str]: (count, error_message) — empty string if OK.
+        """
+        raise NotImplementedError

pentool/api/comparer_api.py

@@ -0,0 +1,19 @@
+"""ComparerAPI — публичный интерфейс Comparer для TUI."""
+
+from __future__ import annotations
+
+from pentool.modules.comparer import (  # noqa: F401
+    compare,
+    compare_lines,
+    CompareStats,
+    DiffLine,
+    DiffResult,
+)
+
+__all__ = [
+    "compare",
+    "compare_lines",
+    "CompareStats",
+    "DiffLine",
+    "DiffResult",
+]

pentool/api/decoder_api.py

@@ -0,0 +1,24 @@
+"""DecoderAPI — публичный интерфейс Decoder/Encoder для TUI."""
+
+from __future__ import annotations
+
+# Реэкспорт всего публичного из modules/decoder
+from pentool.modules.decoder import (  # noqa: F401
+    OPERATIONS,
+    OP_LABELS,
+    DecoderChain,
+    decode_op,
+    decode_smart,
+    encode_op,
+    run_chain,
+)
+
+__all__ = [
+    "OPERATIONS",
+    "OP_LABELS",
+    "DecoderChain",
+    "decode_op",
+    "decode_smart",
+    "encode_op",
+    "run_chain",
+]

pentool/api/intruder_api.py

@@ -0,0 +1,171 @@
+"""Публичный API Intruder-модуля для TUI и CLI."""
+
+from __future__ import annotations
+
+
+
+from pentool.modules.intruder import (
+    AttackType,
+    IntruderAttack,
+    IntruderConfig,
+    IntruderResult,
+    count_markers,
+    extract_marker_defaults,
+    generate_char_payloads,
+    generate_numeric_payloads,
+    load_payloads_from_file,
+    process_payload,
+)
+
+__all__ = [
+    "IntruderAPI",
+    "AttackType",
+    "IntruderAttack",
+    "IntruderConfig",
+    "IntruderResult",
+    "count_markers",
+    "extract_marker_defaults",
+    "generate_char_payloads",
+    "generate_numeric_payloads",
+    "load_payloads_from_file",
+    "process_payload",
+]
+
+
+class IntruderAPI:
+
+    def __init__(self, db_path: str | None = None) -> None:
+        self._db_path = db_path
+        self._attack: IntruderAttack | None = None
+
+    async def start_attack(
+        self,
+        config: IntruderConfig,
+        on_result=None,
+        on_progress=None,
+        turbo_mode: bool = False,
+    ) -> str:
+        if turbo_mode:
+            # Turbo Mode: connection pooling + Keep-Alive
+            from pentool.modules.intruder_turbo import TurboIntruderAttack
+            self._attack = TurboIntruderAttack(config)
+        else:
+            # Обычный режим
+            self._attack = IntruderAttack(config, db_path=self._db_path)
+
+        _on_result = on_result if on_result else lambda r: None
+        _on_progress = on_progress if on_progress else lambda d, t: None
+
+        import asyncio
+        asyncio.create_task(self._attack.run(_on_result, _on_progress))
+        return self._attack.attack_id if hasattr(self._attack, 'attack_id') else "turbo"
+
+    async def pause(self) -> None:
+        if self._attack:
+            await self._attack.pause()
+
+    async def resume(self) -> None:
+        """Возобновить атаку после паузы."""
+        if self._attack:
+            await self._attack.resume()
+
+    async def stop(self) -> None:
+        if self._attack:
+            await self._attack.stop()
+
+    def get_results(self) -> list[IntruderResult]:
+        if self._attack:
+            # Turbo mode использует get_results(), обычный - results property
+            if hasattr(self._attack, 'get_results'):
+                return self._attack.get_results()
+            return self._attack.results
+        return []
+
+    def get_progress(self) -> tuple[int, int]:
+        if self._attack:
+            return self._attack.progress
+        return (0, 0)
+
+    @property
+    def is_running(self) -> bool:
+        return bool(self._attack and self._attack.is_running)
+
+    async def load_payloads(self, path: str) -> list[str]:
+        return load_payloads_from_file(path)
+
+    async def generate_numeric(self, start: int, end: int, step: int = 1) -> list[str]:
+        return generate_numeric_payloads(start, end, step)
+
+    async def generate_chars(
+        self, charset: str, min_len: int, max_len: int
+    ) -> list[str]:
+        return generate_char_payloads(charset, min_len, max_len)
+
+    def export_csv(self, path: str) -> None:
+        if self._attack:
+            self._attack.export_csv(path)
+
+    # ── Project persistence ────────────────────────────────────────────────────
+
+    def export_project_data(self) -> dict:
+        results = self.get_results()
+        return {
+            "results": [
+                {
+                    "id": r.id,
+                    "attack_id": r.attack_id,
+                    "request_number": r.request_number,
+                    "payload_values": r.payload_values,
+                    "request_raw": r.request_raw,
+                    "response_status": r.response_status,
+                    "response_length": r.response_length,
+                    "response_time_ms": r.response_time_ms,
+                    "error": r.error,
+                    "timestamp": r.timestamp.isoformat(),
+                }
+                for r in results
+            ]
+        }
+
+    def import_project_data(self, data: dict) -> int:
+        from datetime import datetime, timezone
+        from pentool.modules.intruder import IntruderResult
+
+        results_data = data.get("results", [])
+        # Создаём фиктивный attack для хранения результатов
+        # без реального запуска атаки
+        if self._attack is None:
+            # Ленивая инициализация — просто храним в атрибуте
+            self._restored_results: list[IntruderResult] = []
+        else:
+            self._restored_results = []
+
+        loaded = 0
+        for rd in results_data:
+            try:
+                ts_raw = rd.get("timestamp", "")
+                try:
+                    ts = datetime.fromisoformat(ts_raw)
+                except Exception:
+                    ts = datetime.now(timezone.utc)
+                result = IntruderResult(
+                    id=rd.get("id", ""),
+                    attack_id=rd.get("attack_id", ""),
+                    request_number=rd.get("request_number", 0),
+                    payload_values=rd.get("payload_values", []),
+                    request_raw=rd.get("request_raw", ""),
+                    response_status=rd.get("response_status"),
+                    response_length=rd.get("response_length"),
+                    response_time_ms=rd.get("response_time_ms"),
+                    error=rd.get("error"),
+                    timestamp=ts,
+                )
+                if hasattr(self, "_restored_results"):
+                    self._restored_results.append(result)
+                loaded += 1
+            except Exception as exc:
+                from pentool.core.logging import get_logger
+                get_logger(__name__).warning(
+                    "IntruderAPI.import_project_data: skip result: %s", exc
+                )
+        return loaded

pentool/api/proxy_api.py

@@ -0,0 +1,210 @@
+"""Публичный 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:
+
+    def __init__(self) -> None:
+        self._proxy: ProxyServer | None = None
+
+    def set_proxy(self, proxy: ProxyServer) -> None:
+        logger.debug("ProxyAPI: set_proxy called, proxy=%s", proxy)
+        self._proxy = proxy
+
+    def get_proxy(self) -> 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:
+        proxy = ProxyServer(host=host, port=port, cert_dir=cert_dir, db_path=db_path)
+        self._proxy = proxy
+        return proxy
+
+    def is_running(self) -> bool:
+        return bool(self._proxy and self._proxy.is_running)
+
+    def get_port(self) -> int:
+        if self._proxy:
+            return self._proxy.port
+        return 8080
+
+    def get_host(self) -> str:
+        if self._proxy:
+            return self._proxy.host
+        return "127.0.0.1"
+
+    def get_status(self) -> dict:
+        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]:
+        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:
+        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:
+        if self._proxy:
+            # ProxyServer.set_intercept() использует call_soon_threadsafe —
+            # обязательно для безопасного изменения флага из TUI-треда,
+            # пока proxy-loop работает в своём asyncio-треде.
+            self._proxy.set_intercept(enabled)
+
+    def get_intercept(self) -> bool:
+        return bool(self._proxy and self._proxy.intercept_enabled)
+
+    def set_scope(self, hosts: list[str]) -> None:
+        if self._proxy:
+            self._proxy.set_scope(hosts)
+
+    def get_scope(self) -> list[str]:
+        if self._proxy:
+            return list(self._proxy.scope)
+        return []
+
+    def get_match_replace_rules(self) -> 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:
+        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]:
+        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,57 @@
+"""Публичный 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:
+
+    def __init__(
+        self,
+        db_path: str,
+        project_id: int | None = None,
+        timeout: float = 30.0,
+        verify_ssl: bool = False,
+    ) -> None:
+        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:
+        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:
+        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]:
+        return await self._repeater.get_history(limit=limit, project_id=project_id)
+
+    async def get_entry(self, entry_id: int) -> RepeaterEntry | None:
+        return await self._repeater.get_entry(entry_id)
+
+    async def delete_entry(self, entry_id: int) -> None:
+        return await self._repeater.delete_entry(entry_id)