Red-YT-Cipher-Solver 0.1.0__tar.gz

red_yt_cipher_solver-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: Red-YT-Cipher-Solver
+Version: 0.1.0
+Summary: A thin wrapper over yt-dlp/ejs for deciphering YT signatures. Comes with Deno out of the box.
+Author: Jakub Kuczys
+Author-email: Jakub Kuczys <me@jacken.men>
+Requires-Dist: aiohttp>=3.9.5,<4
+Requires-Dist: deno>=2.7.1,<3
+Requires-Dist: typing-extensions~=4.15.0
+Requires-Dist: yarl~=1.15.2
+Requires-Dist: yt-dlp-ejs~=0.5.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Red-YT-Cipher-Solver
+
+A thin wrapper over [yt-dlp/ejs](https://github.com/yt-dlp/ejs) for deciphering YT signatures.
+Aside from yt-dlp/ejs, this uses the [official Deno PyPI package](https://github.com/denoland/deno_pypi),
+meaning no additional setup is required beyond installing the package and then using it either as a library
+or as a [Lavalink-compatible cipher server](https://github.com/lavalink-devs/youtube-source#using-a-remote-cipher-server).
+
+## Using this project
+
+This package only functions on systems supported by Deno JS runtime.
+At the time of writing, this includes:
+-   Windows x86_64
+-   macOS x86_64 & arm64
+-   Linux x86_64 & aarch64 with glibc 2.27 or higher
+
+> [!NOTE]
+> If you intend to add this as a dependency to your project and want to support other platforms as well,
+ensure to specify appropriate environment markers for the dependency and guard your imports appropriately
+as the `deno` dependency of this project will not install on unsupported platforms:
+> -   `pyproject.toml`
+>     ```toml
+>     [project]
+>     # [...]
+>     dependencies = [
+>         """\
+>         Red-YT-Cipher-Solver; \
+>             (sys_platform == 'win32' and platform_machine == 'AMD64') \
+>             or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) \
+>             or (sys_platform == 'darwin' and (platform_machine == 'x86_64' or platform_machine == 'arm64')) \
+>         """,
+>     ]
+>
+>     # [...]
+>     ```
+> -   `requirements.txt`
+>     ```
+>     Red-YT-Cipher-Solver; (sys_platform == 'win32' and platform_machine == 'AMD64') or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and (platform_machine == 'x86_64' or platform_machine == 'arm64'))
+>     # [...]
+>     ```
+
+### Installation
+
+Install the package:
+-   Linux & macOS
+    ```console
+    python3.10 -m venv red_yt_cipher_solver
+    . red_yt_cipher_solver/bin/activate
+    python -m pip install -U Red-YT-Cipher-Solver
+    ```
+-   Windows
+    ```powershell
+    py -3.10 -m venv red_yt_cipher_solver
+    red_yt_cipher_solver\Scripts\Activate.ps1
+    python -m pip install -U Red-YT-Cipher-Solver
+    ```
+
+### Running as a server
+
+Run the server with the default configuration (listening on `http://localhost:2334` with no authentication):
+```console
+red-yt-cipher-solver serve
+```
+
+To specify custom hostname and port, use the positional arguments:
+```console
+red-yt-cipher-solver 0.0.0.0 4242
+```
+
+You can require the clients to send an `Authorization` header with a token
+by specifying one in the `RED_YT_CIPHER_SERVER_TOKEN` environment variable.
+
+### Using as a standalone solver
+
+```
+$ red-yt-cipher-solver solve --help
+usage: red-yt-cipher-solver solve [-h] [--encrypted-signature ENCRYPTED_SIGNATURE]
+                                  [--n-param N_PARAM] [--signature-key SIGNATURE_KEY]
+                                  [--include-player-content]
+                                  player_url stream_url
+```
+
+Solve a JS challenge request using the yt-dlp/ejs solver:
+```console
+red-yt-cipher-solver solve \
+    /s/player/00c52fa0/player_ias.vflset/de_DE/base.js \
+    "https://rr4---sn-4g5e6nzl.googlevideo.com/videoplayback?expire=1772476120&n=Fc9IL2b0xD7Lybd7&ei=..." \
+    --encrypted-signature "R=ANHkhNZInqwBBEsHpvykqHsygJje6J4T_Q-aL2VO7PkCQIC4ruoYYg2TeWFSfKXFTeQF=B_hR1UlnJw75Wfb24g6nQgIQRw4MNqEHA"
+```
+
+### Using as a library
+
+While this is mostly a thin wrapper over yt-dlp/ejs, it does come with Deno out of the box,
+so it might be of interest to some to use that wrapper directly.
+
+The following functions are currently exposed in `red_yt_cipher_solver`
+
+#### `solve_js_challenges()` / `solve_js_challenges_sync()`
+
+Solve JS challenge requests using the yt-dlp/ejs solver.
+
+The variant without the `_sync` suffix is an asynchronous function.
+
+**Arguments:**
+-   `player_content` (`str`) - The content of the player script.
+-   `*requests` (`JsChallengeRequest`) - The JS challenge requests to solve.
+
+**Returns:**<br>
+`SolveOutput` - The parsed output from yt-dlp/ejs solver.
+
+**Raises:**
+-   `SolveOutputError` - Some or all of the challenge requests could not be solved.
+-   `UnsupportedGLibCError` - The glibc version used on this system is unsupported.
+-   `subprocess.CalledProcessError` - The yt-dlp/ejs script crashed/Deno failed to run.
+
+#### `get_sts()`
+
+Get timestamp from the player script.
+
+**Parameters:**
+-   `player_content` (`str`) - The content of the player script.
+
+**Returns:**<br>
+`str` - The timestamp extracted from the player script. When this is an empty string, the timestamp could not be found.
+
+#### `normalize_player_url()`
+
+Normalize the provided player URL.
+
+This will prepend the YT URL to a path-only URL in case of relative URLs
+and validate the URL and its hostname in case of absolute URLs.
+
+**Parameters:**
+-   `player_url` (`str`) - The player URL.
+
+**Returns:**<br>
+`str` - The normalized player URL.

red_yt_cipher_solver-0.1.0/README.md

@@ -0,0 +1,136 @@
+# Red-YT-Cipher-Solver
+
+A thin wrapper over [yt-dlp/ejs](https://github.com/yt-dlp/ejs) for deciphering YT signatures.
+Aside from yt-dlp/ejs, this uses the [official Deno PyPI package](https://github.com/denoland/deno_pypi),
+meaning no additional setup is required beyond installing the package and then using it either as a library
+or as a [Lavalink-compatible cipher server](https://github.com/lavalink-devs/youtube-source#using-a-remote-cipher-server).
+
+## Using this project
+
+This package only functions on systems supported by Deno JS runtime.
+At the time of writing, this includes:
+-   Windows x86_64
+-   macOS x86_64 & arm64
+-   Linux x86_64 & aarch64 with glibc 2.27 or higher
+
+> [!NOTE]
+> If you intend to add this as a dependency to your project and want to support other platforms as well,
+ensure to specify appropriate environment markers for the dependency and guard your imports appropriately
+as the `deno` dependency of this project will not install on unsupported platforms:
+> -   `pyproject.toml`
+>     ```toml
+>     [project]
+>     # [...]
+>     dependencies = [
+>         """\
+>         Red-YT-Cipher-Solver; \
+>             (sys_platform == 'win32' and platform_machine == 'AMD64') \
+>             or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) \
+>             or (sys_platform == 'darwin' and (platform_machine == 'x86_64' or platform_machine == 'arm64')) \
+>         """,
+>     ]
+>
+>     # [...]
+>     ```
+> -   `requirements.txt`
+>     ```
+>     Red-YT-Cipher-Solver; (sys_platform == 'win32' and platform_machine == 'AMD64') or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and (platform_machine == 'x86_64' or platform_machine == 'arm64'))
+>     # [...]
+>     ```
+
+### Installation
+
+Install the package:
+-   Linux & macOS
+    ```console
+    python3.10 -m venv red_yt_cipher_solver
+    . red_yt_cipher_solver/bin/activate
+    python -m pip install -U Red-YT-Cipher-Solver
+    ```
+-   Windows
+    ```powershell
+    py -3.10 -m venv red_yt_cipher_solver
+    red_yt_cipher_solver\Scripts\Activate.ps1
+    python -m pip install -U Red-YT-Cipher-Solver
+    ```
+
+### Running as a server
+
+Run the server with the default configuration (listening on `http://localhost:2334` with no authentication):
+```console
+red-yt-cipher-solver serve
+```
+
+To specify custom hostname and port, use the positional arguments:
+```console
+red-yt-cipher-solver 0.0.0.0 4242
+```
+
+You can require the clients to send an `Authorization` header with a token
+by specifying one in the `RED_YT_CIPHER_SERVER_TOKEN` environment variable.
+
+### Using as a standalone solver
+
+```
+$ red-yt-cipher-solver solve --help
+usage: red-yt-cipher-solver solve [-h] [--encrypted-signature ENCRYPTED_SIGNATURE]
+                                  [--n-param N_PARAM] [--signature-key SIGNATURE_KEY]
+                                  [--include-player-content]
+                                  player_url stream_url
+```
+
+Solve a JS challenge request using the yt-dlp/ejs solver:
+```console
+red-yt-cipher-solver solve \
+    /s/player/00c52fa0/player_ias.vflset/de_DE/base.js \
+    "https://rr4---sn-4g5e6nzl.googlevideo.com/videoplayback?expire=1772476120&n=Fc9IL2b0xD7Lybd7&ei=..." \
+    --encrypted-signature "R=ANHkhNZInqwBBEsHpvykqHsygJje6J4T_Q-aL2VO7PkCQIC4ruoYYg2TeWFSfKXFTeQF=B_hR1UlnJw75Wfb24g6nQgIQRw4MNqEHA"
+```
+
+### Using as a library
+
+While this is mostly a thin wrapper over yt-dlp/ejs, it does come with Deno out of the box,
+so it might be of interest to some to use that wrapper directly.
+
+The following functions are currently exposed in `red_yt_cipher_solver`
+
+#### `solve_js_challenges()` / `solve_js_challenges_sync()`
+
+Solve JS challenge requests using the yt-dlp/ejs solver.
+
+The variant without the `_sync` suffix is an asynchronous function.
+
+**Arguments:**
+-   `player_content` (`str`) - The content of the player script.
+-   `*requests` (`JsChallengeRequest`) - The JS challenge requests to solve.
+
+**Returns:**<br>
+`SolveOutput` - The parsed output from yt-dlp/ejs solver.
+
+**Raises:**
+-   `SolveOutputError` - Some or all of the challenge requests could not be solved.
+-   `UnsupportedGLibCError` - The glibc version used on this system is unsupported.
+-   `subprocess.CalledProcessError` - The yt-dlp/ejs script crashed/Deno failed to run.
+
+#### `get_sts()`
+
+Get timestamp from the player script.
+
+**Parameters:**
+-   `player_content` (`str`) - The content of the player script.
+
+**Returns:**<br>
+`str` - The timestamp extracted from the player script. When this is an empty string, the timestamp could not be found.
+
+#### `normalize_player_url()`
+
+Normalize the provided player URL.
+
+This will prepend the YT URL to a path-only URL in case of relative URLs
+and validate the URL and its hostname in case of absolute URLs.
+
+**Parameters:**
+-   `player_url` (`str`) - The player URL.
+
+**Returns:**<br>
+`str` - The normalized player URL.

red_yt_cipher_solver-0.1.0/pyproject.toml

@@ -0,0 +1,102 @@
+[project]
+name = "Red-YT-Cipher-Solver"
+version = "0.1.0"
+description = "A thin wrapper over yt-dlp/ejs for deciphering YT signatures. Comes with Deno out of the box."
+readme = "README.md"
+authors = [
+    { name = "Jakub Kuczys", email = "me@jacken.men" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "aiohttp>=3.9.5,<4",
+    "deno>=2.7.1,<3",
+    "typing-extensions~=4.15.0",
+    "yarl~=1.15.2",
+    "yt-dlp-ejs~=0.5.0",
+]
+
+[project.scripts]
+red-yt-cipher-solver = "red_yt_cipher_solver.__main__:main"
+
+[build-system]
+requires = ["uv_build>=0.10.7,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.4",
+    "ty>=0.0.19",
+]
+
+[tool.ruff]
+line-length = 99
+
+[tool.ruff.format]
+line-ending = "lf"
+
+[tool.ruff.lint]
+select = [
+    # pyflakes rules
+    "F",
+    # pycodestyle rules
+    "E",
+    "W",
+    # import sorting
+    "I",
+    # pyupgrade rules
+    "UP",
+    # flake8-bugbear rules
+    "B",
+    # flake8-bandit rules
+    "S",
+    # builtin shadowing rules
+    "A",
+    # unused arguments
+    "ARG",
+    # refurb rules
+    "FURB",
+    "FURB148",  # unnecessary-enumerate (in preview)
+    # flake8-simplify rules
+    "SIM",
+    # flake8-logging rules
+    "LOG",
+    # flake8-logging-format rules
+    "G",
+    # flake8-comprehensions rules
+    "C4",
+    # "boolean trap" rules
+    "FBT",
+    # disallow implicitly concatenated strings on a single line
+    # and explicitly concatenated strings
+    "ISC",
+    # perflint rules
+    "PERF",
+    # pygrep-hooks rules
+    "PGH",
+    # flake8-pie rules
+    "PIE",
+    # flake8-return rules
+    "RET",
+    # collection of rules unique to Ruff
+    "RUF",
+    # leftover `breakpoint()`
+    "T100",
+    # flake8-tidy-imports rules
+    "TID",
+]
+ignore = [
+    # setattr is needed to make type checkers happy when creating new attributes on objects
+    "B010",
+    # disable __all__ sorting
+    # see https://github.com/astral-sh/ruff/issues/20952
+    "RUF022",
+    # `assert` is expected to be used in code (to appease type checkers)
+    "S101",
+    # the idea of checking untrusted input is not a bad one but this is prone to false positives
+    "S603",
+]
+preview = true
+explicit-preview-rules = true
+
+[tool.ruff.lint.isort]
+combine-as-imports = true

red_yt_cipher_solver-0.1.0/src/red_yt_cipher_solver/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from .challenges import (
+    JsChallengeErrorResponse,
+    JsChallengeRequest,
+    JsChallengeResponse,
+    JsChallengeResultResponse,
+    JsChallengeType,
+    NChallengeRequest,
+    SigChallengeRequest,
+    SolveOutput,
+    SolveOutputError,
+    solve_js_challenges,
+    solve_js_challenges_sync,
+)
+from .player import get_sts, normalize_player_url
+
+__all__ = (
+    # .challenges
+    "JsChallengeRequest",
+    "JsChallengeType",
+    "JsChallengeErrorResponse",
+    "JsChallengeResponse",
+    "JsChallengeResultResponse",
+    "NChallengeRequest",
+    "SigChallengeRequest",
+    "SolveOutput",
+    "SolveOutputError",
+    "solve_js_challenges",
+    "solve_js_challenges_sync",
+    # .player
+    "get_sts",
+    "normalize_player_url",
+)

red_yt_cipher_solver-0.1.0/src/red_yt_cipher_solver/__main__.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import dataclasses
+import enum
+import json
+import logging
+import os
+import signal
+import sys
+from collections.abc import Awaitable, Callable
+from types import TracebackType
+from typing import Any, NoReturn, TypeVar
+
+import aiohttp
+import yarl
+from aiohttp import web
+from typing_extensions import Self
+
+from . import _platform_support, challenges, player
+
+_T = TypeVar("_T")
+log = logging.getLogger(__name__)
+
+
+def post_route(path: str) -> Callable[[_T], _T]:
+    def decorator(func: _T) -> _T:
+        app_routes = getattr(func, "__app_routes__", [])
+        app_routes.append(("POST", path))
+        setattr(func, "__app_routes__", app_routes)
+        return func
+
+    return decorator
+
+
+def get_required_key(payload: dict[str, str], key: str) -> str:
+    try:
+        return payload[key]
+    except KeyError:
+        raise web.HTTPBadRequest(reason=f"required key {key} is missing") from None
+
+
+class App:
+    def __init__(self, host: str, port: int, *, token: str = "") -> None:
+        self.host = host
+        self.port = port
+        self.token = token
+        self.web_app = web.Application(middlewares=[self._auth_middleware, self._error_middleware])
+        self.web_app.add_routes(self._get_routes())
+        self._stopped = asyncio.Event()
+        self._runner: web.AppRunner | None = None
+        self._site: web.TCPSite | None = None
+        self.session: aiohttp.ClientSession
+
+    @web.middleware
+    async def _auth_middleware(
+        self, request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
+    ) -> web.StreamResponse:
+        if self.token:
+            auth_header = request.headers.get("Authorization")
+            if auth_header != self.token:
+                raise web.HTTPUnauthorized()
+
+        return await handler(request)
+
+    @web.middleware
+    async def _error_middleware(
+        self, request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
+    ) -> web.StreamResponse:
+        try:
+            return await handler(request)
+        except web.HTTPException as ex:
+            if ex.empty_body:
+                raise
+            return web.json_response({"error": ex.reason}, status=ex.status_code)
+
+    def _get_routes(self) -> list[web.RouteDef]:
+        routes: list[web.RouteDef] = []
+        for base in reversed(self.__class__.__mro__):
+            for attr_name, attr_value in base.__dict__.items():
+                app_routes = getattr(attr_value, "__app_routes__", None)
+                if not app_routes:
+                    continue
+                method = getattr(self, attr_name)
+                for route_method, route_path in app_routes:
+                    routes.append(web.route(route_method, route_path, method))
+        return routes
+
+    async def __aenter__(self) -> Self:
+        await self.async_initialize()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+        /,
+    ) -> None:
+        await self.close()
+
+    async def async_initialize(self) -> None:
+        self.session = aiohttp.ClientSession()
+
+    async def close(self) -> None:
+        await self.session.close()
+
+    async def start(self) -> None:
+        log.info("Starting the server...")
+        self._runner = web.AppRunner(self.web_app)
+        await self._runner.setup()
+        self._site = web.TCPSite(self._runner, self.host, self.port)
+        await self._site.start()
+        log.info("The server has been started on http://%s:%s", self.host, self.port)
+
+    async def stop(self) -> None:
+        log.info("Stopping the server...")
+        if self._site is not None:
+            await self._site.stop()
+        if self._runner is not None:
+            await self._runner.cleanup()
+        self._stopped.set()
+
+    async def run(self) -> int:
+        self._stopped.clear()
+        await self.start()
+        try:
+            await self._stopped.wait()
+        except asyncio.CancelledError:
+            await self.stop()
+            raise
+
+        return 0
+
+    @post_route("/get_sts")
+    async def get_sts(self, request: web.Request) -> web.Response:
+        payload = await request.json()
+        try:
+            player_url = player.normalize_player_url(get_required_key(payload, "player_url"))
+        except ValueError as exc:
+            raise web.HTTPBadRequest(reason=str(exc)) from None
+
+        player_content = await _get_player_content(self.session, player_url)
+        sts = player.get_sts(player_content)
+        if not sts:
+            raise web.HTTPNotFound(reason="timestamp could not be found in the player script")
+
+        return web.json_response({"sts": sts})
+
+    @post_route("/resolve_url")
+    async def resolve_url(self, request: web.Request) -> web.Response:
+        payload = await request.json()
+        try:
+            player_url = player.normalize_player_url(get_required_key(payload, "player_url"))
+        except ValueError as exc:
+            raise web.HTTPBadRequest(reason=str(exc)) from None
+        encrypted_signature = payload.get("encrypted_signature")
+        signature_key = payload.get("signature_key") or "sig"
+
+        try:
+            stream_url = yarl.URL(get_required_key(payload, "stream_url"))
+        except ValueError:
+            raise web.HTTPBadRequest(reason="stream URL appears to be invalid") from None
+        n_param = payload.get("n_param")
+        if not n_param:
+            n_param = stream_url.query.get("n")
+        if not n_param:
+            raise web.HTTPBadRequest(reason="n_param not found in request or stream_url")
+
+        player_content = await _get_player_content(self.session, player_url)
+        challenge_requests: list[challenges.JsChallengeRequest] = []
+
+        n_challenge_request = challenges.NChallengeRequest([n_param])
+        challenge_requests.append(n_challenge_request)
+
+        sig_challenge_request: challenges.SigChallengeRequest | None = None
+        if encrypted_signature:
+            sig_challenge_request = challenges.SigChallengeRequest([encrypted_signature])
+            challenge_requests.append(sig_challenge_request)
+
+        try:
+            solve_output = await challenges.solve_js_challenges(
+                player_content, *challenge_requests
+            )
+        except challenges.SolveOutputError as exc:
+            if not exc.responses:
+                raise web.HTTPNotFound(
+                    reason=f"error occurred during challenge request: {exc}"
+                ) from exc
+            n_challenge_response = exc[n_challenge_request]
+            sig_challenge_response = exc[sig_challenge_request] if sig_challenge_request else None
+            if sig_challenge_response is not None and not sig_challenge_response:
+                raise web.HTTPNotFound(
+                    reason=f"error occurred during challenge request: {exc}"
+                ) from exc
+        else:
+            n_challenge_response = solve_output[n_challenge_request]
+            sig_challenge_response = (
+                solve_output[sig_challenge_request] if sig_challenge_request else None
+            )
+
+        query = stream_url.query.copy()
+
+        if n_challenge_response:
+            query["n"] = n_challenge_response.solutions[0]
+
+        if sig_challenge_response:
+            query[signature_key] = sig_challenge_response.solutions[0]
+            query.pop("s", None)
+
+        resolved_url = stream_url.with_query(query)
+
+        return web.json_response({"resolved_url": str(resolved_url)})
+
+
+async def _get_player_content(session: aiohttp.ClientSession, player_url: str) -> str:
+    # TODO: cache players
+    async with session.get(player_url) as resp:
+        return await resp.text()
+
+
+async def _serve_command(args: argparse.Namespace) -> int:
+    logging.basicConfig(level=logging.INFO)
+    token = os.getenv("RED_YT_CIPHER_SERVER_TOKEN", "")
+
+    async with App(args.host, args.port, token=token) as app:
+        return await app.run()
+
+
+async def _solve_command(args: argparse.Namespace) -> int:
+    player_url = player.normalize_player_url(args.player_url)
+    stream_url = yarl.URL(args.stream_url)
+    n_param = args.n_param
+    if not n_param:
+        n_param = stream_url.query.get("n")
+    if not n_param:
+        print("n_param not provided in stream_url nor by the --n-param option", file=sys.stderr)
+        return 2
+
+    challenge_requests: list[challenges.JsChallengeRequest] = []
+
+    n_challenge_request = challenges.NChallengeRequest([n_param])
+    challenge_requests.append(n_challenge_request)
+
+    sig_challenge_request = None
+    if args.encrypted_signature:
+        sig_challenge_request = challenges.SigChallengeRequest([args.encrypted_signature])
+        challenge_requests.append(sig_challenge_request)
+
+    async with aiohttp.ClientSession() as session:
+        player_content = await _get_player_content(session, player_url)
+    try:
+        solve_output = await challenges.solve_js_challenges(player_content, *challenge_requests)
+    except challenges.SolveOutputError as exc:
+        print(f"error occurred during challenge request: {exc}", file=sys.stderr)
+        return 2
+
+    query = stream_url.query.copy()
+
+    if solve_output[n_challenge_request]:
+        query["n"] = solve_output[n_challenge_request].solutions[0]
+
+    if sig_challenge_request and solve_output[sig_challenge_request]:
+        query[args.signature_key] = solve_output[sig_challenge_request].solutions[0]
+        query.pop("s", None)
+
+    resolved_url = stream_url.with_query(query)
+
+    data: dict[str, Any] = {}
+    if args.include_player_content:
+        data["player"] = player_content
+        data["preprocessed_player"] = solve_output.preprocessed_player
+    data["resolved_url"] = str(resolved_url)
+    data["player_url"] = player_url
+    data["sts"] = player.get_sts(player_content)
+    solve_output_data = dataclasses.asdict(solve_output)
+    solve_output_data.pop("preprocessed_player", None)
+    data["solve_output"] = solve_output_data
+
+    def default(o: Any) -> Any:
+        if isinstance(o, enum.Enum):
+            return o.value
+        raise TypeError(f"Object of type {o.__class__.__name__} is not JSON serializable")
+
+    print(json.dumps(data, indent=4, default=default))
+
+    return 0
+
+
+async def _main() -> NoReturn:
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(required=True, help="command to run")
+
+    serve_parser = subparsers.add_parser(
+        "serve", help="Run a Lavalink-compatible YT cipher server."
+    )
+    serve_parser.set_defaults(func=_serve_command)
+    serve_parser.add_argument("host", nargs="?", default="localhost")
+    serve_parser.add_argument("port", type=int, nargs="?", default=2334)
+
+    solve_parser = subparsers.add_parser(
+        "solve", help="Solve JS challenge request using the yt-dlp/ejs solver."
+    )
+    solve_parser.add_argument("player_url")
+    solve_parser.add_argument("stream_url")
+    solve_parser.add_argument("--encrypted-signature")
+    solve_parser.add_argument("--n-param")
+    solve_parser.add_argument("--signature-key", default="sig")
+    solve_parser.add_argument("--include-player-content", action="store_true", default=False)
+    solve_parser.set_defaults(func=_solve_command)
+
+    args = parser.parse_args()
+    raise SystemExit(await args.func(args))
+
+
+def main() -> NoReturn:
+    if _platform_support.GLIBC_UNSUPPORTED:
+        print(
+            f"The minimum supported version of glibc is {_platform_support.MIN_SUPPORTED_GLIBC}",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    try:
+        asyncio.run(_main())
+    except KeyboardInterrupt:
+        raise SystemExit(128 + signal.Signals.SIGINT) from None
+
+
+if __name__ == "__main__":
+    main()

red_yt_cipher_solver-0.1.0/src/red_yt_cipher_solver/_platform_support.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import platform
+import sys
+
+
+def _get_glibc_version() -> tuple[int, int] | None:
+    if sys.platform != "linux":
+        return None
+    try:
+        libc_ver = platform.libc_ver()
+    except OSError:
+        return None
+    if libc_ver[0] != "glibc":
+        return None
+    parts = libc_ver[1].split(".")
+    return (int(parts[0]), int(parts[1]))
+
+
+MIN_SUPPORTED_GLIBC = (2, 27)
+GLIBC_VERSION = _get_glibc_version()
+GLIBC_UNSUPPORTED = GLIBC_VERSION and GLIBC_VERSION < MIN_SUPPORTED_GLIBC

red_yt_cipher_solver-0.1.0/src/red_yt_cipher_solver/challenges.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import enum
+import json
+import subprocess
+from collections.abc import Iterable
+from typing import Final, Literal, TypedDict
+
+import deno
+import yt_dlp_ejs.yt.solver
+from typing_extensions import NotRequired
+
+from . import _platform_support
+
+_DENO_BIN: Final = deno.find_deno_bin()
+_DENO_ARGS: Final = (
+    "--ext=js",
+    "--no-code-cache",
+    "--no-prompt",
+    "--no-remote",
+    "--no-lock",
+    "--node-modules-dir=none",
+    "--no-config",
+    "--no-npm",
+    "--cached-only",
+    "-",
+)
+
+__all__ = (
+    "JsChallengeType",
+    "NChallengeRequest",
+    "SigChallengeRequest",
+    "JsChallengeRequest",
+    "JsChallengeResultResponse",
+    "JsChallengeErrorResponse",
+    "JsChallengeResponse",
+    "SolveOutputError",
+    "SolveOutput",
+    "solve_js_challenges",
+    "solve_js_challenges_sync",
+)
+
+
+class JsChallengeType(enum.Enum):
+    N = "n"
+    SIG = "sig"
+
+
+@dataclasses.dataclass(frozen=True)
+class NChallengeRequest:
+    challenges: list[str] = dataclasses.field(default_factory=list)
+    type: Literal[JsChallengeType.N] = dataclasses.field(init=False, default=JsChallengeType.N)
+
+
+@dataclasses.dataclass(frozen=True)
+class SigChallengeRequest:
+    challenges: list[str] = dataclasses.field(default_factory=list)
+    type: Literal[JsChallengeType.SIG] = dataclasses.field(init=False, default=JsChallengeType.SIG)
+
+
+JsChallengeRequest = NChallengeRequest | SigChallengeRequest
+
+
+class _PlayerInput(TypedDict):
+    type: Literal["player"]
+    player: str
+    requests: list[_Request]
+    output_preprocessed: bool
+
+
+class _PreprocessedInput(TypedDict):
+    type: Literal["preprocessed"]
+    preprocessed_player: str
+    requests: list[_Request]
+
+
+_Input = _PlayerInput | _PreprocessedInput
+
+
+class _Request(TypedDict):
+    type: Literal["n", "sig"]
+    challenges: list[str]
+
+
+class _ResultChallengeResponse(TypedDict):
+    type: Literal["result"]
+    data: dict[str, str]
+
+
+class _ErrorChallengeResponse(TypedDict):
+    type: Literal["error"]
+    error: str
+
+
+_ChallengeResponse = _ResultChallengeResponse | _ErrorChallengeResponse
+
+
+class _ResultOutput(TypedDict):
+    type: Literal["result"]
+    preprocessed_player: NotRequired[str]
+    responses: list[_ChallengeResponse]
+
+
+class _ErrorOutput(TypedDict):
+    type: Literal["error"]
+    error: str
+
+
+_Output = _ResultOutput | _ErrorOutput
+
+
+def _construct_stdin(
+    player: str, requests: Iterable[JsChallengeRequest], /, *, preprocessed: bool = False
+) -> bytes:
+    json_requests: list[_Request] = [
+        {
+            "type": request.type.value,
+            "challenges": request.challenges,
+        }
+        for request in requests
+    ]
+    data: _Input = (
+        {
+            "type": "preprocessed",
+            "preprocessed_player": player,
+            "requests": json_requests,
+        }
+        if preprocessed
+        else {
+            "type": "player",
+            "player": player,
+            "requests": json_requests,
+            "output_preprocessed": True,
+        }
+    )
+    return (
+        f"{yt_dlp_ejs.yt.solver.lib()}\n"
+        "Object.assign(globalThis, lib);\n"
+        f"{yt_dlp_ejs.yt.solver.core()}\n"
+        f"console.log(JSON.stringify(jsc({json.dumps(data)})));"
+    ).encode()
+
+
+@dataclasses.dataclass(frozen=True)
+class JsChallengeResultResponse:
+    request: JsChallengeRequest
+    data: dataclasses.InitVar[dict[str, str]]
+    solutions: tuple[str] = dataclasses.field(init=False)
+
+    def __post_init__(self, data: dict[str, str]) -> None:
+        object.__setattr__(
+            self, "solutions", tuple(data[challenge] for challenge in self.request.challenges)
+        )
+
+    def __bool__(self) -> Literal[True]:
+        return True
+
+
+@dataclasses.dataclass(frozen=True)
+class JsChallengeErrorResponse:
+    request: JsChallengeRequest
+    message: str
+
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+JsChallengeResponse = JsChallengeResultResponse | JsChallengeErrorResponse
+
+
+class SolveOutputError(Exception):
+    """Failed to solve JS challenge requests."""
+
+    def __init__(
+        self,
+        requests: tuple[JsChallengeRequest, ...],
+        message: str,
+        /,
+        *,
+        responses: tuple[JsChallengeResponse, ...] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.requests = requests
+        self.responses = responses
+
+    def __getitem__(self, request: JsChallengeRequest) -> JsChallengeResponse:
+        if self.responses is None:
+            raise TypeError("no responses are available")
+        return self.responses[self.requests.index(request)]
+
+
+@dataclasses.dataclass(frozen=True)
+class SolveOutput:
+    requests: tuple[JsChallengeRequest, ...]
+    responses: tuple[JsChallengeResultResponse, ...]
+    preprocessed_player: str | None
+
+    def __getitem__(self, request: JsChallengeRequest) -> JsChallengeResultResponse:
+        return self.responses[self.requests.index(request)]
+
+
+def _parse_output(requests: tuple[JsChallengeRequest, ...], stdout: bytes) -> SolveOutput:
+    data: _Output = json.loads(stdout)
+    if data["type"] == "error":
+        raise SolveOutputError(requests, data["error"])
+
+    responses: list[JsChallengeResponse] = []
+    result_responses: list[JsChallengeResultResponse] = []
+    has_errors = False
+    for request, response_data in zip(requests, data["responses"], strict=True):
+        if response_data["type"] == "error":
+            has_errors = True
+            responses.append(JsChallengeErrorResponse(request, response_data["error"]))
+        else:
+            response = JsChallengeResultResponse(request, response_data["data"])
+            responses.append(response)
+            result_responses.append(response)
+
+    if has_errors:
+        raise SolveOutputError(
+            requests,
+            "Some of the challenge requests could not be solved",
+            responses=tuple(responses),
+        )
+
+    return SolveOutput(requests, tuple(result_responses), data.get("preprocessed_player"))
+
+
+class UnsupportedGLibCError(Exception):
+    """The glibc version used on this system is unsupported."""
+
+
+async def solve_js_challenges(player_content: str, *requests: JsChallengeRequest) -> SolveOutput:
+    """
+    Solve JS challenge requests using the yt-dlp/ejs solver.
+
+    Parameters
+    ----------
+    player_content: str
+        The content of the player script.
+    *requests: JsChallengeRequest
+        The JS challenge requests to solve.
+
+    Returns
+    -------
+    SolveOutput
+        The parsed output from yt-dlp/ejs solver.
+
+    Raises
+    ------
+    SolveOutputError
+        Some or all of the challenge requests could not be solved.
+    UnsupportedGLibCError
+        The glibc version used on this system is unsupported.
+    subprocess.CalledProcessError
+        The yt-dlp/ejs script crashed/Deno failed to run.
+    """
+    if _platform_support.GLIBC_UNSUPPORTED:
+        raise UnsupportedGLibCError(
+            f"The minimum supported version of glibc is {_platform_support.MIN_SUPPORTED_GLIBC}"
+        )
+    args = (_DENO_BIN, *_DENO_ARGS)
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate(_construct_stdin(player_content, requests))
+    if proc.returncode is None:
+        raise RuntimeError("unreachable")
+    if proc.returncode != 0:
+        raise subprocess.CalledProcessError(proc.returncode, args, stdout)
+    return _parse_output(requests, stdout)
+
+
+def solve_js_challenges_sync(player_content: str, *requests: JsChallengeRequest) -> SolveOutput:
+    """
+    Solve JS challenge requests using the yt-dlp/ejs solver.
+
+    Parameters
+    ----------
+    player_content: str
+        The content of the player script.
+    *requests: JsChallengeRequest
+        The JS challenge requests to solve.
+
+    Returns
+    -------
+    SolveOutput
+        The parsed output from yt-dlp/ejs solver.
+
+    Raises
+    ------
+    SolveOutputError
+        Some or all of the challenge requests could not be solved.
+    UnsupportedGLibCError
+        The glibc version used on this system is unsupported.
+    subprocess.CalledProcessError
+        The yt-dlp/ejs script crashed/Deno failed to run.
+    """
+    if _platform_support.GLIBC_UNSUPPORTED:
+        raise UnsupportedGLibCError(
+            f"The minimum supported version of glibc is {_platform_support.MIN_SUPPORTED_GLIBC}"
+        )
+    proc = subprocess.run(
+        (_DENO_BIN, *_DENO_ARGS),
+        input=_construct_stdin(player_content, requests),
+        check=True,
+    )
+    return _parse_output(requests, proc.stdout)

red_yt_cipher_solver-0.1.0/src/red_yt_cipher_solver/player.py

@@ -0,0 +1,61 @@
+import re
+
+import yarl
+
+_STS_RE = re.compile(r"(signatureTimestamp|sts):(\d+)")
+VALID_YT_HOSTNAMES = ("youtube.com", "www.youtube.com", "m.youtube.com")
+
+
+__all__ = ("VALID_YT_HOSTNAMES", "normalize_player_url", "get_sts")
+
+
+def normalize_player_url(player_url: str) -> str:
+    """
+    Normalize the provided player URL.
+
+    This will prepend the YT URL to a path-only URL in case of relative URLs
+    and validate the URL and its hostname in case of absolute URLs.
+
+    Parameters
+    -------
+    player_url: str
+        The player URL.
+
+    Returns
+    -------
+    str
+        The normalized player URL.
+    """
+    if player_url.startswith("/"):
+        if player_url.startswith("/s/player"):
+            return f"https://www.youtube.com{player_url}"
+        raise ValueError(f"invalid player path: {player_url}")
+
+    try:
+        url = yarl.URL(player_url)
+        if url.host in VALID_YT_HOSTNAMES:
+            return player_url
+        raise ValueError(f"unexpected hostname in player url: {player_url}")
+    except ValueError as exc:
+        raise ValueError(f"invalid player url: {player_url}") from exc
+
+
+def get_sts(player_content: str) -> str:
+    """
+    Get timestamp from the player script.
+
+    Parameters
+    ----------
+    player_content: str
+        The content of the player script.
+
+    Returns
+    -------
+    str
+        The timestamp extracted from the player script.
+        When this is an empty string, the timestamp could not be found.
+    """
+    match = _STS_RE.search(player_content)
+    if not match:
+        return ""
+    return match.group(2)