pentool 1.0.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,17 @@
+"""Точка входа: без аргументов — TUI, с аргументами — CLI."""
+
+import sys
+
+
+def main() -> None:
+    """Запустить TUI или CLI в зависимости от аргументов."""
+    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,45 @@
+"""API-слой pentool — публичный интерфейс между modules/ и TUI/CLI.
+
+TUI и CLI импортируют только из pentool.api, не из pentool.modules напрямую.
+Это позволяет независимо менять логику и отображение.
+"""
+
+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,52 @@
+"""ExportableAPI — base mixin for API classes supporting project persistence.
+
+All API classes that implement export_project_data/import_project_data should
+inherit from this mixin for type consistency and documentation.
+"""
+
+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,23 @@
+"""ComparerAPI — публичный интерфейс Comparer для TUI.
+
+TUI-экраны импортируют только этот модуль,
+не modules/comparer.py напрямую.
+"""
+
+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,28 @@
+"""DecoderAPI — публичный интерфейс Decoder/Encoder для TUI.
+
+TUI-экраны импортируют только этот модуль,
+не modules/decoder.py напрямую.
+"""
+
+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,209 @@
+"""Публичный 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:
+    """Публичный интерфейс Intruder-модуля.
+
+    Тонкая обёртка над IntruderAttack.
+    Не знает о Textual.
+    """
+
+    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:
+        """Запустить атаку. Возвращает attack_id.
+
+        Args:
+            config: Конфиг атаки.
+            on_result: Callback(IntruderResult) — вызывается на каждый результат.
+            on_progress: Callback(done, total) — вызывается при обновлении прогресса.
+            turbo_mode: Использовать Turbo Mode (HTTP Keep-Alive, connection pooling).
+
+        Returns:
+            str: attack_id (UUID).
+        """
+        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]:
+        """Вернуть (done, total) текущей атаки."""
+        if self._attack:
+            return self._attack.progress
+        return (0, 0)
+
+    @property
+    def is_running(self) -> bool:
+        """Возвращает True если атака сейчас выполняется."""
+        return bool(self._attack and self._attack.is_running)
+
+    async def load_payloads(self, path: str) -> list[str]:
+        """Загрузить payload'ы из файла."""
+        return load_payloads_from_file(path)
+
+    async def generate_numeric(self, start: int, end: int, step: int = 1) -> list[str]:
+        """Сгенерировать числовые payload'ы."""
+        return generate_numeric_payloads(start, end, step)
+
+    async def generate_chars(
+        self, charset: str, min_len: int, max_len: int
+    ) -> list[str]:
+        """Сгенерировать символьные payload'ы."""
+        return generate_char_payloads(charset, min_len, max_len)
+
+    def export_csv(self, path: str) -> None:
+        """Экспортировать результаты в CSV."""
+        if self._attack:
+            self._attack.export_csv(path)
+
+    # ── Project persistence ────────────────────────────────────────────────────
+
+    def export_project_data(self) -> dict:
+        """Экспортировать результаты Intruder в сериализуемый dict.
+
+        Returns:
+            dict с ключом "results" — список IntruderResult в виде 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:
+        """Импортировать результаты Intruder из загруженного dict проекта.
+
+        Args:
+            data: Блок "intruder" из project.json ({"results": [...]}).
+
+        Returns:
+            Количество загруженных результатов.
+        """
+        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