frida 0.1.0 → 0.1.1

data/ext/c_frida/c_frida.c

@@ -0,0 +1,68 @@
+#include "c_frida.h"
+
+VALUE _gvl_bridge_thread;
+
+VALUE mCFrida;
+VALUE cGObject;
+VALUE cDevice;
+VALUE cDeviceManager;
+VALUE cBus;
+VALUE cIOStream;
+VALUE cApplication;
+VALUE cProcess;
+VALUE cSpawn;
+VALUE cChild;
+VALUE cSession;
+VALUE cScript;
+VALUE cRelay;
+VALUE cPortalMembership;
+VALUE cCrash;
+VALUE cFileMonitor;
+VALUE cCompiler;
+VALUE cEndpointParameters;
+VALUE cPortalService;
+
+void	raise_argerror(char *err)
+{
+    rb_raise(rb_eArgError, "%s", err);
+}
+
+void	raise_rerror(char *err, GError *gerr)
+{
+    if (!gerr)
+        rb_raise(rb_eRuntimeError, "%s", err);
+    else if (gerr->message) {
+        VALUE ruby_string = rb_str_new_cstr(gerr->message);
+        rb_funcall(ruby_string, rb_intern("force_encoding"), 1, rb_const_get(rb_cEncoding, rb_intern("UTF_8")));
+        rb_funcall(rb_mKernel, rb_intern("raise"), 2, rb_eRuntimeError, ruby_string);
+        g_error_free(gerr);
+    } else
+        raise_rerror("error.", NULL);
+}
+
+void Init_c_frida(void)
+{
+    rb_require("date");
+    mCFrida = rb_define_module("CFrida");
+    frida_init();
+    rb_define_const(mCFrida, "FRIDA_VERSION", rb_str_new_cstr(frida_version_string()));
+    define_GObject();
+    define_Device();
+    define_DeviceManager();
+    define_Bus();
+    define_IOStream();
+    define_Application();
+    define_Process();
+    define_Spawn();
+    define_Child();
+    define_Session();
+    define_Script();
+    define_Relay();
+    define_PortalMembership();
+    define_Crash();
+    define_FileMonitor();
+    define_Compiler();
+    define_EndpointParameters();
+    define_PortalService();
+    _gvl_bridge_thread = rb_thread_create(RUBY_METHOD_FUNC(gvl_bridge), NULL);
+}

data/ext/c_frida/extconf.rb

@@ -1,25 +1,26 @@
-# frozen_string_literal: true
-
-require "mkmf"
-
-unless ENV["FRIDA_CORE_DEVKIT"] && File.directory?(ENV["FRIDA_CORE_DEVKIT"])
-  abort "please download frida-core devkit, and set its path in the env variable FRIDA_CORE_DEVKIT"
-end
-
-# todo: use the native #have_header and #have_library
-unless File.file?("#{ENV["FRIDA_CORE_DEVKIT"]}/frida-core.h") && File.file?("#{ENV["FRIDA_CORE_DEVKIT"]}/libfrida-core.a")
-  abort "could not find frida-core.h or libfrida-core.a in the configured env variable FRIDA_CORE_DEVKIT"
-end
-
-W =
-  if false
-    # only on DEV mode because it detects lot of unused var/params, in our code and Ruby's.
-    "-Wno-error=cast-function-type -Wno-error=unused-parameter -Wno-error=unused-variable -Wno-error=unused-function -Wall -Werror -Wextra"
-  else
-    ""
-  end
-
-$CFLAGS = "#{W} -g3 -ffunction-sections -fdata-sections -I#{ENV["FRIDA_CORE_DEVKIT"]} -I#{File.dirname(__FILE__)}/inc"
-$LDFLAGS = "-Wl,--export-dynamic -static-libgcc -Wl,-z,noexecstack,--gc-sections -L#{ENV["FRIDA_CORE_DEVKIT"]} -lfrida-core -ldl -lrt -lm -lresolv -pthread"
-
-create_makefile("c_frida")
+# frozen_string_literal: true
+require "mkmf"
+
+unless ENV["FRIDA_CORE_DEVKIT"] && File.directory?(ENV["FRIDA_CORE_DEVKIT"])
+  abort "please download frida-core devkit, and set its path in the env variable FRIDA_CORE_DEVKIT"
+end
+
+# todo: use the native #have_header and #have_library
+unless File.file?("#{ENV["FRIDA_CORE_DEVKIT"]}/frida-core.h") && File.file?("#{ENV["FRIDA_CORE_DEVKIT"]}/libfrida-core.a")
+  abort "could not find frida-core.h or libfrida-core.a in the configured env variable FRIDA_CORE_DEVKIT"
+end
+
+if RUBY_PLATFORM =~ /darwin/ && RUBY_PLATFORM =~ /x86_64/
+  target = "x86_64-apple-macos10.9"
+  $CFLAGS << " -I#{ENV["FRIDA_CORE_DEVKIT"]} -I#{File.dirname(__FILE__)}/inc"
+  $CFLAGS << " -target #{target} -w"
+  $libs << " -L. -L#{ENV["FRIDA_CORE_DEVKIT"]} -lfrida-core -lbsm -ldl -lm -lresolv"
+  $LDFLAGS << " -Wl,-framework,Foundation,-framework,AppKit,-dead_strip"
+elsif RUBY_PLATFORM =~ /linux/
+  $CFLAGS = "-g3 -ffunction-sections -fdata-sections -I#{ENV["FRIDA_CORE_DEVKIT"]} -I#{File.dirname(__FILE__)}/inc"
+  $LDFLAGS = "-Wl,--export-dynamic -static-libgcc -Wl,-z,noexecstack,--gc-sections -L#{ENV["FRIDA_CORE_DEVKIT"]} -lfrida-core -ldl -lrt -lm -lresolv -pthread"
+else
+  abort "Platform not supported."
+end
+
+create_makefile("c_frida")

