sticker-convert 2.8.12__py3-none-any.whl → 2.17.0.0__py3-none-any.whl

sticker_convert/auth/auth_kakao_desktop_login.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+import base64
+import hashlib
+import json
+import os
+import platform
+import re
+import shutil
+import socket
+import subprocess
+import time
+import uuid
+from typing import Any, Optional, Tuple
+
+import requests
+from bs4 import BeautifulSoup
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+from sticker_convert.auth.auth_base import AuthBase
+from sticker_convert.utils.translate import I
+
+
+class AuthKakaoDesktopLogin(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.OK_MSG = I("Login successful, auth_token={}")
+
+        super().__init__(*args, **kwargs)
+        self.username = self.opt_cred.kakao_username
+        self.password = self.opt_cred.kakao_password
+
+        if platform.system() == "Darwin":
+            self.plat = "mac"
+            user_agent_os = "Mc"
+            self.os_version = platform.mac_ver()[0]
+            version = self.macos_get_ver()
+            if version is None:
+                version = "25.2.0"
+        else:
+            self.plat = "win32"
+            user_agent_os = "Wd"
+            if platform.system() == "Windows":
+                self.os_version = platform.uname().version
+            else:
+                self.os_version = "10.0"
+            version = self.windows_get_ver()
+            if version is None:
+                version = "25.8.2"
+
+        user_agent = f"KT/{version} {user_agent_os}/{self.os_version} en"
+        self.headers = {
+            "user-agent": user_agent,
+            "a": f"{self.plat}/{version}/en",
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br",
+            "accept-language": "en",
+            "host": "katalk.kakao.com",
+            "Connection": "close",
+        }
+
+        self.device_name = socket.gethostname()
+        if platform.system() != "Darwin":
+            self.device_name = self.device_name.upper()
+        self.device_uuid = self.get_device_uuid()
+
+        hash = hashlib.sha512(
+            f"KLEAL|{self.username}|{self.device_uuid}|LCNUE|{user_agent}".encode(
+                "utf-8"
+            )
+        ).hexdigest()
+        xvc = hash[:16]
+
+        self.headers_login = self.headers.copy()
+        self.headers_login["x-vc"] = xvc
+
+    def pkcs7_pad(self, m: str) -> str:
+        return m + chr(16 - len(m) % 16) * (16 - len(m) % 16)
+
+    def windows_get_ver(self) -> Optional[str]:
+        r = requests.get(
+            "https://api.github.com/repos/microsoft/winget-pkgs/contents/manifests/k/Kakao/KakaoTalk"
+        )
+        rjson = json.loads(r.text)
+        if len(rjson) == 0:
+            return None
+        ver = rjson[-1]["name"]
+        return ".".join(ver.split(".")[:3])
+
+    def macos_get_ver(self) -> Optional[str]:
+        country = "us"
+        app_name = "kakaotalk-messenger"
+        app_id = "362057947"
+
+        url = f"https://apps.apple.com/{country}/app/{app_name}/id{app_id}"
+
+        r = requests.get(url)
+        soup = BeautifulSoup(r.text, "html.parser")
+        version_tag = soup.find("p", {"class": re.compile(".*latest__version")})
+        version_str = None
+        if version_tag is not None:
+            version_str = version_tag.text.replace("Version ", "")
+        return version_str
+
+    def windows_get_pragma(self, use_wine: bool = False) -> Optional[str]:
+        sys_uuid = None
+        hdd_model = None
+        hdd_serial = None
+
+        if use_wine and shutil.which("wine") is None:
+            return None
+
+        regkey = "HKEY_CURRENT_USER\\Software\\Kakao\\KakaoTalk\\DeviceInfo"
+        wine = "wine " if use_wine else ""
+        cmd = f"{wine}reg query '{regkey}' /v Last"
+        last_device_info = subprocess.run(
+            cmd, stdout=subprocess.PIPE, shell=True
+        ).stdout.decode()
+        if "REG_SZ" not in last_device_info:
+            return None
+        last_device_info = last_device_info.split("\n")[2].split()[2]
+
+        if self.opt_cred.kakao_device_uuid:
+            sys_uuid = self.opt_cred.kakao_device_uuid
+        else:
+            cmd = f"{wine}reg query '{regkey}\\{last_device_info}' /v sys_uuid"
+            sys_uuid = subprocess.run(
+                cmd, stdout=subprocess.PIPE, shell=True
+            ).stdout.decode()
+            if "REG_SZ" in sys_uuid:
+                sys_uuid = sys_uuid.split("\n")[2].split()[2]
+
+        cmd = f"{wine}reg query '{regkey}\\{last_device_info}' /v hdd_model"
+        hdd_model = subprocess.run(
+            cmd, stdout=subprocess.PIPE, shell=True
+        ).stdout.decode()
+        if "REG_SZ" in hdd_model:
+            hdd_model = hdd_model.split("\n")[2].split()[2]
+
+        cmd = f"{wine}reg query '{regkey}\\{last_device_info}' /v hdd_serial"
+        hdd_serial = subprocess.run(
+            cmd, stdout=subprocess.PIPE, shell=True
+        ).stdout.decode()
+        if "REG_SZ" in hdd_serial:
+            hdd_serial = hdd_serial.split("\n")[2].split()[2]
+
+        if sys_uuid and hdd_model and hdd_serial:
+            return f"{sys_uuid}|{hdd_model}|{hdd_serial}"
+        else:
+            return None
+
+    def get_device_uuid(self) -> str:
+        if platform.system() == "Darwin":
+            cmd = "ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID | awk '{print $3}'"
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True, check=True)
+            hwid = result.stdout.decode().strip().replace('"', "")
+
+            hwid_sha1 = bytes.fromhex(hashlib.sha1(hwid.encode()).hexdigest())
+            hwid_sha256 = bytes.fromhex(hashlib.sha256(hwid.encode()).hexdigest())
+
+            return base64.b64encode(hwid_sha1 + hwid_sha256).decode()
+        else:
+            use_wine = True if platform.system() != "Windows" else False
+            pragma = self.windows_get_pragma(use_wine=use_wine)
+            if pragma is None:
+                if platform.system() == "Windows":
+                    if self.opt_cred.kakao_device_uuid:
+                        sys_uuid = self.opt_cred.kakao_device_uuid
+                    else:
+                        cmd = "wmic csproduct get uuid"
+                        result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True)
+                        sys_uuid = result.stdout.decode().split("\n")[1].strip()
+                    cmd = "wmic diskdrive get Model"
+                    result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True)
+                    hdd_model = result.stdout.decode().split("\n")[1].strip()
+                    cmd = "wmic diskdrive get SerialNumber"
+                    result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True)
+                    hdd_serial = result.stdout.decode().split("\n")[1].strip()
+                else:
+                    if self.opt_cred.kakao_device_uuid:
+                        sys_uuid = self.opt_cred.kakao_device_uuid
+                    else:
+                        product_uuid_path = "/sys/devices/virtual/dmi/id/product_uuid"
+                        sys_uuid = None
+                        if os.access(product_uuid_path, os.R_OK):
+                            cmd = f"cat {product_uuid_path}"
+                            result = subprocess.run(
+                                cmd, stdout=subprocess.PIPE, shell=True
+                            )
+                            if result.returncode == 0:
+                                sys_uuid = result.stdout.decode().strip()
+                        if sys_uuid is None:
+                            sys_uuid = str(uuid.uuid4()).upper()
+                            self.opt_cred.kakao_device_uuid = sys_uuid
+                    hdd_model = "Wine Disk Drive"
+                    hdd_serial = ""
+                pragma = f"{sys_uuid}|{hdd_model}|{hdd_serial}"
+
+            aes_key = bytes.fromhex("9FBAE3118FDE5DEAEB8279D08F1D4C79")
+            aes_iv = bytes.fromhex("00000000000000000000000000000000")
+
+            cipher = Cipher(algorithms.AES(aes_key), modes.CBC(aes_iv))
+            encryptor = cipher.encryptor()
+            padded = self.pkcs7_pad(pragma).encode()
+            encrypted_pragma = encryptor.update(padded) + encryptor.finalize()
+            pragma_hash = hashlib.sha512(encrypted_pragma).digest()
+
+            return base64.b64encode(pragma_hash).decode()
+
+    def login(self, forced: bool = False):
+        data = {
+            "device_name": self.device_name,
+            "device_uuid": self.device_uuid,
+            "email": self.username,
+            "os_version": self.os_version,
+            "password": self.password,
+            "permanent": "1",
+        }
+
+        if forced:
+            data["forced"] = "1"
+
+        headers = self.headers_login.copy()
+        headers["content-type"] = "application/x-www-form-urlencoded"
+        response = requests.post(
+            f"https://katalk.kakao.com/{self.plat}/account/login.json",
+            headers=headers,
+            data=data,
+        )
+
+        return json.loads(response.text)
+
+    def generate_passcode(self):
+        data = {
+            "password": self.password,
+            "permanent": True,
+            "device": {
+                "name": self.device_name,
+                "osVersion": self.os_version,
+                "uuid": self.device_uuid,
+            },
+            "email": self.username,
+        }
+
+        if platform.system() == "Darwin":
+            cmd = "sysctl -n hw.model"
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True, check=True)
+            data["device"]["model"] = result.stdout.decode().strip()  # type: ignore
+
+        headers = self.headers_login.copy()
+        headers["content-type"] = "application/json"
+        response = requests.post(
+            f"https://katalk.kakao.com/{self.plat}/account/passcodeLogin/generate",
+            headers=headers,
+            json=data,
+        )
+
+        return json.loads(response.text)
+
+    def register_device(self):
+        data = {
+            "device": {"uuid": self.device_uuid},
+            "email": self.username,
+            "password": self.password,
+        }
+
+        headers = self.headers_login.copy()
+        headers["content-type"] = "application/json"
+        response = None
+
+        response = requests.post(
+            f"https://katalk.kakao.com/{self.plat}/account/passcodeLogin/registerDevice",
+            headers=headers,
+            json=data,
+        )
+        return json.loads(response.text)
+
+    def get_cred(self) -> Tuple[Optional[str], str]:
+        msg = I("Getting Kakao authorization token by desktop login...")
+        self.cb.put(("msg_dynamic", (msg,), None))
+        rjson = self.login()
+        access_token = rjson.get("access_token")
+        if access_token is not None:
+            auth_token = access_token + "-" + self.device_uuid
+            self.cb.put(("msg_dynamic", (None,), None))
+            return auth_token, self.OK_MSG.format(auth_token)
+
+        rjson = self.generate_passcode()
+        if rjson.get("status") != 0:
+            return None, I("Failed to generate passcode: {}").format(rjson)
+        passcode = rjson["passcode"]
+
+        fail_reason = None
+        self.cb.put(("msg_dynamic", (None,), None))
+        while True:
+            rjson = self.register_device()
+            if rjson["status"] == 0:
+                break
+            elif rjson["status"] == -110:
+                fail_reason = "Timeout"
+                break
+            elif rjson["status"] != -100:
+                fail_reason = str(rjson)
+                break
+            time_remaining = rjson.get("remainingSeconds")
+            next_req_time = rjson.get("nextRequestIntervalInSeconds")
+            if time_remaining is None or next_req_time is None:
+                fail_reason = str(rjson)
+            msg = I(
+                "Please enter passcode in Kakao app on mobile device within {} seconds: {}"
+            ).format(time_remaining, passcode)
+            msg_dynamic_window_exist = self.cb.put(("msg_dynamic", (msg,), None))
+            if msg_dynamic_window_exist is False:
+                fail_reason = "Cancelled"
+                break
+            time.sleep(next_req_time)
+        self.cb.put(("msg_dynamic", (None,), None))
+        if fail_reason is not None:
+            return None, I("Failed to register device: {}").format(fail_reason)
+
+        rjson = self.login()
+        if rjson.get("status") == -101:
+            rjson = self.login(forced=True)
+        access_token = rjson.get("access_token")
+        if access_token is None:
+            return None, I("Failed to login after registering device: {}").format(rjson)
+
+        auth_token = access_token + "-" + self.device_uuid
+        return auth_token, self.OK_MSG.format(auth_token)

