spluspy 2.0.7__tar.gz → 2.0.8__tar.gz

{spluspy-2.0.7 → spluspy-2.0.8}/CHANGELOG.md

@@ -5,10 +5,11 @@ All notable changes to SplusPy will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
-## [2.0.7] - 2026-07-11
+## [2.0.8] - 2026-07-12
 
 ### Changed
-- Version bump to 2.0.7
+- Version bump to 2.0.8
+- Downgraded verbose internal warnings (USER_ALREADY_JOINED, missing access_hash, TypeNotFoundError) from WARNING to DEBUG level to reduce log noise
 
 ## [2.0.6] - 2026-07-11
 

{spluspy-2.0.7 → spluspy-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.0.7
+Version: 2.0.8
 Summary: A modern async Python library for interacting with Soroush Plus
 Project-URL: Homepage, https://github.com/Itskillmaster/spluspy
 Project-URL: Documentation, https://github.com/Itskillmaster/spluspy#readme

{spluspy-2.0.7 → spluspy-2.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "spluspy"
-version = "2.0.7"
+version = "2.0.8"
 description = "A modern async Python library for interacting with Soroush Plus"
 readme = "README.md"
 license = "MIT"

spluspy-2.0.8/setup.py

@@ -0,0 +1,48 @@
+"""
+setup.py — Build script for spluspy Cython extensions.
+
+Build locally with:
+
+    pip install cython cryptography
+    python setup.py build_ext --inplace
+
+Or install in editable/development mode:
+
+    pip install -e ".[speed]"
+
+The compiled ``.so`` / ``.pyd`` modules are placed alongside the source
+``.pyx`` files so the dispatcher in ``__init__.py`` can find them at
+import time.
+"""
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+
+extensions = [
+    Extension(
+        "spluspy._engine.crypto.fast_aes",
+        sources=["spluspy/_engine/crypto/fast_aes.pyx"],
+        # No extra link flags needed — OpenSSL is loaded at runtime via
+        # the cryptography library's bundled libcrypto or via ctypes.
+    ),
+    Extension(
+        "spluspy._engine.crypto.fast_rsa",
+        sources=["spluspy/_engine/crypto/fast_rsa.pyx"],
+        # The cryptography package is a runtime dependency of this module.
+        # It is listed in pyproject.toml under [project.optional-dependencies]
+        # under the "crypto" extra.
+    ),
+]
+
+setup(
+    ext_modules=cythonize(
+        extensions,
+        compiler_directives={
+            "language_level": "3",       # Python 3 semantics
+            "boundscheck": False,        # skip bounds checks for speed
+            "wraparound": False,         # skip negative-index wrapping
+            "cdivision": True,           # use C division (no ZeroDivisionError)
+            "initializedcheck": False,   # skip memoryview init checks
+            "nonecheck": False,          # skip None checks on typed vars
+        },
+    ),
+)

{spluspy-2.0.7 → spluspy-2.0.8}/spluspy/__version__.py

@@ -1,6 +1,6 @@
 """SplusPy version information."""
 
-__version__ = "2.0.7"
+__version__ = "2.0.8"
 __author__ = "Ali Mirshekari"
 __license__ = "MIT"
 __url__ = "https://github.com/Itskillmaster/spluspy"

spluspy-2.0.8/spluspy/_engine/crypto/__init__.py

@@ -0,0 +1,86 @@
+"""
+This module contains several utilities regarding cryptographic purposes,
+such as the AES IGE mode used by SoroushPlus, the authorization key bound with
+their data centers, and so on.
+
+Dispatching strategy
+--------------------
+The ``AES`` class and the ``rsa`` submodule are resolved at import time
+using a two-tier fallback:
+
+1. **Fast path** – compiled Cython extensions (``fast_aes`` / ``fast_rsa``)
+   backed by OpenSSL via the ``cryptography`` library.
+2. **Pure-Python path** – ``aes`` (``pyaes`` / ``cryptg`` / ``libssl``) and
+   ``rsa`` (``rsa`` package).
+
+If the compiled extensions are not available (the ``.so`` / ``.pyd`` files
+have not been built, or a required dependency is missing), the dispatcher
+silently falls back to the pure-Python implementations.
+"""
+import sys as _sys
+import logging as _logging
+
+_log = _logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# AES dispatcher  —  prefers Cython fast_aes, falls back to pure-Python aes
+# ---------------------------------------------------------------------------
+try:
+    from .fast_aes import encrypt_ige as _fast_encrypt_ige
+    from .fast_aes import decrypt_ige as _fast_decrypt_ige
+
+    class AES:
+        """
+        AES-IGE encryption / decryption interface.
+
+        When the Cython ``fast_aes`` extension is available the operations
+        are dispatched to OpenSSL (via the ``cryptography`` library) through
+        a Cython-typed wrapper.  Otherwise the pure-Python ``aes.AES``
+        implementation is used.
+        """
+
+        __slots__ = ()  # no instance state — all methods are static
+
+        @staticmethod
+        def encrypt_ige(plain_text: bytes, key: bytes, iv: bytes) -> bytes:
+            """Encrypt *plain_text* using AES-IGE."""
+            return _fast_encrypt_ige(plain_text, key, iv)
+
+        @staticmethod
+        def decrypt_ige(cipher_text: bytes, key: bytes, iv: bytes) -> bytes:
+            """Decrypt *cipher_text* using AES-IGE."""
+            return _fast_decrypt_ige(cipher_text, key, iv)
+
+    _log.debug('fast_aes Cython extension loaded – using OpenSSL AES-IGE')
+
+except ImportError:
+    from .aes import AES
+    _log.debug('fast_aes not available – using pure-Python AES fallback')
+
+# ---------------------------------------------------------------------------
+# RSA dispatcher  —  prefers Cython fast_rsa, falls back to pure-Python rsa
+#
+# Consumers typically ``from ..crypto import rsa`` which resolves the
+# submodule *rsa*.  By injecting ``fast_rsa`` into ``sys.modules`` under
+# the same dotted name *before* any other code imports ``.rsa``, we can
+# transparently swap in the faster implementation.
+# ---------------------------------------------------------------------------
+_RSA_PKG = f'{__name__}.rsa'          # e.g. "spluspy._engine.crypto.rsa"
+
+try:
+    from . import fast_rsa as _fast_rsa  # noqa: F401 — triggers import
+
+    # Only replace if the original rsa module hasn't been imported yet.
+    if _RSA_PKG not in _sys.modules:
+        _sys.modules[_RSA_PKG] = _fast_rsa
+    _log.debug('fast_rsa Cython extension loaded – using OpenSSL RSA')
+except ImportError:
+    _log.debug('fast_rsa not available – using pure-Python RSA fallback')
+
+# ---------------------------------------------------------------------------
+# Other submodules — always imported directly (no fast variant yet)
+# ---------------------------------------------------------------------------
+from .aesctr import AESModeCTR
+from .authkey import AuthKey
+from .factorization import Factorization
+from .cdndecrypter import CdnDecrypter

spluspy-2.0.8/spluspy/_engine/crypto/fast_aes.pyx

@@ -0,0 +1,226 @@
+# cython: language_level=3, boundscheck=False, wraparound=False
+"""
+High-performance AES-IGE encryption/decryption using OpenSSL via Cython.
+
+This module provides AES-IGE encrypt/decrypt optimized with:
+- Direct OpenSSL calls via the ``cryptography`` library's bundled bindings
+  (falls back to ``ctypes.util.find_library`` if unavailable).
+- C-level ``malloc``/``memcpy``/``free`` for buffer management, avoiding
+  intermediate Python objects in the hot path.
+
+Falls back gracefully: if neither the ``cryptography`` library nor a
+system OpenSSL is reachable, an ``ImportError`` is raised at import time
+so the dispatcher in ``__init__.py`` can select the pure-Python path.
+"""
+import ctypes
+import ctypes.util
+import os
+import sys
+from libc.stdlib cimport malloc, free
+from libc.string cimport memcpy
+
+# ---------------------------------------------------------------------------
+# OpenSSL loading
+# ---------------------------------------------------------------------------
+cdef bint _loaded = False
+cdef object _lib = None          # ctypes CDLL handle
+cdef object _AES_set_encrypt_key = None
+cdef object _AES_set_decrypt_key = None
+cdef object _AES_ige_encrypt = None
+
+# AES_KEY struct size (AES-256: 4*(14+1)*4 = 240 bytes rd_key + 4 bytes rounds)
+cdef int _AES_KEY_SIZE = 260
+
+
+cdef void _ensure_openssl():
+    """Lazily load OpenSSL and configure ctypes function signatures."""
+    global _loaded, _lib
+    global _AES_set_encrypt_key, _AES_set_decrypt_key, _AES_ige_encrypt
+    if _loaded:
+        return
+    _loaded = True
+
+    # --- Strategy 1: use the cryptography library's bundled OpenSSL ---
+    try:
+        from cryptography.hazmat.bindings.openssl import binding
+        _lib = binding.Binding.lib
+    except Exception:
+        _lib = None
+
+    # --- Strategy 2: fall back to system OpenSSL ---
+    if _lib is None:
+        try:
+            _lib = ctypes.cdll.LoadLibrary(
+                ctypes.util.find_library('ssl')
+                or ctypes.util.find_library('crypto')
+            )
+        except OSError:
+            _lib = None
+
+    if _lib is None:
+        return
+
+    # Configure AES_set_encrypt_key
+    _AES_set_encrypt_key = _lib.AES_set_encrypt_key
+    _AES_set_encrypt_key.restype = ctypes.c_int
+    _AES_set_encrypt_key.argtypes = [
+        ctypes.c_char_p,    # const unsigned char *userKey
+        ctypes.c_int,       # int bits
+        ctypes.c_void_p,    # AES_KEY *aesKey
+    ]
+
+    # Configure AES_set_decrypt_key
+    _AES_set_decrypt_key = _lib.AES_set_decrypt_key
+    _AES_set_decrypt_key.restype = ctypes.c_int
+    _AES_set_decrypt_key.argtypes = [
+        ctypes.c_char_p,    # const unsigned char *userKey
+        ctypes.c_int,       # int bits
+        ctypes.c_void_p,    # AES_KEY *aesKey
+    ]
+
+    # Configure AES_ige_encrypt — use c_void_p for all pointer args so we
+    # can pass integer addresses from Cython malloc'd buffers.
+    _AES_ige_encrypt = _lib.AES_ige_encrypt
+    _AES_ige_encrypt.restype = None
+    _AES_ige_encrypt.argtypes = [
+        ctypes.c_void_p,    # const unsigned char *in
+        ctypes.c_void_p,    # unsigned char *out
+        ctypes.c_size_t,    # size_t length
+        ctypes.c_void_p,    # AES_KEY *key
+        ctypes.c_void_p,    # unsigned char *iv (32 bytes)
+        ctypes.c_int,       # int enc (1=encrypt, 0=decrypt)
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def encrypt_ige(bytes plain_text, bytes key, bytes iv) -> bytes:
+    """
+    AES-IGE *encrypt* using OpenSSL.
+
+    :param plain_text: plaintext (will be padded to a 16-byte boundary).
+    :param key:        AES key (16, 24 or 32 bytes).
+    :param iv:         32-byte IGE initialization vector.
+    :returns:          ciphertext bytes.
+    :raises RuntimeError: if OpenSSL is not available.
+    """
+    _ensure_openssl()
+    if _AES_ige_encrypt is None:
+        raise RuntimeError(
+            "OpenSSL AES_ige_encrypt is not available. "
+            "Install the ``cryptography`` package or ensure libssl/libcrypto "
+            "is reachable via ctypes."
+        )
+
+    # Pad plaintext to 16-byte boundary (matches existing aes.py behaviour)
+    cdef Py_ssize_t pt_len = len(plain_text)
+    cdef int remainder = pt_len % 16
+    if remainder:
+        plain_text = plain_text + os.urandom(16 - remainder)
+        pt_len = len(plain_text)
+
+    # Allocate C-level buffers via libc (no Python object overhead)
+    cdef unsigned char *in_buf  = <unsigned char *>malloc(pt_len)
+    cdef unsigned char *out_buf = <unsigned char *>malloc(pt_len)
+    cdef unsigned char *aes_key = <unsigned char *>malloc(_AES_KEY_SIZE)
+
+    if in_buf == NULL or out_buf == NULL or aes_key == NULL:
+        free(in_buf)
+        free(out_buf)
+        free(aes_key)
+        raise MemoryError("Failed to allocate buffers for AES-IGE")
+
+    cdef int rc = 0
+    cdef const unsigned char[:] pt_view = plain_text
+    cdef const unsigned char[:] iv_view  = iv
+
+    try:
+        # Copy plaintext into C buffer
+        memcpy(in_buf, &pt_view[0], <size_t>pt_len)
+
+        # Set up AES encrypt key schedule
+        # key is passed as bytes (ctypes c_char_p); aes_key as void* integer
+        rc = _AES_set_encrypt_key(key, <int>(len(key) * 8), <size_t>aes_key)
+        if rc != 0:
+            raise RuntimeError(f"AES_set_encrypt_key failed (rc={rc})")
+
+        # Perform IGE encryption — all pointer args as integer addresses
+        _AES_ige_encrypt(
+            <size_t>in_buf,
+            <size_t>out_buf,
+            <size_t>pt_len,
+            <size_t>aes_key,
+            <size_t>&iv_view[0],
+            <int>1,  # AES_ENCRYPT
+        )
+
+        # Build Python bytes from C buffer
+        return bytes(out_buf[:pt_len])
+    finally:
+        free(in_buf)
+        free(out_buf)
+        free(aes_key)
+
+
+def decrypt_ige(bytes cipher_text, bytes key, bytes iv) -> bytes:
+    """
+    AES-IGE *decrypt* using OpenSSL.
+
+    :param cipher_text: ciphertext (must be a multiple of 16 bytes).
+    :param key:         AES key (16, 24 or 32 bytes).
+    :param iv:          32-byte IGE initialization vector.
+    :returns:           plaintext bytes.
+    :raises RuntimeError: if OpenSSL is not available.
+    """
+    _ensure_openssl()
+    if _AES_ige_encrypt is None:
+        raise RuntimeError(
+            "OpenSSL AES_ige_encrypt is not available. "
+            "Install the ``cryptography`` package or ensure libssl/libcrypto "
+            "is reachable via ctypes."
+        )
+
+    cdef Py_ssize_t ct_len = len(cipher_text)
+
+    # Allocate C-level buffers
+    cdef unsigned char *in_buf  = <unsigned char *>malloc(ct_len)
+    cdef unsigned char *out_buf = <unsigned char *>malloc(ct_len)
+    cdef unsigned char *aes_key = <unsigned char *>malloc(_AES_KEY_SIZE)
+
+    if in_buf == NULL or out_buf == NULL or aes_key == NULL:
+        free(in_buf)
+        free(out_buf)
+        free(aes_key)
+        raise MemoryError("Failed to allocate buffers for AES-IGE")
+
+    cdef int rc = 0
+    cdef const unsigned char[:] ct_view = cipher_text
+    cdef const unsigned char[:] iv_view  = iv
+
+    try:
+        # Copy ciphertext into C buffer
+        memcpy(in_buf, &ct_view[0], <size_t>ct_len)
+
+        # Set up AES decrypt key schedule
+        rc = _AES_set_decrypt_key(key, <int>(len(key) * 8), <size_t>aes_key)
+        if rc != 0:
+            raise RuntimeError(f"AES_set_decrypt_key failed (rc={rc})")
+
+        # Perform IGE decryption
+        _AES_ige_encrypt(
+            <size_t>in_buf,
+            <size_t>out_buf,
+            <size_t>ct_len,
+            <size_t>aes_key,
+            <size_t>&iv_view[0],
+            <int>0,  # AES_DECRYPT
+        )
+
+        # Build Python bytes from C buffer
+        return bytes(out_buf[:ct_len])
+    finally:
+        free(in_buf)
+        free(out_buf)
+        free(aes_key)