pymobiledevice3 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymobiledevice3/restore/asr.py

@@ -29,28 +29,28 @@ class ASRClient:
 
     def __init__(self, udid: str) -> None:
         self._udid: str = udid
-        self.logger = logging.getLogger(f'{asyncio.current_task().get_name()}-{__name__}')
+        self.logger = logging.getLogger(f"{asyncio.current_task().get_name()}-{__name__}")
         self.service: typing.Optional[ServiceConnection] = None
         self.checksum_chunks: bool = False
 
     async def connect(self, port: int = DEFAULT_ASR_SYNC_PORT) -> None:
-        self.service = ServiceConnection.create_using_usbmux(self._udid, port, connection_type='USB')
+        self.service = ServiceConnection.create_using_usbmux(self._udid, port, connection_type="USB")
         await self.service.aio_start()
 
         # receive Initiate command message
         data = await self.recv_plist()
-        self.logger.debug(f'got command: {data}')
+        self.logger.debug(f"got command: {data}")
 
-        command = data.get('Command')
-        if command != 'Initiate':
-            raise PyMobileDevice3Exception(f'invalid command received: {command}')
+        command = data.get("Command")
+        if command != "Initiate":
+            raise PyMobileDevice3Exception(f"invalid command received: {command}")
 
-        self.checksum_chunks = data.get('Checksum Chunks', False)
-        self.logger.debug(f'Checksum Chunks: {self.checksum_chunks}')
+        self.checksum_chunks = data.get("Checksum Chunks", False)
+        self.logger.debug(f"Checksum Chunks: {self.checksum_chunks}")
 
     async def recv_plist(self) -> dict:
-        buf = b''
-        while not buf.endswith(b'</plist>\n'):
+        buf = b""
+        while not buf.endswith(b"</plist>\n"):
             buf += await self.service.aio_recvall(1)
         return plistlib.loads(buf)
 
@@ -62,8 +62,8 @@ class ASRClient:
         await self.service.aio_sendall(buf)
 
     async def handle_oob_data_request(self, packet: dict, filesystem: typing.IO):
-        oob_length = packet['OOB Length']
-        oob_offset = packet['OOB Offset']
+        oob_length = packet["OOB Length"]
+        oob_offset = packet["OOB Offset"]
         filesystem.seek(oob_offset, os.SEEK_SET)
 
         oob_data = filesystem.read(oob_length)
@@ -77,36 +77,36 @@ class ASRClient:
         filesystem.seek(0, os.SEEK_SET)
 
         payload_info = {
-            'Port': 1,
-            'Size': length,
+            "Port": 1,
+            "Size": length,
         }
 
-        packet_info = dict()
+        packet_info = {}
         if self.checksum_chunks:
-            packet_info['Checksum Chunk Size'] = ASR_CHECKSUM_CHUNK_SIZE
+            packet_info["Checksum Chunk Size"] = ASR_CHECKSUM_CHUNK_SIZE
 
-        packet_info['FEC Slice Stride'] = ASR_FEC_SLICE_STRIDE
-        packet_info['Packet Payload Size'] = ASR_PAYLOAD_PACKET_SIZE
-        packet_info['Packets Per FEC'] = ASR_PACKETS_PER_FEC
-        packet_info['Payload'] = payload_info
-        packet_info['Stream ID'] = ASR_STREAM_ID
-        packet_info['Version'] = ASR_VERSION
+        packet_info["FEC Slice Stride"] = ASR_FEC_SLICE_STRIDE
+        packet_info["Packet Payload Size"] = ASR_PAYLOAD_PACKET_SIZE
+        packet_info["Packets Per FEC"] = ASR_PACKETS_PER_FEC
+        packet_info["Payload"] = payload_info
+        packet_info["Stream ID"] = ASR_STREAM_ID
+        packet_info["Version"] = ASR_VERSION
 
         await self.send_plist(packet_info)
 
         while True:
             packet = await self.recv_plist()
-            self.logger.debug(f'perform_validation: {packet}')
-            command = packet['Command']
+            self.logger.debug(f"perform_validation: {packet}")
+            command = packet["Command"]
 
