Wire up some more

Generic @overload definitions on signal handlers were masking
type-checking errors.

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: frida

.gitignore

@@ -1,5 +1,6 @@
 *.pyc
-*.user
 /*.egg-info/
 /build/
+/deps/
 /dist/
+/subprojects/*

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "releng"]
+	path = releng
+	url = https://github.com/frida/releng.git

BSDmakefile

@@ -0,0 +1,6 @@
+all: .DEFAULT
+
+.DEFAULT:
+	@gmake ${.MAKEFLAGS} ${.TARGETS}
+
+.PHONY: all

MANIFEST.in

@@ -0,0 +1,19 @@
+include meson.build
+include frida/meson.build
+include frida/_frida/extension.c
+include frida/_frida/extension.version
+include frida/_frida/meson.build
+include subprojects/frida-core.wrap
+
+include BSDmakefile
+include Makefile
+include configure
+include configure.bat
+include make.bat
+include releng/*.py
+include releng/*.toml
+graft releng/devkit-assets/
+graft releng/meson-scripts/
+include releng/meson/meson.py
+graft releng/meson/mesonbuild/
+graft releng/tomlkit/tomlkit/

Makefile

@@ -0,0 +1,16 @@
+PYTHON ?= $(shell which python3 >/dev/null && echo python3 || echo python)
+
+all $(MAKECMDGOALS):
+	@$(PYTHON) \
+		-c "import sys; sys.path.insert(0, sys.argv[1]); from releng.meson_make import main; main()" \
+		"$(shell pwd)" \
+		./build \
+		$(MAKECMDGOALS)
+
+git-submodules:
+	@if [ ! -f releng/meson/meson.py ]; then \
+		git submodule update --init --recursive --depth 1; \
+	fi
+-include git-submodules
+
+.PHONY: all $(MAKECMDGOALS)

_frida/__init__.pyi

@@ -1,663 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
-
-# Exceptions
-class AddressInUseError(Exception): ...
-class ExecutableNotFoundError(Exception): ...
-class ExecutableNotSupportedError(Exception): ...
-class ServerNotRunningError(Exception): ...
-class TimedOutError(Exception): ...
-class TransportError(Exception): ...
-class ProcessNotFoundError(Exception): ...
-class ProcessNotRespondingError(Exception): ...
-class ProtocolError(Exception): ...
-class InvalidArgumentError(Exception): ...
-class InvalidOperationError(Exception): ...
-class NotSupportedError(Exception): ...
-class OperationCancelledError(Exception): ...
-class PermissionDeniedError(Exception): ...
-
-class Object:
-    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    def on(self, signal: str, callback: Callable[..., Any]) -> None:
-        """
-        Add a signal handler.
-        """
-        ...
-    def off(self, signal: str, callback: Callable[..., Any]) -> None:
-        """
-        Remove a signal handler.
-        """
-        ...
-
-class Application(Object):
-    @property
-    def identifier(self) -> str:
-        """
-        Application identifier.
-        """
-        ...
-    @property
-    def name(self) -> str:
-        """
-        Human-readable application name.
-        """
-        ...
-    @property
-    def parameters(self) -> Dict[str, Any]:
-        """
-        Parameters.
-        """
-        ...
-    @property
-    def pid(self) -> int:
-        """
-        Process ID, or 0 if not running.
-        """
-        ...
-
-class Bus(Object):
-    def attach(self) -> None:
-        """
-        Attach to the bus.
-        """
-        ...
-    def post(self, message: str, data: Optional[Union[bytes, str]]) -> None:
-        """
-        Post a JSON-encoded message to the bus.
-        """
-        ...
-
-class Cancellable(Object):
-    def cancel(self) -> None:
-        """
-        Set cancellable to cancelled.
-        """
-        ...
-    def connect(self, callback: Callable[..., Any]) -> int:
-        """
-        Register notification callback.
-        """
-        ...
-    def disconnect(self, handler_id: int) -> None:
-        """
-        Unregister notification callback.
-        """
-        ...
-    @classmethod
-    def get_current(cls) -> "Cancellable":
-        """
-        Get the top cancellable from the stack.
-        """
-        ...
-    def get_fd(self) -> int:
-        """
-        Get file descriptor for integrating with an event loop.
-        """
-        ...
-    def is_cancelled(self) -> bool:
-        """
-        Query whether cancellable has been cancelled.
-        """
-        ...
-    def pop_current(self) -> None:
-        """
-        Pop cancellable off the cancellable stack.
-        """
-        ...
-    def push_current(self) -> None:
-        """
-        Push cancellable onto the cancellable stack.
-        """
-        ...
-    def raise_if_cancelled(self) -> None:
-        """
-        Raise an exception if cancelled.
-        """
-        ...
-    def release_fd(self) -> None:
-        """
-        Release a resource previously allocated by get_fd().
-        """
-        ...
-
-class Child(Object):
-    @property
-    def argv(self) -> List[str]:
-        """
-        Argument vector.
-        """
-        ...
-    @property
-    def envp(self) -> Dict[str, str]:
-        """
-        Environment vector.
-        """
-        ...
-    @property
-    def identifier(self) -> str:
-        """
-        Application identifier.
-        """
-        ...
-    @property
-    def origin(self) -> str:
-        """
-        Origin.
-        """
-        ...
-    @property
-    def parent_pid(self) -> int:
-        """
-        Parent Process ID.
-        """
-        ...
-    @property
-    def path(self) -> str:
-        """
-        Path of executable.
-        """
-        ...
-    @property
-    def pid(self) -> int:
-        """
-        Process ID.
-        """
-        ...
-
-class Crash(Object):
-    @property
-    def parameters(self) -> Dict[str, Any]:
-        """
-        Parameters.
-        """
-        ...
-    @property
-    def pid(self) -> int:
-        """
-        Process ID.
-        """
-        ...
-    @property
-    def process_name(self) -> str:
-        """
-        Process name.
-        """
-        ...
-    @property
-    def report(self) -> str:
-        """
-        Human-readable crash report.
-        """
-        ...
-    @property
-    def summary(self) -> str:
-        """
-        Human-readable crash summary.
-        """
-        ...
-
-class Device(Object):
-    @property
-    def id(self) -> Optional[str]:
-        """
-        Device ID.
-        """
-        ...
-    @property
-    def name(self) -> Optional[str]:
-        """
-        Human-readable device name.
-        """
-        ...
-    @property
-    def icon(self) -> Optional[Any]:
-        """
-        Icon.
-        """
-        ...
-    @property
-    def type(self) -> Optional[str]:
-        """
-        Device type. One of: local, remote, usb.
-        """
-        ...
-    @property
-    def bus(self) -> Optional[Bus]:
-        """
-        Message bus.
-        """
-        ...
-    def attach(self, pid: int, realm: Optional[str] = None, persist_timeout: Optional[int] = None) -> "Session":
-        """
-        Attach to a PID.
-        """
-        ...
-    def disable_spawn_gating(self) -> None:
-        """
-        Disable spawn gating.
-        """
-        ...
-    def enable_spawn_gating(self) -> None:
-        """
-        Enable spawn gating.
-        """
-        ...
-    def enumerate_applications(
-        self, identifiers: Optional[Sequence[str]] = None, scope: Optional[str] = None
-    ) -> List[Application]:
-        """
-        Enumerate applications.
-        """
-        ...
-    def enumerate_pending_children(self) -> List[Child]:
-        """
-        Enumerate pending children.
-        """
-        ...
-    def enumerate_pending_spawn(self) -> List["Spawn"]:
-        """
-        Enumerate pending spawn.
-        """
-        ...
-    def enumerate_processes(self, pids: Optional[Sequence[int]] = None, scope: Optional[str] = None) -> List[Process]:
-        """
-        Enumerate processes.
-        """
-        ...
-    def get_frontmost_application(self, scope: Optional[str] = None) -> Optional[Application]:
-        """
-        Get details about the frontmost application.
-        """
-        ...
-    def inject_library_blob(self, pid: int, blob_buffer: bytes, entrypoint: str, data: str) -> int:
-        """
-        Inject a library blob to a PID.
-        """
-        ...
-    def inject_library_file(self, pid: int, path: str, entrypoint: str, data: str) -> int:
-        """
-        Inject a library file to a PID.
-        """
-        ...
-    def input(self, pid: int, data: bytes) -> None:
-        """
-        Input data on stdin of a spawned process.
-        """
-        ...
-    def is_lost(self) -> bool:
-        """
-        Query whether the device has been lost.
-        """
-        ...
-    def kill(self, pid: int) -> None:
-        """
-        Kill a PID.
-        """
-        ...
-    def open_channel(self, address: str) -> "IOStream":
-        """
-        Open a device-specific communication channel.
-        """
-        ...
-    def unpair(self) -> None:
-        """
-        Unpair device.
-        """
-        ...
-    def query_system_parameters(self) -> Dict[str, Any]:
-        """
-        Returns a dictionary of information about the host system.
-        """
-        ...
-    def resume(self, pid: int) -> None:
-        """
-        Resume a process from the attachable state.
-        """
-        ...
-    def spawn(
-        self,
-        program: str,
-        argv: Union[None, List[Union[str, bytes]], Tuple[Union[str, bytes]]] = None,
-        envp: Optional[Dict[str, str]] = None,
-        env: Optional[Dict[str, str]] = None,
-        cwd: Optional[str] = None,
-        stdio: Optional[str] = None,
-        **kwargs: Any,
-    ) -> int:
-        """
-        Spawn a process into an attachable state.
-        """
-        ...
-
-class DeviceManager(Object):
-    def add_remote_device(
-        self,
-        address: str,
-        certificate: Optional[str] = None,
-        origin: Optional[str] = None,
-        token: Optional[str] = None,
-        keepalive_interval: Optional[int] = None,
-    ) -> Device:
-        """
-        Add a remote device.
-        """
-        ...
-    def close(self) -> None:
-        """
-        Close the device manager.
-        """
-        ...
-    def enumerate_devices(self) -> List[Device]:
-        """
-        Enumerate devices.
-        """
-        ...
-    def get_device_matching(self, predicate: Callable[[Device], bool], timeout: int) -> Device:
-        """
-        Get device matching predicate.
-        """
-        ...
-    def remove_remote_device(self, address: str) -> None:
-        """
-        Remove a remote device.
-        """
-        ...
-
-class EndpointParameters(Object): ...
-
-class FileMonitor(Object):
-    def disable(self) -> None:
-        """
-        Disable the file monitor.
-        """
-        ...
-    def enable(self) -> None:
-        """
-        Enable the file monitor.
-        """
-        ...
-
-class IOStream(Object):
-    def close(self) -> None:
-        """
-        Close the stream.
-        """
-        ...
-    def is_closed(self) -> bool:
-        """
-        Query whether the stream is closed.
-        """
-        ...
-    def read(self, size: int) -> bytes:
-        """
-        Read up to the specified number of bytes from the stream.
-        """
-        ...
-    def read_all(self, size: int) -> bytes:
-        """
-        Read exactly the specified number of bytes from the stream.
-        """
-        ...
-    def write(self, data: bytes) -> int:
-        """
-        Write as much as possible of the provided data to the stream.
-        """
-        ...
-    def write_all(self, data: bytes) -> None:
-        """
-        Write all of the provided data to the stream.
-        """
-        ...
-
-class PortalMembership(Object):
-    def terminate(self) -> None:
-        """
-        Terminate the membership.
-        """
-        ...
-
-class PortalService(Object):
-    @property
-    def device(self) -> Device:
-        """
-        Device for in-process control.
-        """
-        ...
-    def broadcast(self, message: str, data: Optional[Union[str, bytes]] = None) -> None:
-        """
-        Broadcast a message to all control channels.
-        """
-        ...
-    def enumerate_tags(self, connection_id: int) -> List[str]:
-        """
-        Enumerate tags of a specific connection.
-        """
-        ...
-    def kick(self, connection_id: int) -> None:
-        """
-        Kick out a specific connection.
-        """
-        ...
-    def narrowcast(self, tag: str, message: str, data: Optional[Union[str, bytes]] = None) -> None:
-        """
-        Post a message to control channels with a specific tag.
-        """
-        ...
-    def post(self, connection_id: int, message: str, data: Optional[Union[str, bytes]] = None) -> None:
-        """
-        Post a message to a specific control channel.
-        """
-        ...
-    def start(self) -> None:
-        """
-        Start listening for incoming connections.
-        """
-        ...
-    def stop(self) -> None:
-        """
-        Stop listening for incoming connections, and kick any connected clients.
-        """
-        ...
-    def tag(self, connection_id: int, tag: str) -> None:
-        """
-        Tag a specific control channel.
-        """
-        ...
-    def untag(self, connection_id: int, tag: str) -> None:
-        """
-        Untag a specific control channel.
-        """
-        ...
-
-class Process(Object):
-    @property
-    def pid(self) -> int:
-        """
-        Process ID.
-        """
-        ...
-    @property
-    def name(self) -> str:
-        """
-        Human-readable process name.
-        """
-        ...
-    @property
-    def parameters(self) -> Dict[str, Any]:
-        """
-        Parameters.
-        """
-        ...
-
-class Relay(Object):
-    def __init__(self, address: str, username: str, password: str, kind: str) -> None: ...
-    @property
-    def address(self) -> str:
-        """
-        Network address or address:port of the TURN server.
-        """
-        ...
-    @property
-    def kind(self) -> str:
-        """
-        Relay kind. One of: turn-udp, turn-tcp, turn-tls.
-        """
-        ...
-    @property
-    def password(self) -> str:
-        """
-        The TURN password to use for the allocate request.
-        """
-        ...
-    @property
-    def username(self) -> str:
-        """
-        The TURN username to use for the allocate request.
-        """
-        ...
-
-class Script(Object):
-    def eternalize(self) -> None:
-        """
-        Eternalize the script.
-        """
-        ...
-    def is_destroyed(self) -> bool:
-        """
-        Query whether the script has been destroyed.
-        """
-        ...
-    def load(self) -> None:
-        """
-        Load the script.
-        """
-        ...
-    def post(self, message: str, data: Optional[Union[str, bytes]] = None) -> None:
-        """
-        Post a JSON-encoded message to the script.
-        """
-        ...
-    def unload(self) -> None:
-        """
-        Unload the script.
-        """
-        ...
-    def enable_debugger(self, port: Optional[int]) -> None:
-        """
-        Enable the Node.js compatible script debugger
-        """
-        ...
-    def disable_debugger(self) -> None:
-        """
-        Disable the Node.js compatible script debugger
-        """
-        ...
-
-class Session(Object):
-    @property
-    def pid(self) -> int:
-        """
-        Process ID.
-        """
-        ...
-    def compile_script(self, source: str, name: Optional[str] = None, runtime: Optional[str] = None) -> bytes:
-        """
-        Compile script source code to bytecode.
-        """
-        ...
-    def create_script(self, source: str, name: Optional[str] = None, runtime: Optional[str] = None) -> Script:
-        """
-        Create a new script.
-        """
-        ...
-    def create_script_from_bytes(
-        self, data: bytes, name: Optional[str] = None, runtime: Optional[str] = None
-    ) -> Script:
-        """
-        Create a new script from bytecode.
-        """
-        ...
-    def snapshot_script(self, embed_script: str, warmup_script: Optional[str], runtime: Optional[str] = None) -> bytes:
-        """
-        Evaluate script and snapshot the resulting VM state
-        """
-        ...
-    def detach(self) -> None:
-        """
-        Detach session from the process.
-        """
-        ...
-    def disable_child_gating(self) -> None:
-        """
-        Disable child gating.
-        """
-        ...
-    def enable_child_gating(self) -> None:
-        """
-        Enable child gating.
-        """
-        ...
-    def is_detached(self) -> bool:
-        """
-        Query whether the session is detached.
-        """
-        ...
-    def join_portal(
-        self, address: str, certificate: Optional[str] = None, token: Optional[str] = None, acl: Optional[Any] = None
-    ) -> PortalMembership:
-        """
-        Join a portal.
-        """
-        ...
-    def resume(self) -> None:
-        """
-        Resume session after network error.
-        """
-        ...
-    def setup_peer_connection(
-        self, stun_server: Optional[str] = None, relays: Optional[Sequence[Relay]] = None
-    ) -> None:
-        """
-        Set up a peer connection with the target process.
-        """
-        ...
-
-class Spawn(Object):
-    @property
-    def identifier(self) -> str:
-        """
-        Application identifier.
-        """
-        ...
-    @property
-    def pid(self) -> int:
-        """
-        Process ID.
-        """
-        ...
-
-class Compiler(Object):
-    def build(
-        self,
-        entrypoint: str,
-        project_root: Optional[str] = None,
-        source_maps: Optional[str] = None,
-        compression: Optional[str] = None,
-    ) -> str:
-        """
-        Build an agent.
-        """
-        ...
-    def watch(
-        self,
-        entrypoint: str,
-        project_root: Optional[str] = None,
-        source_maps: Optional[str] = None,
-        compression: Optional[str] = None,
-    ) -> None:
-        """
-        Continuously build an agent.
-        """
-        ...
-
-__version__: str

config.h.in

@@ -1,19 +0,0 @@
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if OS is Android based. */
-#mesondefine HAVE_ANDROID
-
-/* Define to 1 if OS is Darwin based. */
-#mesondefine HAVE_DARWIN
-
-/* Define to 1 if OS is iOS. */
-#mesondefine HAVE_IOS
-
-/* Define to 1 if OS is Linux based. */
-#mesondefine HAVE_LINUX
-
-/* Define to 1 if OS is macOS. */
-#mesondefine HAVE_MACOS
-
-/* Define to 1 if OS is QNX based. */
-#mesondefine HAVE_QNX

