pentool 0.1.0__py3-none-any.whl

pentool/core/updater.py

@@ -0,0 +1,96 @@
+"""Update checker — checks GitHub releases for a newer version."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class UpdateInfo:
+    has_update: bool
+    latest_version: str
+    url: str
+    error: str = ""
+
+
+def _parse_version(v: str) -> tuple[int, ...]:
+    """Parse 'v1.2.3' or '1.2.3' into (1, 2, 3)."""
+    v = v.lstrip("v").strip()
+    try:
+        return tuple(int(x) for x in v.split(".")[:3])
+    except Exception:
+        return (0,)
+
+
+async def check_update_async(
+    owner: str = "sudores",
+    repo: str = "pentool",
+    timeout: float = 6.0,
+) -> UpdateInfo:
+    """Query GitHub releases API and compare with installed version."""
+    try:
+        from pentool import __version__ as current_version
+    except Exception:
+        current_version = "0.0.0"
+
+    url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
+
+    try:
+        import aiohttp  # type: ignore[import]
+    except ImportError:
+        return UpdateInfo(has_update=False, latest_version=current_version, url="",
+                          error="aiohttp not installed")
+
+    try:
+        aio_timeout = aiohttp.ClientTimeout(total=timeout)
+        async with aiohttp.ClientSession(timeout=aio_timeout) as session:
+            async with session.get(
+                url,
+                headers={"Accept": "application/vnd.github+json"},
+                ssl=False,
+            ) as resp:
+                if resp.status != 200:
+                    return UpdateInfo(has_update=False, latest_version=current_version,
+                                      url="", error=f"HTTP {resp.status}")
+                data = await resp.json()
+    except asyncio.TimeoutError:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error="timeout")
+    except Exception as exc:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error=str(exc))
+
+    latest_tag = data.get("tag_name", "")
+    html_url   = data.get("html_url", "")
+    if not latest_tag:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error="no tag_name in response")
+
+    has_update = _parse_version(latest_tag) > _parse_version(current_version)
+    return UpdateInfo(has_update=has_update, latest_version=latest_tag, url=html_url)
+
+
+def check_update_sync() -> UpdateInfo:
+    """Synchronous wrapper for use outside an async context."""
+    try:
+        loop = asyncio.new_event_loop()
+        result = loop.run_until_complete(check_update_async())
+        loop.close()
+        return result
+    except Exception as exc:
+        return UpdateInfo(has_update=False, latest_version="", url="", error=str(exc))
+
+
+def do_pip_upgrade() -> bool:
+    """Attempt to upgrade via pip. Returns True on success."""
+    import subprocess, sys
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "pentool"],
+            capture_output=True, text=True, timeout=120,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False

pentool/core/utils.py

@@ -0,0 +1,36 @@
+"""core/utils.py — утилиты общего назначения."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Any, Coroutine, TypeVar
+
+T = TypeVar("T")
+
+
+def run_async_sync(coro: Coroutine[Any, Any, T], timeout: float = 15.0) -> T:
+    result: list[Any] = []
+    exc_box: list[BaseException] = []
+    done_event = threading.Event()
+
+    def _run() -> None:
+        loop = asyncio.new_event_loop()
+        try:
+            result.append(loop.run_until_complete(coro))
+        except Exception as e:
+            exc_box.append(e)
+        finally:
+            loop.close()
+            done_event.set()
+
+    threading.Thread(target=_run, daemon=True).start()
+    finished = done_event.wait(timeout=timeout)
+    if not finished:
+        raise TimeoutError(f"run_async_sync: timed out after {timeout}s")
+    if exc_box:
+        raise exc_box[0]
+    return result[0] if result else None  # type: ignore[return-value]
+
+
+__all__ = ["run_async_sync"]

pentool/modules/__init__.py

@@ -0,0 +1 @@
+"""Пакет modules: логика модулей, независимая от интерфейса."""

pentool/modules/comparer.py

