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

pymobiledevice3/remote/utils.py

@@ -9,11 +9,12 @@ from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remoted
 from pymobiledevice3.exceptions import AccessDeniedError
 from pymobiledevice3.remote.remote_service_discovery import RSD_PORT, RemoteServiceDiscoveryService
 
-REMOTED_PATH = '/usr/libexec/remoted'
+REMOTED_PATH = "/usr/libexec/remoted"
 
 
-async def get_rsds(bonjour_timeout: float = DEFAULT_BONJOUR_TIMEOUT, udid: Optional[str] = None) -> \
-        list[RemoteServiceDiscoveryService]:
+async def get_rsds(
+    bonjour_timeout: float = DEFAULT_BONJOUR_TIMEOUT, udid: Optional[str] = None
+) -> list[RemoteServiceDiscoveryService]:
     result = []
     with stop_remoted():
         for answer in await browse_remoted(timeout=bonjour_timeout):
@@ -45,39 +46,39 @@ def get_remoted_process() -> psutil.Process:
 
 
 def stop_remoted_if_required() -> None:
-    if platform.system() != 'Darwin':
+    if platform.system() != "Darwin":
         # only Darwin systems require it
         return
 
     remoted = get_remoted_process()
     if remoted is None:
         return
-    if remoted.status() == 'stopped':
+    if remoted.status() == "stopped":
         # process already stopped, we don't need to do anything
         return
 
     try:
         remoted.suspend()
-    except psutil.AccessDenied:
-        raise AccessDeniedError()
+    except psutil.AccessDenied as e:
+        raise AccessDeniedError() from e
 
 
 def resume_remoted_if_required() -> None:
-    if platform.system() != 'Darwin':
+    if platform.system() != "Darwin":
         # only Darwin systems require it
         return
 
     remoted = get_remoted_process()
     if remoted is None:
         return
-    if remoted.status() == 'running':
+    if remoted.status() == "running":
         # process already running, we don't need to do anything
         return
 
     try:
         remoted.resume()
-    except psutil.AccessDenied:
-        raise AccessDeniedError()
+    except psutil.AccessDenied as e:
+        raise AccessDeniedError() from e
 
 
 @contextlib.contextmanager

pymobiledevice3/remote/xpc_message.py

@@ -3,50 +3,74 @@ import uuid
 from datetime import datetime
 from typing import Any
 
-from construct import Aligned, Array, Bytes, Const, CString, Default, Double, Enum, ExprAdapter, FlagsEnum, \
-    GreedyBytes, Hex, If, Int32ul, Int64sl, Int64ul, LazyBound
+from construct import (
+    Aligned,
+    Array,
+    Bytes,
+    Const,
+    CString,
+    Default,
+    Double,
+    Enum,
+    ExprAdapter,
+    FlagsEnum,
+    GreedyBytes,
+    Hex,
+    If,
+    Int32ul,
+    Int64sl,
+    Int64ul,
+    LazyBound,
+    Pass,
+    Prefixed,
+    Probe,
+    Struct,
+    Switch,
+    this,
+)
 from construct import Optional as ConstructOptional
