pentool 1.0.0__py3-none-any.whl

pentool/cli/main.py

@@ -0,0 +1,100 @@
+"""Главная группа CLI-команд."""
+
+from __future__ import annotations
+
+import click
+
+from pentool.core.config import get_config
+from pentool.core.logging import setup_logging
+
+
+@click.group()
+@click.version_option(package_name="pentool")
+@click.option("--config", "config_path", default=None, help="Путь к файлу конфигурации.")
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Подробный вывод (DEBUG).")
+@click.pass_context
+def cli(ctx: click.Context, config_path: str | None, verbose: bool) -> None:
+    """Pentool — консольный инструмент для пентестинга веб-приложений.
+
+    Запустите без аргументов для открытия TUI:
+
+        pentool
+
+    Или используйте команды ниже для работы из командной строки.
+    """
+    ctx.ensure_object(dict)
+
+    cfg = get_config()
+    if config_path:
+        from pentool.core.config import Config
+        cfg = Config.load(config_path)
+
+    log_level = "DEBUG" if verbose else cfg.log_level
+    setup_logging(cfg.log_file, log_level)
+
+    ctx.obj["config"] = cfg
+
+
+# Импорт и регистрация групп команд
+from pentool.cli.project import project  # noqa: E402
+
+cli.add_command(project)
+
+
+from pentool.cli.proxy import proxy  # noqa: E402
+
+cli.add_command(proxy)
+
+
+@cli.group()
+def repeater() -> None:
+    """Модуль Repeater: ручная отправка запросов."""
+
+
+@repeater.command("send")
+@click.option("--request-file", required=True, type=click.Path(exists=True), help="Файл с HTTP-запросом.")
+def repeater_send(request_file: str) -> None:
+    """Отправить HTTP-запрос из файла."""
+    click.echo(f"Repeater send {request_file} — not implemented yet.")
+
+
+@cli.group()
+def intruder() -> None:
+    """Модуль Intruder: автоматизированные атаки."""
+
+
+@intruder.command("run")
+@click.option("--request", "request_file", required=True, type=click.Path(exists=True))
+@click.option("--payloads", required=True, type=click.Path(exists=True))
+@click.option("--attack", default="sniper", show_default=True,
+              type=click.Choice(["sniper", "battering_ram", "pitchfork", "cluster_bomb"]))
+def intruder_run(request_file: str, payloads: str, attack: str) -> None:
+    """Запустить атаку."""
+    click.echo(f"Intruder run [{attack}] — not implemented yet.")
+
+
+from pentool.cli.scan import scan  # noqa: E402
+
+cli.add_command(scan)
+
+
+@cli.command("decode")
+@click.argument("operation", type=click.Choice([
+    "url_encode", "url_decode",
+    "base64_encode", "base64_decode",
+    "base64url_encode", "base64url_decode",
+    "html_encode", "html_decode",
+    "hex_encode", "hex_decode",
+    "unicode_escape", "unicode_unescape",
+    "md5", "sha1", "sha256",
+]))
+@click.argument("text")
+def decode_cmd(operation: str, text: str) -> None:
+    """Кодировать/декодировать/хэшировать текст."""
+    from pentool.utils.coder import apply_operation
+    try:
+        result = apply_operation(operation, text)
+        click.echo(result)
+    except ValueError as exc:
+        click.echo(f"Error: {exc}", err=True)
+        raise SystemExit(1) from exc

pentool/cli/project.py

