frida 16.2.0 → 16.2.2

package/src/uv_context.cc

@@ -0,0 +1,118 @@
+#include "uv_context.h"
+
+#define UV_CONTEXT_LOCK()   g_mutex_lock(&mutex_)
+#define UV_CONTEXT_UNLOCK() g_mutex_unlock(&mutex_)
+#define UV_CONTEXT_WAIT()   g_cond_wait(&cond_, &mutex_)
+#define UV_CONTEXT_SIGNAL() g_cond_signal(&cond_)
+
+using v8::Context;
+using v8::External;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Value;
+using Nan::HandleScope;
+
+namespace frida {
+
+UVContext::UVContext(uv_loop_t* loop)
+    : usage_count_(0), async_(new uv_async_t), async_resource_("frida"),
+      pending_(NULL) {
+  async_->data = this;
+  uv_async_init(loop, async_, ProcessPendingWrapper);
+  uv_unref(reinterpret_cast<uv_handle_t*>(async_));
+
+  g_mutex_init(&mutex_);
+  g_cond_init(&cond_);
+
+  auto isolate = Isolate::GetCurrent();
+  auto context = isolate->GetCurrentContext();
+  auto module = Nan::New<Object>();
+  auto process_pending = Function::New(context, ProcessPendingWrapper,
+      External::New(isolate, this)).ToLocalChecked();
+  auto process_pending_name = Nan::New("processPending").ToLocalChecked();
+  process_pending->SetName(process_pending_name);
+  Nan::Set(module, process_pending_name, process_pending);
+  module_.Reset(isolate, module);
+  process_pending_.Reset(isolate, process_pending);
+}
+
+UVContext::~UVContext() {
+  process_pending_.Reset();
+  module_.Reset();
+  g_cond_clear(&cond_);
+  g_mutex_clear(&mutex_);
+  uv_close(reinterpret_cast<uv_handle_t*>(async_), DeleteAsyncHandle);
+}
+
+void UVContext::DeleteAsyncHandle(uv_handle_t* handle) {
+  delete reinterpret_cast<uv_async_t*>(handle);
+}
+
+void UVContext::IncreaseUsage() {
+  if (++usage_count_ == 1)
+    uv_ref(reinterpret_cast<uv_handle_t*>(async_));
+}
+
+void UVContext::DecreaseUsage() {
+  if (usage_count_-- == 1)
+    uv_unref(reinterpret_cast<uv_handle_t*>(async_));
+}
+
+void UVContext::Schedule(std::function<void ()> f) {
+  auto work = new std::function<void ()>(f);
+  UV_CONTEXT_LOCK();
+  pending_ = g_slist_append(pending_, work);
+  UV_CONTEXT_UNLOCK();
+  uv_async_send(async_);
+}
+
+void UVContext::Perform(std::function<void ()> f) {
+  volatile bool finished = false;
+
+  Schedule([this, f, &finished]() {
+    f();
+
+    UV_CONTEXT_LOCK();
+    finished = true;
+    UV_CONTEXT_SIGNAL();
+    UV_CONTEXT_UNLOCK();
+  });
+
+  UV_CONTEXT_LOCK();
+  while (!finished)
+    UV_CONTEXT_WAIT();
+  UV_CONTEXT_UNLOCK();
+}
+
+void UVContext::ProcessPending() {
+  UV_CONTEXT_LOCK();
+  while (pending_ != NULL) {
+    auto work = static_cast<std::function<void ()>*>(pending_->data);
+    pending_ = g_slist_delete_link(pending_, pending_);
+    UV_CONTEXT_UNLOCK();
+    (*work)();
+    delete work;
+    UV_CONTEXT_LOCK();
+  }
+  UV_CONTEXT_UNLOCK();
+}
+
+void UVContext::ProcessPendingWrapper(const FunctionCallbackInfo<Value>& info) {
+  UVContext* self = static_cast<UVContext*>(
+      info.Data().As<External>()->Value ());
+  self->ProcessPending();
+}
+
+void UVContext::ProcessPendingWrapper(uv_async_t* handle) {
+  HandleScope scope;
+
+  auto self = static_cast<UVContext*>(handle->data);
+  auto module = Nan::New<Object>(self->module_);
+  auto process_pending = Nan::New<Function>(self->process_pending_);
+  self->async_resource_.runInAsyncScope(module, process_pending, 0, NULL);
+}
+
+}

package/src/uv_context.h