-from construct import Pass, Prefixed, Probe, Struct, Switch, this
-
-XpcMessageType = Enum(Hex(Int32ul),
-                      NULL=0x00001000,
-                      BOOL=0x00002000,
-                      INT64=0x00003000,
-                      UINT64=0x00004000,
-                      DOUBLE=0x00005000,
-                      POINTER=0x00006000,
-                      DATE=0x00007000,
-                      DATA=0x00008000,
-                      STRING=0x00009000,
-                      UUID=0x0000a000,
-                      FD=0x0000b000,
-                      SHMEM=0x0000c000,
-                      MACH_SEND=0x0000d000,
-                      ARRAY=0x0000e000,
-                      DICTIONARY=0x0000f000,
-                      ERROR=0x00010000,
-                      CONNECTION=0x00011000,
-                      ENDPOINT=0x00012000,
-                      SERIALIZER=0x00013000,
-                      PIPE=0x00014000,
-                      MACH_RECV=0x00015000,
-                      BUNDLE=0x00016000,
-                      SERVICE=0x00017000,
-                      SERVICE_INSTANCE=0x00018000,
-                      ACTIVITY=0x00019000,
-                      FILE_TRANSFER=0x0001a000,
-                      )
-XpcFlags = FlagsEnum(Hex(Int32ul),
-                     ALWAYS_SET=0x00000001,
-                     PING=0x00000002,
-                     DATA_PRESENT=0x00000100,
-                     WANTING_REPLY=0x00010000,
-                     REPLY=0x00020000,
-                     FILE_TX_STREAM_REQUEST=0x00100000,
-                     FILE_TX_STREAM_RESPONSE=0x00200000,
-                     INIT_HANDSHAKE=0x00400000,
-                     )
-AlignedString = Aligned(4, CString('utf8'))
+
+XpcMessageType = Enum(
+    Hex(Int32ul),
+    NULL=0x00001000,
+    BOOL=0x00002000,
+    INT64=0x00003000,
+    UINT64=0x00004000,
+    DOUBLE=0x00005000,
+    POINTER=0x00006000,
+    DATE=0x00007000,
+    DATA=0x00008000,
+    STRING=0x00009000,
+    UUID=0x0000A000,
+    FD=0x0000B000,
+    SHMEM=0x0000C000,
+    MACH_SEND=0x0000D000,
+    ARRAY=0x0000E000,
+    DICTIONARY=0x0000F000,
+    ERROR=0x00010000,
+    CONNECTION=0x00011000,
+    ENDPOINT=0x00012000,
+    SERIALIZER=0x00013000,
+    PIPE=0x00014000,
+    MACH_RECV=0x00015000,
+    BUNDLE=0x00016000,
+    SERVICE=0x00017000,
+    SERVICE_INSTANCE=0x00018000,
+    ACTIVITY=0x00019000,
+    FILE_TRANSFER=0x0001A000,
+)
+XpcFlags = FlagsEnum(
+    Hex(Int32ul),
+    ALWAYS_SET=0x00000001,
+    PING=0x00000002,
+    DATA_PRESENT=0x00000100,
+    WANTING_REPLY=0x00010000,
+    REPLY=0x00020000,
+    FILE_TX_STREAM_REQUEST=0x00100000,
+    FILE_TX_STREAM_RESPONSE=0x00200000,
+    INIT_HANDSHAKE=0x00400000,
+)
+AlignedString = Aligned(4, CString("utf8"))
 XpcNull = Pass
 XpcBool = Int32ul
 XpcInt64 = Int64sl
@@ -55,59 +79,67 @@ XpcDouble = Double
 XpcPointer = None
 XpcDate = Int64ul
 XpcData = Aligned(4, Prefixed(Int32ul, GreedyBytes))
-XpcString = Aligned(4, Prefixed(Int32ul, CString('utf8')))
+XpcString = Aligned(4, Prefixed(Int32ul, CString("utf8")))
 XpcUuid = Bytes(16)
 XpcFd = Int32ul
-XpcShmem = Struct('length' / Int32ul, Int32ul)
-XpcArray = Prefixed(Int32ul, Struct(
-    'count' / Int32ul,
-    'entries' / Array(this.count, LazyBound(lambda: XpcObject))))
+XpcShmem = Struct("length" / Int32ul, Int32ul)
+XpcArray = Prefixed(Int32ul, Struct("count" / Int32ul, "entries" / Array(this.count, LazyBound(lambda: XpcObject))))
 XpcDictionaryEntry = Struct(
-    'key' / AlignedString,
-    'value' / LazyBound(lambda: XpcObject),
+    "key" / AlignedString,
+    "value" / LazyBound(lambda: XpcObject),
+)
+XpcDictionary = Prefixed(
+    Int32ul,
+    Struct(
+        "count" / Hex(Int32ul),
+        "entries" / If(this.count > 0, Array(this.count, XpcDictionaryEntry)),
+    ),
 )
