@zsa233/frida-analykit-agent 2.0.0 → 2.0.1

package/dist/helper.js

@@ -0,0 +1,527 @@
+import { Libc } from './lib/libc.js';
+import { FixedQueue } from './utils/queue.js';
+import { RPCMsgType, saveFileSource } from './message.js';
+import { Config, LogLevel, setGlobalProperties } from './config.js';
+import { TextEncoder } from './utils/text_endec.js';
+export class NativePointerObject {
+    constructor(handle) {
+        this._handle = handle;
+    }
+    get $handle() {
+        return this._handle;
+    }
+    $isNull() {
+        return this.$handle.isNull();
+    }
+}
+export function downAlign(value, alignTo) { return Math.floor(value / alignTo) * alignTo; }
+export function upAlign(value, alignTo) { return Math.ceil(value / alignTo) * alignTo; }
+export function page_start(value) { return downAlign(value, Process.pageSize); }
+export function page_end(value) { return upAlign(value, Process.pageSize); }
+export class LoggerState {
+    constructor(depth = 1) {
+        this.match_offset = 0;
+        this.depth = 1;
+        this.counter = 1;
+        this.index = 0;
+        this.depth = depth;
+        this.index = 0;
+        this.msgs = new FixedQueue(depth);
+        this.base_msgs = new FixedQueue(depth);
+    }
+    onLog(msg) {
+        this.index++;
+        const earliest_msg = this.msgs.push(msg);
+        if (earliest_msg === undefined) {
+            this.base_msgs.push(msg);
+            return [msg];
+        }
+        else {
+            let outMsgs = [];
+            if (this.base_msgs.index(this.match_offset) === msg) {
+                this.match_offset++;
+                if (this.match_offset === this.depth) {
+                    this.counter++;
+                    this.match_offset = 0;
+                }
+            }
+            else {
+                if (this.counter > 1) {
+                    outMsgs = this.base_msgs.list.map(v => `#${this.counter}# | ${v}`);
+                    outMsgs.push(msg);
+                    this.base_msgs.clear();
+                }
+                else {
+                    outMsgs = [msg];
+                }
+                this.base_msgs.push(msg);
+                this.match_offset = 0;
+                this.counter = 1;
+            }
+            return outMsgs;
+        }
+    }
+}
+const AID_USER_OFFSET = 100000;
+function multiuser_get_user_id(uid) {
+    return Math.floor(uid / AID_USER_OFFSET);
+}
+export class FileHelper extends NativePointerObject {
+    constructor(pathname, mode) {
+        const handle = Helper.libc.fopen(pathname, mode);
+        if (handle.isNull()) {
+            throw new Error(`can't open file[${pathname}], mode[${mode}]`);
+        }
+        super(handle);
+        this._isClosed = false;
+        const weakRef = ptr(handle.toString());
+        this._weakRefId = Script.bindWeak(this.$handle, () => {
+            return Helper.libc.fclose(weakRef);
+        });
+    }
+    close() {
+        return this._isClosed ? 0 : (this._isClosed = true, Script.unbindWeak(this._weakRefId), Helper.libc.fclose(this.$handle));
+    }
+    writeLine(data, append = '\n') {
+        return Helper.libc.fputs(data + append, this.$handle);
+    }
+    flush() {
+        return Helper.libc.fflush(this.$handle);
+    }
+}
+export class BatchSender {
+    constructor(source) {
+        this._batch_list = [];
+        this._source = source;
+    }
+    send(message, data) {
+        this._batch_list.push({
+            message: message,
+            data: data,
+        });
+    }
+    rpcResponse() {
+        if (!this._batch_list.length) {
+            return [];
+        }
+        let totalBuffLen = this._batch_list.reduce((acc, cur) => acc + (cur.data?.byteLength || 0), 0);
+        const batchBuff = new Uint8Array(totalBuffLen);
+        const buffSizeList = [];
+        const messageList = [];
+        let buffIndex = 0;
+        for (let i = 0; i < this._batch_list.length; i++) {
+            const data = this._batch_list[i];
+            messageList.push(data.message);
+            const buffSize = data.data?.byteLength || 0;
+            buffSizeList.push(buffSize);
+            if (data.data && buffSize > 0) {
+                batchBuff.set(new Uint8Array(data.data), buffIndex);
+                buffIndex += buffSize;
+            }
+        }
+        return [{
+                type: RPCMsgType.BATCH,
+                source: this._source,
+                data: {
+                    message_list: messageList,
+                    data_sizes: buffSizeList,
+                }
+            }, batchBuff.buffer];
+    }
+    clear() {
+        this._batch_list = [];
+    }
+    flush() {
+        const [message, buff] = this.rpcResponse();
+        if (!message && !buff) {
+            return;
+        }
+        Helper.$send(message, buff);
+        this.clear();
+    }
+}
+let PROGRESS_INC = 0;
+export class ProgressNotify {
+    constructor(tag) {
+        this.step = 0;
+        PROGRESS_INC++;
+        this.ID = PROGRESS_INC;
+        this.tag = tag;
+        this.startTime = new Date();
+    }
+    notify(extra = {}, err) {
+        sendProgressMsg(this.tag, this.ID, this.step, extra, err);
+        this.step++;
+    }
+    log(name, extra, lines) {
+        const now = new Date();
+        console.error(`[+] | ${this.tag} | <${name}> - ${extra} (${now.getTime() - this.startTime.getTime()} ms)`);
+        if (lines?.length) {
+            console.error('[>] ' + lines.map(v => `${v}`).join('\n'));
+        }
+        this.startTime = now;
+    }
+}
+function sendProgressMsg(tag, id, step, extra = {}, err) {
+    Helper.$send({
+        type: RPCMsgType.PROGRESSING,
+        data: {
+            tag: tag,
+            id: id,
+            step: step,
+            time: new Date().getTime(),
+            extra: extra,
+            error: err ? {
+                message: err?.message,
+                stack: err?.stack
+            } : null,
+        }
+    });
+}
+function getScanPatternSize(pattern) {
+    if (pattern.startsWith('/') && pattern.endsWith('/')) {
+        throw new Error("Regular expression patterns are not allowed");
+    }
+    const bytesPart = pattern.split(':', 1)[0].trim();
+    if (bytesPart === '') {
+        return 0;
+    }
+    const bytes = bytesPart.split(/\s+/);
+    return bytes.length;
+}
+class Helper {
+    static get dataDir() {
+        if (!Helper._dataDir) {
+            const cmdline = this.readCmdline(Process.id);
+            const uid = this.libc.getuid();
+            const dataDir = `/data/user/${multiuser_get_user_id(uid)}/${cmdline}`;
+            Helper._dataDir = dataDir;
+        }
+        return Helper._dataDir;
+    }
+    static setOutputDir(dir) {
+        Config.OutputDir = dir;
+    }
+    static get outputDir() {
+        return Config.OutputDir ? Config.OutputDir : this.dataDir;
+    }
+    static _loggerPrefix() {
+        return String(Process.getCurrentThreadId());
+    }
+    static _prelog(states, prefix, ...args) {
+        let state = states[prefix];
+        const msg = Array.from(args).map(v => String(v)).join(' ');
+        if (!state) {
+            state = new LoggerState(6);
+            states[prefix] = state;
+        }
+        return state.onLog(msg);
+    }
+    static assert(cond) {
+        if (!cond) {
+            throw new Error(`assert false`);
+        }
+    }
+    static $log(level, logger, ...args) {
+        if (level < Config.LogLevel) {
+            return;
+        }
+        const prefix = this._loggerPrefix();
+        if (Config.LogCollapse) {
+            const msgs = this._prelog(this._logStates, prefix, ...args);
+            for (let v of msgs) {
+                logger(`${prefix}|`, v);
+            }
+        }
+        else {
+            logger(`${prefix}|`, ...args);
+        }
+    }
+    static $debug(...args) {
+        this.$log(LogLevel.DEBUG, console.log, ...args);
+    }
+    static $info(...args) {
+        this.$log(LogLevel.INFO, console.log, ...args);
+    }
+    static $warn(...args) {
+        this.$log(LogLevel.WARN, console.log, ...args);
+    }
+    static $error(...args) {
+        this.$log(LogLevel.WARN, console.error, ...args);
+    }
+    static walkDir(path, fn) {
+        const libc = this.libc;
+        const dir = libc.opendir(path);
+        if (dir.isNull()) {
+            console.error(`[walkDir] path[${path}] 打开失败.`);
+            return null;
+        }
+        const nameOffset = Process.pointerSize * 2 + 2 + 1;
+        let dirent;
+        while (!(dirent = libc.readdir(dir)).isNull()) {
+            const name = dirent.add(nameOffset).readCString();
+            const fp = `${path}/${name}`;
+            const link = libc.readlink(fp);
+            if (!fn(name, link)) {
+                break;
+            }
+        }
+        libc.closedir(dir);
+    }
+    static getFdLinked(fd) {
+        return this.libc.readlink(`/proc/self/fd/${fd}`);
+    }
+    static getFileStreamLinked(stream) {
+        const libc = this.libc;
+        const fd = libc.fileno(stream);
+        let link = null;
+        if (fd >= 0) {
+            link = libc.readlink(`/proc/self/fd/${fd}`);
+        }
+        return link;
+    }
+    static readProcMaps(pid = 'self') {
+        return this.readTextFile(`/proc/${pid}/maps`);
+    }
+    static readCmdline(pid = 'self') {
+        const cmdline = this.readFile(`/proc/${pid}/cmdline`);
+        const sepList = [];
+        let lastIdx = 0;
+        const u8bs = new Uint8Array(cmdline);
+        for (let i = 0; i < u8bs.byteLength; i++) {
+            const b = u8bs[i];
+            if (b === 0) {
+                if (lastIdx < i - 1) {
+                    let result = '';
+                    const view = u8bs.slice(lastIdx, i);
+                    for (let i = 0; i < view.length; i++) {
+                        result += String.fromCharCode(view[i]);
+                    }
+                    if (result.length > 0)
+                        sepList.push(result);
+                }
+                lastIdx = i;
+            }
+        }
+        return sepList.join(' ');
+    }
+    static readFile(path) {
+        return File.readAllBytes(path);
+    }
+    static openFile(pathname, mode) {
+        return new FileHelper(pathname, mode);
+    }
+    static isFilePath(str) {
+        if (!str.length) {
+            return false;
+        }
+        return str[0] === '/' && str[str.length - 1] !== '/';
+    }
+    static joinPath(dir, file) {
+        if (!dir.length) {
+            return dir;
+        }
+        return dir.replace(/\/+$/, '') + '/' + file.replace(/^\/+/, '');
+    }
+    static readTextFile(path) {
+        return File.readAllText(path);
+    }
+    static dumpProcMaps(tag, pid = 'self') {
+        const prog = new ProgressNotify('Helper.dumpProcMaps');
+        const sm = this.readProcMaps(pid);
+        this.saveFile(tag, sm, 'w', saveFileSource.procMaps);
+        prog.log(pid, `[${sm.length}]${tag}`);
+    }
+    static dumpTextFile(tag, srcPath) {
+        const prog = new ProgressNotify('Helper.dumpTextFile');
+        const sm = File.readAllText(srcPath);
+        this.saveFile(tag, sm, 'w', saveFileSource.textFile);
+        prog.log(srcPath, `[${sm.length}](${tag})`);
+    }
+    static backtrace({ context = undefined, addrHandler = DebugSymbol.fromAddress, backtracer = Backtracer.ACCURATE } = {}) {
+        const prog = new ProgressNotify('Helper.backtrace');
+        const stacks = Thread.backtrace(context, backtracer).map(addr => {
+            return `${addrHandler(addr)}`;
+        });
+        prog.log(Process.getCurrentThreadId(), '', stacks);
+    }
+    static saveFile(tag, bs, mode, source) {
+        if (bs === null || bs === undefined) {
+            return false;
+        }
+        if (Config.OnRPC) {
+            let buff;
+            if (bs instanceof String) {
+                const enc = new TextEncoder();
+                const view = enc.encode(bs);
+                buff = view.buffer;
+            }
+            else {
+                buff = bs;
+            }
+            Helper.$send({
+                type: RPCMsgType.SAVE_FILE,
+                data: {
+                    source,
+                    filepath: Helper.joinPath(this.outputDir, tag),
+                    mode,
+                }
+            }, buff);
+        }
+        else {
+            const savedFile = new File(tag, mode);
+            savedFile.write(bs);
+            savedFile.close();
+        }
+    }
+    static androidGetApiLevel() {
+        if (this._android_api_level === undefined) {
+            this._android_api_level = parseInt(this.libc.__system_property_get('ro.build.version.sdk'));
+        }
+        return this._android_api_level;
+    }
+    static memoryReadDo(address, size, doFunc) {
+        const page_infos = [];
+        const makeReadable = () => {
+            let cur = address;
+            const end = address.add(size);
+            while (cur < end) {
+                const range = Process.findRangeByAddress(cur);
+                let originProts = '';
+                let newProts = '';
+                let readable = false;
+                if (range !== null) {
+                    cur = range.base.add(range.size);
+                    originProts = range.protection;
+                    if (range.protection[0] !== 'r') {
+                        newProts = 'r' + originProts.slice(1);
+                    }
+                    else {
+                        readable = true;
+                    }
+                }
+                page_infos.push({
+                    readable,
+                    originProts,
+                    newProts,
+                    range,
+                });
+            }
+            for (let v of page_infos) {
+                if (v.range && v.newProts !== '') {
+                    v.protectResult = Memory.protect(v.range.base, v.range.size, v.newProts);
+                    if (v.protectResult) {
+                        v.readable = true;
+                    }
+                }
+            }
+            return page_infos;
+        };
+        const makeRecovery = () => {
+            for (let v of page_infos) {
+                if (v.range && v.newProts !== '' && v.protectResult) {
+                    v.recoverResult = Memory.protect(v.range.base, v.range.size, v.originProts);
+                }
+            }
+            return page_infos;
+        };
+        doFunc(makeReadable, makeRecovery);
+    }
+    static memoryReadPageDo(base, size, doFunc) {
+        const page_infos = [];
+        let cur = base;
+        const end = base.add(size);
+        let isAbort = false;
+        while (!isAbort && cur < end) {
+            const range = Process.findRangeByAddress(cur);
+            let mp = {
+                base: cur.and(ptr(Process.pageSize - 1).not()),
+                size: Process.pageSize,
+                protectResult: false,
+                originProts: '',
+                newProts: '',
+                readable: false,
+                range,
+            };
+            if (range !== null) {
+                mp.originProts = range.protection;
+                if (range.protection[0] !== 'r') {
+                    mp.newProts = 'r' + mp.originProts.slice(1);
+                    mp.protectResult = Memory.protect(mp.base, mp.size, mp.newProts);
+                    if (mp.protectResult) {
+                        mp.readable = true;
+                    }
+                }
+                else {
+                    mp.readable = true;
+                }
+                isAbort = doFunc(mp);
+                if (mp.protectResult) {
+                    mp.recoverResult = Memory.protect(mp.base, mp.size, mp.originProts);
+                }
+            }
+            page_infos.push(mp);
+            cur = mp.base.add(mp.size);
+        }
+        return page_infos;
+    }
+    static newBatchSender(source) {
+        return new BatchSender(source);
+    }
+    static getLogfile(tag, mode) {
+        const filepath = Helper.isFilePath(tag) ? tag : Helper.joinPath(Helper.outputDir, tag);
+        let fp = Helper._logfiles[filepath];
+        if (!fp) {
+            fp = Helper.openFile(filepath, mode);
+            Helper._logfiles[filepath] = fp;
+        }
+        return fp;
+    }
+    static $send(message, data) {
+        send(message, data);
+    }
+    static scanMemory(scanRange, pattern, { limit = Process.pageSize, maxMatchNum = -1, onMatch }) {
+        const patternSize = getScanPatternSize(pattern);
+        const { base, size } = scanRange;
+        const end = base.add(size);
+        let cursor = base;
+        const scanResults = [];
+        this.memoryReadDo(base, size, (makeReadable, makeRecovery) => {
+            makeReadable();
+            while (cursor < end) {
+                const nextCur = cursor.add(Math.min(Number(end.sub(cursor)), limit));
+                const cur = Number(cursor.sub(base)) > patternSize ? cursor.sub(patternSize) : cursor;
+                let results;
+                try {
+                    results = Memory.scanSync(cur, Number(nextCur.sub(cur)), pattern);
+                    if (onMatch) {
+                        results = results.filter(v => onMatch(v));
+                    }
+                    scanResults.push(...results);
+                }
+                catch (e) {
+                    // TODO: Error: access violation accessing 0xxxxxx
+                    console.error(`[scanMemory] e[${e}]`);
+                }
+                finally {
+                    if (maxMatchNum > 0 && scanResults.length >= maxMatchNum) {
+                        break;
+                    }
+                    cursor = nextCur;
+                }
+            }
+            makeRecovery();
+        });
+        return scanResults;
+    }
+}
+Helper.libc = new Libc();
+Helper._logStates = {};
+export { Helper as help };
+export const print = Helper.$log.bind(Helper, LogLevel._MUST_LOG, console.log);
+export const printErr = Helper.$log.bind(Helper, LogLevel._MUST_LOG, console.error);
+setGlobalProperties({
+    'help': Helper,
+    'print': print,
+    'printErr': printErr,
+});

package/{src/index.ts → dist/index.d.ts}

@@ -1,5 +1,4 @@
 import "./bridges.js";
-
 export { Java, ObjC, Swift } from "./bridges.js";
 export { Config, LogLevel, setGlobalProperties } from "./config.js";
 export { help, NativePointerObject, BatchSender, ProgressNotify, LoggerState, FileHelper } from "./helper.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+import "./bridges.js";
+export { Java, ObjC, Swift } from "./bridges.js";
+export { Config, LogLevel, setGlobalProperties } from "./config.js";
+export { help, NativePointerObject, BatchSender, ProgressNotify, LoggerState, FileHelper } from "./helper.js";
+export { proc } from "./process.js";
+export { JNIEnv } from "./jni/env.js";
+export { SSLTools } from "./net/ssl.js";
+export { ElfTools } from "./elf/tools.js";
+export { Libssl } from "./lib/libssl.js";