frida 16.7.14 → 16.7.15

package/src/addon.cc

@@ -1,78 +0,0 @@
-#include "application.h"
-#include "bus.h"
-#include "cancellable.h"
-#include "child.h"
-#include "crash.h"
-#include "device.h"
-#include "device_manager.h"
-#include "endpoint_parameters.h"
-#include "glib_context.h"
-#include "iostream.h"
-#include "portal_membership.h"
-#include "portal_service.h"
-#include "process.h"
-#include "relay.h"
-#include "runtime.h"
-#include "script.h"
-#include "service.h"
-#include "session.h"
-#include "signals.h"
-#include "spawn.h"
-#include "uv_context.h"
-
-using v8::Context;
-using v8::Local;
-using v8::Object;
-using v8::Value;
-
-namespace frida {
-
-static void DisposeAll(void* data);
-
-static void InitAll(Local<Object> exports,
-    Local<Value> module,
-    Local<Context> context) {
-  frida_init();
-
-  auto uv_context = new UVContext(uv_default_loop());
-  auto glib_context = new GLibContext(frida_get_main_context());
-  auto runtime = new Runtime(uv_context, glib_context);
-
-  Signals::Init(exports, runtime);
-
-  DeviceManager::Init(exports, runtime);
-  Device::Init(exports, runtime);
-  Application::Init(exports, runtime);
-  Process::Init(exports, runtime);
-  Spawn::Init(exports, runtime);
-  Child::Init(exports, runtime);
-  Crash::Init(exports, runtime);
-  Bus::Init(exports, runtime);
-  Service::Init(exports, runtime);
-  Session::Init(exports, runtime);
-  Script::Init(exports, runtime);
-  Relay::Init(exports, runtime);
-  PortalMembership::Init(exports, runtime);
-  PortalService::Init(exports, runtime);
-  EndpointParameters::Init(exports, runtime);
-  IOStream::Init(exports, runtime);
-  Cancellable::Init(exports, runtime);
-
-#if NODE_VERSION_AT_LEAST(11, 0, 0)
-  node::AddEnvironmentCleanupHook(context->GetIsolate(), DisposeAll, runtime);
-#else
-  node::AtExit(DisposeAll, runtime);
-#endif
-}
-
-static void DisposeAll(void* data) {
-  auto runtime = static_cast<Runtime*>(data);
-
-  DeviceManager::Dispose(runtime);
-
-  delete runtime;
-}
-
-}
-
-NODE_MODULE_CONTEXT_AWARE(frida_binding, frida::InitAll)

package/src/application.cc

