pentool 0.1.0__py3-none-any.whl

pentool/utils/cert.py

@@ -0,0 +1,314 @@
+"""Генерация и управление TLS-сертификатами для HTTPS-перехвата прокси."""
+
+from __future__ import annotations
+
+import ipaddress
+import os
+import ssl
+import tempfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
+from cryptography.x509 import Certificate
+from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
+
+
+def _generate_rsa_key(key_size: int = 2048) -> RSAPrivateKey:
+    return rsa.generate_private_key(public_exponent=65537, key_size=key_size)
+
+
+def _key_to_pem(key: RSAPrivateKey) -> bytes:
+    """Сериализовать приватный ключ в PEM без пароля."""
+    return key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+
+def _cert_to_pem(cert: Certificate) -> bytes:
+    """Сериализовать сертификат в PEM."""
+    return cert.public_bytes(serialization.Encoding.PEM)
+
+
+def generate_ca_cert(cert_dir: str) -> tuple[str, str]:
+    dir_path = Path(cert_dir)
+    dir_path.mkdir(parents=True, exist_ok=True)
+    # Устанавливаем права 700 для директории с сертификатами
+    dir_path.chmod(0o700)
+
+    cert_path = dir_path / "ca.crt"
+    key_path = dir_path / "ca.key"
+
+    if cert_path.exists() and key_path.exists():
+        return str(cert_path), str(key_path)
+
+    key = _generate_rsa_key(4096)
+    now = datetime.now(timezone.utc)
+
+    subject = issuer = x509.Name([
+        x509.NameAttribute(NameOID.COMMON_NAME, "Pentool CA"),
+        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Pentool"),
+        x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "Security Testing"),
+    ])
+
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(subject)
+        .issuer_name(issuer)
+        .public_key(key.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(now)
+        .not_valid_after(now + timedelta(days=3650))  # 10 лет
+        .add_extension(x509.BasicConstraints(ca=True, path_length=None), critical=True)
+        .add_extension(
+            x509.KeyUsage(
+                digital_signature=True,
+                content_commitment=False,
+                key_encipherment=False,
+                data_encipherment=False,
+                key_agreement=False,
+                key_cert_sign=True,
+                crl_sign=True,
+                encipher_only=False,
+                decipher_only=False,
+            ),
+            critical=True,
+        )
+        .add_extension(
+            x509.SubjectKeyIdentifier.from_public_key(key.public_key()),
+            critical=False,
+        )
+        .sign(key, hashes.SHA256())
+    )
+
+    cert_path.write_bytes(_cert_to_pem(cert))
+    cert_path.chmod(0o644)
+
+    key_path.write_bytes(_key_to_pem(key))
+    key_path.chmod(0o600)
+
+    return str(cert_path), str(key_path)
+
+
+def load_or_create_ca(cert_dir: str) -> tuple[str, str]:
+    return generate_ca_cert(cert_dir)
+
+
+def generate_domain_cert(
+    domain: str,
+    ca_cert_path: str,
+    ca_key_path: str,
+) -> tuple[bytes, bytes]:
+    # Загрузить CA
+    ca_cert = x509.load_pem_x509_certificate(Path(ca_cert_path).read_bytes())
+    ca_key_data = Path(ca_key_path).read_bytes()
+    ca_key = serialization.load_pem_private_key(ca_key_data, password=None)
+
+    key = _generate_rsa_key(2048)
+    now = datetime.now(timezone.utc)
+
+    subject = x509.Name([
+        x509.NameAttribute(NameOID.COMMON_NAME, domain),
+    ])
+
+    # Определить SAN: IP или DNS
+    san_list: list[x509.GeneralName] = []
+    try:
+        san_list.append(x509.IPAddress(ipaddress.ip_address(domain)))
+    except ValueError:
+        san_list.append(x509.DNSName(domain))
+        # Добавить wildcard для поддоменов
+        if "." in domain and not domain.startswith("*."):
+            san_list.append(x509.DNSName(f"*.{domain}"))
+
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(subject)
+        .issuer_name(ca_cert.subject)
+        .public_key(key.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(now)
+        .not_valid_after(now + timedelta(days=825))  # ~2 года 3 месяца
+        .add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
+        .add_extension(x509.SubjectAlternativeName(san_list), critical=False)
+        .add_extension(
+            x509.KeyUsage(
+                digital_signature=True,
+                content_commitment=False,
+                key_encipherment=True,
+                data_encipherment=False,
+                key_agreement=False,
+                key_cert_sign=False,
+                crl_sign=False,
+                encipher_only=False,
+                decipher_only=False,
+            ),
+            critical=True,
+        )
+        .add_extension(
+            x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH]),
+            critical=False,
+        )
+        .sign(ca_key, hashes.SHA256())
+    )
+
+    return _cert_to_pem(cert), _key_to_pem(key)
+
+
+def create_ssl_context_for_domain(
+    domain: str,
+    ca_cert_path: str,
+    ca_key_path: str,
+    cert_dir: str | None = None,
+) -> ssl.SSLContext:
+    # ── Уровень 1: in-memory LRU ──────────────────────────────────────────────
+    cache_key = f"{domain}:{ca_cert_path}"
+    ctx = _ssl_ctx_cache.get(cache_key)
+    if ctx is not None:
+        return ctx
+
+    # ── Уровень 2: disk-cache ─────────────────────────────────────────────────
+    ctx = _load_ctx_from_disk(domain, ca_cert_path, cert_dir)
+    if ctx is not None:
+        _ssl_ctx_cache.put(cache_key, ctx)
+        return ctx
+
+    # ── Генерация нового сертификата ──────────────────────────────────────────
+    cert_pem, key_pem = generate_domain_cert(domain, ca_cert_path, ca_key_path)
+
+    # Сохранить на диск (если cert_dir задан)
+    _save_ctx_to_disk(domain, cert_pem, key_pem, cert_dir)
+
+    ctx = _build_ssl_ctx(cert_pem, key_pem)
+    _ssl_ctx_cache.put(cache_key, ctx)
+    return ctx
+
+
+# ── Вспомогательные функции для disk-cache ────────────────────────────────────
+
+def _domain_cache_path(domain: str, cert_dir: str) -> Path:
+    """Путь к кэш-файлу для домена: {cert_dir}/domains/{sha256(domain)[:16]}.pem"""
+    import hashlib
+    key = hashlib.sha256(domain.encode()).hexdigest()[:16]
+    return Path(cert_dir) / "domains" / f"{key}.pem"
+
+
+def _load_ctx_from_disk(
+    domain: str, ca_cert_path: str, cert_dir: str | None
+) -> ssl.SSLContext | None:
+    """Попытаться загрузить сертификат из disk-cache.
+
+    Проверяет:
+    - файл существует
+    - CN сертификата совпадает с доменом
+    - срок действия не истекает в ближайшие 30 дней
+    """
+    if not cert_dir:
+        return None
+    path = _domain_cache_path(domain, cert_dir)
+    if not path.exists():
+        return None
+    try:
+        pem_data = path.read_bytes()
+        # Файл содержит cert_pem + key_pem, разделённые маркером
+        sep = b"-----BEGIN RSA PRIVATE KEY-----"
+        sep2 = b"-----BEGIN PRIVATE KEY-----"
+        if sep in pem_data:
+            cert_pem, key_pem = pem_data.split(sep, 1)
+            key_pem = sep + key_pem
+        elif sep2 in pem_data:
+            cert_pem, key_pem = pem_data.split(sep2, 1)
+            key_pem = sep2 + key_pem
+        else:
+            return None
+
+        # Проверить срок действия
+        cert = x509.load_pem_x509_certificate(cert_pem)
+        expires = cert.not_valid_after_utc
+        margin = timedelta(days=30)
+        if expires - datetime.now(timezone.utc) < margin:
+            path.unlink(missing_ok=True)
+            return None
+
+        return _build_ssl_ctx(cert_pem, key_pem)
+    except Exception:
+        # Повреждённый кэш — удалить и регенерировать
+        try:
+            path.unlink(missing_ok=True)
+        except Exception:
+            pass
+        return None
+
+
+def _save_ctx_to_disk(
+    domain: str, cert_pem: bytes, key_pem: bytes, cert_dir: str | None
+) -> None:
+    if not cert_dir:
+        return
+    try:
+        path = _domain_cache_path(domain, cert_dir)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(cert_pem + key_pem)
+        path.chmod(0o600)
+    except Exception:
+        pass  # disk-cache не критичен — продолжаем без него
+
+
+def _build_ssl_ctx(cert_pem: bytes, key_pem: bytes) -> ssl.SSLContext:
+    """Собрать SSLContext из PEM-байтов через временные файлы."""
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    ctx.check_hostname = False
+    ctx.set_alpn_protocols(["http/1.1"])
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".crt") as cf:
+        cf.write(cert_pem)
+        cert_tmp = cf.name
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".key") as kf:
+        kf.write(key_pem)
+        key_tmp = kf.name
+
+    try:
+        ctx.load_cert_chain(cert_tmp, key_tmp)
+    finally:
+        os.unlink(cert_tmp)
+        os.unlink(key_tmp)
+
+    return ctx
+
+
+# ── In-memory LRU cache для SSL-контекстов (1000 доменов) ────────────────────
+
+class _SslCtxLRU:
+    """Простой LRU-кэш для SSLContext объектов.
+
+    Ключ — строка "{domain}:{ca_cert_path}", значение — ssl.SSLContext.
+    Максимум 1000 записей — примерно 1–2 МБ памяти.
+    """
+    def __init__(self, max_size: int = 1000) -> None:
+        from collections import OrderedDict
+        self._data: "OrderedDict[str, ssl.SSLContext]" = OrderedDict()
+        self._max = max_size
+
+    def get(self, key: str) -> ssl.SSLContext | None:
+        if key not in self._data:
+            return None
+        self._data.move_to_end(key)
+        return self._data[key]
+
+    def put(self, key: str, ctx: ssl.SSLContext) -> None:
+        if key in self._data:
+            self._data.move_to_end(key)
+            self._data[key] = ctx
+            return
+        self._data[key] = ctx
+        if len(self._data) > self._max:
+            self._data.popitem(last=False)
+
+
+_ssl_ctx_cache = _SslCtxLRU(max_size=1000)

