@zsa233/frida-analykit-agent 2.0.0

package/src/utils/std.ts

@@ -0,0 +1,165 @@
+import { Java } from '../bridges.js'
+import { help, NativePointerObject } from '../helper.js'
+
+
+export class StdVector extends NativePointerObject {
+    private readonly _start: NativePointer
+    private readonly _finish: NativePointer
+    private readonly _end_of_storage: NativePointer
+
+    constructor(handle: NativePointer = NULL){
+        let shouldDelete = handle.isNull()
+        if(handle.isNull()) {
+            handle = Memory.alloc(3 * Process.pointerSize)
+        }
+        super(handle)
+        
+        this._start = this.$handle
+        this._finish = this.$handle.add(Process.pointerSize)
+        this._end_of_storage = this.$handle.add(Process.pointerSize * 2)
+
+        if (shouldDelete) {
+            const weakRef = ptr(handle.toString())
+            Script.bindWeak(this.$handle, () =>{
+                Java.api.$delete(weakRef)
+            })
+        }
+    }
+
+    static cast(handle: NativePointer): StdVector {
+        return new StdVector(handle)
+    }
+
+    get start(): NativePointer {
+        return this._start.readPointer()
+    }
+
+    set start(val: NativePointer){
+        this._start.writePointer(val)
+    } 
+
+    get finish(): NativePointer {
+        return this._finish.readPointer()
+    }
+
+    set finish(val: NativePointer) {
+        this._finish.writePointer(val)
+    }
+
+    get end_of_storage(): NativePointer {
+        return this._end_of_storage.readPointer()
+    }
+
+    set end_of_storage(val: NativePointer) {
+        this._end_of_storage.writePointer(val)
+    }
+
+    get length(): number {
+        return this.finish.sub(this.start).toUInt32() / Process.pointerSize
+    }
+
+    get capacity(): number {
+        return this.end_of_storage.sub(this.start).toUInt32() / Process.pointerSize
+    }
+
+    [Symbol.iterator](){
+        let nextPtr = this.start
+        const that = this
+        return {
+            next(){
+                let done = false
+                let value = nextPtr
+                if(value >= that.finish) {
+                    done = true
+                    value = NULL
+                }else{
+                    nextPtr = nextPtr.add(Process.pointerSize)
+                }
+                return {
+                    value: value,
+                    done: done,
+                }
+            }
+        }
+    }
+
+    toArray(): NativePointer[] {
+        const list = []
+        for(let v of this) {
+            list.push(v)
+        }
+        return list
+    }
+}
+
+
+const STD_STRING_MEM_BYTE_SIZE = Process.pointerSize === 4 ? 12 : 24
+const STD_STRING_CAP_LONG_MODE_CAP_MASK = help.androidGetApiLevel() <= 16 
+    ? (Process.pointerSize === 4 ? '0x80000000': '0x8000000000000000')
+    : '0x1'
+
+
+export class StdString extends NativePointerObject {
+    private readonly _cap: NativePointer
+    private readonly _size: NativePointer
+    private readonly _data: NativePointer
+
+    constructor(handle: NativePointer = NULL) {
+        if (handle.isNull()) {
+            handle = Memory.alloc(STD_STRING_MEM_BYTE_SIZE)
+        }
+        super(handle)
+
+        this._cap = this.$handle
+        this._size = this.$handle.add(Process.pointerSize)
+        this._data = this.$handle.add(Process.pointerSize * 2)
+    }
+
+    static cast(handle: NativePointer): StdString {
+        return new StdString(handle)
+    }
+
+    get size(): number  {
+        return this.longMode ? this._size.readU64().toNumber() : this.$handle.add(STD_STRING_MEM_BYTE_SIZE - 1).and(0x7F).toUInt32()
+    }
+
+    get data(): ArrayBuffer | null {
+        return this._data.readByteArray(this.size)
+    }
+
+    get length(): number {
+        return this.size
+    }
+
+    get capacity(): number {
+        return this.longMode ? this._cap.readU64().toNumber() : this.size
+    }
+
+    get longMode(): boolean {
+        return !this._cap.readU64().and(STD_STRING_CAP_LONG_MODE_CAP_MASK).equals(0)
+    }
+
+    get stringPtr(): NativePointer {
+        if(this.longMode) {
+            return this._data.readPointer()
+        }else{
+            return this.$handle.readPointer()
+        }
+    }
+
+    toString(): string {
+        return this.stringPtr.readUtf8String(this.size) || ''
+    }
+
+    toCString(): string {
+        return this.stringPtr.readCString(this.size) || ''
+    }
+
+    toUtf8String(): string {
+        return this.stringPtr.readUtf8String(this.size) || ''
+    }
+
+    toUtf16String(): string {
+        return this.stringPtr.readUtf16String(this.size) || ''
+    }
+}

package/src/utils/text_endec.ts

