frida 16.2.1 → 16.2.3

package/src/authentication.cc

@@ -0,0 +1,174 @@
+#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

@@ -0,0 +1,24 @@
+#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

@@ -0,0 +1,167 @@
+#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

@@ -0,0 +1,33 @@
+#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

package/src/cancellable.cc

@@ -0,0 +1,117 @@
+#include "cancellable.h"
+
+#include "signals.h"
+
+#define CANCELLABLE_DATA_TEMPLATE "cancellable:tpl"
+
+using v8::DEFAULT;
+using v8::External;
+using v8::Function;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Persistent;
+using v8::ReadOnly;
+using v8::Value;
+
+namespace frida {
+
+Cancellable::Cancellable(GCancellable* handle, Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+}
+
+Cancellable::~Cancellable() {
+  g_object_unref(handle_);
+}
+
+void Cancellable::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("Cancellable").ToLocalChecked();
+  auto tpl = CreateTemplate(name, Cancellable::New, runtime);
+
+  auto instance_tpl = tpl->InstanceTemplate();
+  auto data = Local<Value>();
+  Nan::SetAccessor(instance_tpl, Nan::New("isCancelled").ToLocalChecked(),
+      IsCancelled, 0, data, DEFAULT, ReadOnly);
+
+  Nan::SetPrototypeMethod(tpl, "throwIfCancelled", ThrowIfCancelled);
+  Nan::SetPrototypeMethod(tpl, "cancel", Cancel);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(CANCELLABLE_DATA_TEMPLATE,
+      new Persistent<FunctionTemplate>(isolate, tpl));
+}
+
+GCancellable* Cancellable::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<Cancellable>(impl.As<Object>())
+      ->GetHandle<GCancellable>();
+}
+
+bool Cancellable::HasInstance(Local<Value> value, Runtime* runtime) {
+  auto tpl = Nan::New<FunctionTemplate>(
+      *static_cast<Persistent<FunctionTemplate>*>(
+      runtime->GetDataPointer(CANCELLABLE_DATA_TEMPLATE)));
+  return tpl->HasInstance(value);
+}
+
+NAN_METHOD(Cancellable::New) {
+  if (!info.IsConstructCall()) {
+    Nan::ThrowError("Use the `new` keyword to create a new instance");
+    return;
+  }
+
+  auto runtime = GetRuntimeFromConstructorArgs(info);
+
+  auto handle = g_cancellable_new();
+
+  auto wrapper = new Cancellable(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+
+  auto signals_obj = Signals::New(handle, runtime);
+  Nan::Set(obj, Nan::New("signals").ToLocalChecked(), signals_obj);
+
+  g_object_unref(handle);
+
+  info.GetReturnValue().Set(obj);
+}
+
+NAN_PROPERTY_GETTER(Cancellable::IsCancelled) {
+  auto handle = ObjectWrap::Unwrap<Cancellable>(
+      info.Holder())->GetHandle<GCancellable>();
+
+  info.GetReturnValue().Set(
+      static_cast<bool>(g_cancellable_is_cancelled(handle)));
+}
+
+NAN_METHOD(Cancellable::ThrowIfCancelled) {
+  auto handle = ObjectWrap::Unwrap<Cancellable>(
+      info.Holder())->GetHandle<GCancellable>();
+
+  GError* error = NULL;
+  if (g_cancellable_set_error_if_cancelled(handle, &error)) {
+    Nan::ThrowError(Nan::Error(error->message));
+    g_error_free(error);
+  }
+}
+
+NAN_METHOD(Cancellable::Cancel) {
+  auto handle = ObjectWrap::Unwrap<Cancellable>(
+      info.Holder())->GetHandle<GCancellable>();
+
+  g_cancellable_cancel(handle);
+}
+
+}

package/src/cancellable.h

@@ -0,0 +1,31 @@
+#ifndef FRIDANODE_CANCELLABLE_H
+#define FRIDANODE_CANCELLABLE_H
+
+#include "glib_object.h"
+
+#include <gio/gio.h>
+
+namespace frida {
+
+class Cancellable : public GLibObject {
+ public:
+  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
+
+  static GCancellable* TryParse(v8::Local<v8::Value> value, Runtime* runtime);
+  static bool HasInstance(v8::Local<v8::Value> value, Runtime* runtime);
+
+ private:
+  explicit Cancellable(GCancellable* handle, Runtime* runtime);
+  ~Cancellable();
+
+  static NAN_METHOD(New);
+
+  static NAN_PROPERTY_GETTER(IsCancelled);
+
+  static NAN_METHOD(ThrowIfCancelled);
+  static NAN_METHOD(Cancel);
+};
+
+}
+
+#endif