-XpcDictionary = Prefixed(Int32ul, Struct(
-    'count' / Hex(Int32ul),
-    'entries' / If(this.count > 0, Array(this.count, XpcDictionaryEntry)),
-))
 XpcFileTransfer = Struct(
-    'msg_id' / Int64ul,
-    'data' / LazyBound(lambda: XpcObject),
+    "msg_id" / Int64ul,
+    "data" / LazyBound(lambda: XpcObject),
 )
 XpcObject = Struct(
-    'type' / XpcMessageType,
-    'data' / Switch(this.type, {
-        XpcMessageType.DICTIONARY: XpcDictionary,
-        XpcMessageType.STRING: XpcString,
-        XpcMessageType.INT64: XpcInt64,
-        XpcMessageType.UINT64: XpcUInt64,
-        XpcMessageType.DOUBLE: XpcDouble,
-        XpcMessageType.BOOL: XpcBool,
-        XpcMessageType.NULL: XpcNull,
-        XpcMessageType.UUID: XpcUuid,
-        XpcMessageType.POINTER: XpcPointer,
-        XpcMessageType.DATE: XpcDate,
-        XpcMessageType.DATA: XpcData,
-        XpcMessageType.FD: XpcFd,
-        XpcMessageType.SHMEM: XpcShmem,
-        XpcMessageType.ARRAY: XpcArray,
-        XpcMessageType.FILE_TRANSFER: XpcFileTransfer,
-    }, default=Probe(lookahead=1000)),
+    "type" / XpcMessageType,
+    "data"
+    / Switch(
+        this.type,
+        {
+            XpcMessageType.DICTIONARY: XpcDictionary,
+            XpcMessageType.STRING: XpcString,
+            XpcMessageType.INT64: XpcInt64,
+            XpcMessageType.UINT64: XpcUInt64,
+            XpcMessageType.DOUBLE: XpcDouble,
+            XpcMessageType.BOOL: XpcBool,
+            XpcMessageType.NULL: XpcNull,
+            XpcMessageType.UUID: XpcUuid,
+            XpcMessageType.POINTER: XpcPointer,
+            XpcMessageType.DATE: XpcDate,
+            XpcMessageType.DATA: XpcData,
+            XpcMessageType.FD: XpcFd,
+            XpcMessageType.SHMEM: XpcShmem,
+            XpcMessageType.ARRAY: XpcArray,
+            XpcMessageType.FILE_TRANSFER: XpcFileTransfer,
+        },
+        default=Probe(lookahead=1000),
+    ),
 )
 XpcPayload = Struct(
-    'magic' / Hex(Const(0x42133742, Int32ul)),
-    'protocol_version' / Hex(Const(0x00000005, Int32ul)),
-    'obj' / XpcObject,
+    "magic" / Hex(Const(0x42133742, Int32ul)),
+    "protocol_version" / Hex(Const(0x00000005, Int32ul)),
+    "obj" / XpcObject,
 )
 XpcWrapper = Struct(
-    'magic' / Hex(Const(0x29b00b92, Int32ul)),
-    'flags' / Default(XpcFlags, XpcFlags.ALWAYS_SET),
-    'message' / Prefixed(
+    "magic" / Hex(Const(0x29B00B92, Int32ul)),
+    "flags" / Default(XpcFlags, XpcFlags.ALWAYS_SET),
+    "message"
+    / Prefixed(
         ExprAdapter(Int64ul, lambda obj, context: obj + 8, lambda obj, context: obj - 8),
         Struct(
-            'message_id' / Hex(Default(Int64ul, 0)),
-            'payload' / ConstructOptional(XpcPayload),
-        ))
+            "message_id" / Hex(Default(Int64ul, 0)),
+            "payload" / ConstructOptional(XpcPayload),
+        ),
+    ),
 )
 
 
@@ -170,7 +202,7 @@ def _decode_xpc_date(xpc_object) -> datetime:
 
 
 def _decode_xpc_file_transfer(xpc_object) -> FileTransferType:
