miasst 1.4.0__tar.gz

miasst-1.4.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 offici5l
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

miasst-1.4.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: miasst
+Version: 1.4.0
+Summary: Cross-platform CLI for Xiaomi Mi Assistant mode: flash, wipe, reboot
+Project-URL: Repository, https://github.com/MiForge/MiAssistantTool
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyusb
+Requires-Dist: requests
+Requires-Dist: pyaes
+Requires-Dist: rsa
+Dynamic: license-file
+
+<div align="center">
+
+  <a href="https://github.com/MiForge/MiAssistantTool"><img src="https://img.shields.io/badge/MiAssistantTool-%230070FF?style=flat&logo=xiaomi&logoColor=%23FF6900" alt="MiAssistantTool" style="width: 200px; vertical-align: middle;" /></a><br>
+
+  Windows, macOS, Linux, and Termux.
+
+  [![Version](https://img.shields.io/pypi/v/miasst?label=Version&labelColor=black&color=brightgreen)](https://pypi.org/project/miasst/)
+  [![Changelog](https://img.shields.io/badge/Changelog-blue?style=flat)](CHANGELOG.md)
+  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+  ___
+
+</div>
+
+In Mi Assistant mode, without unlocking the bootloader:
+
+- Read Info
+- Flash Official Recovery ROM
+- ROMs that can be flashed
+- Format Data / Cache / Storage / Data + Storage / FRP
+- Wipe Data Storage / EFS
+- Reboot / Reboot to recovery / fastboot / bootloader
+- Shutdown
+
+___
+
+### Dependencies
+
+* Linux: `sudo apt install libusb-1.0-0`
+* macOS: `brew install libusb`
+* Termux: `pkg install libusb`
+* Windows: No extra steps required (uses standard USB drivers).
+
+### Install
+
+```bash
+pip install miasst
+```
+
+### Usage
+
+```bash
+miasst
+```
+
+## Notes
+
+On Termux (without root) you'll need the [Termux:API](https://github.com/termux/termux-api/releases/latest) app, and `pkg install termux-api`.
+
+### Quick Installation (for Termux):
+
+```sh
+curl -sS https://raw.githubusercontent.com/MiForge/MiAssistantTool/main/install.sh | bash
+```

miasst-1.4.0/README.md

@@ -0,0 +1,53 @@
+<div align="center">
+
+  <a href="https://github.com/MiForge/MiAssistantTool"><img src="https://img.shields.io/badge/MiAssistantTool-%230070FF?style=flat&logo=xiaomi&logoColor=%23FF6900" alt="MiAssistantTool" style="width: 200px; vertical-align: middle;" /></a><br>
+
+  Windows, macOS, Linux, and Termux.
+
+  [![Version](https://img.shields.io/pypi/v/miasst?label=Version&labelColor=black&color=brightgreen)](https://pypi.org/project/miasst/)
+  [![Changelog](https://img.shields.io/badge/Changelog-blue?style=flat)](CHANGELOG.md)
+  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+  ___
+
+</div>
+
+In Mi Assistant mode, without unlocking the bootloader:
+
+- Read Info
+- Flash Official Recovery ROM
+- ROMs that can be flashed
+- Format Data / Cache / Storage / Data + Storage / FRP
+- Wipe Data Storage / EFS
+- Reboot / Reboot to recovery / fastboot / bootloader
+- Shutdown
+
+___
+
+### Dependencies
+
+* Linux: `sudo apt install libusb-1.0-0`
+* macOS: `brew install libusb`
+* Termux: `pkg install libusb`
+* Windows: No extra steps required (uses standard USB drivers).
+
+### Install
+
+```bash
+pip install miasst
+```
+
+### Usage
+
+```bash
+miasst
+```
+
+## Notes
+
+On Termux (without root) you'll need the [Termux:API](https://github.com/termux/termux-api/releases/latest) app, and `pkg install termux-api`.
+
+### Quick Installation (for Termux):
+
+```sh
+curl -sS https://raw.githubusercontent.com/MiForge/MiAssistantTool/main/install.sh | bash
+```

miasst-1.4.0/miassistant/cli.py

@@ -0,0 +1,61 @@
+import json
+import os
+import subprocess
+import sys
+import time
+
+from miassistant import core
+
+def prompt_choice():
+    for n, (label, _) in core.ACTION_HANDLERS.items():
+        print(f"  {n} > {label}")
+    print()
+
+    while True:
+        raw = input("Choice: ").strip()
+        if not raw.isdigit() or int(raw) not in core.ACTION_HANDLERS:
+            print("Invalid choice, try again.")
+            continue
+        return int(raw)
+
+
+def _relaunch_via_termux_usb(choice):
+    subprocess.run(["pkill", "-9", "-f", "tcp"])
+
+    while True:
+        result = subprocess.run(["termux-usb", "-l"], capture_output=True, text=True)
+        try:
+            devices = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            devices = []
+        if devices:
+            device = devices[0]
+            result = subprocess.run(["termux-usb", "-r", device], capture_output=True, text=True)
+            if "granted" in result.stdout.lower():
+                break
+            print("\nUSB permission not granted. Please allow access when prompted.")
+        else:
+            for i in range(4):
+                print(f"\rNo USB devices connected {'.' * (i % 4)}", end="")
+                time.sleep(0.5)
+
+    env = os.environ.copy()
+    env["MIASSISTANT_CHOICE"] = str(choice)
+    subprocess.run(["termux-usb", "-E", "-e", "miasst", device], env=env)
+    sys.exit()
+
+
+def main():
+    preset_choice = os.environ.get("MIASSISTANT_CHOICE")
+    choice = int(preset_choice) if preset_choice else prompt_choice()
+
+    if core.is_nonroot_termux() and "TERMUX_USB_FD" not in os.environ:
+        _relaunch_via_termux_usb(choice)
+        return
+
+    _, handler = core.ACTION_HANDLERS[choice]
+    handler()
+
+
+if __name__ == "__main__":
+    main()

miasst-1.4.0/miassistant/core.py

@@ -0,0 +1,605 @@
+import ctypes
+import json
+import base64
+import re
+import urllib.parse
+import requests
+import usb.core
+import usb.util
+import usb.backend.libusb1
+import struct
+import os
+import hashlib
+import pyaes
+from rsa import PublicKey
+
+B_INTERFACE_CLASS = 0xFF
+B_INTERFACE_SUBCLASS = 0x42
+B_INTERFACE_PROTOCOL = 0x1
+
+ADB_CNXN = int.from_bytes(b"CNXN", "little")
+ADB_OPEN = int.from_bytes(b"OPEN", "little")
+ADB_OKAY = int.from_bytes(b"OKAY", "little")
+ADB_WRTE = int.from_bytes(b"WRTE", "little")
+ADB_VERSION = 0x01000001
+ADB_MAX_DATA = 1024 * 1024
+ADB_SIDELOAD_CHUNK_SIZE = 1024 * 64
+LIBUSB_OPTION_NO_DEVICE_DISCOVERY = 2
+USB_TIMEOUT_MS = 3000
+
+
+class EPDesc(ctypes.Structure):
+    _fields_ = [
+        ("bLength", ctypes.c_uint8), ("bDescriptorType", ctypes.c_uint8),
+        ("bEndpointAddress", ctypes.c_uint8), ("bmAttributes", ctypes.c_uint8),
+        ("wMaxPacketSize", ctypes.c_uint16), ("bInterval", ctypes.c_uint8),
+        ("bRefresh", ctypes.c_uint8), ("bSynchAddress", ctypes.c_uint8),
+        ("extra", ctypes.c_void_p), ("extra_length", ctypes.c_int),
+    ]
+
+
+class IntfDesc(ctypes.Structure):
+    _fields_ = [
+        ("bLength", ctypes.c_uint8), ("bDescriptorType", ctypes.c_uint8),
+        ("bInterfaceNumber", ctypes.c_uint8), ("bAlternateSetting", ctypes.c_uint8),
+        ("bNumEndpoints", ctypes.c_uint8), ("bInterfaceClass", ctypes.c_uint8),
+        ("bInterfaceSubClass", ctypes.c_uint8), ("bInterfaceProtocol", ctypes.c_uint8),
+        ("iInterface", ctypes.c_uint8), ("endpoint", ctypes.POINTER(EPDesc)),
+        ("extra", ctypes.c_void_p), ("extra_length", ctypes.c_int),
+    ]
+
+
+class Intf(ctypes.Structure):
+    _fields_ = [("altsetting", ctypes.POINTER(IntfDesc)), ("num_altsetting", ctypes.c_int)]
+
+
+class ConfigDesc(ctypes.Structure):
+    _fields_ = [
+        ("bLength", ctypes.c_uint8), ("bDescriptorType", ctypes.c_uint8),
+        ("wTotalLength", ctypes.c_uint16), ("bNumInterfaces", ctypes.c_uint8),
+        ("bConfigurationValue", ctypes.c_uint8), ("iConfiguration", ctypes.c_uint8),
+        ("bmAttributes", ctypes.c_uint8), ("MaxPower", ctypes.c_uint8),
+        ("interface", ctypes.POINTER(Intf)),
+        ("extra", ctypes.c_void_p), ("extra_length", ctypes.c_int),
+    ]
+
+
+def is_nonroot_termux():
+    return (
+        bool(os.environ.get("PREFIX"))
+        and os.path.exists("/data/data/com.termux")
+        and hasattr(os, "geteuid")
+        and os.geteuid() != 0
+    )
+
+
+def find_adb_endpoints_raw(lib, dev):
+    lib.libusb_get_active_config_descriptor.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(ConfigDesc))]
+    lib.libusb_get_active_config_descriptor.restype = ctypes.c_int
+    cfg = ctypes.POINTER(ConfigDesc)()
+    if lib.libusb_get_active_config_descriptor(dev, ctypes.byref(cfg)) != 0:
+        return None, None
+    for i in range(cfg.contents.bNumInterfaces):
+        intf = cfg.contents.interface[i]
+        if intf.num_altsetting == 0:
+            continue
+        alt = intf.altsetting[0]
+        if (alt.bInterfaceClass, alt.bInterfaceSubClass, alt.bInterfaceProtocol) != (
+            B_INTERFACE_CLASS, B_INTERFACE_SUBCLASS, B_INTERFACE_PROTOCOL
+        ):
+            continue
+        ep_out = ep_in = None
+        for e in range(alt.bNumEndpoints):
+            ep = alt.endpoint[e]
+            if ep.bmAttributes & 0x03 != 0x02:
+                continue
+            if ep.bEndpointAddress & 0x80:
+                ep_in = ep.bEndpointAddress
+            else:
+                ep_out = ep.bEndpointAddress
+        if ep_out is not None and ep_in is not None:
+            return ep_out, ep_in
+    return None, None
+
+
+def connect_termux_nonroot():
+    fd = os.environ.get("TERMUX_USB_FD")
+    if fd is None:
+        exit("\n\nWithout root (termux-usb must be used)\n\n")
+    fd = int(fd)
+
+    m = usb.backend.libusb1
+    lib_path = f"{os.environ.get('PREFIX', '')}/lib/libusb-1.0.so"
+    lib = m._load_library(find_library=lambda _: lib_path)
+    m._setup_prototypes(lib)
+
+    lib.libusb_set_option.argtypes = [ctypes.c_void_p, ctypes.c_int]
+    lib.libusb_set_option.restype = ctypes.c_int
+    lib.libusb_set_option(None, LIBUSB_OPTION_NO_DEVICE_DISCOVERY)
+
+    backend = m._LibUSB(lib)
+    ctx = backend.ctx
+
+    lib.libusb_wrap_sys_device.argtypes = [ctypes.c_void_p, ctypes.c_longlong, ctypes.POINTER(ctypes.c_void_p)]
+    lib.libusb_wrap_sys_device.restype = ctypes.c_int
+    handle = ctypes.c_void_p()
+    if lib.libusb_wrap_sys_device(ctx, fd, ctypes.byref(handle)) != 0 or not handle.value:
+        exit("\n\ndevice is not connected, or not in mi assistant mode\n\n")
+
+    lib.libusb_get_device.argtypes = [ctypes.c_void_p]
+    lib.libusb_get_device.restype = ctypes.c_void_p
+    dev = lib.libusb_get_device(handle)
+
+    ep_out, ep_in = find_adb_endpoints_raw(lib, dev)
+    if ep_out is None:
+        exit("\n\ndevice is not connected, or not in mi assistant mode\n\n")
+
+    lib.libusb_claim_interface.argtypes = [ctypes.c_void_p, ctypes.c_int]
+    lib.libusb_claim_interface.restype = ctypes.c_int
+    lib.libusb_claim_interface(handle, 0)
+
+    lib.libusb_bulk_transfer.argtypes = [
+        ctypes.c_void_p, ctypes.c_ubyte, ctypes.c_char_p,
+        ctypes.c_int, ctypes.POINTER(ctypes.c_int), ctypes.c_uint,
+    ]
+    lib.libusb_bulk_transfer.restype = ctypes.c_int
+
+    return {"kind": "raw", "lib": lib, "handle": handle, "ep_out": ep_out, "ep_in": ep_in, "backend": backend}
+
+
+def connect_normal():
+    try:
+        dev_list = list(usb.core.find(find_all=True))
+    except usb.core.USBError:
+        return None
+
+    for dev in dev_list:
+        for cfg in dev:
+            for intf in cfg:
+                if (intf.bInterfaceClass, intf.bInterfaceSubClass, intf.bInterfaceProtocol) != (
+                    B_INTERFACE_CLASS, B_INTERFACE_SUBCLASS, B_INTERFACE_PROTOCOL
+                ):
+                    continue
+                out_ep = usb.util.find_descriptor(
+                    intf, custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT
+                )
+                in_ep = usb.util.find_descriptor(
+                    intf, custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN
+                )
+                if not out_ep or not in_ep:
+                    continue
+                try:
+                    if dev.is_kernel_driver_active(intf.bInterfaceNumber):
+                        dev.detach_kernel_driver(intf.bInterfaceNumber)
+                except (NotImplementedError, usb.core.USBError):
+                    pass
+                dev.set_configuration(cfg.bConfigurationValue)
+                usb.util.claim_interface(dev, intf.bInterfaceNumber)
+                return {"kind": "pyusb", "out_ep": out_ep, "in_ep": in_ep}
+    return None
+
+
+def connect():
+    transport = connect_termux_nonroot() if is_nonroot_termux() else connect_normal()
+    if not transport:
+        exit("\n\ndevice is not connected, or not in mi assistant mode\n\n")
+    return transport
+
+
+class DeviceWriteError(Exception):
+    pass
+
+
+def usb_write(transport, data):
+    if transport["kind"] == "pyusb":
+        try:
+            transport["out_ep"].write(data, timeout=USB_TIMEOUT_MS)
+        except usb.core.USBError as e:
+            raise DeviceWriteError(str(e))
+    else:
+        buf = ctypes.create_string_buffer(data, len(data))
+        n = ctypes.c_int(0)
+        r = transport["lib"].libusb_bulk_transfer(
+            transport["handle"], transport["ep_out"], buf, len(data), ctypes.byref(n), USB_TIMEOUT_MS
+        )
+        if r != 0:
+            raise DeviceWriteError(f"libusb_bulk_transfer write failed (code {r})")
+
+
+def usb_read(transport, size):
+    if transport["kind"] == "pyusb":
+        try:
+            return bytes(transport["in_ep"].read(size, timeout=USB_TIMEOUT_MS))
+        except usb.core.USBError:
+            return b""
+    buf = ctypes.create_string_buffer(size)
+    n = ctypes.c_int(0)
+    r = transport["lib"].libusb_bulk_transfer(
+        transport["handle"], transport["ep_in"], buf, size, ctypes.byref(n), USB_TIMEOUT_MS
+    )
+    return buf.raw[: n.value] if r == 0 else b""
+
+
+def send_packet(transport, cmd, arg0, arg1, data=b""):
+    header = struct.pack("<6I", cmd, arg0, arg1, len(data), 0, cmd ^ 0xFFFFFFFF)
+    usb_write(transport, header)
+    if data:
+        usb_write(transport, data)
+
+
+class DeviceTimeout(Exception):
+    pass
+
+
+def read_packet(transport):
+    header = usb_read(transport, 24)
+    if len(header) < 24:
+        raise DeviceTimeout()
+    cmd, arg0, arg1, length, checksum, magic = struct.unpack("<6I", header)
+    data = usb_read(transport, length) if length else b""
+    return cmd, arg0, arg1, data
+
+
+def adb_connect(transport):
+    send_packet(transport, ADB_CNXN, ADB_VERSION, ADB_MAX_DATA, b"host::\x00")
+    _, _, _, data = read_packet(transport)
+    if not data.startswith(b"sideload::"):
+        exit("device not connected, or not in Mi Assistant mode")
+
+
+def adb_cmd(transport, command):
+    send_packet(transport, ADB_OPEN, 1, 0, command.encode())
+    read_packet(transport)
+    _, _, _, resp = read_packet(transport)
+    read_packet(transport)
+    text = resp.decode(errors="ignore")
+    return text[:-1] if text.endswith("\n") else text
+
+
+def start_sideload(transport, file_path, validate):
+    file_size = os.path.getsize(file_path)
+    send_packet(transport, ADB_OPEN, 1, 0, f"sideload-host:{file_size}:{ADB_SIDELOAD_CHUNK_SIZE}:{validate}:0".encode())
+
+    total_sent = 0
+    final_message = ""
+
+    with open(file_path, "rb") as f:
+        while True:
+            try:
+                cmd, arg0, arg1, data = read_packet(transport)
+            except (DeviceTimeout, DeviceWriteError):
+                continue
+
+            if len(data) > 8:
+                final_message = data.decode(errors="ignore")
+                break
+
+            if cmd == ADB_OKAY:
+                send_packet(transport, ADB_OKAY, arg1, arg0)
+
+            if cmd != ADB_WRTE:
+                continue
+
+            m = re.match(r"\d+", data.decode(errors="ignore"))
+            block = int(m.group()) if m else 0
+            offset = block * ADB_SIDELOAD_CHUNK_SIZE
+            if offset > file_size:
+                break
+            to_write = min(ADB_SIDELOAD_CHUNK_SIZE, file_size - offset)
+            f.seek(offset)
+            chunk = f.read(to_write)
+
+            try:
+                send_packet(transport, ADB_WRTE, arg1, arg0, chunk)
+                send_packet(transport, ADB_OKAY, arg1, arg0)
+            except DeviceWriteError:
+                continue
+            total_sent += to_write
+
+            pct = min(100, int(total_sent * 100 / file_size))
+            print(f"\rFlashing in progress ... {pct}/100%", end="", flush=True)
+
+    print(f"\n\n{final_message}\n")
+    return final_message
+
+
+_transport = None
+_connected = False
+_info = None
+
+
+def get_transport():
+    global _transport, _connected
+    if _transport is None:
+        _transport = connect()
+    if not _connected:
+        try:
+            adb_connect(_transport)
+        except DeviceTimeout:
+            exit("\n\nError: device did not respond in time. Make sure the screen is on and it is in Mi Assistant mode.\n\n")
+        _connected = True
+    return _transport
+
+
+def get_info():
+    global _info
+    if _info is None:
+        transport = get_transport()
+        try:
+            _info = {
+                "sn": adb_cmd(transport, "getsn:"),
+                "region": adb_cmd(transport, "getregion:"),
+                "device": adb_cmd(transport, "getdevice:"),
+                "branch": adb_cmd(transport, "getbranch:"),
+                "version": adb_cmd(transport, "getversion:"),
+                "romzone": adb_cmd(transport, "getromzone:"),
+                "language": adb_cmd(transport, "getlanguage:"),
+                "codebase": adb_cmd(transport, "getcodebase:"),
+                "carrier": adb_cmd(transport, "getcarrier:"),
+                "mitoken": adb_cmd(transport, "getmitoken:"),
+                "recoveryversion": adb_cmd(transport, "getrecoveryversion:"),
+            }
+        except DeviceTimeout:
+            exit("\n\nError: device did not respond in time. Make sure the screen is on and it is in Mi Assistant mode.\n\n")
+    return _info
+
+
+
+def read_info():
+    info = get_info()
+    print(f"\nDevice: {info['device']}")
+    print(f"Version: {info['version']}")
+    print(f"Serial Number: {info['sn']}")
+    print(f"Codebase: {info['codebase']}")
+    print(f"Branch: {info['branch']}")
+    print(f"Language: {info['language']}")
+    print(f"Region: {info['region']}")
+    print(f"ROM Zone: {info['romzone']}\n")
+    print(f"Mi Token: {info['mitoken']}")
+    print(f"Carrier: {info['carrier']}")
+    print(f"Recovery Version: {info['recoveryversion']}")
+
+
+BLOCK_SIZE = 16
+
+def _pkcs7_pad(data):
+    p = BLOCK_SIZE - len(data) % BLOCK_SIZE
+    return data + bytes([p]) * p
+
+def _pkcs7_unpad(data):
+    return data[:-data[-1]]
+
+def _aes_cbc_encrypt(key, iv, data):
+    mode = pyaes.AESModeOfOperationCBC(key, iv=iv)
+    return b''.join(mode.encrypt(data[i:i+BLOCK_SIZE]) for i in range(0, len(data), BLOCK_SIZE))
+
+def _aes_cbc_decrypt(key, iv, data):
+    mode = pyaes.AESModeOfOperationCBC(key, iv=iv)
+    return b''.join(mode.decrypt(data[i:i+BLOCK_SIZE]) for i in range(0, len(data), BLOCK_SIZE))
+
+def _validate_request(info, md5):
+    key = b"miuiotavalided11"
+    iv = b"0102030405060708"
+
+    payload = {
+        "d": info["device"], "v": info["version"], "c": info["codebase"], "b": info["branch"],
+        "sn": info["sn"], "l": "en-US", "f": "1",
+        "options": {"zone": int(info["romzone"])},
+        "pkg": md5,
+    }
+    body = _pkcs7_pad(json.dumps(payload).encode())
+    enc = _aes_cbc_encrypt(key, iv, body)
+    q = urllib.parse.quote(base64.b64encode(enc).decode())
+
+    resp = requests.post(
+        "http://update.miui.com/updates/miotaV3.php",
+        data=f"q={q}&t=&s=1",
+        headers={"User-Agent": "MiTunes_UserAgent_v3.0", "Content-Type": "application/x-www-form-urlencoded"},
+    )
+    dec = _aes_cbc_decrypt(key, iv, base64.b64decode(resp.text.strip()))
+    result = json.loads(_pkcs7_unpad(dec).decode("utf-8", errors="ignore"))
+    return result
+
+def validate_decrypt(validate):
+    PUBLIC_KEY_PEM = b"""-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs3X/eMU56OEc5buvfnXe
+D+9X4xKsImY7Q3Y+FY/xcdRIIvypKPjqxgqV548+Vf/H2VHeUXsMgiaeAqbmNAwP
+BU0He0p0YlUEOZ9Bkn6dKniuEe9G7PeL3tx6qjnf+Y5actf7IwJBTGJefa7wt+OZ
+4pNCBfgPHkTW+3VGlioP8rHbnLyZ98BdNxrvcLqJHCTblwomhVR64syqP1/eVOqE
+BKeHT+IkTXFZAzEVGha0FyKgBwcET/851zW93FiiC1HYpubLSiK1crbtDVK2ho4z
+NWzHCPfAfKQQn1VqXthiwxTZ25i4FYbuySwZ7xfXhqJwcLKuxN9uRCHBG8KV9V5T
+7wIDAQAB
+-----END PUBLIC KEY-----"""
+
+    key = PublicKey.load_pkcs1_openssl_pem(PUBLIC_KEY_PEM)
+    encrypted_bytes = base64.b64decode(validate)
+    c = int.from_bytes(encrypted_bytes, 'big')
+    m = pow(c, key.e, key.n)
+    key_size_bytes = (key.n.bit_length() + 7) // 8
+    decrypted_padded_bytes = m.to_bytes(key_size_bytes, 'big')
+    if decrypted_padded_bytes[0:2] != b'\x00\x01':
+        raise ValueError("Error: Invalid padding (not PKCS#1 Type 1).")
+    separator_index = decrypted_padded_bytes.find(b'\x00', 2)
+    if separator_index == -1:
+        raise ValueError("Error: Padding separator (0x00) not found.")
+    payload_bytes = decrypted_padded_bytes[separator_index + 1:]
+    result = json.loads(payload_bytes.decode('utf-8').replace('}{', ','))
+    return result
+
+
+def file_info():
+
+    while True:
+        file_path = input("Enter .zip file path: ")
+        if os.path.isfile(file_path) and file_path.lower().endswith(".zip"):
+            break
+        print("Invalid path or file is not a .zip. Try again.")
+
+    md5_hash = hashlib.md5()
+    sha1_hash = hashlib.sha1()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            md5_hash.update(chunk)
+            sha1_hash.update(chunk)
+    md5_hex = md5_hash.hexdigest()
+    sha1_hex = sha1_hash.hexdigest()
+
+    return file_path, md5_hex, sha1_hex
+
+
+def extract_validate(data):
+    result = {}
+    seen = set()
+    def walk(obj, parent=None):
+        if isinstance(obj, dict):
+            if 'Validate' in obj and parent:
+                md5 = obj.get('md5')
+                if md5 not in seen:
+                    seen.add(md5)
+                    result[parent] = {'md5': obj.get('md5'), 'Validate': obj['Validate']}
+            for k, v in obj.items():
+                walk(v, k)
+        elif isinstance(obj, list):
+            for item in obj:
+                walk(item, parent)
+    walk(data)
+    return result
+
+def flash_rom():
+    path, md5, sha1 = file_info()
+
+    info = get_info()
+    transport = get_transport()
+    r = _validate_request(info, md5)
+
+    if "PkgRom" in r and "Validate" in r["PkgRom"]:
+        validate = r["PkgRom"]["Validate"]
+        decrypted = validate_decrypt(validate)
+        if decrypted.get("SHA1") != sha1:
+            print("SHA1 mismatch between local file and server response.")
+            return
+        if r["PkgRom"]["Erase"] == 1:
+            input("NOTICE: Data will be erased during flashing.\nPress Enter to continue...")
+        start_sideload(transport, path, validate)
+    else:
+        r2 = _validate_request(info, "")
+        checkv = extract_validate(r2)
+        for key, v in checkv.items():
+            decrypted = validate_decrypt(v['Validate'])
+            if decrypted.get("SHA1") == sha1:
+                if v['md5'] != md5:
+                    r3 = _validate_request(info, v['md5'])
+                    if "PkgRom" in r3 and "Validate" in r3["PkgRom"]:
+                        print("MD5 mismatch between local file and server response.")
+                        validate3 = r3["PkgRom"]["Validate"]
+                        start_sideload(transport, path, validate3)
+                break
+        else:
+            valid = []
+            for key, v in checkv.items():
+                r4 = _validate_request(info, v['md5'])
+                if "PkgRom" in r4 and "Validate" in r4["PkgRom"]:
+                    pkg = r4["PkgRom"]
+                    link = f"https://bigota.d.miui.com/{pkg['version']}/{pkg['filename']}"
+                    valid.append((pkg['md5'], link))
+            if valid:
+                print("\nROMs that can be flashed on this device:")
+                for md5v, link in valid:
+                    print(f"\nmd5: {md5v}\ndownload_url: {link}\n")
+            else:
+                print("\nNo ROM can be installed on this device !.")
+
+
+def check_rom():
+    info = get_info()
+    r2 = _validate_request(info, "")
+    checkv = extract_validate(r2)
+    valid = []
+    for key, v in checkv.items():
+        r4 = _validate_request(info, v['md5'])
+        if "PkgRom" in r4 and "Validate" in r4["PkgRom"]:
+            pkg = r4["PkgRom"]
+            link = f"https://bigota.d.miui.com/{pkg['version']}/{pkg['filename']}"
+            valid.append((pkg['md5'], link))
+    if valid:
+        print("\nROMs that can be flashed on this device:")
+        for md5v, link in valid:
+            print(f"\nmd5: {md5v}\ndownload_url: {link}\n")
+    else:
+            print("\nNo ROM can be installed on this device !.")
+
+
+def send_simple(command):
+    transport = get_transport()
+    print(adb_cmd(transport, command))
+
+def format_data():
+    send_simple("format-data:")
+
+def format_cache():
+    send_simple("format-cache:")
+
+def format_storage():
+    send_simple("format-storage:")
+
+def format_data_storage():
+    send_simple("format-data-storage:")
+
+def format_frp():
+    send_simple("format-frp:")
+
+def wipe_data_storage():
+    send_simple("wipe-data-storage:")
+
+def wipe_efs():
+    print("\n⚠️ [WARNING]: If you are a normal user and don't know what this means, DO NOT use this command!")
+    print("Wiping EFS will permanently break your phone's network and delete your IMEI.")
+    confirm = input("Type 'YES' only if you are an expert and know exactly what you are doing: ")  
+    if confirm == "YES":
+        print("Wiping EFS partition...")
+        send_simple("wipe-efs:")
+    else:
+        print("Operation cancelled.")
+
+
+def send_disconnecting(command, verb):
+    transport = get_transport()
+    try:
+        print(adb_cmd(transport, command))
+    except DeviceTimeout:
+        print(f"Device is {verb} (connection closed as expected).")
+
+
+def reboot():
+    send_disconnecting("reboot:", "rebooting")
+
+def reboot_recovery():
+    send_disconnecting("recovery:", "rebooting to recovery")
+
+def reboot_fastboot():
+    send_disconnecting("fastboot:", "rebooting to fastboot")
+
+def reboot_bootloader():
+    send_disconnecting("bootloader:", "rebooting to bootloader")
+
+
+def shutdown():
+    send_disconnecting("shutdown:", "shutting down")
+
+ACTION_HANDLERS = {
+    1: ("Read Info", read_info),
+    2: ("Flash Official Recovery ROM", flash_rom),
+    3: ("ROMs That Can Be Flashed", check_rom),
+    4: ("Format Data", format_data),
+    5: ("Format Cache", format_cache),
+    6: ("Format Storage", format_storage),
+    7: ("Format Data + Storage", format_data_storage),
+    8: ("Format FRP", format_frp),
+    9: ("Wipe Data Storage", wipe_data_storage),
+    10: ("Wipe EFS", wipe_efs),
+    11: ("Reboot", reboot),
+    12: ("Reboot to recovery", reboot_recovery),
+    13: ("Reboot to fastboot", reboot_fastboot),
+    14: ("Reboot to bootloader", reboot_bootloader),
+    15: ("Shutdown", shutdown),
+}

miasst-1.4.0/miasst.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: miasst
+Version: 1.4.0
+Summary: Cross-platform CLI for Xiaomi Mi Assistant mode: flash, wipe, reboot
+Project-URL: Repository, https://github.com/MiForge/MiAssistantTool
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyusb
+Requires-Dist: requests
+Requires-Dist: pyaes
+Requires-Dist: rsa
+Dynamic: license-file
+
+<div align="center">
+
+  <a href="https://github.com/MiForge/MiAssistantTool"><img src="https://img.shields.io/badge/MiAssistantTool-%230070FF?style=flat&logo=xiaomi&logoColor=%23FF6900" alt="MiAssistantTool" style="width: 200px; vertical-align: middle;" /></a><br>
+
+  Windows, macOS, Linux, and Termux.
+
+  [![Version](https://img.shields.io/pypi/v/miasst?label=Version&labelColor=black&color=brightgreen)](https://pypi.org/project/miasst/)
+  [![Changelog](https://img.shields.io/badge/Changelog-blue?style=flat)](CHANGELOG.md)
+  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+  ___
+
+</div>
+
+In Mi Assistant mode, without unlocking the bootloader:
+
+- Read Info
+- Flash Official Recovery ROM
+- ROMs that can be flashed
+- Format Data / Cache / Storage / Data + Storage / FRP
+- Wipe Data Storage / EFS
+- Reboot / Reboot to recovery / fastboot / bootloader
+- Shutdown
+
+___
+
+### Dependencies
+
+* Linux: `sudo apt install libusb-1.0-0`
+* macOS: `brew install libusb`
+* Termux: `pkg install libusb`
+* Windows: No extra steps required (uses standard USB drivers).
+
+### Install
+
+```bash
+pip install miasst
+```
+
+### Usage
+
+```bash
+miasst
+```
+
+## Notes
+
+On Termux (without root) you'll need the [Termux:API](https://github.com/termux/termux-api/releases/latest) app, and `pkg install termux-api`.
+
+### Quick Installation (for Termux):
+
+```sh
+curl -sS https://raw.githubusercontent.com/MiForge/MiAssistantTool/main/install.sh | bash
+```

miasst-1.4.0/miasst.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+miassistant/__init__.py
+miassistant/cli.py
+miassistant/core.py
+miasst.egg-info/PKG-INFO
+miasst.egg-info/SOURCES.txt
+miasst.egg-info/dependency_links.txt
+miasst.egg-info/entry_points.txt
+miasst.egg-info/requires.txt
+miasst.egg-info/top_level.txt

miasst-1.4.0/miasst.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

miasst-1.4.0/miasst.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+miasst = miassistant.cli:main

miasst-1.4.0/miasst.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pyusb
+requests
+pyaes
+rsa

miasst-1.4.0/miasst.egg-info/top_level.txt

@@ -0,0 +1 @@
+miassistant

miasst-1.4.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "miasst"
+version = "1.4.0"
+description = "Cross-platform CLI for Xiaomi Mi Assistant mode: flash, wipe, reboot"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "pyusb",
+    "requests",
+    "pyaes",
+    "rsa",
+]
+
+[project.urls]
+Repository = "https://github.com/MiForge/MiAssistantTool"
+
+[project.scripts]
+miasst = "miassistant.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["miassistant*"]

miasst-1.4.0/setup.cfg

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