pentool/utils/coder.py

@@ -0,0 +1,170 @@
+"""Кодирование, декодирование и хэширование строк."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import html
+import urllib.parse
+from typing import Callable
+
+
+def url_encode(text: str) -> str:
+    """URL-кодировать строку (все символы, кроме букв/цифр/'-._~')."""
+    return urllib.parse.quote(text, safe="")
+
+
+def url_decode(text: str) -> str:
+    """URL-декодировать строку."""
+    return urllib.parse.unquote(text)
+
+
+def url_encode_all(text: str) -> str:
+    """URL-кодировать строку, включая пробелы как %20."""
+    return urllib.parse.quote(text, safe="")
+
+
+def url_decode_plus(text: str) -> str:
+    """URL-декодировать строку, обрабатывая '+' как пробел."""
+    return urllib.parse.unquote_plus(text)
+
+
+def base64_encode(text: str) -> str:
+    """Закодировать строку в стандартный Base64."""
+    return base64.b64encode(text.encode("utf-8")).decode("ascii")
+
+
+def base64_decode(text: str) -> str:
+    """Декодировать строку из стандартного Base64.
+
+    Raises:
+        ValueError: Если строка не является корректным Base64.
+    """
+    try:
+        padded = text + "=" * (-len(text) % 4)
+        return base64.b64decode(padded).decode("utf-8", errors="replace")
+    except Exception as exc:
+        raise ValueError(f"Invalid base64: {exc}") from exc
+
+
+def base64url_encode(text: str) -> str:
+    """Закодировать строку в URL-safe Base64 (без паддинга)."""
+    return base64.urlsafe_b64encode(text.encode("utf-8")).decode("ascii").rstrip("=")
+
+
+def base64url_decode(text: str) -> str:
+    """Декодировать строку из URL-safe Base64.
+
+    Raises:
+        ValueError: Если строка не является корректным Base64url.
+    """
+    try:
+        padded = text + "=" * (-len(text) % 4)
+        return base64.urlsafe_b64decode(padded).decode("utf-8", errors="replace")
+    except Exception as exc:
+        raise ValueError(f"Invalid base64url: {exc}") from exc
+
+
+def html_encode(text: str) -> str:
+    """HTML-кодировать строку (заменить спецсимволы на HTML-сущности)."""
+    return html.escape(text, quote=True)
+
+
+def html_decode(text: str) -> str:
+    """HTML-декодировать строку (заменить HTML-сущности на символы)."""
+    return html.unescape(text)
+
+
+def hex_encode(text: str) -> str:
+    """Закодировать строку в hex-представление байт (UTF-8)."""
+    return text.encode("utf-8").hex()
+
+
+def hex_decode(text: str) -> str:
+    """Декодировать hex-строку обратно в текст.
+
+    Raises:
+        ValueError: Если строка не является корректным hex.
+    """
+    try:
+        clean = text.replace(" ", "").replace("\\x", "").replace("0x", "")
+        return bytes.fromhex(clean).decode("utf-8", errors="replace")
+    except Exception as exc:
+        raise ValueError(f"Invalid hex: {exc}") from exc
+
+
+def unicode_escape(text: str) -> str:
+    """Закодировать строку в Unicode escape (\\uXXXX для не-ASCII)."""
+    result = []
+    for ch in text:
+        code = ord(ch)
+        if code > 127:
+            result.append(f"\\u{code:04x}")
+        else:
+            result.append(ch)
+    return "".join(result)
+
+
+def unicode_unescape(text: str) -> str:
+    """Декодировать строку из Unicode escape."""
+    try:
+        return text.encode("utf-8").decode("unicode_escape")
+    except Exception:
+        import codecs
+        try:
+            return codecs.decode(text, "unicode_escape")
+        except Exception as exc:
+            raise ValueError(f"Invalid unicode escape: {exc}") from exc
+
+
+def md5(text: str) -> str:
+    """Вычислить MD5-хэш строки (hex-дайджест)."""
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+
+def sha1(text: str) -> str:
+    """Вычислить SHA1-хэш строки (hex-дайджест)."""
+    return hashlib.sha1(text.encode("utf-8")).hexdigest()
+
+
+def sha256(text: str) -> str:
+    """Вычислить SHA256-хэш строки (hex-дайджест)."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+OPERATIONS: dict[str, Callable[[str], str]] = {
+    "url_encode": url_encode,
+    "url_decode": url_decode,
+    "base64_encode": base64_encode,
+    "base64_decode": base64_decode,
+    "base64url_encode": base64url_encode,
+    "base64url_decode": base64url_decode,
+    "html_encode": html_encode,
+    "html_decode": html_decode,
+    "hex_encode": hex_encode,
+    "hex_decode": hex_decode,
+    "unicode_escape": unicode_escape,
+    "unicode_unescape": unicode_unescape,
+    "md5": md5,
+    "sha1": sha1,
+    "sha256": sha256,
+}
+
+
+def apply_operation(operation: str, text: str) -> str:
+    """Применить именованную операцию к тексту.
+
+    Args:
+        operation: Имя операции из OPERATIONS.
+        text: Входная строка.
+
+    Returns:
+        Результат операции.
+
+    Raises:
+        ValueError: Если операция неизвестна.
+    """
+    func = OPERATIONS.get(operation)
+    if func is None:
+        raise ValueError(f"Unknown operation: {operation!r}. Available: {list(OPERATIONS)}")
+    return func(text)