@@ -0,0 +1,40 @@
+#ifndef FRIDANODE_UV_CONTEXT_H
+#define FRIDANODE_UV_CONTEXT_H
+
+#include <glib.h>
+#include <nan.h>
+
+#include <functional>
+
+namespace frida {
+
+class UVContext {
+public:
+  UVContext(uv_loop_t* handle);
+  ~UVContext();
+
+  void IncreaseUsage();
+  void DecreaseUsage();
+
+  void Schedule(std::function<void ()> f);
+  void Perform(std::function<void ()> f);
+
+private:
+  static void DeleteAsyncHandle(uv_handle_t* handle);
+  void ProcessPending();
+  static void ProcessPendingWrapper(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void ProcessPendingWrapper(uv_async_t* handle);
+
+  int usage_count_;
+  uv_async_t* async_;
+  Nan::AsyncResource async_resource_;
+  GMutex mutex_;
+  GCond cond_;
+  GSList* pending_;
+  v8::Persistent<v8::Object> module_;
+  v8::Persistent<v8::Function> process_pending_;
+};
+
+}
+
+#endif

package/src/win_delay_load_hook.cc

@@ -0,0 +1,63 @@
+/*
+ * When this file is linked to a DLL, it sets up a delay-load hook that
+ * intervenes when the DLL is trying to load the host executable
+ * dynamically. Instead of trying to locate the .exe file it'll just
+ * return a handle to the process image.
+ *
+ * This allows compiled addons to work when the host executable is renamed.
+ */
+
+#ifdef _MSC_VER
+
+#pragma managed(push, off)
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#include <delayimp.h>
+#include <string.h>
+
+static FARPROC WINAPI load_exe_hook(unsigned int event, DelayLoadInfo* info) {
+#ifdef FRIDA_NODE_WEBKIT
+  static HMODULE node_dll = NULL;
+  static HMODULE nw_dll = NULL;
+
+  switch (event) {
+    case dliStartProcessing:
+      node_dll = GetModuleHandle("node.dll");
+      nw_dll = GetModuleHandle("nw.dll");
+      return NULL;
+    case dliNotePreLoadLibrary:
+      if (_stricmp(info->szDll, "node.exe") == 0)
+        return (FARPROC) node_dll;
+      return NULL;
+    case dliNotePreGetProcAddress: {
+      FARPROC ret = GetProcAddress(node_dll, info->dlp.szProcName);
+      if (ret)
+        return ret;
+      return GetProcAddress(nw_dll, info->dlp.szProcName);
+    }
+    default:
+      return NULL;
+  }
+#else
+  HMODULE m;
+  if (event != dliNotePreLoadLibrary)
+    return NULL;
+
+  if (_stricmp(info->szDll, HOST_BINARY) != 0)
+    return NULL;
+
+  m = GetModuleHandle(NULL);
+  return (FARPROC) m;
+#endif
+}
+
+decltype(__pfnDliNotifyHook2) __pfnDliNotifyHook2 = load_exe_hook;
+
+#pragma managed(pop)
+
+#endif

package/subprojects/frida-core.wrap

@@ -0,0 +1,8 @@
+[wrap-git]
+url = https://github.com/frida/frida-core.git
+revision = 16.2.2
+depth = 1
+
+[provide]
+dependency_names = frida-core-1.0
+

package/subprojects/nan.wrap

@@ -0,0 +1,9 @@
+[wrap-git]
+url = https://github.com/nodejs/nan.git
+revision = 56585a1cd21f25b4d56168063cedaf0831c63fef
+depth = 1
+diff_files = nan.patch
+
+[provide]
+dependency_names = nan
+

package/subprojects/packagefiles/nan.patch

@@ -0,0 +1,13 @@
+diff -Nur nan-2.18.0-orig/meson.build nan-2.18.0/meson.build
+--- nan-2.18.0-orig/meson.build	1970-01-01 01:00:00.000000000 +0100
++++ nan-2.18.0/meson.build	2024-02-27 10:43:03.643648729 +0100
+@@ -0,0 +1,9 @@
++project('nan', 'cpp',
++  version: '2.18.0',
++)
++
++nan_dep = declare_dependency(
++  include_directories: include_directories('.'),
++)
++
++meson.override_dependency('nan', nan_dep)

package/test/data/index.ts

@@ -0,0 +1,13 @@
+export function targetProgram() {
+    const platform = process.platform;
+    if (platform === "win32") {
+        return "C:\\Windows\\notepad.exe";
+    } else if (platform === "darwin") {
+        return __dirname + "/unixvictim-macos";
+    } else if (platform === "linux" && ["ia32", "x64"].includes(process.arch)) {
+        const fridaArch = (process.arch === "x64") ? "x86_64" : "x86";
+        return __dirname + "/unixvictim-linux-" + fridaArch;
+    } else {
+        return "/bin/cat";
+    }
+}

package/test/device.ts

@@ -0,0 +1,27 @@
+import * as frida from "../lib";
+
+import { expect } from "chai";
+import "mocha";
+
+declare function gc(): void;
+
+describe("Device", function () {
+    afterEach(gc);
+
+    it("should have some metadata", async () => {
+        const device = await frida.getLocalDevice();
+        expect(device.name).to.equal("Local System");
+        expect(device.type).to.equal("local");
+    });
+
+    it("should enumerate processes", async () => {
+        const device = await frida.getLocalDevice();
+
+        const processes = await device.enumerateProcesses();
+        expect(processes.length).to.be.above(0);
+
+        const process = processes[0];
+        expect(process.pid).to.be.at.least(0);
+        expect(process.name.length).to.be.greaterThan(0);
+    });
+});

package/test/device_manager.ts

@@ -0,0 +1,16 @@
+import * as frida from "../lib";
+
+import { expect } from "chai";
+import "mocha";
+
+declare function gc(): void;
+
+describe("DeviceManager", function () {
+    afterEach(gc);
+
+    it("should enumerate devices", async () => {
+        const deviceManager = frida.getDeviceManager();
+        const devices = await deviceManager.enumerateDevices();
+        expect(devices.length).to.be.above(0);
+    });
+});

package/test/labrat.ts

@@ -0,0 +1,32 @@
+import * as frida from "../lib";
+import { targetProgram } from "./data";
+
+export class LabRat {
+    private constructor(private _pid: number) {
+    }
+
+    get pid(): number {
+        return this._pid;
+    }
+
+    static async start(): Promise<LabRat> {
+        const pid = await frida.spawn(targetProgram(), {
+            stdio: frida.Stdio.Pipe
+        });
+        await frida.resume(pid);
+        // TODO: improve injectors to handle injection into a process that hasn't yet finished initializing
+        await sleep(50);
+
+        return new LabRat(pid);
+    }
+
+    stop(): void {
+        frida.kill(this._pid);
+    }
+}
+
+function sleep(delay: number): Promise<void> {
+    return new Promise(resolve => {
+        setTimeout(() => { resolve(); }, delay);
+    });
+}

package/test/script.ts

@@ -0,0 +1,176 @@
+import * as frida from "../lib";
+import { LabRat } from "./labrat";
+
+import { expect } from "chai";
+import "mocha";
+
+declare function gc(): void;
+
+describe("Script", function () {
+    let target: LabRat;
+    let session: frida.Session;
+
+    beforeEach(async () => {
+        target = await LabRat.start();
+        session = await frida.attach(target.pid);
+    });
+
+    afterEach(() => {
+        target.stop();
+        gc();
+    });
+
+    it("should support rpc", async () => {
+        const script = await session.createScript(
+            "rpc.exports = {" +
+            "add: function (a, b) {" +
+            "var result = a + b;" +
+            "if (result < 0)" +
+            "throw new Error('No');" +
+            "return result;" +
+            "}," +
+            "sub: function (a, b) {" +
+            "return a - b;" +
+            "}," +
+            "speak: function () {" +
+            "var buf = Memory.allocUtf8String('Yo');" +
+            "return Memory.readByteArray(buf, 2);" +
+            "}" +
+            "};");
+        await script.load();
+
+        const agent = script.exports;
+
+        expect(await agent.add(2, 3)).to.equal(5);
+        expect(await agent.sub(5, 3)).to.equal(2);
+
+        let thrownException: Error | null = null;
+        try {
+            await agent.add(1, -2);
+        } catch (e) {
+            thrownException = e;
+        }
+        expect(thrownException).to.not.be.equal(null);
+        expect(thrownException.message).to.equal("No");
+
+        const buf = await agent.speak();
+        expect(buf.toJSON().data).to.deep.equal([0x59, 0x6f]);
+    });
+
+    it("should fail rpc request if post() fails", async () => {
+        const script = await session.createScript(
+            "rpc.exports = {" +
+            "init: function () {" +
+            "}" +
+            "};");
+        await script.load();
+
+        await session.detach();
+
+        let thrownException: Error | null = null;
+        try {
+            await script.exports.init();
+        } catch (e) {
+            thrownException = e;
+        }
+        expect(thrownException).to.not.equal(null);
+        expect(thrownException.message).to.equal("Script is destroyed");
+    });
+
+    it("should fail rpc request if script is unloaded mid-request", async () => {
+        const script = await session.createScript(
+            "rpc.exports = {" +
+            "waitForever: function () {" +
+            "return new Promise(function () {});" +
+            "}" +
+            "};");
+        await script.load();
+
+        setTimeout(() => script.unload(), 100);
+
+        let thrownException: Error | null = null;
+        try {
+            await script.exports.waitForever();
+        } catch (e) {
+            thrownException = e;
+        }
+        expect(thrownException).to.not.equal(null);
+        expect(thrownException.message).to.equal("Script is destroyed");
+    });
+
+    it("should fail rpc request if session gets detached mid-request", async () => {
+        const script = await session.createScript(
+            "rpc.exports = {" +
+            "waitForever: function () {" +
+            "return new Promise(function () {});" +
+            "}" +
+            "};");
+        await script.load();
+
+        setTimeout(() => target.stop(), 100);
+
+        let thrownException: Error | null = null;
+        try {
+            await script.exports.waitForever();
+        } catch (e) {
+            thrownException = e;
+        }
+        expect(thrownException).to.not.equal(null);
+        expect(thrownException.message).to.equal("Script is destroyed");
+    });
+
+    it("should fail rpc request if cancelled mid-request", async () => {
+        const cancellable = new frida.Cancellable();
+
+        const script = await session.createScript(
+            "rpc.exports = {" +
+            "waitForever: function () {" +
+            "return new Promise(function () {});" +
+            "}" +
+            "};", {}, cancellable);
+        await script.load(cancellable);
+
+        setTimeout(() => cancellable.cancel(), 100);
+
+        let thrownException: Error | null = null;
+        try {
+            await script.exports.waitForever(cancellable);
+        } catch (e) {
+            thrownException = e;
+        }
+        expect(thrownException).to.not.equal(null);
+        expect(thrownException.message).to.equal("Operation was cancelled");
+    });
+
+    it("should support returning rpc exports object from async method", async () => {
+        const api = await load();
+        expect(await api.hello()).to.equal("Is it me you're looking for?");
+
+        async function load(): Promise<frida.ScriptExports> {
+            const script = await session.createScript(`
+            rpc.exports.hello = function () {
+                return "Is it me you're looking for?";
+            };`);
+            await script.load();
+
+            const api = script.exports;
+
+            expect(api.then).to.be.undefined;
+            expect(api.catch).to.be.undefined;
+            expect(api.finally).to.be.undefined;
+
+            return api;
+        }
+    });
+
+    it("should support custom log handler", async () => {
+        const script = await session.createScript("console.error(new Error('test message'))");
+
+        script.logHandler = function (level, text) {
+            expect(level).to.equal("error");
+            expect(text).to.equal("Error: test message");
+        };
+
+        await script.load();
+    });
+});

package/test/session.ts

@@ -0,0 +1,73 @@
+import * as frida from "../lib";
+import { LabRat } from "./labrat";
+
+import { expect } from "chai";
+import "mocha";
+
+declare function gc(): void;
+
+describe("Session", () => {
+    let target: LabRat;
+    let session: frida.Session;
+
+    beforeEach(async () => {
+        target = await LabRat.start();
+        session = await frida.attach(target.pid);
+    });
+
+    afterEach(() => {
+        target.stop();
+        gc();
+    });
+
+    it("should have some metadata", () => {
+        expect(session.pid).to.equal(target.pid);
+    });
+
+    it("should support specifying which script runtime to use", async () => {
+        expect(await evaluteScript("Script.runtime")).to.equal("QJS");
+        expect(await evaluteScript("Script.runtime", { runtime: frida.ScriptRuntime.Default })).to.equal("QJS");
+        expect(await evaluteScript("Script.runtime", { runtime: frida.ScriptRuntime.QJS })).to.equal("QJS");
+
+        try {
+            await evaluteScript("Script.runtime", { runtime: frida.ScriptRuntime.V8 });
+        } catch (e) {
+            if (/V8 runtime not available due to build configuration/.test(e.message)) {
+                return;
+            }
+            throw e;
+        }
+        expect(await evaluteScript("Script.runtime", { runtime: frida.ScriptRuntime.V8 })).to.equal("V8");
+
+        const bytes = await session.compileScript("console.log('Hello World!');", { runtime: frida.ScriptRuntime.QJS });
+        expect(bytes).instanceOf(Buffer);
+        expect(bytes.length).to.be.greaterThan(0);
+    });
+
+    async function evaluteScript(expression: string, options?: frida.ScriptOptions): Promise<string> {
+        const script = await session.createScript(`send(${expression});`, options);
+
+        const getMessageRequest = getNextMessage(script);
+        await script.load();
+
+        const message = await getMessageRequest;
+
+        await script.unload();
+
+        if (message.type !== frida.MessageType.Send) {
+            throw new Error("Unexpected message type");
+        }
+
+        return message.payload;
+    }
+
+    function getNextMessage(script: frida.Script): Promise<frida.Message> {
+        return new Promise(resolve => {
+            script.message.connect(onMessage);
+
+            function onMessage(message: frida.Message): void {
+                resolve(message);
+                script.message.disconnect(onMessage);
+            }
+        })
+}});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "lib": ["es2017"],
+        "target": "es2017",
+        "module": "commonjs",
+        "declaration": true,
+        "outDir": "./dist",
+        "typeRoots": [
+            "node_modules/@types"
+        ],
+        "types": [
+            "node"
+        ]
+    },
+    "include": [
+        "lib/**/*"
+    ]
+}