@@ -0,0 +1,90 @@
+"""CLI-команды для управления проектами."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import click
+
+from pentool.core.config import Config, get_config
+from pentool.core.database import init_db
+from pentool.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group()
+def project() -> None:
+    """Управление проектами: инициализация, список, открытие."""
+
+
+@project.command("init")
+@click.option("--name", default="default", show_default=True, help="Имя проекта.")
+@click.option(
+    "--path",
+    default=None,
+    help="Директория проекта (по умолчанию: ~/.config/pentool/projects/<name>).",
+)
+def project_init(name: str, path: str | None) -> None:
+    """Инициализировать новый проект: создать директорию, БД и конфиг."""
+    cfg = get_config()
+
+    if path is None:
+        project_dir = Path.home() / ".config" / "pentool" / "projects" / name
+    else:
+        project_dir = Path(path) / name
+
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    db_path = str(project_dir / "pentool.db")
+    log_file = str(project_dir / "pentool.log")
+    cert_dir = str(project_dir / "certs")
+    plugins_dir = str(project_dir / "plugins")
+
+    # Обновить и сохранить конфиг проекта
+    project_cfg = Config(
+        proxy_host=cfg.proxy_host,
+        proxy_port=cfg.proxy_port,
+        cert_dir=cert_dir,
+        db_path=db_path,
+        log_file=log_file,
+        log_level=cfg.log_level,
+        plugins_dir=plugins_dir,
+    )
+    config_path = project_dir / "config.yaml"
+    project_cfg.save(config_path)
+
+    # Создать таблицы БД
+    try:
+        asyncio.run(init_db(db_path))
+        click.echo(f"Project '{name}' initialized:")
+        click.echo(f"  Directory : {project_dir}")
+        click.echo(f"  Database  : {db_path}")
+        click.echo(f"  Config    : {config_path}")
+        click.echo(f"  Log file  : {log_file}")
+        logger.info("Project '%s' initialized at %s", name, project_dir)
+    except Exception as exc:
+        click.echo(f"Error initializing database: {exc}", err=True)
+        logger.error("Failed to initialize project '%s': %s", name, exc)
+        raise SystemExit(1) from exc
+
+
+@project.command("list")
+def project_list() -> None:
+    """Показать список сохранённых проектов."""
+    projects_dir = Path.home() / ".config" / "pentool" / "projects"
+    if not projects_dir.exists():
+        click.echo("No projects found.")
+        return
+
+    entries = [d for d in projects_dir.iterdir() if d.is_dir()]
+    if not entries:
+        click.echo("No projects found.")
+        return
+
+    click.echo(f"{'Name':<20} {'Path'}")
+    click.echo("-" * 60)
+    for entry in sorted(entries):
+        click.echo(f"{entry.name:<20} {entry}")

pentool/cli/proxy.py

@@ -0,0 +1,185 @@
+"""CLI-команды для управления прокси-сервером."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+import click
+
+from pentool.core.config import get_config
+from pentool.core.logging import get_logger, setup_logging
+
+logger = get_logger(__name__)
+
+
+@click.group()
+def proxy() -> None:
+    """Управление HTTP/HTTPS прокси-сервером."""
+
+
+@proxy.command("start")
+@click.option("--port", default=8080, show_default=True, help="Порт прокси.")
+@click.option("--host", default="127.0.0.1", show_default=True, help="Адрес для прослушивания.")
+@click.option("--cert-dir", default=None, help="Директория для CA-сертификатов.")
+@click.option("--db", "db_path", default=None, help="Путь к SQLite БД для логирования.")
+@click.option("--intercept", is_flag=True, default=False, help="Включить интерактивный перехват.")
+@click.option("--scope", default="", help="Список хостов через запятую (пусто = все).")
+def proxy_start(
+    port: int,
+    host: str,
+    cert_dir: str | None,
+    db_path: str | None,
+    intercept: bool,
+    scope: str,
+) -> None:
+    """Запустить прокси-сервер в текущем процессе (блокирующий режим).
+
+    Примеры:
+
+        pentool proxy start --port 8080
+
+        pentool proxy start --port 8080 --scope "example.com,api.example.com"
+
+        pentool proxy start --intercept
+    """
+    cfg = get_config()
+    setup_logging(cfg.log_file, cfg.log_level)
+
+    _cert_dir = cert_dir or cfg.cert_dir
+    _db_path = db_path or cfg.db_path
+
+    from pentool.api.proxy_api import ProxyAPI
+
+    api = ProxyAPI()
+    server = api.create_proxy(
+        host=host,
+        port=port,
+        cert_dir=_cert_dir,
+        db_path=_db_path,
+    )
+    server.intercept_enabled = intercept
+
+    if scope:
+        server.set_scope([h.strip() for h in scope.split(",") if h.strip()])
+
+    click.echo(f"Starting proxy on {host}:{port}")
+    click.echo(f"  CA certs  : {_cert_dir}")
+    click.echo(f"  Database  : {_db_path}")
+    click.echo(f"  Intercept : {'ON' if intercept else 'OFF'}")
+    if server.scope:
+        click.echo(f"  Scope     : {', '.join(server.scope)}")
+    else:
+        click.echo("  Scope     : ALL hosts")
+    click.echo("Press Ctrl+C to stop.\n")
+
+    # Инициализировать БД если нужно
+    from pentool.core.database import init_db_sync
+    try:
+        init_db_sync(_db_path)
+    except Exception as exc:
+        click.echo(f"Warning: could not init database: {exc}", err=True)
+
+    try:
+        asyncio.run(server.serve_forever())
+    except KeyboardInterrupt:
+        click.echo("\nProxy stopped.")
+
+
+@proxy.command("status")
+@click.option("--port", default=8080, show_default=True, help="Порт для проверки.")
+def proxy_status(port: int) -> None:
+    """Проверить, слушает ли прокси на указанном порту."""
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(1.0)
+        result = s.connect_ex(("127.0.0.1", port))
+    if result == 0:
+        click.echo(f"Proxy is RUNNING on port {port}")
+    else:
+        click.echo(f"Proxy is NOT running on port {port}")
+
+
+@proxy.command("history")
+@click.option("--db", "db_path", default=None, help="Путь к SQLite БД.")
+@click.option("--limit", default=20, show_default=True, help="Количество записей.")
+@click.option("--method", default=None, help="Фильтр по методу (GET, POST, ...).")
+@click.option("--host", default=None, help="Фильтр по хосту (подстрока URL).")
+def proxy_history(
+    db_path: str | None,
+    limit: int,
+    method: str | None,
+    host: str | None,
+) -> None:
+    """Показать историю перехваченных запросов из БД."""
+    cfg = get_config()
+    _db_path = db_path or cfg.db_path
+
+    if not Path(_db_path).exists():
+        click.echo(f"Database not found: {_db_path}", err=True)
+        raise SystemExit(1)
+
+    async def _fetch() -> list:
+        from pentool.storage.http_storage import HttpStorage
+        storage = HttpStorage()
+        await storage.init_db(_db_path)
+        filters: dict = {}
+        if method:
+            filters["method"] = [method.upper()]
+        if host:
+            filters["host"] = host
+        return await storage.get_metadata_batch(
+            offset=0,
+            limit=limit,
+            filters=filters if filters else None,
+            order_by="id",
+            desc=True,
+        )
+
+    rows = asyncio.run(_fetch())
+
+    if not rows:
+        click.echo("No requests found.")
+        return
+
+    click.echo(f"{'ID':<6} {'METHOD':<8} {'STATUS':<8} {'URL'}")
+    click.echo("-" * 80)
+    for row in rows:
+        rid = row["id"]
+        meth = row.get("method", "-")
+        url = row.get("url", "-")
+        status = row.get("status_code")
+        status_str = str(status) if status else "-"
+        url_short = url[:60] + "..." if len(url) > 60 else url
+        click.echo(f"{rid:<6} {meth:<8} {status_str:<8} {url_short}")
+
+
+@proxy.command("ca-info")
+@click.option("--cert-dir", default=None, help="Директория CA-сертификатов.")
+def proxy_ca_info(cert_dir: str | None) -> None:
+    """Показать путь к CA-сертификату и инструкцию по установке."""
+    cfg = get_config()
+    _cert_dir = cert_dir or cfg.cert_dir
+    ca_cert = Path(_cert_dir) / "ca.crt"
+
+    if ca_cert.exists():
+        click.echo(f"CA certificate: {ca_cert}")
+    else:
+        from pentool.utils.cert import generate_ca_cert
+        cert_path, _ = generate_ca_cert(_cert_dir)
+        click.echo(f"CA certificate generated: {cert_path}")
+
+    click.echo("\nTo trust the CA certificate:")
+    click.echo("")
+    click.echo("  Linux (Ubuntu/Debian):")
+    click.echo(f"    sudo cp {ca_cert} /usr/local/share/ca-certificates/pentool-ca.crt")
+    click.echo("    sudo update-ca-certificates")
+    click.echo("")
+    click.echo("  macOS:")
+    click.echo(f"    sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain {ca_cert}")
+    click.echo("")
+    click.echo("  Firefox / Chrome:")
+    click.echo("    Settings → Certificates → Import → select ca.crt → Trust for websites")

