pendify 0.1.0__py3-none-any.whl

pendify/client.py

@@ -0,0 +1,223 @@
+"""The game client's side: where its credentials are (S:693-716) and its loopback calls (S:718-786).
+
+The client writes its port and token to a lockfile while it runs. When no lockfile answers, one read of
+the client process's command line through PowerShell takes the place of the script's psutil fallback, at
+most once every 10 s. Every failure is no client, never an exception. Nothing here prints, logs or raises
+the client's token, and Credentials hides it from repr. The client's phase says the loading screen opened;
+the game's own loopback port is asked one number, its clock, to tell when the match itself starts. Nothing
+else of the live data is read, kept, printed or sent.
+"""
+import base64
+import http.client
+import json
+import re
+import ssl
+import subprocess
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+
+# S:139-140: the two Windows places of the client's lockfile, the one list of them.
+LOCKFILE_PATHS = (r"C:\Riot Games\League of Legends\lockfile", r"D:\Riot Games\League of Legends\lockfile")
+# S:705: the process whose command line carries the port and the token, matched as a part of its name.
+PROCESS_NAME = "LeagueClient"
+# S:707-708, the script's two expressions.
+PORT_PATTERN = re.compile(r"--app-port=(\d+)")
+TOKEN_PATTERN = re.compile(r"--remoting-auth-token=([\w-]+)")
+# Written by [Console]::Out: the host's own output wraps a long line at the console width, which would
+# cut the token in two.
+PROCESS_QUERY = ("powershell", "-NoProfile", "-Command",
+                 f"Get-CimInstance -ClassName Win32_Process -Filter 'Name LIKE ''%{PROCESS_NAME}%''' "
+                 "| ForEach-Object { [Console]::Out.WriteLine($_.CommandLine) }")
+PROCESS_READ_INTERVAL = 10.0
+PROCESS_READ_TIMEOUT = 5
+
+
+@dataclass(frozen=True)
+class Credentials:
+    """The client's port and its token; the token is never shown by repr."""
+
+    port: int
+    token: str = field(repr=False)
+
+
+def _credentials(port, token):
+    """Credentials when the port is a TCP port and the token is not empty, else None."""
+    if not port.isdigit() or not 0 < int(port) < 65536 or not token:
+        return None
+    return Credentials(int(port), token)
+
+
+def read_lockfile(path):
+    """The third and fourth fields of the lockfile (S:697-700); a missing, short or unreadable file is None."""
+    try:
+        with open(path, "rb") as handle:
+            data = handle.read().decode("utf-8").split(":")
+    except (OSError, UnicodeDecodeError):
+        return None
+    if len(data) < 4:
+        return None
+    return _credentials(data[2].strip(), data[3].strip())
+
+
+def parse_command_lines(text):
+    """The first command line that carries both the port and the token (S:704-709), or None."""
+    for line in text.splitlines():
+        port, token = PORT_PATTERN.search(line), TOKEN_PATTERN.search(line)
+        if port and token:
+            return _credentials(port.group(1), token.group(1))
+    return None
+
+
+def query_process(run):
+    """The client process's command lines, or None on a timeout, a nonzero exit or a missing shell."""
+    try:
+        done = run(list(PROCESS_QUERY), capture_output=True, text=True, errors="replace",
+                   timeout=PROCESS_READ_TIMEOUT, creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return done.stdout if done.returncode == 0 and isinstance(done.stdout, str) else None
+
+
+class ClientCredentials:
+    """The lockfiles first; the process read only when none answers and at most once every 10 s.
+    `run` None turns the process read off (the test override reads its one lockfile only)."""
+
+    def __init__(self, paths=LOCKFILE_PATHS, run=subprocess.run, clock=time.monotonic):
+        self._paths, self._run, self._clock = tuple(paths), run, clock
+        self._last_query = None
+
+    def read(self):
+        for path in self._paths:
+            found = read_lockfile(path)
+            if found is not None:
+                return found
+        if self._run is None:
+            return None
+        now = self._clock()
+        if self._last_query is not None and now - self._last_query < PROCESS_READ_INTERVAL:
+            return None
+        self._last_query = now
+        output = query_process(self._run)
+        return None if output is None else parse_command_lines(output)
+
+
+
+# S:742: the client's user name beside its token, in basic authentication.
+USER_NAME = "riot"
+CLIENT_HOST = "127.0.0.1"
+PHASE_PATH = "/lol-gameflow/v1/gameflow-phase"  # S:745
+ACCEPT_PATH = "/lol-matchmaking/v1/ready-check/accept"  # S:784
+CLIENT_TIMEOUT = 2.0  # S:746, S:785
+_MAX_ANSWER_BYTES = 64 * 1024
+# The game's own loopback port while a match runs, and the one route of it that is read: its clock.
+LIVE_PORT = 2999
+LIVE_CLOCK_PATH = "/liveclientdata/gamestats"
+LIVE_TIMEOUT = 1.0
+
+
+class ClientUnreachable(Exception):
+    """The client gave no answer. The message names the failure's type only."""
+
+
+def real_addresses(port):
+    """The client's base address in a real run (S:743)."""
+    return f"https://{CLIENT_HOST}:{port}"
+
+
+def loopback_addresses(port):
+    """The test override's base address: a fake on 127.0.0.1, over plain http."""
+    return f"http://{CLIENT_HOST}:{port}"
+
+
+def real_live_address():
+    """The game's own loopback port in a real run."""
+    return f"https://{CLIENT_HOST}:{LIVE_PORT}"
+
+
+def loopback_tls_context(host):
+    """The one TLS context in the package that does not verify, for the client's self-signed certificate.
+    Only the literal 127.0.0.1 is served; any other host, a name that resolves there included, is refused."""
+    if host != CLIENT_HOST:
+        raise ValueError("an unverified TLS context is only for 127.0.0.1")
+    context = ssl.create_default_context()
+    context.check_hostname = False
+    context.verify_mode = ssl.CERT_NONE
+    return context
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    """A redirect answer is returned as it is, never followed off the loopback address."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _call(url, token, timeout, data=None):
+    """(status, body) of one call on 127.0.0.1; ClientUnreachable when no answer came."""
+    parts = urllib.parse.urlsplit(url)
+    if parts.hostname != CLIENT_HOST or parts.scheme not in ("http", "https"):
+        raise ValueError("the client is only called on 127.0.0.1")
+    handlers = [urllib.request.ProxyHandler({}), _NoRedirect()]
+    if parts.scheme == "https":
+        handlers.append(urllib.request.HTTPSHandler(context=loopback_tls_context(parts.hostname)))
+    headers = {"Accept": "application/json"}
+    if token is not None:
+        try:
+            pair = f"{USER_NAME}:{token}".encode("latin-1")  # as requests encodes basic authentication
+        except UnicodeEncodeError:
+            raise ClientUnreachable("UnicodeEncodeError") from None
+        headers["Authorization"] = "Basic " + base64.b64encode(pair).decode("ascii")
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    request = urllib.request.Request(url, data=data, headers=headers, method="GET" if data is None else "POST")
+    try:
+        try:
+            answer = urllib.request.build_opener(*handlers).open(request, timeout=timeout)
+        except urllib.error.HTTPError as refused:  # an answer all the same
+            answer = refused
+        with answer:
+            return answer.getcode(), answer.read(_MAX_ANSWER_BYTES)
+    except urllib.error.URLError as failure:
+        reason = failure.reason
+        name = type(reason).__name__ if isinstance(reason, BaseException) else type(failure).__name__
+        raise ClientUnreachable(name) from None
+    except (OSError, http.client.HTTPException, ValueError) as failure:  # a reset, a timeout, a broken answer
+        raise ClientUnreachable(type(failure).__name__) from None
+
+
+def get(url, token, timeout):
+    """GET on the client: (status, body), or ClientUnreachable. `token` None sends no authentication."""
+    return _call(url, token, timeout)
+
+
+def post(url, token, timeout):
+    """POST of an empty JSON object on the client, as S:784-786: the status, or ClientUnreachable."""
+    return _call(url, token, timeout, data=b"{}")[0]
+
+
+def game_clock(base, get=get):
+    """The game's clock in seconds, from one GET of its clock route with no authentication; None when the
+    port gave no answer, the status is not 200, the body is not a JSON object or its gameTime is not a
+    number (a bool is not one). Never raises; no other key is read and nothing is kept."""
+    try:
+        status, raw = get(base + LIVE_CLOCK_PATH, None, LIVE_TIMEOUT)
+    except ClientUnreachable:
+        return None
+    if status != 200:
+        return None
+    try:
+        answer = json.loads(raw.decode("utf-8"))
+    except (ValueError, RecursionError):  # not JSON, not UTF-8, or nested past the parser's depth
+        return None
+    if not isinstance(answer, dict):
+        return None
+    seconds = answer.get("gameTime")
+    if isinstance(seconds, bool) or not isinstance(seconds, (int, float)):
+        return None
+    try:
+        return float(seconds)
+    except OverflowError:  # an int no float holds
+        return None

pendify/codes.py

@@ -0,0 +1,38 @@
+"""The pairing value: the Worker's alphabet and length, a mint, normalization and the 4-4-4 display.
+
+The rules are the Worker's own (proxy/src/link-registry.ts:31-32, :45 and :97-101), so a value this
+program normalizes is the value the Worker normalizes and digests.
+"""
+import secrets
+
+# 32 symbols with no 0, O, 1 or I (link-registry.ts:31); twelve of them are 2^60.
+ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+LENGTH = 12
+# A pasted value may carry the display dashes; anything longer cannot be one (link-registry.ts:45).
+# Counted in UTF-16 units, as the Worker's raw.length counts it (link-registry.ts:98).
+MAX_RAW_CHARS = 32
+
+
+def mint():
+    """Twelve symbols of the alphabet from the system's cryptographic random source."""
+    return "".join(secrets.choice(ALPHABET) for _ in range(LENGTH))
+
+
+def normalize(value):
+    """Upper-cased, every character outside the alphabet dropped; None unless exactly twelve remain.
+
+    The raw bound is in UTF-16 units, as the Worker's raw.length is: a character outside the Basic
+    Multilingual Plane counts two, so a value the Worker refuses is never stored here. A lone surrogate
+    counts one unit, as in JavaScript, and is no encoding error."""
+    if not isinstance(value, str) or len(value.encode("utf-16-le", "surrogatepass")) // 2 > MAX_RAW_CHARS:
+        return None
+    code = "".join(char for char in value.upper() if char in ALPHABET)
+    return code if len(code) == LENGTH else None
+
+
+def display(code):
+    """The value as 4-4-4. A value that does not normalize is refused and never echoed."""
+    normal = normalize(code)
+    if normal is None:
+        raise ValueError("not a pairing value of twelve symbols")
+    return f"{normal[0:4]}-{normal[4:8]}-{normal[8:12]}"

pendify/config.py

@@ -0,0 +1,223 @@
+"""The config file: the secret and the link id, under the user's profile (design P1, P6), and the page's theme
+choice when there is one (light or dark; the system's choice is no key), and its language choice when there is one
+(es or en; with none the page follows the browser).
+
+The file is `<base>/<folder>/config.json`, where the base is %APPDATA% in a real run and is injected
+everywhere else, so no test touches the real profile. A write goes to a temp file in the same folder
+and is moved over the old one with os.replace, so a reader sees the old file or the new one, never half.
+"""
+import json
+import os
+import tempfile
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from . import codes
+
+# The folder under the base is named after the package, the one constant that names it.
+FOLDER_NAME = __name__.split(".")[0]
+FILE_NAME = "config.json"
+# The one sentence for a config file that is there but cannot be read or replaced, most often because
+# another program holds it open. It names the path, never anything the file holds.
+UNAVAILABLE = "the config file {path} cannot be used now: close any program that holds it open and start again"
+# A refused os.replace is tried again after each pause: five retries over one second.
+REPLACE_PAUSES = (0.2,) * 5
+# The theme button's choices; "system" follows the system and is kept as no key.
+THEMES = ("light", "dark")
+SYSTEM_THEME = "system"
+# The language switch's choices; with no key the page follows the browser's language.
+LANGS = ("es", "en")
+# _write's default: the stored theme and language choices are kept.
+_KEEP = object()
+
+
+class ConfigError(OSError):
+    """The config file is there but cannot be read or written; the message is UNAVAILABLE."""
+
+
+@dataclass(frozen=True)
+class Pairing:
+    """What the file holds. Neither value is ever shown by repr."""
+
+    secret: str = field(repr=False)
+    link_id: Optional[str] = field(repr=False, default=None)
+
+
+def default_base_dir(environ=None):
+    """%APPDATA%, the base of a real run. Its absence is an error, never a silent fallback."""
+    environ = os.environ if environ is None else environ
+    value = (environ.get("APPDATA") or "").strip()
+    if not value:
+        raise RuntimeError("APPDATA is not set, so the config folder has no place")
+    return Path(value)
+
+
+class ConfigStore:
+    def __init__(self, base_dir, *, pause=time.sleep):
+        self.path = Path(base_dir) / FOLDER_NAME / FILE_NAME
+        self._lock = threading.Lock()
+        self._pause = pause
+
+    def read(self):
+        """The stored pair, or None when the file is missing, empty, corrupt or its secret does not
+        normalize. A malformed link id beside a good secret reads as no link id. Never writes. A file
+        that is there and cannot be read raises ConfigError, never a first load over the stored pair."""
+        try:
+            raw = self.path.read_bytes()
+        except FileNotFoundError:
+            return None
+        except OSError:
+            raise self._unavailable() from None
+        try:
+            data = json.loads(raw.decode("utf-8"))
+        except ValueError:  # JSONDecodeError and UnicodeDecodeError alike
+            return None
+        if not isinstance(data, dict):
+            return None
+        secret = codes.normalize(data.get("secret"))
+        if secret is None:
+            return None
+        return Pairing(secret, codes.normalize(data.get("linkId")))
+
+    def read_theme(self):
+        """The stored theme choice, light or dark, or None when there is none (the system's). A file that is
+        there and cannot be read raises ConfigError, as read() does; a missing, corrupt or foreign value is None."""
+        return _choice(self._stored(), "theme", THEMES)
+
+    def read_lang(self):
+        """The stored language choice, es or en, or None when there is none (the browser's). A file that is there
+        and cannot be read raises ConfigError, as read_theme() does; a missing, corrupt or foreign value is None."""
+        return _choice(self._stored(), "lang", LANGS)
+
+    def set_theme(self, choice):
+        """The theme button's choice written beside the pair: light or dark kept, system kept as no key. Any
+        other value is refused and nothing is written. Answers the stored choice, None for the system's."""
+        if choice not in THEMES + (SYSTEM_THEME,):
+            raise ValueError("the theme is not light, dark or system")
+        theme = None if choice == SYSTEM_THEME else choice
+        with self._lock:
+            self._write(self._current(), theme=theme)
+            return theme
+
+    def set_lang(self, choice):
+        """The language switch's choice, es or en, written beside the pair and the theme. Any other value is
+        refused and nothing is written. Answers the stored choice."""
+        if choice not in LANGS:
+            raise ValueError("the language is not es or en")
+        with self._lock:
+            self._write(self._current(), lang=choice)
+            return choice
+
+    def load(self):
+        """The stored pair; when there is none, a first load: a new secret, written (P1)."""
+        with self._lock:
+            current = self.read()
+            if current is None:
+                current = self._write(Pairing(codes.mint()))
+            return current
+
+    def forget(self):
+        """«Olvidar este PC»: a new secret and no link id."""
+        with self._lock:
+            old = self.read()
+            secret = codes.mint()
+            while old is not None and secret == old.secret:
+                secret = codes.mint()
+            return self._write(Pairing(secret))
+
+    def set_typed(self, link_id, secret):
+        """The typed road (P6): both values normalized, a malformed pair refused without echoing it."""
+        normal_link_id, normal_secret = codes.normalize(link_id), codes.normalize(secret)
+        if normal_link_id is None or normal_secret is None:
+            raise ValueError("the typed pair is not two values of twelve symbols")
+        with self._lock:
+            return self._write(Pairing(normal_secret, normal_link_id))
+
+    def set_link_id(self, link_id):
+        """The link id a check answered, stored beside the current secret."""
+        normal = codes.normalize(link_id)
+        if normal is None:
+            raise ValueError("the link id is not twelve symbols")
+        with self._lock:
+            return self._write(Pairing(self._current().secret, normal))
+
+    def clear_link_id(self):
+        """«Volver a enlazar»: no link id, the SAME secret."""
+        with self._lock:
+            return self._write(Pairing(self._current().secret))
+
+    def _current(self):
+        """The stored pair whose secret a write keeps; a file gone mid-run is the one sentence, as a held one is."""
+        current = self.read()
+        if current is None:
+            raise self._unavailable()
+        return current
+
+    def _unavailable(self):
+        return ConfigError(UNAVAILABLE.format(path=self.path))
+
+    def _stored(self):
+        """The file's object, or None when the file is missing, corrupt or not an object. A file that is there and
+        cannot be read raises ConfigError."""
+        try:
+            raw = self.path.read_bytes()
+        except FileNotFoundError:
+            return None
+        except OSError:
+            raise self._unavailable() from None
+        try:
+            data = json.loads(raw.decode("utf-8"))
+        except ValueError:  # JSONDecodeError and UnicodeDecodeError alike
+            return None
+        return data if isinstance(data, dict) else None
+
+    def _write(self, pairing, theme=_KEEP, lang=_KEEP):
+        """The pair, and the theme and language choices: each stored one kept unless set_theme or set_lang passes
+        its own."""
+        folder = self.path.parent
+        if theme is _KEEP or lang is _KEEP:
+            stored = self._stored()
+            theme = _choice(stored, "theme", THEMES) if theme is _KEEP else theme
+            lang = _choice(stored, "lang", LANGS) if lang is _KEEP else lang
+        values = {"secret": pairing.secret, "linkId": pairing.link_id}
+        if theme is not None:
+            values["theme"] = theme
+        if lang is not None:
+            values["lang"] = lang
+        data = json.dumps(values).encode("utf-8")
+        try:
+            folder.mkdir(parents=True, exist_ok=True)
+            handle, temp = tempfile.mkstemp(dir=folder, prefix=".config-", suffix=".tmp")
+        except OSError:
+            raise self._unavailable() from None
+        try:
+            with os.fdopen(handle, "wb") as out:
+                out.write(data)
+                out.flush()
+                os.fsync(out.fileno())
+            self._replace(temp)
+        except BaseException as failure:
+            if os.path.exists(temp):
+                os.remove(temp)
+            if isinstance(failure, OSError):
+                raise self._unavailable() from None
+            raise
+        return pairing
+
+    def _replace(self, temp):
+        """os.replace, retried while Windows refuses it because another program holds the file open."""
+        for pause in REPLACE_PAUSES:
+            try:
+                return os.replace(temp, self.path)
+            except PermissionError:
+                self._pause(pause)
+        return os.replace(temp, self.path)
+
+
+def _choice(stored, key, allowed):
+    """The value of `key` in the file's object when it is one of `allowed`, else None (missing, corrupt or foreign)."""
+    value = stored.get(key) if stored is not None else None
+    return value if isinstance(value, str) and value in allowed else None

pendify/icon.py

@@ -0,0 +1,14 @@
+"""The program's icon for the page: the 32 px frame of pendify.ico as PNG in base64.
+
+Written by tools/make_icon.py from tools/icon_grid.py: run the tool, never edit this file by hand.
+"""
+
+PNG_32 = (
+    "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABlElEQVR4AWMYBcSEQFfMh/8wTEg9TB2IJqSWKHmQQf+B4OW9"
+    "30DyP9ghuDSSohaXGRjipBhKiloMi3AJYDMUJIYLg4KJmNDCZR9WcZBlIINJwSA9WA0jVRBkECkWI6sF6SXVPhT1IAOQDSSH"
+    "DTIDxVBSOCDN5FgK0wNKCyAzSLETrhakEWYQJTTZjsDmADlR4/8gjMtBIDkQRpYfUAeALAdhkGfgQUssA6QJ2SfksEGWgzDI"
+    "LGLthasDacrVuPmfGhhkFtxgYhkgTeRa7qBe8x8Zg8wi1l64OpAmUoId5liQxaBgR8Ygs+AGk8IAaSTWEbgcADKDFDtR1II0"
+    "k+IAkK9BDgHRMAwyA8VQUjkgA7A5AmYBPhqklyT7QBrogbE6CmTx4Y3f4Z4FsZHx8vmH/pOCkfWis0F2oTgCJABSBLIdRNMD"
+    "g+yEOwLEoYelyHaA7Bx1wOAJAZBLQHGCHEeUsAnlFpBdIDsxMEgChJEtB/GpjTEsRhYAWQZzAIiNLEcXNshSkANANF0sRLcE"
+    "ZDEIo4vTig8AgGltBNeEC2EAAAAASUVORK5CYII="
+)