configure

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+[ -z "$PYTHON" ] && PYTHON=$(which python3 >/dev/null && echo python3 || echo python)
+
+cd $(dirname $0)
+
+srcroot=$(pwd)
+
+if [ ! -f releng/meson/meson.py ]; then
+  git submodule update --init --recursive --depth 1 || exit $?
+fi
+
+cd - >/dev/null
+
+exec "$PYTHON" \
+    -c "import sys; sys.path.insert(0, sys.argv[1]); from releng.meson_configure import main; main()" \
+    "$srcroot" \
+    "$@"

configure.bat

@@ -0,0 +1,22 @@
+@setlocal
+@echo off
+rem:: Based on: https://github.com/microsoft/terminal/issues/217#issuecomment-737594785
+goto :_start_
+
+:set_real_dp0
+set dp0=%~dp0
+set "dp0=%dp0:~0,-1%"
+goto :eof
+
+:_start_
+call :set_real_dp0
+
+if not exist "%dp0%\releng\meson\meson.py" (
+  pushd "%dp0%" & git submodule update --init --recursive --depth 1 & popd
+  if %errorlevel% neq 0 exit /b %errorlevel%
+)
+
+endlocal & goto #_undefined_# 2>nul || title %COMSPEC% & python ^
+    -c "import sys; sys.path.insert(0, sys.argv[1]); from releng.meson_configure import main; main()" ^
+    "%dp0%" ^
+    %*

examples/open_service/dtx/deviceinfo.py

@@ -0,0 +1,9 @@
+import pprint
+
+import frida
+
+device = frida.get_usb_device()
+
+deviceinfo = device.open_service("dtx:com.apple.instruments.server.services.deviceinfo")
+response = deviceinfo.request({"method": "runningProcesses"})
+pprint.pp(response)

examples/open_service/dtx/opengl.py

@@ -0,0 +1,27 @@
+import sys
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+opengl = device.open_service("dtx:com.apple.instruments.server.services.graphics.opengl")
+opengl.on("message", on_message)
+opengl.request(
+    {
+        "method": "setSamplingRate:",
+        "args": [5.0],
+    }
+)
+opengl.request(
+    {
+        "method": "startSamplingAtTimeInterval:",
+        "args": [0.0],
+    }
+)
+
+sys.stdin.read()

examples/open_service/dtx/processcontrol.py

@@ -0,0 +1,31 @@
+import sys
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+control = device.open_service("dtx:com.apple.instruments.server.services.processcontrol")
+control.on("message", on_message)
+pid = control.request(
+    {
+        "method": "launchSuspendedProcessWithDevicePath:bundleIdentifier:environment:arguments:options:",
+        "args": [
+            "",
+            "no.oleavr.HelloIOS",
+            {},
+            [],
+            {
+                "StartSuspendedKey": False,
+            },
+        ],
+    }
+)
+control.request({"method": "startObservingPid:", "args": [pid]})
+
+print(f"App spawned, PID: {pid}.  Kill it to see an example message being emitted.")
+sys.stdin.read()

examples/open_service/dtx/screenshot.py

@@ -0,0 +1,15 @@
+import sys
+
+import frida
+
+if len(sys.argv) != 2:
+    print(f"Usage: {sys.argv[0]} outfile.png", file=sys.stderr)
+    sys.exit(1)
+outfile = sys.argv[1]
+
+device = frida.get_usb_device()
+
+screenshot = device.open_service("dtx:com.apple.instruments.server.services.screenshot")
+png = screenshot.request({"method": "takeScreenshot"})
+with open(outfile, "wb") as f:
+    f.write(png)

examples/open_service/dtx/sysmontap.py

@@ -0,0 +1,29 @@
+import time
+
+import frida
+
+
+def on_message(message):
+    print("on_message:", message)
+
+
+device = frida.get_usb_device()
+
+sysmon = device.open_service("dtx:com.apple.instruments.server.services.sysmontap")
+sysmon.on("message", on_message)
+sysmon.request(
+    {
+        "method": "setConfig:",
+        "args": [
+            {
+                "ur": 1000,
+                "cpuUsage": True,
+                "sampleInterval": 1000000000,
+            },
+        ],
+    }
+)
+sysmon.request({"method": "start"})
+time.sleep(5)
+sysmon.request({"method": "stop"})
+time.sleep(1)

examples/open_service/plist.py

@@ -0,0 +1,7 @@
+import frida
+
+device = frida.get_usb_device()
+
+diag = device.open_service("plist:com.apple.mobile.diagnostics_relay")
+diag.request({"type": "query", "payload": {"Request": "Sleep", "WaitForDisconnect": True}})
+diag.request({"type": "query", "payload": {"Request": "Goodbye"}})

examples/open_service/xpc/launchapplication.py

@@ -0,0 +1,64 @@
+import pprint
+import sys
+from threading import Thread
+
+import frida
+
+
+def main():
+    device = frida.get_usb_device()
+
+    stdout_uuid, stdout_stream = create_stdio_socket(device)
+    stderr_uuid, stderr_stream = create_stdio_socket(device)
+
+    appservice = device.open_service("xpc:com.apple.coredevice.appservice")
+    response = appservice.request(
+        {
+            "CoreDevice.featureIdentifier": "com.apple.coredevice.feature.launchapplication",
+            "CoreDevice.action": {},
+            "CoreDevice.input": {
+                "applicationSpecifier": {
+                    "bundleIdentifier": {"_0": "no.oleavr.HelloIOS"},
+                },
+                "options": {
+                    "arguments": [],
+                    "environmentVariables": {},
+                    "standardIOUsesPseudoterminals": True,
+                    "startStopped": False,
+                    "terminateExisting": True,
+                    "user": {"active": True},
+                    "platformSpecificOptions": b'<?xml version="1.0" encoding="UTF-8"?><plist version="1.0"><dict/></plist>',
+                },
+                "standardIOIdentifiers": {
+                    "standardOutput": ("uuid", stdout_uuid),
+                    "standardError": ("uuid", stderr_uuid),
+                },
+            },
+        }
+    )
+    pprint.pp(response)
+
+    workers = set()
+    for stream, sink in {(stdout_stream, sys.stdout), (stderr_stream, sys.stderr)}:
+        t = Thread(target=process_console_output, args=(stream, sink))
+        t.start()
+        workers.add(t)
+    for worker in workers:
+        worker.join()
+
+
+def create_stdio_socket(device):
+    stream = device.open_channel("tcp:com.apple.coredevice.openstdiosocket")
+    return (stream.read_all(16), stream)
+
+
+def process_console_output(stream, sink):
+    while True:
+        chunk = stream.read(4096)
+        if not chunk:
+            break
+        sink.write(chunk.decode("utf-8"))
+
+
+if __name__ == "__main__":
+    main()

examples/open_service/xpc/listprocesses.py

@@ -0,0 +1,15 @@
+import pprint
+
+import frida
+
+device = frida.get_usb_device()
+
+appservice = device.open_service("xpc:com.apple.coredevice.appservice")
+response = appservice.request(
+    {
+        "CoreDevice.featureIdentifier": "com.apple.coredevice.feature.listprocesses",
+        "CoreDevice.action": {},
+        "CoreDevice.input": {},
+    }
+)
+pprint.pp(response)

frida-python.vcxproj

