pymobiledevice3 4.27.7__tar.gz → 6.1.4__tar.gz

pymobiledevice3-6.1.4/.github/workflows/generate-executable.py

@@ -0,0 +1,67 @@
+import logging
+import os
+import site
+import sys
+from pathlib import Path
+
+import coloredlogs
+import PyInstaller.__main__
+
+import pymobiledevice3.__main__
+import pymobiledevice3.cli
+import pymobiledevice3.resources
+
+coloredlogs.install(level=logging.DEBUG)
+
+ROOT = Path(__file__).parent.parent.parent
+DEFAULT_OUTPUT = ROOT / Path("dist/__main__").with_suffix(".exe" if sys.platform == "win32" else "")
+OUTPUT = (ROOT / "dist/pymobiledevice3").with_suffix(".exe" if sys.platform == "win32" else "")
+
+
+def main() -> None:
+    site_packages_path = site.getsitepackages()[0]
+    resources_dir = Path(pymobiledevice3.resources.__file__).parent
+    pymobiledevice3_cli_path = Path(pymobiledevice3.cli.__file__).parent
+
+    hidden_imports = []
+
+    for module in pymobiledevice3_cli_path.iterdir():
+        if module.name.endswith(".py") and module.name != "__init__.py":  # Avoid including the __init__.py
+            # Create the module name to be added to hidden imports
+            module_name = "pymobiledevice3.cli." + os.path.splitext(module.name)[0]
+            hidden_imports.append("--hidden-import=" + module_name)
+
+    pyinstaller_args = [
+        pymobiledevice3.__main__.__file__,
+        "--hidden-import=ipsw_parser",
+        "--hidden-import=zeroconf",
+        "--hidden-import=pyimg4",
+        "--hidden-import=zeroconf._utils.ipaddress",
+        "--hidden-import=zeroconf._handlers.answers",
+        "--hidden-import=readchar",
+        "--copy-metadata=pyimg4",
+        "--copy-metadata=readchar",
+        "--copy-metadata=apple_compress",
+        "--onefile",
+    ]
+    if sys.platform == "win32":
+        pyinstaller_args.extend([
+            "--add-binary",
+            f"{site_packages_path}/Lib/site-packages/pytun_pmd3/wintun/*;pytun_pmd3/wintun/bin",
+            "--add-binary",
+            f"{resources_dir}/webinspector;pymobiledevice3/resources/webinspector",
+        ])
+    else:
+        pyinstaller_args.extend([
+            "--add-binary",
+            f"{site_packages_path}/pytun_pmd3:pytun_pmd3",
+            "--add-binary",
+            f"{resources_dir}/webinspector:pymobiledevice3/resources/webinspector",
+        ])
+    pyinstaller_args.extend(hidden_imports)
+    PyInstaller.__main__.run(pyinstaller_args)
+    DEFAULT_OUTPUT.rename(OUTPUT)
+
+
+if __name__ == "__main__":
+    main()

pymobiledevice3-6.1.4/.github/workflows/python-publish.yml

@@ -0,0 +1,27 @@
+# This workflow builds and uploads the Python package to PyPI when a release is created
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [ created ]
+
+jobs:
+  deploy:
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+      - name: Build distributions
+        run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

pymobiledevice3-6.1.4/.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.14.2
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+    # Run the formatter.
+    - id: ruff-format