@@ -0,0 +1,177 @@
+"""Comparer — side-by-side diff двух текстов с подсветкой различий."""
+
+from __future__ import annotations
+
+import difflib
+from dataclasses import dataclass
+
+__all__ = ["compare", "compare_lines", "CompareStats", "DiffLine", "DiffResult"]
+
+
+@dataclass
+class DiffLine:
+    """Одна строка diff-результата."""
+
+    tag: str           # "equal" | "replace" | "insert" | "delete"
+    left: str          # текст левой стороны (пустая если insert)
+    right: str         # текст правой стороны (пустая если delete)
+    line_left: int     # номер строки слева (0 если нет)
+    line_right: int    # номер строки справа (0 если нет)
+
+
+@dataclass
+class CompareStats:
+    """Статистика сравнения."""
+
+    total_left: int
+    total_right: int
+    equal_lines: int
+    added_lines: int
+    removed_lines: int
+    changed_lines: int
+    similarity: float  # 0.0–1.0
+
+    @property
+    def similarity_pct(self) -> int:
+        return int(self.similarity * 100)
+
+
+@dataclass
+class DiffResult:
+    """Результат сравнения: строки diff + статистика."""
+
+    lines: list[DiffLine]
+    stats: CompareStats
+
+    def rich_text(self) -> str:
+        """Собрать Rich-markup строку для RichLog."""
+        parts: list[str] = []
+        for dl in self.lines:
+            if dl.tag == "equal":
+                parts.append(f"[dim]  {dl.left}[/dim]")
+            elif dl.tag == "insert":
+                parts.append(f"[green]+ {dl.right}[/green]")
+            elif dl.tag == "delete":
+                parts.append(f"[red]- {dl.left}[/red]")
+            elif dl.tag == "replace":
+                parts.append(f"[red]- {dl.left}[/red]")
+                parts.append(f"[green]+ {dl.right}[/green]")
+        return "\n".join(parts)
+
+
+def compare(left: str, right: str) -> DiffResult:
+    """Сравнить два текста построчно.
+
+    Args:
+        left: Левый текст.
+        right: Правый текст.
+
+    Returns:
+        DiffResult с построчными различиями и статистикой.
+    """
+    left_lines = left.splitlines()
+    right_lines = right.splitlines()
+    return compare_lines(left_lines, right_lines)
+
+
+def compare_lines(left_lines: list[str], right_lines: list[str]) -> DiffResult:
+    """Сравнить два списка строк.
+
+    Args:
+        left_lines: Строки левой стороны.
+        right_lines: Строки правой стороны.
+
+    Returns:
+        DiffResult с построчными различиями и статистикой.
+    """
+    matcher = difflib.SequenceMatcher(None, left_lines, right_lines, autojunk=False)
+    opcodes = matcher.get_opcodes()
+
+    diff_lines: list[DiffLine] = []
+    equal = added = removed = changed = 0
+
+    ln_left = 1
+    ln_right = 1
+
+    for tag, i1, i2, j1, j2 in opcodes:
+        if tag == "equal":
+            for k in range(i2 - i1):
+                diff_lines.append(DiffLine(
+                    tag="equal",
+                    left=left_lines[i1 + k],
+                    right=right_lines[j1 + k],
+                    line_left=ln_left + k,
+                    line_right=ln_right + k,
+                ))
+            equal += i2 - i1
+            ln_left += i2 - i1
+            ln_right += j2 - j1
+
+        elif tag == "replace":
+            # Показываем удалённые строки слева, добавленные справа
+            left_chunk = left_lines[i1:i2]
+            right_chunk = right_lines[j1:j2]
+            max_len = max(len(left_chunk), len(right_chunk))
+            for k in range(max_len):
+                l_text = left_chunk[k] if k < len(left_chunk) else ""
+                r_text = right_chunk[k] if k < len(right_chunk) else ""
+                if l_text and r_text:
+                    diff_lines.append(DiffLine(
+                        tag="replace",
+                        left=l_text, right=r_text,
+                        line_left=ln_left + k if k < len(left_chunk) else 0,
+                        line_right=ln_right + k if k < len(right_chunk) else 0,
+                    ))
+                elif l_text:
+                    diff_lines.append(DiffLine(
+                        tag="delete", left=l_text, right="",
+                        line_left=ln_left + k, line_right=0,
+                    ))
+                else:
+                    diff_lines.append(DiffLine(
+                        tag="insert", left="", right=r_text,
+                        line_left=0, line_right=ln_right + k,
+                    ))
+            changed += max(len(left_chunk), len(right_chunk))
+            ln_left += i2 - i1
+            ln_right += j2 - j1
+
+        elif tag == "delete":
+            for k in range(i2 - i1):
+                diff_lines.append(DiffLine(
+                    tag="delete",
+                    left=left_lines[i1 + k], right="",
+                    line_left=ln_left + k, line_right=0,
+                ))
+            removed += i2 - i1
+            ln_left += i2 - i1
+
+        elif tag == "insert":
+            for k in range(j2 - j1):
+                diff_lines.append(DiffLine(
+                    tag="insert",
+                    left="", right=right_lines[j1 + k],
+                    line_left=0, line_right=ln_right + k,
+                ))
+            added += j2 - j1
+            ln_right += j2 - j1
+
+    similarity = matcher.ratio()
+    stats = CompareStats(
+        total_left=len(left_lines),
+        total_right=len(right_lines),
+        equal_lines=equal,
+        added_lines=added,
+        removed_lines=removed,
+        changed_lines=changed,
+        similarity=similarity,
+    )
+    return DiffResult(lines=diff_lines, stats=stats)
+
+
+def compare_bytes(left: bytes, right: bytes) -> DiffResult:
+    """Сравнить два байтовых потока (декодируются как UTF-8 с заменой)."""
+    return compare(
+        left.decode("utf-8", errors="replace"),
+        right.decode("utf-8", errors="replace"),
+    )