@@ -1,148 +0,0 @@
-#include "application.h"
-
-#include <cstring>
-
-#define APPLICATION_DATA_CONSTRUCTOR "application:ctor"
-
-using std::strcmp;
-using v8::DEFAULT;
-using v8::External;
-using v8::Function;
-using v8::Integer;
-using v8::Isolate;
-using v8::Local;
-using v8::Object;
-using v8::Persistent;
-using v8::ReadOnly;
-using v8::String;
-using v8::Value;
-
-namespace frida {
-
-Application::Application(FridaApplication* handle, Runtime* runtime)
-    : GLibObject(handle, runtime) {
-  g_object_ref(handle_);
-}
-
-Application::~Application() {
-  g_object_unref(handle_);
-}
-
-void Application::Init(Local<Object> exports, Runtime* runtime) {
-  auto isolate = Isolate::GetCurrent();
-
-  auto name = Nan::New("Application").ToLocalChecked();
-  auto tpl = CreateTemplate(name, Application::New, runtime);
-
-  auto instance_tpl = tpl->InstanceTemplate();
-  auto data = Local<Value>();
-  Nan::SetAccessor(instance_tpl, Nan::New("parameters").ToLocalChecked(),
-      GetParameters, 0, data, DEFAULT, ReadOnly);
-  Nan::SetAccessor(instance_tpl, Nan::New("pid").ToLocalChecked(),
-      GetPid, 0, data, DEFAULT, ReadOnly);
-  Nan::SetAccessor(instance_tpl, Nan::New("name").ToLocalChecked(),
-      GetName, 0, data, DEFAULT, ReadOnly);
-  Nan::SetAccessor(instance_tpl, Nan::New("identifier").ToLocalChecked(),
-      GetIdentifier, 0, data, DEFAULT, ReadOnly);
-
-  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
-  Nan::Set(exports, name, ctor);
-  runtime->SetDataPointer(APPLICATION_DATA_CONSTRUCTOR,
-      new Persistent<Function>(isolate, ctor));
-}
-
-Local<Object> Application::New(gpointer handle, Runtime* runtime) {
-  auto ctor = Nan::New<Function>(
-    *static_cast<Persistent<Function>*>(
-      runtime->GetDataPointer(APPLICATION_DATA_CONSTRUCTOR)));
-
-  const int argc = 1;
-  Local<Value> argv[argc] = { Nan::New<External>(handle) };
-  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
-}
-
-NAN_METHOD(Application::New) {
-  if (!info.IsConstructCall()) {
-    Nan::ThrowError("Use the `new` keyword to create a new instance");
-    return;
-  }
-
-  if (info.Length() != 1 || !info[0]->IsExternal()) {
-    Nan::ThrowTypeError("Bad argument, expected raw handle");
-    return;
-  }
-
-  auto runtime = GetRuntimeFromConstructorArgs(info);
-
-  auto handle = static_cast<FridaApplication*>(
-      Local<External>::Cast(info[0])->Value());
-  auto wrapper = new Application(handle, runtime);
-  auto obj = info.This();
-  wrapper->Wrap(obj);
-
-  info.GetReturnValue().Set(obj);
-}
-
-NAN_PROPERTY_GETTER(Application::GetIdentifier) {
-  auto handle = ObjectWrap::Unwrap<Application>(
-      info.Holder())->GetHandle<FridaApplication>();
-
-  info.GetReturnValue().Set(
-      Nan::New(frida_application_get_identifier(handle)).ToLocalChecked());
-}
-
-NAN_PROPERTY_GETTER(Application::GetName) {
-  auto handle = ObjectWrap::Unwrap<Application>(
-      info.Holder())->GetHandle<FridaApplication>();
-
-  info.GetReturnValue().Set(
-      Nan::New(frida_application_get_name(handle)).ToLocalChecked());
-}
-
-NAN_PROPERTY_GETTER(Application::GetPid) {
-  auto isolate = info.GetIsolate();
-  auto handle = ObjectWrap::Unwrap<Application>(
-      info.Holder())->GetHandle<FridaApplication>();
-
-  info.GetReturnValue().Set(
-      Integer::NewFromUnsigned(isolate, frida_application_get_pid(handle)));
-}
-
-NAN_PROPERTY_GETTER(Application::GetParameters) {
-  auto wrapper = ObjectWrap::Unwrap<Application>(info.Holder());
-  auto handle = wrapper->GetHandle<FridaApplication>();
-
-  GHashTable* parameters = frida_application_get_parameters(handle);
-  info.GetReturnValue().Set(ParseParameters(parameters));
-}
-
-Local<Value> Application::ParseParameters(GHashTable* dict) {
-  auto result = Nan::New<Object>();
-
-  GHashTableIter iter;
-  gpointer raw_key, raw_value;
-
-  g_hash_table_iter_init(&iter, dict);
-
-  while (g_hash_table_iter_next(&iter, &raw_key, &raw_value)) {
-    char* canonicalized_key =
-        Runtime::ParameterNameFromC(static_cast<char*>(raw_key));
-    GVariant* var_value = static_cast<GVariant*>(raw_value);
-
-    Local<String> key = Nan::New(canonicalized_key).ToLocalChecked();
-    Local<Value> value;
-    if (strcmp(canonicalized_key, "started") == 0 &&
-        g_variant_is_of_type(var_value, G_VARIANT_TYPE_STRING)) {
-      value = Runtime::ValueFromDatetime(g_variant_get_string(var_value, NULL));
-    } else {
-      value = Runtime::ValueFromVariant(var_value);
-    }
-    Nan::Set(result, key, value);
-
-    g_free(canonicalized_key);
-  }
-
-  return result;
-}
-
-}

