@zsa233/frida-analykit-agent 2.0.0 → 2.0.2

package/dist/rpc.js

@@ -0,0 +1,248 @@
+import { Java, ObjC, Swift } from "./bridges.js";
+import { JNIEnv } from "./jni/env.js";
+import { RPCMsgType } from "./message.js";
+import { SSLTools } from "./net/ssl.js";
+import { help } from "./helper.js";
+import { Libssl } from "./lib/libssl.js";
+import { proc } from "./process.js";
+import { ElfTools } from "./elf/tools.js";
+const _BASE_CONTEXT = {
+    Java,
+    Process,
+    Module,
+    Memory,
+    ObjC,
+    Swift,
+    File,
+    hexdump,
+    ApiResolver,
+    Arm64Relocator,
+    Arm64Writer,
+    Stalker,
+    Thread,
+    Interceptor,
+    ModuleMap,
+    Frida,
+    Script,
+    Backtracer,
+    UInt64,
+    Int64,
+    Worker,
+    help,
+    proc,
+    JNIEnv,
+    SSLTools,
+    ElfTools,
+    Libssl,
+    Object, Array, String, Number, Boolean, Symbol, BigInt, Function,
+    Math, Date, RegExp, Map, Set, WeakMap, WeakSet,
+    Error, TypeError, SyntaxError,
+    JSON, console,
+    isNaN, isFinite, parseInt, parseFloat,
+    setTimeout, clearTimeout, setInterval, clearInterval,
+    encodeURI, decodeURI, encodeURIComponent, decodeURIComponent,
+    Reflect, Proxy,
+    ArrayBuffer,
+    Int8Array,
+    Int16Array,
+    Int32Array,
+    Uint8Array,
+    Uint16Array,
+    Uint32Array,
+    NativePointer,
+    NativeFunction,
+    NativeCallback,
+};
+const EVAL_SCOPES = {};
+const SCOPE_GETTER_PREFIX = '__get__$$';
+let ID_INCR = 0;
+function gen_id() {
+    ID_INCR++;
+    return `${SCOPE_GETTER_PREFIX}${ID_INCR.toString(16)}`;
+}
+function getValueByPath(path, bind = false, root = globalThis) {
+    let obj = root;
+    let parent = obj;
+    for (let key of path.split('/')) {
+        parent = obj;
+        obj = obj[key];
+    }
+    if (parent !== root && typeof (obj) === 'function') {
+        obj = bind ? obj.bind(parent) : obj;
+    }
+    return obj;
+}
+function getObj(instIdOrObjChain, scopeId, bind = false) {
+    let value;
+    if (instIdOrObjChain.startsWith(SCOPE_GETTER_PREFIX)) {
+        const scope = EVAL_SCOPES[scopeId];
+        value = getValueByPath(instIdOrObjChain, bind, scope);
+    }
+    else {
+        value = getValueByPath(instIdOrObjChain, bind);
+    }
+    return value;
+}
+function enumerateObjProps(instIdOrObjChain, scopeId) {
+    const propsList = [];
+    const objList = [];
+    if (typeof (instIdOrObjChain) === 'string') {
+        objList.push(instIdOrObjChain);
+    }
+    else {
+        objList.push(...instIdOrObjChain);
+    }
+    for (let v of objList) {
+        const props = {};
+        let obj;
+        try {
+            obj = getObj(v, scopeId);
+        }
+        catch (e) { }
+        try {
+            const numKeys = [];
+            while (obj && obj !== Object.prototype) {
+                for (const key of Reflect.ownKeys(obj)) {
+                    if (typeof (key) === 'symbol') {
+                        continue;
+                    }
+                    if (/^\d+$/.test(key)) {
+                        numKeys.push(parseInt(key));
+                        continue;
+                    }
+                    let type;
+                    const desc = Reflect.getOwnPropertyDescriptor(obj, key);
+                    if (desc?.get) {
+                        type = 'getter';
+                    }
+                    else if (desc?.set) {
+                        type = 'setter';
+                    }
+                    else {
+                        type = typeof (obj[key]);
+                    }
+                    props[String(key)] = type;
+                }
+                obj = Object.getPrototypeOf(obj);
+            }
+            if (numKeys.length > 0) {
+                if (numKeys.length <= 50) {
+                    for (let n of numKeys) {
+                        const key = n.toString();
+                        const desc = Reflect.getOwnPropertyDescriptor(obj, key);
+                        let type;
+                        if (desc?.get) {
+                            type = 'getter';
+                        }
+                        else if (desc?.set) {
+                            type = 'setter';
+                        }
+                        else {
+                            type = typeof (obj[key]);
+                        }
+                        props[String(key)] = type;
+                    }
+                }
+                else {
+                    const minN = Math.min(...numKeys);
+                    const maxN = Math.max(...numKeys);
+                    props[`[${minN}:${maxN + 1}]`] = 'index';
+                }
+            }
+        }
+        catch (e) {
+        }
+        propsList.push(props);
+    }
+    return {
+        type: RPCMsgType.ENUMERATE_OBJ_PROPS,
+        data: {
+            props: propsList,
+        },
+    };
+}
+function iterScopeGet(v, scopeId, bind = false) {
+    switch (typeof (v)) {
+        case 'string':
+            if (v.startsWith(SCOPE_GETTER_PREFIX)) {
+                return getObj(v, scopeId, bind);
+            }
+            break;
+        case 'object':
+            const nv = {};
+            for (const [kk, vv] of Object.entries(v)) {
+                nv[kk] = iterScopeGet(vv, scopeId, bind);
+            }
+            return nv;
+    }
+    return v;
+}
+function scopeCall(instIdOrObjChain, args, scopeId) {
+    const obj = getObj(instIdOrObjChain, scopeId, true);
+    const nargs = args.map(v => {
+        return iterScopeGet(v, scopeId, false);
+    });
+    const result = obj(...nargs);
+    const id = gen_id();
+    scopeSave(result, id, scopeId);
+    return {
+        type: RPCMsgType.SCOPE_CALL,
+        data: {
+            id,
+            type: typeof (result),
+            result
+        }
+    };
+}
+function scopeSave(obj, instId, scopeId) {
+    let scope = EVAL_SCOPES[scopeId];
+    if (scope === undefined) {
+        scope = {};
+        EVAL_SCOPES[scopeId] = scope;
+    }
+    scope[instId] = obj;
+}
+function scopeGet(instIdOrObjChain, scopeId, bind = false) {
+    const value = getObj(instIdOrObjChain, scopeId, bind);
+    return {
+        type: RPCMsgType.SCOPE_GET,
+        data: {
+            value,
+        }
+    };
+}
+function scopeClear(scopeId) {
+    delete (EVAL_SCOPES[scopeId]);
+}
+function scopeDel(instId, scopeId) {
+    const scope = EVAL_SCOPES[scopeId];
+    if (scope) {
+        delete (scope[instId]);
+    }
+}
+function evalWithContext(code, context = {}) {
+    const mergeContext = { ..._BASE_CONTEXT, ...context };
+    return Function(...Object.keys(mergeContext), code)(...Object.values(mergeContext));
+}
+function scopeEval(source, scopeId) {
+    const result = evalWithContext(source, EVAL_SCOPES[scopeId] || {});
+    const id = gen_id();
+    scopeSave(result, id, scopeId);
+    return {
+        type: RPCMsgType.SCOPE_EVAL,
+        data: {
+            id,
+            type: typeof (result),
+            result
+        }
+    };
+}
+rpc.exports = {
+    enumerateObjProps,
+    scopeCall,
+    scopeEval,
+    scopeClear,
+    scopeGet,
+    scopeSave,
+    scopeDel,
+};