{pymobiledevice3-4.27.7 → pymobiledevice3-6.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.7
+Version: 6.1.4
 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>
@@ -46,8 +46,7 @@ Requires-Dist: wsproto
 Requires-Dist: nest_asyncio>=1.5.5
 Requires-Dist: Pillow
 Requires-Dist: inquirer3>=0.6.0
-Requires-Dist: ipsw_parser>=1.3.4
-Requires-Dist: zeroconf>=0.132.2
+Requires-Dist: ipsw_parser>=1.5.0
 Requires-Dist: ifaddr
 Requires-Dist: hyperframe
 Requires-Dist: srptools

{pymobiledevice3-4.27.7 → pymobiledevice3-6.1.4}/misc/plist_sniffer.py

@@ -7,8 +7,8 @@ import click
 from scapy.packet import Packet, Raw
 from scapy.sendrecv import sniff
 
-BPLIST_MAGIC = b'bplist'
-PLIST_MAGIC = b'<plist'
+BPLIST_MAGIC = b"bplist"
+PLIST_MAGIC = b"<plist"
 
 
 class PcapSniffer:
@@ -20,13 +20,13 @@ class PcapSniffer:
 
         if BPLIST_MAGIC in packet:
             try:
-                plist = plistlib.loads(packet[packet.find(BPLIST_MAGIC):])
+                plist = plistlib.loads(packet[packet.find(BPLIST_MAGIC) :])
                 self.report(plist)
             except plistlib.InvalidFileException:
                 pass
         if PLIST_MAGIC in packet:
             try:
-                plist = plistlib.loads(packet[packet.find(PLIST_MAGIC):])
+                plist = plistlib.loads(packet[packet.find(PLIST_MAGIC) :])
                 self.report(plist)
             except xml.parsers.expat.ExpatError:
                 pass
@@ -35,37 +35,37 @@ class PcapSniffer:
         try:
             print(plist)
             if self.file is not None:
-                self.file.write('---\n')
+                self.file.write("---\n")
                 self.file.write(pprint.pformat(plist))
-                self.file.write('\n---\n')
+                self.file.write("\n---\n")
         except ValueError:
-            print('failed to print plist')
+            print("failed to print plist")
 
 
 @click.group()
 def cli():
-    """ Parse RemoteXPC traffic """
+    """Parse RemoteXPC traffic"""
     pass
 
 
 @cli.command()
-@click.argument('pcap', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.option('-o', '--out', type=click.File('wt'))
+@click.argument("pcap", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.option("-o", "--out", type=click.File("wt"))
 def offline(pcap: str, out: IO):
-    """ Parse plists traffic from a .pcap file """
+    """Parse plists traffic from a .pcap file"""
     sniffer = PcapSniffer(out)
     for p in sniff(offline=pcap):
         sniffer.process_packet(p)
 
 
 @cli.command()
-@click.argument('iface')
-@click.option('-o', '--out', type=click.File('wt'))
+@click.argument("iface")
+@click.option("-o", "--out", type=click.File("wt"))
 def live(iface: str, out: IO):
-    """ Parse plists live from a given network interface """
+    """Parse plists live from a given network interface"""
     sniffer = PcapSniffer(out)
     sniff(iface=iface, prn=sniffer.process_packet)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     cli()

{pymobiledevice3-4.27.7 → pymobiledevice3-6.1.4}/misc/remotexpc_sniffer.py

@@ -22,7 +22,7 @@ FRAME_HEADER_SIZE = 9
 
 
 def create_stream_key(src: str, sport: int, dst: str, dport: int) -> str:
-    return f'{src}/{sport}//{dst}/{dport}'
+    return f"{src}/{sport}//{dst}/{dport}"
 
 
 class TCPStream:
@@ -37,7 +37,7 @@ class TCPStream:
         self.segments = {}  # data segments to add later
 
     def __repr__(self) -> str:
-        return f'Stream<{self.key}>'
+        return f"Stream<{self.key}>"
 
     def __len__(self) -> int:
         return len(self.data)
@@ -58,12 +58,12 @@ class TCPStream:
             return False
         else:
             # if this data is in order (has a place to be inserted)
-            self.data[seq_offset:seq_offset + data_len] = data
+            self.data[seq_offset : seq_offset + data_len] = data
             # check if there are any waiting data segments to add
             for seq_offset in sorted(self.segments.keys()):
                 if seq_offset <= len(self.data):  # if we can add this segment to the stream
                     segment_payload = self.segments[seq_offset]
-                    self.data[seq_offset:seq_offset + len(segment_payload)] = segment_payload
+                    self.data[seq_offset : seq_offset + len(segment_payload)] = segment_payload
                     self.segments.pop(seq_offset)
                 else:
                     break  # short circuit because list is sorted
@@ -72,12 +72,12 @@ class TCPStream:
 
 class H2Stream(TCPStream):
     def pop_frames(self) -> list[Frame]:
-        """ Pop all available H2Frames """
+        """Pop all available H2Frames"""
 
         # If self.data starts with the http/2 magic bytes, pop them off
         if self.data.startswith(HTTP2_MAGIC):
-            logger.debug('HTTP/2 magic bytes')
-            self.data = self.data[len(HTTP2_MAGIC):]
+            logger.debug("HTTP/2 magic bytes")
+            self.data = self.data[len(HTTP2_MAGIC) :]
             self.seq += len(HTTP2_MAGIC)
 
         frames = []
@@ -120,13 +120,14 @@ class RemoteXPCSniffer:
         tcp_pkt = pkt[TCP]
         stream_key = create_stream_key(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport)
         stream = self._h2_streams.setdefault(
-            stream_key, H2Stream(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport))
+            stream_key, H2Stream(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport)
+        )
         stream_finished_assembling = stream.add(tcp_pkt)
         if stream_finished_assembling:  # if we just added something in order
             self._process_stream(stream)
 
     def _handle_data_frame(self, stream: H2Stream, frame: DataFrame) -> None:
-        previous_frame_data = self._previous_frame_data.get(stream.key, b'')
+        previous_frame_data = self._previous_frame_data.get(stream.key, b"")
         try:
             payload = XpcWrapper.parse(previous_frame_data + frame.data).message.payload
             if payload is None:
@@ -134,10 +135,11 @@ class RemoteXPCSniffer:
             xpc_message = decode_xpc_object(payload.obj)
         except ConstError:  # if we don't know what this payload is
             logger.debug(
-                f'New Data frame {stream.src}->{stream.dst} on HTTP/2 stream {frame.stream_id} TCP port {stream.dport}')
+                f"New Data frame {stream.src}->{stream.dst} on HTTP/2 stream {frame.stream_id} TCP port {stream.dport}"
+            )
             hexdump(frame.data[:64])
             if len(frame.data) > 64:
-                logger.debug(f'... {len(frame.data)} bytes')
+                logger.debug(f"... {len(frame.data)} bytes")
             return
         except StreamError:
             self._previous_frame_data[stream.key] = previous_frame_data + frame.data
@@ -149,27 +151,26 @@ class RemoteXPCSniffer:
         if xpc_message is None:
             return
 
-        logger.info(f'As Python Object (#{frame.stream_id}): {pformat(xpc_message)}')
+        logger.info(f"As Python Object (#{frame.stream_id}): {pformat(xpc_message)}")
 
         # print `pairingData` if exists, since it contains an inner struct
-        if 'value' not in xpc_message:
+        if "value" not in xpc_message:
             return
-        message = xpc_message['value']['message']
-        if 'plain' not in message:
+        message = xpc_message["value"]["message"]
+        if "plain" not in message:
             return
-        plain = message['plain']['_0']
-        if 'event' not in plain:
+        plain = message["plain"]["_0"]
+        if "event" not in plain:
             return
-        pairing_data = plain['event']['_0']['pairingData']['_0']['data']
+        pairing_data = plain["event"]["_0"]["pairingData"]["_0"]["data"]
         logger.info(PairingDataComponentTLVBuf.parse(pairing_data))
 
     def _handle_single_frame(self, stream: H2Stream, frame: Frame) -> None:
-        logger.debug(f'New HTTP/2 frame: {stream.key} ({frame})')
+        logger.debug(f"New HTTP/2 frame: {stream.key} ({frame})")
         if isinstance(frame, HeadersFrame):
-            logger.debug(
-                f'{stream.src} opening stream {frame.stream_id} for communication on port {stream.dport}')
+            logger.debug(f"{stream.src} opening stream {frame.stream_id} for communication on port {stream.dport}")
         elif isinstance(frame, GoAwayFrame):
-            logger.debug(f'{stream.src} closing stream {frame.stream_id} on port {stream.sport}')
+            logger.debug(f"{stream.src} closing stream {frame.stream_id} on port {stream.sport}")
         elif isinstance(frame, DataFrame):
             self._handle_data_frame(stream, frame)
 
@@ -180,27 +181,27 @@ class RemoteXPCSniffer:
 
 @click.group()
 def cli():
-    """ Parse RemoteXPC traffic """
+    """Parse RemoteXPC traffic"""
     pass
 
 
 @cli.command()
-@click.argument('file', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("file", type=click.Path(exists=True, file_okay=True, dir_okay=False))
 def offline(file: str):
-    """ Parse RemoteXPC traffic from a .pcap file """
+    """Parse RemoteXPC traffic from a .pcap file"""
     sniffer = RemoteXPCSniffer()
     for p in sniff(offline=file):
         sniffer.process_packet(p)
 
 
 @cli.command()
-@click.argument('iface')
+@click.argument("iface")
 def live(iface: str):
-    """ Parse RemoteXPC live from a given network interface """
+    """Parse RemoteXPC live from a given network interface"""
     sniffer = RemoteXPCSniffer()
     sniff(iface=iface, prn=sniffer.process_packet)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     coloredlogs.install(level=logging.DEBUG)
     cli()