-    return FileTransferType(transfer_size=_decode_xpc_dictionary(xpc_object.data.data)['s'])
+    return FileTransferType(transfer_size=_decode_xpc_dictionary(xpc_object.data.data)["s"])
 
 
 def _decode_xpc_double(xpc_object) -> float:
@@ -198,7 +230,7 @@ def decode_xpc_object(xpc_object) -> Any:
     }
     decoder = decoders.get(xpc_object.type)
     if decoder is None:
-        raise TypeError(f'deserialize error: {xpc_object}')
+        raise TypeError(f"deserialize error: {xpc_object}")
     return decoder(xpc_object)
 
 
@@ -207,82 +239,76 @@ def _build_xpc_array(payload: list) -> dict:
     for entry in payload:
         entry = _build_xpc_object(entry)
         entries.append(entry)
-    return {
-        'type': XpcMessageType.ARRAY,
-        'data': {
-            'count': len(entries),
-            'entries': entries
-        }
-    }
+    return {"type": XpcMessageType.ARRAY, "data": {"count": len(entries), "entries": entries}}
 
 
 def _build_xpc_dictionary(payload: dict) -> dict:
     entries = []
     for key, value in payload.items():
-        entry = {'key': key, 'value': _build_xpc_object(value)}
+        entry = {"key": key, "value": _build_xpc_object(value)}
         entries.append(entry)
     return {
-        'type': XpcMessageType.DICTIONARY,
-        'data': {
-            'count': len(entries),
-            'entries': entries,
-        }
+        "type": XpcMessageType.DICTIONARY,
+        "data": {
+            "count": len(entries),
+            "entries": entries,
+        },
     }
 
 
 def _build_xpc_bool(payload: bool) -> dict:
     return {
-        'type': XpcMessageType.BOOL,
-        'data': payload,
+        "type": XpcMessageType.BOOL,
+        "data": payload,
     }
 
 
 def _build_xpc_string(payload: str) -> dict:
     return {
-        'type': XpcMessageType.STRING,
-        'data': payload,
+        "type": XpcMessageType.STRING,
+        "data": payload,
     }
 
 
 def _build_xpc_data(payload: bool) -> dict:
     return {
-        'type': XpcMessageType.DATA,
-        'data': payload,
+        "type": XpcMessageType.DATA,
+        "data": payload,
     }
 
 
 def _build_xpc_double(payload: float) -> dict:
     return {
-        'type': XpcMessageType.DOUBLE,
-        'data': payload,
+        "type": XpcMessageType.DOUBLE,
+        "data": payload,
     }
 
 
 def _build_xpc_uuid(payload: uuid.UUID) -> dict:
     return {
-        'type': XpcMessageType.UUID,
-        'data': payload.bytes,
+        "type": XpcMessageType.UUID,
+        "data": payload.bytes,
     }
 
 
 def _build_xpc_null(payload: None) -> dict:
     return {
-        'type': XpcMessageType.NULL,
-        'data': None,
+        "type": XpcMessageType.NULL,
+        "data": None,
     }
 
 
 def _build_xpc_uint64(payload: XpcUInt64Type) -> dict:
     return {
-        'type': XpcMessageType.UINT64,
-        'data': payload,
+        "type": XpcMessageType.UINT64,
+        "data": payload,
     }
 
 
 def _build_xpc_int64(payload: XpcInt64Type) -> dict:
     return {
-        'type': XpcMessageType.INT64,
-        'data': payload,
+        "type": XpcMessageType.INT64,
+        "data": payload,
     }
 
 
@@ -298,12 +324,12 @@ def _build_xpc_object(payload: Any) -> dict:
         bytearray: _build_xpc_data,
         float: _build_xpc_double,
         uuid.UUID: _build_xpc_uuid,
-        'XpcUInt64Type': _build_xpc_uint64,
-        'XpcInt64Type': _build_xpc_int64,
+        "XpcUInt64Type": _build_xpc_uint64,
+        "XpcInt64Type": _build_xpc_int64,
     }
     builder = payload_builders.get(type(payload), payload_builders.get(type(payload).__name__))
     if builder is None:
