pentool 0.1.0__py3-none-any.whl

pentool/core/features.py

@@ -0,0 +1,373 @@
+"""Feature flags и лимиты для лицензионной модели Pentool."""
+
+from enum import Enum
+from dataclasses import dataclass
+
+
+class FeatureStatus(str, Enum):
+    """Статус фичи."""
+    STABLE = "stable"    # Стабильная, готова к production
+    BETA = "beta"        # Стабильная, но в beta-тестировании
+    ALPHA = "alpha"      # Экспериментальная, может быть нестабильной
+
+
+@dataclass
+class Feature:
+    """Описание одной фичи."""
+    name: str
+    description: str
+    status: FeatureStatus
+    required_plan: str  # "free", "lite", "medium", "full"
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# FEATURE CONSTANTS — строковые идентификаторы для require_feature
+# ═══════════════════════════════════════════════════════════════════════
+
+# Scanner PRO checks
+FEATURE_SCANNER_ADVANCED_WAF = "scanner_advanced_waf"
+FEATURE_SCANNER_OOB = "scanner_oob"
+FEATURE_SCANNER_SSRF_PORTSCAN = "scanner_ssrf_portscan"
+FEATURE_SCANNER_SQLI_UNION = "scanner_sqli_union"
+FEATURE_SCANNER_SQLI_OOB = "scanner_sqli_oob"
+FEATURE_SCANNER_LFI_LOG_POISON = "scanner_lfi_log_poison"
+FEATURE_SCANNER_XSS_STORED = "scanner_xss_stored"
+FEATURE_SCANNER_DOM_XSS_ACTIVE = "scanner_dom_xss_active"
+FEATURE_SCANNER_DESER = "scanner_deser"
+FEATURE_SCANNER_SMUGGLING = "scanner_smuggling"
+FEATURE_SCANNER_FILE_UPLOAD = "scanner_file_upload"
+FEATURE_SCANNER_IDOR = "scanner_idor"
+FEATURE_SCANNER_PROMPT_INJECT = "scanner_prompt_inject"
+FEATURE_SCANNER_RCE_OOB = "scanner_rce_oob"
+
+# AI features
+FEATURE_AI_ANALYSIS = "ai_analysis"
+FEATURE_AI_STRATEGY = "ai_strategy"
+
+# Reports
+FEATURE_REPORTS_PRO = "pro_reports"
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# FEATURES — доступность фич по планам
+# ═══════════════════════════════════════════════════════════════════════
+
+FEATURES = {
+    # ────────────────────────────────────────────────────────────────────
+    # FREE PLAN — базовые инструменты
+    # ────────────────────────────────────────────────────────────────────
+    "proxy": Feature(
+        "proxy",
+        "HTTP/HTTPS Proxy с перехватом",
+        FeatureStatus.STABLE,
+        "free"
+    ),
+    "repeater": Feature(
+        "repeater",
+        "Repeater — повтор и модификация запросов",
+        FeatureStatus.STABLE,
+        "free"
+    ),
+    "intruder_basic": Feature(
+        "intruder_basic",
+        "Intruder (Sniper, Battering Ram)",
+        FeatureStatus.BETA,
+        "free"
+    ),
+    "decoder": Feature(
+        "decoder",
+        "Decoder — кодирование/декодирование данных",
+        FeatureStatus.STABLE,
+        "free"
+    ),
+    "comparer": Feature(
+        "comparer",
+        "Comparer — сравнение запросов/ответов",
+        FeatureStatus.STABLE,
+        "free"
+    ),
+    "httpql": Feature(
+        "httpql",
+        "HTTPQL — фильтрация истории запросов",
+        FeatureStatus.BETA,
+        "free"
+    ),
+
+    # ────────────────────────────────────────────────────────────────────
+    # LITE PLAN — расширенные возможности
+    # ────────────────────────────────────────────────────────────────────
+    "scanner_extended": Feature(
+        "scanner_extended",
+        "Scanner — расширенные проверки безопасности",
+        FeatureStatus.ALPHA,
+        "lite"
+    ),
+    "intruder_all_types": Feature(
+        "intruder_all_types",
+        "Intruder (Pitchfork, Cluster Bomb)",
+        FeatureStatus.ALPHA,
+        "lite"
+    ),
+    "spider": Feature(
+        "spider",
+        "Spider — автоматическое сканирование сайта",
+        FeatureStatus.BETA,
+        "lite"
+    ),
+    "match_replace": Feature(
+        "match_replace",
+        "Match & Replace — авто-модификация запросов",
+        FeatureStatus.BETA,
+        "lite"
+    ),
+    "target_scope": Feature(
+        "target_scope",
+        "Target Scope — управление областью тестирования",
+        FeatureStatus.STABLE,
+        "lite"
+    ),
+
+    # ────────────────────────────────────────────────────────────────────
+    # MEDIUM PLAN — профессиональные инструменты
+    # ────────────────────────────────────────────────────────────────────
+    "oob_detection": Feature(
+        "oob_detection",
+        "Out-of-Band детекция уязвимостей",
+        FeatureStatus.ALPHA,
+        "medium"
+    ),
+    "websocket_intercept": Feature(
+        "websocket_intercept",
+        "WebSocket перехват и модификация",
+        FeatureStatus.ALPHA,
+        "medium"
+    ),
+    "plugins": Feature(
+        "plugins",
+        "Система плагинов",
+        FeatureStatus.ALPHA,
+        "medium"
+    ),
+    "sequencer": Feature(
+        "sequencer",
+        "Sequencer — анализ случайности токенов",
+        FeatureStatus.BETA,
+        "medium"
+    ),
+    "passive_scanner": Feature(
+        "passive_scanner",
+        "Passive Scanner — фоновый анализ трафика",
+        FeatureStatus.BETA,
+        "medium"
+    ),
+    "turbo_mode": Feature(
+        "turbo_mode",
+        "Turbo Mode Intruder (10x ускорение)",
+        FeatureStatus.BETA,
+        "medium"
+    ),
+
+    # ────────────────────────────────────────────────────────────────────
+    # FULL PLAN — enterprise возможности
+    # ────────────────────────────────────────────────────────────────────
+    "ai_analysis": Feature(
+        "ai_analysis",
+        "AI-анализ уязвимостей (GPT-4)",
+        FeatureStatus.ALPHA,
+        "full"
+    ),
+    "pro_reports": Feature(
+        "pro_reports",
+        "PRO отчёты (HTML/PDF/JSON)",
+        FeatureStatus.ALPHA,
+        "full"
+    ),
+    "collaboration": Feature(
+        "collaboration",
+        "Совместная работа над проектами",
+        FeatureStatus.ALPHA,
+        "full"
+    ),
+    "api_access": Feature(
+        "api_access",
+        "REST API для автоматизации",
+        FeatureStatus.BETA,
+        "full"
+    ),
+    "custom_scanner_checks": Feature(
+        "custom_scanner_checks",
+        "Кастомные проверки Scanner",
+        FeatureStatus.ALPHA,
+        "full"
+    ),
+}
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# LIMITS — лимиты по планам
+# ═══════════════════════════════════════════════════════════════════════
+
+LIMITS = {
+    # История запросов
+    "history_max_entries": {
+        "free": 500,
+        "lite": 5000,
+        "medium": 50000,
+        "full": -1,  # unlimited
+    },
+
+    # Intruder
+    "intruder_max_threads": {
+        "free": 10,
+        "lite": 20,
+        "medium": 50,
+        "full": 100,
+    },
+    "intruder_max_requests": {
+        "free": 1000,
+        "lite": 10000,
+        "medium": 100000,
+        "full": -1,  # unlimited
+    },
+
+    # Scanner
+    "scanner_max_depth": {
+        "free": 2,
+        "lite": 5,
+        "medium": 10,
+        "full": -1,  # unlimited
+    },
+    "scanner_max_pages": {
+        "free": 20,
+        "lite": 100,
+        "medium": 1000,
+        "full": -1,  # unlimited
+    },
+    "scanner_threads": {
+        "free": 5,
+        "lite": 10,
+        "medium": 20,
+        "full": 50,
+    },
+
+    # Spider
+    "spider_max_depth": {
+        "free": 2,
+        "lite": 5,
+        "medium": 10,
+        "full": -1,  # unlimited
+    },
+    "spider_max_pages": {
+        "free": 50,
+        "lite": 200,
+        "medium": 1000,
+        "full": -1,  # unlimited
+    },
+
+    # Проекты
+    "projects_max": {
+        "free": 5,
+        "lite": 20,
+        "medium": 100,
+        "full": -1,  # unlimited
+    },
+
+    # Export
+    "export_formats": {
+        "free": ["txt"],
+        "lite": ["txt", "csv", "json"],
+        "medium": ["txt", "csv", "json", "html"],
+        "full": ["txt", "csv", "json", "html", "pdf"],
+    },
+}
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# PLAN NAMES — человекочитаемые названия планов
+# ═══════════════════════════════════════════════════════════════════════
+
+PLAN_NAMES = {
+    "free": "Free",
+    "lite": "Lite",
+    "medium": "Medium",
+    "full": "Full (PRO)",
+}
+
+
+PLAN_DESCRIPTIONS = {
+    "free": "Базовые инструменты для тестирования",
+    "lite": "Расширенные возможности для профессионалов",
+    "medium": "Продвинутые инструменты + плагины",
+    "full": "Enterprise функции + AI + API",
+}
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# HELPER FUNCTIONS
+# ═══════════════════════════════════════════════════════════════════════
+
+def has_feature(feature_name: str, plan: str) -> bool:
+    """Проверить, доступна ли фича для указанного плана.
+
+    Args:
+        feature_name: Название фичи (ключ из FEATURES)
+        plan: Название плана ("free", "lite", "medium", "full")
+
+    Returns:
+        True если фича доступна для этого плана
+    """
+    feature = FEATURES.get(feature_name)
+    if not feature:
+        return False
+
+    # Порядок планов от младшего к старшему
+    plan_order = ["free", "lite", "medium", "full"]
+
+    # Если текущий план >= требуемого плана, фича доступна
+    try:
+        current_level = plan_order.index(plan.lower())
+        required_level = plan_order.index(feature.required_plan)
+        return current_level >= required_level
+    except (ValueError, AttributeError):
+        return False
+
+
+def get_limit(limit_name: str, plan: str, default: int = 0) -> int | list:
+    limits = LIMITS.get(limit_name, {})
+    return limits.get(plan.lower(), default)
+
+
+def get_feature_status(feature_name: str) -> str:
+    feature = FEATURES.get(feature_name)
+    return feature.status.value if feature else "unknown"
+
+
+def get_features_for_plan(plan: str) -> list[Feature]:
+    return [
+        feature
+        for feature in FEATURES.values()
+        if has_feature(feature.name, plan)
+    ]
+
+
+def get_plan_info(plan: str) -> dict:
+    features = get_features_for_plan(plan)
+
+    return {
+        "plan": plan,
+        "name": PLAN_NAMES.get(plan, plan.capitalize()),
+        "description": PLAN_DESCRIPTIONS.get(plan, ""),
+        "features_count": len(features),
+        "features": [
+            {
+                "name": f.name,
+                "description": f.description,
+                "status": f.status.value,
+            }
+            for f in features
+        ],
+        "limits": {
+            limit_name: get_limit(limit_name, plan)
+            for limit_name in LIMITS.keys()
+        },
+    }