@@ -0,0 +1,35 @@
+import { setGlobalProperties } from "../config.js"
+
+
+export class TextEncoder {
+    readonly encoding = 'utf-8'
+
+    encode(input: string): Uint8Array {
+        const strPtr = Memory.allocUtf8String(input)
+        const eosZeros = Memory.scanSync(strPtr, input.length * 4, "00")
+        const blen = eosZeros[0].address.sub(strPtr)
+        return new Uint8Array(strPtr.readByteArray(Number(blen))!)
+    }
+
+}
+
+
+export class TextDecoder {
+    readonly encoding = 'utf-8'
+
+    decode(input: ArrayBuffer): string {
+        if (typeof(input['unwrap']) === 'function') {
+            return input.unwrap().readUtf8String() || ''
+        }
+
+        const tmp = Memory.alloc(input.byteLength)
+        tmp.writeByteArray(input)
+        return tmp.readUtf8String() || ''
+    }
+}
+
+
+setGlobalProperties({
+    TextDecoder,
+    TextEncoder,
+})

package/src/utils/utils.ts

@@ -0,0 +1,111 @@
+
+import { ArrayPointer } from "./array_pointer.js"
+
+export function mustType<T>(val: T | null | undefined): T {
+    if (!val) {
+        throw new Error(`val不能为null`)
+    }
+    return val
+}
+
+export function unwrapArgs(args: InvocationArguments, n: number): (any|NativePointer)[] {
+    const list = []
+    for(let i = 0; i < n; i++) {
+        list.push(args[i])
+    }
+    return list
+}
+
+
+type NumberReaderMethod =
+    'readU8' |
+    'readU16' |
+    'readU32' |
+    'readU64' |
+    'readS8' |
+    'readS16' |
+    'readS32' |
+    'readS64' 
+
+
+
+type BianaryBaseReader<T> = (base: NativePointer | ArrayPointer) => T
+
+
+function binaryNumberReader(offset: number, method: NumberReaderMethod): BianaryBaseReader<number> {
+    return function (base: NativePointer | ArrayPointer): number {
+        return Number(base.add(offset)[method]())
+    }
+}
+
+function binaryPointerReader(offset: number): BianaryBaseReader<NativePointer> {
+    return function (base: NativePointer | ArrayPointer): NativePointer {
+        return base.add(offset).readPointer()
+    }
+}
+
+function binaryPointerOffset(offset: number): BianaryBaseReader<NativePointer> {
+    return function (base: NativePointer | ArrayPointer): NativePointer {
+        return ptr(base.add(offset).toString())
+    }
+}
+
+
+function readByteArray(offset: number, length: number) { return (base: NativePointer | ArrayPointer) => mustType(base.add(offset).readByteArray(length)) }
+function binaryReadU8(offset: number) { return binaryNumberReader(offset, 'readU8') }
+function binaryReadU16(offset: number) { return binaryNumberReader(offset, 'readU16') }
+function binaryReadU32(offset: number) { return binaryNumberReader(offset, 'readU32') }
+function binaryReadS32(offset: number) { return binaryNumberReader(offset, 'readS32') }
+function binaryReadU64(offset: number) { return binaryNumberReader(offset, 'readU64') }
+function binaryReadS64(offset: number) { return binaryNumberReader(offset, 'readS64') }
+function binaryReadPointer(offset: number) { return binaryPointerReader(offset) }
+function binaryPointer(offset: number) { return binaryPointerOffset(offset) }
+function binaryReadPointerStruct(offset: number, structOfs: { B64: { [key: string]: BianaryBaseReader<any> }, B32?: { [key: string]: BianaryBaseReader<any> } }) {
+    return function (base: NativePointer | ArrayPointer): { [key: string]: any } {
+        const structOf = Process.pointerSize === 4 ? structOfs['B32'] : structOfs['B64']
+        const structBase = binaryPointerReader(offset)(base)
+        const obj: { [key: string]: any } = {}
+        for (let [k, offseter] of Object.entries(structOf!)) {
+            Object.defineProperty(obj, k, {
+                value: offseter(structBase),
+                writable: false,
+                enumerable: true,
+            })
+        }
+        return obj
+    }
+}
+
+export {
+    readByteArray,
+    binaryReadU8,
+    binaryReadU16,
+    binaryReadU32,
+    binaryReadS32,
+    binaryReadU64,
+    binaryReadS64,
+    binaryReadPointer,
+    binaryPointer,
+    binaryReadPointerStruct,
+}
+
+
+
+export function wrapArgTypes(typ: NativeFunctionArgumentType, length: number): NativeFunctionArgumentType[] {
+    return Array.from({ length: length }, () => typ)
+}
+
+
+export function arrayBuffer2Hex(
+    buffer: ArrayBuffer,
+    options: { uppercase?: boolean } = {}
+): string {
+    const { uppercase = false } = options
+    const bytes = new Uint8Array(buffer)
+    return Array.from(bytes)
+        .map(b => {
+            const hex = b.toString(16).padStart(2, '0')
+            return uppercase ? hex.toUpperCase() : hex
+        })
+        .join(' ')
+}