@@ -1,176 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{7505F884-DD69-4F23-ADE6-1E0E049AB018}</ProjectGuid>
-    <RootNamespace>frida</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-    <ProjectName>frida-python</ProjectName>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(SolutionDir)releng\frida-toolchain.props" />
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(SolutionDir)releng\frida-$(Configuration).props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(SolutionDir)releng\frida-$(Configuration).props" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(SolutionDir)releng\frida-$(Configuration).props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(SolutionDir)releng\frida-$(Configuration).props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)build\frida-windows\$(PlatformName)-$(Configuration)\lib\python3.10\site-packages\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)build\frida-windows\$(PlatformName)-$(Configuration)\lib\python3.10\site-packages\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)build\frida-windows\$(PlatformName)-$(Configuration)\lib\python3.10\site-packages\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)build\frida-windows\$(PlatformName)-$(Configuration)\lib\python3.10\site-packages\</OutDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">_frida</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">_frida</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">_frida</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">_frida</TargetName>
-    <TargetExt Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.pyd</TargetExt>
-    <TargetExt Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.pyd</TargetExt>
-    <TargetExt Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.pyd</TargetExt>
-    <TargetExt Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.pyd</TargetExt>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <AdditionalLibraryDirectories>$(PythonLocation)\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(IntDir)..\frida-core\api;$(PythonLocation)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>$(FridaComponentDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <AdditionalLibraryDirectories>$(PythonLocation)\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(IntDir)..\frida-core\api;$(PythonLocation)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>$(FridaComponentDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <AdditionalLibraryDirectories>$(PythonLocation)\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(IntDir)..\frida-core\api;$(PythonLocation)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>$(FridaComponentDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <AdditionalLibraryDirectories>$(PythonLocation)\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(IntDir)..\frida-core\api;$(PythonLocation)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>$(FridaComponentDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\frida-core\frida-core.vcxproj">
-      <Project>{b7dc9b02-a5ff-4aa1-b2a2-dc1653168d44}</Project>
-      <Private>false</Private>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
-      <LinkLibraryDependencies>true</LinkLibraryDependencies>
-      <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="src\_frida.c" />
-  </ItemGroup>
-  <ItemGroup>
-    <CustomBuild Include="frida\__init__.py">
-      <FileType>Document</FileType>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Installing frida package</Message>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Installing frida package</Message>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Installing frida package</Message>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Installing frida package</Message>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">rmdir /S /Q $(OutDir)frida 2&gt;NUL
-mkdir $(OutDir)frida || exit 1
-copy /B /Y "$(ProjectDir)frida\*.py" $(OutDir)frida || exit 1
-echo. &gt; $(IntDir)frida-package.stamp</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(IntDir)frida-package.stamp</Outputs>
-      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir)frida\core.py</AdditionalInputs>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">rmdir /S /Q $(OutDir)frida 2&gt;NUL
-mkdir $(OutDir)frida || exit 1
-copy /B /Y "$(ProjectDir)frida\*.py" $(OutDir)frida || exit 1
-echo. &gt; $(IntDir)frida-package.stamp</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IntDir)frida-package.stamp</Outputs>
-      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(ProjectDir)frida\core.py</AdditionalInputs>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">rmdir /S /Q $(OutDir)frida 2&gt;NUL
-mkdir $(OutDir)frida || exit 1
-copy /B /Y "$(ProjectDir)frida\*.py" $(OutDir)frida || exit 1
-echo. &gt; $(IntDir)frida-package.stamp</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(IntDir)frida-package.stamp</Outputs>
-      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(ProjectDir)frida\core.py</AdditionalInputs>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">rmdir /S /Q $(OutDir)frida 2&gt;NUL
-mkdir $(OutDir)frida || exit 1
-copy /B /Y "$(ProjectDir)frida\*.py" $(OutDir)frida || exit 1
-echo. &gt; $(IntDir)frida-package.stamp</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)frida-package.stamp</Outputs>
-      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(ProjectDir)frida\core.py</AdditionalInputs>
-    </CustomBuild>
-    <None Include="frida\core.py" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

frida-python.vcxproj.filters

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-    <Filter Include="Source Files\frida">
-      <UniqueIdentifier>{e8366f87-de40-4415-8724-a51c48fc532d}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="src\_frida.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="frida\core.py">
-      <Filter>Source Files\frida</Filter>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <CustomBuild Include="frida\__init__.py">
-      <Filter>Source Files\frida</Filter>
-    </CustomBuild>
-  </ItemGroup>
-</Project>

frida/__init__.py

@@ -1,172 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
-try:
-    import _frida
-except Exception as ex:
-    print("")
-    print("***")
-    if str(ex).startswith("No module named "):
-        print("Frida native extension not found")
-        print("Please check your PYTHONPATH.")
-    else:
-        print(f"Failed to load the Frida native extension: {ex}")
-        print("Please ensure that the extension was compiled correctly")
-    print("***")
-    print("")
-    raise ex
-from . import core
-
-__version__: str = _frida.__version__
-
-get_device_manager = core.get_device_manager
-Relay = _frida.Relay
-PortalService = core.PortalService
-EndpointParameters = core.EndpointParameters
-Compiler = core.Compiler
-FileMonitor = _frida.FileMonitor
-Cancellable = core.Cancellable
-
-ServerNotRunningError = _frida.ServerNotRunningError
-ExecutableNotFoundError = _frida.ExecutableNotFoundError
-ExecutableNotSupportedError = _frida.ExecutableNotSupportedError
-ProcessNotFoundError = _frida.ProcessNotFoundError
-ProcessNotRespondingError = _frida.ProcessNotRespondingError
-InvalidArgumentError = _frida.InvalidArgumentError
-InvalidOperationError = _frida.InvalidOperationError
-PermissionDeniedError = _frida.PermissionDeniedError
-AddressInUseError = _frida.AddressInUseError
-TimedOutError = _frida.TimedOutError
-NotSupportedError = _frida.NotSupportedError
-ProtocolError = _frida.ProtocolError
-TransportError = _frida.TransportError
-OperationCancelledError = _frida.OperationCancelledError
-
-
-def query_system_parameters() -> Dict[str, Any]:
-    """
-    Returns a dictionary of information about the host system
-    """
-
-    return get_local_device().query_system_parameters()
-
-
-def spawn(
-    program: Union[str, List[Union[str, bytes]], Tuple[Union[str, bytes]]],
-    argv: Union[None, List[Union[str, bytes]], Tuple[Union[str, bytes]]] = None,
-    envp: Optional[Dict[str, str]] = None,
-    env: Optional[Dict[str, str]] = None,
-    cwd: Optional[str] = None,
-    stdio: Optional[str] = None,
-    **kwargs: Any,
-) -> int:
-    """
-    Spawn a process into an attachable state
-    """
-
-    return get_local_device().spawn(program=program, argv=argv, envp=envp, env=env, cwd=cwd, stdio=stdio, **kwargs)
-
-
-def resume(target: core.ProcessTarget) -> None:
-    """
-    Resume a process from the attachable state
-    :param target: the PID or name of the process
-    """
-
-    get_local_device().resume(target)
-
-
-def kill(target: core.ProcessTarget) -> None:
-    """
-    Kill a process
-    :param target: the PID or name of the process
-    """
-
-    get_local_device().kill(target)
-
-
-def attach(
-    target: core.ProcessTarget, realm: Optional[str] = None, persist_timeout: Optional[int] = None
-) -> core.Session:
-    """
-    Attach to a process
-    :param target: the PID or name of the process
-    """
-
-    return get_local_device().attach(target, realm=realm, persist_timeout=persist_timeout)
-
-
-def inject_library_file(target: core.ProcessTarget, path: str, entrypoint: str, data: str) -> int:
-    """
-    Inject a library file to a process.
-    :param target: the PID or name of the process
-    """
-
-    return get_local_device().inject_library_file(target, path, entrypoint, data)
-
-
-def inject_library_blob(target: core.ProcessTarget, blob: bytes, entrypoint: str, data: str) -> int:
-    """
-    Inject a library blob to a process
-    :param target: the PID or name of the process
-    """
-
-    return get_local_device().inject_library_blob(target, blob, entrypoint, data)
-
-
-def get_local_device() -> core.Device:
-    """
-    Get the local device
-    """
-
-    return get_device_manager().get_local_device()
-
-
-def get_remote_device() -> core.Device:
-    """
-    Get the first remote device in the devices list
-    """
-
-    return get_device_manager().get_remote_device()
-
-
-def get_usb_device(timeout: int = 0) -> core.Device:
-    """
-    Get the first device connected over USB in the devices list
-    """
-
-    return get_device_manager().get_usb_device(timeout)
-
-
-def get_device(id: Optional[str], timeout: int = 0) -> core.Device:
-    """
-    Get a device by its id
-    """
-
-    return get_device_manager().get_device(id, timeout)
-
-
-def get_device_matching(predicate: Callable[[core.Device], bool], timeout: int = 0) -> core.Device:
-    """
-    Get device matching predicate.
-    :param predicate: a function to filter the devices
-    :param timeout: operation timeout in seconds
-    """
-
-    return get_device_manager().get_device_matching(predicate, timeout)
-
-
-def enumerate_devices() -> List[core.Device]:
-    """
-    Enumerate all the devices from the device manager
-    """
-
-    return get_device_manager().enumerate_devices()
-
-
-@core.cancellable
-def shutdown() -> None:
-    """
-    Shutdown the main device manager
-    """
-
-    get_device_manager()._impl.close()

frida/frida_bindgen/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

frida/frida_bindgen/assets/codegen_gobject_globals.c

@@ -0,0 +1 @@
+static GHashTable * pygobject_type_spec_by_type;

frida/frida_bindgen/assets/codegen_gobject_methods.c

@@ -0,0 +1,77 @@
+static void
+PyGObject_class_init (void)
+{
+  pygobject_type_spec_by_type = g_hash_table_new_full (NULL, NULL, NULL, NULL);
+}
+
+static int
+PyGObject_init (PyGObject * self)
+{
+  self->handle = NULL;
+  self->type = PYFRIDA_TYPE (GObject);
+
+  self->signal_closures = NULL;
+
+  return 0;
+}
+
+static void
+PyGObject_dealloc (PyGObject * self)
+{
+  gpointer handle;
+
+  handle = PyGObject_steal_handle (self);
+  if (handle != NULL)
+  {
+    Py_BEGIN_ALLOW_THREADS
+    self->type->destroy (handle);
+    Py_END_ALLOW_THREADS
+  }
+
+  ((freefunc) PyType_GetSlot (Py_TYPE (self), Py_tp_free)) (self);
+}
+
+static void
+PyGObject_take_handle (PyGObject * self,
+                       gpointer handle,
+                       const PyGObjectType * type)
+{
+  self->handle = handle;
+  self->type = type;
+
+  if (handle != NULL)
+    g_object_set_data (G_OBJECT (handle), "pyobject", self);
+}
+
+static gpointer
+PyGObject_steal_handle (PyGObject * self)
+{
+  gpointer handle = self->handle;
+  GSList * entry;
+
+  if (handle == NULL)
+    return NULL;
+
+  for (entry = self->signal_closures; entry != NULL; entry = entry->next)
+  {
+    PyGObjectSignalClosure * closure = entry->data;
+    G_GNUC_UNUSED guint num_matches;
+
+    num_matches = g_signal_handlers_disconnect_matched (handle, G_SIGNAL_MATCH_CLOSURE, closure->signal_id, 0, &closure->parent, NULL, NULL);
+    g_assert (num_matches == 1);
+  }
+  g_clear_pointer (&self->signal_closures, g_slist_free);
+
+  g_object_set_data (G_OBJECT (handle), "pyobject", NULL);
+
+  self->handle = NULL;
+
+  return handle;
+}
+
+static void
+PyGObject_register_type (GType instance_type,
+                         PyGObjectType * python_type)
+{
+  g_hash_table_insert (pygobject_type_spec_by_type, GSIZE_TO_POINTER (instance_type), python_type);
+}

frida/frida_bindgen/assets/codegen_gobject_prototypes.h

@@ -0,0 +1,5 @@
+static void PyGObject_class_init (void);
+static int PyGObject_init (PyGObject * self);
+static void PyGObject_dealloc (PyGObject * self);
+static gpointer PyGObject_steal_handle (PyGObject * self);
+static void PyGObject_register_type (GType instance_type, PyGObjectType * python_type);

frida/frida_bindgen/assets/codegen_helpers.ts

@@ -0,0 +1,100 @@
+type SignalTransformer<
+    Source extends SignalHandler,
+    Target extends SignalHandler
+> = (...args: Parameters<Source>) => Parameters<Target>;
+
+type SignalInterceptor<H extends SignalHandler> = (...args: Parameters<H>) => boolean;
+
+interface SignalWrapperOptionsNoTransform<H extends SignalHandler> {
+    transform?: undefined;
+    intercept?: SignalInterceptor<H>;
+}
+
+interface SignalWrapperOptionsTransform<
+    Source extends SignalHandler,
+    Target extends SignalHandler
+> {
+    transform: SignalTransformer<Source, Target>;
+    intercept?: SignalInterceptor<Target>;
+}
+
+type SignalWrapperOptions<
+    Source extends SignalHandler,
+    Target extends SignalHandler
+> =
+    | SignalWrapperOptionsNoTransform<Source & Target>
+    | SignalWrapperOptionsTransform<Source, Target>;
+
+class SignalWrapper<
+    SourceHandler extends SignalHandler,
+    TargetHandler extends SignalHandler
+> {
+    #source: Signal<SourceHandler>;
+    #transform?: SignalTransformer<SourceHandler, TargetHandler>;
+    #intercept?: SignalInterceptor<any>;
+
+    #handlers = new Set<TargetHandler>();
+
+    constructor(
+        source: Signal<SourceHandler>,
+        options?: SignalWrapperOptions<SourceHandler, TargetHandler>
+    ) {
+        this.#source = source;
+
+        if (options === undefined || options.transform === undefined) {
+            this.#intercept = options?.intercept;
+        } else {
+            this.#transform = options.transform;
+            this.#intercept = options.intercept;
+        }
+    }
+
+    connect(handler: TargetHandler): void {
+        this.#handlers.add(handler);
+        if (this.#handlers.size === 1) {
+            this.#source.connect(this.#wrappedHandler);
+        }
+    }
+
+    disconnect(handler: TargetHandler): void {
+        this.#handlers.delete(handler);
+        if (this.#handlers.size === 0) {
+            this.#source.disconnect(this.#wrappedHandler);
+        }
+    }
+
+    #wrappedHandler = ((...sourceArgs: Parameters<SourceHandler>) => {
+        let targetArgs: Parameters<TargetHandler>;
+        const transform = this.#transform;
+        if (transform === undefined) {
+            targetArgs = sourceArgs as unknown as Parameters<TargetHandler>;
+        } else {
+            targetArgs = transform(...sourceArgs);
+        }
+
+        const intercept = this.#intercept;
+        if (intercept !== undefined) {
+            if (!intercept(...targetArgs)) {
+                return;
+            }
+        }
+
+        for (const handler of this.#handlers) {
+            handler(...targetArgs);
+        }
+    }) as SourceHandler;
+}
+
+function inspectWrapper(object: any, name: string, properties: string[], depth: number, options: util.InspectOptionsStylized): string {
+    if (depth < 0) {
+        return options.stylize(`[${name}]`, "special");
+    }
+
+    const summary = Object.fromEntries(properties.map(name => [name, object[name]]));
+
+    const nextOptions = Object.assign({}, options, {
+        depth: (options.depth === null) ? null : depth - 1
+    });
+
+    return name + " " + inspect(summary, nextOptions);
+}

frida/frida_bindgen/assets/codegen_macros.h

@@ -0,0 +1,60 @@
+#define PYFRIDA_TYPE(name) \
+  (&_PYFRIDA_TYPE_VAR (name, type))
+#define PYFRIDA_TYPE_OBJECT(name) \
+  PYFRIDA_TYPE (name)->object
+#define _PYFRIDA_TYPE_VAR(name, var) \
+  G_PASTE (G_PASTE (G_PASTE (Py, name), _), var)
+#define PYFRIDA_DEFINE_BASETYPE(pyname, cname, ...) \
+  _PYFRIDA_DEFINE_TYPE_SLOTS (cname, __VA_ARGS__); \
+  _PYFRIDA_DEFINE_TYPE_SPEC (cname, pyname, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE); \
+  static PyGObjectType _PYFRIDA_TYPE_VAR (cname, type) = \
+  { \
+    .parent = NULL, \
+    .object = NULL, \
+  }
+#define PYFRIDA_DEFINE_TYPE(pyname, cname, parent_cname, ...) \
+  _PYFRIDA_DEFINE_TYPE_SLOTS (cname, __VA_ARGS__); \
+  _PYFRIDA_DEFINE_TYPE_SPEC (cname, pyname, Py_TPFLAGS_DEFAULT); \
+  static PyGObjectType _PYFRIDA_TYPE_VAR (cname, type) = \
+  { \
+    .parent = PYFRIDA_TYPE (parent_cname), \
+    .object = NULL, \
+  }
+#define PYFRIDA_REGISTER_TYPE(cname, gtype) \
+  G_BEGIN_DECLS \
+  { \
+    PyGObjectType * t = PYFRIDA_TYPE (cname); \
+    t->object = PyType_FromSpecWithBases (&_PYFRIDA_TYPE_VAR (cname, spec), \
+        (t->parent != NULL) ? PyTuple_Pack (1, t->parent->object) : NULL); \
+    PyGObject_register_type (gtype, t); \
+    Py_IncRef (t->object); \
+    PyModule_AddObject (module, G_STRINGIFY (cname), t->object); \
+  } \
+  G_END_DECLS
+#define _PYFRIDA_DEFINE_TYPE_SPEC(cname, pyname, type_flags) \
+  static PyType_Spec _PYFRIDA_TYPE_VAR (cname, spec) = \
+  { \
+    .name = pyname, \
+    .basicsize = sizeof (G_PASTE (Py, cname)), \
+    .itemsize = 0, \
+    .flags = type_flags, \
+    .slots = _PYFRIDA_TYPE_VAR (cname, slots), \
+  }
+#define _PYFRIDA_DEFINE_TYPE_SLOTS(cname, ...) \
+  static PyType_Slot _PYFRIDA_TYPE_VAR (cname, slots)[] = \
+  { \
+    __VA_ARGS__ \
+    { 0 }, \
+  }
+
+#define PY_GOBJECT(o) ((PyGObject *) (o))
+#define PY_GOBJECT_HANDLE(o) (PY_GOBJECT (o)->handle)
+#define PY_GOBJECT_SIGNAL_CLOSURE(o) ((PyGObjectSignalClosure *) (o))
+
+#define PyFrida_RETURN_NONE \
+  G_STMT_START \
+  { \
+    Py_IncRef (Py_None); \
+    return Py_None; \
+  } \
+  G_STMT_END

frida/frida_bindgen/assets/codegen_prototypes.h

@@ -0,0 +1,78 @@
+G_GNUC_UNUSED static gboolean fdn_is_null (napi_env env, napi_value value);
+static gboolean fdn_is_undefined_or_null (napi_env env, napi_value value);
+static gboolean fdn_is_function (napi_env env, napi_value value);
+
+static gboolean fdn_boolean_from_value (napi_env env, napi_value value, gboolean * b);
+static napi_value fdn_boolean_to_value (napi_env env, gboolean b);
+static gboolean fdn_size_from_value (napi_env env, napi_value value, gsize * s);
+static napi_value fdn_size_to_value (napi_env env, gsize s);
+static napi_value fdn_ssize_to_value (napi_env env, gssize s);
+static gboolean fdn_int_from_value (napi_env env, napi_value value, gint * i);
+static napi_value fdn_int_to_value (napi_env env, gint i);
+static gboolean fdn_uint_from_value (napi_env env, napi_value value, guint * u);
+static napi_value fdn_uint_to_value (napi_env env, guint u);
+static gboolean fdn_uint16_from_value (napi_env env, napi_value value, guint16 * u);
+static napi_value fdn_uint16_to_value (napi_env env, guint16 u);
+static napi_value fdn_uint32_to_value (napi_env env, guint32 u);
+static gboolean fdn_int64_from_value (napi_env env, napi_value value, gint64 * i);
+static napi_value fdn_int64_to_value (napi_env env, gint64 i);
+static napi_value fdn_uint64_to_value (napi_env env, guint64 u);
+static gboolean fdn_ulong_from_value (napi_env env, napi_value value, gulong * u);
+static gboolean fdn_double_from_value (napi_env env, napi_value value, gdouble * d);
+static napi_value fdn_double_to_value (napi_env env, gdouble d);
+static gboolean fdn_enum_from_value (napi_env env, GType enum_type, napi_value value, gint * e);
+static napi_value fdn_enum_to_value (napi_env env, GType enum_type, gint e);
+static gboolean fdn_utf8_from_value (napi_env env, napi_value value, gchar ** str);
+static napi_value fdn_utf8_to_value (napi_env env, const gchar * str);
+static gboolean fdn_strv_from_value (napi_env env, napi_value value, gchar *** strv);
+static napi_value fdn_strv_to_value (napi_env env, gchar ** strv);
+static napi_value fdn_buffer_to_value (napi_env env, const guint8 * data, gsize size);
+static gboolean fdn_bytes_from_value (napi_env env, napi_value value, GBytes ** bytes);
+static napi_value fdn_bytes_to_value (napi_env env, GBytes * bytes);
+static gboolean fdn_vardict_from_value (napi_env env, napi_value value, GHashTable ** vardict);
+static napi_value fdn_vardict_to_value (napi_env env, GHashTable * vardict);
+static gboolean fdn_variant_from_value (napi_env env, napi_value value, GVariant ** variant);
+static napi_value fdn_variant_to_value (napi_env env, GVariant * variant);
+static gboolean fdn_gvalue_from_value (napi_env env, GType type, napi_value js_value, GValue * value);
+static napi_value fdn_gvalue_to_value (napi_env env, GValue * value);
+static gboolean fdn_error_from_value (napi_env env, napi_value value, GError ** error);
+static napi_value fdn_error_to_value (napi_env env, GError * error);
+static gboolean fdn_file_from_value (napi_env env, napi_value value, GFile ** file);
+static napi_value fdn_file_to_value (napi_env env, GFile * file);
+static gboolean fdn_tls_certificate_from_value (napi_env env, napi_value value, GTlsCertificate ** certificate);
+static napi_value fdn_tls_certificate_to_value (napi_env env, GTlsCertificate * certificate);
+static gboolean fdn_options_from_value (napi_env env, GType object_type, napi_value value, gpointer * options);
+
+static napi_value fdn_object_subclass_to_value (napi_env env, GObject * object);
+static napi_value fdn_object_new (napi_env env, GObject * handle, napi_ref constructor);
+static gboolean fdn_object_wrap (napi_env env, napi_value wrapper, GObject * handle, napi_finalize finalizer);
+static gboolean fdn_object_unwrap (napi_env env, napi_value wrapper, GType expected_type, GObject ** handle);
+static void fdn_object_finalize (napi_env env, void * finalize_data, void * finalize_hint);
+static napi_value fdn_object_get_signal (napi_env env, napi_callback_info info, const gchar * name, const gchar * js_storage_name, FdnSignalBehavior behavior);
+
+static napi_value fdn_signal_new (napi_env env, GObject * handle, const gchar * name, FdnSignalBehavior behavior);
+static void fdn_signal_register (napi_env env, napi_value exports);
+static napi_value fdn_signal_construct (napi_env env, napi_callback_info info);
+static void fdn_signal_finalize (napi_env env, void * finalize_data, void * finalize_hint);
+static napi_value fdn_signal_connect (napi_env env, napi_callback_info info);
+static napi_value fdn_signal_disconnect (napi_env env, napi_callback_info info);
+static void fdn_signal_disconnect_closure (FdnSignal * self, FdnSignalClosure * closure);
+static gboolean fdn_signal_parse_arguments (napi_env env, napi_callback_info info, FdnSignal ** self, napi_value * js_self, napi_value * handler);
+static FdnSignalClosure * fdn_signal_closure_new (napi_env env, FdnSignal * sig, napi_value js_sig, napi_value handler);
+static void fdn_signal_closure_finalize (gpointer data, GClosure * closure);
+static void fdn_signal_closure_marshal (GClosure * closure, GValue * return_gvalue, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
+static void fdn_signal_closure_deliver (napi_env env, napi_value js_cb, void * context, void * data);
+
+static void fdn_keep_alive_until (napi_env env, napi_value js_object, GObject * handle, FdnIsDestroyedFunc is_destroyed, const gchar * destroy_signal_name);
+static void fdn_keep_alive_on_finalize (napi_env env, void * finalize_data, void * finalize_hint);
+static void fdn_keep_alive_on_destroy_signal (GObject * handle, gpointer user_data);
+static void fdn_keep_alive_on_destroy_signal_handler_detached (gpointer data, GClosure * closure);
+static void fdn_keep_alive_schedule_cleanup (FdnKeepAliveContext * context);
+static void fdn_keep_alive_on_tsfn_invoke (napi_env env, napi_value js_cb, void * context, void * data);
+
+static void fdn_inherit_val_val (napi_env env, napi_value sub_ctor, napi_value super_ctor, napi_value object_ctor, napi_value set_proto);
+G_GNUC_UNUSED static void fdn_inherit_val_ref (napi_env env, napi_value sub_ctor, napi_ref super_ctor, napi_value object_ctor, napi_value set_proto);
+static void fdn_inherit_ref_val (napi_env env, napi_ref sub_ctor, napi_value super_ctor, napi_value object_ctor, napi_value set_proto);
+static void fdn_inherit_ref_ref (napi_env env, napi_ref sub_ctor, napi_ref super_ctor, napi_value object_ctor, napi_value set_proto);
+
+static gchar * fdn_camel_case_to_kebab_case (const gchar * name);

frida/frida_bindgen/assets/codegen_structs.h

@@ -0,0 +1,24 @@
+struct _PyGObject
+{
+  PyObject_HEAD
+
+  gpointer handle;
+  const PyGObjectType * type;
+
+  GSList * signal_closures;
+};
+
+struct _PyGObjectType
+{
+  PyGObjectType * parent;
+  PyObject * object;
+  PyGObjectInitFromHandleFunc init_from_handle;
+  GDestroyNotify destroy;
+};
+
+struct _PyGObjectSignalClosure
+{
+  GClosure parent;
+  guint signal_id;
+  guint max_arg_count;
+};

frida/frida_bindgen/assets/codegen_typedefs.h

@@ -0,0 +1,4 @@
+typedef struct _PyGObject                      PyGObject;
+typedef void (* PyGObjectInitFromHandleFunc)  (PyObject * self, gpointer handle);
+typedef struct _PyGObjectType                  PyGObjectType;
+typedef struct _PyGObjectSignalClosure         PyGObjectSignalClosure;

frida/frida_bindgen/assets/customization_facade.exports

@@ -0,0 +1,13 @@
+querySystemParameters
+spawn
+resume
+kill
+attach
+injectLibraryFile
+injectLibraryBlob
+enumerateDevices
+getDeviceManager
+getLocalDevice
+getRemoteDevice
+getUsbDevice
+getDevice

frida/frida_bindgen/assets/customization_facade.ts

@@ -0,0 +1,157 @@
+let sharedDeviceManager: DeviceManager | null = null;
+
+export async function querySystemParameters(cancellable?: Cancellable | null): Promise<SystemParameters> {
+    const device = await getLocalDevice(cancellable);
+    return await device.querySystemParameters(cancellable);
+}
+
+export async function spawn(program: string | string[], options?: SpawnOptions, cancellable?: Cancellable | null): Promise<number> {
+    const device = await getLocalDevice(cancellable);
+    return await device.spawn(program, options, cancellable);
+}
+
+export async function resume(target: TargetProcess, cancellable?: Cancellable | null): Promise<void> {
+    const device = await getLocalDevice(cancellable);
+    await device.resume(target, cancellable);
+}
+
+export async function kill(target: TargetProcess, cancellable?: Cancellable | null): Promise<void> {
+    const device = await getLocalDevice(cancellable);
+    await device.kill(target, cancellable);
+}
+
+export async function attach(target: TargetProcess, options?: SessionOptions, cancellable?: Cancellable | null): Promise<Session> {
+    const device = await getLocalDevice(cancellable);
+    return await device.attach(target, options, cancellable);
+}
+
+export async function injectLibraryFile(target: TargetProcess, path: string, entrypoint: string, data: string,
+        cancellable?: Cancellable | null): Promise<number> {
+    const device = await getLocalDevice(cancellable);
+    return await device.injectLibraryFile(target, path, entrypoint, data, cancellable);
+}
+
+export async function injectLibraryBlob(target: TargetProcess, blob: Buffer, entrypoint: string, data: string,
+        cancellable?: Cancellable | null): Promise<number> {
+    const device = await getLocalDevice(cancellable);
+    return await device.injectLibraryBlob(target, blob, entrypoint, data, cancellable);
+}
+
+export async function enumerateDevices(cancellable?: Cancellable | null): Promise<Device[]> {
+    const deviceManager = getDeviceManager();
+    return await deviceManager.enumerateDevices(cancellable);
+};
+
+export function getDeviceManager(): DeviceManager {
+    if (sharedDeviceManager === null) {
+        sharedDeviceManager = new DeviceManager();
+    }
+    return sharedDeviceManager;
+}
+
+export function getLocalDevice(cancellable?: Cancellable | null): Promise<Device> {
+    return getMatchingDevice(device => device.type === DeviceType.Local, {}, cancellable);
+}
+
+export function getRemoteDevice(cancellable?: Cancellable | null): Promise<Device> {
+    return getMatchingDevice(device => device.type === DeviceType.Remote, {}, cancellable);
+}
+
+export function getUsbDevice(options?: GetDeviceOptions, cancellable?: Cancellable | null): Promise<Device> {
+    return getMatchingDevice(device => device.type === DeviceType.Usb, options, cancellable);
+}
+
+export function getDevice(id: string, options?: GetDeviceOptions, cancellable?: Cancellable | null): Promise<Device> {
+    return getMatchingDevice(device => device.id === id, options, cancellable);
+}
+
+export interface GetDeviceOptions {
+    timeout?: number | null;
+}
+
+async function getMatchingDevice(predicate: DevicePredicate, options: GetDeviceOptions = {}, cancellable: Cancellable | null = null): Promise<Device> {
+    const device = await findMatchingDevice(predicate, cancellable);
+    if (device !== null) {
+        return device;
+    }
+
+    const { timeout = 0 } = options;
+    if (timeout === 0) {
+        throw new Error("Device not found");
+    }
+
+    const getDeviceEventually = new Promise((resolve: (device: Device) => void, reject: (error: Error) => void) => {
+        const deviceManager = getDeviceManager();
+
+        deviceManager.added.connect(onDeviceAdded);
+
+        const timer = (timeout !== null) ? setTimeout(onTimeout, timeout) : null;
+
+        if (cancellable !== null) {
+            cancellable.cancelled.connect(onCancel);
+            if (cancellable.isCancelled) {
+                onCancel();
+                return;
+            }
+        }
+
+        findMatchingDevice(predicate, cancellable)
+            .then(device => {
+                if (device !== null) {
+                    onSuccess(device);
+                }
+            })
+            .catch(onError);
+
+        function onDeviceAdded(device: Device): void {
+            if (predicate(device)) {
+                onSuccess(device);
+            }
+        }
+
+        function onSuccess(device: Device): void {
+            stopMonitoring();
+            resolve(device);
+        }
+
+        function onError(error: Error): void {
+            stopMonitoring();
+            reject(error);
+        }
+
+        function onTimeout(): void {
+            onError(new Error("Timed out while waiting for device to appear"));
+        }
+
+        function onCancel(): void {
+            onError(new Error("Operation was cancelled"));
+        }
+
+        function stopMonitoring(): void {
+            cancellable?.cancelled.disconnect(onCancel);
+
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+
+            deviceManager.added.disconnect(onDeviceAdded);
+        }
+    });
+
+    return await getDeviceEventually;
+}
+
+async function findMatchingDevice(predicate: DevicePredicate, cancellable?: Cancellable | null): Promise<Device | null> {
+    const deviceManager = getDeviceManager();
+
+    const devices = await deviceManager.enumerateDevices(cancellable);
+
+    const matching = devices.filter(predicate);
+    if (matching.length === 0) {
+        return null;
+    }
+
+    return matching[0];
+}
+
+type DevicePredicate = (device: Device) => boolean;

frida/frida_bindgen/assets/customization_helpers.imports

@@ -0,0 +1,2 @@
+import { Minimatch } from "minimatch";
+import { Duplex } from "stream";

frida/frida_bindgen/assets/customization_helpers.ts

@@ -0,0 +1,396 @@
+const STANDARD_SPAWN_OPTION_NAMES = new Set<keyof SpawnOptions>([
+    "argv",
+    "envp",
+    "env",
+    "cwd",
+    "stdio",
+]);
+
+interface LogMessage {
+    type: "log";
+    level: LogLevel;
+    payload: string;
+}
+
+class ScriptServices implements RpcController {
+    exportsProxy = new ScriptExportsProxy(this);
+
+    #script: Script;
+    #pendingRequests = new Map<number, (error: Error | null, result?: any) => void>();
+    #nextRequestId = 1;
+
+    constructor(script: Script) {
+        this.#script = script;
+        process.nextTick(() => {
+            script.message.connect(() => {});
+        });
+    }
+
+    handleMessageIntercept = (message: Message, data: Buffer | null): boolean => {
+        if (message.type === MessageType.Send && isRpcSendMessage(message)) {
+            const [ , id, operation, ...params ] = message.payload;
+            this.#onRpcMessage(id, operation, params, data);
+            return false;
+        } else if (isLogMessage(message)) {
+            const opaqueMessage: any = message;
+            const logMessage: LogMessage = opaqueMessage;
+            this.#script.logHandler(logMessage.level, logMessage.payload);
+            return false;
+        }
+
+        return true;
+    };
+
+    request(operation: string, params: any[], data: Buffer | null, cancellable: Cancellable | null = null): Promise<any> {
+        return new Promise((resolve, reject) => {
+            const id = this.#nextRequestId++;
+
+            const complete = (error: Error | null, result?: any): void => {
+                if (cancellable !== null) {
+                    cancellable.cancelled.disconnect(onOperationCancelled);
+                }
+                this.#script.destroyed.disconnect(onScriptDestroyed);
+
+                this.#pendingRequests.delete(id);
+
+                if (error === null) {
+                    resolve(result);
+                } else {
+                    reject(error);
+                }
+            };
+
+            function onScriptDestroyed(): void {
+                complete(new Error("Script is destroyed"));
+            }
+
+            function onOperationCancelled(): void {
+                complete(new Error("Operation was cancelled"));
+            }
+
+            this.#pendingRequests.set(id, complete);
+
+            this.#script.post(["frida:rpc", id, operation, ...params], data);
+            this.#script.destroyed.connect(onScriptDestroyed);
+            if (cancellable !== null) {
+                cancellable.cancelled.connect(onOperationCancelled);
+                if (cancellable.isCancelled) {
+                    onOperationCancelled();
+                    return;
+                }
+            }
+            if (this.#script.isDestroyed) {
+                onScriptDestroyed();
+            }
+        });
+    }
+
+    #onRpcMessage(id: number, operation: RpcOperation, params: any[], data: Buffer | null) {
+        if (operation === RpcOperation.Ok || operation === RpcOperation.Error) {
+            const callback = this.#pendingRequests.get(id);
+            if (callback === undefined) {
+                return;
+            }
+
+            let value = null;
+            let error = null;
+            if (operation === RpcOperation.Ok) {
+                if (data !== null) {
+                    value = (params.length > 1) ? [params[1], data] : data;
+                } else {
+                    value = params[0];
+                }
+            } else {
+                const [message, name, stack, rawErr] = params;
+                error = new Error(message);
+                error.name = name;
+                error.stack = stack;
+                Object.assign(error, rawErr);
+            }
+
+            callback(error, value);
+        }
+    }
+}
+
+class ScriptExportsProxy implements ScriptExports {
+    [name: string]: (...args: any[]) => Promise<any>;
+
+    constructor(rpcController: RpcController) {
+        return new Proxy(this, {
+            has(target, property) {
+                return !isReservedMethodName(property);
+            },
+            get(target, property, receiver) {
+                if (typeof property === "symbol") {
+                    if (property === inspect.custom) {
+                        return inspectProxy;
+                    }
+
+                    return undefined;
+                }
+
+                if (property in target) {
+                    return target[property];
+                }
+
+                if (isReservedMethodName(property)) {
+                    return undefined;
+                }
+
+                return (...args: any[]): Promise<any> => {
+                    let cancellable: Cancellable | null = null;
+                    if (args[args.length - 1] instanceof Cancellable) {
+                        cancellable = args.pop();
+                    }
+
+                    let data: Buffer | null = null;
+                    if (Buffer.isBuffer(args[args.length - 1])) {
+                        data = args.pop();
+                    }
+
+                    return rpcController.request("call", [property, args], data, cancellable);
+                };
+            },
+            set(target, property, value, receiver) {
+                if (typeof property === "symbol") {
+                    return false;
+                }
+                target[property] = value;
+                return true;
+            },
+            ownKeys(target) {
+                return Object.getOwnPropertyNames(target);
+            },
+            getOwnPropertyDescriptor(target, property) {
+                if (property in target) {
+                    return Object.getOwnPropertyDescriptor(target, property);
+                }
+
+                if (isReservedMethodName(property)) {
+                    return undefined;
+                }
+
+                return {
+                    writable: true,
+                    configurable: true,
+                    enumerable: true
+                };
+            },
+        });
+    }
+}
+
+function inspectProxy() {
+    return "ScriptExportsProxy {}";
+}
+
+interface RpcController {
+    request(operation: string, params: any[], data: ArrayBuffer | null, cancellable: Cancellable | null): Promise<any>;
+}
+
+enum RpcOperation {
+    Ok = "ok",
+    Error = "error"
+}
+
+function isInternalMessage(message: Message): boolean {
+    return isRpcMessage(message) || isLogMessage(message);
+}
+
+function isRpcMessage(message: Message): boolean {
+    return message.type === MessageType.Send && isRpcSendMessage(message);
+}
+
+function isRpcSendMessage(message: SendMessage): boolean {
+    const payload = message.payload;
+    if (!Array.isArray(payload)) {
+        return false;
+    }
+
+    return payload[0] === "frida:rpc";
+}
+
+function isLogMessage(message: Message): boolean {
+    return message.type as string === "log";
+}
+
+function log(level: LogLevel, text: string): void {
+    switch (level) {
+        case LogLevel.Info:
+            console.log(text);
+            break;
+        case LogLevel.Warning:
+            console.warn(text);
+            break;
+        case LogLevel.Error:
+            console.error(text);
+            break;
+    }
+}
+
+const reservedMethodNames = new Set<string>([
+    "then",
+    "catch",
+    "finally",
+]);
+
+function isReservedMethodName(name: string | number | symbol): boolean {
+    return reservedMethodNames.has(name.toString());
+}
+
+const IO_PRIORITY_DEFAULT = 0;
+
+class IOStreamAdapter extends Duplex {
+    #impl: IOStream;
+    #input: InputStream;
+    #output: OutputStream;
+    #pending = new Set<Promise<void>>();
+
+    #cancellable = new Cancellable();
+
+    constructor(impl: IOStream) {
+        super({});
+
+        this.#impl = impl;
+        this.#input = impl.inputStream;
+        this.#output = impl.outputStream;
+    }
+
+    async _destroy(error: Error | null, callback: (error: Error | null) => void): Promise<void> {
+        this.#cancellable.cancel();
+
+        for (const operation of this.#pending) {
+            try {
+                await operation;
+            } catch (e) {
+            }
+        }
+
+        try {
+            await this.#impl.close(IO_PRIORITY_DEFAULT);
+        } catch (e) {
+        }
+
+        callback(error);
+    }
+
+    _read(size: number): void {
+        const operation = this.#input.read(size, IO_PRIORITY_DEFAULT, this.#cancellable)
+            .then((data: Buffer): void => {
+                const isEof = data.length === 0;
+                if (isEof) {
+                    this.push(null);
+                    return;
+                }
+
+                this.push(data);
+            })
+            .catch((error: Error): void => {
+                if (this.#impl.closed) {
+                    this.push(null);
+                }
+                this.emit("error", error);
+            });
+        this.#track(operation);
+    }
+
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+        let data: Buffer;
+        if (Buffer.isBuffer(chunk)) {
+            data = chunk;
+        } else {
+            data = Buffer.from(chunk, encoding);
+        }
+        const operation = this.#writeAll(data)
+            .then((): void => {
+                callback(null);
+            })
+            .catch((error: Error): void => {
+                callback(error);
+            });
+        this.#track(operation);
+    }
+
+    async #writeAll(data: Buffer): Promise<void> {
+        let offset = 0;
+        do {
+            const n = await this.#output.write(data.slice(offset), IO_PRIORITY_DEFAULT, this.#cancellable);
+            offset += n;
+        } while (offset !== data.length);
+    }
+
+    #track(operation: Promise<void>): void {
+        this.#pending.add(operation);
+        operation
+            .catch(_ => {})
+            .finally(() => {
+                this.#pending.delete(operation);
+            });
+    }
+}
+
+class CallbackAuthenticationService extends binding.AbstractAuthenticationService {
+    #callback: AuthenticationCallback;
+
+    constructor(callback: AuthenticationCallback) {
+        super();
+        this.#callback = callback;
+    }
+
+    async authenticate(token: string, cancellable: Cancellable | null): Promise<string> {
+        const info = await this.#callback(token);
+        return JSON.stringify(info);
+    }
+}
+
+function parseSocketAddress(address: BaseSocketAddress): SocketAddress {
+    const family = address.family;
+    switch (family) {
+        case SocketFamily.Unix: {
+            const addr = address as UnixSocketAddress;
+            switch (addr.addressType) {
+                case UnixSocketAddressType.Anonymous:
+                    return {
+                        family: "unix:anonymous",
+                    };
+                case UnixSocketAddressType.Path:
+                    return {
+                        family: "unix:path",
+                        path: addr.path.toString(),
+                    };
+                case UnixSocketAddressType.Abstract:
+                case UnixSocketAddressType.AbstractPadded:
+                    return {
+                        family: "unix:abstract",
+                        path: addr.path,
+                    };
+            }
+            break;
+        }
+        case SocketFamily.Ipv4: {
+            const addr = address as InetSocketAddress;
+            return {
+                family: "ipv4",
+                address: addr.address.toString(),
+                port: addr.port,
+            };
+        }
+        case SocketFamily.Ipv6: {
+            const addr = address as InetSocketAddress;
+            return {
+                family: "ipv6",
+                address: addr.address.toString(),
+                port: addr.port,
+                flowlabel: addr.flowinfo,
+                scopeid: addr.scopeId,
+            };
+        }
+    }
+
+    throw new Error("invalid BaseSocketAddress");
+}
+
+function objectToStrv(object: { [name: string]: string }): string[] {
+    return Object.entries(object).map(([k, v]) => `${k}=${v}`);
+}