data/ext/c_frida/gutils.c

@@ -0,0 +1,498 @@
+#include "gutils.h"
+
+// Ruby version of frida-python's Glib objects un/marshals.
+VALUE rbGObject_marshal_string(const gchar * str)
+{
+    if (!str)
+        return (Qnil);
+    return (rb_str_new_cstr(str));
+}
+
+gboolean rbGObject_unmarshal_string(VALUE value, gchar **str)
+{
+    VALUE to_s = rb_funcall(value, rb_intern("to_s"), 0);
+    *str = g_strdup(StringValueCStr(to_s));
+    return (*str != NULL);
+}
+
+VALUE rbGObject_marshal_enum(gint value, GType type)
+{
+    GEnumClass * enum_class;
+    GEnumValue * enum_value;
+    VALUE	result;
+
+    enum_class = g_type_class_ref (type);
+
+    enum_value = g_enum_get_value (enum_class, value);
+    g_assert (enum_value != NULL);
+
+    result = rbGObject_marshal_string(enum_value->value_nick);
+
+    g_type_class_unref (enum_class);
+
+    return (result);
+}
+
+VALUE rbGObject_marshal_variant(GVariant * variant)
+{
+    if (g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING))
+        return rbGObject_marshal_string(g_variant_get_string(variant, NULL));
+
+    if (g_variant_is_of_type(variant, G_VARIANT_TYPE_INT64))
+        return LL2NUM(g_variant_get_int64(variant));
+
+    if (g_variant_is_of_type(variant, G_VARIANT_TYPE_BOOLEAN))
+        return (g_variant_get_boolean(variant) ? Qtrue : Qfalse);
+
+    if (g_variant_is_of_type(variant, G_VARIANT_TYPE("ay"))) {
+        gconstpointer elements;
+        gsize n_elements;
+
+        elements = g_variant_get_fixed_array(variant, &n_elements, sizeof(guint8));
+
+        return rb_str_new(elements, n_elements);
+    }
+
+    if (g_variant_is_of_type(variant, G_VARIANT_TYPE_VARDICT)) {
+        VALUE hash;
+        GVariantIter iter;
+        gchar * key;
+        GVariant * raw_value;
+
+        hash = rb_hash_new();
+
+        g_variant_iter_init (&iter, variant);
+
+        while (g_variant_iter_next(&iter, "{sv}", &key, &raw_value)) {
+            rb_hash_aset(hash, ID2SYM(rb_intern(key)), rbGObject_marshal_variant(raw_value));
+            g_variant_unref(raw_value);
+            g_free (key);
+        }
+        return hash;
+    }
+
+    if (g_variant_is_of_type (variant, G_VARIANT_TYPE_ARRAY)) {
+        GVariantIter iter;
+        VALUE list;
+        guint i;
+        GVariant * child;
+
+        g_variant_iter_init (&iter, variant);
+
+        list = rb_ary_new_capa(g_variant_iter_n_children(&iter));
+
+        for (i = 0; (child = g_variant_iter_next_value (&iter)) != NULL; i++) {
+            rb_ary_store(list, i, rbGObject_marshal_variant(child));
+            g_variant_unref (child);
+        }
+        return list;
+    }
+    return (Qnil);
+}
+
+gboolean rbGObject_unmarshal_certificate(const gchar *str, GTlsCertificate **certificate)
+{
+    GError * error = NULL;
+
+    if (strchr(str, '\n') != NULL)
+        *certificate = g_tls_certificate_new_from_pem(str, -1, &error);
+    else
+        *certificate = g_tls_certificate_new_from_file(str, &error);
+    if (error != NULL)
+        goto propagate_error;
+
+    return TRUE;
+
+propagate_error: {
+        raise_rerror(NULL, error);
+
+        return FALSE;
+    }
+}
+
+VALUE rbGObject_marshal_dict(GHashTable *dict)
+{
+    VALUE result;
+    GHashTableIter iter;
+    const gchar * key;
+    GVariant * raw_value;
+
+    result = rb_hash_new();
+
+    g_hash_table_iter_init(&iter, dict);
+    while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &raw_value)) {
+        rb_hash_aset(result, ID2SYM(rb_intern(key)), rbGObject_marshal_variant(raw_value));
+    }
+    return result;
+}
+
+gboolean rbGObject_unmarshal_enum(const gchar *str, GType type, gpointer value)
+{
+    GEnumClass * enum_class;
+    GEnumValue * enum_value;
+
+    enum_class = g_type_class_ref(type);
+
+    enum_value = g_enum_get_value_by_nick(enum_class, str);
+    if (enum_value == NULL)
+        goto invalid_value;
+
+    *((gint *) value) = enum_value->value;
+
+    g_type_class_unref(enum_class);
+
+    return TRUE;
+
+invalid_value: {
+        return FALSE;
+    }
+}
+
+static VALUE rbGObject_marshal_datetime(const gchar * iso8601_text)
+{
+    VALUE result;
+    GDateTime * raw_dt, * dt;
+
+    raw_dt = g_date_time_new_from_iso8601(iso8601_text, NULL);
+    if (raw_dt == NULL)
+        return (Qnil);
+
+    dt = g_date_time_to_local (raw_dt);
+    result = rb_funcall(rb_const_get(rb_cObject, rb_intern("DateTime")), rb_intern("new"), 7,
+                        LL2NUM(g_date_time_get_year(dt)),
+                        LL2NUM(g_date_time_get_month(dt)),
+                        LL2NUM(g_date_time_get_day_of_month(dt)),
+                        LL2NUM(g_date_time_get_hour(dt)),
+                        LL2NUM(g_date_time_get_minute(dt)),
+                        LL2NUM(g_date_time_get_second(dt)),
+                        LL2NUM(g_date_time_get_microsecond(dt)));
+
+    g_date_time_unref(dt);
+    g_date_time_unref(raw_dt);
+
+    return result;
+}
+
+VALUE rbApplication_marshal_parameters_dict(GHashTable * dict)
+{
+    VALUE result;
+    GHashTableIter iter;
+    const gchar * key;
+    GVariant * raw_value;
+
+    result = rb_hash_new();
+
+    g_hash_table_iter_init(&iter, dict);
+
+    while (g_hash_table_iter_next(&iter, (gpointer *)&key, (gpointer *)&raw_value)) {
+        VALUE value;
+
+        if (strcmp(key, "started") == 0 && g_variant_is_of_type(raw_value, G_VARIANT_TYPE_STRING))
+            value = rbGObject_marshal_datetime(g_variant_get_string (raw_value, NULL));
+        else
+            value = rbGObject_marshal_variant(raw_value);
+
+        rb_hash_aset(result, ID2SYM(rb_intern(key)), value);
+    }
+
+    return result;
+}
+
+gboolean rbGObject_unmarshal_strv(VALUE value, gchar ***strv, gint *length)
+{
+    gint n, i;
+    gchar ** elements;
+
+    n = RARRAY_LEN(value);
+    elements = g_new0(gchar *, n + 1);
+
+    for (i = 0; i != n; i++) {
+        VALUE element;
+
+        element = RARRAY_AREF(value, i);
+        elements[i] = g_strdup(StringValueCStr(element));
+        if (elements[i] == NULL)
+            goto invalid_element;
+    }
+
+    *strv = elements;
+    *length = n;
+
+    return TRUE;
+
+invalid_element: {
+        g_strfreev(elements);
+        return FALSE;
+    }
+}
+
+gboolean rbGObject_unmarshal_envp(VALUE hash, gchar ***envp, gint *length)
+{
+    gint n;
+    gchar **elements;
+    VALUE keys, name, value;
+    gchar *raw_name = NULL;
+    gchar *raw_value = NULL;
+
+    keys = rb_funcall(hash, rb_intern("keys"), 0);
+    n = RARRAY_LEN(hash);
+    elements = g_new0 (gchar *, n + 1);
+
+    for (int i = 0; i < n; i++) {
+        name = RARRAY_AREF(keys, i);
+        raw_name = g_strdup(StringValueCStr(name));
+        value = rb_hash_aref(hash, name);
+        raw_value = g_strdup(StringValueCStr(value));
+        elements[i] = g_strconcat (raw_name, "=", raw_value, NULL);
+
+        g_free(g_steal_pointer(&raw_value));
+        g_free(g_steal_pointer(&raw_name));
+    }
+
+    *envp = elements;
+    *length = n;
+
+    return TRUE;
+}
+
+gboolean rbGObject_unmarshal_variant(VALUE value, GVariant ** variant)
+{
+    if (RB_TYPE_P(value, T_STRING)) {
+        gchar *str;
+
+        rbGObject_unmarshal_string(value, &str);
+
+        *variant = g_variant_new_take_string(str);
+    } else if (value == Qtrue || value == Qfalse) {
+        *variant = g_variant_new_boolean(value == Qtrue);
+    } else if (RB_TYPE_P(value, T_FIXNUM)) {
+        long long l;
+
+        l = NUM2LL(value);
+        *variant = g_variant_new_int64(l);
+    } else {
+        goto unsupported_type;
+    }
+    return TRUE;
+
+unsupported_type: {
+        raise_argerror("unsupported type");
+        goto propagate_error;
+    }
+propagate_error: {
+        return FALSE;
+    }
+}
+
+VALUE rbGObject_marshal_strv(gchar **strv, gint length)
+{
+    VALUE result;
+    gint i;
+
+    if (strv == NULL)
+        return (Qnil);
+
+    result = rb_ary_new_capa(length);
+    for (i = 0; i != length; i++) {
+        rb_ary_store(result, i, rbGObject_marshal_string(strv[i]));
+    }
+
+    return result;
+}
+
+VALUE rbGObject_marshal_envp(const gchar **envp, gint length)
+{
+    VALUE result;
+    gint i;
+
+    if (envp == NULL)
+        return (Qnil);
+
+    result = rb_hash_new();
+
+    for (i = 0; i != length; i++) {
+        gchar **tokens;
+
+        tokens = g_strsplit(envp[i], "=", 2);
+
+        if (g_strv_length(tokens) == 2) {
+            const gchar * name;
+            VALUE value;
+
+            name = tokens[0];
+            value = rbGObject_marshal_string(tokens[1]);
+
+            rb_hash_aset(result, ID2SYM(rb_intern(name)), value);
+        }
+
+        g_strfreev(tokens);
+    }
+
+    return result;
+}
+
+VALUE rbGObject_marshal_bytes(GBytes * bytes)
+{
+    if (!bytes)	return (Qnil);
+    gconstpointer data;
+    gsize size;
+
+    data = g_bytes_get_data (bytes, &size);
+    return (rb_str_new((const char *)data, size));
+}
+
+static VALUE rbGObject_marshal_object(gpointer handle, GType type)
+{
+    VALUE object = Qnil;
+
+    if (!handle)
+        return (Qnil);
+    g_object_ref(handle);
+    if (type == FRIDA_TYPE_DEVICE_MANAGER)
+        object = DeviceManager_from_FridaDeviceManager(handle);
+    else if (type ==  FRIDA_TYPE_DEVICE)
+        object = Device_from_FridaDevice(handle);
+    else if (type ==  FRIDA_TYPE_APPLICATION)
+        object = Application_from_FridaApplication(handle);
+    else if (type ==  FRIDA_TYPE_PROCESS)
+        object = Process_from_FridaProcess(handle);
+    else if (type ==  FRIDA_TYPE_SPAWN)
+        object = Spawn_from_FridaSpawn(handle);
+    else if (type ==  FRIDA_TYPE_CHILD)
+        object = Child_from_FridaChild(handle);
+    else if (type ==  FRIDA_TYPE_BUS)
+        object = Bus_from_FridaBus(handle);
+    else if (type ==  FRIDA_TYPE_SESSION)
+        object = Session_from_FridaSession(handle);
+    else if (type ==  FRIDA_TYPE_SCRIPT)
+        object = Script_from_FridaScript(handle);
+    else if (type ==  FRIDA_TYPE_RELAY)
+        object = Relay_from_FridaRelay(handle);
+    else if (type ==  FRIDA_TYPE_PORTAL_MEMBERSHIP)
+        object = PortalMembership_from_FridaPortalMembership(handle);
+    else if (type ==  G_TYPE_IO_STREAM)
+        object = IOStream_from_GIOStream(handle);
+    else if (type == FRIDA_TYPE_CRASH)
+        object = Crash_from_FridaCrash(handle);
+    else if (type == FRIDA_TYPE_FILE_MONITOR)
+        object = FileMonitor_from_FridaFileMonitor(handle);
+    else if (type == FRIDA_TYPE_COMPILER)
+        object = Compiler_from_FridaCompiler(handle);
+    return (object);
+}
+
+static VALUE rbGObject_marshal_socket_address(GSocketAddress * address)
+{
+    VALUE result = Qnil;
+
+    if (G_IS_INET_SOCKET_ADDRESS (address)) {
+        GInetSocketAddress * sa;
+        GInetAddress * ia;
+        gchar * host;
+        guint16 port;
+
+        sa = G_INET_SOCKET_ADDRESS (address);
+        ia = g_inet_socket_address_get_address (sa);
+
+        host = g_inet_address_to_string (ia);
+        port = g_inet_socket_address_get_port (sa);
+
+        if (g_socket_address_get_family (address) == G_SOCKET_FAMILY_IPV4)
+            result = rb_sprintf("(%s, %d)", host, port);
+        else
+            result = rb_sprintf("(%s, %d, %d, %d)", host, port, g_inet_socket_address_get_flowinfo(sa), g_inet_socket_address_get_scope_id(sa));
+
+        g_free (host);
+    } else if (G_IS_UNIX_SOCKET_ADDRESS (address)) {
+        GUnixSocketAddress * sa = G_UNIX_SOCKET_ADDRESS (address);
+
+        switch (g_unix_socket_address_get_address_type (sa)) {
+        case G_UNIX_SOCKET_ADDRESS_ANONYMOUS: {
+            result = rb_str_new_cstr ("");
+            break;
+        }
+        case G_UNIX_SOCKET_ADDRESS_PATH: {
+            gchar * path = g_filename_to_utf8 (g_unix_socket_address_get_path (sa), -1, NULL, NULL, NULL);
+            result = rb_str_new_cstr (path);
+            g_free (path);
+            break;
+        }
+        case G_UNIX_SOCKET_ADDRESS_ABSTRACT:
+        case G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED: {
+            result = rb_str_new (g_unix_socket_address_get_path (sa), g_unix_socket_address_get_path_len (sa));
+            break;
+        }
+        default: {
+            result = Qnil;
+            break;
+        }
+        }
+    }
+    return result;
+}
+
+VALUE rbGObject_marshal_value(const GValue *value)
+{
+    GType type;
+
+    type = G_VALUE_TYPE(value);
+    switch (type) {
+    case G_TYPE_BOOLEAN:
+        return (g_value_get_boolean(value) ? Qtrue : Qfalse);
+
+    case G_TYPE_INT:
+        return LL2NUM(g_value_get_int(value));
+
+    case G_TYPE_UINT:
+        return UINT2NUM(g_value_get_uint(value));
+
+    case G_TYPE_FLOAT:
+        return DBL2NUM(g_value_get_float(value));
+
+    case G_TYPE_DOUBLE:
+        return DBL2NUM(g_value_get_double(value));
+
+    case G_TYPE_STRING:
+        return rbGObject_marshal_string(g_value_get_string(value));
+
+    case G_TYPE_VARIANT:
+        return rbGObject_marshal_variant(g_value_get_variant(value));
+
+    default:
+        if (G_TYPE_IS_ENUM(type))
+            return rbGObject_marshal_enum(g_value_get_enum(value), type);
+
+        if (type == G_TYPE_BYTES) {
+            return rbGObject_marshal_bytes(g_value_get_boxed(value));
+        }
+
+        if (G_TYPE_IS_OBJECT(type)) {
+            if (G_IS_SOCKET_ADDRESS(g_value_get_object(value)))
+                return (rbGObject_marshal_socket_address(g_value_get_object(value)));
+            return rbGObject_marshal_object(g_value_get_object(value), type);
+        }
+        goto unsupported_type;
+    }
+
+    g_assert_not_reached();
+
+unsupported_type: {
+        raise_rerror("unsupported type", NULL);
+        return (Qnil);
+    }
+}
+
+VALUE *rbGObjectSignalClosure_marshal_params(const GValue *params, guint params_length)
+{
+    VALUE *args;
+
+    args = malloc(sizeof(VALUE) * params_length);
+
+    for (uint i = 0; i < params_length; i++) {
+        VALUE arg;
+
+        arg = rbGObject_marshal_value(&params[i]);
+        args[i] = arg;
+    }
+    return args;
+}