pentool/core/license.py

@@ -0,0 +1,274 @@
+"""Система лицензирования Pentool."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+import time
+import uuid
+from dataclasses import dataclass, field
+
+from pathlib import Path
+
+
+_LICENSE_FILE = Path.home() / ".pentool" / "license.dat"
+_GRACE_PERIOD_DAYS = 7
+
+
+@dataclass
+class LicenseInfo:
+    """Информация о текущей лицензии."""
+
+    valid: bool = False
+    plan: str = "free"                      # "free" | "pro" | "enterprise"
+    features: list[str] = field(default_factory=list)
+    expires: str | None = None           # ISO date или None (permanent)
+    machine_id: str = ""
+    license_key: str = ""
+    last_check: float | None = None      # timestamp последней онлайн-проверки
+    error: str = ""                         # сообщение об ошибке если not valid
+
+    def has_feature(self, feature: str) -> bool:
+        return self.valid and feature in self.features
+
+    def is_pro(self) -> bool:
+        return self.valid and self.plan in ("pro", "enterprise")
+
+    @property
+    def status_text(self) -> str:
+        if not self.valid:
+            return "FREE"
+        return self.plan.upper()
+
+    @property
+    def expires_text(self) -> str:
+        if not self.expires:
+            return "Lifetime"
+        return self.expires
+
+
+def get_machine_id() -> str:
+    try:
+        import socket
+        hostname = socket.gethostname()
+        # Получить MAC первого интерфейса через uuid
+        mac = hex(uuid.getnode())[2:]
+        raw = f"{hostname}:{mac}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:32]
+    except Exception:
+        return hashlib.sha256(platform.node().encode()).hexdigest()[:32]
+
+
+def _load_cached() -> dict | None:
+    try:
+        if _LICENSE_FILE.exists():
+            data = json.loads(_LICENSE_FILE.read_text(encoding="utf-8"))
+            return data
+    except Exception:
+        pass
+    return None
+
+
+def _save_cached(data: dict) -> None:
+    try:
+        _LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        _LICENSE_FILE.write_text(
+            json.dumps(data, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+    except Exception:
+        pass
+
+
+def get_license() -> LicenseInfo:
+    cached = _load_cached()
+    if cached is None:
+        return LicenseInfo(valid=False, plan="free", machine_id=get_machine_id())
+
+    last_check = cached.get("last_check", 0)
+    grace_seconds = _GRACE_PERIOD_DAYS * 24 * 3600
+    if (time.time() - last_check) > grace_seconds:
+        # Grace period истёк — деактивируем
+        return LicenseInfo(
+            valid=False,
+            plan="free",
+            machine_id=get_machine_id(),
+            license_key=cached.get("license_key", ""),
+            error=f"Grace period expired. Please reconnect to validate license.",
+        )
+
+    return LicenseInfo(
+        valid=cached.get("valid", False),
+        plan=cached.get("plan", "free"),
+        features=cached.get("features", []),
+        expires=cached.get("expires"),
+        machine_id=cached.get("machine_id", get_machine_id()),
+        license_key=cached.get("license_key", ""),
+        last_check=last_check,
+    )
+
+
+# Session-level license cache (avoids repeated file reads per check)
+_session_license: "LicenseInfo | None" = None
+
+
+def get_session_license() -> "LicenseInfo":
+    """Return cached session license (refreshed once per process)."""
+    global _session_license
+    if _session_license is None:
+        _session_license = get_license()
+    return _session_license
+
+
+def invalidate_session_license() -> None:
+    """Force re-read on next get_session_license() call."""
+    global _session_license
+    _session_license = None
+
+
+class FeatureNotAvailable(Exception):
+    """Feature not available in the current plan."""
+    def __init__(self, feature: str, plan_required: str = "pro"):
+        self.feature = feature
+        self.plan_required = plan_required
+        super().__init__(
+            f"Feature '{feature}' requires {plan_required.upper()} plan. "
+            f"Upgrade at https://pentool.dev/upgrade"
+        )
+
+
+def require_feature(feature: str, plan_required: str = "pro"):
+    """Decorator: raise FeatureNotAvailable if feature is not licensed."""
+    def decorator(func):
+        import functools
+        import asyncio as _asyncio
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            if not get_session_license().has_feature(feature):
+                raise FeatureNotAvailable(feature, plan_required)
+            return await func(*args, **kwargs)
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            if not get_session_license().has_feature(feature):
+                raise FeatureNotAvailable(feature, plan_required)
+            return func(*args, **kwargs)
+
+        if _asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    return decorator
+
+
+async def activate_license(key: str) -> LicenseInfo:
+    """Активировать лицензию онлайн (license.pentool.dev/api/validate).
+
+    Returns:
+        LicenseInfo с результатом активации.
+    """
+    key = key.strip().upper()
+    machine_id = get_machine_id()
+
+    if not key:
+        return LicenseInfo(
+            valid=False, plan="free",
+            machine_id=machine_id,
+            error="License key is empty",
+        )
+
+    # Попытка реальной онлайн-проверки
+    try:
+        import aiohttp
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=10)
+        ) as session:
+            async with session.post(
+                "https://license.pentool.dev/api/validate",
+                json={"key": key, "machine_id": machine_id},
+                ssl=False,
+            ) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    info = LicenseInfo(
+                        valid=data.get("valid", False),
+                        plan=data.get("plan", "free"),
+                        features=data.get("features", []),
+                        expires=data.get("expires"),
+                        machine_id=machine_id,
+                        license_key=key,
+                        last_check=time.time(),
+                    )
+                    if info.valid:
+                        _save_cached({
+                            "valid": True,
+                            "plan": info.plan,
+                            "features": info.features,
+                            "expires": info.expires,
+                            "machine_id": machine_id,
+                            "license_key": key,
+                            "last_check": time.time(),
+                        })
+                    return info
+    except Exception:
+        pass  # Сервер недоступен — fallback к локальной проверке
+
+    # Оффлайн-fallback: проверяем формат ключа
+    # Формат: XXXX-XXXX-XXXX-XXXX (16 hex символов через дефисы)
+    import re
+    if re.match(r'^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$', key):
+        if key.startswith("DEMO"):
+            info = LicenseInfo(
+                valid=True,
+                plan="pro",
+                features=["scanner_pro", "reports_pro", "payloads_pro"],
+                expires=None,
+                machine_id=machine_id,
+                license_key=key,
+                last_check=time.time(),
+            )
+            _save_cached({
+                "valid": True,
+                "plan": "pro",
+                "features": ["scanner_pro", "reports_pro", "payloads_pro"],
+                "expires": None,
+                "machine_id": machine_id,
+                "license_key": key,
+                "last_check": time.time(),
+            })
+            return info
+
+    return LicenseInfo(
+        valid=False,
+        plan="free",
+        machine_id=machine_id,
+        license_key=key,
+        error="License server unavailable. Key format invalid or not activated.",
+    )
+
+
+def deactivate_license() -> None:
+    """Деактивировать лицензию (удалить кэш)."""
+    try:
+        if _LICENSE_FILE.exists():
+            _LICENSE_FILE.unlink()
+    except Exception:
+        pass
+
+
+# Глобальный кэш лицензии для текущей сессии
+_session_license: LicenseInfo | None = None
+
+
+def get_session_license() -> LicenseInfo:
+    global _session_license
+    if _session_license is None:
+        _session_license = get_license()
+    return _session_license
+
+
+def refresh_session_license(info: LicenseInfo | None = None) -> LicenseInfo:
+    global _session_license
+    _session_license = info or get_license()
+    return _session_license

pentool/core/logging.py

@@ -0,0 +1,54 @@
+"""Настройка системы логирования."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+
+def setup_logging(log_file: str, level: str = "INFO") -> logging.Logger:
+    """Настроить логирование: запись в файл (DEBUG) и в консоль (указанный уровень).
+
+    Args:
+        log_file: Путь к лог-файлу.
+        level: Уровень логирования для консоли (DEBUG/INFO/WARNING/ERROR).
+
+    Returns:
+        Настроенный корневой логгер.
+    """
+    log_path = Path(log_file)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+
+    logger = logging.getLogger("pentool")
+    logger.setLevel(logging.DEBUG)
+
+    # Очистить существующие хендлеры, чтобы избежать дублирования
+    logger.handlers.clear()
+
+    # FileHandler — пишет всё (DEBUG и выше), дописывает в лог (не очищает)
+    fmt = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    file_handler = logging.FileHandler(log_file, encoding="utf-8", mode="a")
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(fmt)
+
+    # StreamHandler — пишет в stderr на указанном уровне
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(
+        logging.Formatter("[%(levelname)s] %(message)s")
+    )
+
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+    return logger
+
+
+def get_logger(name: str = "pentool") -> logging.Logger:
+    return logging.getLogger(name)