frida 0.1.0 → 0.1.1

data/ext/c_frida/gvl_bridge.c

@@ -0,0 +1,131 @@
+#include "gvl_bridge.h"
+
+static int	_gvl_bridge_pipe[2] = {-1, -1};
+static int	__gvl_bridge_pipe[2] = {-1, -1};
+static bool main_thread_exited = false;
+
+static void gvl_bridge_signal_exit(VALUE _)
+{
+    main_thread_exited = true;
+    close(_gvl_bridge_pipe[0]);
+    close(_gvl_bridge_pipe[1]);
+    close(__gvl_bridge_pipe[0]);
+    close(__gvl_bridge_pipe[1]);
+}
+
+void	gvl_bridge_forward_GC(GClosure *closure, GValue *_, guint n_param_values, GValue *param_values, gpointer __, gpointer ___)
+{
+    void *dummy;
+    gvl_bridge_data *data = malloc(sizeof(gvl_bridge_data));
+
+    data->type = GCLOSURE;
+    data->GC.closure = closure;
+    data->GC.n_param_values = n_param_values;
+    data->GC.param_values = param_values;
+    write(_gvl_bridge_pipe[1], &data, sizeof(void *));
+    // hold until the callback is done, also prevents GC-ing param_values
+    read(__gvl_bridge_pipe[0], &dummy, sizeof(void *));
+    if (data->GC.param_values != param_values)
+        free(data->GC.param_values);
+    free(data);
+}
+
+static VALUE GC_rbcall(gclosure_callback *callback)
+{
+    RBClosure *rc = TO_RBCLOSURE(callback->closure);
+    VALUE *args_array;
+
+    int arity = rc->is_lambda ? MIN(callback->n_param_values, rc->arity) : (callback->n_param_values - 1);
+    if (arity == -1) // splat operator
+        arity = callback->n_param_values;
+    if (callback->n_param_values == arity)
+        args_array = rbGObjectSignalClosure_marshal_params(callback->param_values, arity);
+    else
+        args_array = rbGObjectSignalClosure_marshal_params(callback->param_values + 1, arity); // +1 skip sender instance.
+    callback->param_values = (void *)args_array;
+    rb_funcallv((VALUE)callback->closure->data, rb_intern("call"), arity, args_array);
+    return (Qnil);
+}
+
+static void gvl_bridge_call_GC(gclosure_callback *data)
+{
+    int state;
+
+    rb_protect((VALUE (*)(VALUE))GC_rbcall, (VALUE)data, &state);
+    if (state)
+        rb_set_errinfo(Qnil);
+}
+
+void	gvl_bridge_forward_GT(GTask *task, FridaRBAuthenticationService *self)
+{
+    gvl_bridge_data *data = malloc(sizeof(gvl_bridge_data));
+
+    data->type = GTASK;
+    data->GT.task = task;
+    data->GT.self = self;
+    write(_gvl_bridge_pipe[1], &data, sizeof(void *));
+}
+
+static VALUE GT_rbcall(gtask_callback *data)
+{
+    gchar *token;
+
+    token = g_task_get_task_data(data->task);
+    return (rb_funcall((VALUE)data->self->callback, rb_intern("call"), 1, rb_str_new_cstr(token)));
+}
+
+static void gvl_bridge_call_GT(gtask_callback *data)
+{
+    int state;
+    gchar *msg = NULL;
+    VALUE result;
+
+    result = rb_protect((VALUE (*)(VALUE))GT_rbcall, (VALUE)data, &state);
+    if (state) {
+        result = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
+        if (result != Qnil)
+            msg = g_strdup(StringValueCStr(result));
+        else
+            msg = g_strdup("Internal error");
+        rb_set_errinfo(Qnil);
+        g_task_return_new_error(data->task, FRIDA_ERROR, FRIDA_ERROR_INVALID_ARGUMENT, "%s", msg);
+        g_free(msg);
+    } else {
+        rbGObject_unmarshal_string(result, &msg);
+        g_task_return_pointer(data->task, msg, g_free);
+    }
+    g_object_unref(data->task);
+}
+
+static void gvl_bridge_main()
+{
+    gvl_bridge_data	*data;
+
+    g_assert(sizeof(void *) <= sizeof(VALUE));
+    while (1) {
+        read(_gvl_bridge_pipe[0], &data, sizeof(void *));
+        if (!data || main_thread_exited)
+            return;
+        if (data->type == GCLOSURE) {
+            rb_thread_call_with_gvl((void_fp)gvl_bridge_call_GC, &data->GC);
+            write(__gvl_bridge_pipe[1], &data, sizeof(void *));
+        } else if (data->type == GTASK) {
+            rb_thread_call_with_gvl((void_fp)gvl_bridge_call_GT, &data->GT);
+            free(data);
+        }
+    }
+}
+
+void gvl_bridge(void)
+{
+    if (pipe(_gvl_bridge_pipe) < 0) {
+        raise_rerror("pipe() error @ gvl_bridge", NULL);
+        exit(EXIT_FAILURE);
+    }
+    if (pipe(__gvl_bridge_pipe) < 0) {
+        raise_rerror("pipe() error @ gvl_bridge", NULL);
+        exit(EXIT_FAILURE);
+    }
+    rb_set_end_proc(gvl_bridge_signal_exit, Qnil);
+    rb_thread_call_without_gvl((void_fp)gvl_bridge_main, NULL, RUBY_UBF_IO, NULL);
+}