package/src/child.cc

@@ -0,0 +1,150 @@
+#include "child.h"
+
+#define CHILD_DATA_CONSTRUCTOR "child:ctor"
+
+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::Value;
+
+namespace frida {
+
+Child::Child(FridaChild* handle, Runtime* runtime)
+    : GLibObject(handle, runtime) {
+  g_object_ref(handle_);
+}
+
+Child::~Child() {
+  g_object_unref(handle_);
+}
+
+void Child::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("Child").ToLocalChecked();
+  auto tpl = CreateTemplate(name, Child::New, runtime);
+
+  auto instance_tpl = tpl->InstanceTemplate();
+  auto data = Local<Value>();
+  Nan::SetAccessor(instance_tpl, Nan::New("envp").ToLocalChecked(),
+      GetEnvp, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("argv").ToLocalChecked(),
+      GetArgv, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("path").ToLocalChecked(),
+      GetPath, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("identifier").ToLocalChecked(),
+      GetIdentifier, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("origin").ToLocalChecked(),
+      GetOrigin, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("parentPid").ToLocalChecked(),
+      GetParentPid, 0, data, DEFAULT, ReadOnly);
+  Nan::SetAccessor(instance_tpl, Nan::New("pid").ToLocalChecked(),
+      GetPid, 0, data, DEFAULT, ReadOnly);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(CHILD_DATA_CONSTRUCTOR,
+      new Persistent<Function>(isolate, ctor));
+}
+
+Local<Object> Child::New(gpointer handle, Runtime* runtime) {
+  auto ctor = Nan::New<Function>(
+      *static_cast<Persistent<Function>*>(
+      runtime->GetDataPointer(CHILD_DATA_CONSTRUCTOR)));
+  const int argc = 1;
+  Local<Value> argv[argc] = { Nan::New<External>(handle) };
+  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
+}
+
+NAN_METHOD(Child::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<FridaChild*>(
+      Local<External>::Cast(info[0])->Value());
+  auto wrapper = new Child(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+
+  info.GetReturnValue().Set(obj);
+}
+
+NAN_PROPERTY_GETTER(Child::GetPid) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  info.GetReturnValue().Set(Nan::New<Integer>(frida_child_get_pid(handle)));
+}
+
+NAN_PROPERTY_GETTER(Child::GetParentPid) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  info.GetReturnValue().Set(
+      Nan::New<Integer>(frida_child_get_parent_pid(handle)));
+}
+
+NAN_PROPERTY_GETTER(Child::GetOrigin) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  info.GetReturnValue().Set(Runtime::ValueFromEnum(
+      frida_child_get_origin(handle), FRIDA_TYPE_CHILD_ORIGIN));
+}
+
+NAN_PROPERTY_GETTER(Child::GetIdentifier) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  auto identifier = frida_child_get_identifier(handle);
+  if (identifier != NULL)
+    info.GetReturnValue().Set(Nan::New(identifier).ToLocalChecked());
+  else
+    info.GetReturnValue().Set(Nan::Null());
+}
+
+NAN_PROPERTY_GETTER(Child::GetPath) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  auto path = frida_child_get_path(handle);
+  if (path != NULL)
+    info.GetReturnValue().Set(Nan::New(path).ToLocalChecked());
+  else
+    info.GetReturnValue().Set(Nan::Null());
+}
+
+NAN_PROPERTY_GETTER(Child::GetArgv) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  gint length;
+  auto argv = frida_child_get_argv(handle, &length);
+  info.GetReturnValue().Set(Runtime::ValueFromStrv(argv, length));
+}
+
+NAN_PROPERTY_GETTER(Child::GetEnvp) {
+  auto handle = ObjectWrap::Unwrap<Child>(
+      info.Holder())->GetHandle<FridaChild>();
+
+  gint length;
+  auto envp = frida_child_get_envp(handle, &length);
+  info.GetReturnValue().Set(Runtime::ValueFromEnvp(envp, length));
+}
+
+}