package/src/application.h

@@ -1,31 +0,0 @@
-#ifndef FRIDANODE_APPLICATION_H
-#define FRIDANODE_APPLICATION_H
-
-#include "glib_object.h"
-
-#include <frida-core.h>
-
-namespace frida {
-
-class Application : public GLibObject {
- public:
-  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
-  static v8::Local<v8::Object> New(gpointer handle, Runtime* runtime);
-
- private:
-  explicit Application(FridaApplication* handle, Runtime* runtime);
-  ~Application();
-
-  static NAN_METHOD(New);
-
-  static NAN_PROPERTY_GETTER(GetIdentifier);
-  static NAN_PROPERTY_GETTER(GetName);
-  static NAN_PROPERTY_GETTER(GetPid);
-  static NAN_PROPERTY_GETTER(GetParameters);
-
-  static v8::Local<v8::Value> ParseParameters(GHashTable* dict);
-};
-
-}
-
-#endif

package/src/authentication.cc

@@ -1,174 +0,0 @@
-#include "authentication.h"
-
-using frida::Runtime;
-using v8::External;
-using v8::Function;
-using v8::Isolate;
-using v8::Local;
-using v8::Object;
-using v8::Persistent;
-using v8::String;
-using v8::Value;
-
-struct _FridaNodeAuthenticationService {
-  GObject parent;
-  Persistent<Function>* callback;
-  Runtime* runtime;
-};
-
-static void frida_node_authentication_service_iface_init(gpointer g_iface,
-    gpointer iface_data);
-static void frida_node_authentication_service_dispose(GObject* object);
-static void frida_node_authentication_service_authenticate(
-    FridaAuthenticationService* service, const gchar* token,
-    GCancellable* cancellable, GAsyncReadyCallback callback,
-    gpointer user_data);
-static gchar* frida_node_authentication_service_authenticate_finish(
-    FridaAuthenticationService* service, GAsyncResult* result, GError** error);
-
-G_DEFINE_TYPE_EXTENDED(
-    FridaNodeAuthenticationService,
-    frida_node_authentication_service,
-    G_TYPE_OBJECT,
-    0,
-    G_IMPLEMENT_INTERFACE(FRIDA_TYPE_AUTHENTICATION_SERVICE,
-      frida_node_authentication_service_iface_init))
-
-FridaAuthenticationService* frida_node_authentication_service_new(
-    Local<Function> callback, Runtime* runtime) {
-  auto service = static_cast<FridaNodeAuthenticationService*>(
-      g_object_new(FRIDA_TYPE_NODE_AUTHENTICATION_SERVICE, NULL));
-  service->callback = new Persistent<Function>(Isolate::GetCurrent(), callback);
-  service->runtime = runtime;
-  return FRIDA_AUTHENTICATION_SERVICE(service);
-}
-
-static void frida_node_authentication_service_class_init(
-    FridaNodeAuthenticationServiceClass* klass)
-{
-  GObjectClass* object_class = G_OBJECT_CLASS(klass);
-
-  object_class->dispose = frida_node_authentication_service_dispose;
-}
-
-static void frida_node_authentication_service_iface_init(gpointer g_iface,
-    gpointer iface_data) {
-  auto iface = static_cast<FridaAuthenticationServiceIface*>(g_iface);
-
-  iface->authenticate =
-      frida_node_authentication_service_authenticate;
-  iface->authenticate_finish =
-      frida_node_authentication_service_authenticate_finish;
-}
-
-static void frida_node_authentication_service_init(
-    FridaNodeAuthenticationService* self) {
-}
-
-static void frida_node_authentication_service_dispose(GObject* object) {
-  auto self = FRIDA_NODE_AUTHENTICATION_SERVICE(object);
-
-  Persistent<Function>* callback = self->callback;
-  if (callback != NULL) {
-    self->callback = NULL;
-    self->runtime->GetUVContext()->Schedule([=]() {
-      delete callback;
-    });
-  }
-
-  G_OBJECT_CLASS(frida_node_authentication_service_parent_class)->dispose(
-      object);
-}
-
-static NAN_METHOD(OnAuthenticationSuccess) {
-  auto task = static_cast<GTask*>(info.Data().As<External>()->Value ());
-  auto self = static_cast<FridaNodeAuthenticationService*>(
-      g_task_get_source_object(task));
-
-  gchar* session_info = NULL;
-  if (info.Length() >= 1) {
-    auto val = info[0];
-    if (val->IsObject() && !val->IsNull()) {
-      Local<String> json = self->runtime->ValueToJson(val);
-      Nan::Utf8String str(json);
-      session_info = g_strdup(*str);
-    }
-  }
-
-  if (session_info != NULL) {
-    g_task_return_pointer(task, session_info, g_free);
-  } else {
-    g_task_return_new_error(task, FRIDA_ERROR, FRIDA_ERROR_INVALID_ARGUMENT,
-        "Internal error");
-  }
-
-  g_object_unref(task);
-}
-
-static NAN_METHOD(OnAuthenticationFailure) {
-  auto task = static_cast<GTask*>(info.Data().As<External>()->Value ());
-
-  Local<Value> fallback_message = Nan::New("Internal error").ToLocalChecked();
-  Local<Value> message = fallback_message;
-  if (info.Length() >= 1) {
-    auto error_value = info[0];
-    if (error_value->IsObject()) {
-      message = Nan::Get(error_value.As<Object>(),
-          Nan::New("message").ToLocalChecked()).FromMaybe(fallback_message);
-    }
-  }
-
-  Nan::Utf8String str(message);
-  g_task_return_new_error(task, FRIDA_ERROR, FRIDA_ERROR_INVALID_ARGUMENT,
-      "%s", *str);
-
-  g_object_unref(task);
-}
-
-static void frida_node_authentication_service_authenticate(
-    FridaAuthenticationService* service, const gchar* token,
-    GCancellable* cancellable, GAsyncReadyCallback callback,
-    gpointer user_data) {
-  auto self = FRIDA_NODE_AUTHENTICATION_SERVICE(service);
-
-  auto task = g_task_new(self, cancellable, callback, user_data);
-  g_task_set_task_data(task, g_strdup(token), g_free);
-
-  self->runtime->GetUVContext()->Schedule([=]() {
-    auto context = Isolate::GetCurrent()->GetCurrentContext();
-
-    bool scheduled = false;
-    Local<Value> no_result = Nan::Undefined();
-
-    auto callback = Nan::New<Function>(*self->callback);
-    Local<Value> token_value = Nan::New(static_cast<gchar*>(
-          g_task_get_task_data(task))).ToLocalChecked();
-
-    Local<Value> promise_value = callback->Call(context, Nan::Undefined(), 1,
-        &token_value).FromMaybe(no_result);
-    if (promise_value->IsObject()) {
-      auto promise = promise_value.As<Object>();
-      auto then = Nan::Get(promise, Nan::New("then").ToLocalChecked())
-          .FromMaybe(no_result);
-      if (then->IsFunction()) {
-        Local<Value> argv[] = {
-          Nan::New<Function>(OnAuthenticationSuccess, Nan::New<External>(task)),
-          Nan::New<Function>(OnAuthenticationFailure, Nan::New<External>(task)),
-        };
-        scheduled = !then.As<Function>()->Call(context, promise_value,
-            G_N_ELEMENTS(argv), argv).IsEmpty();
-      }
-    }
-
-    if (!scheduled) {
-      g_task_return_new_error(task, FRIDA_ERROR, FRIDA_ERROR_INVALID_ARGUMENT,
-          "Internal error");
-      g_object_unref(task);
-    }
-  });
-}
-
-static gchar* frida_node_authentication_service_authenticate_finish(
-    FridaAuthenticationService* service, GAsyncResult* result, GError** error) {
-  return static_cast<gchar*>(g_task_propagate_pointer(G_TASK(result), error));
-}

