frida 16.2.1 → 16.2.2

package/src/glib_context.h

@@ -0,0 +1,29 @@
+#ifndef FRIDANODE_GLIB_CONTEXT_H
+#define FRIDANODE_GLIB_CONTEXT_H
+
+#include <frida-core.h>
+
+#include <functional>
+
+namespace frida {
+
+class GLibContext {
+public:
+  GLibContext(GMainContext* main_context);
+  ~GLibContext();
+
+  void Schedule(std::function<void ()> f);
+  void Perform(std::function<void ()> f);
+
+private:
+  static gboolean InvokeCallback(gpointer data);
+  static void DestroyCallback(gpointer data);
+
+  GMainContext* main_context_;
+  GMutex mutex_;
+  GCond cond_;
+};
+
+}
+
+#endif

package/src/glib_object.cc

@@ -0,0 +1,25 @@
+#include "glib_object.h"
+
+using v8::External;
+using v8::FunctionTemplate;
+using v8::Local;
+using v8::String;
+using v8::Value;
+
+namespace frida {
+
+Local<FunctionTemplate> GLibObject::CreateTemplate(Local<String> name,
+    Nan::FunctionCallback callback, Runtime* runtime) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(callback,
+      Nan::New<External>(runtime));
+  tpl->SetClassName(name);
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+  return tpl;
+}
+
+Runtime* GLibObject::GetRuntimeFromConstructorArgs(
+    const Nan::FunctionCallbackInfo<Value>& args) {
+  return static_cast<Runtime*>(args.Data().As<External>()->Value ());
+}
+
+}

package/src/glib_object.h

@@ -0,0 +1,37 @@
+#ifndef FRIDANODE_GLIB_OBJECT_H
+#define FRIDANODE_GLIB_OBJECT_H
+
+#include "runtime.h"
+
+#include <glib.h>
+#include <nan.h>
+#include <node_object_wrap.h>
+
+namespace frida {
+
+class GLibObject : public node::ObjectWrap {
+ protected:
+  GLibObject(gpointer handle, Runtime* runtime)
+    : handle_(handle),
+      runtime_(runtime) {
+  }
+
+  static v8::Local<v8::FunctionTemplate> CreateTemplate(v8::Local<v8::String> name,
+      Nan::FunctionCallback callback, Runtime* runtime);
+  static Runtime* GetRuntimeFromConstructorArgs(
+      const Nan::FunctionCallbackInfo<v8::Value>& info);
+
+ public:
+  template<typename T>
+  T* GetHandle() const { return static_cast<T*>(handle_); }
+
+  Runtime* GetRuntime() const { return runtime_; }
+
+ protected:
+  gpointer handle_;
+  Runtime* runtime_;
+};
+
+}
+
+#endif

package/src/iostream.cc

