pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/restore/base_restore.py

@@ -9,31 +9,33 @@ from ipsw_parser.ipsw import IPSW
 
 from pymobiledevice3.exceptions import PyMobileDevice3Exception
 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,
@@ -41,33 +43,120 @@ 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__}')
+        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"]
+        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",
+            ]
+        else:
+            key_list += additional_keys
+
+        for k in key_list:
+            try:
+                v = self.build_identity[k]
+                if isinstance(v, str) and v.startswith("0x"):
+                    v = int(v, 16)
+                parameters[k] = v
+            except KeyError:
+                pass
+
+        if additional_keys is None:
+            # special treat for RequiresUIDMode
+            info = self.build_identity.get("Info")
+            if info is None:
+                return
+            requires_uid_mode = info.get("RequiresUIDMode")
+            if requires_uid_mode is not None:
+                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

@@ -1,5 +1,6 @@
 from contextlib import suppress
 from functools import cached_property
+from typing import Optional, overload
 
 from pymobiledevice3.exceptions import MissingValueError
 from pymobiledevice3.irecv import IRecv
@@ -7,18 +8,42 @@ from pymobiledevice3.lockdown import LockdownClient
 
 
 class Device:
-    def __init__(self, lockdown: LockdownClient = None, irecv: IRecv = None):
-        self.lockdown = lockdown
-        self.irecv = irecv
+    @overload
+    def __init__(self, lockdown: LockdownClient, irecv: None = None) -> None: ...
+
+    @overload
+    def __init__(self, lockdown: None = None, *, irecv: IRecv) -> None: ...
+
+    def __init__(self, lockdown: Optional[LockdownClient] = None, irecv: Optional[IRecv] = None) -> None:
+        self._lockdown: Optional[LockdownClient] = lockdown
+        self._irecv: Optional[IRecv] = irecv
 
     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
+    def is_lockdown(self) -> bool:
+        return self._lockdown is not None
+
+    @cached_property
+    def is_irecv(self) -> bool:
+        return self._irecv is not None
+
+    @cached_property
+    def lockdown(self) -> LockdownClient:
+        assert self._lockdown is not None
+        return self._lockdown
+
+    @cached_property
+    def irecv(self) -> IRecv:
+        assert self._irecv is not None
+        return self._irecv
+
     @cached_property
     def ecid(self):
         if self.lockdown:
@@ -28,34 +53,56 @@ 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")
+            except MissingValueError:
+                pass
+        return {}
+
     @cached_property
     def ap_nonce(self):
         if self.lockdown:
-            return self.lockdown.get_value(key='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.irecv.ap_nonce
 
     @cached_property
     def sep_nonce(self):
         if self.lockdown:
-            return self.lockdown.get_value(key='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.irecv.sep_nonce
 
     @cached_property
-    def preflight_info(self):
+    def preflight_info(self) -> Optional[dict]:
         if self.lockdown:
             with suppress(MissingValueError):
                 return self.lockdown.preflight_info
         return None
 
+    @cached_property
+    def firmware_preflight_info(self) -> Optional[dict]:
+        if self.lockdown:
+            with suppress(MissingValueError):
+                return self.lockdown.firmware_preflight_info
+        return None
+
     @cached_property
     def product_type(self) -> str:
         if self.lockdown: