frida 16.7.13 → 16.7.15

package/src/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);
+}

package/src/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);

package/src/frida_bindgen/assets/codegen_types.h

@@ -0,0 +1,57 @@
+typedef enum {
+  FDN_SIGNAL_ALLOW_EXIT,
+  FDN_SIGNAL_KEEP_ALIVE
+} FdnSignalBehavior;
+
+typedef struct {
+  GObject * handle;
+  guint id;
+  FdnSignalBehavior behavior;
+  GSList * closures;
+} FdnSignal;
+
+typedef enum {
+  FDN_SIGNAL_CLOSURE_OPEN,
+  FDN_SIGNAL_CLOSURE_CLOSED,
+} FdnSignalClosureState;
+
+typedef struct {
+  GClosure closure;
+  FdnSignal * sig;
+  napi_ref js_sig;
+  FdnSignalClosureState state;
+  napi_threadsafe_function tsfn;
+  napi_ref handler;
+  gulong handler_id;
+} FdnSignalClosure;
+
+typedef enum {
+  FDN_SIGNAL_CLOSURE_MESSAGE_DESTROY,
+  FDN_SIGNAL_CLOSURE_MESSAGE_MARSHAL,
+} FdnSignalClosureMessageType;
+
+typedef struct {
+  napi_ref js_sig;
+  napi_threadsafe_function tsfn;
+  napi_ref handler;
+} FdnSignalClosureMessageDestroy;
+
+typedef struct {
+  GArray * args;
+} FdnSignalClosureMessageMarshal;
+
+typedef struct {
+  FdnSignalClosureMessageType type;
+  union {
+    FdnSignalClosureMessageDestroy destroy;
+    FdnSignalClosureMessageMarshal marshal;
+  } payload;
+} FdnSignalClosureMessage;
+
+typedef struct {
+  guint ref_count;
+  GObject * handle;
+  gulong signal_handler_id;
+} FdnKeepAliveContext;
+
+typedef gboolean (* FdnIsDestroyedFunc) (GObject * handle);

package/src/frida_bindgen/assets/customization_facade.exports

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

package/src/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;

package/src/frida_bindgen/assets/customization_helpers.imports

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