frida/frida_bindgen/cli.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import argparse
+from io import StringIO
+from pathlib import Path
+
+from . import codegen
+from .customization import load_customizations
+from .loader import compute_model
+
+
+def main():
+    run(build_arguments())
+
+
+def build_arguments() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Generate TypeScript and Node-API bindings for Frida."
+    )
+    p.add_argument(
+        "--frida-gir",
+        required=True,
+        type=Path,
+        help="Path to the Frida .gir file.",
+    )
+    p.add_argument(
+        "--glib-gir",
+        required=True,
+        type=Path,
+        help="Path to the GLib .gir file.",
+    )
+    p.add_argument(
+        "--gobject-gir",
+        required=True,
+        type=Path,
+        help="Path to the GObject .gir file.",
+    )
+    p.add_argument(
+        "--gio-gir",
+        required=True,
+        type=Path,
+        help="Path to the GIO .gir file.",
+    )
+    p.add_argument(
+        "--output-py",
+        required=True,
+        type=Path,
+        help="Path to the output .py file.",
+    )
+    p.add_argument(
+        "--output-pyi",
+        required=True,
+        type=Path,
+        help="Path to the output .pyi file.",
+    )
+    p.add_argument(
+        "--output-c",
+        required=True,
+        type=Path,
+        help="Path to the output C file for the Python extension.",
+    )
+    return p.parse_args()
+
+
+def run(args: argparse.Namespace) -> None:
+    customizations = load_customizations()
+    model = compute_model(
+        args.frida_gir, args.glib_gir, args.gobject_gir, args.gio_gir, customizations
+    )
+
+    artefacts = codegen.generate_all(model)
+
+    with OutputFile(args.output_py) as f:
+        f.write(artefacts["py"])
+    with OutputFile(args.output_pyi) as f:
+        f.write(artefacts["pyi"])
+    with OutputFile(args.output_c) as f:
+        f.write(artefacts["c"])
+
+
+class OutputFile:
+    def __init__(self, output_path):
+        self._output_path = output_path
+        self._io = StringIO()
+
+    def __enter__(self):
+        return self._io
+
+    def __exit__(self, *exc):
+        result = self._io.getvalue()
+        if self._output_path.exists():
+            existing_contents = self._output_path.read_text(encoding="utf-8")
+            if existing_contents == result:
+                return False
+        self._output_path.write_text(result, encoding="utf-8")
+        return False

frida/frida_bindgen/customization.py

