@zsa233/frida-analykit-agent 2.0.0 → 2.0.2

package/dist/api/android.d.ts

@@ -0,0 +1,41 @@
+export type NP = NativePointer;
+export interface EnvJvmti {
+    handle: NP;
+    vm: NP;
+    vtable: NP;
+}
+export interface VMApi {
+    vm: NP;
+    module: Module;
+    flavor: 'art' | 'dalvik';
+    addLocalRefrence: null;
+    find(name: string): NativePointer;
+    artRuntime: NativePointer;
+    artClassLinker: {
+        address: NativePointer;
+        quickResolutionTrampoline: NativePointer;
+        quickImtConflictTrampoline: NativePointer;
+        quickGenericJniTrampoline: NativePointer;
+        quickToInterpreterBridgeTrampoline: NativePointer;
+    };
+    jvmti: EnvJvmti;
+    $new(size: number): NativePointer;
+    $delete(pointer: NativePointer): void;
+    JNI_GetCreateJavaVMs(vmBuf: NP, bufLen: number, nVMs: NP): number;
+    ['art::JavaVMExt::AddGlobalRef']: (vm: NP, self: NP, obj: NP) => NP;
+    ['art::ReaderWriterMutex::ExclusiveLock']: (lock: NP, self: NP) => void;
+    ['art::IndirectReferenceTable::Add']: (table: NP, previous_state: NP, obj: number, error_msg: NP) => NP;
+    ['art::JavaVMExt::DecodeGlobal']: (vm: NP, thread: NP, ref: NP) => NP;
+    ['art::Thread::DecodeJObject']: (thread: NP, obj: NP) => NP;
+}
+declare global {
+    namespace Java {
+        const api: VMApi, Env: {
+            handle: NativePointer;
+            vm: Java.VM & {
+                handle: NativePointer;
+            };
+            throwIfExceptionPending(): Error;
+        };
+    }
+}

package/dist/api/android.js

@@ -0,0 +1 @@
+export {};

package/dist/bridges.d.ts

@@ -0,0 +1,4 @@
+import JavaBridge from "frida-java-bridge";
+export declare const Java: typeof globalThis.Java & typeof JavaBridge;
+export declare const ObjC: typeof globalThis.ObjC;
+export declare const Swift: unknown;

package/dist/bridges.js

@@ -0,0 +1,8 @@
+import JavaBridge from "frida-java-bridge";
+const globals = globalThis;
+export const Java = globals.Java ?? JavaBridge;
+export const ObjC = globals.ObjC;
+export const Swift = globals.Swift;
+if (!("Java" in globals)) {
+    globals.Java = Java;
+}

package/dist/cmodule/scan_adrp.d.ts

@@ -0,0 +1,9 @@
+export declare class ScanAdrpCMod {
+    static readonly cm: CModule;
+    static readonly $scan: NativeFunction<NativePointer, [NativePointerValue, number | UInt64, NativePointerValue, NativePointerValue]>;
+    static scan(scanRange: {
+        base: NativePointer;
+        size: number;
+    }, pattern: string, targetAddr: NativePointer, alignOffset: number): NativePointer[];
+    static readonly $dispose: NativeFunction<void, [NativePointerValue]>;
+}

package/{src/cmodule/scan_adrp.ts → dist/cmodule/scan_adrp.js}