data/ext/c_frida/inc/Application.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cApplication;
+
+void	define_Application();
+VALUE	Application_from_FridaApplication(FridaApplication *handle);

data/ext/c_frida/inc/Bus.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cBus;
+
+typedef struct {
+    FridaBus	*handle;
+    char		*message;
+    GBytes		*data;
+} bus_post_proxy_args;
+
+void	define_Bus();
+VALUE	Bus_from_FridaBus(FridaBus *fridabus);

data/ext/c_frida/inc/Child.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cChild;
+
+void	define_Child();
+VALUE	Child_from_FridaChild(FridaChild *stream);

data/ext/c_frida/inc/Compiler.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cCompiler;
+
+typedef struct {
+    FridaCompiler   *handle;
+    char            *entrypoint;
+    FridaBuildOptions *options;
+} build_sync_proxy_args;
+
+typedef struct {
+    FridaCompiler   *handle;
+    char            *entrypoint;
+    FridaWatchOptions *options;
+} watch_sync_proxy_args;
+
+void	define_Compiler();
+VALUE	Compiler_from_FridaCompiler(FridaCompiler *handle);

data/ext/c_frida/inc/Crash.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cCrash;
+
+void	define_Crash();
+VALUE	Crash_from_FridaCrash(FridaCrash *handle);

data/ext/c_frida/inc/Device.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cDevice;
+
+typedef struct {
+    FridaDevice	*device_handle;
+    char		*address;
+} open_channel_proxy_args;
+
+typedef struct {
+    FridaDevice	*device_handle;
+    FridaFrontmostQueryOptions *options;
+} get_frontmost_application_proxy_args;
+
+typedef struct {
+    FridaDevice	*device_handle;
+    FridaProcessQueryOptions *options;
+} enumerate_processes_proxy_args;
+
+typedef struct {
+    FridaDevice	*device_handle;
+    FridaApplicationQueryOptions *options;
+} enumerate_applications_proxy_args;
+
+typedef struct {
+    FridaDevice	*device_handle;
+    char		*program;
+    FridaSpawnOptions *options;
+} spawn_sync_proxy_args;
+
+typedef struct {
+    FridaDevice *device_handle;
+    guint		pid;
+} resume_sync_proxy_args;
+
+typedef resume_sync_proxy_args kill_sync_proxy_args;
+
+typedef struct {
+    FridaDevice *device_handle;
+    guint		pid;
+    GBytes 		*data;
+} input_sync_proxy_args;
+
+typedef struct {
+    FridaDevice *device_handle;
+    guint		pid;
+    char		*path;
+    char		*entrypoint;
+    char		*data;
+} inject_library_file_sync_proxy_args;
+
+typedef struct {
+    FridaDevice *device_handle;
+    guint		pid;
+    GBytes		*blob;
+    char		*entrypoint;
+    char		*data;
+} inject_library_blob_sync_proxy_args;
+
+typedef struct {
+    FridaDevice *device_handle;
+    guint		pid;
+    FridaSessionOptions	*options;
+} attach_sync_proxy_args;
+
+void	define_Device();
+VALUE	Device_from_FridaDevice(FridaDevice *device);
+int		array_all_type(VALUE arr, VALUE rtype);

