sticker-convert 2.13.3.0__py3-none-any.whl → 2.15.0.0__py3-none-any.whl

sticker_convert/auth/auth_kakao_desktop_login.py

@@ -0,0 +1,323 @@
+#!/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
+
+OK_MSG = "Login successful, auth_token: {auth_token}"
+
+
+class AuthKakaoDesktopLogin(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        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 = "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
+            return auth_token, OK_MSG.format(auth_token=auth_token)
+
+        rjson = self.generate_passcode()
+        if rjson.get("status") != 0:
+            return None, f"Failed to generate passcode: {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 = f"Please enter passcode in Kakao app on mobile device within {time_remaining} seconds: {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, f"Failed to register device: {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, f"Failed to login after registering device: {rjson}"
+
+        auth_token = access_token + "-" + self.device_uuid
+        return auth_token, OK_MSG.format(auth_token=auth_token)

sticker_convert/{utils/auth/get_kakao_desktop_auth.py → auth/auth_kakao_desktop_memdump.py}

@@ -4,11 +4,10 @@ import platform
 import re
 import subprocess
 import time
-from functools import partial
-from getpass import getpass
 from pathlib import Path
-from typing import Callable, Optional, Tuple, Union, cast
+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
 
 MSG_NO_BIN = """Kakao Desktop not detected.
@@ -26,9 +25,9 @@ MSG_LAUNCH_FAIL = "Failed to launch Kakao"
 MSG_PERMISSION_ERROR = "Failed to read Kakao process memory"
 
 
-class GetKakaoDesktopAuth:
-    def __init__(self, cb_ask_str: Callable[..., str] = input) -> None:
-        self.cb_ask_str = cb_ask_str
+class AuthKakaoDesktopMemdump(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
     def launch_kakao(self, kakao_bin_path: str) -> None:
         if platform.system() == "Windows":
@@ -111,12 +110,18 @@ class GetKakaoDesktopAuth:
             if relaunch and self.relaunch_kakao(kakao_bin_path) is None:
                 return None, MSG_LAUNCH_FAIL
 
-        if self.cb_ask_str == input:
-            pw_func = getpass
-        else:
-            pw_func = partial(
-                self.cb_ask_str, initialvalue="", cli_show_initialvalue=False
+        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:
@@ -129,7 +134,7 @@ class GetKakaoDesktopAuth:
             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:
-                return None, MSG_NO_AUTH
+                continue
             auth_token_candidate = auth_token_bytes[:auth_token_term].decode(
                 encoding="ascii"
             )
@@ -245,6 +250,8 @@ class GetKakaoDesktopAuth:
         # - Slow
         # - Cannot run on macOS
 
+        msg = "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()
 
@@ -260,4 +267,6 @@ class GetKakaoDesktopAuth:
         else:
             kakao_auth, msg = self.get_auth_by_dump(kakao_bin_path)
 
+        self.cb.put(("msg_dynamic", (None,), None))
+
         return kakao_auth, msg

sticker_convert/{utils/auth/get_line_auth.py → auth/auth_line.py}

@@ -2,14 +2,25 @@
 import json
 import platform
 from http.cookiejar import CookieJar
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import requests
 import rookiepy
 
+from sticker_convert.auth.auth_base import AuthBase
+
+OK_MSG = "Got Line cookies successfully"
+FAIL_MSG = "Failed to get Line cookies. Have you logged in the web browser?"
+
+
+class AuthLine(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def get_cred(self) -> Tuple[Optional[str], str]:
+        msg = "Getting Line cookies"
+        self.cb.put(("msg_dynamic", (msg,), None))
 
-class GetLineAuth:
-    def get_cred(self) -> Optional[str]:
         browsers: List[Callable[..., Any]] = [
             rookiepy.load,  # Supposed to load from any browser, but may fail
             rookiepy.firefox,
@@ -44,19 +55,23 @@ class GetLineAuth:
                 cookies_dict = browser(["store.line.me"])
                 cookies_jar = rookiepy.to_cookiejar(cookies_dict)
 
-                if GetLineAuth.validate_cookies(cookies_jar):
+                if AuthLine.validate_cookies(cookies_jar):
                     break
 
             except Exception:
                 continue
 
+        self.cb.put(("msg_dynamic", (None,), None))
         if cookies_dict is None or cookies_jar is None:
-            return None
+            return (
+                None,
+                "Failed to get Line cookies. Have you logged in the web browser?",
+            )
 
         cookies_list = ["%s=%s" % (i["name"], i["value"]) for i in cookies_dict]
         cookies = ";".join(cookies_list)
 
-        return cookies
+        return cookies, OK_MSG
 
     @staticmethod
     def validate_cookies(cookies: Union[CookieJar, Dict[str, str]]) -> bool:

sticker_convert/{utils/auth/get_signal_auth.py → auth/auth_signal.py}

@@ -5,43 +5,33 @@ import platform
 import shutil
 import time
 import webbrowser
-from typing import Callable, Optional, Tuple, cast
+from typing import Any, Optional, Tuple, cast
 
+from sticker_convert.auth.auth_base import AuthBase
 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 __init__(
-        self,
-        cb_msg: Callable[..., None] = print,
-        cb_ask_str: Callable[..., str] = input,
-    ) -> None:
+class AuthSignal(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
         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) -> None:
         download_url = "https://signal.org/en/download/"
 
         webbrowser.open(download_url)
 
-        self.cb_msg(download_url)
+        self.cb.put(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
-            )
-        else:
-            self.cb_msg(prompt)
+        self.cb.put(("ask_str", (prompt,), None))
 
     def get_signal_bin_path(self) -> Optional[str]:
         signal_paths: Tuple[Optional[str], ...]
@@ -73,11 +63,14 @@ class GetSignalAuth:
                 return signal_path
         return None
 
-    def get_cred(self) -> Tuple[Optional[str], Optional[str]]:
+    def get_cred(self) -> Tuple[Optional[str], Optional[str], str]:
+        msg = "Getting Signal credentials..."
+        self.cb.put(("msg_dynamic", (msg,), None))
         signal_bin_path = self.get_signal_bin_path()
         if signal_bin_path is None:
+            self.cb.put(("msg_dynamic", (None,), None))
             self.download_signal_desktop()
-            return None, None
+            return None, None, "Failed to get uuid and password"
 
         if platform.system() == "Windows":
             killall("signal")
@@ -132,4 +125,9 @@ class GetSignalAuth:
             time.sleep(1)
 
         crd.close()
-        return uuid, password
+        self.cb.put(("msg_dynamic", (None,), None))
+        return (
+            uuid,
+            password,
+            f"Got uuid and password successfully:\nuuid={uuid}\npassword={password}",
+        )

sticker_convert/auth/auth_telethon.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+from typing import Any, Optional, Tuple
+
+import anyio
+from telethon import TelegramClient  # type: ignore
+from telethon.errors import RPCError, SessionPasswordNeededError  # type: ignore
+
+from sticker_convert.auth.auth_base import AuthBase
+from sticker_convert.definitions import CONFIG_DIR
+
+GUIDE_MSG = """1. Visit https://my.telegram.org
+2. Login using your phone number
+3. Go to "API development tools"
+4. Fill form
+- App title: sticker-convert
+- Short name: sticker-convert
+- URL: www.telegram.org
+- Platform: Desktop
+- Description: sticker-convert
+5. Note down api_id and api_hash
+Continue when done"""
+OK_MSG = "Telethon setup successful"
+FAIL_MSG = "Telethon setup failed"
+
+
+class AuthTelethon(AuthBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    async def signin_async(
+        self, try_sign_in: bool = True
+    ) -> Tuple[bool, TelegramClient, int, str, str]:
+        client = TelegramClient(
+            CONFIG_DIR / f"telethon-{self.opt_cred.telethon_api_id}.session",
+            self.opt_cred.telethon_api_id,
+            self.opt_cred.telethon_api_hash,
+        )
+
+        await client.connect()
+        authed = await client.is_user_authorized()
+        if authed is False and try_sign_in is True:
+            error_msg = ""
+            while True:
+                msg = f"{error_msg}Enter phone number: "
+                phone_number = self.cb.put(("ask_str", (msg,), None))
+                if phone_number == "":
+                    return False, client, 0, "", FAIL_MSG
+                try:
+                    await client.send_code_request(phone_number)
+                    break
+                except RPCError as e:
+                    error_msg = f"Error: {e}\n"
+
+            error_msg = ""
+            while True:
+                msg = f"{error_msg}Enter code: "
+                code = self.cb.put(("ask_str", (msg,), None))
+                if code == "":
+                    return False, client, 0, "", FAIL_MSG
+                try:
+                    await client.sign_in(phone_number, code)
+                    break
+                except SessionPasswordNeededError:
+                    password = self.cb.put(
+                        (
+                            "ask_str",
+                            None,
+                            {"question": "Enter password: ", "password": True},
+                        )
+                    )
+                    try:
+                        await client.sign_in(password=password)
+                        break
+                    except RPCError as e:
+                        error_msg = f"Error: {e}\n"
+                except RPCError as e:
+                    error_msg = f"Error: {e}\n"
+            authed = await client.is_user_authorized()
+
+        return (
+            authed,
+            client,
+            self.opt_cred.telethon_api_id,
+            self.opt_cred.telethon_api_hash,
+            OK_MSG if authed else FAIL_MSG,
+        )
+
+    def guide(self) -> None:
+        self.cb.put(("msg_block", (GUIDE_MSG,), None))
+
+    def get_api_info(self) -> bool:
+        api_id_ask = "Enter api_id: "
+        wrong_hint = ""
+
+        while True:
+            telethon_api_id = self.cb.put(
+                (
+                    "ask_str",
+                    None,
+                    {
+                        "question": wrong_hint + api_id_ask,
+                        "initialvalue": str(self.opt_cred.telethon_api_id),
+                    },
+                )
+            )
+            if telethon_api_id == "":
+                return False
+            elif telethon_api_id.isnumeric():
+                self.opt_cred.telethon_api_id = int(telethon_api_id)
+                break
+            else:
+                wrong_hint = "Error: api_id should be numeric\n"
+
+        msg = "Enter api_hash: "
+        self.opt_cred.telethon_api_hash = self.cb.put(
+            (
+                "ask_str",
+                None,
+                {"question": msg, "initialvalue": self.opt_cred.telethon_api_hash},
+            )
+        )
+        if self.opt_cred.telethon_api_hash == "":
+            return False
+        return True
+
+    async def start_async(
+        self, check_auth_only: bool = False
+    ) -> Tuple[bool, Optional[TelegramClient], int, str, str]:
+        if self.opt_cred.telethon_api_id != 0 and self.opt_cred.telethon_api_hash != "":
+            success, client, api_id, api_hash, msg = await self.signin_async(
+                try_sign_in=False
+            )
+            if check_auth_only:
+                client.disconnect()
+            if success is True:
+                return success, client, api_id, api_hash, msg
+
+        self.guide()
+        cred_valid = self.get_api_info()
+        if cred_valid:
+            success, client, api_id, api_hash, msg = await self.signin_async()
+            if check_auth_only:
+                client.disconnect()
+            return success, client, api_id, api_hash, msg
+        else:
+            return False, None, 0, "", FAIL_MSG
+
+    def start(
+        self, check_auth_only: bool = False
+    ) -> Tuple[bool, Optional[TelegramClient], int, str, str]:
+        return anyio.run(self.start_async, check_auth_only)