@@ -1,8 +1,6 @@
-
-import { nativeFunctionOptions } from "../consts.js"
-import { CMemoryScanRes } from "../utils/scan.js"
-
-
+var _a;
+import { nativeFunctionOptions } from "../consts.js";
+import { CMemoryScanRes } from "../utils/scan.js";
 const CM = new CModule(`
 #include <glib.h>
 #include <gum/gummemory.h>
@@ -86,33 +84,24 @@ gpointer scan(const GumAddress base_address,
     return scan_res->results;
 }
 
-`)
-
-
+`);
 export class ScanAdrpCMod {
-    static readonly cm: CModule = CM
-
-    static readonly $scan = new NativeFunction(this.cm.scan, 'pointer', ['pointer', 'size_t', 'pointer', 'pointer'], nativeFunctionOptions)
-
-    static scan(scanRange: { base: NativePointer, size: number }, pattern: string, targetAddr: NativePointer, alignOffset: number) {
-        let matcheResults: NativePointer[] = []
-        
-        const userData = Memory.alloc(8 + 4)
-        userData.writePointer(targetAddr)
-        userData.add(8).writeU32(alignOffset)
-        
-        const scanRes = new CMemoryScanRes(userData)
-        const { base, size } = scanRange
-        this.$scan(
-            base, size, Memory.allocUtf8String(pattern), scanRes.$handle,
-        )
+    static scan(scanRange, pattern, targetAddr, alignOffset) {
+        let matcheResults = [];
+        const userData = Memory.alloc(8 + 4);
+        userData.writePointer(targetAddr);
+        userData.add(8).writeU32(alignOffset);
+        const scanRes = new CMemoryScanRes(userData);
+        const { base, size } = scanRange;
+        this.$scan(base, size, Memory.allocUtf8String(pattern), scanRes.$handle);
         if (scanRes.data.length > 0) {
-            matcheResults = scanRes.data.toArray().map(v => v.readPointer())
+            matcheResults = scanRes.data.toArray().map(v => v.readPointer());
         }
-        this.$dispose(scanRes.$handle)
-        return matcheResults
+        this.$dispose(scanRes.$handle);
+        return matcheResults;
     }
-
-    static readonly $dispose = new NativeFunction(this.cm._dispose, 'void', ['pointer'], nativeFunctionOptions)
 }
-
+_a = ScanAdrpCMod;
+ScanAdrpCMod.cm = CM;
+ScanAdrpCMod.$scan = new NativeFunction(_a.cm.scan, 'pointer', ['pointer', 'size_t', 'pointer', 'pointer'], nativeFunctionOptions);
+ScanAdrpCMod.$dispose = new NativeFunction(_a.cm._dispose, 'void', ['pointer'], nativeFunctionOptions);

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+export declare function setGlobalProperties(keyValues: {
+    [key: string]: any;
+}): void;
+export declare const LogLevel: {
+    readonly DEBUG: 0;
+    readonly INFO: 1;
+    readonly WARN: 2;
+    readonly ERROR: 3;
+    readonly _MUST_LOG: 9999999;
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+declare global {
+    const LogLevel: {
+        DEBUG: number;
+        INFO: number;
+        WARN: number;
+        ERROR: number;
+        _MUST_LOG: number;
+    };
+}
+export declare class Config {
+    static OnRPC: boolean;
+    static OutputDir?: string;
+    static LogLevel: number;
+    static LogCollapse: boolean;
+}

package/dist/config.js

@@ -0,0 +1,27 @@
+const injectedConfig = (globalThis.__FRIDA_ANALYKIT_CONFIG__) || {};
+export function setGlobalProperties(keyValues) {
+    for (let [k, v] of Object.entries(keyValues)) {
+        if (k in globalThis) {
+            throw new Error(`global property[${k}] exists already`);
+        }
+        ;
+        globalThis[k] = v;
+    }
+}
+export const LogLevel = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    _MUST_LOG: 9999999,
+};
+export class Config {
+}
+Config.OnRPC = injectedConfig.OnRPC ?? false;
+Config.OutputDir = injectedConfig.OutputDir;
+Config.LogLevel = injectedConfig.LogLevel ?? LogLevel.INFO;
+Config.LogCollapse = injectedConfig.LogCollapse ?? true;
+setGlobalProperties({
+    'Config': Config,
+    'LogLevel': LogLevel,
+});

package/dist/consts.d.ts

@@ -0,0 +1,18 @@
+export declare const nativeFunctionOptions: NativeABI | NativeFunctionOptions;
+export declare enum SYM_INFO_BIND {
+    STB_LOCAL = 0,
+    STB_GLOBAL = 1,
+    STB_WEAK = 2,
+    STB_GNU_UNIQUE = 3
+}
+export declare enum SYM_INFO_TYPE {
+    STT_NOTYPE = 0,
+    STT_OBJECT = 1,
+    STT_FUNC = 2,
+    STT_SECTION = 3,
+    STT_FILE = 4
+}
+export declare enum SYM_SHNDX {
+    SHN_UNDEF = 0,
+    SHN_ABS = 65521
+}

package/dist/consts.js

@@ -0,0 +1,23 @@
+export const nativeFunctionOptions = {
+    exceptions: 'propagate',
+};
+export var SYM_INFO_BIND;
+(function (SYM_INFO_BIND) {
+    SYM_INFO_BIND[SYM_INFO_BIND["STB_LOCAL"] = 0] = "STB_LOCAL";
+    SYM_INFO_BIND[SYM_INFO_BIND["STB_GLOBAL"] = 1] = "STB_GLOBAL";
+    SYM_INFO_BIND[SYM_INFO_BIND["STB_WEAK"] = 2] = "STB_WEAK";
+    SYM_INFO_BIND[SYM_INFO_BIND["STB_GNU_UNIQUE"] = 3] = "STB_GNU_UNIQUE";
+})(SYM_INFO_BIND || (SYM_INFO_BIND = {}));
+export var SYM_INFO_TYPE;
+(function (SYM_INFO_TYPE) {
+    SYM_INFO_TYPE[SYM_INFO_TYPE["STT_NOTYPE"] = 0] = "STT_NOTYPE";
+    SYM_INFO_TYPE[SYM_INFO_TYPE["STT_OBJECT"] = 1] = "STT_OBJECT";
+    SYM_INFO_TYPE[SYM_INFO_TYPE["STT_FUNC"] = 2] = "STT_FUNC";
+    SYM_INFO_TYPE[SYM_INFO_TYPE["STT_SECTION"] = 3] = "STT_SECTION";
+    SYM_INFO_TYPE[SYM_INFO_TYPE["STT_FILE"] = 4] = "STT_FILE";
+})(SYM_INFO_TYPE || (SYM_INFO_TYPE = {}));
+export var SYM_SHNDX;
+(function (SYM_SHNDX) {
+    SYM_SHNDX[SYM_SHNDX["SHN_UNDEF"] = 0] = "SHN_UNDEF";
+    SYM_SHNDX[SYM_SHNDX["SHN_ABS"] = 65521] = "SHN_ABS";
+})(SYM_SHNDX || (SYM_SHNDX = {}));

package/dist/elf/insn.d.ts

@@ -0,0 +1,10 @@
+import { NativePointerObject } from "../helper.js";
+export declare class InstructionSequence extends NativePointerObject {
+    protected readonly entryInsn: Arm64Instruction;
+    protected readonly insns: Arm64Instruction[];
+    protected eoi?: Arm64Instruction;
+    constructor(entry: Arm64Instruction);
+    static loadFromPointer<T extends InstructionSequence>(this: new (insn: Arm64Instruction) => T, handle: NativePointer): T;
+    [Symbol.iterator](): Generator<Arm64Instruction, void, unknown>;
+    clearCache(): void;
+}

package/dist/elf/insn.js

@@ -0,0 +1,43 @@
+import { setGlobalProperties } from "../config.js";
+import { NativePointerObject } from "../helper.js";
+export class InstructionSequence extends NativePointerObject {
+    constructor(entry) {
+        const handle = entry.address;
+        super(handle);
+        this.insns = [];
+        this.entryInsn = entry;
+        this.insns = [entry];
+    }
+    static loadFromPointer(handle) {
+        const insn = Instruction.parse(handle);
+        return new this(insn);
+    }
+    *[Symbol.iterator]() {
+        let insns = this.insns;
+        let insn = this.entryInsn;
+        let inc = 0;
+        const that = this;
+        let value;
+        while (true) {
+            value = insns[inc];
+            if (value === undefined && that.eoi === undefined) {
+                try {
+                    insn = Instruction.parse(insns[inc - 1].next);
+                    insns.push(insn);
+                }
+                catch (error) {
+                    that.eoi = insn;
+                    break;
+                }
+            }
+            inc++;
+            yield insn;
+        }
+    }
+    clearCache() {
+        this.insns.length = 0;
+    }
+}
+setGlobalProperties({
+    InstructionSequence,
+});

package/dist/elf/module.d.ts

@@ -0,0 +1,95 @@
+import { Ehdr, Phdr, Dyn, Shdr, Soinfo, Sym, Rela } from './struct.js';
+import { ArrayPointer } from '../utils/array_pointer.js';
+interface ElfModuleX extends BaseModule {
+}
+declare global {
+    interface BaseModule {
+        name: string;
+        base: NativePointer;
+        size: number;
+    }
+}
+export interface ElfModuleFixer {
+    fixShdrs(modx: ElfModuleX): boolean;
+}
+declare class ElfModuleX {
+    module: BaseModule;
+    ehdr: Ehdr;
+    phdrs: Phdr[];
+    dyntabs: Dyn[] | null;
+    shdrs: Shdr[] | null;
+    soinfo: Soinfo | null;
+    dynSymbols: Sym[] | null;
+    rela: Rela[] | null;
+    plt_rela: Rela[] | null;
+    symtab: Sym[] | null;
+    strtab: {
+        [key: number]: string;
+    } | null;
+    private _keepNativeCb;
+    constructor(module: BaseModule, fixers?: ElfModuleFixer[], { symbolScanLimit }?: {
+        symbolScanLimit?: number;
+    });
+    static loadFromModule(mod: Module): ElfModuleX;
+    readEhdr(): {
+        ei_class: number;
+        e_type: number;
+        e_phoff: number;
+        e_shoff: number;
+        e_phnum: number;
+        e_shnum: number;
+        e_shstrndx: number;
+    };
+    readPhdrs(): Phdr[];
+    readDyntabs(): Dyn[] | null;
+    load_bias(value: number | NativePointer): NativePointer;
+    prelink_image(): Soinfo | null;
+    link_image(): void;
+    off2addr(offset: number): number | null;
+    readShdrs(): Shdr[] | null;
+    getSymString(index: number): string | null;
+    scanSymbols(cursor: number, limit: number): Sym[] | null;
+    readRela(): Rela[] | null;
+    readPltRela(): Rela[] | null;
+    attachSymbol<RetType extends NativeFunctionReturnType, ArgTypes extends any[]>(symName: string, fn: AnyFunction, retType: RetType, argTypes: ArgTypes, abi?: undefined): boolean;
+    findSymbol(symName: string): Sym | undefined;
+    fromAddress(addr: NativePointer): string | NativePointer | null;
+    isMyAddr(addr: NativePointer): boolean;
+    getSegment(seg: string): Shdr | null;
+    dump(tag: string): void;
+}
+export { ElfModuleX };
+export declare class ElfFileFixer implements ElfModuleFixer {
+    path: string;
+    private modx?;
+    private fileBytes?;
+    private ehdr?;
+    private phdrs?;
+    private shdrs?;
+    private strtab?;
+    private shstrtabShdr?;
+    constructor(path: string);
+    getFilePtr(): ArrayPointer;
+    ensureEhdr(): void;
+    ensurePhdrs(): void;
+    ensureShdrs(): void;
+    ensureStrtab(): void;
+    readEhdr(): {
+        ei_class: number;
+        e_type: number;
+        e_phoff: number;
+        e_shoff: number;
+        e_phnum: number;
+        e_shnum: number;
+        e_shstrndx: number;
+    };
+    readPhdrs(): Phdr[];
+    readShdrs(): Shdr[];
+    readStrtab(): {
+        [key: number]: string;
+    } | undefined;
+    getShstrtabString(nameOff: number): string;
+    getSymString(nameIDX: number): string;
+    readSymtab(): Sym[] | null;
+    fixShdrs(modx: ElfModuleX): boolean;
+}