data/ext/c_frida/inc/DeviceManager.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cDeviceManager;
+
+typedef struct {
+    FridaDeviceManager	*device_manager;
+    char				*address;
+    FridaRemoteDeviceOptions *options;
+} add_remote_device_proxy_args;
+
+typedef struct {
+    FridaDeviceManager	*device_manager;
+    char				*address;
+} remove_remote_devices_proxy_args;
+
+void	define_DeviceManager();
+VALUE	DeviceManager_from_FridaDeviceManager(FridaDeviceManager *handle);

data/ext/c_frida/inc/EndpointParameters.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cEndpointParameters;
+
+struct _FridaRBAuthenticationService {
+    GObject       parent;
+    VALUE         callback;
+    GThreadPool   *pool;
+};
+
+void	define_EndpointParameters();
+VALUE	EndpointParameters_from_FridaEndpointParameters(FridaEndpointParameters *handle);

data/ext/c_frida/inc/FileMonitor.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cFileMonitor;
+
+void	define_FileMonitor();
+VALUE	FileMonitor_from_FridaFileMonitor(FridaFileMonitor *handle);

data/ext/c_frida/inc/GObject.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cGObject;
+
+void	GObject_free(GObject_d *d);
+
+void	define_GObject();

data/ext/c_frida/inc/IOStream.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cIOStream;
+
+typedef struct {
+    GObject_d		base;
+    GInputStream	*input;
+    GOutputStream	*output;
+} IOStream_d;
+
+typedef struct {
+    GOutputStream	*output;
+    char			*data;
+    gsize			size;
+} write_proxy_args;
+
+typedef struct {
+    GInputStream	*input;
+    char			*buffer;
+    gsize			count;
+} read_proxy_args;
+
+void IOStream_free(IOStream_d *d);
+
+void	define_IOStream();
+VALUE	IOStream_from_GIOStream(GIOStream *stream);

data/ext/c_frida/inc/PortalMembership.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cPortalMembership;
+
+void	define_PortalMembership();
+VALUE	PortalMembership_from_FridaPortalMembership(FridaPortalMembership *handle);

data/ext/c_frida/inc/PortalService.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "c_frida.h"
+
+typedef struct {
+    FridaPortalService	*handle;
+    guint               connection_id;
+} kick_proxy_args;
+
+typedef struct {
+    FridaPortalService	*handle;
+    guint               connection_id;
+    char                *message;
+    GBytes              *data;
+} _post_proxy_args;
+
+typedef struct {
+    FridaPortalService	*handle;
+    char                *tag;
+    char                *message;
+    GBytes              *data;
+} narrowcast_proxy_args;
+
+typedef struct {
+    FridaPortalService	*handle;
+    char                *message;
+    GBytes              *data;
+} broadcast_proxy_args;
+
+typedef struct {
+    FridaPortalService	*handle;
+    guint               connection_id;
+    gint                *tags_count;
+} enumerate_tags_proxy_args;
+
+typedef struct {
+    FridaPortalService	*handle;
+    guint               connection_id;
+    char                *tag;
+} tag_proxy_args;
+
+typedef tag_proxy_args untag_proxy_args;
+
+extern VALUE mCFrida;
+extern VALUE cPortalService;
+
+void	define_PortalService();

data/ext/c_frida/inc/Process.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cProcess;
+
+void	define_Process();
+VALUE	Process_from_FridaProcess(FridaProcess *handle);

data/ext/c_frida/inc/Relay.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cRelay;
+
+void	define_Relay();
+VALUE	Relay_from_FridaRelay(FridaRelay *handle);