package/dist/utils/array_pointer.d.ts

@@ -0,0 +1,21 @@
+export declare class ArrayPointer extends Number {
+    buff: ArrayBuffer | undefined;
+    constructor(val: any, buff?: ArrayBuffer);
+    isNull(): boolean;
+    add(val: number | ArrayPointer): ArrayPointer;
+    sub(val: number | ArrayPointer): ArrayPointer;
+    toNumber(): number;
+    getViewer(size: number): DataView;
+    readS8(): number;
+    readU8(): number;
+    readS16(): number;
+    readU16(): number;
+    readS32(): number;
+    readU32(): number;
+    readS64(): BigInt;
+    readU64(): BigInt;
+    readCString(): string;
+    readByteArray(length: number): ArrayBuffer;
+    readPointer(): NativePointer;
+    toString(): string;
+}

package/dist/utils/array_pointer.js

@@ -0,0 +1,81 @@
+export class ArrayPointer extends Number {
+    constructor(val, buff) {
+        super(val);
+        this.buff = buff;
+    }
+    isNull() {
+        return !this.buff?.byteLength;
+    }
+    add(val) {
+        return new ArrayPointer(this.toNumber() + Number(val), this.buff);
+    }
+    sub(val) {
+        return new ArrayPointer(this.toNumber() - Number(val), this.buff);
+    }
+    toNumber() {
+        return Number(this);
+    }
+    getViewer(size) {
+        const off = this.toNumber();
+        const view = new DataView(this.buff.slice(off, off + size));
+        return view;
+    }
+    readS8() {
+        const view = this.getViewer(1);
+        return view.getInt8(0);
+    }
+    readU8() {
+        const view = this.getViewer(1);
+        return view.getUint8(0);
+    }
+    readS16() {
+        const view = this.getViewer(2);
+        return view.getInt16(0, true);
+    }
+    readU16() {
+        const view = this.getViewer(2);
+        return view.getUint16(0, true);
+    }
+    readS32() {
+        const view = this.getViewer(4);
+        return view.getInt32(0, true);
+    }
+    readU32() {
+        const view = this.getViewer(4);
+        return view.getUint32(0, true);
+    }
+    readS64() {
+        const view = this.getViewer(8);
+        return view.getBigInt64(0, true);
+    }
+    readU64() {
+        const view = this.getViewer(8);
+        return view.getBigUint64(0, true);
+    }
+    readCString() {
+        if (this.isNull()) {
+            return '';
+        }
+        const off = this.toNumber();
+        let str = '';
+        const bview = new DataView(this.buff);
+        for (let i = off; i < this.buff.byteLength; i++) {
+            const b = bview.getUint8(i);
+            if (b === 0x00) {
+                break;
+            }
+            str += String.fromCharCode(b);
+        }
+        return str;
+    }
+    readByteArray(length) {
+        const off = this.toNumber();
+        return this.buff.slice(off, off + length);
+    }
+    readPointer() {
+        return ptr(Number(this.readU64())).readPointer();
+    }
+    toString() {
+        return this.readU64().toString(16);
+    }
+}