-            if command == 'Payload':
+            if command == "Payload":
                 break
 
-            elif command == 'OOBData':
+            elif command == "OOBData":
                 await self.handle_oob_data_request(packet, filesystem)
 
             else:
-                raise PyMobileDevice3Exception(f'unknown packet: {packet}')
+                raise PyMobileDevice3Exception(f"unknown packet: {packet}")
 
     async def send_payload(self, filesystem: typing.IO) -> None:
         filesystem.seek(0, os.SEEK_END)

pymobiledevice3/restore/base_restore.py

@@ -12,29 +12,30 @@ from pymobiledevice3.restore.device import Device
 from pymobiledevice3.restore.img4 import stitch_component
 from pymobiledevice3.restore.tss import TSSResponse
 
-RESTORE_VARIANT_ERASE_INSTALL = 'Erase Install (IPSW)'
-RESTORE_VARIANT_UPGRADE_INSTALL = 'Upgrade Install (IPSW)'
-RESTORE_VARIANT_MACOS_RECOVERY_OS = 'macOS Customer'
+RESTORE_VARIANT_ERASE_INSTALL = "Erase Install (IPSW)"
+RESTORE_VARIANT_UPGRADE_INSTALL = "Upgrade Install (IPSW)"
+RESTORE_VARIANT_MACOS_RECOVERY_OS = "macOS Customer"
 
 
 class Behavior(Enum):
-    Update = 'Update'
-    Erase = 'Erase'
+    Update = "Update"
+    Erase = "Erase"
 
 
 class BaseRestore:
-    def __init__(self, ipsw: ZipFile, device: Device, tss: Optional[dict] = None,
-                 behavior: Behavior = Behavior.Update) -> None:
+    def __init__(
+        self, ipsw: ZipFile, device: Device, tss: Optional[dict] = None, behavior: Behavior = Behavior.Update
+    ) -> None:
         self.ipsw = IPSW(ipsw)
         self.device = device
         self.tss = TSSResponse(tss) if tss is not None else None
 
         if not self.device.is_image4_supported:
-            raise NotImplementedError('is_image4_supported is False')
+            raise NotImplementedError("is_image4_supported is False")
 
-        self.logger.info(f'connected device: {self.device}')
+        self.logger.info(f"connected device: {self.device}")
 
-        self.logger.debug('scanning BuildManifest.plist for the correct BuildIdentity')
+        self.logger.debug("scanning BuildManifest.plist for the correct BuildIdentity")
 
         variant = {
             Behavior.Update: RESTORE_VARIANT_UPGRADE_INSTALL,
@@ -42,68 +43,110 @@ class BaseRestore:
         }[behavior]
 
         try:
-            self.build_identity = self.ipsw.build_manifest.get_build_identity(self.device.hardware_model,
-                                                                              restore_behavior=behavior.value,
-                                                                              variant=variant)
+            self.build_identity = self.ipsw.build_manifest.get_build_identity(
+                self.device.hardware_model, restore_behavior=behavior.value, variant=variant
+            )
         except NoSuchBuildIdentityError:
             if behavior == Behavior.Update:
-                self.build_identity = self.ipsw.build_manifest.get_build_identity(self.device.hardware_model,
-                                                                                  restore_behavior=behavior.value)
+                self.build_identity = self.ipsw.build_manifest.get_build_identity(
+                    self.device.hardware_model, restore_behavior=behavior.value
+                )
             else:
                 raise
 
         self.macos_variant = None
         try:
             self.macos_variant = self.ipsw.build_manifest.get_build_identity(
-                self.device.hardware_model,
-                variant=RESTORE_VARIANT_MACOS_RECOVERY_OS)
-            self.logger.info('Performing macOS restore')
+                self.device.hardware_model, variant=RESTORE_VARIANT_MACOS_RECOVERY_OS
+            )
+            self.logger.info("Performing macOS restore")
         except NoSuchBuildIdentityError:
             pass
 
-        build_info = self.build_identity.get('Info')
+        build_info = self.build_identity.get("Info")
         if build_info is None:
             raise PyMobileDevice3Exception('build identity does not contain an "Info" element')
 
