frida 16.2.0 → 16.2.2

package/src/device.h

@@ -0,0 +1,55 @@
+#ifndef FRIDANODE_DEVICE_H
+#define FRIDANODE_DEVICE_H
+
+#include "glib_object.h"
+
+#include <frida-core.h>
+
+namespace frida {
+
+class Device : public GLibObject {
+ public:
+  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
+  static v8::Local<v8::Object> New(gpointer handle, Runtime* runtime);
+
+ private:
+  Device(FridaDevice* handle, Runtime* runtime);
+  ~Device();
+
+  static NAN_METHOD(New);
+
+  static NAN_PROPERTY_GETTER(GetId);
+  static NAN_PROPERTY_GETTER(GetName);
+  static NAN_PROPERTY_GETTER(GetIcon);
+  static NAN_PROPERTY_GETTER(GetType);
+  static NAN_PROPERTY_GETTER(GetBus);
+  static NAN_PROPERTY_GETTER(IsLost);
+
+  static NAN_METHOD(QuerySystemParameters);
+  static NAN_METHOD(GetFrontmostApplication);
+  static NAN_METHOD(EnumerateApplications);
+  static NAN_METHOD(EnumerateProcesses);
+  static NAN_METHOD(EnableSpawnGating);
+  static NAN_METHOD(DisableSpawnGating);
+  static NAN_METHOD(EnumeratePendingSpawn);
+  static NAN_METHOD(EnumeratePendingChildren);
+  static NAN_METHOD(Spawn);
+  static NAN_METHOD(Input);
+  static NAN_METHOD(Resume);
+  static NAN_METHOD(Kill);
+  static NAN_METHOD(Attach);
+  static NAN_METHOD(InjectLibraryFile);
+  static NAN_METHOD(InjectLibraryBlob);
+  static NAN_METHOD(OpenChannel);
+  static NAN_METHOD(Unpair);
+
+  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

package/src/device_manager.cc

@@ -0,0 +1,362 @@
+#include "device_manager.h"
+
+#include "device.h"
+#include "operation.h"
+#include "signals.h"
+
+#include <cstring>
+
+#define DEVICE_MANAGER_DATA_WRAPPERS "device_manager:wrappers"
+
+using std::strcmp;
+using v8::Array;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace frida {
+
+DeviceManager::DeviceManager(FridaDeviceManager* handle, Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+
+  runtime_->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, g_slist_prepend(
+      static_cast<GSList*>(
+      runtime_->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS)), this));
+}
+
+DeviceManager::~DeviceManager() {
+  runtime_->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, g_slist_remove(
+      static_cast<GSList*>(
+      runtime_->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS)), this));
+
+  frida_unref(handle_);
+}
+
+void DeviceManager::Init(Local<Object> exports, Runtime* runtime) {
+  Local<String> name = Nan::New("DeviceManager").ToLocalChecked();
+
+  auto tpl = CreateTemplate(name, DeviceManager::New, runtime);
+
+  Nan::SetPrototypeMethod(tpl, "close", Close);
+  Nan::SetPrototypeMethod(tpl, "enumerateDevices", EnumerateDevices);
+  Nan::SetPrototypeMethod(tpl, "addRemoteDevice", AddRemoteDevice);
+  Nan::SetPrototypeMethod(tpl, "removeRemoteDevice", RemoveRemoteDevice);
+
+  Nan::Set(exports, name, Nan::GetFunction(tpl).ToLocalChecked());
+}
+
+void DeviceManager::Dispose(Runtime* runtime) {
+  auto wrappers = static_cast<GSList*>(
+      runtime->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS));
+  while (wrappers != NULL) {
+    auto wrapper = static_cast<DeviceManager*>(wrappers->data);
+    frida_device_manager_close_sync(wrapper->GetHandle<FridaDeviceManager>(),
+        NULL, NULL);
+    wrappers = g_slist_delete_link(wrappers, wrappers);
+  }
+  runtime->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, NULL);
+}
+
+NAN_METHOD(DeviceManager::New) {
+  if (!info.IsConstructCall()) {
+    Nan::ThrowError("Use the `new` keyword to create a new instance");
+    return;
+  }
+
+  auto runtime = GetRuntimeFromConstructorArgs(info);
+
+  auto handle = frida_device_manager_new();
+
+  auto wrapper = new DeviceManager(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+
+  auto signals_obj = Signals::New(handle, runtime, TransformDeviceSignals,
+      runtime);
+  Nan::Set(obj, Nan::New("signals").ToLocalChecked(), signals_obj);
+
+  g_object_unref(handle);
+
+  auto signals_wrapper = ObjectWrap::Unwrap<Signals>(signals_obj);
+  signals_wrapper->SetConnectCallback(OnConnect, runtime);
+  signals_wrapper->SetDisconnectCallback(OnDisconnect, runtime);
+
+  info.GetReturnValue().Set(obj);
+}
+
+namespace {
+
+class CloseOperation : public Operation<FridaDeviceManager> {
+ protected:
+  void Begin() {
+    frida_device_manager_close(handle_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    frida_device_manager_close_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+};
+
+}
+
+NAN_METHOD(DeviceManager::Close) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
+
+  auto operation = new CloseOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class EnumerateDevicesOperation : public Operation<FridaDeviceManager> {
+ protected:
+  void Begin() {
+    frida_device_manager_enumerate_devices(handle_, cancellable_, OnReady,
+        this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    devices_ = frida_device_manager_enumerate_devices_finish(handle_, result,
+        error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    auto size = frida_device_list_size(devices_);
+    Local<Array> devices = Nan::New<Array>(size);
+    for (auto i = 0; i != size; i++) {
+      auto handle = frida_device_list_get(devices_, i);
+      auto device = Device::New(handle, runtime_);
+      Nan::Set(devices, i, device);
+      g_object_unref(handle);
+    }
+
+    frida_unref(devices_);
+
+    return devices;
+  }
+
+ private:
+  FridaDeviceList* devices_;
+};
+
+}
+
+NAN_METHOD(DeviceManager::EnumerateDevices) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
+
+  auto operation = new EnumerateDevicesOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class AddRemoteDeviceOperation : public Operation<FridaDeviceManager> {
+ public:
+  AddRemoteDeviceOperation(gchar* address, FridaRemoteDeviceOptions* options)
+    : address_(address),
+      options_(options) {
+  }
+
+  ~AddRemoteDeviceOperation() {
+    g_object_unref(options_);
+    g_free(address_);
+  }
+
+ protected:
+  void Begin() {
+    frida_device_manager_add_remote_device(handle_, address_, options_,
+        cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    device_ = frida_device_manager_add_remote_device_finish(handle_, result,
+        error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    auto wrapper = Device::New(device_, runtime_);
+    g_object_unref(device_);
+    return wrapper;
+  }
+
+ private:
+  gchar* address_;
+  FridaRemoteDeviceOptions* options_;
+  FridaDevice* device_;
+};
+
+}
+
+NAN_METHOD(DeviceManager::AddRemoteDevice) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
+
+  if (info.Length() < 5) {
+    Nan::ThrowTypeError("Missing one or more arguments");
+    return;
+  }
+
+  auto address_value = info[0];
+  auto certificate_value = info[1];
+  auto origin_value = info[2];
+  auto token_value = info[3];
+  auto keepalive_interval_value = info[4];
+
+  if (!address_value->IsString()) {
+    Nan::ThrowTypeError("Bad argument, 'address' must be a string");
+    return;
+  }
+  Nan::Utf8String address(address_value);
+
+  auto options = frida_remote_device_options_new();
+  bool valid = true;
+
+  if (!certificate_value->IsNull()) {
+    GTlsCertificate* certificate;
+    valid = Runtime::ValueToCertificate(certificate_value, &certificate);
+    if (valid) {
+      frida_remote_device_options_set_certificate(options, certificate);
+      g_object_unref(certificate);
+    }
+  }
+
+  if (valid && !origin_value->IsNull()) {
+    if (origin_value->IsString()) {
+      Nan::Utf8String origin(origin_value);
+      frida_remote_device_options_set_origin(options, *origin);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'origin' must be a string");
+      valid = false;
+    }
+  }
+
+  if (valid && !token_value->IsNull()) {
+    if (token_value->IsString()) {
+      Nan::Utf8String token(token_value);
+      frida_remote_device_options_set_token(options, *token);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'token' must be a string");
+      valid = false;
+    }
+  }
+
+  if (valid && !keepalive_interval_value->IsNull()) {
+    if (keepalive_interval_value->IsNumber()) {
+      auto keepalive_interval =
+          Nan::To<int32_t>(keepalive_interval_value).FromMaybe(-1);
+      if (keepalive_interval >= -1) {
+        frida_remote_device_options_set_keepalive_interval(options,
+            keepalive_interval);
+      } else {
+        Nan::ThrowTypeError("Bad argument, invalid 'keepaliveInterval'");
+        valid = false;
+      }
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'keepaliveInterval' must be a number");
+      valid = false;
+    }
+  }
+
+  if (!valid) {
+    g_object_unref(options);
+    return;
+  }
+
+  auto operation = new AddRemoteDeviceOperation(g_strdup(*address), options);
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class RemoveRemoteDeviceOperation : public Operation<FridaDeviceManager> {
+ public:
+  RemoveRemoteDeviceOperation(gchar* address) : address_(address) {
+  }
+
+  ~RemoveRemoteDeviceOperation() {
+    g_free(address_);
+  }
+
+ protected:
+  void Begin() {
+    frida_device_manager_remove_remote_device(handle_, address_, cancellable_,
+        OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    frida_device_manager_remove_remote_device_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+
+ private:
+  gchar* address_;
+};
+
+}
+
+NAN_METHOD(DeviceManager::RemoveRemoteDevice) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
+
+  if (info.Length() < 1 || !info[0]->IsString()) {
+    Nan::ThrowTypeError("Expected an address");
+    return;
+  }
+
+  Nan::Utf8String address(info[0]);
+
+  auto operation = new RemoveRemoteDeviceOperation(g_strdup(*address));
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+Local<Value> DeviceManager::TransformDeviceSignals(const gchar* name,
+    guint index, const GValue* value, gpointer user_data) {
+  if (index == 0 && (strcmp(name, "added") == 0 ||
+      strcmp(name, "removed") == 0)) {
+    auto runtime = static_cast<Runtime*>(user_data);
+    return Device::New(g_value_get_object(value), runtime);
+  }
+  return Local<Value>();
+}
+
+void DeviceManager::OnConnect(const gchar* name, gpointer user_data) {
+  auto runtime = static_cast<Runtime*>(user_data);
+
+  if (ShouldStayAliveToEmit(name))
+    runtime->GetUVContext()->IncreaseUsage();
+}
+
+void DeviceManager::OnDisconnect(const gchar* name, gpointer user_data) {
+  auto runtime = static_cast<Runtime*>(user_data);
+
+  if (ShouldStayAliveToEmit(name))
+    runtime->GetUVContext()->DecreaseUsage();
+}
+
+bool DeviceManager::ShouldStayAliveToEmit(const gchar* name) {
+  return strcmp(name, "added") == 0 ||
+      strcmp(name, "removed") == 0 ||
+      strcmp(name, "changed") == 0;
+}
+
+}

package/src/device_manager.h

@@ -0,0 +1,35 @@
+#ifndef FRIDANODE_DEVICE_MANAGER_H
+#define FRIDANODE_DEVICE_MANAGER_H
+
+#include "glib_object.h"
+
+#include <frida-core.h>
+
+namespace frida {
+
+class DeviceManager : public GLibObject {
+ public:
+  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
+  static void Dispose(Runtime* runtime);
+
+ private:
+  DeviceManager(FridaDeviceManager* handle, Runtime* runtime);
+  ~DeviceManager();
+
+  static NAN_METHOD(New);
+
+  static NAN_METHOD(Close);
+  static NAN_METHOD(EnumerateDevices);
+  static NAN_METHOD(AddRemoteDevice);
+  static NAN_METHOD(RemoveRemoteDevice);
+
+  static v8::Local<v8::Value> TransformDeviceSignals(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

package/src/endpoint_parameters.cc

@@ -0,0 +1,171 @@
+#include "endpoint_parameters.h"
+
+#include "authentication.h"
+
+#define ENDPOINT_PARAMETERS_DATA_TEMPLATE "endpoint_parameters:tpl"
+
+using v8::Function;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Persistent;
+using v8::Value;
+
+namespace frida {
+
+EndpointParameters::EndpointParameters(FridaEndpointParameters* handle,
+    Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+}
+
+EndpointParameters::~EndpointParameters() {
+  g_object_unref(handle_);
+}
+
+void EndpointParameters::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("EndpointParameters").ToLocalChecked();
+  auto tpl = CreateTemplate(name, EndpointParameters::New, runtime);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(ENDPOINT_PARAMETERS_DATA_TEMPLATE,
+      new Persistent<FunctionTemplate>(isolate, tpl));
+}
+
+FridaEndpointParameters* EndpointParameters::TryParse(Local<Value> value,
+    Runtime* runtime) {
+  if (!value->IsObject())
+    return NULL;
+
+  auto impl = Nan::Get(value.As<Object>(), Nan::New("impl").ToLocalChecked())
+      .ToLocalChecked();
+  if (!HasInstance(impl, runtime))
+    return NULL;
+
+  return ObjectWrap::Unwrap<EndpointParameters>(
+      impl.As<Object>())->GetHandle<FridaEndpointParameters>();
+}
+
+bool EndpointParameters::HasInstance(Local<Value> value, Runtime* runtime) {
+  auto tpl = Nan::New<FunctionTemplate>(
+      *static_cast<Persistent<FunctionTemplate>*>(
+      runtime->GetDataPointer(ENDPOINT_PARAMETERS_DATA_TEMPLATE)));
+  return tpl->HasInstance(value);
+}
+
+NAN_METHOD(EndpointParameters::New) {
+  if (!info.IsConstructCall()) {
+    Nan::ThrowError("Use the `new` keyword to create a new instance");
+    return;
+  }
+
+  if (info.Length() < 7) {
+    Nan::ThrowTypeError("Missing one or more arguments");
+    return;
+  }
+
+  auto runtime = GetRuntimeFromConstructorArgs(info);
+
+  auto address_value = info[0];
+  auto port_value = info[1];
+  auto certificate_value = info[2];
+  auto origin_value = info[3];
+  auto auth_token_value = info[4];
+  auto auth_callback_value = info[5];
+  auto asset_root_value = info[6];
+
+  gchar* address = NULL;
+  guint16 port = 0;
+  GTlsCertificate* certificate = NULL;
+  gchar* origin = NULL;
+  FridaAuthenticationService* auth_service = NULL;
+  GFile* asset_root = NULL;
+  bool valid = true;
+
+  if (!address_value->IsNull()) {
+    if (address_value->IsString()) {
+      Nan::Utf8String str(address_value);
+      address = g_strdup(*str);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'address' must be a string");
+      valid = false;
+    }
+  }
+
+  if (valid && !port_value->IsNull()) {
+    auto val = Nan::To<int32_t>(port_value).FromMaybe(-1);
+    if (val >= 0 && val <= 65535) {
+      port = val;
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'port' must be a valid port number");
+      valid = false;
+    }
+  }
+
+  if (valid && !certificate_value->IsNull()) {
+    valid = Runtime::ValueToCertificate(certificate_value, &certificate);
+  }
+
+  if (valid && !origin_value->IsNull()) {
+    if (origin_value->IsString()) {
+      Nan::Utf8String str(origin_value);
+      origin = g_strdup(*str);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'origin' must be a string");
+      valid = false;
+    }
+  }
+
+  if (valid && !auth_token_value->IsNull()) {
+    if (auth_token_value->IsString()) {
+      Nan::Utf8String auth_token(auth_token_value);
+      auth_service = FRIDA_AUTHENTICATION_SERVICE(
+          frida_static_authentication_service_new(*auth_token));
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'authToken' must be a string");
+      valid = false;
+    }
+  } else if (valid && !auth_callback_value->IsNull()) {
+    if (auth_callback_value->IsFunction()) {
+      auto auth_callback = Local<Function>::Cast(auth_callback_value);
+      auth_service =
+          frida_node_authentication_service_new(auth_callback, runtime);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'authCallback' must be a function");
+      valid = false;
+    }
+  }
+
+  if (valid && !asset_root_value->IsNull()) {
+    if (asset_root_value->IsString()) {
+      Nan::Utf8String str(asset_root_value);
+      asset_root = g_file_new_for_path(*str);
+    } else {
+      Nan::ThrowTypeError("Bad argument, 'assetRoot' must be a string");
+      valid = false;
+    }
+  }
+
+  if (valid) {
+    auto handle = frida_endpoint_parameters_new(address, port, certificate,
+        origin, auth_service, asset_root);
+    auto wrapper = new EndpointParameters(handle, runtime);
+    g_object_unref(handle);
+    auto obj = info.This();
+    wrapper->Wrap(obj);
+
+    info.GetReturnValue().Set(obj);
+  }
+
+  g_clear_object(&asset_root);
+  g_clear_object(&auth_service);
+  g_free(origin);
+  g_clear_object(&certificate);
+  g_free(address);
+}
+
+}

package/src/endpoint_parameters.h

@@ -0,0 +1,28 @@
+#ifndef FRIDANODE_ENDPOINT_PARAMETERS_H
+#define FRIDANODE_ENDPOINT_PARAMETERS_H
+
+#include "glib_object.h"
+
+#include <frida-core.h>
+
+namespace frida {
+
+class EndpointParameters : public GLibObject {
+ public:
+  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
+
+  static FridaEndpointParameters* TryParse(v8::Local<v8::Value> value,
+      Runtime* runtime);
+  static bool HasInstance(v8::Local<v8::Value> value, Runtime* runtime);
+
+ private:
+  explicit EndpointParameters(FridaEndpointParameters* handle,
+      Runtime* runtime);
+  ~EndpointParameters();
+
+  static NAN_METHOD(New);
+};
+
+}
+
+#endif

package/src/glib_context.cc

@@ -0,0 +1,62 @@
+#include "glib_context.h"
+
+#define GLIB_CONTEXT_LOCK()   g_mutex_lock(&mutex_)
+#define GLIB_CONTEXT_UNLOCK() g_mutex_unlock(&mutex_)
+#define GLIB_CONTEXT_WAIT()   g_cond_wait(&cond_, &mutex_)
+#define GLIB_CONTEXT_SIGNAL() g_cond_signal(&cond_)
+
+namespace frida {
+
+GLibContext::GLibContext(GMainContext* main_context) : main_context_(main_context) {
+  g_mutex_init(&mutex_);
+  g_cond_init(&cond_);
+}
+
+GLibContext::~GLibContext() {
+  g_cond_clear(&cond_);
+  g_mutex_clear(&mutex_);
+}
+
+void GLibContext::Schedule(std::function<void ()> f) {
+  auto source = g_idle_source_new();
+  g_source_set_callback(source, InvokeCallback, new std::function<void ()>(f),
+      DestroyCallback);
+  g_source_attach(source, main_context_);
+  g_source_unref(source);
+}
+
+void GLibContext::Perform(std::function<void ()> f) {
+  volatile bool finished = false;
+
+  auto work = new std::function<void ()>([this, f, &finished]() {
+    f();
+
+    GLIB_CONTEXT_LOCK();
+    finished = true;
+    GLIB_CONTEXT_SIGNAL();
+    GLIB_CONTEXT_UNLOCK();
+  });
+
+  auto source = g_idle_source_new();
+  g_source_set_callback(source, InvokeCallback, work, DestroyCallback);
+  g_source_attach(source, main_context_);
+  g_source_unref(source);
+
+  GLIB_CONTEXT_LOCK();
+  while (!finished)
+    GLIB_CONTEXT_WAIT();
+  GLIB_CONTEXT_UNLOCK();
+}
+
+gboolean GLibContext::InvokeCallback(gpointer data) {
+  auto f = static_cast<std::function<void ()>*>(data);
+  (*f)();
+  return FALSE;
+}
+
+void GLibContext::DestroyCallback(gpointer data) {
+  auto f = static_cast<std::function<void ()>*>(data);
+  delete f;
+}
+
+}