data/ext/c_frida/inc/Script.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cScript;
+extern VALUE cGObject;
+
+typedef struct {
+    FridaScript	*handle;
+    uint port;
+} enable_debugger_proxy_args;
+
+typedef struct {
+    FridaScript	*handle;
+    char * message;
+    GBytes * data;
+} post_proxy_args;
+
+void	define_Script();
+VALUE	Script_from_FridaScript(FridaScript *handle);

data/ext/c_frida/inc/Session.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cSession;
+
+typedef struct {
+    FridaSession *handle;
+    char		*source;
+    FridaScriptOptions *options;
+} create_script_sync_proxy_args;
+
+typedef create_script_sync_proxy_args compile_script_sync_proxy_args;
+
+typedef struct {
+    FridaSession *handle;
+    char		*embed_script;
+    FridaSnapshotOptions *options;
+} snapshot_script_sync_proxy_args;
+
+typedef struct {
+    FridaSession *handle;
+    GBytes	*bytes;
+    FridaScriptOptions *options;
+} create_script_from_bytes_sync_proxy_args;
+
+typedef struct {
+    FridaSession *handle;
+    FridaPeerOptions *options;
+} setup_peer_connection_sync_proxy_args;
+
+typedef struct {
+    FridaSession		*handle;
+    char				*address;
+    FridaPortalOptions	*options;
+} join_portal_sync_proxy_args;
+
+void	define_Session();
+VALUE	Session_from_FridaSession(FridaSession *stream);

data/ext/c_frida/inc/Spawn.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "c_frida.h"
+
+extern VALUE mCFrida;
+extern VALUE cSpawn;
+
+void	define_Spawn();
+VALUE	Spawn_from_FridaSpawn(FridaSpawn *stream);

data/ext/c_frida/inc/c_frida.h