@@ -0,0 +1,247 @@
+#include "iostream.h"
+
+#include "operation.h"
+#include "signals.h"
+
+#define IOSTREAM_DATA_CONSTRUCTOR "iostream:ctor"
+
+using v8::CopyablePersistentTraits;
+using v8::DEFAULT;
+using v8::External;
+using v8::Function;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::Object;
+using v8::Persistent;
+using v8::ReadOnly;
+using v8::Value;
+
+namespace frida {
+
+static void UnrefGBytes(char* data, void* hint);
+
+IOStream::IOStream(GIOStream* handle, Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+}
+
+IOStream::~IOStream() {
+  g_object_unref(handle_);
+}
+
+void IOStream::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("IOStream").ToLocalChecked();
+  auto tpl = CreateTemplate(name, New, runtime);
+
+  auto instance_tpl = tpl->InstanceTemplate();
+  auto data = Local<Value>();
+  Nan::SetAccessor(instance_tpl, Nan::New("isClosed").ToLocalChecked(),
+      IsClosed, 0, data, DEFAULT, ReadOnly);
+
+  Nan::SetPrototypeMethod(tpl, "close", Close);
+  Nan::SetPrototypeMethod(tpl, "read", Read);
+  Nan::SetPrototypeMethod(tpl, "write", Write);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(IOSTREAM_DATA_CONSTRUCTOR,
+      new Persistent<Function>(isolate, ctor));
+}
+
+Local<Object> IOStream::New(gpointer handle, Runtime* runtime) {
+  auto ctor = Nan::New<Function>(
+      *static_cast<Persistent<Function>*>(
+      runtime->GetDataPointer(IOSTREAM_DATA_CONSTRUCTOR)));
+  const int argc = 1;
+  Local<Value> argv[argc] = { Nan::New<External>(handle) };
+  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
+}
+
+NAN_METHOD(IOStream::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<GIOStream*>(
+      Local<External>::Cast(info[0])->Value());
+  auto wrapper = new IOStream(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+  Nan::Set(obj, Nan::New("signals").ToLocalChecked(),
+      Signals::New(handle, runtime));
+
+  info.GetReturnValue().Set(obj);
+}
+
+NAN_PROPERTY_GETTER(IOStream::IsClosed) {
+  auto handle = ObjectWrap::Unwrap<IOStream>(
+      info.Holder())->GetHandle<GIOStream>();
+
+  info.GetReturnValue().Set(
+      static_cast<bool>(g_io_stream_is_closed(handle)));
+}
+
+namespace {
+
+class CloseOperation : public Operation<GIOStream> {
+ protected:
+  void Begin() {
+    g_io_stream_close_async(handle_, G_PRIORITY_DEFAULT, cancellable_,
+        OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    g_io_stream_close_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+};
+
+}
+
+NAN_METHOD(IOStream::Close) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<IOStream>(info.Holder());
+
+  auto operation = new CloseOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class ReadOperation : public Operation<GIOStream> {
+ public:
+  ReadOperation(gsize count)
+    : stream_(NULL),
+      count_(count),
+      bytes_(NULL) {
+  }
+
+ protected:
+  void Begin() {
+    stream_ = g_io_stream_get_input_stream(handle_);
+
+    g_input_stream_read_bytes_async(stream_, count_, G_PRIORITY_DEFAULT,
+        cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    bytes_ = g_input_stream_read_bytes_finish(stream_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    gsize size;
+    auto data = g_bytes_get_data(bytes_, &size);
+    return Nan::NewBuffer(static_cast<char*>(const_cast<void*>(data)), size,
+        UnrefGBytes, bytes_).ToLocalChecked();
+  }
+
+ private:
+  GInputStream* stream_;
+  gsize count_;
+  GBytes* bytes_;
+};
+
+}
+
+NAN_METHOD(IOStream::Read) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<IOStream>(info.Holder());
+
+  if (info.Length() < 1 || !info[0]->IsNumber()) {
+    Nan::ThrowTypeError("Bad argument, expected amount to read");
+    return;
+  }
+  auto count = Nan::To<int32_t>(info[0]).FromMaybe(-1);
+  if (count <= 0) {
+    Nan::ThrowTypeError("Bad argument, expected amount to read");
+    return;
+  }
+
+  auto operation = new ReadOperation(count);
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class WriteOperation : public Operation<GIOStream> {
+ public:
+  WriteOperation(Isolate* isolate, Local<Value> buffer)
+    : stream_(NULL),
+      buffer_(isolate, buffer),
+      data_(node::Buffer::Data(buffer)),
+      count_(node::Buffer::Length(buffer)) {
+  }
+
+  ~WriteOperation() {
+  }
+
+ protected:
+  void Begin() {
+    stream_ = g_io_stream_get_output_stream(handle_);
+
+    g_output_stream_write_all_async(stream_, data_, count_, G_PRIORITY_DEFAULT,
+        cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    g_output_stream_write_all_finish(stream_, result, NULL, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+
+ private:
+  GOutputStream* stream_;
+  Persistent<Value, CopyablePersistentTraits<Value>> buffer_;
+  const void* data_;
+  gsize count_;
+};
+
+}
+
+NAN_METHOD(IOStream::Write) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<IOStream>(info.Holder());
+
+  auto num_args = info.Length();
+  if (num_args < 1) {
+    Nan::ThrowTypeError("Expected a buffer");
+    return;
+  }
+
+  auto buffer = info[0];
+  if (!node::Buffer::HasInstance(buffer)) {
+    Nan::ThrowTypeError("Expected a buffer");
+    return;
+  }
+
+  auto operation = new WriteOperation(isolate, buffer);
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+static void UnrefGBytes(char* data, void* hint) {
+  g_bytes_unref(static_cast<GBytes*>(hint));
+}
+
+}

package/src/iostream.h

@@ -0,0 +1,30 @@
+#ifndef FRIDANODE_IOSTREAM_H
+#define FRIDANODE_IOSTREAM_H
+
+#include "glib_object.h"
+
+#include <gio/gio.h>
+
+namespace frida {
+
+class IOStream : 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 IOStream(GIOStream* handle, Runtime* runtime);
+  ~IOStream();
+
+  static NAN_METHOD(New);
+
+  static NAN_PROPERTY_GETTER(IsClosed);
+
+  static NAN_METHOD(Close);
+  static NAN_METHOD(Read);
+  static NAN_METHOD(Write);
+};
+
+}
+
+#endif

package/src/meson.build

@@ -0,0 +1,26 @@
+frida_binding_sources = files(
+  'addon.cc',
+  'device_manager.cc',
+  'device.cc',
+  'application.cc',
+  'process.cc',
+  'spawn.cc',
+  'child.cc',
+  'crash.cc',
+  'bus.cc',
+  'session.cc',
+  'script.cc',
+  'relay.cc',
+  'portal_membership.cc',
+  'portal_service.cc',
+  'endpoint_parameters.cc',
+  'authentication.cc',
+  'iostream.cc',
+  'cancellable.cc',
+  'signals.cc',
+  'glib_object.cc',
+  'runtime.cc',
+  'uv_context.cc',
+  'glib_context.cc',
+  'win_delay_load_hook.cc',
+)

package/src/operation.h

@@ -0,0 +1,94 @@
+#ifndef FRIDANODE_OPERATION_H
+#define FRIDANODE_OPERATION_H
+
+#include "cancellable.h"
+#include "runtime.h"
+
+namespace frida {
+
+template<class T>
+class Operation {
+ public:
+  void Schedule(v8::Isolate* isolate, GLibObject* parent,
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    wrapper_ = parent;
+    parent_.Reset(isolate, parent->handle(isolate));
+    handle_ = parent->GetHandle<T>();
+    resolver_.Reset(isolate,
+        v8::Promise::Resolver::New(isolate->GetCurrentContext())
+            .ToLocalChecked());
+    runtime_ = parent->GetRuntime();
+
+    auto num_args = info.Length();
+    if (num_args >= 1) {
+      cancellable_ = Cancellable::TryParse(info[num_args - 1], runtime_);
+    }
+
+    runtime_->GetUVContext()->IncreaseUsage();
+    runtime_->GetGLibContext()->Schedule([=]() { Begin(); });
+  }
+
+  v8::Local<v8::Promise> GetPromise(v8::Isolate* isolate) {
+    return v8::Local<v8::Promise::Resolver>::New(isolate, resolver_)->GetPromise();
+  }
+
+ protected:
+  Operation()
+    : wrapper_(NULL),
+      handle_(NULL),
+      cancellable_(NULL),
+      runtime_(NULL),
+      error_(NULL) {
+  }
+
+  virtual ~Operation() {
+    if (error_ != NULL) {
+      g_error_free(error_);
+    }
+    resolver_.Reset();
+    parent_.Reset();
+  }
+
+  virtual void Begin() = 0;
+  virtual void End(GAsyncResult* result, GError** error) = 0;
+  virtual v8::Local<v8::Value> Result(v8::Isolate* isolate) = 0;
+
+  template<typename W>
+  W* GetWrapper() const { return static_cast<W*>(wrapper_); }
+
+  static void OnReady(GObject* source_object, GAsyncResult* result, gpointer user_data) {
+    static_cast<Operation<T>*>(user_data)->PerformEnd(result);
+  }
+
+  void* wrapper_;
+  v8::Persistent<v8::Value> parent_;
+  T* handle_;
+  GCancellable* cancellable_;
+  v8::Persistent<v8::Promise::Resolver> resolver_;
+  Runtime* runtime_;
+
+ private:
+  void PerformEnd(GAsyncResult* result) {
+    End(result, &error_);
+    runtime_->GetUVContext()->Schedule([=]() { Deliver(); });
+  }
+
+  void Deliver() {
+    auto isolate = v8::Isolate::GetCurrent();
+    auto context = isolate->GetCurrentContext();
+    auto resolver = v8::Local<v8::Promise::Resolver>::New(isolate, resolver_);
+    if (error_ == NULL) {
+      resolver->Resolve(context, Result(isolate)).FromJust();
+    } else {
+      resolver->Reject(context, Nan::Error(error_->message)).FromJust();
+    }
+    runtime_->GetUVContext()->DecreaseUsage();
+    delete this;
+  }
+
+  GError* error_;
+};
+
+}
+
+#endif

package/src/portal_membership.cc

@@ -0,0 +1,100 @@
+#include "portal_membership.h"
+
+#include "operation.h"
+
+#define PORTAL_MEMBERSHIP_DATA_CONSTRUCTOR "portal_membership:ctor"
+
+using v8::External;
+using v8::Function;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Persistent;
+using v8::Value;
+
+namespace frida {
+
+PortalMembership::PortalMembership(FridaPortalMembership* handle, Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+}
+
+PortalMembership::~PortalMembership() {
+  frida_unref(handle_);
+}
+
+void PortalMembership::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("PortalMembership").ToLocalChecked();
+  auto tpl = CreateTemplate(name, New, runtime);
+
+  Nan::SetPrototypeMethod(tpl, "terminate", Terminate);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(PORTAL_MEMBERSHIP_DATA_CONSTRUCTOR,
+      new Persistent<Function>(isolate, ctor));
+}
+
+Local<Object> PortalMembership::New(gpointer handle, Runtime* runtime) {
+  auto ctor = Nan::New<Function>(
+      *static_cast<Persistent<Function>*>(
+      runtime->GetDataPointer(PORTAL_MEMBERSHIP_DATA_CONSTRUCTOR)));
+  const int argc = 1;
+  Local<Value> argv[argc] = { Nan::New<External>(handle) };
+  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
+}
+
+NAN_METHOD(PortalMembership::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<FridaPortalMembership*>(
+      Local<External>::Cast(info[0])->Value());
+  auto wrapper = new PortalMembership(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+
+  info.GetReturnValue().Set(obj);
+}
+
+namespace {
+
+class TerminateOperation : public Operation<FridaPortalMembership> {
+ protected:
+  void Begin() {
+    frida_portal_membership_terminate(handle_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    frida_portal_membership_terminate_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+};
+
+}
+
+NAN_METHOD(PortalMembership::Terminate) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<PortalMembership>(info.Holder());
+
+  auto operation = new TerminateOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+}

package/src/portal_membership.h

@@ -0,0 +1,26 @@
+#ifndef FRIDANODE_PORTAL_MEMBERSHIP_H
+#define FRIDANODE_PORTAL_MEMBERSHIP_H
+
+#include "glib_object.h"
+
+#include <frida-core.h>
+
+namespace frida {
+
+class PortalMembership : 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 PortalMembership(FridaPortalMembership* handle, Runtime* runtime);
+  ~PortalMembership();
+
+  static NAN_METHOD(New);
+
+  static NAN_METHOD(Terminate);
+};
+
+}
+
+#endif