package/dist/utils/queue.d.ts

@@ -0,0 +1,19 @@
+export declare class FixedQueue<T> {
+    private _index;
+    private $depth;
+    private $list;
+    private $length;
+    private $overflowCallback?;
+    constructor(length: number);
+    push(elm: T): T | undefined;
+    pop(): T | undefined;
+    clear(): void;
+    get $headIndex(): number;
+    get $tailIndex(): number;
+    get list(): T[];
+    get length(): number;
+    index(offset: number): T | undefined;
+    flush(): Array<T>;
+    registerOverflowCallback(callback: (elements: T[]) => void): void;
+    $onOverflow(element: T): void;
+}

package/dist/utils/queue.js

@@ -0,0 +1,89 @@
+export class FixedQueue {
+    constructor(length) {
+        this._index = -1;
+        this.$depth = 0;
+        this.$length = 0;
+        this.$list = Array.from({ length: length }, () => undefined);
+        this.$length = 0;
+        this.$depth = length;
+    }
+    push(elm) {
+        let popElm = undefined;
+        this._index = (this._index + 1) % this.$depth;
+        if (this.$length === this.$depth) {
+            popElm = this.$list[this._index];
+        }
+        else {
+            this.$length++;
+        }
+        this.$list[this._index] = elm;
+        if (popElm !== undefined) {
+            this.$onOverflow(popElm);
+        }
+        return popElm;
+    }
+    pop() {
+        if (this.$length === this.$depth) {
+            const head = this.$headIndex;
+            const elm = this.$list[head];
+            this.$length--;
+            this.$list[head] = undefined;
+            return elm;
+        }
+        else if (this.$length > 0) {
+            let head = this.$headIndex;
+            const elm = this.$list[head];
+            this.$length--;
+            if (this.$length < 0)
+                this.$length = 0;
+            this.$list[head] = undefined;
+            return elm;
+        }
+        return undefined;
+    }
+    clear() {
+        this.$length = 0;
+        this._index = 0;
+    }
+    get $headIndex() {
+        let head = this._index + 1 - this.$length;
+        if (head < 0) {
+            head += this.$depth;
+        }
+        return head;
+    }
+    get $tailIndex() {
+        return this._index;
+    }
+    get list() {
+        if (this.$length <= 0) {
+            return [];
+        }
+        const head = this.$headIndex;
+        const tail = this.$tailIndex + 1;
+        if (head >= tail) {
+            return [...this.$list.slice(head), ...this.$list.slice(0, tail)];
+        }
+        return this.$list.slice(head, tail);
+    }
+    get length() {
+        return this.$length;
+    }
+    index(offset) {
+        const idx = (this._index + 1 + offset) % this.$depth;
+        return this.$list[idx];
+    }
+    flush() {
+        const list = this.list;
+        this.clear();
+        return list;
+    }
+    registerOverflowCallback(callback) {
+        this.$overflowCallback = callback;
+    }
+    $onOverflow(element) {
+        if (!this.$overflowCallback)
+            return;
+        this.$overflowCallback([element, ...this.flush()]);
+    }
+}

package/dist/utils/scan.d.ts

