@zsa233/frida-analykit-agent 2.0.0 → 2.0.2

package/src/utils/std.ts

@@ -1,165 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,111 +0,0 @@
-
-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(' ')
-}