@@ -0,0 +1,924 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Mapping
+
+from .model import (ConstructorCustomizations, CustomCode, CustomDeclaration,
+                    Customizations, CustomMethod, CustomType, CustomTypeKind,
+                    EnumerationCustomizations, EnumerationMemberCustomizations,
+                    KeepAliveCustomization, MethodCustomizations,
+                    ObjectTypeCustomizations, PropertyCustomizations,
+                    SignalCustomizations, TypeCustomizations)
+
+ASSETS_DIR = Path(__file__).resolve().parent / "assets"
+CUSTOMIZATION_FACADE_EXPORTS = (
+    (ASSETS_DIR / "customization_facade.exports")
+    .read_text(encoding="utf-8")
+    .strip()
+    .split("\n")
+)
+CUSTOMIZATION_FACADE_TS = (ASSETS_DIR / "customization_facade.ts").read_text(
+    encoding="utf-8"
+)
+CUSTOMIZATION_HELPERS_IMPORTS = (
+    (ASSETS_DIR / "customization_helpers.imports")
+    .read_text(encoding="utf-8")
+    .strip()
+    .split("\n")
+)
+CUSTOMIZATION_HELPERS_TS = (ASSETS_DIR / "customization_helpers.ts").read_text(
+    encoding="utf-8"
+)
+
+
+def load_customizations() -> Customizations:
+    custom_types: List[CustomType] = {
+        "TargetProcess": CustomType(CustomTypeKind.TYPE, "ProcessID | ProcessName"),
+        "ProcessID": CustomType(CustomTypeKind.TYPE, "number"),
+        "InjecteeID": CustomType(CustomTypeKind.TYPE, "number"),
+        "FileDescriptor": CustomType(CustomTypeKind.TYPE, "number"),
+        "ProcessName": CustomType(CustomTypeKind.TYPE, "string"),
+        "SystemParameters": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+/**
+ * Operating System details.
+ */
+os: {
+    /**
+     * ID, e.g.: windows, macos, linux, ios, android, qnx, fedora, ubuntu, etc.
+     */
+    id: string;
+
+    /**
+     * Human-readable name, e.g. `"macOS"`.
+     */
+    name: string;
+
+    /**
+     * Human-readable version string, e.g. `"11.2.2"`.
+     */
+    version?: string;
+
+    /**
+     * Build version, e.g. `"21B91"`.
+     */
+    build?: string;
+}
+
+/**
+ * Platform, same as `Process.platform` in GumJS.
+ */
+platform: "windows" | "darwin" | "linux" | "freebsd" | "qnx";
+
+/**
+ * Architecture, same as `Process.arch` in GumJS.
+ */
+arch: "ia32" | "x64" | "arm" | "arm64" | "mips";
+
+/**
+ * Hardware details.
+ */
+hardware?: {
+    /**
+     * Product type, e.g. `"iPad6,3"`.
+     */
+    product?: string;
+
+    /**
+     * Hardware platform, e.g. `"t8010"`.
+     */
+    platform?: string;
+
+    /**
+     * Hardware model, e.g. `"J71bAP"`.
+     */
+    model?: string;
+}
+
+/**
+ * Level of access.
+ */
+access: "full" | "jailed";
+
+/**
+ * System name, e.g. `"Ole André’s iPhone"`.
+ */
+name?: string;
+
+/**
+ * iOS UDID (Unique Device ID).
+ */
+udid?: string;
+
+/**
+ * Details about cellular and networking interfaces.
+ */
+interfaces?: SystemInterface[];
+
+/**
+ * Android API level, e.g.: `30`.
+ */
+apiLevel?: number;
+
+[name: string]: any;
+            """,
+        ),
+        "SystemInterface": CustomType(
+            CustomTypeKind.TYPE, "NetworkInterface | CellularInterface"
+        ),
+        "NetworkInterface": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+type: "ethernet" | "wifi" | "bluetooth";
+
+/**
+ * MAC address, e.g.: `"aa:bb:cc:dd:ee:ff"`.
+ */
+address: string;
+            """,
+        ),
+        "CellularInterface": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+type: "cellular";
+
+/**
+ * Phone number, e.g. `"+47 123 45 678"`.
+ */
+phoneNumber: string;
+            """,
+        ),
+        "SpawnOptions": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+argv?: string[];
+envp?: { [name: string]: string };
+env?: { [name: string]: string };
+cwd?: string;
+stdio?: Stdio;
+
+[name: string]: any;
+            """,
+        ),
+        "RelayProperties": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+address: string;
+username: string;
+password: string;
+kind: RelayKind;
+            """,
+        ),
+        "Message": CustomType(CustomTypeKind.TYPE, "SendMessage | ErrorMessage"),
+        "MessageType": CustomType(
+            CustomTypeKind.ENUM,
+            """
+Send = "send",
+Error = "error"
+            """,
+        ),
+        "SendMessage": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+type: MessageType.Send;
+payload: any;
+            """,
+        ),
+        "ErrorMessage": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+type: MessageType.Error;
+description: string;
+stack?: string;
+fileName?: string;
+lineNumber?: number;
+columnNumber?: number;
+            """,
+        ),
+        "ScriptLogHandler": CustomType(
+            CustomTypeKind.TYPE, "(level: LogLevel, text: string) => void"
+        ),
+        "ScriptExports": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+[name: string]: (...args: any[]) => Promise<any>;
+            """,
+        ),
+        "LogLevel": CustomType(
+            CustomTypeKind.ENUM,
+            """
+Info = "info",
+Warning = "warning",
+Error = "error",
+            """,
+        ),
+        "EnableDebuggerOptions": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+port?: number;
+            """,
+        ),
+        "PortalServiceOptions": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+clusterParams?: EndpointParameters;
+controlParams?: EndpointParameters;
+            """,
+        ),
+        "PortalConnectionId": CustomType(CustomTypeKind.TYPE, "number"),
+        "PortalConnectionTag": CustomType(CustomTypeKind.TYPE, "string"),
+        "EndpointParametersSubset": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+address?: string;
+port?: number;
+certificate?: string;
+origin?: string;
+authentication?: AuthenticationScheme;
+assetRoot?: string;
+            """,
+        ),
+        "AuthenticationScheme": CustomType(
+            CustomTypeKind.TYPE,
+            "TokenAuthenticationScheme | CallbackAuthenticationScheme",
+        ),
+        "TokenAuthenticationScheme": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+scheme: "token";
+token: string;
+            """,
+        ),
+        "CallbackAuthenticationScheme": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+scheme: "callback";
+callback: AuthenticationCallback;
+            """,
+        ),
+        "AuthenticationCallback": CustomType(
+            CustomTypeKind.TYPE,
+            "(token: string) => Promise<AuthenticatedSessionInfo>",
+        ),
+        "AuthenticatedSessionInfo": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+[key: string]: any;
+            """,
+        ),
+        "SocketAddress": CustomType(
+            CustomTypeKind.TYPE,
+            "IPV4SocketAddress | IPV6SocketAddress | AnonymousUnixSocketAddress | PathUnixSocketAddress | AbstractUnixSocketAddress",
+        ),
+        "IPV4SocketAddress": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+family: "ipv4";
+address: string;
+port: number;
+            """,
+        ),
+        "IPV6SocketAddress": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+family: "ipv6";
+address: string;
+port: number;
+flowlabel: number;
+scopeid: number;
+            """,
+        ),
+        "AnonymousUnixSocketAddress": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+family: "unix:anonymous";
+            """,
+        ),
+        "PathUnixSocketAddress": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+family: "unix:path";
+path: string;
+            """,
+        ),
+        "AbstractUnixSocketAddress": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+family: "unix:abstract";
+path: Buffer;
+            """,
+        ),
+        "Variant": CustomType(
+            CustomTypeKind.TYPE, "VariantValue | [type: symbol, value: VariantValue]"
+        ),
+        "VariantValue": CustomType(
+            CustomTypeKind.TYPE,
+            """
+| boolean
+| number
+| string
+| Buffer
+| Variant[]
+| VariantDict
+            """,
+        ),
+        "VariantDict": CustomType(
+            CustomTypeKind.INTERFACE,
+            """
+[key: string]: Variant;
+            """,
+        ),
+    }
+
+    type_customizations: Mapping[str, TypeCustomizations] = {
+        "DeviceManager": ObjectTypeCustomizations(
+            signals={
+                "added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "changed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+            },
+            cleanup="close",
+        ),
+        "Device": ObjectTypeCustomizations(
+            methods={
+                "query_system_parameters": MethodCustomizations(
+                    return_typing="Promise<SystemParameters>",
+                    return_wrapper="as SystemParameters",
+                ),
+                "spawn": MethodCustomizations(
+                    param_typings=[
+                        "programOrArgv: string | string[]",
+                        "opts?: SpawnOptions",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    return_typing="Promise<ProcessID>",
+                    custom_logic="""
+const options: RawSpawnOptions = {};
+
+let program: string;
+let argv;
+if (typeof programOrArgv === "string") {
+    program = programOrArgv;
+    argv = opts?.argv;
+} else {
+    program = programOrArgv[0];
+    argv = programOrArgv;
+    if (argv.length === 1) {
+        argv = undefined;
+    }
+}
+if (argv !== undefined) {
+    options.argv = argv;
+}
+
+if (opts !== undefined) {
+    const envp = opts.envp;
+    if (envp !== undefined) {
+        options.envp = objectToStrv(envp);
+    }
+
+    const env = opts.env;
+    if (env !== undefined) {
+        options.env = objectToStrv(env);
+    }
+
+    const cwd = opts.cwd;
+    if (cwd !== undefined) {
+        options.cwd = cwd;
+    }
+
+    options.aux = Object.fromEntries(Object.entries(opts).filter(([k, v]) => !STANDARD_SPAWN_OPTION_NAMES.has(k)));
+}
+                    """,
+                ),
+                "input": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "data: Buffer",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "resume": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "kill": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "attach": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "options?: SessionOptions",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "inject_library_file": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "path: string",
+                        "entrypoint: string",
+                        "data: string",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    return_typing="Promise<InjecteeID>",
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "inject_library_blob": MethodCustomizations(
+                    param_typings=[
+                        "target: TargetProcess",
+                        "blob: Buffer",
+                        "entrypoint: string",
+                        "data: string",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    return_typing="Promise<InjecteeID>",
+                    custom_logic="const pid = await this.#getPid(target, cancellable);",
+                ),
+                "open_channel": MethodCustomizations(
+                    return_typing='Promise<import("stream").Duplex>',
+                    return_wrapper="new IOStreamAdapter",
+                ),
+            },
+            properties={
+                "dtype": PropertyCustomizations(
+                    js_name="type",
+                ),
+            },
+            signals={
+                "spawn-added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "spawn-removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "child-added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "child-removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "process-crashed": SignalCustomizations(
+                    behavior="FDN_SIGNAL_KEEP_ALIVE"
+                ),
+                "output": SignalCustomizations(
+                    behavior="FDN_SIGNAL_KEEP_ALIVE",
+                    transform={
+                        0: ("pid: ProcessID", None),
+                        1: ("fd: FileDescriptor", None),
+                    },
+                ),
+                "uninjected": SignalCustomizations(
+                    behavior="FDN_SIGNAL_KEEP_ALIVE",
+                    transform={
+                        0: ("id: InjecteeID", None),
+                    },
+                ),
+            },
+            custom_code=CustomCode(
+                methods=[
+                    CustomMethod(
+                        typing="getProcess(name: string, options?: ProcessMatchOptions, cancellable?: Cancellable | null): Promise<Process>",
+                        code="""
+async getProcess(name: string, options: ProcessMatchOptions = {}, cancellable?: Cancellable | null): Promise<Process> {
+    const {
+        scope = Scope.Minimal,
+    } = options;
+    const processes = await this.enumerateProcesses({ scope }, cancellable);
+    const mm = new Minimatch(name.toLowerCase());
+    const matching = processes.filter(process => mm.match(process.name.toLowerCase()));
+    if (matching.length === 1) {
+        return matching[0];
+    } else if (matching.length > 1) {
+        throw new Error("Ambiguous name; it matches: " + matching.map(process => `${process.name} (pid: ${process.pid})`).join(", "));
+    } else {
+        throw new Error("Process not found");
+    }
+}
+""",
+                    ),
+                    CustomMethod(
+                        typing=None,
+                        code="""
+async #getPid(target: TargetProcess, cancellable?: Cancellable | null): Promise<ProcessID> {
+    if (typeof target === "number") {
+        return target;
+    }
+
+    const process = await this.getProcess(target, {}, cancellable);
+    return process.pid;
+}
+""",
+                    ),
+                ],
+            ),
+        ),
+        "SpawnOptions": ObjectTypeCustomizations(js_name="RawSpawnOptions"),
+        "Bus": ObjectTypeCustomizations(
+            methods={
+                "post": MethodCustomizations(
+                    param_typings=[
+                        "message: any",
+                        "data?: Buffer | null",
+                    ],
+                    custom_logic="const json = JSON.stringify(message);",
+                ),
+            },
+            signals={
+                "detached": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
+                "message": SignalCustomizations(
+                    behavior="FDN_SIGNAL_KEEP_ALIVE",
+                    transform={
+                        0: ("message: any", "JSON.parse"),
+                    },
+                ),
+            },
+        ),
+        "Service": ObjectTypeCustomizations(
+            keep_alive=KeepAliveCustomization(
+                is_destroyed_function="is_closed", destroy_signal_name="close"
+            ),
+        ),
+        "Relay": ObjectTypeCustomizations(
+            constructor=ConstructorCustomizations(
+                param_typings=[
+                    "properties: RelayProperties",
+                ],
+                custom_logic="const { address, username, password, kind } = properties;",
+            ),
+        ),
+        "RelayKind": EnumerationCustomizations(
+            members={
+                "turn_udp": EnumerationMemberCustomizations(js_name="TurnUDP"),
+                "turn_tcp": EnumerationMemberCustomizations(js_name="TurnTCP"),
+                "turn_tls": EnumerationMemberCustomizations(js_name="TurnTLS"),
+            },
+        ),
+        "Script": ObjectTypeCustomizations(
+            methods={
+                "is_destroyed": MethodCustomizations(hide=True),
+                "post": MethodCustomizations(
+                    param_typings=[
+                        "message: any",
+                        "data?: Buffer | null",
+                    ],
+                    custom_logic="const json = JSON.stringify(message);",
+                ),
+                "enable_debugger": MethodCustomizations(
+                    param_typings=[
+                        "options?: EnableDebuggerOptions",
+                        "cancellable?: Cancellable | null",
+                    ],
+                    custom_logic="const port = options?.port ?? 0;",
+                ),
+            },
+            signals={
+                "message": SignalCustomizations(
+                    transform={
+                        0: ("message: Message", "JSON.parse"),
+                    },
+                    intercept="this.#services.handleMessageIntercept",
+                ),
+            },
+            custom_code=CustomCode(
+                declarations=[
+                    CustomDeclaration(
+                        typing=None, code="#services = new ScriptServices(this);"
+                    ),
+                    CustomDeclaration(
+                        typing="logHandler: ScriptLogHandler",
+                        code="logHandler: ScriptLogHandler = log;",
+                    ),
+                ],
+                methods=[
+                    CustomMethod(
+                        typing="readonly isDestroyed: boolean",
+                        code="""
+get isDestroyed(): boolean {
+    return this._isDestroyed();
+}
+""",
+                    ),
+                    CustomMethod(
+                        typing="readonly exports: ScriptExports",
+                        code="""
+get exports(): ScriptExports {
+    return this.#services.exportsProxy;
+}
+""",
+                    ),
+                    CustomMethod(
+                        typing="readonly defaultLogHandler: ScriptLogHandler",
+                        code="""
+get defaultLogHandler(): ScriptLogHandler {
+    return log;
+}
+""",
+                    ),
+                ],
+            ),
+            keep_alive=KeepAliveCustomization(
+                is_destroyed_function="is_destroyed", destroy_signal_name="destroyed"
+            ),
+        ),
+        "ScriptRuntime": EnumerationCustomizations(
+            members={
+                "qjs": EnumerationMemberCustomizations(js_name="QJS"),
+            },
+        ),
+        "ControlService": ObjectTypeCustomizations(
+            methods={
+                "start": MethodCustomizations(ref_keep_alive=True),
+                "stop": MethodCustomizations(unref_keep_alive=True),
+                "get_endpoint_params": MethodCustomizations(drop=True),
+            },
+            properties={
+                "endpoint-params": PropertyCustomizations(drop=True),
+            },
+        ),
+        "PortalService": ObjectTypeCustomizations(
+            constructor=ConstructorCustomizations(
+                param_typings=[
+                    "options?: PortalServiceOptions",
+                ],
+                custom_logic="""
+const clusterParams = options?.clusterParams ?? new EndpointParameters();
+const controlParams = options?.controlParams ?? null;
+""",
+            ),
+            methods={
+                "start": MethodCustomizations(ref_keep_alive=True),
+                "stop": MethodCustomizations(unref_keep_alive=True),
+                "kick": MethodCustomizations(
+                    param_typings=[
+                        "connectionId: PortalConnectionId",
+                    ],
+                ),
+                "post": MethodCustomizations(
+                    param_typings=[
+                        "connectionId: PortalConnectionId",
+                        "message: any",
+                        "data?: Buffer | null",
+                    ],
+                    custom_logic="const json = JSON.stringify(message);",
+                ),
+                "narrowcast": MethodCustomizations(
+                    param_typings=[
+                        "tag: string",
+                        "message: any",
+                        "data?: Buffer | null",
+                    ],
+                    custom_logic="const json = JSON.stringify(message);",
+                ),
+                "broadcast": MethodCustomizations(
+                    param_typings=[
+                        "message: any",
+                        "data?: Buffer | null",
+                    ],
+                    custom_logic="const json = JSON.stringify(message);",
+                ),
+                "enumerate_tags": MethodCustomizations(
+                    param_typings=[
+                        "connectionId: PortalConnectionId",
+                    ],
+                ),
+                "tag": MethodCustomizations(
+                    param_typings=[
+                        "connectionId: PortalConnectionId",
+                        "tag: string",
+                    ],
+                ),
+                "untag": MethodCustomizations(
+                    param_typings=[
+                        "connectionId: PortalConnectionId",
+                        "tag: string",
+                    ],
+                ),
+            },
+            signals={
+                "node-connected": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
+                    },
+                ),
+                "node-joined": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                    },
+                ),
+                "node-left": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                    },
+                ),
+                "node-disconnected": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
+                    },
+                ),
+                "controller-connected": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
+                    },
+                ),
+                "controller-disconnected": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
+                    },
+                ),
+                "authenticated": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("sessionInfo: AuthenticatedSessionInfo", "JSON.parse"),
+                    },
+                ),
+                "subscribe": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                    },
+                ),
+                "message": SignalCustomizations(
+                    transform={
+                        0: ("connectionId: PortalConnectionId", None),
+                        1: ("message: any", "JSON.parse"),
+                    },
+                ),
+            },
+        ),
+        "EndpointParameters": ObjectTypeCustomizations(
+            constructor=ConstructorCustomizations(
+                param_typings=[
+                    "params?: EndpointParametersSubset",
+                ],
+                custom_logic="""
+const address = params?.address ?? null;
+const port = params?.port ?? 0;
+const certificate = params?.certificate ?? null;
+const origin = params?.origin ?? null;
+
+let authService: AuthenticationService | null = null;
+const auth = params?.authentication;
+if (auth !== undefined) {
+    if (auth.scheme === "token") {
+        authService = new StaticAuthenticationService(auth.token);
+    } else {
+        authService = new CallbackAuthenticationService(auth.callback);
+    }
+}
+
+const assetRoot = params?.assetRoot ?? null;
+""",
+            ),
+        ),
+        "Injector": ObjectTypeCustomizations(drop=True),
+        "RpcClient": ObjectTypeCustomizations(drop=True),
+        "RpcPeer": ObjectTypeCustomizations(drop=True),
+        "Cancellable": ObjectTypeCustomizations(
+            methods={
+                "is_cancelled": MethodCustomizations(hide=True),
+                "set_error_if_cancelled": MethodCustomizations(
+                    js_name="throwIfCancelled",
+                    return_typing="void",
+                ),
+                "make_pollfd": MethodCustomizations(drop=True),
+                "release_fd": MethodCustomizations(drop=True),
+                "source_new": MethodCustomizations(drop=True),
+            },
+            custom_code=CustomCode(
+                methods=[
+                    CustomMethod(
+                        typing="readonly isCancelled: boolean",
+                        code="""
+get isCancelled(): boolean {
+    return this._isCancelled();
+}
+""",
+                    ),
+                ],
+            ),
+        ),
+        "IOStream": ObjectTypeCustomizations(
+            methods={
+                "close": MethodCustomizations(drop=True),
+                "close_async": MethodCustomizations(js_name="close"),
+                "splice_async": MethodCustomizations(drop=True),
+                "has_pending": MethodCustomizations(drop=True),
+                "set_pending": MethodCustomizations(drop=True),
+                "clear_pending": MethodCustomizations(drop=True),
+            },
+        ),
+        "InputStream": ObjectTypeCustomizations(
+            methods={
+                "close": MethodCustomizations(drop=True),
+                "close_async": MethodCustomizations(js_name="close"),
+                "read": MethodCustomizations(drop=True),
+                "read_async": MethodCustomizations(drop=True),
+                "read_all": MethodCustomizations(drop=True),
+                "read_all_async": MethodCustomizations(drop=True),
+                "read_bytes": MethodCustomizations(drop=True),
+                "read_bytes_async": MethodCustomizations(js_name="read"),
+                "skip": MethodCustomizations(drop=True),
+                "skip_async": MethodCustomizations(js_name="skip"),
+                "is_closed": MethodCustomizations(drop=True),
+                "has_pending": MethodCustomizations(drop=True),
+                "set_pending": MethodCustomizations(drop=True),
+                "clear_pending": MethodCustomizations(drop=True),
+            },
+        ),
+        "OutputStream": ObjectTypeCustomizations(
+            methods={
+                "close": MethodCustomizations(drop=True),
+                "close_async": MethodCustomizations(js_name="close"),
+                "flush": MethodCustomizations(drop=True),
+                "flush_async": MethodCustomizations(js_name="flush"),
+                "write": MethodCustomizations(drop=True),
+                "write_async": MethodCustomizations(drop=True),
+                "write_all": MethodCustomizations(drop=True),
+                "write_all_async": MethodCustomizations(drop=True),
+                "write_bytes": MethodCustomizations(drop=True),
+                "write_bytes_async": MethodCustomizations(js_name="write"),
+                "writev": MethodCustomizations(drop=True),
+                "writev_async": MethodCustomizations(drop=True),
+                "writev_all": MethodCustomizations(drop=True),
+                "writev_all_async": MethodCustomizations(drop=True),
+                "splice": MethodCustomizations(drop=True),
+                "splice_async": MethodCustomizations(drop=True),
+                "is_closing": MethodCustomizations(drop=True),
+                "is_closed": MethodCustomizations(drop=True),
+                "has_pending": MethodCustomizations(drop=True),
+                "set_pending": MethodCustomizations(drop=True),
+                "clear_pending": MethodCustomizations(drop=True),
+            },
+        ),
+        "UnixSocketAddress": ObjectTypeCustomizations(
+            methods={
+                "get_path": MethodCustomizations(
+                    return_typing="Buffer",
+                    return_cconversion="fdn_buffer_to_value (env, (const guint8 *) retval, g_unix_socket_address_get_path_len (handle))",
+                ),
+                "get_path_len": MethodCustomizations(drop=True),
+                "get_is_abstract": MethodCustomizations(drop=True),
+            },
+            properties={
+                "path": PropertyCustomizations(typing="path: Buffer"),
+                "abstract": PropertyCustomizations(drop=True),
+                "path-as-array": PropertyCustomizations(drop=True),
+            },
+        ),
+        "SocketAddress": ObjectTypeCustomizations(
+            js_name="BaseSocketAddress",
+            constructor=ConstructorCustomizations(drop=True),
+            methods={
+                "to_native": MethodCustomizations(drop=True),
+            },
+        ),
+        "SocketConnectable": ObjectTypeCustomizations(drop_abstract_base=True),
+        "InetAddress": ObjectTypeCustomizations(
+            properties={
+                "bytes": PropertyCustomizations(drop=True),
+            },
+        ),
+        "Object": ObjectTypeCustomizations(
+            js_name="BaseObject",
+            methods={
+                "is_floating": MethodCustomizations(drop=True),
+                "ref": MethodCustomizations(drop=True),
+                "ref_sink": MethodCustomizations(drop=True),
+                "unref": MethodCustomizations(drop=True),
+                "getv": MethodCustomizations(drop=True),
+                "get_property": MethodCustomizations(drop=True),
+                "set_property": MethodCustomizations(drop=True),
+                "notify_by_pspec": MethodCustomizations(drop=True),
+                "freeze_notify": MethodCustomizations(drop=True),
+                "thaw_notify": MethodCustomizations(drop=True),
+                "bind_property": MethodCustomizations(drop=True),
+                "bind_property_full": MethodCustomizations(drop=True),
+                "bind_property_with_closures": MethodCustomizations(drop=True),
+                "force_floating": MethodCustomizations(drop=True),
+                "get_data": MethodCustomizations(drop=True),
+                "get_qdata": MethodCustomizations(drop=True),
+                "run_dispose": MethodCustomizations(drop=True),
+                "set_data": MethodCustomizations(drop=True),
+                "steal_data": MethodCustomizations(drop=True),
+                "steal_qdata": MethodCustomizations(drop=True),
+                "watch_closure": MethodCustomizations(drop=True),
+            },
+            signals={
+                "notify": SignalCustomizations(drop=True),
+            },
+        ),
+    }
+
+    return Customizations(
+        custom_types,
+        type_customizations,
+        CUSTOMIZATION_FACADE_EXPORTS,
+        CUSTOMIZATION_FACADE_TS,
+        CUSTOMIZATION_HELPERS_IMPORTS,
+        CUSTOMIZATION_HELPERS_TS,
+    )

frida/frida_bindgen/loader.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from pathlib import Path
+
+from .model import Customizations, Model, parse_gir
+
+INCLUDED_GIO_OBJECT_TYPES = [
+    "Cancellable",
+    "IOStream",
+    "InputStream",
+    "OutputStream",
+    "SocketAddress",
+    "SocketAddressEnumerator",
+    "SocketConnectable",
+    "InetSocketAddress",
+    "InetAddress",
+    "UnixSocketAddress",
+]
+INCLUDED_GIO_ENUMERATIONS = [
+    "FileMonitorEvent",
+    "SocketFamily",
+    "UnixSocketAddressType",
+]
+
+
+def compute_model(
+    frida_gir: Path,
+    glib_gir: Path,
+    gobject_gir: Path,
+    gio_gir: Path,
+    customizations: Customizations,
+) -> Model:
+    glib = parse_gir(glib_gir, [])
+    gobject = parse_gir(gobject_gir, [glib])
+    gio = parse_gir(gio_gir, [glib, gobject])
+    frida = parse_gir(frida_gir, [glib, gobject, gio])
+
+    object_types = OrderedDict()
+    object_types["Object"] = gobject.object_types["Object"]
+    object_types.update(frida.object_types)
+    for t in INCLUDED_GIO_OBJECT_TYPES:
+        object_types[t] = gio.object_types[t]
+
+    enumerations = OrderedDict(frida.enumerations)
+    for t in INCLUDED_GIO_ENUMERATIONS:
+        enumerations[t] = gio.enumerations[t]
+
+    model = Model(
+        frida.namespace,
+        object_types,
+        enumerations,
+        customizations,
+    )
+
+    for t in object_types.values():
+        t.model = model
+    for t in enumerations.values():
+        t.model = model
+
+    return model

frida/meson.build

@@ -1,6 +1,95 @@
-frida_sources = [
-  '__init__.py',
-  'core.py',
-]
+if frida_core_dep.type_name() == 'internal'
+  frida_core_subprj = subproject('frida-core')
+  frida_gir = frida_core_subprj.get_variable('core_public_gir')
+  glib_gir = frida_core_subprj.get_variable('glib_gir')
+  gobject_gir = frida_core_subprj.get_variable('gobject_gir')
+  gio_gir = frida_core_subprj.get_variable('gio_gir')
+else
+  girdir = frida_core_dep.get_variable('frida_girdir')
+  frida_gir = girdir / 'Frida-1.0.gir'
+  glib_gir = girdir / 'GLib-2.0.gir'
+  gobject_gir = girdir / 'GObject-2.0.gir'
+  gio_gir = girdir / 'Gio-2.0.gir'
+endif
 
-install_data(frida_sources, install_dir: join_paths(python_site_packages, 'frida'))
+env = environment()
+env.set('PYTHONPATH', meson.current_source_dir())
+
+code = custom_target('binding-code',
+  output: [
+    '__init__.py',
+    '__init__.pyi',
+    'extension.c',
+  ],
+  input: [
+    frida_gir,
+    glib_gir,
+    gobject_gir,
+    gio_gir,
+    files(
+      'frida_bindgen' / '__init__.py',
+      'frida_bindgen' / '__main__.py',
+      'frida_bindgen' / 'cli.py',
+      'frida_bindgen' / 'codegen.py',
+      'frida_bindgen' / 'customization.py',
+      'frida_bindgen' / 'loader.py',
+      'frida_bindgen' / 'model.py',
+      'frida_bindgen' / 'assets' / 'codegen_gobject_globals.c',
+      'frida_bindgen' / 'assets' / 'codegen_gobject_methods.c',
+      'frida_bindgen' / 'assets' / 'codegen_gobject_prototypes.h',
+      'frida_bindgen' / 'assets' / 'codegen_helpers.c',
+      'frida_bindgen' / 'assets' / 'codegen_helpers.ts',
+      'frida_bindgen' / 'assets' / 'codegen_macros.h',
+      'frida_bindgen' / 'assets' / 'codegen_prototypes.h',
+      'frida_bindgen' / 'assets' / 'codegen_structs.h',
+      'frida_bindgen' / 'assets' / 'codegen_typedefs.h',
+      'frida_bindgen' / 'assets' / 'customization_facade.exports',
+      'frida_bindgen' / 'assets' / 'customization_facade.ts',
+      'frida_bindgen' / 'assets' / 'customization_helpers.imports',
+      'frida_bindgen' / 'assets' / 'customization_helpers.ts',
+    )
+  ],
+  command: [
+    python, '-m', 'frida_bindgen',
+    '--frida-gir=@INPUT0@',
+    '--glib-gir=@INPUT1@',
+    '--gobject-gir=@INPUT2@',
+    '--gio-gir=@INPUT3@',
+    '--output-py=@OUTPUT0@',
+    '--output-pyi=@OUTPUT1@',
+    '--output-c=@OUTPUT2@',
+  ],
+  env: env,
+  install: true,
+  install_dir: [
+    python.get_install_dir() / 'frida',
+    python.get_install_dir() / 'frida' / '_frida',
+    false,
+  ]
+)
+
+py_sources = [
+  'py.typed',
+]
+python.install_sources(py_sources, subdir: 'frida', pure: false)
+
+extension_py_sources = [
+  'py.typed',
+]
+python.install_sources(extension_py_sources, subdir: 'frida' / '_frida', pure: false)
+
+extra_link_args = []
+if host_os_family == 'darwin'
+  extra_link_args += '-Wl,-exported_symbol,_PyInit__frida'
+elif host_os_family != 'windows'
+  extra_link_args += '-Wl,--version-script,' + meson.current_source_dir() / 'extension.version'
+endif
+
+extension = python.extension_module('_frida', code[2],
+  limited_api: '3.7',
+  c_args: frida_component_cflags,
+  link_args: extra_link_args,
+  dependencies: [python_dep, frida_core_dep, os_deps],
+  install: true,
+  subdir: 'frida',
+)

make.bat

@@ -0,0 +1,23 @@
+@setlocal
+@echo off
+rem:: Based on: https://github.com/microsoft/terminal/issues/217#issuecomment-737594785
+goto :_start_
+
+:set_real_dp0
+set dp0=%~dp0
+set "dp0=%dp0:~0,-1%"
+goto :eof
+
+:_start_
+call :set_real_dp0
+
+if not exist "%dp0%\releng\meson\meson.py" (
+  pushd "%dp0%" & git submodule update --init --recursive --depth 1 & popd
+  if %errorlevel% neq 0 exit /b %errorlevel%
+)
+
+endlocal & goto #_undefined_# 2>nul || title %COMSPEC% & python ^
+    -c "import sys; sys.path.insert(0, sys.argv[1]); from releng.meson_make import main; main()" ^
+    "%dp0%" ^
+    .\build ^
+    %*

meson.build

@@ -1,11 +1,11 @@
-project('frida-python', 'c', version: '1.0.0')
+project('frida-python', 'c',
+  version: run_command(find_program('python3'), files('setup.py'), '-V',
+    capture: true,
+    check: true).stdout().strip(),
+  meson_version: '>=1.3.0',
+)
 
-host_os = host_machine.system()
-if host_os == 'android'
-  host_os_family = 'linux'
-else
-  host_os_family = host_os
-endif
+python = import('python').find_installation()
 
 cc = meson.get_compiler('c')
 
@@ -19,81 +19,22 @@ if ndebug == 'true' or (ndebug == 'if-release' and not get_option('debug'))
   ]
 endif
 
-target_conditionals_prefix = '#include <TargetConditionals.h>'
+python_dep = python.dependency()
+frida_core_dep = dependency('frida-core-1.0', default_options: [
+  'frida_version=' + meson.project_version().replace('.dev', '-dev.'),
+])
 
-is_macos_src = target_conditionals_prefix + '''
-#if !TARGET_OS_OSX
-# error Not macOS
-#endif
-'''
-if cc.compiles(is_macos_src, name: 'compiling for macOS')
-  host_os = 'macos'
-endif
-
-is_ios_src = target_conditionals_prefix + '''
-#if !TARGET_OS_IOS
-# error Not iOS
-#endif
-'''
-if cc.compiles(is_ios_src, name: 'compiling for iOS')
-  host_os = 'ios'
-endif
-
-if cc.has_header('android/api-level.h')
-  host_os = 'android'
-endif
-
-python_incdir = get_option('python_incdir')
-if python_incdir == ''
-  python = get_option('python')
-  if python == ''
-    python = find_program('python3', required: false)
-    if not python.found()
-      python = find_program('python')
-    endif
-  endif
-
-  result = run_command(python, '-c',
-    'import sys; sys.stdout.write(f"{sys.version_info[0]}.{sys.version_info[1]}")',
-    check: true)
-  python_version = result.stdout()
-  python_name = 'python' + python_version
-
-  result = run_command(python, '-c',
-    'from distutils import sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())',
-    check: true)
-  python_incdir = result.stdout()
-else
-  py_major_v = cc.get_define('PY_MAJOR_VERSION',
-    prefix: '#include <patchlevel.h>',
-    args: ['-I' + python_incdir])
-
-  py_minor_v = cc.get_define('PY_MINOR_VERSION',
-    prefix: '#include <patchlevel.h>',
-    args: ['-I' + python_incdir])
-
-  python_version = py_major_v + '.' + py_minor_v
-  python_name = 'python' + python_version
-endif
-
-python_site_packages = join_paths(get_option('libdir'), python_name, 'site-packages')
-
-cdata = configuration_data()
-
-cdata.set('HAVE_' + host_os_family.to_upper(), 1)
-if host_os != host_os_family
-  cdata.set('HAVE_' + host_os.to_upper(), 1)
-endif
-
-frida_core_dep = dependency('frida-core-1.0')
 os_deps = []
+host_os_family = host_machine.system()
 if host_os_family != 'windows'
   os_deps += dependency('gio-unix-2.0')
 endif
 
-configure_file(input: 'config.h.in',
-  output: 'config.h',
-  configuration: cdata)
-
-subdir('src')
 subdir('frida')
+
+#test('frida-python', python,
+#  args: ['-m', 'unittest', 'discover'],
+#  workdir: meson.current_source_dir(),
+#  env: {'PYTHONPATH': meson.current_build_dir() / 'src'},
+#  timeout: 30,
+#)

meson_options.txt

@@ -1,11 +0,0 @@
-option('python',
-  type: 'string',
-  value: '',
-  description: 'Python interpreter to build for'
-)
-
-option('python_incdir',
-  type: 'string',
-  value: '',
-  description: 'Python headers directory to build against'
-)

setup.py

@@ -1,109 +1,25 @@
 import os
 import platform
 import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Iterator
 
 from setuptools import setup
 from setuptools.command.build_ext import build_ext
 from setuptools.extension import Extension
 
-package_dir = os.path.dirname(os.path.realpath(__file__))
-pkg_info = os.path.join(package_dir, "PKG-INFO")
-in_source_package = os.path.isfile(pkg_info)
-if in_source_package:
-    with open(pkg_info, "r", encoding="utf-8") as f:
-        version_line = [line for line in f if line.startswith("Version: ")][0].strip()
-    frida_version = version_line[9:]
-else:
-    frida_version = os.environ.get("FRIDA_VERSION", "0.0.0")
-with open(os.path.join(package_dir, "README.md"), "r", encoding="utf-8") as f:
-    long_description = f.read()
-frida_extension = os.environ.get("FRIDA_EXTENSION", None)
+SOURCE_ROOT = Path(__file__).resolve().parent
+FRIDA_EXTENSION = os.environ.get("FRIDA_EXTENSION", None)
 
 
-class FridaPrebuiltExt(build_ext):
-    def build_extension(self, ext):
-        target = self.get_ext_fullpath(ext.name)
-        target_dir = os.path.dirname(target)
-        os.makedirs(target_dir, exist_ok=True)
-
-        shutil.copyfile(frida_extension, target)
-
-
-class FridaMissingDevkitBuildExt(build_ext):
-    def build_extension(self, ext):
-        raise RuntimeError(
-            "Need frida-core devkit to build from source.\n"
-            "Download one from https://github.com/frida/frida/releases, "
-            "extract it to a directory,\n"
-            "and then add an environment variable named FRIDA_CORE_DEVKIT "
-            "pointing at the directory."
-        )
-
-
-include_dirs = []
-library_dirs = []
-libraries = []
-extra_link_args = []
-
-cmdclass = {}
-if frida_extension is not None:
-    cmdclass["build_ext"] = FridaPrebuiltExt
-else:
-    devkit_dir = os.environ.get("FRIDA_CORE_DEVKIT", None)
-    if devkit_dir is not None:
-        include_dirs += [devkit_dir]
-        library_dirs += [devkit_dir]
-        libraries += ["frida-core"]
-
-        system = platform.system()
-        if system == "Windows":
-            pass
-        elif system == "Darwin":
-            extra_link_args += [
-                "-Wl,-exported_symbol,_PyInit__frida",
-                "-Wl,-dead_strip",
-            ]
-            if "_PYTHON_HOST_PLATFORM" not in os.environ:
-                if platform.machine() == "arm64":
-                    host_arch = "arm64"
-                    macos_req = "11.0"
-                else:
-                    host_arch = "x86_64"
-                    macos_req = "10.9"
-                os.environ["_PYTHON_HOST_PLATFORM"] = f"macosx-{macos_req}-{host_arch}"
-                os.environ["ARCHFLAGS"] = f"-arch {host_arch}"
-                os.environ["MACOSX_DEPLOYMENT_TARGET"] = macos_req
-        else:
-            version_script = os.path.join(package_dir, "src", "_frida.version")
-            if not os.path.exists(version_script):
-                with open(version_script, "w", encoding="utf-8") as f:
-                    f.write(
-                        "\n".join(
-                            [
-                                "{",
-                                "  global:",
-                                "    PyInit__frida;",
-                                "",
-                                "  local:",
-                                "    *;",
-                                "};",
-                            ]
-                        )
-                    )
-            extra_link_args += [
-                f"-Wl,--version-script,{version_script}",
-                "-Wl,--gc-sections",
-            ]
-    else:
-        cmdclass["build_ext"] = FridaMissingDevkitBuildExt
-
-
-if __name__ == "__main__":
+def main():
     setup(
         name="frida",
-        version=frida_version,
+        version=detect_version(),
         description="Dynamic instrumentation toolkit for developers, reverse-engineers, and security researchers",
-        long_description=long_description,
+        long_description=compute_long_description(),
         long_description_content_type="text/markdown",
         author="Frida Developers",
         author_email="oleavr@frida.re",
@@ -134,19 +50,81 @@ if __name__ == "__main__":
             "Topic :: Software Development :: Debuggers",
             "Topic :: Software Development :: Libraries :: Python Modules",
         ],
-        packages=["frida", "_frida"],
-        package_data={"frida": ["py.typed"], "_frida": ["py.typed", "__init__.pyi"]},
+        packages=["frida", "frida._frida"],
+        package_data={"frida": ["py.typed"], "frida._frida": ["py.typed", "__init__.pyi"]},
         ext_modules=[
             Extension(
-                name="_frida",
-                sources=["src/_frida.c"],
-                include_dirs=include_dirs,
-                library_dirs=library_dirs,
-                libraries=libraries,
-                extra_link_args=extra_link_args,
+                name="frida._frida",
+                sources=["frida/_frida/extension.c"],
                 py_limited_api=True,
             )
         ],
-        cmdclass=cmdclass,
+        cmdclass={"build_ext": FridaPrebuiltExt if FRIDA_EXTENSION is not None else FridaDemandBuiltExt},
         zip_safe=False,
     )
+
+
+def detect_version() -> str:
+    pkg_info = SOURCE_ROOT / "PKG-INFO"
+    in_source_package = pkg_info.exists()
+    if in_source_package:
+        version_line = [
+            line for line in pkg_info.read_text(encoding="utf-8").split("\n") if line.startswith("Version: ")
+        ][0].strip()
+        return version_line[9:]
+
+    version = os.environ.get("FRIDA_VERSION")
+    if version is not None:
+        return version
+
+    releng_location = next(enumerate_releng_locations(), None)
+    if releng_location is not None:
+        sys.path.insert(0, str(releng_location.parent))
+        from releng.frida_version import detect
+
+        return detect(SOURCE_ROOT).name.replace("-dev.", ".dev")
+
+    return "0.0.0"
+
+
+def compute_long_description() -> str:
+    return (SOURCE_ROOT / "README.md").read_text(encoding="utf-8")
+
+
+def enumerate_releng_locations() -> Iterator[Path]:
+    val = os.environ.get("MESON_SOURCE_ROOT")
+    if val is not None:
+        parent_releng = Path(val) / "releng"
+        if releng_location_exists(parent_releng):
+            yield parent_releng
+
+    local_releng = SOURCE_ROOT / "releng"
+    if releng_location_exists(local_releng):
+        yield local_releng
+
+
+def releng_location_exists(location: Path) -> bool:
+    return (location / "frida_version.py").exists()
+
+
+class FridaPrebuiltExt(build_ext):
+    def build_extension(self, ext):
+        target = self.get_ext_fullpath(ext.name)
+        Path(target).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(FRIDA_EXTENSION, target)
+
+
+class FridaDemandBuiltExt(build_ext):
+    def build_extension(self, ext):
+        make = SOURCE_ROOT / "make.bat" if platform.system() == "Windows" else "make"
+        subprocess.run([make], check=True)
+
+        outputs = [entry for entry in (SOURCE_ROOT / "build" / "frida" / "_frida").glob("_frida.*") if entry.is_file()]
+        assert len(outputs) == 1
+        target = self.get_ext_fullpath(ext.name)
+        Path(target).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(outputs[0], target)
+
+
+if __name__ == "__main__":
+    main()

src/meson.build

@@ -1,17 +0,0 @@
-extra_link_args = []
-if host_os_family == 'darwin'
-  extra_link_args += ['-Wl,-exported_symbol,_PyInit__frida']
-elif host_os_family != 'windows'
-  extra_link_args += ['-Wl,--version-script,' + join_paths(meson.current_source_dir(), '_frida.version')]
-endif
-
-extension = shared_module('_frida', '_frida.c',
-  name_prefix: '',
-  name_suffix: 'so',
-  c_args: frida_component_cflags,
-  include_directories: include_directories(python_incdir),
-  link_args: extra_link_args,
-  dependencies: [frida_core_dep] + os_deps,
-  install: true,
-  install_dir: python_site_packages,
-)

subprojects/frida-core.wrap

@@ -0,0 +1,8 @@
+[wrap-git]
+url = https://github.com/frida/frida-core.git
+revision = 17.6.0
+depth = 1
+
+[provide]
+dependency_names = frida-core-1.0
+

tests/test_rpc.py

@@ -31,27 +31,41 @@ class TestRpc(unittest.TestCase):
             name="test-rpc",
             source="""\
 rpc.exports = {
-    add: function (a, b) {
-        var result = a + b;
+    add(a, b) {
+        const result = a + b;
         if (result < 0)
-          throw new Error("No");
+            throw new Error("No");
         return result;
     },
-    sub: function (a, b) {
+    sub(a, b) {
         return a - b;
     },
-    speak: function () {
-        var buf = Memory.allocUtf8String("Yo");
+    speak() {
+        const buf = Memory.allocUtf8String("Yo");
         return Memory.readByteArray(buf, 2);
-    }
+    },
+    speakWithMetadata() {
+        const buf = Memory.allocUtf8String("Yo");
+        return ['soft', Memory.readByteArray(buf, 2)];
+    },
+    processData(val, data) {
+        return { val, dump: hexdump(data, { header: false }) };
+    },
 };
 """,
         )
         script.load()
-        self.assertEqual(script.exports.add(2, 3), 5)
-        self.assertEqual(script.exports.sub(5, 3), 2)
-        self.assertRaises(Exception, lambda: script.exports.add(1, -2))
-        self.assertListEqual([x for x in iter(script.exports.speak())], [0x59, 0x6F])
+        agent = script.exports_sync
+        self.assertEqual(agent.add(2, 3), 5)
+        self.assertEqual(agent.sub(5, 3), 2)
+        self.assertRaises(Exception, lambda: agent.add(1, -2))
+        self.assertEqual(agent.speak(), b"\x59\x6f")
+        meta, data = agent.speak_with_metadata()
+        self.assertEqual(meta, "soft")
+        self.assertEqual(data, b"\x59\x6f")
+        result = agent.process_data(1337, b"\x13\x37")
+        self.assertEqual(result["val"], 1337)
+        self.assertEqual(result["dump"], "00000000  13 37                                            .7")
 
     def test_post_failure(self):
         script = self.session.create_script(
@@ -64,7 +78,7 @@ rpc.exports = {
 """,
         )
         script.load()
-        agent = script.exports
+        agent = script.exports_sync
 
         self.session.detach()
         self.assertRaisesScriptDestroyed(lambda: agent.init())
@@ -82,7 +96,7 @@ rpc.exports = {
 """,
         )
         script.load()
-        agent = script.exports
+        agent = script.exports_sync
 
         def unload_script_after_100ms():
             time.sleep(0.1)
@@ -104,7 +118,7 @@ rpc.exports = {
 """,
         )
         script.load()
-        agent = script.exports
+        agent = script.exports_sync
 
         def terminate_target_after_100ms():
             time.sleep(0.1)
@@ -126,7 +140,7 @@ rpc.exports = {
 """,
         )
         script.load()
-        agent = script.exports
+        agent = script.exports_sync
 
         def cancel_after_100ms():
             time.sleep(0.1)