-        raise TypeError(f'unrecognized type for: {payload} {type(payload)}')
+        raise TypeError(f"unrecognized type for: {payload} {type(payload)}")
     return builder(payload)
 
 
@@ -314,13 +340,7 @@ def create_xpc_wrapper(d: dict, message_id: int = 0, wanting_reply: bool = False
     if wanting_reply:
         flags |= XpcFlags.WANTING_REPLY
 
-    xpc_payload = {
-        'message_id': message_id,
-        'payload': {'obj': _build_xpc_object(d)}
-    }
+    xpc_payload = {"message_id": message_id, "payload": {"obj": _build_xpc_object(d)}}
 
-    xpc_wrapper = {
-        'flags': flags,
-        'message': xpc_payload
-    }
+    xpc_wrapper = {"flags": flags, "message": xpc_payload}
     return XpcWrapper.build(xpc_wrapper)

pymobiledevice3/resources/dsc_uuid_map.py

@@ -6,10 +6,10 @@ from uuid import UUID
 import click
 import coloredlogs
 
-MAGIC = b'\x0b\x10\x00\x00'
-DYLD_MAGIC = b'dyld_v1'
-MAP_FILENAME = os.path.join(os.path.dirname(__file__), 'dsc_uuid_map.json')
-PARTITIONS = ('/System', '/usr', '/Applications', '/private')
+MAGIC = b"\x0b\x10\x00\x00"
+DYLD_MAGIC = b"dyld_v1"
+MAP_FILENAME = os.path.join(os.path.dirname(__file__), "dsc_uuid_map.json")
+PARTITIONS = ("/System", "/usr", "/Applications", "/private")
 DYLD_UUID_OFFSET = 0x58
 UUID_SIZE = 0x10
 
@@ -34,9 +34,9 @@ def sanitize_path(path):
 
 
 @click.command()
-@click.argument('dyld_uuid', type=click.UUID)
-@click.argument('dsc', type=click.File('rb'))
-@click.option('-f', '--force', is_flag=True)
+@click.argument("dyld_uuid", type=click.UUID)
+@click.argument("dsc", type=click.File("rb"))
+@click.option("-f", "--force", is_flag=True)
 def main(dsc, dyld_uuid, force):
     """
     Simple utility to get all UUIDs used for symbolication from given DSC.
@@ -48,23 +48,23 @@ def main(dsc, dyld_uuid, force):
     dsc = dsc.read()
 
     if not dsc.startswith(DYLD_MAGIC):
-        logging.error('invalid dsc file')
+        logging.error("invalid dsc file")
         return
 
-    dsc_uuid = str(UUID(bytes=dsc[DYLD_UUID_OFFSET:DYLD_UUID_OFFSET + UUID_SIZE]))
+    dsc_uuid = str(UUID(bytes=dsc[DYLD_UUID_OFFSET : DYLD_UUID_OFFSET + UUID_SIZE]))
 
     if dsc_uuid in uuid_map:
-        logger.warning(f'dsc {dsc_uuid} is already found in dsc_uuid_map')
+        logger.warning(f"dsc {dsc_uuid} is already found in dsc_uuid_map")
         if not force:
-            logger.info('exiting. use --force to force update')
+            logger.info("exiting. use --force to force update")
             return
     else:
-        uuid_map[dsc_uuid] = {str(dyld_uuid): '/usr/lib/dyld'}
+        uuid_map[dsc_uuid] = {str(dyld_uuid): "/usr/lib/dyld"}
 
     for i in range(0, len(dsc) - 4, 4):
         # we can assume MAGIC is always aligned to 4
 
-        if dsc[i:i + 4] != MAGIC:
+        if dsc[i : i + 4] != MAGIC:
             continue
 
         # skip NULLs for filename pad
@@ -73,29 +73,29 @@ def main(dsc, dyld_uuid, force):
             j -= 1
 
         # read filename backwards
-        filename = ''
+        filename = ""
         c = chr(dsc[j])
         while c.isprintable():
             filename = c + filename
             j -= 1
             c = chr(dsc[j])
 
-        if '/' not in filename:
+        if "/" not in filename:
             continue
 
         filename = sanitize_path(filename)
 
         # read uuid
-        uuid = UUID(bytes=dsc[i + 4:i + 4 + UUID_SIZE])
+        uuid = UUID(bytes=dsc[i + 4 : i + 4 + UUID_SIZE])
 
-        logging.info(f'offset: 0x{i:x} image: {filename} uuid: {uuid}')
+        logging.info(f"offset: 0x{i:x} image: {filename} uuid: {uuid}")
 
         uuid_map[dsc_uuid][str(uuid)] = filename
 
-    with open(MAP_FILENAME, 'w') as f:
+    with open(MAP_FILENAME, "w") as f:
         json.dump(uuid_map, f, indent=4)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     coloredlogs.install(level=logging.DEBUG)
     main()

pymobiledevice3/resources/firmware_notifications.py

@@ -5,61 +5,61 @@ import plistlib
 import click
 import coloredlogs
 
-NOTIFICATIONS_FILENAME = os.path.join(os.path.dirname(__file__), 'notifications.txt')
+NOTIFICATIONS_FILENAME = os.path.join(os.path.dirname(__file__), "notifications.txt")
 
 
 def get_notifications():
-    with open(NOTIFICATIONS_FILENAME, 'rb') as f:
-        return f.read().decode().split('\n')
+    with open(NOTIFICATIONS_FILENAME, "rb") as f:
+        return f.read().decode().split("\n")
 
 
 def save_notifications(notifications: list[str]):
-    with open(NOTIFICATIONS_FILENAME, 'wb') as f:
+    with open(NOTIFICATIONS_FILENAME, "wb") as f:
         notifications.sort()
-        f.write('\n'.join(notifications).encode())
+        f.write("\n".join(notifications).encode())
 
 
 @click.command()
-@click.argument('root_fs', type=click.Path(dir_okay=True, file_okay=False, exists=True))
+@click.argument("root_fs", type=click.Path(dir_okay=True, file_okay=False, exists=True))
 def main(root_fs):
     """
     Add notifications registered to `com.apple.notifyd.matching` from a given IPSW `root_fs` (extracted filesystem)
     into `notifications.txt`
     """
-    launch_daemons = os.path.join(root_fs, 'System', 'Library', 'LaunchDaemons')
+    launch_daemons = os.path.join(root_fs, "System", "Library", "LaunchDaemons")
 
     notifications = set(get_notifications())
 
     for filename in os.listdir(launch_daemons):
-        if not filename.endswith('.plist'):
+        if not filename.endswith(".plist"):
             continue
 
         filename = os.path.join(launch_daemons, filename)
         try:
-            with open(filename, 'rb') as f:
+            with open(filename, "rb") as f:
                 plist = plistlib.load(f)
         except Exception:
-            logging.exception(f'error parsing: {filename}')
+            logging.exception(f"error parsing: {filename}")
             continue
 
-        launch_events = plist.get('LaunchEvents', {})
-        notifyd_matching = launch_events.get('com.apple.notifyd.matching', {})
+        launch_events = plist.get("LaunchEvents", {})
+        notifyd_matching = launch_events.get("com.apple.notifyd.matching", {})
 
         for v in notifyd_matching.values():
             if not isinstance(v, dict):
-                logging.error(f'error parsing: {filename}')
+                logging.error(f"error parsing: {filename}")
                 continue
-            notification = v.get('Notification')
+            notification = v.get("Notification")
             if notification is None:
                 continue
 
             if notification not in notifications:
-                logging.info(f'adding notification: {notification}')
+                logging.info(f"adding notification: {notification}")
                 notifications.add(notification)
 
     save_notifications(list(notifications))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     coloredlogs.install(level=logging.DEBUG)
     main()