-        device_class = build_info.get('DeviceClass')
+        device_class = build_info.get("DeviceClass")
         if device_class is None:
             raise PyMobileDevice3Exception('build identity does not contain an "DeviceClass" element')
 
     @property
     def logger(self) -> logging.Logger:
-        return logging.getLogger(f'{asyncio.current_task().get_name()}-{self.__class__.__module__}')
-
-    def get_personalized_data(self, component_name: str, data: Optional[bytes] = None,
-                              tss: Optional[TSSResponse] = None, path: Optional[str] = None) -> bytes:
-        return stitch_component(component_name,
-                                self.build_identity.get_component(component_name, tss=tss, data=data, path=path).data,
-                                tss,
-                                self.build_identity,
-                                self.device.ap_parameters)
+        return logging.getLogger(f"{asyncio.current_task().get_name()}-{self.__class__.__module__}")
+
+    def get_personalized_data(
+        self,
+        component_name: str,
+        data: Optional[bytes] = None,
+        tss: Optional[TSSResponse] = None,
+        path: Optional[str] = None,
+    ) -> bytes:
+        return stitch_component(
+            component_name,
+            self.build_identity.get_component(component_name, tss=tss, data=data, path=path).data,
+            tss,
+            self.build_identity,
+            self.device.ap_parameters,
+        )
 
     def populate_tss_request_from_manifest(self, parameters: dict, additional_keys: Optional[list[str]] = None) -> None:
-        """ equivalent to idevicerestore:tss_parameters_add_from_manifest """
-        key_list = ['ApBoardID', 'ApChipID']
+        """equivalent to idevicerestore:tss_parameters_add_from_manifest"""
+        key_list = ["ApBoardID", "ApChipID"]
         if additional_keys is None:
-            key_list += ['UniqueBuildID', 'Ap,OSLongVersion', 'Ap,OSReleaseType', 'Ap,ProductType', 'Ap,SDKPlatform',
-                         'Ap,SikaFuse', 'Ap,Target', 'Ap,TargetType', 'ApBoardID', 'ApChipID',
-                         'ApSecurityDomain', 'BMU,BoardID', 'BMU,ChipID', 'BbChipID', 'BbProvisioningManifestKeyHash',
-                         'BbActivationManifestKeyHash', 'BbCalibrationManifestKeyHash', 'Ap,ProductMarketingVersion',
-                         'BbFactoryActivationManifestKeyHash', 'BbFDRSecurityKeyHash', 'BbSkeyId', 'SE,ChipID',
-                         'Savage,ChipID', 'Savage,PatchEpoch', 'Yonkers,BoardID', 'Yonkers,ChipID',
-                         'Yonkers,PatchEpoch', 'Rap,BoardID', 'Rap,ChipID', 'Rap,SecurityDomain', 'Baobab,BoardID',
-                         'Baobab,ChipID', 'Baobab,ManifestEpoch', 'Baobab,SecurityDomain', 'eUICC,ChipID',
-                         'PearlCertificationRootPub', 'Timer,BoardID,1', 'Timer,BoardID,2', 'Timer,ChipID,1',
-                         'Timer,ChipID,2', 'Timer,SecurityDomain,1', 'Timer,SecurityDomain,2', 'Manifest',
-                         'NeRDEpoch',
-                         ]
+            key_list += [
+                "UniqueBuildID",
+                "Ap,OSLongVersion",
+                "Ap,OSReleaseType",
+                "Ap,ProductType",
+                "Ap,SDKPlatform",
+                "Ap,SikaFuse",
+                "Ap,Target",
+                "Ap,TargetType",
+                "ApBoardID",
+                "ApChipID",
+                "ApSecurityDomain",
+                "BMU,BoardID",
+                "BMU,ChipID",
+                "BbChipID",
+                "BbProvisioningManifestKeyHash",
+                "BbActivationManifestKeyHash",
+                "BbCalibrationManifestKeyHash",
+                "Ap,ProductMarketingVersion",
+                "BbFactoryActivationManifestKeyHash",
+                "BbFDRSecurityKeyHash",
+                "BbSkeyId",
+                "SE,ChipID",
+                "Savage,ChipID",
+                "Savage,PatchEpoch",
+                "Yonkers,BoardID",
+                "Yonkers,ChipID",
+                "Yonkers,PatchEpoch",
+                "Rap,BoardID",
+                "Rap,ChipID",
+                "Rap,SecurityDomain",
+                "Baobab,BoardID",
+                "Baobab,ChipID",
+                "Baobab,ManifestEpoch",
+                "Baobab,SecurityDomain",
+                "eUICC,ChipID",
+                "PearlCertificationRootPub",
+                "Timer,BoardID,1",
+                "Timer,BoardID,2",
+                "Timer,ChipID,1",
+                "Timer,ChipID,2",
+                "Timer,SecurityDomain,1",
+                "Timer,SecurityDomain,2",
+                "Manifest",
+                "NeRDEpoch",
+            ]
         else:
             key_list += additional_keys
 
         for k in key_list:
             try:
                 v = self.build_identity[k]
