migate 1.0.0__tar.gz

migate-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 offici5l
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

migate-1.0.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: migate
+Version: 1.0.0
+Summary: migate is a simplified Xiaomi authentication gateway for Python projects
+Author: offici5l
+License: MIT License
+        
+        Copyright (c) 2026 offici5l
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Repository, https://github.com/offici5l/migate
+Keywords: xiaomi,miunlock,MiUnlockTool,bootloader,unlock,MIUI,HyperOS,Tools,18n_bbs_global,unlockApi,xiaomiio,mi,auth,login,gateway,2fa,Captcha
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+# migate 
+
+**migate** is a simplified Xiaomi authentication gateway for Python projects
+
+## Installation
+```bash
+pip install migate
+```
+
+Or in pyproject.toml:
+
+```toml
+dependencies = [
+    "migate"
+]
+
+```
+
+## Usage
+
+```python
+import migate
+
+service_id = ''
+
+service_param = {"sid": service_id}
+
+# Required for some service IDs like "unlockApi"
+# service_param["checkSafeAddress"] = True
+
+pass_token = migate.get_passtoken(service_param)
+# pass_token returns: {"deviceId", "passToken", "userId"}
+
+# ___
+
+service = migate.get_service(pass_token, service_id)
+# {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+print(service)
+```
+
+returns: {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+
+___
+
+<div align="center">
+
+![MIT License](https://img.shields.io/badge/License-MIT-green.svg)
+
+</div>

migate-1.0.0/README.md

@@ -0,0 +1,49 @@
+# migate 
+
+**migate** is a simplified Xiaomi authentication gateway for Python projects
+
+## Installation
+```bash
+pip install migate
+```
+
+Or in pyproject.toml:
+
+```toml
+dependencies = [
+    "migate"
+]
+
+```
+
+## Usage
+
+```python
+import migate
+
+service_id = ''
+
+service_param = {"sid": service_id}
+
+# Required for some service IDs like "unlockApi"
+# service_param["checkSafeAddress"] = True
+
+pass_token = migate.get_passtoken(service_param)
+# pass_token returns: {"deviceId", "passToken", "userId"}
+
+# ___
+
+service = migate.get_service(pass_token, service_id)
+# {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+print(service)
+```
+
+returns: {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+
+___
+
+<div align="center">
+
+![MIT License](https://img.shields.io/badge/License-MIT-green.svg)
+
+</div>

migate-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "migate"
+version = "1.0.0"
+description = "migate is a simplified Xiaomi authentication gateway for Python projects"
+authors = [{name = "offici5l"}]
+readme = "README.md"
+license = {file = "LICENSE"}
+
+keywords = ["xiaomi", "miunlock", "MiUnlockTool", "bootloader", "unlock", "MIUI", "HyperOS", "Tools", "18n_bbs_global", "unlockApi", "xiaomiio", "mi", "auth", "login", "gateway", "2fa", "Captcha"]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent"
+]
+
+requires-python = ">=3.7"
+
+dependencies = [
+    "requests"
+]
+
+[project.urls]
+Repository = "https://github.com/offici5l/migate"
+
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

migate-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

migate-1.0.0/src/migate/__init__.py

@@ -0,0 +1,4 @@
+from .passtoken import get_passtoken
+from .service import get_service
+
+__all__ = ['get_passtoken', 'get_service']

migate-1.0.0/src/migate/config.py

@@ -0,0 +1,23 @@
+agent = "offici5l/migate"
+
+HEADERS = {
+    "User-Agent": agent,
+    "Content-Type": "application/x-www-form-urlencoded"
+}
+
+BASE_URL = "https://account.xiaomi.com"
+
+SERVICELOGIN_URL = BASE_URL + "/pass/serviceLogin"
+SERVICELOGINAUTH2_URL = SERVICELOGIN_URL + "Auth2"
+
+LIST_URL = BASE_URL + "/identity/list"
+
+SEND_EM_TICKET = BASE_URL + "/identity/auth/sendEmailTicket"
+
+SEND_PH_TICKET = BASE_URL + "/identity/auth/sendPhoneTicket"
+
+VERIFY_EM = BASE_URL + "/identity/auth/verifyEmail"
+
+VERIFY_PH = BASE_URL + "/identity/auth/verifyPhone"
+
+USERQUOTA_URL = BASE_URL + "/identity/pass/sms/userQuota"

migate-1.0.0/src/migate/login/captcha.py

@@ -0,0 +1,69 @@
+import os
+import time
+import webbrowser
+import requests
+import json
+import http.server
+import socketserver
+import threading
+from pathlib import Path
+import platform
+
+from migate.config import (
+    HEADERS,
+    BASE_URL
+)
+
+class QuietHandler(http.server.SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        pass
+
+
+def start_temp_server(directory):
+    handler = lambda *args: QuietHandler(*args, directory=directory)
+    httpd = socketserver.TCPServer(("127.0.0.1", 0), handler)
+    port = httpd.server_address[1]
+
+    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    thread.start()
+
+    return httpd, port
+
+def handle_captcha(send_url, response, cookies, payload, capt_key):
+    response_text = json.loads(response.text[11:])
+    cap_url = BASE_URL + response_text["captchaUrl"]
+    response = requests.get(cap_url, headers=HEADERS)
+    cookies.update(response.cookies.get_dict())
+    captcha_filename = f"{int(time.time())}_captcha.jpg"
+    captcha_dir = Path.home()
+    captcha_path = captcha_dir / captcha_filename
+
+    with open(captcha_path, "wb") as f:
+        f.write(response.content)
+
+    httpd, port = start_temp_server(str(captcha_dir))
+    local_url = f"http://127.0.0.1:{port}/{captcha_filename}"
+    
+    if platform.system() == "Linux":
+        os.system("xdg-open '" + local_url + "'")
+    else:
+        webbrowser.open(local_url)
+
+    print(f"check browser: {local_url}")
+    user_input = input(f"Enter Captcha: ")
+    payload[capt_key] = user_input
+
+    httpd.shutdown()
+    httpd.server_close()
+
+    response = requests.post(send_url, headers=HEADERS, data=payload, cookies=cookies)
+    
+    os.remove(captcha_path)
+
+    response_text = json.loads(response.text[11:])
+
+    if response_text.get("code") == 87001:
+        print("\nIncorrect captcha code\n")
+        return handle_captcha(send_url, response, cookies, payload, capt_key)
+
+    return response

migate-1.0.0/src/migate/login/sendcode.py

@@ -0,0 +1,48 @@
+import requests
+import json
+import time
+from pathlib import Path
+
+from migate.login.captcha import handle_captcha
+
+from migate.config import (
+    HEADERS,
+    BASE_URL,
+    SEND_EM_TICKET,
+    SEND_PH_TICKET,
+    USERQUOTA_URL
+)
+
+
+def send_verification_code(addressType, cookies):
+
+    if addressType == "EM":
+        send_url = SEND_EM_TICKET
+    else:
+        send_url = SEND_PH_TICKET
+
+    payload = {'addressType': addressType, 'contentType': "160040", '_json': "true"}
+    response = requests.post(USERQUOTA_URL, data=payload, headers=HEADERS, cookies=cookies)
+
+    response_text = json.loads(response.text[11:])
+
+    info = response_text.get('info')
+    print(f"Attempts remaining: {info}")
+    if info == "0":
+        exit(f"Sent too many codes. (to {addressType} )Try again tomorrow")
+
+    response = requests.post(send_url, headers=HEADERS, cookies=cookies)
+    response_text = json.loads(response.text[11:])
+
+    if response_text.get("code") == 87001:
+        print(f'\nCAPTCHA verification required !\n')     
+        payload = {'icode': "", '_json': "true"}
+        response = handle_captcha(send_url, response, cookies, payload, "icode")
+        response_text = json.loads(response.text[11:])
+
+    if response_text.get("code") == 0:
+        print(f"\nCode sent to {addressType}")
+    else:
+        code = response_text.get("code")
+        error = response_text.get("tips", response_text) if code == 70022 else response_text
+        exit(error)

migate-1.0.0/src/migate/login/verify.py

@@ -0,0 +1,64 @@
+import requests
+import json
+import time
+import platform
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse, parse_qs
+
+from migate.login.sendcode import send_verification_code
+
+from migate.login.verifycode import verify_code_ticket
+
+from miutility.config import (
+    HEADERS,
+    LIST_URL,
+    SERVICELOGINAUTH2_URL
+)
+
+
+def handle_verify(context, auth_data, cookies):
+    print(f'\n2FA verification required !\n')
+
+    params = {
+        'sid': auth_data["sid"],
+        'supportedMask': "0",
+        'context': context
+    }
+
+    response = requests.get(LIST_URL, params=params, headers=HEADERS, cookies=cookies)
+
+    cookies.update(response.cookies.get_dict())
+
+    result_json = json.loads(response.text[11:])
+    options = result_json.get('options', [])
+
+    if 8 in options and 4 in options:
+        choice = input(f"\nChoose verification method:\n1 = phone\n2 = email\nEnter 1 or 2: ").strip()
+        if choice not in ["1", "2"]:
+            exit("\nInvalid choice!")
+        addressType = "PH" if choice == "1" else "EM"
+    elif 4 in options:
+        addressType = "PH"
+    elif 8 in options:
+        addressType = "EM"
+    else:
+        exit(result_json)
+
+    send_verification_code(addressType, cookies)
+
+    url = verify_code_ticket(addressType, cookies)
+
+    response = requests.get(url, headers=HEADERS, allow_redirects=False, cookies=cookies)
+
+    url = response.headers.get("Location")
+
+    response = requests.get(url, headers=HEADERS, allow_redirects=False, cookies=cookies)
+
+    cookies.update(response.cookies.get_dict())
+
+    response = requests.post(SERVICELOGINAUTH2_URL, headers=HEADERS, data=auth_data, cookies=cookies)
+
+    response_text = json.loads(response.text[11:])
+
+    return response

migate-1.0.0/src/migate/login/verifycode.py

@@ -0,0 +1,29 @@
+import requests
+import json
+
+from migate.config import (
+    HEADERS,
+    VERIFY_EM,
+    VERIFY_PH
+)
+
+def verify_code_ticket(addressType, cookies):
+
+    url = VERIFY_EM if addressType == "EM" else VERIFY_PH
+    
+    ticket = input(f"Enter code: ").strip()
+    response = requests.post(url, data={"ticket": ticket, "trust": "true", '_json': "true"}, headers=HEADERS, cookies=cookies)
+
+    response_text = json.loads(response.text[11:])
+
+    if response_text.get("code") == 0:
+        url = response_text.get('location')
+        return url
+    elif response_text.get("code") == 70014:
+        #tips = response_text.get("tips")
+        print("Invalid code")
+        return verify_code_ticket(addressType, cookies)
+    else:
+        exit(response_text)
+
+

migate-1.0.0/src/migate/passtoken.py

@@ -0,0 +1,92 @@
+import requests
+import hashlib
+import json
+from urllib.parse import urlparse, parse_qs
+import json
+import uuid
+from pathlib import Path
+import pickle
+
+from migate.login.captcha import handle_captcha
+from migate.login.verify import handle_verify
+
+from miutility.config import (
+    HEADERS,
+    SERVICELOGINAUTH2_URL,
+    SERVICELOGIN_URL
+)
+
+def get_passtoken(auth_data):
+
+    sid = auth_data['sid']
+
+    cookies_file = Path.home() / f".{sid}" / "cookies.pkl"
+    if cookies_file.exists():
+        passToken = pickle.load(open(cookies_file, "rb"))
+        choice = input(
+            f"\nAlready logged in\n"
+            f"Account ID: {passToken['userId']}\n\n"
+            f"Press 'Enter' to continue\n"
+            f"(To log out, type 2 and press Enter.)"
+        ).strip().lower()
+        if choice == "2":
+            cookies_file.unlink()
+        else:
+            return passToken
+
+    auth_data["_json"] = True
+
+    response = requests.get(SERVICELOGIN_URL, params=auth_data)
+    response_text = json.loads(response.text[11:])
+
+    auth_data["serviceParam"] = response_text["serviceParam"]
+    auth_data["qs"] = response_text["qs"]
+    auth_data["callback"] = response_text["callback"]
+    auth_data["_sign"] = response_text["_sign"]
+
+    cookies = {}
+
+    while True:
+        user = input("Username: ").strip()
+        pwd = hashlib.md5(input("Password: ").strip().encode()).hexdigest().upper()
+        auth_data["user"] = user
+        auth_data["hash"] = pwd
+        deviceId = "wb_" + str(uuid.UUID(bytes=hashlib.md5((user + pwd + json.dumps(auth_data, sort_keys=True)).encode()).digest()))
+        cookies.update({'deviceId': deviceId})
+        response = requests.post(SERVICELOGINAUTH2_URL, headers=HEADERS, data=auth_data, cookies=cookies)
+        response_text = json.loads(response.text[11:])
+        if response_text.get("code") == 70016:
+            print(f"\nInvalid password! or username Please try again.\n")
+            continue
+        break
+
+    if response_text.get("code") == 87001:
+        print(f'\nCAPTCHA verification required !\n')
+        cookies = response.cookies.get_dict()
+        response = handle_captcha(SERVICELOGINAUTH2_URL, response, cookies, auth_data, "captCode")
+        response_text = json.loads(response.text[11:])
+
+    if "notificationUrl" in response_text:
+        notification_url = response_text["notificationUrl"]
+        if any(x in notification_url for x in ["callback", "SetEmail", "BindAppealOrSafePhone"]):
+            exit(notification_url)
+        context = parse_qs(urlparse(notification_url).query)["context"][0]
+        response = handle_verify(context, auth_data, cookies)
+        response_text = json.loads(response.text[11:])
+
+    cookies = response.cookies.get_dict()
+
+    required = {"deviceId", "passToken", "userId"}
+    missing = required - cookies.keys()
+    if missing:
+        return {"error": f"Missing keys: {', '.join(missing)}"}
+
+    passToken = {k: cookies[k] for k in required}
+
+    cookies_file.parent.mkdir(parents=True, exist_ok=True)
+    pickle.dump(passToken, open(cookies_file, "wb"))
+
+    print("\nLogin successful\n")
+    return passToken
+
+

migate-1.0.0/src/migate/service.py

@@ -0,0 +1,43 @@
+import requests, json, urllib.parse, os, base64, hashlib
+
+from urllib.parse import parse_qs, urlparse, quote
+
+from migate.config import (
+    HEADERS,
+    SERVICELOGIN_URL
+)
+
+def get_service(cookies, sid):
+    response = requests.get(SERVICELOGIN_URL, params={'_json': "true", 'sid': sid}, cookies=cookies, headers=HEADERS)
+
+    response_text = json.loads(response.text[11:])
+
+    nonce = response_text.get('nonce')
+    ssecurity = response_text.get('ssecurity')
+    location = response_text.get('location')
+    cUserId = response_text.get('cUserId')
+    psecurity = response_text.get('psecurity')
+
+    sign_text = f"nonce={nonce}&{ssecurity}"
+    sha1_digest = hashlib.sha1(sign_text.encode()).digest()
+    base64_sign = base64.b64encode(sha1_digest)
+    client_sign = quote(base64_sign)
+
+    url = location + f"&clientSign={client_sign}"
+    
+    response = requests.get(url, headers=HEADERS, cookies=cookies)
+
+    cookies = response.cookies.get_dict()
+
+    servicedata = {
+        'nonce': nonce,
+        'ssecurity': ssecurity,
+        'cUserId': cUserId,
+        'psecurity': psecurity,
+    }
+
+    service = {'servicedata': servicedata}
+
+    service['cookies'] = cookies
+
+    return service

migate-1.0.0/src/migate.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: migate
+Version: 1.0.0
+Summary: migate is a simplified Xiaomi authentication gateway for Python projects
+Author: offici5l
+License: MIT License
+        
+        Copyright (c) 2026 offici5l
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Repository, https://github.com/offici5l/migate
+Keywords: xiaomi,miunlock,MiUnlockTool,bootloader,unlock,MIUI,HyperOS,Tools,18n_bbs_global,unlockApi,xiaomiio,mi,auth,login,gateway,2fa,Captcha
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+# migate 
+
+**migate** is a simplified Xiaomi authentication gateway for Python projects
+
+## Installation
+```bash
+pip install migate
+```
+
+Or in pyproject.toml:
+
+```toml
+dependencies = [
+    "migate"
+]
+
+```
+
+## Usage
+
+```python
+import migate
+
+service_id = ''
+
+service_param = {"sid": service_id}
+
+# Required for some service IDs like "unlockApi"
+# service_param["checkSafeAddress"] = True
+
+pass_token = migate.get_passtoken(service_param)
+# pass_token returns: {"deviceId", "passToken", "userId"}
+
+# ___
+
+service = migate.get_service(pass_token, service_id)
+# {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+print(service)
+```
+
+returns: {'servicedata': {'nonce', 'ssecurity', 'cUserId', 'psecurity'}, 'cookies': {'serviceToken/popRunToken/new_bbs_serviceToken' ...}}
+
+___
+
+<div align="center">
+
+![MIT License](https://img.shields.io/badge/License-MIT-green.svg)
+
+</div>

migate-1.0.0/src/migate.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/migate/__init__.py
+src/migate/config.py
+src/migate/passtoken.py
+src/migate/service.py
+src/migate.egg-info/PKG-INFO
+src/migate.egg-info/SOURCES.txt
+src/migate.egg-info/dependency_links.txt
+src/migate.egg-info/requires.txt
+src/migate.egg-info/top_level.txt
+src/migate/login/captcha.py
+src/migate/login/sendcode.py
+src/migate/login/verify.py
+src/migate/login/verifycode.py

migate-1.0.0/src/migate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

migate-1.0.0/src/migate.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

migate-1.0.0/src/migate.egg-info/top_level.txt

@@ -0,0 +1 @@
+migate