pymobiledevice3 4.27.5__py3-none-any.whl → 4.27.6__py3-none-any.whl

pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.27.5'
-__version_tuple__ = version_tuple = (4, 27, 5)
+__version__ = version = '4.27.6'
+__version_tuple__ = version_tuple = (4, 27, 6)
 
 __commit_id__ = commit_id = None

pymobiledevice3/restore/mbn.py

@@ -0,0 +1,606 @@
+# mbn.py
+# Support for Qualcomm MBN (Modem Binary) formats — Python port
+# Mirrors the logic of mbn.c (v1/v2/BIN headers, ELF detection, and v7 stitching)
+#
+# Copyright (c) 2012 Martin Szulecki
+# Copyright (c) 2012 Nikias Bassen
+# Copyright (c) 2025 Visual Ehrmanntraut <visual@chefkiss.dev>
+#
+# Ported to Python by DoronZ <doron88@gmail.com>. Licensed under LGPL-2.1-or-later (same as original).
+
+import io
+import logging
+from typing import Optional
+
+from construct import Bytes, ChecksumError, Int16ul, Int32ul, Int64ul, Struct
+
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+MBN_V1_MAGIC = b"\x0a\x00\x00\x00"
+MBN_V1_MAGIC_SIZE = 4
+
+MBN_V2_MAGIC = b"\xd1\xdc\x4b\x84\x34\x10\xd7\x73"
+MBN_V2_MAGIC_SIZE = 8
+
+MBN_BIN_MAGIC = b"\x04\x00\xea\x6c\x69\x48\x55"
+MBN_BIN_MAGIC_SIZE = 7
+MBN_BIN_MAGIC_OFFSET = 1
+
+# ELF
+EI_MAG0, EI_MAG1, EI_MAG2, EI_MAG3, EI_CLASS = 0, 1, 2, 3, 4
+EI_NIDENT = 16
+ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 = 0x7F, ord("E"), ord("L"), ord("F")
+ELFCLASSNONE, ELFCLASS32, ELFCLASS64 = 0, 1, 2
+
+# -----------------------------------------------------------------------------
+# Construct Structs (little-endian)
+# -----------------------------------------------------------------------------
+
+# MBN v1
+MBN_V1 = Struct(
+    "type" / Int32ul,
+    "unk_0x04" / Int32ul,
+    "unk_0x08" / Int32ul,
+    "unk_0x0c" / Int32ul,
+    "data_size" / Int32ul,  # total - sizeof(header)
+    "sig_offset" / Int32ul,  # real offset = enc_sig_offset & 0xFFFFFF00 (FYI)
+    "unk_0x18" / Int32ul,
+    "unk_0x1c" / Int32ul,
+    "unk_0x20" / Int32ul,
+    "unk_0x24" / Int32ul,
+)
+
+# MBN v2
+MBN_V2 = Struct(
+    "magic1" / Bytes(8),
+    "unk_0x08" / Int32ul,
+    "unk_0x0c" / Int32ul,  # 0xFFFFFFFF
+    "unk_0x10" / Int32ul,  # 0xFFFFFFFF
+    "header_size" / Int32ul,
+    "unk_0x18" / Int32ul,
+    "data_size" / Int32ul,  # total - sizeof(header)
+    "sig_offset" / Int32ul,
+    "unk_0x24" / Int32ul,
+    "unk_0x28" / Int32ul,
+    "unk_0x2c" / Int32ul,
+    "unk_0x30" / Int32ul,
+    "unk_0x34" / Int32ul,  # 0x1
+    "unk_0x38" / Int32ul,  # 0x1
+    "unk_0x3c" / Int32ul,  # 0xFFFFFFFF
+    "unk_0x40" / Int32ul,  # 0xFFFFFFFF
+    "unk_0x44" / Int32ul,  # 0xFFFFFFFF
+    "unk_0x48" / Int32ul,  # 0xFFFFFFFF
+    "unk_0x4c" / Int32ul,  # 0xFFFFFFFF
+)
+
+# MBN BIN
+MBN_BIN = Struct(
+    "magic" / Bytes(8),
+    "unk_0x08" / Int32ul,
+    "version" / Int32ul,
+    "total_size" / Int32ul,  # includes header
+    "unk_0x14" / Int32ul,
+)
+
+# v7 trailer header used by mbn_mav25_stitch
+MBN_V7 = Struct(
+    "reserved" / Int32ul,
+    "version" / Int32ul,
+    "common_metadata_size" / Int32ul,
+    "qti_metadata_size" / Int32ul,
+    "oem_metadata_size" / Int32ul,
+    "hash_table_size" / Int32ul,
+    "qti_signature_size" / Int32ul,
+    "qti_certificate_chain_size" / Int32ul,
+    "oem_signature_size" / Int32ul,
+    "oem_certificate_chain_size" / Int32ul,
+)
+
+# ELF (minimal fields we need)
+ELF32_Ehdr = Struct(
+    "e_ident" / Bytes(16),
+    "e_type" / Int16ul,
+    "e_machine" / Int16ul,
+    "e_version" / Int32ul,
+    "e_entry" / Int32ul,
+    "e_phoff" / Int32ul,
+    "e_shoff" / Int32ul,
+    "e_flags" / Int32ul,
+    "e_ehsize" / Int16ul,
+    "e_phentsize" / Int16ul,
+    "e_phnum" / Int16ul,
+    "e_shentsize" / Int16ul,
+    "e_shnum" / Int16ul,
+    "e_shstrndx" / Int16ul,
+)
+
+ELF64_Ehdr = Struct(
+    "e_ident" / Bytes(16),
+    "e_type" / Int16ul,
+    "e_machine" / Int16ul,
+    "e_version" / Int32ul,
+    "e_entry" / Int64ul,
+    "e_phoff" / Int64ul,
+    "e_shoff" / Int64ul,
+    "e_flags" / Int32ul,
+    "e_ehsize" / Int16ul,
+    "e_phentsize" / Int16ul,
+    "e_phnum" / Int16ul,
+    "e_shentsize" / Int16ul,
+    "e_shnum" / Int16ul,
+    "e_shstrndx" / Int16ul,
+)
+
+ELF32_Phdr = Struct(
+    "p_type" / Int32ul,
+    "p_offset" / Int32ul,
+    "p_vaddr" / Int32ul,
+    "p_paddr" / Int32ul,
+    "p_filesz" / Int32ul,
+    "p_memsz" / Int32ul,
+    "p_flags" / Int32ul,
+    "p_align" / Int32ul,
+)
+
+ELF64_Phdr = Struct(
+    "p_type" / Int32ul,
+    "p_flags" / Int32ul,
+    "p_offset" / Int64ul,
+    "p_vaddr" / Int64ul,
+    "p_paddr" / Int64ul,
+    "p_filesz" / Int64ul,
+    "p_memsz" / Int64ul,
+    "p_align" / Int64ul,
+)
+
+
+# -----------------------------------------------------------------------------
+# Helpers
+# -----------------------------------------------------------------------------
+
+
+def _is_valid_elf_ident(e_ident: bytes) -> bool:
+    return (
+            len(e_ident) >= EI_NIDENT
+            and e_ident[EI_MAG0] == ELFMAG0
+            and e_ident[EI_MAG1] == ELFMAG1
+            and e_ident[EI_MAG2] == ELFMAG2
+            and e_ident[EI_MAG3] == ELFMAG3
+            and e_ident[EI_CLASS] != ELFCLASSNONE
+    )
+
+
+def _read_elf_headers(data: bytes):
+    if len(data) < EI_NIDENT:
+        return None, None
+    e_ident = data[:EI_NIDENT]
+    if not _is_valid_elf_ident(e_ident):
+        return None, None
+    if e_ident[EI_CLASS] == ELFCLASS64:
+        if len(data) < ELF64_Ehdr.sizeof():
+            return None, None
+        hdr = ELF64_Ehdr.parse(data[: ELF64_Ehdr.sizeof()])
+        return "ELF64", hdr
+    elif e_ident[EI_CLASS] == ELFCLASS32:
+        if len(data) < ELF32_Ehdr.sizeof():
+            return None, None
+        hdr = ELF32_Ehdr.parse(data[: ELF32_Ehdr.sizeof()])
+        return "ELF32", hdr
+    return None, None
+
+
+def _read_program_headers(data: bytes, kind: str, hdr) -> list:
+    phdrs = []
+    if hdr.e_phnum == 0:
+        logger.error("%s: ELF has no program sections", "_read_program_headers")
+        return phdrs
+
+    table_size = hdr.e_phnum * (
+        ELF64_Phdr.sizeof() if kind == "ELF64" else ELF32_Phdr.sizeof()
+    )
+    if hdr.e_phoff + table_size > len(data):
+        logger.error(
+            "%s: Program header table is out of bounds", "_read_program_headers"
+        )
+        return []
+
+    table = data[hdr.e_phoff:hdr.e_phoff + table_size]
+    bio = io.BytesIO(table)
+    for _ in range(hdr.e_phnum):
+        if kind == "ELF64":
+            ph = ELF64_Phdr.parse_stream(bio)
+        else:
+            ph = ELF32_Phdr.parse_stream(bio)
+        phdrs.append(ph)
+    return phdrs
+
+
+def _elf_last_segment_end(data: bytes) -> Optional[int]:
+    kind, hdr = _read_elf_headers(data)
+    if not hdr:
+        return None
+    phdrs = _read_program_headers(data, kind, hdr)
+    if not phdrs:
+        return None
+    # last by highest p_offset
+    last = max(phdrs, key=lambda p: int(p.p_offset))
+    return int(last.p_offset + last.p_filesz)
+
+
+def _mbn_v7_header_sizes_valid(h, sect_size: int) -> bool:
+    total = (
+            MBN_V7.sizeof()
+            + h.common_metadata_size
+            + h.qti_metadata_size
+            + h.oem_metadata_size
+            + h.hash_table_size
+            + h.qti_signature_size
+            + h.qti_certificate_chain_size
+            + h.oem_signature_size
+            + h.oem_certificate_chain_size
+    )
+    return total <= sect_size
+
+
+def _mbn_v7_header_sizes_expected(h) -> bool:
+    return (
+            (h.qti_metadata_size in (0, 0xE0))
+            and (h.oem_metadata_size in (0, 0xE0))
+            and (h.oem_signature_size in (0, 0x68))
+            and (h.oem_certificate_chain_size in (0, 0xD20))
+    )
+
+
+def _mbn_v7_log(h, func: str, prefix: str) -> None:
+    logger.debug(
+        "%s: %s header {version=0x%x, common_metadata_size=0x%x, qti_metadata_size=0x%x, "
+        "oem_metadata_size=0x%x, hash_table_size=0x%x, qti_signature_size=0x%x, "
+        "qti_certificate_chain_size=0x%x, oem_signature_size=0x%x, oem_certificate_chain_size=0x%x}",
+        func,
+        prefix,
+        h.version,
+        h.common_metadata_size,
+        h.qti_metadata_size,
+        h.oem_metadata_size,
+        h.hash_table_size,
+        h.qti_signature_size,
+        h.qti_certificate_chain_size,
+        h.oem_signature_size,
+        h.oem_certificate_chain_size,
+    )
+
+
+# -----------------------------------------------------------------------------
+# Public API
+# -----------------------------------------------------------------------------
+
+
+def mbn_stitch(data: bytes, blob: bytes) -> Optional[bytes]:
+    """
+    Overwrite the tail of `data` with `blob`. Format-aware size logging/checks.
+    Returns new bytes or None.
+    """
+    if data is None:
+        logger.error("%s: data is NULL", "mbn_stitch")
+        return None
+    if not data:
+        logger.error("%s: data size is 0", "mbn_stitch")
+        return None
+    if blob is None:
+        logger.error("%s: blob is NULL", "mbn_stitch")
+        return None
+    if not blob:
+        logger.error("%s: blob size is 0", "mbn_stitch")
+        return None
+
+    data_size = len(data)
+    blob_size = len(blob)
+    parsed_size = 0
+
+    try:
+        # MBN v2
+        if data_size > MBN_V2_MAGIC_SIZE and data[:MBN_V2_MAGIC_SIZE] == MBN_V2_MAGIC:
+            if data_size < MBN_V2.sizeof():
+                logger.error("%s: truncated MBN v2 header", "mbn_stitch")
+                return None
+            h = MBN_V2.parse(data[: MBN_V2.sizeof()])
+            parsed_size = h.data_size + MBN_V2.sizeof()
+            logger.debug(
+                "%s: encountered MBN v2 image, parsed_size = 0x%x",
+                "mbn_stitch",
+                parsed_size,
+            )
+
+        # MBN v1
+        elif data_size > MBN_V1_MAGIC_SIZE and data[:MBN_V1_MAGIC_SIZE] == MBN_V1_MAGIC:
+            if data_size < MBN_V1.sizeof():
+                logger.error("%s: truncated MBN v1 header", "mbn_stitch")
+                return None
+            h = MBN_V1.parse(data[: MBN_V1.sizeof()])
+            parsed_size = h.data_size + MBN_V1.sizeof()
+            logger.debug(
+                "%s: encountered MBN v1 image, parsed_size = 0x%x",
+                "mbn_stitch",
+                parsed_size,
+            )
+
+        # BIN
+        elif (
+                data_size > (MBN_BIN_MAGIC_SIZE + MBN_BIN_MAGIC_OFFSET)
+                and data[MBN_BIN_MAGIC_OFFSET:MBN_BIN_MAGIC_OFFSET + MBN_BIN_MAGIC_SIZE]
+                == MBN_BIN_MAGIC
+        ):
+            if data_size < MBN_BIN.sizeof():
+                logger.error("%s: truncated MBN BIN header", "mbn_stitch")
+                return None
+            h = MBN_BIN.parse(data[: MBN_BIN.sizeof()])
+            parsed_size = h.total_size
+            logger.debug(
+                "%s: encountered MBN BIN image, parsed_size = 0x%x",
+                "mbn_stitch",
+                parsed_size,
+            )
+
+        # ELF
+        else:
+            end = _elf_last_segment_end(data)
+            if end is not None:
+                parsed_size = end
+                logger.debug(
+                    "%s: encountered ELF image, parsed_size = 0x%x",
+                    "mbn_stitch",
+                    parsed_size,
+                )
+            else:
+                logger.warning("Unknown file format passed to %s", "mbn_stitch")
+                parsed_size = data_size
+
+        if parsed_size != data_size:
+            logger.warning(
+                "%s: size mismatch for MBN data, expected 0x%x, input size 0x%x",
+                "mbn_stitch",
+                parsed_size,
+                data_size,
+            )
+
+        stitch_offset = data_size - blob_size
+        if stitch_offset < 0 or stitch_offset + blob_size > data_size:
+            logger.error(
+                "%s: stitch offset (0x%x) + size (0x%x) is larger than the destination (0x%x)",
+                "mbn_stitch",
+                stitch_offset,
+                blob_size,
+                data_size,
+            )
+            return None
+
+        out = bytearray(data)
+        logger.debug(
+            "%s: stitching mbn at 0x%x, size 0x%x",
+            "mbn_stitch",
+            stitch_offset,
+            blob_size,
+        )
+        out[stitch_offset: stitch_offset + blob_size] = blob
+        return bytes(out)
+
+    except ChecksumError as e:
+        logger.error("%s: construct checksum error: %s", "mbn_stitch", str(e))
+        return None
+    except Exception as e:
+        logger.error("%s: unexpected error: %s", "mbn_stitch", str(e))
+        return None
+
+
+def mbn_mav25_stitch(data: bytes, blob: bytes) -> Optional[bytes]:
+    """
+    Patch an ELF's last program-section area with a v7 trailer from `blob`.
+    - Writes new metadata+hash at section start
+    - Writes OEM sig+chain after existing dest qti sig+chain
+    Returns new bytes or None.
+    """
+    if data is None:
+        logger.error("%s: data is NULL", "mbn_mav25_stitch")
+        return None
+    if not data:
+        logger.error("%s: data size is 0", "mbn_mav25_stitch")
+        return None
+    if blob is None:
+        logger.error("%s: blob is NULL", "mbn_mav25_stitch")
+        return None
+    if not blob:
+        logger.error("%s: blob size is 0", "mbn_mav25_stitch")
+        return None
+
+    data_size, blob_size = len(data), len(blob)
+
+    kind, ehdr = _read_elf_headers(data)
+    if not ehdr:
+        logger.error("%s: data is not a valid ELF", "mbn_mav25_stitch")
+        return None
+
+    if blob_size < MBN_V7.sizeof():
+        logger.error("%s: header is bigger than blob", "mbn_mav25_stitch")
+        return None
+
+    src = MBN_V7.parse(blob[: MBN_V7.sizeof()])
+    _mbn_v7_log(src, "mbn_mav25_stitch", "src")
+    if src.version != 7:
+        logger.error(
+            "%s: src header version (0x%x) is incorrect",
+            "mbn_mav25_stitch",
+            src.version,
+        )
+        return None
+    if not _mbn_v7_header_sizes_expected(src):
+        logger.warning(
+            "%s: header sizes in header are unexpected (qti_metadata_size=0x%x, oem_metadata_size=0x%x, "
+            "oem_signature_size=0x%x, oem_certificate_chain_size=0x%x)",
+            "mbn_mav25_stitch",
+            src.qti_metadata_size,
+            src.oem_metadata_size,
+            src.oem_signature_size,
+            src.oem_certificate_chain_size,
+        )
+
+    # last PHDR (by index)
+    phdrs = _read_program_headers(data, kind, ehdr)
+    if not phdrs:
+        return None
+    last_ph = phdrs[-1]
+    sect_off, sect_size = int(last_ph.p_offset), int(last_ph.p_filesz)
+
+    if sect_off == 0:
+        logger.error("%s: section has 0 offset", "mbn_mav25_stitch")
+        return None
+    if sect_size == 0:
+        logger.error("%s: section has 0 size", "mbn_mav25_stitch")
+        return None
+    if sect_off + sect_size > data_size:
+        logger.error(
+            "%s: section (0x%x+0x%x) is bigger than the data",
+            "mbn_mav25_stitch",
+            sect_off,
+            sect_size,
+        )
+        return None
+    if sect_size < MBN_V7.sizeof():
+        logger.error(
+            "%s: dest header is bigger than the section (0x%x)",
+            "mbn_mav25_stitch",
+            sect_size,
+        )
+        return None
+
+    dest = MBN_V7.parse(data[sect_off: sect_off + MBN_V7.sizeof()])
+    _mbn_v7_log(dest, "mbn_mav25_stitch", "dest")
+    if dest.version != 7:
+        logger.error(
+            "%s: dest header version (0x%x) is incorrect",
+            "mbn_mav25_stitch",
+            dest.version,
+        )
+        return None
+    if not _mbn_v7_header_sizes_valid(dest, sect_size):
+        logger.error(
+            (
+                "%s: sizes in dest header are invalid (common_metadata_size=0x%x, qti_metadata_size=0x%x, "
+                "oem_metadata_size=0x%x, hash_table_size=0x%x, qti_signature_size=0x%x, "
+                "qti_certificate_chain_size=0x%x, oem_signature_size=0x%x, "
+                "oem_certificate_chain_size=0x%x)"
+            ),
+            "mbn_mav25_stitch",
+            dest.common_metadata_size,
+            dest.qti_metadata_size,
+            dest.oem_metadata_size,
+            dest.hash_table_size,
+            dest.qti_signature_size,
+            dest.qti_certificate_chain_size,
+            dest.oem_signature_size,
+            dest.oem_certificate_chain_size,
+        )
+        return None
+    if not _mbn_v7_header_sizes_expected(dest):
+        logger.warning(
+            "%s: header sizes in dest header are unexpected (qti_metadata_size=0x%x, oem_metadata_size=0x%x, "
+            "oem_signature_size=0x%x, oem_certificate_chain_size=0x%x)",
+            "mbn_mav25_stitch",
+            dest.qti_metadata_size,
+            dest.oem_metadata_size,
+            dest.oem_signature_size,
+            dest.oem_certificate_chain_size,
+        )
+
+    # compute new layout from src
+    new_metadata_size = (
+            MBN_V7.sizeof()
+            + src.common_metadata_size
+            + src.qti_metadata_size
+            + src.oem_metadata_size
+    )
+    new_metadata_and_hash_table_size = new_metadata_size + src.hash_table_size
+    new_oem_sig_and_cert_chain_size = (
+            src.oem_signature_size + src.oem_certificate_chain_size
+    )
+
+    new_oem_sig_and_cert_chain_off = (
+            new_metadata_and_hash_table_size
+            + dest.qti_signature_size
+            + dest.qti_certificate_chain_size
+    )
+
+    # bounds
+    if new_metadata_and_hash_table_size > blob_size:
+        logger.error(
+            "%s: new metadata (0x%x) and hash table (0x%x) are bigger than the source (0x%x)",
+            "mbn_mav25_stitch",
+            new_metadata_size,
+            src.hash_table_size,
+            blob_size,
+        )
+        return None
+    if new_metadata_and_hash_table_size > sect_size:
+        logger.error(
+            "%s: new metadata (0x%x) and hash table (0x%x) are bigger than the destination (0x%x)",
+            "mbn_mav25_stitch",
+            new_metadata_size,
+            src.hash_table_size,
+            sect_size,
+        )
+        return None
+    if new_metadata_and_hash_table_size + new_oem_sig_and_cert_chain_size > blob_size:
+        logger.error(
+            "%s: new OEM signature and certificate chain are bigger than the source",
+            "mbn_mav25_stitch",
+        )
+        return None
+    if new_oem_sig_and_cert_chain_off + new_oem_sig_and_cert_chain_size > sect_size:
+        logger.error(
+            "%s: new OEM signature and certificate chain are outside the bounds of the destination",
+            "mbn_mav25_stitch",
+        )
+        return None
+
+    out = bytearray(data)
+    # write metadata + hash
+    logger.debug(
+        "%s: stitching mbn at 0x%x (0x%x bytes)",
+        "mbn_mav25_stitch",
+        sect_off,
+        new_metadata_and_hash_table_size,
+    )
+    out[sect_off: sect_off + new_metadata_and_hash_table_size] = blob[
+        :new_metadata_and_hash_table_size
+    ]
+
+    # write OEM sig + chain
+    logger.debug(
+        "%s: stitching mbn at 0x%x (0x%x bytes)",
+        "mbn_mav25_stitch",
+        sect_off + new_oem_sig_and_cert_chain_off,
+        new_oem_sig_and_cert_chain_size,
+    )
+    start = new_metadata_and_hash_table_size
+    end = start + new_oem_sig_and_cert_chain_size
+
+    slice_start = sect_off + new_oem_sig_and_cert_chain_off
+    slice_end = sect_off + new_oem_sig_and_cert_chain_off + new_oem_sig_and_cert_chain_size
+    out[slice_start:slice_end] = blob[start:end]
+
+    return bytes(out)
+
+
+# -----------------------------------------------------------------------------
+# Tiny helpers (optional)
+# -----------------------------------------------------------------------------
+
+
+def mbn_is_valid_elf(buf: bytes) -> bool:
+    return len(buf) >= EI_NIDENT and _is_valid_elf_ident(buf[:EI_NIDENT])
+
+
+def mbn_is_64bit_elf(buf: bytes) -> bool:
+    return len(buf) >= EI_NIDENT and buf[EI_CLASS] == ELFCLASS64