sticker_convert/auth/auth_kakao_desktop_memdump.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+import os
+import platform
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Optional, Tuple, Union, cast
+
+from sticker_convert.auth.auth_base import AuthBase
+from sticker_convert.utils.process import find_pid_by_name, get_mem, killall
+from sticker_convert.utils.translate import I
+
+
+class AuthKakaoDesktopMemdump(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.MSG_NO_BIN = I(
+            "Kakao Desktop not detected.\n"
+            "Download and install Kakao Desktop,\n"
+            "then login to Kakao Desktop and try again."
+        )
+        self.MSG_NO_AUTH = I(
+            "Kakao Desktop installed,\n"
+            "but kakao_auth not found.\n"
+            "Please login to Kakao Desktop and try again."
+        )
+        self.MSG_SIP_ENABLED = I(
+            "You need to disable SIP:\n"
+            "1. Restart computer in Recovery mode\n"
+            "2. Launch Terminal from the Utilities menu\n"
+            "3. Run the command `csrutil disable`\n"
+            "4. Restart your computer"
+        )
+        self.MSG_LAUNCH_FAIL = I("Failed to launch Kakao")
+        self.MSG_PERMISSION_ERROR = I("Failed to read Kakao process memory")
+
+        super().__init__(*args, **kwargs)
+
+    def launch_kakao(self, kakao_bin_path: str) -> None:
+        if platform.system() == "Windows":
+            subprocess.Popen([kakao_bin_path])
+        elif platform.system() == "Darwin":
+            subprocess.Popen(["open", kakao_bin_path])
+        else:
+            subprocess.Popen(["wine", kakao_bin_path])
+
+    def relaunch_kakao(self, kakao_bin_path: str) -> Optional[int]:
+        killed = killall("kakaotalk")
+        if killed:
+            time.sleep(5)
+
+        self.launch_kakao(kakao_bin_path)
+        time.sleep(20)
+
+        return find_pid_by_name("kakaotalk")
+
+    def get_auth_by_pme(
+        self, kakao_bin_path: str, relaunch: bool = True
+    ) -> Tuple[Optional[str], str]:
+        from PyMemoryEditor import OpenProcess  # type: ignore
+
+        auth_token = None
+
+        if relaunch:
+            kakao_pid = self.relaunch_kakao(kakao_bin_path)
+        else:
+            kakao_pid = find_pid_by_name("kakaotalk")
+        if kakao_pid is None:
+            return None, self.MSG_LAUNCH_FAIL
+
+        try:
+            with OpenProcess(pid=int(kakao_pid)) as process:
+                for address in process.search_by_value(  # type: ignore
+                    str, 15, "authorization: "
+                ):
+                    auth_token_addr = cast(int, address) + 15
+                    auth_token_bytes = process.read_process_memory(
+                        auth_token_addr, bytes, 200
+                    )
+                    auth_token_term = auth_token_bytes.find(b"\x00")
+                    if auth_token_term == -1:
+                        continue
+                    auth_token_candidate = auth_token_bytes[:auth_token_term].decode(
+                        encoding="ascii"
+                    )
+                    if len(auth_token_candidate) > 150:
+                        auth_token = auth_token_candidate
+                        break
+        except PermissionError:
+            return None, self.MSG_PERMISSION_ERROR
+
+        if auth_token is None:
+            return None, self.MSG_NO_AUTH
+        else:
+            msg = "(Note: auth_token will be invalid if you quit Kakao Desktop)"
+            msg += "Got auth_token successfully:\n"
+            msg += f"{auth_token=}\n"
+
+            return auth_token, msg
+
+    def get_auth_by_dump(
+        self, kakao_bin_path: str, relaunch: bool = True
+    ) -> Tuple[Optional[str], str]:
+        auth_token = None
+        kakao_pid: Union[str, int, None]
+        if platform.system() == "Windows":
+            is_wine = False
+            if relaunch:
+                kakao_pid = self.relaunch_kakao(kakao_bin_path)
+            else:
+                kakao_pid = find_pid_by_name("kakaotalk")
+            if kakao_pid is None:
+                return None, self.MSG_LAUNCH_FAIL
+        else:
+            is_wine = True
+            kakao_pid = "KakaoTalk.exe"
+            if relaunch and self.relaunch_kakao(kakao_bin_path) is None:
+                return None, self.MSG_LAUNCH_FAIL
+
+        def pw_func(msg: str) -> str:
+            return self.cb.put(
+                (
+                    "ask_str",
+                    None,
+                    {
+                        "message": msg,
+                        "password": True,
+                    },
+                )
+            )
+
+        s = get_mem(kakao_pid, pw_func, is_wine)
+
+        if s is None:
+            return None, "Failed to dump memory"
+
+        auth_token = None
+        for i in re.finditer(b"authorization: ", s):
+            auth_token_addr = i.start() + 15
+
+            auth_token_bytes = s[auth_token_addr : auth_token_addr + 200]
+            auth_token_term = auth_token_bytes.find(b"\x00")
+            if auth_token_term == -1:
+                continue
+            auth_token_candidate = auth_token_bytes[:auth_token_term].decode(
+                encoding="ascii"
+            )
+            if len(auth_token_candidate) > 150:
+                auth_token = auth_token_candidate
+                break
+
+        if auth_token is None:
+            return None, self.MSG_NO_AUTH
+        else:
+            msg = "Got auth_token successfully:\n"
+            msg += f"{auth_token=}\n"
+
+            return auth_token, msg
+
+    def get_auth_darwin(self, kakao_bin_path: str) -> Tuple[Optional[str], str]:
+        csrutil_status = subprocess.run(
+            ["csrutil", "status"], capture_output=True, text=True
+        ).stdout
+
+        if "enabled" in csrutil_status:
+            return None, self.MSG_SIP_ENABLED
+
+        killall("kakaotalk")
+
+        subprocess.run(
+            [
+                "lldb",
+                kakao_bin_path,
+                "-o",
+                "b ptrace",
+                "-o",
+                "r",
+                "-o",
+                "thread return",
+                "-o",
+                "con",
+                "-o",
+                "process save-core /tmp/memdump.kakaotalk.dmp",
+                "-o",
+                "con",
+                "-o",
+                "quit",
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        with open("/tmp/memdump.kakaotalk.dmp", "rb") as f:
+            mem = f.read()
+
+        os.remove("/tmp/memdump.kakaotalk.dmp")
+
+        auth_token = None
+        for i in re.finditer(b"]mac/", mem):
+            auth_token_term = i.start()
+
+            auth_token_bytes = mem[auth_token_term - 200 : auth_token_term]
+            auth_token_start = auth_token_bytes.find(b"application/json_\x10\x8a") + 19
+            if auth_token_start == -1:
+                continue
+            try:
+                auth_token_candidate = auth_token_bytes[auth_token_start:].decode(
+                    encoding="ascii"
+                )
+            except UnicodeDecodeError:
+                continue
+
+            if 150 > len(auth_token_candidate) > 100:
+                auth_token = auth_token_candidate
+                break
+
+        if auth_token is None:
+            return None, self.MSG_NO_AUTH
+        else:
+            msg = "Got auth_token successfully:\n"
+            msg += f"{auth_token=}\n"
+
+            return auth_token, msg
+
+    def get_kakao_desktop(self) -> Optional[str]:
+        if platform.system() == "Windows":
+            kakao_bin_path = os.path.expandvars(
+                "%programfiles(x86)%\\Kakao\\KakaoTalk\\KakaoTalk.exe"
+            )
+            if Path(kakao_bin_path).exists() is False:
+                kakao_bin_path = os.path.expandvars(
+                    "%programfiles%\\Kakao\\KakaoTalk\\KakaoTalk.exe"
+                )
+        elif platform.system() == "Darwin":
+            kakao_bin_path = "/Applications/KakaoTalk.app"
+        else:
+            wineprefix = os.environ.get("WINEPREFIX")
+            if not (wineprefix and Path(wineprefix).exists()):
+                wineprefix = os.path.expanduser("~/.wine")
+            kakao_bin_path = f"{wineprefix}/drive_c/Program Files (x86)/Kakao/KakaoTalk/KakaoTalk.exe"
+
+        if Path(kakao_bin_path).exists():
+            return kakao_bin_path
+
+        return None
+
+    def get_cred(
+        self,
+        kakao_bin_path: Optional[str] = None,
+    ) -> Tuple[Optional[str], str]:
+        # get_auth_by_dump()
+        # + Fast
+        # - Requires downloading procdump, or builtin method that needs admin
+
+        # get_auth_by_pme()
+        # + No admin (If have permission to read process)
+        # - Slow
+        # - Cannot run on macOS
+
+        msg = I(
+            "Getting Kakao authorization token by Desktop memdump...\n(This may take a minute)"
+        )
+        self.cb.put(("msg_dynamic", (msg,), None))
+        if not kakao_bin_path:
+            kakao_bin_path = self.get_kakao_desktop()
+
+        if not kakao_bin_path:
+            return None, self.MSG_NO_BIN
+
+        if platform.system() == "Windows":
+            kakao_auth, msg = self.get_auth_by_dump(kakao_bin_path)
+            if kakao_auth is None:
+                kakao_auth, msg = self.get_auth_by_pme(kakao_bin_path, False)
+        elif platform.system() == "Darwin":
+            kakao_auth, msg = self.get_auth_darwin(kakao_bin_path)
+        else:
+            kakao_auth, msg = self.get_auth_by_dump(kakao_bin_path)
+
+        self.cb.put(("msg_dynamic", (None,), None))
+
+        return kakao_auth, msg