-                if isinstance(v, str) and v.startswith('0x'):
+                if isinstance(v, str) and v.startswith("0x"):
                     v = int(v, 16)
                 parameters[k] = v
             except KeyError:
@@ -111,9 +154,9 @@ class BaseRestore:
 
         if additional_keys is None:
             # special treat for RequiresUIDMode
-            info = self.build_identity.get('Info')
+            info = self.build_identity.get("Info")
             if info is None:
                 return
-            requires_uid_mode = info.get('RequiresUIDMode')
+            requires_uid_mode = info.get("RequiresUIDMode")
             if requires_uid_mode is not None:
-                parameters['RequiresUIDMode'] = requires_uid_mode
+                parameters["RequiresUIDMode"] = requires_uid_mode

pymobiledevice3/restore/consts.py

@@ -1,70 +1,91 @@
-lpol_file = bytes([0x30, 0x14, 0x16, 0x04, 0x49, 0x4d, 0x34, 0x50,
-                   0x16, 0x04, 0x6c, 0x70, 0x6f, 0x6c, 0x16, 0x03,
-                   0x31, 0x2e, 0x30, 0x04, 0x01, 0x00])
+lpol_file = bytes([
+    0x30,
+    0x14,
+    0x16,
+    0x04,
+    0x49,
+    0x4D,
+    0x34,
+    0x50,
+    0x16,
+    0x04,
+    0x6C,
+    0x70,
+    0x6F,
+    0x6C,
+    0x16,
+    0x03,
+    0x31,
+    0x2E,
+    0x30,
+    0x04,
+    0x01,
+    0x00,
+])
 
 # extracted from ac2
 PROGRESS_BAR_OPERATIONS = {
-    11: 'CREATE_PARTITION_MAP',
-    12: 'CREATE_FILESYSTEM',
-    13: 'RESTORE_IMAGE',
-    14: 'VERIFY_RESTORE',
-    15: 'CHECK_FILESYSTEMS',
-    16: 'MOUNT_FILESYSTEMS',
-    17: 'FIXUP_VAR',
-    18: 'FLASH_FIRMWARE',
-    19: 'UPDATE_BASEBAND',
-    20: 'SET_BOOT_STAGE',
-    21: 'REBOOT_DEVICE',
-    22: 'SHUTDOWN_DEVICE',
-    23: 'TURN_ON_ACCESSORY_POWER',
-    24: 'CLEAR_BOOTARGS',
-    25: 'MODIFY_BOOTARGS',
-    26: 'INSTALL_ROOT',
-    27: 'INSTALL_KERNELCACHE',
-    28: 'WAIT_FOR_NAND',
-    29: 'UNMOUNT_FILESYSTEMS',
-    30: 'SET_DATETIME',
-    31: 'EXEC_IBOOT',
-    32: 'FINALIZE_NAND_EPOCH_UPDATE',
-    33: 'CHECK_INAPPR_BOOT_PARTITIONS',
-    34: 'CREATE_FACTORY_RESTORE_MARKER',
-    35: 'LOAD_FIRMWARE',
-    36: 'REQUESTING_FUD_DATA',
-    37: 'REMOVING_ACTIVATION_RECORD',
-    38: 'CHECK_BATTERY_VOLTAGE',
-    39: 'WAIT_BATTERY_CHARGE',
-    40: 'CLOSE_MODEM_TICKETS',
-    41: 'MIGRATE_DATA',
-    42: 'WIPE_STORAGE_DEVICE',
-    43: 'SEND_APPLE_LOGO',
-    44: 'CHECK_LOGS',
-    46: 'CLEAR_NVRAM',
-    47: 'UPDATE_GAS_GAUGE',
-    48: 'PREPARE_BASEBAND_UPDATE',
-    49: 'BOOT_BASEBAND',
-    50: 'CREATE_SYSTEM_KEYBAG',
-    51: 'UPDATE_IR_MCU_FIRMWARE',
-    52: 'RESIZE_SYSTEM_PARTITION',
-    53: 'COLLECTING_UPDATER_OUTPUT',
-    54: 'PAIR_STOCKHOLM',
-    55: 'UPDATE_STOCKHOLM',
-    56: 'UPDATE_SWDHID',
-    57: 'CERTIFY_SEP',
-    58: 'UPDATE_NAND_FIRMWARE',
-    59: 'UPDATE_SE_FIRMWARE',
-    60: 'UPDATE_SAVAGE',
-    61: 'INSTALLING_DEVICETREE',
-    62: 'CERTIFY_SAVAGE',
-    63: 'SUBMITTING_PROVINFO',
-    64: 'CERTIFY_YONKERS',
-    65: 'UPDATE_ROSE',
-    66: 'UPDATE_VERIDIAN',
-    67: 'CREATING_PROTECTED_VOLUME',
-    68: 'RESIZING_MAIN_FS_PARTITION',
-    69: 'CREATING_RECOVERY_OS_VOLUME',
-    70: 'INSTALLING_RECOVERY_OS_FILES',
-    71: 'INSTALLING_RECOVERY_OS_IMAGE',
-    74: 'REQUESTING_EAN_DATA',
-    77: 'SEALING_SYSTEM_VOLUME',
-    81: 'UPDATING_APPLETCON',
+    11: "CREATE_PARTITION_MAP",
+    12: "CREATE_FILESYSTEM",
+    13: "RESTORE_IMAGE",
+    14: "VERIFY_RESTORE",
+    15: "CHECK_FILESYSTEMS",
+    16: "MOUNT_FILESYSTEMS",
+    17: "FIXUP_VAR",
+    18: "FLASH_FIRMWARE",
+    19: "UPDATE_BASEBAND",
+    20: "SET_BOOT_STAGE",
+    21: "REBOOT_DEVICE",
+    22: "SHUTDOWN_DEVICE",
+    23: "TURN_ON_ACCESSORY_POWER",
+    24: "CLEAR_BOOTARGS",
+    25: "MODIFY_BOOTARGS",
+    26: "INSTALL_ROOT",
+    27: "INSTALL_KERNELCACHE",
+    28: "WAIT_FOR_NAND",
+    29: "UNMOUNT_FILESYSTEMS",
+    30: "SET_DATETIME",
+    31: "EXEC_IBOOT",
+    32: "FINALIZE_NAND_EPOCH_UPDATE",
+    33: "CHECK_INAPPR_BOOT_PARTITIONS",
+    34: "CREATE_FACTORY_RESTORE_MARKER",
+    35: "LOAD_FIRMWARE",
+    36: "REQUESTING_FUD_DATA",
+    37: "REMOVING_ACTIVATION_RECORD",
+    38: "CHECK_BATTERY_VOLTAGE",
+    39: "WAIT_BATTERY_CHARGE",
+    40: "CLOSE_MODEM_TICKETS",
+    41: "MIGRATE_DATA",
+    42: "WIPE_STORAGE_DEVICE",
+    43: "SEND_APPLE_LOGO",
+    44: "CHECK_LOGS",
+    46: "CLEAR_NVRAM",
+    47: "UPDATE_GAS_GAUGE",
+    48: "PREPARE_BASEBAND_UPDATE",
+    49: "BOOT_BASEBAND",
+    50: "CREATE_SYSTEM_KEYBAG",
+    51: "UPDATE_IR_MCU_FIRMWARE",
+    52: "RESIZE_SYSTEM_PARTITION",
+    53: "COLLECTING_UPDATER_OUTPUT",
+    54: "PAIR_STOCKHOLM",
+    55: "UPDATE_STOCKHOLM",
+    56: "UPDATE_SWDHID",
+    57: "CERTIFY_SEP",
+    58: "UPDATE_NAND_FIRMWARE",
+    59: "UPDATE_SE_FIRMWARE",
+    60: "UPDATE_SAVAGE",
+    61: "INSTALLING_DEVICETREE",
+    62: "CERTIFY_SAVAGE",
+    63: "SUBMITTING_PROVINFO",
+    64: "CERTIFY_YONKERS",
+    65: "UPDATE_ROSE",
+    66: "UPDATE_VERIDIAN",
+    67: "CREATING_PROTECTED_VOLUME",
+    68: "RESIZING_MAIN_FS_PARTITION",
+    69: "CREATING_RECOVERY_OS_VOLUME",
+    70: "INSTALLING_RECOVERY_OS_FILES",
+    71: "INSTALLING_RECOVERY_OS_IMAGE",
+    74: "REQUESTING_EAN_DATA",
+    77: "SEALING_SYSTEM_VOLUME",
+    81: "UPDATING_APPLETCON",
 }

