sticker-convert 2.9.4__py3-none-any.whl → 2.10.1__py3-none-any.whl

sticker_convert/utils/auth/get_signal_auth.py

@@ -3,127 +3,128 @@ import json
 import os
 import platform
 import shutil
-from pathlib import Path
-from typing import Optional, Tuple
+import time
+import webbrowser
+from typing import Callable, Optional, Tuple, cast
 
-from sqlcipher3 import dbapi2 as sqlite3
+from sticker_convert.definitions import CONFIG_DIR
+from sticker_convert.utils.chrome_remotedebug import CRD
+from sticker_convert.utils.process import killall
 
 
 class GetSignalAuth:
-    def get_signal_desktop(self) -> Tuple[Optional[str], Optional[str]]:
-        if platform.system() == "Windows":
-            signal_bin_path_prod = os.path.expandvars(
-                "%localappdata%/Programs/signal-desktop/Signal.exe"
-            )
-            signal_bin_path_beta = os.path.expandvars(
-                "%localappdata%/Programs/signal-desktop-beta/Signal Beta.exe"
-            )
-            signal_user_data_dir_prod = os.path.abspath(
-                os.path.expandvars("%appdata%/Signal")
+    def __init__(
+        self,
+        cb_msg: Callable[..., None] = print,
+        cb_ask_str: Callable[..., str] = input,
+    ):
+        chromedriver_download_dir = CONFIG_DIR / "bin"
+        os.makedirs(chromedriver_download_dir, exist_ok=True)
+
+        self.chromedriver_download_dir = chromedriver_download_dir
+
+        self.cb_ask_str = cb_ask_str
+        self.cb_msg = cb_msg
+
+    def download_signal_desktop(self):
+        download_url = "https://signal.org/en/download/"
+
+        webbrowser.open(download_url)
+
+        self.cb_msg(download_url)
+
+        prompt = "Signal Desktop not detected.\n"
+        prompt += "Download and install Signal Desktop version\n"
+        prompt += "After installation, quit Signal Desktop before continuing"
+        if self.cb_ask_str != input:
+            self.cb_ask_str(
+                prompt, initialvalue=download_url, cli_show_initialvalue=False
             )
-            signal_user_data_dir_beta = os.path.abspath(
-                os.path.expandvars("%appdata%/Signal Beta")
+        else:
+            self.cb_msg(prompt)
+
+    def get_signal_bin_path(self) -> Optional[str]:
+        signal_paths: Tuple[Optional[str], ...]
+        if platform.system() == "Windows":
+            signal_paths = (
+                os.path.expandvars("%localappdata%/Programs/signal-desktop/Signal.exe"),
+                os.path.expandvars(
+                    "%localappdata%/Programs/signal-desktop-beta/Signal Beta.exe"
+                ),
             )
         elif platform.system() == "Darwin":
-            signal_bin_path_prod = "/Applications/Signal.app/Contents/MacOS/Signal"
-            signal_bin_path_beta = (
-                "/Applications/Signal Beta.app/Contents/MacOS/Signal Beta"
+            signal_paths = (
+                "/Applications/Signal.app/Contents/MacOS/Signal",
+                "/Applications/Signal Beta.app/Contents/MacOS/Signal Beta",
             )
-            signal_user_data_dir_prod = os.path.expanduser(
-                "~/Library/Application Support/Signal"
-            )
-            signal_user_data_dir_beta = os.path.expanduser(
-                "~/Library/Application Support/Signal Beta"
+        else:
+            signal_paths = (
+                shutil.which("signal-desktop"),
+                shutil.which("signal-desktop-beta"),
             )
+
+        for signal_path in signal_paths:
+            if signal_path is not None and os.path.isfile(signal_path):
+                return signal_path
+        return None
+
+    def get_cred(self) -> Tuple[Optional[str], Optional[str]]:
+        signal_bin_path = self.get_signal_bin_path()
+        if signal_bin_path is None:
+            self.download_signal_desktop()
+            return None, None
+
+        if platform.system() == "Windows":
+            killall("signal")
         else:
-            prod_which = shutil.which("signal-desktop")
-            if prod_which is None:
-                signal_bin_path_prod = "signal-desktop"
-            else:
-                signal_bin_path_prod = prod_which
-            beta_which = shutil.which("signal-desktop-beta")
-            if beta_which is None:
-                signal_bin_path_beta = "signal-desktop-beta"
-            else:
-                signal_bin_path_beta = beta_which
-            signal_user_data_dir_prod = os.path.expanduser("~/.config/Signal")
-            signal_user_data_dir_beta = os.path.expanduser("~/.config/Signal Beta")
-
-        if Path(signal_bin_path_prod).is_file():
-            return signal_bin_path_prod, signal_user_data_dir_prod
-        if Path(signal_bin_path_beta).is_file():
-            return signal_bin_path_beta, signal_user_data_dir_beta
-
-        return None, None
-
-    def get_cred(
-        self,
-        signal_bin_path: Optional[str] = None,
-        signal_user_data_dir: Optional[str] = None,
-    ) -> Tuple[Optional[str], Optional[str], str]:
-        if not (signal_bin_path and signal_user_data_dir):
-            signal_bin_path, signal_user_data_dir = self.get_signal_desktop()
-
-        if not (signal_bin_path and signal_user_data_dir):
-            msg = "Signal Desktop not detected.\n"
-            msg += "Download and install Signal Desktop,\n"
-            msg += "then login to Signal Desktop and try again."
-
-            return None, None, msg
-
-        signal_config = Path(signal_user_data_dir, "config.json")
-
-        if not signal_config.is_file():
-            msg = "Signal Desktop installed,\n"
-            msg += "but it's config file not found.\n"
-            msg += "Please login to Signal Desktop and try again.\n"
-            msg += "\n"
-            msg += f"{signal_bin_path=}\n"
-            msg += f"{signal_user_data_dir=}\n"
-            return None, None, msg
-
-        with open(signal_config, encoding="utf-8") as f:
-            config = json.load(f)
-        key = config.get("key")
-        db_key = f"x'{key}'"
-
-        signal_database = Path(signal_user_data_dir, "sql/db.sqlite")
-
-        if not signal_database.is_file():
-            msg = "Signal Desktop installed,\n"
-            msg += "but database file not found.\n"
-            msg += "Please login to Signal Desktop and try again.\n"
-            msg += "\n"
-            msg += f"{signal_bin_path=}\n"
-            msg += f"{signal_user_data_dir=}\n"
-            return None, None, msg
-
-        db_conn = sqlite3.connect(signal_database.as_posix())
-        db_cursor = db_conn.cursor()
-        db_cursor.execute(f'PRAGMA key="{db_key}"')
-
-        uuid_id = None
-        result = db_cursor.execute("SELECT * FROM items WHERE id='uuid_id'").fetchone()
-        if result:
-            uuid_id = json.loads(result[1])["value"]
-
-        password = None
-        result = db_cursor.execute("SELECT * FROM items WHERE id='password'").fetchone()
-        if result:
-            password = json.loads(result[1])["value"]
-
-        db_conn.close()
-
-        if uuid_id and password:
-            msg = "Got uuid and password successfully:\n"
-            msg += f"{uuid_id=}\n"
-            msg += f"{password=}"
-            return uuid_id, password, msg
-
-        msg = "Signal Desktop installed and Database found,\n"
-        msg += "but uuid and password not found.\n"
-        msg += "Please login to Signal Desktop and try again.\n"
-        msg += "\n"
-        msg += f"{signal_bin_path=}\n"
-        msg += f"{signal_user_data_dir=}\n"
-        return None, None, msg
+            killall("signal-desktop")
+
+        crd = CRD(signal_bin_path)
+        crd.connect()
+        # crd.runtime_enable()
+        # crd.reload()
+        # while True:
+        #     r = crd.ws.recv()
+        #     data = json.loads(r)
+        #     if data.get("method") == "Runtime.executionContextCreated":
+        #         print(data)
+        #     if (data.get("method") == "Runtime.executionContextCreated" and
+        #         data["params"]["context"]["name"] == "Electron Isolated Context"
+        #     ):
+        #         context_id = data["params"]["context"]["id"]
+        #         break
+        # crd.runtime_disable()
+        context_id = 2
+
+        uuid, password = None, None
+        while True:
+            try:
+                r = crd.exec_js(
+                    "window.reduxStore.getState().items.uuid_id", context_id
+                )
+            except RuntimeError:
+                break
+            if (
+                json.loads(r).get("result", {}).get("result", {}).get("type", "")
+                == "string"
+            ):
+                uuid = cast(str, json.loads(r)["result"]["result"]["value"])
+                break
+            time.sleep(1)
+        while True:
+            try:
+                r = crd.exec_js(
+                    "window.reduxStore.getState().items.password", context_id
+                )
+            except RuntimeError:
+                break
+            if (
+                json.loads(r).get("result", {}).get("result", {}).get("type", "")
+                == "string"
+            ):
+                password = cast(str, json.loads(r)["result"]["result"]["value"])
+                break
+            time.sleep(1)
+
+        crd.close()
+        return uuid, password

sticker_convert/utils/auth/get_viber_auth.py

@@ -3,14 +3,14 @@ import importlib.util
 import os
 import platform
 import shutil
-import signal
 import subprocess
 import time
+from functools import partial
 from getpass import getpass
 from pathlib import Path
 from typing import Callable, List, Optional, Tuple, cast
 
-from sticker_convert.definitions import ROOT_DIR
+from sticker_convert.utils.process import check_admin, find_pid_by_name, get_mem, killall
 
 MSG_NO_BIN = """Viber Desktop not detected.
 Download and install Viber Desktop,
@@ -23,102 +23,10 @@ MSG_SIP_ENABLED = """You need to disable SIP:
 2. Launch Terminal from the Utilities menu
 3. Run the command `csrutil disable`
 4. Restart your computer"""
-MSG_NO_PGREP = "pgrep command or psutil python package is necessary"
 MSG_LAUNCH_FAIL = "Failed to launch Viber"
 MSG_PERMISSION_ERROR = "Failed to read Viber process memory"
 
 
-def check_admin_windows() -> bool:
-    username = os.getenv("username")
-    if username is None:
-        return False
-
-    s = subprocess.run(
-        ["net", "user", username],
-        capture_output=True,
-        text=True,
-    ).stdout
-
-    return True if "*Administrators" in s else False
-
-
-def check_admin_linux() -> bool:
-    s = subprocess.run(
-        ["sudo", "-l"],
-        capture_output=True,
-        text=True,
-    ).stdout
-
-    return True if "may run the following commands" in s else False
-
-
-def killall(name: str) -> bool:
-    result = False
-
-    while True:
-        pid = find_pid_by_name(name)
-        if pid is not None:
-            os.kill(pid, signal.SIGTERM)
-            result = True
-        else:
-            break
-
-    return result
-
-
-def find_pid_by_name(name: str) -> Optional[int]:
-    if platform.system() == "Windows":
-        s = subprocess.run(
-            ["powershell", "-c", "Get-Process", f"*{name}*"],
-            capture_output=True,
-            text=True,
-        ).stdout
-
-        for line in s.split("\n"):
-            if name in line.lower():
-                info = name.split()
-                pid = info[5]
-                if pid.isnumeric():
-                    return int(pid)
-
-        return None
-    else:
-        if platform.system() == "Darwin":
-            pattern = "Viber"
-        else:
-            pattern = ".*[Vv]iber.*"
-        pid = (
-            subprocess.run(["pgrep", pattern], capture_output=True, text=True)
-            .stdout.split("\n")[0]
-            .strip()
-        )
-        if pid == "" or pid.isnumeric() is False:
-            return None
-        else:
-            return int(pid)
-
-
-if importlib.util.find_spec("psutil"):
-    import psutil
-
-    def killall(name: str) -> bool:
-        result = False
-
-        for proc in psutil.process_iter():  # type: ignore
-            if name in proc.name().lower():
-                proc.kill()
-                result = True
-
-        return result
-
-    def find_pid_by_name(name: str) -> Optional[int]:
-        for proc in psutil.process_iter():  # type: ignore
-            if name in proc.name().lower():
-                return proc.pid
-
-        return None
-
-
 class GetViberAuth:
     def __init__(self, cb_ask_str: Callable[..., str] = input):
         self.cb_ask_str = cb_ask_str
@@ -137,113 +45,6 @@ class GetViberAuth:
 
         return find_pid_by_name("viber")
 
-    def get_mem_windows(self, viber_pid: int) -> Tuple[Optional[bytes], str]:
-        from pathlib import WindowsPath
-
-        memdump_ps_path = str(WindowsPath(ROOT_DIR / "resources/memdump_windows.ps1"))
-        arglist = (
-            f'-NoProfile -ExecutionPolicy Bypass -File "{memdump_ps_path}" {viber_pid}'
-        )
-        dump_fpath = os.path.expandvars(f"%temp%/memdump.bin.{viber_pid}")
-
-        cmd = [
-            "powershell",
-            "-NoProfile",
-            "-ExecutionPolicy",
-            "Bypass",
-            "-Command",
-            f"Start-Process -Verb RunAs powershell -ArgumentList '{arglist}'",
-        ]
-
-        subprocess.run(cmd, capture_output=True, text=True)
-
-        while True:
-            try:
-                with open(dump_fpath, "rb") as f:
-                    s = f.read()
-                if len(s) != 0:
-                    break
-                time.sleep(1)
-            except (FileNotFoundError, PermissionError):
-                pass
-
-        while True:
-            try:
-                os.remove(dump_fpath)
-                break
-            except PermissionError:
-                pass
-
-        return s, ""
-
-    def get_mem_linux(self, viber_pid: int) -> Tuple[Optional[bytes], str]:
-        memdump_sh_path = (ROOT_DIR / "resources/memdump_linux.sh").as_posix()
-
-        s = subprocess.run(
-            [
-                memdump_sh_path,
-                str(viber_pid),
-            ],
-            capture_output=True,
-        ).stdout
-
-        if len(s) > 1000:
-            pass
-        elif shutil.which("pkexec") and os.getenv("DISPLAY"):
-            s = subprocess.run(
-                [
-                    "pkexec",
-                    memdump_sh_path,
-                    str(viber_pid),
-                ],
-                capture_output=True,
-            ).stdout
-        else:
-            prompt = "Enter sudo password: "
-            if self.cb_ask_str != input:
-                sudo_password = self.cb_ask_str(
-                    prompt, initialvalue="", cli_show_initialvalue=False
-                )
-            else:
-                sudo_password = getpass(prompt)
-            sudo_password_pipe = subprocess.Popen(
-                ("echo", sudo_password), stdout=subprocess.PIPE
-            )
-            s = subprocess.run(
-                [
-                    "sudo",
-                    "-S",
-                    memdump_sh_path,
-                    str(viber_pid),
-                ],
-                capture_output=True,
-                stdin=sudo_password_pipe.stdout,
-            ).stdout
-
-        return s, ""
-
-    def get_mem_darwin(self, viber_pid: int) -> Tuple[Optional[bytes], str]:
-        subprocess.run(
-            [
-                "lldb",
-                "--attach-pid",
-                str(viber_pid),
-                "-o",
-                "process save-core /tmp/viber.dmp",
-                "-o",
-                "quit",
-            ],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-        with open("/tmp/viber.dmp", "rb") as f:
-            s = f.read()
-
-        os.remove("/tmp/viber.dmp")
-
-        return s, ""
-
     def get_auth_by_pme(
         self, viber_bin_path: str, relaunch: bool = True
     ) -> Tuple[Optional[str], str]:
@@ -315,12 +116,6 @@ class GetViberAuth:
 
             if "enabled" in csrutil_status:
                 return None, MSG_SIP_ENABLED
-        elif (
-            platform.system() != "Windows"
-            and shutil.which("pgrep") is None
-            and importlib.find_loader("psutil") is None
-        ):
-            return None, MSG_NO_PGREP
 
         if relaunch:
             viber_pid = self.relaunch_viber(viber_bin_path)
@@ -329,12 +124,13 @@ class GetViberAuth:
         if viber_pid is None:
             return None, MSG_LAUNCH_FAIL
 
-        if platform.system() == "Windows":
-            s, msg = self.get_mem_windows(viber_pid)
-        elif platform.system() == "Darwin":
-            s, msg = self.get_mem_darwin(viber_pid)
+        if self.cb_ask_str == input:
+            pw_func = getpass
         else:
-            s, msg = self.get_mem_linux(viber_pid)
+            pw_func = partial(
+                self.cb_ask_str, initialvalue="", cli_show_initialvalue=False
+            )
+        s, msg = get_mem(viber_pid, pw_func)
 
         if s is None:
             return None, msg
@@ -421,14 +217,14 @@ class GetViberAuth:
             methods.append(self.get_auth_by_dump)
             if pme_present:
                 methods.append(self.get_auth_by_pme)
-            if check_admin_windows() is False:
+            if check_admin() is False:
                 methods.reverse()
         else:
             if not os.path.isfile("/.dockerenv"):
                 methods.append(self.get_auth_by_dump)
             if pme_present:
                 methods.append(self.get_auth_by_pme)
-            if check_admin_linux() is False:
+            if check_admin() is False:
                 methods.reverse()
 
         for method in methods:

sticker_convert/utils/chrome_remotedebug.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+import json
+import os
+import platform
+import shutil
+import socket
+import subprocess
+import time
+from typing import Any, Dict, Optional, Union, cast
+
+import requests
+import websocket
+
+# References
+# https://github.com/yeongbin-jo/python-chromedriver-autoinstaller/blob/master/chromedriver_autoinstaller/utils.py
+# https://chromedevtools.github.io/devtools-protocol/
+
+
+def get_free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("", 0))
+        port = sock.getsockname()[1]
+    return port
+
+
+class CRD:
+    def __init__(self, chrome_bin: str, port: Optional[int] = None):
+        if port is None:
+            port = get_free_port()
+        self.port = port
+        self.chrome_proc = subprocess.Popen(
+            [
+                chrome_bin,
+                "--no-sandbox",
+                f"--remote-debugging-port={port}",
+                f"--remote-allow-origins=http://localhost:{port}",
+            ]
+        )
+
+    @staticmethod
+    def get_chrome_path() -> Optional[str]:
+        chrome_bin: Optional[str]
+        if platform.system() == "Darwin":
+            chrome_bin = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+
+            if os.path.isfile(chrome_bin) is False:
+                return None
+
+            return chrome_bin
+
+        elif platform.system() == "Windows":
+            chrome_x64 = f"{os.environ.get('PROGRAMW6432') or os.environ.get('PROGRAMFILES')}\\Google\\Chrome\\Application"
+            chrome_x86 = (
+                f"{os.environ.get('PROGRAMFILES(X86)')}\\Google\\Chrome\\Application"
+            )
+
+            chrome_dir = (
+                chrome_x64
+                if os.path.isdir(chrome_x64)
+                else chrome_x86
+                if os.path.isdir(chrome_x86)
+                else None
+            )
+
+            if chrome_dir is None:
+                return None
+
+            return chrome_dir + "\\chrome.exe"
+
+        else:
+            for executable in (
+                "google-chrome",
+                "google-chrome-stable",
+                "google-chrome-beta",
+                "google-chrome-dev",
+                "chromium-browser",
+                "chromium",
+            ):
+                chrome_bin = shutil.which(executable)
+                if chrome_bin is not None:
+                    return chrome_bin
+            return None
+
+    def connect(self):
+        self.cmd_id = 1
+        r = None
+        for _ in range(3):
+            try:
+                r = requests.get(f"http://localhost:{self.port}/json")
+                break
+            except requests.exceptions.ConnectionError:
+                time.sleep(1)
+
+        if r is None:
+            raise RuntimeError("Cannot connect to chrome debugging port")
+
+        targets = json.loads(r.text)
+        self.ws = websocket.create_connection(targets[0]["webSocketDebuggerUrl"])  # type: ignore
+
+    def send_cmd(self, command: Dict[Any, Any]) -> Union[str, bytes]:
+        if command.get("id") is None:
+            command["id"] = self.cmd_id
+        for _ in range(3):
+            try:
+                self.ws.send(json.dumps(command))
+                r = self.ws.recv()
+                self.cmd_id += 1
+                return r
+            except BrokenPipeError:
+                self.connect()
+
+        raise RuntimeError("Websocket keep disconnecting")
+
+    def exec_js(self, js: str, context_id: Optional[int] = None):
+        command: Dict[str, Any] = {
+            "id": self.cmd_id,
+            "method": "Runtime.evaluate",
+            "params": {"expression": js},
+        }
+        if context_id is not None:
+            command["params"]["contextId"] = context_id
+        return self.send_cmd(command)
+
+    def get_curr_url(self) -> str:
+        r = self.exec_js("window.location.href")
+        return cast(
+            str, json.loads(r).get("result", {}).get("result", {}).get("value", "")
+        )
+
+    def navigate(self, url: str):
+        command = {"id": self.cmd_id, "method": "Page.navigate", "params": {"url": url}}
+        self.send_cmd(command)
+
+    def runtime_enable(self):
+        command = {
+            "method": "Runtime.enable",
+        }
+        self.send_cmd(command)
+
+    def runtime_disable(self):
+        command = {
+            "method": "Runtime.disable",
+        }
+        self.send_cmd(command)
+
+    def reload(self):
+        command = {
+            "method": "Page.reload",
+        }
+        self.send_cmd(command)
+
+    def close(self):
+        self.ws.close()
+        self.chrome_proc.kill()