package/src/authentication.h

@@ -1,24 +0,0 @@
-#ifndef FRIDANODE_AUTHENTICATION_H
-#define FRIDANODE_AUTHENTICATION_H
-
-#include "runtime.h"
-
-#include <frida-core.h>
-#include <node.h>
-
-G_BEGIN_DECLS
-
-#define FRIDA_TYPE_NODE_AUTHENTICATION_SERVICE (frida_node_authentication_service_get_type())
-G_DECLARE_FINAL_TYPE(
-    FridaNodeAuthenticationService,
-    frida_node_authentication_service,
-    FRIDA,
-    NODE_AUTHENTICATION_SERVICE,
-    GObject)
-
-FridaAuthenticationService* frida_node_authentication_service_new(
-    v8::Local<v8::Function> callback, frida::Runtime* runtime);
-
-G_END_DECLS
-
-#endif

package/src/bus.cc

@@ -1,167 +0,0 @@
-#include "bus.h"
-
-#include "operation.h"
-#include "signals.h"
-#include "usage_monitor.h"
-
-#include <cstring>
-
-#define BUS_DATA_CONSTRUCTOR "bus:ctor"
-
-using std::strcmp;
-using v8::External;
-using v8::Function;
-using v8::Isolate;
-using v8::Local;
-using v8::Object;
-using v8::Persistent;
-using v8::Value;
-
-namespace frida {
-
-Bus::Bus(FridaBus* handle, Runtime* runtime)
-    : GLibObject(handle, runtime) {
-  g_object_ref(handle_);
-}
-
-Bus::~Bus() {
-  g_object_unref(handle_);
-}
-
-void Bus::Init(Local<Object> exports, Runtime* runtime) {
-  auto isolate = Isolate::GetCurrent();
-
-  auto name = Nan::New("Bus").ToLocalChecked();
-  auto tpl = CreateTemplate(name, New, runtime);
-
-  Nan::SetPrototypeMethod(tpl, "attach", Attach);
-  Nan::SetPrototypeMethod(tpl, "post", Post);
-
-  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
-  Nan::Set(exports, name, ctor);
-  runtime->SetDataPointer(BUS_DATA_CONSTRUCTOR,
-      new Persistent<Function>(isolate, ctor));
-}
-
-Local<Object> Bus::New(gpointer handle, Runtime* runtime) {
-  auto ctor = Nan::New<Function>(
-      *static_cast<Persistent<Function>*>(
-      runtime->GetDataPointer(BUS_DATA_CONSTRUCTOR)));
-  const int argc = 1;
-  Local<Value> argv[argc] = { Nan::New<External>(handle) };
-  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
-}
-
-NAN_METHOD(Bus::New) {
-  if (!info.IsConstructCall()) {
-    Nan::ThrowError("Use the `new` keyword to create a new instance");
-    return;
-  }
-
-  if (info.Length() != 1 || !info[0]->IsExternal()) {
-    Nan::ThrowTypeError("Bad argument, expected raw handle");
-    return;
-  }
-
-  auto runtime = GetRuntimeFromConstructorArgs(info);
-
-  auto handle = static_cast<FridaBus*>(
-      Local<External>::Cast(info[0])->Value());
-  auto wrapper = new Bus(handle, runtime);
-  auto obj = info.This();
-  wrapper->Wrap(obj);
-  auto signals_obj = Signals::New(handle, runtime, TransformSignal, runtime);
-
-  Nan::Set(obj, Nan::New("signals").ToLocalChecked(), signals_obj);
-
-  auto signals_wrapper = ObjectWrap::Unwrap<Signals>(signals_obj);
-  signals_wrapper->SetConnectCallback(OnConnect, runtime);
-  signals_wrapper->SetDisconnectCallback(OnDisconnect, runtime);
-
-  info.GetReturnValue().Set(obj);
-}
-
-namespace {
-
-class AttachOperation : public Operation<FridaBus> {
- protected:
-  void Begin() {
-    frida_bus_attach(handle_, cancellable_, OnReady, this);
-  }
-
-  void End(GAsyncResult* result, GError** error) {
-    frida_bus_attach_finish(handle_, result, error);
-  }
-
-  Local<Value> Result(Isolate* isolate) {
-    return Nan::Undefined();
-  }
-};
-
-}
-
-NAN_METHOD(Bus::Attach) {
-  auto isolate = info.GetIsolate();
-  auto wrapper = ObjectWrap::Unwrap<Bus>(info.Holder());
-
-  auto operation = new AttachOperation();
-  operation->Schedule(isolate, wrapper, info);
-
-  info.GetReturnValue().Set(operation->GetPromise(isolate));
-}
-
-NAN_METHOD(Bus::Post) {
-  auto wrapper = ObjectWrap::Unwrap<Bus>(info.Holder());
-
-  auto num_args = info.Length();
-  if (num_args < 2) {
-    Nan::ThrowTypeError("Expected message and data");
-    return;
-  }
-
-  Nan::Utf8String message(wrapper->runtime_->ValueToJson(info[0]));
-
-  GBytes* data = NULL;
-  auto buffer = info[1];
-  if (!buffer->IsNull()) {
-    if (!node::Buffer::HasInstance(buffer)) {
-      Nan::ThrowTypeError("Expected a buffer");
-      return;
-    }
-    data = g_bytes_new(node::Buffer::Data(buffer),
-        node::Buffer::Length(buffer));
-  }
-
-  frida_bus_post(wrapper->GetHandle<FridaBus>(), *message, data);
-
-  g_bytes_unref(data);
-}
-
-Local<Value> Bus::TransformSignal(const gchar* name, guint index,
-    const GValue* value, gpointer user_data) {
-  if (index != 0 || strcmp(name, "message") != 0)
-    return Local<Value>();
-  auto runtime = static_cast<Runtime*>(user_data);
-  auto json = Nan::New(g_value_get_string(value)).ToLocalChecked();
-  return runtime->ValueFromJson(json);
-}
-
-void Bus::OnConnect(const gchar* name, gpointer user_data) {
-  auto runtime = static_cast<Runtime*>(user_data);
-
-  if (ShouldStayAliveToEmit(name))
-    runtime->GetUVContext()->IncreaseUsage();
-}
-
-void Bus::OnDisconnect(const gchar* name, gpointer user_data) {
-  auto runtime = static_cast<Runtime*>(user_data);
-
-  if (ShouldStayAliveToEmit(name))
-    runtime->GetUVContext()->DecreaseUsage();
-}
-
-bool Bus::ShouldStayAliveToEmit(const gchar* name) {
-  return strcmp(name, "detached") == 0 || strcmp(name, "message") == 0;
-}
-
-}

package/src/bus.h

@@ -1,33 +0,0 @@
-#ifndef FRIDANODE_BUS_H
-#define FRIDANODE_BUS_H
-
-#include "glib_object.h"
-
-#include <frida-core.h>
-
-namespace frida {
-
-class Bus : public GLibObject {
- public:
-  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
-  static v8::Local<v8::Object> New(gpointer handle, Runtime* runtime);
-
- private:
-  explicit Bus(FridaBus* handle, Runtime* runtime);
-  ~Bus();
-
-  static NAN_METHOD(New);
-
-  static NAN_METHOD(Attach);
-  static NAN_METHOD(Post);
-
-  static v8::Local<v8::Value> TransformSignal(const gchar* name, guint index,
-      const GValue* value, gpointer user_data);
-  static void OnConnect(const gchar* signal, gpointer user_data);
-  static void OnDisconnect(const gchar* signal, gpointer user_data);
-  static bool ShouldStayAliveToEmit(const gchar* signal);
-};
-
-}
-
-#endif