frida 16.2.1 → 16.2.3

package/scripts/fetch-abi-bits.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from io import BytesIO, IOBase
+import json
+import os
+from pathlib import Path
+import shutil
+import struct
+import subprocess
+import sys
+import tarfile
+import tempfile
+from typing import Union
+import urllib.request
+
+
+IMAGE_ARCHIVE_START = b"!<arch>\n"
+IMAGE_FILE_MACHINE_UNKNOWN = 0
+IMPORT_OBJECT_HDR_SIG2 = 0xffff
+
+
+def main(argv: list[str]):
+    runtime, target, gyp_os, gyp_arch = argv[1:5]
+    flavor = "|".join(argv[1:5])
+    node, npm, outdir = [Path(p) for p in argv[5:8]]
+
+    abidir = outdir / "abi-bits"
+    metadata_file = abidir / "abi-bits.json"
+
+    metadata = None
+    if metadata_file.exists():
+        metadata = json.loads(metadata_file.read_text(encoding="utf-8"))
+        if metadata["flavor"] != flavor:
+            metadata = None
+
+    if metadata is None:
+        if abidir.exists():
+            shutil.rmtree(abidir)
+
+        (node_incdirs, node_gypdir, node_libs) = load_dev_assets(runtime, target, gyp_os, gyp_arch,
+                                                                 node, outdir, abidir)
+
+        subprocess.run([npm, "init", "-y"],
+                       capture_output=True,
+                       cwd=abidir,
+                       check=True)
+        subprocess.run([npm, "install", "node-abi", "node-gyp"],
+                       capture_output=True,
+                       cwd=abidir,
+                       check=True)
+
+        abi = subprocess.run([node, "-e", f"console.log(require('node-abi').getAbi('{target}', '{runtime}'))"],
+                             capture_output=True,
+                             encoding="utf-8",
+                             cwd=abidir,
+                             check=True).stdout.strip()
+
+        node_defines = load_node_defines(gyp_os, gyp_arch, node_gypdir,
+                                         abidir / "node_modules" / "node-gyp" / "gyp" / "pylib")
+
+        node_incdirs_rel = [d.relative_to(outdir) if d.is_relative_to(outdir) else d for d in node_incdirs]
+        node_libs_rel    = [l.relative_to(outdir) if l.is_relative_to(outdir) else l for l in node_libs]
+
+        metadata = {
+            "flavor": flavor,
+            "abi": abi,
+            "node_defines": node_defines,
+            "node_incdirs": [str(d) for d in node_incdirs_rel],
+            "node_libs": [str(l) for l in node_libs_rel],
+        }
+        metadata_file.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+
+    print_metadata(metadata)
+
+
+def print_metadata(metadata: dict[str, Union[str, list[str]]]):
+    print("abi:", metadata["abi"])
+    print("node_defines:", " ".join(metadata["node_defines"]))
+    for d in metadata["node_incdirs"]:
+        print("node_incdir:", d)
+    for l in metadata["node_libs"]:
+        print("node_lib:", l)
+
+
+def load_dev_assets(runtime: str,
+                    target: str,
+                    gyp_os: str,
+                    gyp_arch: str,
+                    node: Path,
+                    outdir: Path,
+                    abidir: Path) -> tuple[list[Path], Path, list[Path]]:
+    if runtime == "node" and target == "" and gyp_os != "win":
+        node_incroot = node.parent.parent / "include"
+        node_incdir = node_incroot / "node"
+        if node_incdir.exists():
+            abidir.mkdir()
+            node_gypdir = node_incdir
+            node_libs = []
+            return ([node_incdir, node_incroot], node_gypdir, node_libs)
+
+    if target == "":
+        version = subprocess.run([node, "--version"], capture_output=True, encoding="utf-8").stdout.strip()
+    else:
+        version = f"v{target}"
+
+    node_arch = "x86" if gyp_arch == "ia32" else gyp_arch
+
+    if runtime == "node":
+        base_url = f"https://nodejs.org/dist/{version}"
+        headers_stem = f"node-{version}-headers"
+        libs_subpath = f"/win-{node_arch}"
+        compression_formats = ["xz", "gz"]
+    elif runtime == "electron":
+        base_url = f"https://electronjs.org/headers/{version}"
+        headers_stem = f"node-{version}-headers"
+        libs_subpath = f"/win-{node_arch}"
+        compression_formats = ["gz"]
+    else:
+        assert runtime == "node-webkit"
+        base_url = f"https://node-webkit.s3.amazonaws.com/{version}"
+        headers_stem = f"nw-headers-{version}"
+        libs_subpath = "" if node_arch == "x86" else f"/{node_arch}"
+        compression_formats = ["gz"]
+
+    download_error = None
+    for compression in compression_formats:
+        try:
+            with urllib.request.urlopen(f"{base_url}/{headers_stem}.tar.{compression}") as response:
+                tar_blob = response.read()
+        except urllib.error.HTTPError as e:
+            download_error = e
+            if e.code == 404:
+                continue
+            raise e
+
+        with tarfile.open(fileobj=BytesIO(tar_blob), mode=f"r:{compression}") as tar:
+            extracted_rootdir_name = tar.getnames()[0].split("/", maxsplit=1)[0]
+            tar.extractall(outdir)
+
+        download_error = None
+        break
+    if download_error is not None:
+        print(download_error, file=sys.stderr)
+        sys.exit(1)
+
+    extracted_rootdir = outdir / extracted_rootdir_name
+
+    node_libnames = []
+    if gyp_os == "win":
+        libdir = extracted_rootdir / "lib"
+        libdir.mkdir()
+
+        node_lib = libdir / "node.lib"
+        with urllib.request.urlopen(f"{base_url}{libs_subpath}/node.lib") as response:
+            vanilla_lib = response.read()
+            redacted_lib = BytesIO(vanilla_lib)
+            redact_node_lib_symbols(redacted_lib, gyp_arch)
+            node_lib.write_bytes(redacted_lib.getvalue())
+        node_libnames.append(node_lib.name)
+
+        if runtime == "node-webkit":
+            nw_lib = libdir / "nw.lib"
+            with urllib.request.urlopen(f"{base_url}{libs_subpath}/nw.lib") as response:
+                nw_lib.write_bytes(response.read())
+            node_libnames.append(nw_lib.name)
+
+    os.rename(extracted_rootdir, abidir)
+
+    if runtime == "node-webkit":
+        node_incdirs = [
+            abidir / "src",
+            abidir / "deps" / "uv" / "include",
+            abidir / "deps" / "v8" / "include",
+        ]
+        node_gypdir = abidir
+    else:
+        incdir = abidir / "include" / "node"
+        node_incdirs = [incdir]
+        node_gypdir = incdir
+
+    node_libs = [abidir / "lib" / name for name in node_libnames]
+
+    return (node_incdirs, node_gypdir, node_libs)
+
+
+def load_node_defines(gyp_os: str, gyp_arch: str, node_gypdir: Path, gyp_pylib: Path) -> list[str]:
+    sys.path.insert(0, str(gyp_pylib))
+    import gyp
+
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as binding_gyp:
+        binding_gyp.write("""{
+  "targets": [
+    {
+      "target_name": "frida_binding",
+      "type": "loadable_module",
+      "sources": [
+        "src/addon.cc",
+      ],
+    },
+  ],
+}
+""")
+        binding_gyp.close()
+        try:
+            [generator, flat_list, targets, data] = \
+                    gyp.Load([binding_gyp.name],
+                             "compile_commands_json",
+                             default_variables={
+                                 "OS": gyp_os,
+                                 "target_arch": gyp_arch,
+                                 "MSVS_VERSION": "auto",
+                                 "node_engine": "v8",
+                             },
+                             includes=[
+                                 node_gypdir / "common.gypi",
+                                 node_gypdir / "config.gypi",
+                             ],
+                             params={
+                                 "options": GypOptions(),
+                                 "parallel": False,
+                                 "root_targets": None,
+                             })
+        finally:
+            os.unlink(binding_gyp.name)
+
+    target = targets[flat_list[0]]
+    config = target["configurations"][target["default_configuration"]]
+    return [adapt_node_define(d) for d in config["defines"] if want_node_define(d)]
+
+
+def want_node_define(d: str) -> bool:
+    if d.startswith("V8_") and "DEPRECATION_WARNINGS" in d:
+        return False
+    return True
+
+
+def adapt_node_define(d: str) -> str:
+    if d.startswith("BUILDING_"):
+        return "USING_" + d[9:]
+    if d == "_HAS_EXCEPTIONS=1":
+        return "_HAS_EXCEPTIONS=0"
+    return d
+
+
+class GypOptions:
+    generator_output = os.getcwd()
+
+
+def redact_node_lib_symbols(lib: Path, gyp_arch: str):
+    magic = lib.read(8)
+    assert magic == IMAGE_ARCHIVE_START
+
+    file_header = read_image_archive_member_header(lib)
+
+    num_symbols, = struct.unpack(">I", lib.read(4))
+
+    symbol_offsets = []
+    for i in range(num_symbols):
+        sym_offset, = struct.unpack(">I", lib.read(4))
+        symbol_offsets.append(sym_offset)
+    symbol_offsets = list(sorted(set(symbol_offsets)))
+
+    string_pool_start = lib.tell()
+    string_pool_end = symbol_offsets[0]
+
+    renamed_symbols = {}
+    node_prefixes = [function_name_to_cdecl_symbol(p, gyp_arch).encode("ascii") for p in {"napi_", "node", "uv_"}]
+    for offset in symbol_offsets:
+        lib.seek(offset)
+
+        member_header = read_image_archive_member_header(lib)
+        object_header = read_import_object_header(lib)
+
+        if object_header.sig1 == IMAGE_FILE_MACHINE_UNKNOWN and \
+                object_header.sig2 == IMPORT_OBJECT_HDR_SIG2:
+            import_name_offset = lib.tell()
+            strings = lib.read(object_header.size_of_data).split(b"\x00")
+            import_name = strings[0]
+            dll_name = strings[1]
+            is_node_symbol = import_name.startswith(b"?") or (
+                    next((p for p in node_prefixes if import_name.startswith(p)), None) is not None)
+            if not is_node_symbol:
+                new_prefix = b"X" if not import_name.startswith(B"X") else b"Y"
+                redacted_name = new_prefix + import_name[1:]
+                lib.seek(import_name_offset)
+                lib.write(redacted_name)
+                renamed_symbols[import_name] = redacted_name
+
+    lib.seek(string_pool_start)
+    string_pool = lib.read(string_pool_end - string_pool_start)
+    lib.seek(string_pool_start)
+    lib.write(update_string_pool(string_pool, renamed_symbols))
+
+
+def function_name_to_cdecl_symbol(name: str, gyp_arch: str) -> str:
+    if gyp_arch == "ia32":
+        return "_" + name
+    return name
+
+
+def read_image_archive_member_header(f: IOBase) -> ImageArchiveMemberHeader:
+    data = f.read(60)
+
+    raw_name = data[:16].decode("utf-8")
+    name = raw_name[:raw_name.index("/")]
+
+    size = int(data[48:58].decode("utf-8"))
+
+    return ImageArchiveMemberHeader(name, size, data)
+
+
+def read_import_object_header(f: IOBase) -> ImportObjectHeader:
+    data = f.read(20)
+
+    (sig1, sig2, version, machine, time_date_stamp, size_of_data) \
+            = struct.unpack("<HHHHII", data[:16])
+
+    return ImportObjectHeader(sig1, sig2, version, machine, size_of_data, data)
+
+
+def update_string_pool(pool: bytes, renames: dict[str, str]) -> bytes:
+    return b"\x00".join(map(lambda s: renames.get(s, s), pool.split(b"\x00")))
+
+
+@dataclass
+class ImageArchiveMemberHeader:
+    name: str
+    size: int
+    raw_header: bytes
+
+
+@dataclass
+class ImportObjectHeader:
+    sig1: int
+    sig2: int
+    version: int
+    machine: int
+    size_of_data: int
+    raw_header: bytes
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/scripts/install.js

@@ -0,0 +1,23 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const pkgRoot = path.dirname(path.dirname(__filename));
+const binding = path.join(pkgRoot, 'build', 'frida_binding.node');
+if (fs.existsSync(binding)) {
+  process.exit(0);
+}
+
+try {
+  execSync('prebuild-install', { stdio: 'inherit' });
+  process.exit(0);
+} catch (e) {
+}
+
+try {
+  execSync('make', { stdio: 'inherit' });
+  process.exit(0);
+} catch (e) {
+}
+
+process.exit(1);

package/scripts/package.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+import sys
+import tarfile
+
+
+def main(argv: list[str]):
+    binding = Path(argv[1])
+    outfile = Path(argv[2])
+
+    with tarfile.open(outfile, "w:gz") as tar:
+        tar.add(binding, arcname="build/frida_binding.node")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/src/addon.cc

@@ -0,0 +1,76 @@
+#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 "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);
+  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

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

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