pymobiledevice3/restore/device.py

@@ -14,10 +14,10 @@ class Device:
 
     def __repr__(self) -> str:
         return (
-            f'<{self.__class__.__name__} '
-            f'ecid: {self.ecid} '
-            f'hardware_model: {self.hardware_model} '
-            f'image4-support: {self.is_image4_supported}>'
+            f"<{self.__class__.__name__} "
+            f"ecid: {self.ecid} "
+            f"hardware_model: {self.hardware_model} "
+            f"image4-support: {self.is_image4_supported}>"
         )
 
     @cached_property
@@ -29,20 +29,20 @@ class Device:
     @cached_property
     def hardware_model(self):
         if self.lockdown:
-            return self.lockdown.all_values['HardwareModel'].lower()
+            return self.lockdown.all_values["HardwareModel"].lower()
         return self.irecv.hardware_model
 
     @cached_property
     def is_image4_supported(self):
         if self.lockdown:
-            return self.lockdown.get_value(key='Image4Supported')
+            return self.lockdown.get_value(key="Image4Supported")
         return self.irecv.is_image4_supported
 
     @cached_property
     def ap_parameters(self) -> dict:
         if self.lockdown:
             try:
-                return self.lockdown.get_value(key='ApParameters')
+                return self.lockdown.get_value(key="ApParameters")
             except MissingValueError:
                 pass
         return {}
@@ -50,19 +50,19 @@ class Device:
     @cached_property
     def ap_nonce(self):
         if self.lockdown:
-            ap_nonce_from_ap_parameters = self.ap_parameters.get('ApNonce')
+            ap_nonce_from_ap_parameters = self.ap_parameters.get("ApNonce")
             if ap_nonce_from_ap_parameters:
                 return ap_nonce_from_ap_parameters
-            return self.lockdown.get_value(key='ApNonce')
+            return self.lockdown.get_value(key="ApNonce")
         return self.irecv.ap_nonce
 
     @cached_property
     def sep_nonce(self):
         if self.lockdown:
-            sep_nonce_from_ap_parameters = self.ap_parameters.get('SepNonce')
+            sep_nonce_from_ap_parameters = self.ap_parameters.get("SepNonce")
             if sep_nonce_from_ap_parameters:
                 return sep_nonce_from_ap_parameters
-            return self.lockdown.get_value(key='SEPNonce')
+            return self.lockdown.get_value(key="SEPNonce")
         return self.irecv.sep_nonce
 
     @cached_property