pentool/cli/scan.py

@@ -0,0 +1,118 @@
+"""CLI-команды сканирования: pentool scan active / passive / report."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import click
+
+
+@click.group("scan")
+def scan() -> None:
+    """Модуль Scanner: сканирование уязвимостей."""
+
+
+@scan.command("active")
+@click.option("--url", "urls", required=True, multiple=True, help="Целевой URL (можно несколько).")
+@click.option(
+    "--checks", "check_names", default=None,
+    help="Проверки через запятую: missing_security_headers,info_leak",
+)
+@click.option("--output", "output", default=None, help="Сохранить findings в файл (json/csv/html).")
+@click.option("--concurrency", default=5, show_default=True, help="Параллельных потоков.")
+@click.option("--delay", default=0.0, show_default=True, help="Задержка между запросами (сек).")
+@click.pass_context
+def scan_active(
+    ctx: click.Context,
+    urls: tuple[str, ...],
+    check_names: str | None,
+    output: str | None,
+    concurrency: int,
+    delay: float,
+) -> None:
+    """Запустить активное сканирование по URL."""
+    from pentool.api.scanner_api import ScannerAPI
+    from pentool.core.config import get_config
+
+    cfg = (ctx.obj or {}).get("config") or get_config()
+    names = [c.strip() for c in check_names.split(",")] if check_names else None
+
+    api = ScannerAPI(db_path=cfg.db_path)
+
+    findings = []
+
+    def on_finding(f) -> None:
+        findings.append(f)
+        sev = f.severity.upper()
+        click.echo(f"  [{sev}] {f.name} — {f.url}")
+
+    def on_progress(done: int, total: int) -> None:
+        click.echo(f"\r  Progress: {done}/{total}", nl=False)
+
+    async def _run() -> None:
+        await api.start_active_scan(
+            list(urls),
+            check_names=names,
+            on_finding=on_finding,
+            on_progress=on_progress,
+            concurrency=concurrency,
+            request_delay=delay,
+        )
+        # Ждём завершения задачи
+        if api._active_task:
+            await api._active_task
+
+    click.echo(f"Starting active scan on {len(urls)} target(s)...")
+    asyncio.run(_run())
+    click.echo(f"\nDone. Found {len(findings)} finding(s).")
+
+    if output:
+        fmt = "html"
+        if output.endswith(".json"):
+            fmt = "json"
+        elif output.endswith(".csv"):
+            fmt = "csv"
+        asyncio.run(api.generate_report(output, fmt))
+        click.echo(f"Report saved: {output}")
+
+
+@scan.command("passive")
+@click.option("--scope", default=None, help="Фильтр хоста (например *.example.com).")
+@click.pass_context
+def scan_passive(ctx: click.Context, scope: str | None) -> None:
+    """Показать информацию о пассивном сканировании."""
+    click.echo(
+        "Passive scanning runs automatically while the proxy intercepts traffic.\n"
+        "Use the TUI (Scanner tab) to enable Passive mode and view findings."
+    )
+    if scope:
+        click.echo(f"Scope filter: {scope}")
+
+
+@scan.command("report")
+@click.option("--output", required=True, help="Путь к файлу отчёта.")
+@click.option(
+    "--format", "fmt", default="html",
+    type=click.Choice(["html", "json", "csv"], case_sensitive=False),
+    show_default=True,
+    help="Формат отчёта.",
+)
+@click.pass_context
+def scan_report(ctx: click.Context, output: str, fmt: str) -> None:
+    """Сгенерировать отчёт по найденным уязвимостям."""
+    from pentool.api.scanner_api import ScannerAPI
+    from pentool.core.config import get_config
+
+    cfg = (ctx.obj or {}).get("config") or get_config()
+    api = ScannerAPI(db_path=cfg.db_path)
+
+    async def _run() -> None:
+        findings = await api.get_findings(limit=10000)
+        if not findings:
+            click.echo("No findings in database.")
+            return
+        await api.generate_report(output, fmt)
+        click.echo(f"Report saved: {output} ({len(findings)} findings)")
+
+    asyncio.run(_run())

pentool/core/__init__.py

@@ -0,0 +1 @@
+"""Пакет core: конфигурация, логирование, БД."""

pentool/core/config.py

@@ -0,0 +1,184 @@
+"""Управление конфигурацией приложения."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+import yaml
+
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "pentool"
+DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.yaml"
+
+# Тип колбэка: вызывается при изменении конфига
+ConfigObserver = Callable[[dict], None]
+
+
+@dataclass
+class Config:
+    """Конфигурация приложения с значениями по умолчанию."""
+
+    proxy_host: str = "127.0.0.1"
+    proxy_port: int = 8080
+    cert_dir: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "certs"))
+    db_path: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "pentool.db"))
+    log_file: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "pentool.log"))
+    log_level: str = "INFO"
+    plugins_dir: str = field(default_factory=lambda: str(DEFAULT_CONFIG_DIR / "plugins"))
+    scope: list[str] = field(default_factory=list)
+    intercept_enabled: bool = False
+    recent_projects: list[str] = field(default_factory=list)
+    auto_save_enabled: bool = False
+    auto_save_interval: int = 5  # минуты
+    # ── Network / Scanner settings (Блок 4.10) ─────────────────────────────
+    default_user_agent: str = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/122.0.0.0 Safari/537.36"
+    )
+    request_timeout: int = 15         # секунды
+    connect_timeout: int = 10         # секунды
+    collaborator_url: str = ""        # Burp Collaborator / interactsh URL
+    max_redirects: int = 10
+    verify_ssl: bool = False          # проверка SSL-сертификатов в сканере
+    # ── Scanner request marking ─────────────────────────────────────────────
+    scan_marker_enabled: bool = False
+    scan_marker_name: str = "X-Scanner"
+    scan_marker_value: str = "pentool/1.0"
+
+    # Список наблюдателей — не сериализуется (R-16)
+    _observers: list[ConfigObserver] = field(default_factory=list, init=False, repr=False, compare=False)
+
+    def add_observer(self, cb: ConfigObserver) -> None:
+        """Подписаться на изменения конфигурации.
+
+        Args:
+            cb: Функция вида cb(changed_fields: dict) → None.
+        """
+        if cb not in self._observers:
+            self._observers.append(cb)
+
+    def remove_observer(self, cb: ConfigObserver) -> None:
+        """Отписаться от изменений конфигурации."""
+        try:
+            self._observers.remove(cb)
+        except ValueError:
+            pass
+
+    def notify_observers(self, changed_fields: dict) -> None:
+        """Уведомить всех наблюдателей об изменениях.
+
+        Args:
+            changed_fields: Словарь изменённых полей {name: new_value}.
+        """
+        for cb in list(self._observers):
+            try:
+                cb(changed_fields)
+            except Exception:
+                pass
+
+    def update(self, **kwargs: Any) -> None:
+        """Обновить поля конфига и уведомить наблюдателей.
+
+        Args:
+            **kwargs: Поля для обновления (proxy_host, proxy_port и т.д.).
+        """
+        changed: dict = {}
+        for key, value in kwargs.items():
+            if hasattr(self, key) and not key.startswith("_"):
+                if getattr(self, key) != value:
+                    setattr(self, key, value)
+                    changed[key] = value
+        if changed:
+            self.notify_observers(changed)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Преобразовать в словарь для сериализации."""
+        return {
+            "proxy_host": self.proxy_host,
+            "proxy_port": self.proxy_port,
+            "cert_dir": self.cert_dir,
+            "db_path": self.db_path,
+            "log_file": self.log_file,
+            "log_level": self.log_level,
+            "plugins_dir": self.plugins_dir,
+            "scope": self.scope,
+            "intercept_enabled": self.intercept_enabled,
+            "recent_projects": self.recent_projects,
+            "auto_save_enabled": self.auto_save_enabled,
+            "auto_save_interval": self.auto_save_interval,
+            "default_user_agent": self.default_user_agent,
+            "request_timeout": self.request_timeout,
+            "connect_timeout": self.connect_timeout,
+            "collaborator_url": self.collaborator_url,
+            "max_redirects": self.max_redirects,
+            "verify_ssl": self.verify_ssl,
+            "scan_marker_enabled": self.scan_marker_enabled,
+            "scan_marker_name": self.scan_marker_name,
+            "scan_marker_value": self.scan_marker_value,
+        }
+
+    def add_recent_project(self, path: str) -> None:
+        """Добавить путь в список последних проектов (дедупликация, максимум 10)."""
+        path = str(path)
+        if path in self.recent_projects:
+            self.recent_projects.remove(path)
+        self.recent_projects.insert(0, path)
+        self.recent_projects = self.recent_projects[:10]
+        try:
+            self.save()
+        except Exception:
+            pass
+
+    def save(self, path: str | Path = DEFAULT_CONFIG_PATH) -> None:
+        """Сохранить конфигурацию в YAML-файл."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(self.to_dict(), f, default_flow_style=False, allow_unicode=True)
+
+    @classmethod
+    def load(cls, path: str | Path = DEFAULT_CONFIG_PATH) -> "Config":
+        """Загрузить конфигурацию из YAML-файла.
+
+        Если файл не существует — вернуть конфигурацию по умолчанию.
+        """
+        path = Path(path)
+        if not path.exists():
+            return cls()
+        with open(path, "r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f) or {}
+        cfg = cls()
+        for key, value in data.items():
+            if hasattr(cfg, key) and not key.startswith("_"):
+                setattr(cfg, key, value)
+        # Удалить несуществующие пути из recent_projects при загрузке
+        before = len(cfg.recent_projects)
+        cfg.recent_projects = [p for p in cfg.recent_projects if os.path.exists(p)]
+        if len(cfg.recent_projects) != before:
+            try:
+                cfg.save()
+            except Exception:
+                pass
+        return cfg
+
+
+# Глобальный экземпляр конфигурации (инициализируется при запуске)
+_config: Config | None = None
+
+
+def get_config() -> Config:
+    """Получить глобальный экземпляр конфигурации."""
+    global _config
+    if _config is None:
+        _config = Config.load()
+    return _config
+
+
+def set_config(config: Config) -> None:
+    """Установить глобальный экземпляр конфигурации."""
+    global _config
+    _config = config