@@ -0,0 +1,35 @@
+import { NativePointerObject } from "../helper.js";
+export declare const GArray_structOf: {
+    B64: {
+        data: (base: NativePointer | import("./array_pointer.js").ArrayPointer) => NativePointer;
+        len: (base: NativePointer | import("./array_pointer.js").ArrayPointer) => number;
+    };
+    B32: {};
+};
+declare class GArrayPtr extends NativePointerObject {
+    constructor(handle: NativePointer);
+    static cast(handle: NativePointer): GArrayPtr;
+    get data(): NativePointer;
+    get length(): number;
+    [Symbol.iterator](): {
+        next(): {
+            value: NativePointer;
+            done: boolean;
+        };
+    };
+    toArray(): NativePointer[];
+}
+export declare const MemoryScanRes_structOf: {
+    B64: {
+        results: (base: NativePointer | import("./array_pointer.js").ArrayPointer) => NativePointer;
+        user_data: (base: NativePointer | import("./array_pointer.js").ArrayPointer) => NativePointer;
+        SIZE: number;
+    };
+    B32: {};
+};
+export declare class CMemoryScanRes extends NativePointerObject {
+    readonly data: GArrayPtr;
+    readonly user_data: NativePointer;
+    constructor(userData: NativePointer);
+}
+export {};

package/dist/utils/scan.js

@@ -0,0 +1,72 @@
+import { NativePointerObject } from "../helper.js";
+import { binaryPointer, binaryReadPointer, binaryReadU32, } from "./utils.js";
+export const GArray_structOf = {
+    B64: {
+        data: binaryReadPointer(0),
+        len: binaryReadU32(8),
+    },
+    // B32
+    B32: {}
+};
+class GArrayPtr extends NativePointerObject {
+    constructor(handle) {
+        super(handle);
+    }
+    static cast(handle) {
+        return new GArrayPtr(handle);
+    }
+    get data() {
+        const obj = this.$handle.readPointer();
+        if (obj.isNull())
+            return NULL;
+        return GArray_structOf.B64.data(obj);
+    }
+    get length() {
+        const obj = this.$handle.readPointer();
+        if (obj.isNull())
+            return 0;
+        return GArray_structOf.B64.len(obj);
+    }
+    [Symbol.iterator]() {
+        let nextPtr = this.data;
+        const length = this.length;
+        let inc = 0;
+        return {
+            next() {
+                const result = {
+                    value: nextPtr,
+                    done: inc >= length,
+                };
+                nextPtr = nextPtr.add(Process.pointerSize);
+                inc++;
+                return result;
+            }
+        };
+    }
+    toArray() {
+        const list = [];
+        for (let v of this) {
+            list.push(v);
+        }
+        return list;
+    }
+}
+export const MemoryScanRes_structOf = {
+    B64: {
+        results: binaryPointer(0),
+        user_data: binaryPointer(8),
+        SIZE: 16,
+    },
+    // B32
+    B32: {}
+};
+export class CMemoryScanRes extends NativePointerObject {
+    constructor(userData) {
+        const structOf = MemoryScanRes_structOf.B64;
+        const handle = Memory.alloc(structOf.SIZE);
+        super(handle);
+        this.data = new GArrayPtr(structOf.results(handle));
+        structOf.user_data(handle).writePointer(userData);
+        this.user_data = userData;
+    }
+}

package/dist/utils/std.d.ts

@@ -0,0 +1,40 @@
+import { NativePointerObject } from '../helper.js';
+export declare class StdVector extends NativePointerObject {
+    private readonly _start;
+    private readonly _finish;
+    private readonly _end_of_storage;
+    constructor(handle?: NativePointer);
+    static cast(handle: NativePointer): StdVector;
+    get start(): NativePointer;
+    set start(val: NativePointer);
+    get finish(): NativePointer;
+    set finish(val: NativePointer);
+    get end_of_storage(): NativePointer;
+    set end_of_storage(val: NativePointer);
+    get length(): number;
+    get capacity(): number;
+    [Symbol.iterator](): {
+        next(): {
+            value: NativePointer;
+            done: boolean;
+        };
+    };
+    toArray(): NativePointer[];
+}
+export declare class StdString extends NativePointerObject {
+    private readonly _cap;
+    private readonly _size;
+    private readonly _data;
+    constructor(handle?: NativePointer);
+    static cast(handle: NativePointer): StdString;
+    get size(): number;
+    get data(): ArrayBuffer | null;
+    get length(): number;
+    get capacity(): number;
+    get longMode(): boolean;
+    get stringPtr(): NativePointer;
+    toString(): string;
+    toCString(): string;
+    toUtf8String(): string;
+    toUtf16String(): string;
+}