pentool/modules/decoder.py

@@ -0,0 +1,281 @@
+"""Decoder/Encoder — 15 операций encode/decode + хэширование."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import html
+import json
+import re
+import urllib.parse
+from dataclasses import dataclass, field
+from typing import Callable
+
+__all__ = [
+    "OPERATIONS",
+    "decode_smart",
+    "encode_op",
+    "decode_op",
+    "run_chain",
+    "DecoderChain",
+]
+
+# ── Реестр операций ────────────────────────────────────────────────────────────
+
+def _url_encode(s: str) -> str:
+    return urllib.parse.quote(s, safe="")
+
+def _url_decode(s: str) -> str:
+    return urllib.parse.unquote(s)
+
+def _url_encode_all(s: str) -> str:
+    return urllib.parse.quote(s, safe="")
+
+def _base64_encode(s: str) -> str:
+    return base64.b64encode(s.encode()).decode()
+
+def _base64_decode(s: str) -> str:
+    # Добавляем паддинг если нужно
+    padded = s + "=" * (4 - len(s) % 4) if len(s) % 4 else s
+    return base64.b64decode(padded).decode("utf-8", errors="replace")
+
+def _base64url_encode(s: str) -> str:
+    return base64.urlsafe_b64encode(s.encode()).decode().rstrip("=")
+
+def _base64url_decode(s: str) -> str:
+    padded = s + "=" * (4 - len(s) % 4) if len(s) % 4 else s
+    return base64.urlsafe_b64decode(padded).decode("utf-8", errors="replace")
+
+def _html_encode(s: str) -> str:
+    return html.escape(s, quote=True)
+
+def _html_decode(s: str) -> str:
+    return html.unescape(s)
+
+def _hex_encode(s: str) -> str:
+    return s.encode().hex()
+
+def _hex_decode(s: str) -> str:
+    # Убираем разделители
+    clean = re.sub(r"[\s:%-]", "", s)
+    # Оставляем только hex-символы
+    hex_only = re.sub(r"[^0-9a-fA-F]", "", clean)
+    if not hex_only:
+        return s  # не hex — возвращаем как есть
+    # Выравниваем до чётной длины
+    if len(hex_only) % 2:
+        hex_only = "0" + hex_only
+    return bytes.fromhex(hex_only).decode("utf-8", errors="replace")
+
+def _unicode_encode(s: str) -> str:
+    result = ""
+    for ch in s:
+        cp = ord(ch)
+        if cp > 127:
+            result += f"\\u{cp:04x}"
+        else:
+            result += ch
+    return result
+
+def _unicode_decode(s: str) -> str:
+    try:
+        return s.encode("raw_unicode_escape").decode("unicode_escape")
+    except Exception:
+        return re.sub(r"\\u([0-9a-fA-F]{4})", lambda m: chr(int(m.group(1), 16)), s)
+
+def _jwt_decode(s: str) -> str:
+    """Декодирует header + payload JWT без верификации подписи."""
+    parts = s.strip().split(".")
+    if len(parts) < 2:
+        return "Invalid JWT"
+    result = {}
+    for i, name in enumerate(("header", "payload")):
+        try:
+            part = parts[i]
+            padded = part + "=" * (4 - len(part) % 4) if len(part) % 4 else part
+            decoded = base64.urlsafe_b64decode(padded).decode("utf-8", errors="replace")
+            result[name] = json.loads(decoded)
+        except Exception as exc:
+            result[name] = f"[error: {exc}]"
+    return json.dumps(result, indent=2, ensure_ascii=False)
+
+def _md5(s: str) -> str:
+    return hashlib.md5(s.encode()).hexdigest()
+
+def _sha1(s: str) -> str:
+    return hashlib.sha1(s.encode()).hexdigest()
+
+def _sha256(s: str) -> str:
+    return hashlib.sha256(s.encode()).hexdigest()
+
+def _sha512(s: str) -> str:
+    return hashlib.sha512(s.encode()).hexdigest()
+
+def _gzip_encode(s: str) -> str:
+    import gzip
+    compressed = gzip.compress(s.encode())
+    return base64.b64encode(compressed).decode()
+
+def _gzip_decode(s: str) -> str:
+    import gzip
+    try:
+        padded = s + "=" * (4 - len(s) % 4) if len(s) % 4 else s
+        compressed = base64.b64decode(padded)
+        return gzip.decompress(compressed).decode("utf-8", errors="replace")
+    except Exception as exc:
+        return f"[gzip error: {exc}]"
+
+
+# ── Операции: (label, fn, is_hash) ────────────────────────────────────────────
+
+OPERATIONS: list[tuple[str, Callable[[str], str], bool]] = [
+    ("URL Encode",       _url_encode,       False),
+    ("URL Decode",       _url_decode,       False),
+    ("Base64 Encode",    _base64_encode,    False),
+    ("Base64 Decode",    _base64_decode,    False),
+    ("Base64URL Encode", _base64url_encode, False),
+    ("Base64URL Decode", _base64url_decode, False),
+    ("HTML Encode",      _html_encode,      False),
+    ("HTML Decode",      _html_decode,      False),
+    ("Hex Encode",       _hex_encode,       False),
+    ("Hex Decode",       _hex_decode,       False),
+    ("Unicode Encode",   _unicode_encode,   False),
+    ("Unicode Decode",   _unicode_decode,   False),
+    ("JWT Decode",       _jwt_decode,       False),
+    ("Gzip+B64 Encode",  _gzip_encode,      False),
+    ("Gzip+B64 Decode",  _gzip_decode,      False),
+    ("MD5",              _md5,              True),
+    ("SHA1",             _sha1,             True),
+    ("SHA256",           _sha256,           True),
+    ("SHA512",           _sha512,           True),
+]
+
+_OP_MAP: dict[str, Callable[[str], str]] = {label: fn for label, fn, _ in OPERATIONS}
+OP_LABELS: list[str] = [label for label, _, _ in OPERATIONS]
+
+
+def encode_op(operation: str, text: str) -> str:
+    """Применить операцию по имени. Raises KeyError если операция неизвестна."""
+    fn = _OP_MAP.get(operation)
+    if fn is None:
+        raise KeyError(f"Unknown operation: {operation!r}")
+    return fn(text)
+
+
+def decode_op(operation: str, text: str) -> str:
+    """Alias для encode_op (операции уже включают направление в названии)."""
+    return encode_op(operation, text)
+
+
+def run_chain(operations: list[str], text: str) -> tuple[str, list[str]]:
+    """Применить цепочку операций последовательно.
+
+    Returns:
+        (result, steps) — итоговый текст и список промежуточных значений.
+    """
+    steps: list[str] = [text]
+    current = text
+    for op in operations:
+        try:
+            current = encode_op(op, current)
+        except Exception as exc:
+            current = f"[error in {op!r}: {exc}]"
+        steps.append(current)
+    return current, steps
+
+
+def _detect_encoding(text: str) -> str | None:
+    """Detect the most likely encoding of text. Returns operation label or None."""
+    # JWT
+    if re.match(r"^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$", text):
+        return "JWT Decode"
+    # URL-encoded
+    if "%" in text and re.search(r"%[0-9a-fA-F]{2}", text):
+        return "URL Decode"
+    # HTML entities
+    if re.search(r"&(?:#\d+|#x[0-9a-fA-F]+|[a-zA-Z]+);", text):
+        return "HTML Decode"
+    # Gzip+B64 (gzip magic bytes when decoded: 1f8b)
+    b64_clean = text.strip().rstrip("=")
+    if re.match(r"^[A-Za-z0-9+/]+$", b64_clean) and len(b64_clean) % 4 in (0, 2, 3):
+        try:
+            raw = base64.b64decode(text + "=" * (-len(text) % 4))
+            if raw[:2] == b"\x1f\x8b":
+                return "Gzip+B64 Decode"
+        except Exception:
+            pass
+    # Hex
+    if re.match(r"^[0-9a-fA-F]+$", text) and len(text) % 2 == 0 and len(text) >= 4:
+        try:
+            decoded = bytes.fromhex(text).decode("utf-8", errors="strict")
+            if decoded.isprintable():
+                return "Hex Decode"
+        except Exception:
+            pass
+    # Base64URL (no +/ chars)
+    if re.match(r"^[A-Za-z0-9_-]+=*$", text) and len(text) >= 8:
+        try:
+            decoded = _base64url_decode(text)
+            if len(decoded) > 0 and sum(c.isprintable() for c in decoded) / len(decoded) > 0.8:
+                return "Base64URL Decode"
+        except Exception:
+            pass
+    # Base64 standard
+    if re.match(r"^[A-Za-z0-9+/]+=*$", text) and len(text) >= 8 and len(text) % 4 in (0, 2, 3):
+        try:
+            decoded = _base64_decode(text)
+            if len(decoded) > 0 and sum(c.isprintable() for c in decoded) / len(decoded) > 0.8:
+                return "Base64 Decode"
+        except Exception:
+            pass
+    return None
+
+
+def decode_smart(text: str, max_depth: int = 8) -> str:
+    """Auto-detect encoding and apply chain decoding until no more layers found.
+
+    Tries up to max_depth decode operations. Shows the chain in the result
+    by prepending a header line when multiple steps were applied.
+    Returns the final decoded value.
+    """
+    text = text.strip()
+    current = text
+    chain: list[str] = []
+
+    for _ in range(max_depth):
+        op = _detect_encoding(current)
+        if op is None:
+            break
+        try:
+            next_val = encode_op(op, current)
+            if next_val == current:
+                break
+            chain.append(op)
+            current = next_val
+        except Exception:
+            break
+
+    if not chain:
+        return text
+    return current
+
+
+@dataclass
+class DecoderChain:
+    """Цепочка операций с историей."""
+
+    operations: list[str] = field(default_factory=list)
+
+    def add(self, op: str) -> None:
+        if op not in OP_LABELS:
+            raise KeyError(f"Unknown operation: {op!r}")
+        self.operations.append(op)
+
+    def remove(self, index: int) -> None:
+        del self.operations[index]
+
+    def clear(self) -> None:
+        self.operations.clear()
+
+    def run(self, text: str) -> tuple[str, list[str]]:
+        return run_chain(self.operations, text)