pymobiledevice3/restore/restore.py

@@ -23,12 +23,13 @@ from pymobiledevice3.restore.consts import PROGRESS_BAR_OPERATIONS, lpol_file
 from pymobiledevice3.restore.device import Device
 from pymobiledevice3.restore.fdr import FDRClient, fdr_type, start_fdr_thread
 from pymobiledevice3.restore.ftab import Ftab
+from pymobiledevice3.restore.mbn import mbn_mav25_stitch, mbn_stitch
 from pymobiledevice3.restore.recovery import Behavior, Recovery
 from pymobiledevice3.restore.restore_options import RestoreOptions
 from pymobiledevice3.restore.restored_client import RestoredClient
 from pymobiledevice3.restore.tss import TSSRequest, TSSResponse
 from pymobiledevice3.service_connection import ServiceConnection
-from pymobiledevice3.utils import plist_access_path
+from pymobiledevice3.utils import asyncio_print_traceback, plist_access_path
 
 known_errors = {
     0xFFFFFFFFFFFFFFFF: 'verification error',
@@ -442,7 +443,7 @@ class Restore(BaseRestore):
         await service.aio_send_plist(req)
 
     @staticmethod
-    def get_bbfw_fn_for_element(elem):
+    def get_bbfw_fn_for_element(elem: str, bb_chip_id: Optional[int] = None) -> str:
         bbfw_fn_elem = {
             # ICE3 firmware files
             'RamPSI': 'psi_ram.fls',
@@ -465,7 +466,16 @@ class Restore(BaseRestore):
             # Mav20 Firmware file
             'Misc': 'multi_image.mbn',
         }
-        return bbfw_fn_elem.get(elem)
+
+        bbfw_fn_elem_mav25 = {
+            # Mav25 Firmware files
+            'Misc': 'multi_image.mbn',
+            'RestoreSBL1': 'restorexbl_sc.elf',
+            'SBL1': 'xbl_sc.elf',
+            'TME': 'signed_firmware_soc_view.elf',
+        }
+
+        return bbfw_fn_elem_mav25.get(elem) if bb_chip_id == 0x1F30E1 else bbfw_fn_elem.get(elem)
 
     def fls_parse(self, buffer):
         raise NotImplementedError()
@@ -476,7 +486,8 @@ class Restore(BaseRestore):
     def fls_insert_ticket(self, fls, bbticket):
         raise NotImplementedError()
 
-    def sign_bbfw(self, bbfw_orig, bbtss, bb_nonce):
+    def sign_bbfw(self, bbfw_orig: bytes, bbtss: TSSResponse, bb_nonce: Optional[bytes],
+                  bb_chip_id: Optional[int] = None) -> bytes:
         # check for BBTicket in result
         bbticket = bbtss.bb_ticket
         bbfw_dict = bbtss.get('BasebandFirmware')
@@ -495,7 +506,7 @@ class Restore(BaseRestore):
                     for key, blob in bbfw_dict.items():
                         if key.endswith('-Blob') and isinstance(blob, bytes):
                             key = key.split('-', 1)[0]
-                            signfn = self.get_bbfw_fn_for_element(key)
+                            signfn = self.get_bbfw_fn_for_element(key, bb_chip_id)
 
                             if signfn is None:
                                 raise PyMobileDevice3Exception(
@@ -507,11 +518,11 @@ class Restore(BaseRestore):
                             buffer = bbfw_orig.read(signfn)
 
                             if is_fls:
-                                fls = self.fls_parse(buffer)
-                                data = self.fls_update_sig_blob(fls, blob)
+                                raise NotImplementedError('is_fls')
+                            elif bb_chip_id == 0x1F30E1:  # Mav25 - Qualcomm Snapdragon X80 5G Modem
+                                data = mbn_mav25_stitch(buffer, blob)
                             else:
-                                parsed_sig_offset = len(buffer) - len(blob)
-                                data = buffer[:parsed_sig_offset] + blob
+                                data = mbn_stitch(buffer, blob)
 
                             bbfw_patched.writestr(bbfw_orig.getinfo(signfn), data)
 
@@ -559,6 +570,7 @@ class Restore(BaseRestore):
             if tmp_zip_read_name:
                 os.remove(tmp_zip_read_name)
 
+    @asyncio_print_traceback
     async def send_baseband_data(self, message: dict):
         self.logger.info(f'About to send BasebandData: {message}')
         service = await self._get_service_for_data_request(message)
@@ -608,7 +620,7 @@ class Restore(BaseRestore):
         # extract baseband firmware to temp file
         bbfw = self.ipsw.read(bbfwpath)
 
-        buffer = self.sign_bbfw(bbfw, bbtss, bb_nonce)
+        buffer = self.sign_bbfw(bbfw, bbtss, bb_nonce, bb_chip_id)
 
         self.logger.info('Sending BasebandData now...')
         await service.aio_send_plist({'BasebandData': buffer})

{pymobiledevice3-4.27.5.dist-info → pymobiledevice3-4.27.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.5
+Version: 4.27.6
 Summary: Pure python3 implementation for working with iDevices (iPhone, etc...)
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>

{pymobiledevice3-4.27.5.dist-info → pymobiledevice3-4.27.6.dist-info}/RECORD

@@ -8,7 +8,7 @@ misc/understanding_idevice_protocol_layers.md,sha256=8tEqRXWOUPoxOJLZVh7C7H9JGCh
 misc/usbmux_sniff.sh,sha256=iWtbucOEQ9_UEFXk9x-2VNt48Jg5zrPsnUbZ_LfZxwA,212
 pymobiledevice3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymobiledevice3/__main__.py,sha256=1nv18QRgR_FDq5rE95uhdZGOQ6xkPzNDrcMzQQs8ZZ4,11697
-pymobiledevice3/_version.py,sha256=drqBxOP7IVaoCFNTNLbLqRxgVySWqWe06Z2SK5blf6A,706
+pymobiledevice3/_version.py,sha256=5o71dkMA4e-Z6BEkb9K3FNM6kwzbnHi6uML3NUJ4QSg,706
 pymobiledevice3/bonjour.py,sha256=-Q_TLBGJ6qW3CX_DgBcz-CXfWSwxWVQ2L64hk6PxnDY,5631
 pymobiledevice3/ca.py,sha256=mTvWdSjTZw6Eb-22-IZ323GyA1G6CXYmdPedImTjm3A,10542
 pymobiledevice3/common.py,sha256=-PG6oaUkNFlB3jb7E0finMrX8wqhkS-cuTAfmLvZUmc,329
@@ -91,8 +91,9 @@ pymobiledevice3/restore/device.py,sha256=TZahPSKHxfrF7A8DC70fwcoQK9bXD6QV1dAr80Y
 pymobiledevice3/restore/fdr.py,sha256=KOXZH50oNYseP-PzSkw_uxu1NyGP5d32_DYSoYdbFu8,6269
 pymobiledevice3/restore/ftab.py,sha256=SWNKZRN1pFWzx_qHCkycvsLaHFAqkqQJYRBJYQ_-Wjw,1507
 pymobiledevice3/restore/img4.py,sha256=V03nq1L7FMkdmC15MN7W9Wct4MQx472aDpy5IkuNvII,4888
+pymobiledevice3/restore/mbn.py,sha256=3Xb62vrfCROosvcTYAbAwALW_URxm5wEpctjj82CwIQ,19323
 pymobiledevice3/restore/recovery.py,sha256=1eHQ-I1iJG31TLIAz890fBtGqopBQT3FB--UYESIkEQ,17205
-pymobiledevice3/restore/restore.py,sha256=86qTivTKuYT0cwWcYPoRtLKvsFvPoiUyKtq_9YWjXw0,57485
+pymobiledevice3/restore/restore.py,sha256=VKro3s0vm3WDrgVAbdcw4SNSPmgtsJ5yEvpMy_eUfPM,58104
 pymobiledevice3/restore/restore_options.py,sha256=qeh_wRa_bi0Ccl0p0JuX9EChEQBqwJt94EBImWcEJ3E,7255
 pymobiledevice3/restore/restored_client.py,sha256=h_yBZ_e1wfaIzi0f9-R8Ky2x6xFTkvDlpWIV561uxoU,3638
 pymobiledevice3/restore/tss.py,sha256=QHq5OTyCn7iIrYhhgOxT5_gpV7wggcy5Faje5160FHQ,29852
@@ -164,9 +165,9 @@ pymobiledevice3/services/web_protocol/switch_to.py,sha256=hDddJUEePbRN-8xlllOeGh
 pymobiledevice3/tunneld/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymobiledevice3/tunneld/api.py,sha256=EfGKXEWhsMSB__menPmRmL9R6dpazVJDUy7B3pn05MM,2357
 pymobiledevice3/tunneld/server.py,sha256=L_98QatvVuyiXexoHF5rA0V56wC84VLeKhLyiFWwHrc,22960
-pymobiledevice3-4.27.5.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-pymobiledevice3-4.27.5.dist-info/METADATA,sha256=JkvGLXeRUphXgo-AmCAyHIS3YWJoR9ftkt0hXLAIJWM,17450
-pymobiledevice3-4.27.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pymobiledevice3-4.27.5.dist-info/entry_points.txt,sha256=jJMlOanHlVwUxcY__JwvKeWPrvBJr_wJyEq4oHIZNKE,66
-pymobiledevice3-4.27.5.dist-info/top_level.txt,sha256=MjZoRqcWPOh5banG-BbDOnKEfsS3kCxqV9cv-nzyg2Q,21
-pymobiledevice3-4.27.5.dist-info/RECORD,,
+pymobiledevice3-4.27.6.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pymobiledevice3-4.27.6.dist-info/METADATA,sha256=9zYKxPeaGYsfbQe6-sf4iQn9lQjw12zx_smTNsWVIVU,17450
+pymobiledevice3-4.27.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymobiledevice3-4.27.6.dist-info/entry_points.txt,sha256=jJMlOanHlVwUxcY__JwvKeWPrvBJr_wJyEq4oHIZNKE,66
+pymobiledevice3-4.27.6.dist-info/top_level.txt,sha256=MjZoRqcWPOh5banG-BbDOnKEfsS3kCxqV9cv-nzyg2Q,21
+pymobiledevice3-4.27.6.dist-info/RECORD,,