@@ -0,0 +1,129 @@
+#ifndef FRIDA_RUBY_H
+#define FRIDA_RUBY_H 1
+
+#include "ruby.h"
+#include "ruby/thread.h"
+#include "ruby/vm.h"
+#include "frida-core.h"
+
+typedef struct _GObject_d {
+    void	*handle;
+    void	(*destroy)(void *);
+    GSList	*signal_closures;
+} GObject_d;
+
+#define FRIDA_TYPE_RB_AUTHENTICATION_SERVICE frida_rb_authentication_service_get_type()
+G_DECLARE_FINAL_TYPE(FridaRBAuthenticationService, frida_rb_authentication_service, FRIDA, RB_AUTHENTICATION_SERVICE, GObject)
+
+#include "gutils.h"
+
+#include "GObject.h"
+#include "DeviceManager.h"
+#include "Device.h"
+#include "Bus.h"
+#include "IOStream.h"
+#include "Application.h"
+#include "Process.h"
+#include "Spawn.h"
+#include "Child.h"
+#include "Session.h"
+#include "Script.h"
+#include "Relay.h"
+#include "PortalMembership.h"
+#include "Crash.h"
+#include "FileMonitor.h"
+#include "Compiler.h"
+#include "EndpointParameters.h"
+#include "PortalService.h"
+
+#include "gvl_bridge.h"
+
+extern const rb_data_type_t GObject_dt;
+
+#define DEFINE_KLASS_DATA_TYPE(klass) \
+	const rb_data_type_t klass##_dt = { \
+		.wrap_struct_name = "Frida::" #klass "Data", \
+		.function = { \
+			.dcompact = NULL, \
+			.dmark = NULL, \
+			.dsize = NULL, \
+			.dfree = (void (*)(void*))klass##_free, \
+		}, \
+		.flags = RUBY_TYPED_FREE_IMMEDIATELY \
+	};
+
+#define DEFINE_GOBJECT_CHILD_KLASS_DATA_TYPE(klass) \
+	static const rb_data_type_t klass##_dt = { \
+		.wrap_struct_name = "Frida::" #klass "Data", \
+		.function = { \
+			.dcompact = NULL, \
+			.dmark = NULL, \
+			.dsize = NULL, \
+			.dfree = (void (*)(void*))klass##_free, \
+		}, \
+		.parent = &GObject_dt, \
+		.flags = RUBY_TYPED_FREE_IMMEDIATELY \
+	};
+
+#define MAKE_DATA(k) \
+	k##_d *d; \
+	VALUE obj = TypedData_Make_Struct(klass, k##_d, &k##_dt, d);
+
+#define MAKE_DATA_EX(k, var) \
+	k##_d *var; \
+	VALUE obj = TypedData_Make_Struct(klass, k##_d, &k##_dt, var);
+
+#define GET_DATA(klass) \
+	klass##_d *d; \
+    TypedData_Get_Struct(self, klass##_d, &klass##_dt, d);
+
+#define GET_DATA_EX(klass, self, var) \
+	klass##_d *var; \
+    TypedData_Get_Struct(self, klass##_d, &klass##_dt, var);
+
+#define GET_GOBJECT_DATA() \
+    GET_DATA(GObject);
+
+#define REQUIRE_GOBJECT_HANDLE() \
+    if (!d->handle) return (Qnil);
+
+#define CALL_GVL_FREE(func, arg) \
+    rb_thread_call_without_gvl((void_fp)func##_gvl_free, arg, NULL, NULL);
+
+typedef struct {
+    void	*ret;
+    GError	*gerr;
+} gvl_free_proxy_result;
+
+#define GVL_FREE_PROXY_FUNC(name, arg) \
+    static gvl_free_proxy_result *name##_gvl_free(arg)
+
+#define GERROR_BLOCK \
+    gerror: \
+        raise_rerror(NULL, _gerr); \
+        return (Qnil);
+
+#define UNREACHABLE_GERROR_BLOCK GERROR_BLOCK
+
+#define RETURN_GVL_FREE_RESULT(_ret) \
+	gvl_free_proxy_result *result = malloc(sizeof(gvl_free_proxy_result)); \
+	result->ret = _ret; \
+	result->gerr = gerr; \
+	return (result);
+
+#define CALL_GVL_FREE_WITH_RET(_ret, func, arg) \
+    gvl_free_proxy_result *result = (gvl_free_proxy_result *)rb_thread_call_without_gvl((void_fp)func##_gvl_free, arg, NULL, NULL); \
+    _ret = result->ret; \
+    GError *_gerr = result->gerr; \
+    free(result); \
+    if (_gerr) goto gerror;
+
+#define TO_RBCLOSURE(c) ((RBClosure *)c)
+
+typedef void *(*void_fp)(void *);
+
+void	Init_c_frida(void);
+void	raise_rerror(char *err, GError *gerr);
+void	raise_argerror(char *err);
+
+#endif

data/ext/c_frida/inc/gutils.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "c_frida.h"
+
+VALUE rbGObject_marshal_string(const gchar * str);
+VALUE rbGObject_marshal_enum(gint value, GType type);
+VALUE rbGObject_marshal_variant(GVariant * variant);
+gboolean rbGObject_unmarshal_certificate(const gchar *str, GTlsCertificate **certificate);
+gboolean rbGObject_unmarshal_enum(const gchar *str, GType type, gpointer value);
+VALUE	rbGObject_marshal_dict(GHashTable *dict);
+VALUE rbApplication_marshal_parameters_dict(GHashTable * dict);
+#define rbProcess_marshal_parameters_dict rbApplication_marshal_parameters_dict
+gboolean rbGObject_unmarshal_strv(VALUE value, gchar ***strv, gint *length);
+gboolean rbGObject_unmarshal_envp(VALUE hash, gchar ***envp, gint *length);
+gboolean rbGObject_unmarshal_string(VALUE value, gchar **str);
+gboolean rbGObject_unmarshal_variant(VALUE value, GVariant ** variant);
+VALUE rbGObject_marshal_strv(gchar **strv, gint length);
+VALUE rbGObject_marshal_envp(const gchar **envp, gint length);
+VALUE rbGObject_marshal_value(const GValue *value);
+VALUE *rbGObjectSignalClosure_marshal_params(const GValue *params, guint params_length);
+VALUE rbGObject_marshal_bytes(GBytes * bytes);