proj_name
stringclasses 26
values | relative_path
stringlengths 42
188
| class_name
stringlengths 2
53
| func_name
stringlengths 2
49
| masked_class
stringlengths 68
178k
| func_body
stringlengths 56
6.8k
|
|---|---|---|---|---|---|
zhkl0228_unidbg | unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfRelocation.java | ElfRelocation | equals | class ElfRelocation implements Cloneable {
private final int objectSize;
private final SymbolLocator symtab;
long offset;
long info;
long addend;
private final boolean android;
ElfRelocation(ElfParser parser, long offset, long entry_size, SymbolLocator symtab) {
this.objectSize = parser.elfFile.objectSize;
this.symtab = symtab;
this.android = false;
parser.seek(offset);
if (parser.elfFile.objectSize == ElfFile.CLASS_32) {
this.offset = parser.readInt() & 0xffffffffL;
this.info = parser.readInt();
this.addend = entry_size >= 12 ? parser.readInt() : 0;
} else {
this.offset = parser.readLong();
this.info = parser.readLong();
this.addend = entry_size >= 24 ? parser.readLong() : 0;
}
}
@Override
public ElfRelocation clone() throws CloneNotSupportedException {
return (ElfRelocation) super.clone();
}
ElfRelocation(int objectSize, SymbolLocator symtab) {
this.objectSize = objectSize;
this.symtab = symtab;
this.android = true;
}
public long offset() {
return offset;
}
private ElfSymbol symbol;
public ElfSymbol symbol() throws IOException {
if (symbol == null) {
symbol = symtab.getELFSymbol(sym());
}
return symbol;
}
public int sym() {
int mask = objectSize == ElfFile.CLASS_32 ? 8 : 32;
return (int) (info >> mask);
}
public int type() {
long mask = objectSize == ElfFile.CLASS_32 ? 0xff : 0xffffffffL;
return (int) (info & mask);
}
public long addend() {
return addend;
}
public boolean isAndroid() {
return android;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(offset, info, addend);
}
} |
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ElfRelocation that = (ElfRelocation) o;
return offset == that.offset &&
info == that.info &&
addend == that.addend;
|
zhkl0228_unidbg | unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfStringTable.java | ElfStringTable | get | class ElfStringTable {
/** The string table data. */
private final ByteBuffer buffer;
/** Reads all the strings from [offset, length]. */
ElfStringTable(ElfParser parser, long offset, int length) throws ElfException {
parser.seek(offset);
buffer = parser.readBuffer(length);
}
private final ByteArrayOutputStream baos = new ByteArrayOutputStream(16);
String get(int index) {<FILL_FUNCTION_BODY>}
} |
buffer.position(index);
baos.reset();
byte b;
while((b = buffer.get()) != 0) {
baos.write(b);
}
return baos.toString();
|
zhkl0228_unidbg | unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfSymbol.java | ElfSymbol | getName | class ElfSymbol {
private static final int SHN_UNDEF = 0;
/** Binding specifying that local symbols are not visible outside the object file that contains its definition. */
public static final int BINDING_LOCAL = 0;
/** Binding specifying that global symbols are visible to all object files being combined. */
public static final int BINDING_GLOBAL = 1;
/** Binding specifying that the symbol resembles a global symbol, but has a lower precedence. */
public static final int BINDING_WEAK = 2;
/** Lower bound binding values reserved for processor specific semantics. */
public static final int BINDING_LOPROC = 13;
/** Upper bound binding values reserved for processor specific semantics. */
public static final int BINDING_HIPROC = 15;
/** Type specifying that the symbol is unspecified. */
public static final byte STT_NOTYPE = 0;
/** Type specifying that the symbol is associated with an object. */
public static final byte STT_OBJECT = 1;
/** Type specifying that the symbol is associated with a function or other executable code. */
public static final byte STT_FUNC = 2;
/**
* Type specifying that the symbol is associated with a section. Symbol table entries of this type exist for
* relocation and normally have the binding BINDING_LOCAL.
*/
public static final byte STT_SECTION = 3;
/** Type defining that the symbol is associated with a file. */
public static final byte STT_FILE = 4;
/** The symbol labels an uninitialized common block. */
public static final byte STT_COMMON = 5;
/** The symbol specifies a Thread-Local Storage entity. */
public static final byte STT_TLS = 6;
/** Lower bound for range reserved for operating system-specific semantics. */
public static final byte STT_LOOS = 10;
/** Upper bound for range reserved for operating system-specific semantics. */
public static final byte STT_HIOS = 12;
/** Lower bound for range reserved for processor-specific semantics. */
public static final byte STT_LOPROC = 13;
/** Upper bound for range reserved for processor-specific semantics. */
public static final byte STT_HIPROC = 15;
/**
* Index into the symbol string table that holds the character representation of the symbols. 0 means the symbol has
* no character name.
*/
private final int name_ndx; // Elf32_Word
/** Value of the associated symbol. This may be a relativa address for .so or absolute address for other ELFs. */
public final long value; // Elf32_Addr
/** Size of the symbol. 0 if the symbol has no size or the size is unknown. */
public final long size; // Elf32_Word
/** Specifies the symbol type and binding attributes. */
private final short info; // unsigned char
/** Currently holds the value of 0 and has no meaning. */
public final short other; // unsigned char
/**
* Index to the associated section header. This value will need to be read as an unsigned short if we compare it to
* ELFSectionHeader.NDX_LORESERVE and ELFSectionHeader.NDX_HIRESERVE.
*/
public final short section_header_ndx; // Elf32_Half
private final int section_type;
/** Offset from the beginning of the file to this symbol. */
public final long offset;
private final ElfFile elfHeader;
ElfSymbol(ElfParser parser, long offset, int section_type) {
this.elfHeader = parser.elfFile;
parser.seek(offset);
this.offset = offset;
if (parser.elfFile.objectSize == ElfFile.CLASS_32) {
name_ndx = parser.readInt();
value = parser.readInt();
size = parser.readInt();
info = parser.readUnsignedByte();
other = parser.readUnsignedByte();
section_header_ndx = parser.readShort();
} else {
name_ndx = parser.readInt();
info = parser.readUnsignedByte();
other = parser.readUnsignedByte();
section_header_ndx = parser.readShort();
value = parser.readLong();
size = parser.readLong();
}
this.section_type = section_type;
switch (getType()) {
case STT_NOTYPE:
case STT_OBJECT:
case STT_FUNC:
case STT_SECTION:
case STT_FILE:
case STT_LOPROC:
case STT_HIPROC:
default:
break;
}
}
final boolean matches(long soaddr) {
long value = this.value & ~1L;
return section_header_ndx != SHN_UNDEF &&
soaddr >= value &&
soaddr < value + size;
}
private ElfStringTable stringTable;
ElfSymbol setStringTable(ElfStringTable stringTable) {
this.stringTable = stringTable;
return this;
}
/** Returns the binding for this symbol. */
public int getBinding() {
return info >> 4;
}
/** Returns the symbol type. */
public int getType() {
return info & 0x0F;
}
/** Returns the name of the symbol or null if the symbol has no name. */
public String getName() throws ElfException, IOException {<FILL_FUNCTION_BODY>}
public boolean isUndef() {
return section_header_ndx == SHN_UNDEF;
}
@Override
public String toString() {
String typeString;
switch (getType()) {
case STT_NOTYPE:
case STT_OBJECT:
typeString = "object";
break;
case STT_FUNC:
typeString = "function";
break;
case STT_SECTION:
typeString = "section";
break;
case STT_FILE:
typeString = "file";
break;
case STT_LOPROC:
typeString = "loproc";
break;
case STT_HIPROC:
typeString = "hiproc";
break;
default:
typeString = "???";
break;
}
try {
return "ElfSymbol[name=" + getName() + ", type=" + typeString + ", size=" + size + "]";
} catch (IOException e) {
throw new RuntimeException(e);
}
}
} |
// Check to make sure this symbol has a name.
if (name_ndx == 0)
return null;
// Retrieve the name of the symbol from the correct string table.
String symbol_name = null;
if (stringTable != null) {
symbol_name = stringTable.get(name_ndx);
} else if (section_type == ElfSection.SHT_SYMTAB) {
symbol_name = elfHeader.getStringTable().get(name_ndx);
} else if (section_type == ElfSection.SHT_DYNSYM) {
symbol_name = elfHeader.getDynamicStringTable().get(name_ndx);
}
return symbol_name;
|
zhkl0228_unidbg | unidbg/unidbg-android/src/main/java/net/fornwall/jelf/MemoizedObject.java | MemoizedObject | getValue | class MemoizedObject<T> {
private boolean computed;
private T value;
/**
* Should compute the value of this memoized object. This will only be called once, upon the first call to
* {@link #getValue}.
*/
protected abstract T computeValue() throws ElfException, IOException;
/** Public accessor for the memoized value. */
public final T getValue() throws ElfException, IOException {<FILL_FUNCTION_BODY>}
@SuppressWarnings("unchecked")
public static <T> MemoizedObject<T>[] uncheckedArray(int size) {
return new MemoizedObject[size];
}
} |
if (!computed) {
value = computeValue();
computed = true;
}
return value;
|
zhkl0228_unidbg | unidbg/unidbg-android/src/main/java/net/fornwall/jelf/PtLoadData.java | PtLoadData | writeTo | class PtLoadData {
private final ByteBuffer buffer;
private final long dataSize;
PtLoadData(ByteBuffer buffer, long dataSize) {
this.buffer = buffer;
this.dataSize = dataSize;
}
public long getDataSize() {
return dataSize;
}
public void writeTo(final Pointer ptr) {<FILL_FUNCTION_BODY>}
} |
Pointer pointer = ptr;
byte[] buf = new byte[Math.min(0x1000, buffer.remaining())];
while (buffer.hasRemaining()) {
int write = Math.min(buf.length, buffer.remaining());
buffer.get(buf, 0, write);
pointer.write(0, buf, 0, write);
pointer = pointer.share(write);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/AssemblyCodeDumper.java | AssemblyCodeDumper | hook | class AssemblyCodeDumper implements CodeHook, TraceHook {
private final Emulator<?> emulator;
public AssemblyCodeDumper(Emulator<?> emulator, long begin, long end, TraceCodeListener listener) {
super();
this.emulator = emulator;
this.traceBegin = begin;
this.traceEnd = end;
this.listener = listener;
Memory memory = emulator.getMemory();
if (begin > end) {
maxLengthLibraryName = memory.getMaxLengthLibraryName().length();
} else {
int value = 0;
for (Module module : memory.getLoadedModules()) {
long min = Math.max(begin, module.base);
long max = Math.min(end, module.base + module.size);
if (min < max) {
int length = module.name.length();
if (length > value) {
value = length;
}
}
}
maxLengthLibraryName = value;
}
}
private final long traceBegin, traceEnd;
private final TraceCodeListener listener;
private final int maxLengthLibraryName;
private UnHook unHook;
@Override
public void onAttach(UnHook unHook) {
if (this.unHook != null) {
throw new IllegalStateException();
}
this.unHook = unHook;
}
@Override
public void detach() {
if (unHook != null) {
unHook.unhook();
unHook = null;
}
}
@Override
public void stopTrace() {
detach();
IOUtils.close(redirect);
redirect = null;
}
private boolean canTrace(long address) {
return (traceBegin > traceEnd || (address >= traceBegin && address <= traceEnd));
}
private PrintStream redirect;
@Override
public void setRedirect(PrintStream redirect) {
this.redirect = redirect;
}
private RegAccessPrinter lastInstructionWritePrinter;
@Override
public void hook(final Backend backend, final long address, final int size, Object user) {<FILL_FUNCTION_BODY>}
} |
if (canTrace(address)) {
try {
PrintStream out = System.err;
if (redirect != null) {
out = redirect;
}
Instruction[] insns = emulator.printAssemble(out, address, size, maxLengthLibraryName, new InstructionVisitor() {
@Override
public void visitLast(StringBuilder builder) {
if (lastInstructionWritePrinter != null) {
lastInstructionWritePrinter.print(emulator, backend, builder, address);
}
}
@Override
public void visit(StringBuilder builder, Instruction ins) {
RegsAccess regsAccess = ins.regsAccess();
if (regsAccess != null) {
short[] regsRead = regsAccess.getRegsRead();
RegAccessPrinter readPrinter = new RegAccessPrinter(address, ins, regsRead, false);
readPrinter.print(emulator, backend, builder, address);
short[] regWrite = regsAccess.getRegsWrite();
if (regWrite.length > 0) {
lastInstructionWritePrinter = new RegAccessPrinter(address + size, ins, regWrite, true);
}
}
}
});
if (listener != null) {
if (insns == null || insns.length != 1) {
throw new IllegalStateException("insns=" + Arrays.toString(insns));
}
listener.onInstruction(emulator, address, insns[0]);
}
} catch (BackendException e) {
throw new IllegalStateException(e);
}
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/Module.java | Module | findDependencySymbolByName | class Module {
public final String name;
public final long base;
public final long size;
private final LibraryFile libraryFile;
protected final Map<String, Module> neededLibraries;
private final List<MemRegion> regions;
public Module(String name, long base, long size, Map<String, Module> neededLibraries, List<MemRegion> regions, LibraryFile libraryFile) {
this.name = name;
this.base = base;
this.size = size;
this.neededLibraries = neededLibraries;
this.regions = regions;
this.libraryFile = libraryFile;
}
public long getFileSize() {
return libraryFile == null ? 0 : libraryFile.getFileSize();
}
public long getBaseHeader() {
return base;
}
public final List<MemRegion> getRegions() {
return Collections.unmodifiableList(regions);
}
public abstract Number callFunction(Emulator<?> emulator, long offset, Object... args);
public final Number callFunction(Emulator<?> emulator, String symbolName, Object... args) {
Symbol symbol = findSymbolByName(symbolName, false);
if (symbol == null) {
throw new IllegalStateException("find symbol failed: " + symbolName);
}
if (symbol.isUndef()) {
throw new IllegalStateException(symbolName + " is NOT defined");
}
return symbol.call(emulator, args);
}
public final Symbol findSymbolByName(String name) {
return findSymbolByName(name, true);
}
public abstract Symbol findSymbolByName(String name, boolean withDependencies);
public abstract Symbol findClosestSymbolByAddress(long address, boolean fast);
protected final Symbol findDependencySymbolByName(String name) {<FILL_FUNCTION_BODY>}
private int referenceCount;
public void addReferenceCount() {
referenceCount++;
}
public int decrementReferenceCount() {
return --referenceCount;
}
private boolean forceCallInit;
public boolean isForceCallInit() {
return forceCallInit;
}
@SuppressWarnings("unused")
public void setForceCallInit() {
this.forceCallInit = true;
}
public final void unload(Backend backend) {
for (MemRegion region : regions) {
backend.mem_unmap(region.begin, region.end - region.begin);
}
}
public Collection<Module> getNeededLibraries() {
return neededLibraries.values();
}
public Module getDependencyModule(String name) {
return neededLibraries.get(name);
}
protected long entryPoint;
public void setEntryPoint(long entryPoint) {
this.entryPoint = entryPoint;
}
public abstract int callEntry(Emulator<?> emulator, String... args);
private UnidbgPointer pathPointer;
public abstract String getPath();
/**
* 注册符号
* @param symbolName 符号名称
* @param address 符号的内存地址
*/
public abstract void registerSymbol(String symbolName, long address);
public final UnidbgPointer createPathMemory(SvcMemory svcMemory) {
if (this.pathPointer == null) {
byte[] bytes = getPath().getBytes(StandardCharsets.UTF_8);
byte[] path = Arrays.copyOf(bytes, bytes.length + 1);
this.pathPointer = svcMemory.allocate(path.length, "Module.path: " + getPath());
this.pathPointer.write(0, path, 0, path.length);
}
return this.pathPointer;
}
public static Number emulateFunction(Emulator<?> emulator, long address, Object... args) {
List<Number> list = new ArrayList<>(args.length);
for (Object arg : args) {
if (arg instanceof String) {
list.add(new StringNumber((String) arg));
} else if(arg instanceof byte[]) {
list.add(new ByteArrayNumber((byte[]) arg));
} else if (arg instanceof PointerArg) {
PointerArg pointerArg = (PointerArg) arg;
list.add(new PointerNumber((UnidbgPointer) pointerArg.getPointer()));
} else if (arg instanceof Number) {
list.add((Number) arg);
} else if(arg == null) {
list.add(new PointerNumber(null)); // null
} else {
throw new IllegalStateException("Unsupported arg: " + arg);
}
}
return emulator.eFunc(address, list.toArray(new Number[0]));
}
public boolean isVirtual() {
return false;
}
/**
* 返回-1表示找不到对应文件的偏移
* @param offset 内存偏移
*/
public abstract int virtualMemoryAddressToFileOffset(long offset);
protected InitFunctionListener initFunctionListener;
public void setInitFunctionListener(InitFunctionListener initFunctionListener) {
this.initFunctionListener = initFunctionListener;
}
} |
for (Module module : neededLibraries.values()) {
Symbol symbol = module.findSymbolByName(name, true);
if (symbol != null) {
return symbol;
}
}
return null;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/PointerNumber.java | PointerNumber | intValue | class PointerNumber extends Number {
private final UnidbgPointer value;
public PointerNumber(UnidbgPointer value) {
this.value = value;
}
@Override
public int intValue() {<FILL_FUNCTION_BODY>}
@Override
public long longValue() {
return this.value == null ? 0L : this.value.peer;
}
@Override
public float floatValue() {
throw new AbstractMethodError();
}
@Override
public double doubleValue() {
throw new AbstractMethodError();
}
@Override
public String toString() {
return String.valueOf(value);
}
} |
return this.value == null ? 0 : (int) this.value.toUIntPeer();
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/RegAccessPrinter.java | RegAccessPrinter | print | class RegAccessPrinter {
private final long address;
private final Instruction instruction;
private final short[] accessRegs;
private boolean forWriteRegs;
public RegAccessPrinter(long address, Instruction instruction, short[] accessRegs, boolean forWriteRegs) {
this.address = address;
this.instruction = instruction;
this.accessRegs = accessRegs;
this.forWriteRegs = forWriteRegs;
}
public void print(Emulator<?> emulator, Backend backend, StringBuilder builder, long address) {<FILL_FUNCTION_BODY>}
} |
if (this.address != address) {
return;
}
for (short reg : accessRegs) {
int regId = instruction.mapToUnicornReg(reg);
if (emulator.is32Bit()) {
if ((regId >= ArmConst.UC_ARM_REG_R0 && regId <= ArmConst.UC_ARM_REG_R12) ||
regId == ArmConst.UC_ARM_REG_LR || regId == ArmConst.UC_ARM_REG_SP ||
regId == ArmConst.UC_ARM_REG_CPSR) {
if (forWriteRegs) {
builder.append(" =>");
forWriteRegs = false;
}
if (regId == ArmConst.UC_ARM_REG_CPSR) {
Cpsr cpsr = Cpsr.getArm(backend);
builder.append(String.format(Locale.US, " cpsr: N=%d, Z=%d, C=%d, V=%d",
cpsr.isNegative() ? 1 : 0,
cpsr.isZero() ? 1 : 0,
cpsr.hasCarry() ? 1 : 0,
cpsr.isOverflow() ? 1 : 0));
} else {
int value = backend.reg_read(regId).intValue();
builder.append(' ').append(instruction.regName(reg)).append("=0x").append(Long.toHexString(value & 0xffffffffL));
}
}
} else {
if ((regId >= Arm64Const.UC_ARM64_REG_X0 && regId <= Arm64Const.UC_ARM64_REG_X28) ||
(regId >= Arm64Const.UC_ARM64_REG_X29 && regId <= Arm64Const.UC_ARM64_REG_SP)) {
if (forWriteRegs) {
builder.append(" =>");
forWriteRegs = false;
}
if (regId == Arm64Const.UC_ARM64_REG_NZCV) {
Cpsr cpsr = Cpsr.getArm64(backend);
if (cpsr.isA32()) {
builder.append(String.format(Locale.US, " cpsr: N=%d, Z=%d, C=%d, V=%d",
cpsr.isNegative() ? 1 : 0,
cpsr.isZero() ? 1 : 0,
cpsr.hasCarry() ? 1 : 0,
cpsr.isOverflow() ? 1 : 0));
} else {
builder.append(String.format(Locale.US, " nzcv: N=%d, Z=%d, C=%d, V=%d",
cpsr.isNegative() ? 1 : 0,
cpsr.isZero() ? 1 : 0,
cpsr.hasCarry() ? 1 : 0,
cpsr.isOverflow() ? 1 : 0));
}
} else {
long value = backend.reg_read(regId).longValue();
builder.append(' ').append(instruction.regName(reg)).append("=0x").append(Long.toHexString(value));
}
} else if (regId >= Arm64Const.UC_ARM64_REG_W0 && regId <= Arm64Const.UC_ARM64_REG_W30) {
if (forWriteRegs) {
builder.append(" =>");
forWriteRegs = false;
}
int value = backend.reg_read(regId).intValue();
builder.append(' ').append(instruction.regName(reg)).append("=0x").append(Long.toHexString(value & 0xffffffffL));
}
}
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/TraceMemoryHook.java | TraceMemoryHook | hook | class TraceMemoryHook implements ReadHook, WriteHook, TraceHook {
private final boolean read;
private final DateFormat dateFormat = new SimpleDateFormat("[HH:mm:ss SSS]");
public TraceMemoryHook(boolean read) {
this.read = read;
}
private PrintStream redirect;
TraceReadListener traceReadListener;
TraceWriteListener traceWriteListener;
private UnHook unHook;
@Override
public void onAttach(UnHook unHook) {
if (this.unHook != null) {
throw new IllegalStateException();
}
this.unHook = unHook;
}
@Override
public void detach() {
if (unHook != null) {
unHook.unhook();
unHook = null;
}
}
@Override
public void stopTrace() {
detach();
IOUtils.close(redirect);
redirect = null;
}
@Override
public void setRedirect(PrintStream redirect) {
this.redirect = redirect;
}
@Override
public void hook(Backend backend, long address, int size, Object user) {<FILL_FUNCTION_BODY>}
private void printMsg(String type, Emulator<?> emulator, long address, int size, String value) {
RegisterContext context = emulator.getContext();
UnidbgPointer pc = context.getPCPointer();
UnidbgPointer lr = context.getLRPointer();
PrintStream out = System.out;
if (redirect != null) {
out = redirect;
}
StringBuilder builder = new StringBuilder();
builder.append(type).append(Long.toHexString(address));
if (size > 0) {
builder.append(", data size = ").append(size).append(", data value = ").append(value);
}
builder.append(", PC=").append(pc).append(", LR=").append(lr);
out.println(builder);
}
@Override
public void hook(Backend backend, long address, int size, long value, Object user) {
if (read) {
return;
}
try {
Emulator<?> emulator = (Emulator<?>) user;
if (traceWriteListener == null || traceWriteListener.onWrite(emulator, address, size, value)) {
String str;
switch (size) {
case 1:
str = String.format("0x%02x", value & 0xff);
break;
case 2:
str = String.format("0x%04x", value & 0xffff);
break;
case 4:
str = String.format("0x%08x", value & 0xffffffffL);
break;
case 8:
str = String.format("0x%016x", value);
break;
default:
str = "0x" + Long.toHexString(value);
break;
}
printMsg(dateFormat.format(new Date()) + " Memory WRITE at 0x", emulator, address, size, str);
}
} catch (BackendException e) {
throw new IllegalStateException(e);
}
}
} |
if (!read) {
return;
}
try {
byte[] data = size == 0 ? new byte[0] : backend.mem_read(address, size);
String value;
switch (data.length) {
case 1:
value = String.format("0x%02x", ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN).get() & 0xff);
break;
case 2:
value = String.format("0x%04x", ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN).getShort() & 0xffff);
break;
case 4:
value = String.format("0x%08x", ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN).getInt() & 0xffffffffL);
break;
case 8:
value = String.format("0x%016x", ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN).getLong());
break;
default:
value = "0x" + Hex.encodeHexString(data);
break;
}
Emulator<?> emulator = (Emulator<?>) user;
if (traceReadListener == null || traceReadListener.onRead(emulator, address, data, value)) {
printMsg(dateFormat.format(new Date()) + " Memory READ at 0x", emulator, address, size, value);
}
} catch (BackendException e) {
throw new IllegalStateException(e);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/Utils.java | Utils | readFile | class Utils {
private static final Log log = LogFactory.getLog(Utils.class);
/** Returns val represented by the specified number of hex digits. */
private static String digits(long val, int digits) {
long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}
public static String toUUID(byte[] data) {
if (data == null) {
return null;
}
long msb = 0;
long lsb = 0;
assert data.length == 16 : "data must be 16 bytes in length";
for (int i=0; i<8; i++)
msb = (msb << 8) | (data[i] & 0xff);
for (int i=8; i<16; i++)
lsb = (lsb << 8) | (data[i] & 0xff);
long mostSigBits = msb;
long leastSigBits = lsb;
return (digits(mostSigBits >> 32, 8) + "-" +
digits(mostSigBits >> 16, 4) + "-" +
digits(mostSigBits, 4) + "-" +
digits(leastSigBits >> 48, 4) + "-" +
digits(leastSigBits, 12)).toUpperCase();
}
/**
* Reads an signed integer from {@code buffer}.
*/
public static long readSignedLeb128(ByteBuffer buffer, int size) {
int shift = 0;
long value = 0;
long b;
do {
b = buffer.get() & 0xff;
value |= ((b & 0x7f) << shift);
shift += 7;
} while((b & 0x80) != 0);
if (shift < size && ((b & 0x40) != 0)) {
value |= -(1L << shift);
}
return value;
}
public static BigInteger readULEB128(ByteBuffer buffer) {
BigInteger result = BigInteger.ZERO;
int shift = 0;
while (true) {
byte b = buffer.get();
result = result.or(BigInteger.valueOf(b & 0x7f).shiftLeft(shift));
if ((b & 0x80) == 0) {
break;
}
shift += 7;
}
return result;
}
public static ByteBuffer mapBuffer(File file) throws IOException {
try (FileInputStream inputStream = new FileInputStream(file); FileChannel channel = inputStream.getChannel()) {
return channel.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
}
}
public static int readFile(RandomAccessFile randomAccessFile, Pointer buffer, final int _count) {<FILL_FUNCTION_BODY>}
public static File getClassLocation(Class<?> clazz) {
return new File(clazz.getProtectionDomain().getCodeSource().getLocation().getPath());
}
public static long parseNumber(String str) {
if (str.startsWith("0x")) {
return Long.parseLong(str.substring(2).trim(), 16);
} else {
return Long.parseLong(str);
}
}
public static String decodeVectorRegister(byte[] data) {
if (data.length != 16) {
throw new IllegalStateException("data.length=" + data.length);
}
ByteBuffer buffer = ByteBuffer.allocate(16);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.put(data);
buffer.flip();
boolean twoDouble = false;
for (int i = 8; i < 16; i++) {
if (data[i] != 0) {
twoDouble = true;
break;
}
}
if (twoDouble) {
return String.format("(%s, %s)", buffer.getDouble(), buffer.getDouble());
}
boolean isDouble = false;
for (int i = 4; i < 8; i++) {
if (data[i] != 0) {
isDouble = true;
break;
}
}
return String.format("(%s)", isDouble ? buffer.getDouble() : buffer.getFloat());
}
} |
try {
int count = _count;
long remaining = randomAccessFile.length() - randomAccessFile.getFilePointer();
if (count > remaining) {
count = (int) remaining;
/*
* lseek() allows the file offset to be set beyond the end of the file
* (but this does not change the size of the file). If data is later
* written at this point, subsequent reads of the data in the gap (a
* "hole") return null bytes ('\0') until data is actually written into
* the gap.
*/
if (count < 0) {
log.warn("read path=" + randomAccessFile + ", fp=" + randomAccessFile.getFilePointer() + ", _count=" + _count + ", length=" + randomAccessFile.length() + ", buffer=" + buffer);
return 0;
}
}
int total = 0;
byte[] buf = new byte[Math.min(0x1000, count)];
Pointer pointer = buffer;
while (total < count) {
int read = randomAccessFile.read(buf, 0, Math.min(buf.length, count - total));
if (read <= 0) {
if (log.isDebugEnabled()) {
log.debug("read path=" + randomAccessFile + ", fp=" + randomAccessFile.getFilePointer() + ", read=" + read + ", length=" + randomAccessFile.length() + ", buffer=" + buffer);
}
return total;
}
if (randomAccessFile.getFilePointer() > randomAccessFile.length()) {
throw new IllegalStateException("fp=" + randomAccessFile.getFilePointer() + ", length=" + randomAccessFile.length());
}
if(read > buf.length) {
throw new IllegalStateException("count=" + buf.length + ", read=" + read);
}
if (log.isDebugEnabled()) {
Inspector.inspect(buf, "read path=" + randomAccessFile + ", fp=" + randomAccessFile.getFilePointer() + ", read=" + read + ", length=" + randomAccessFile.length() + ", buffer=" + buffer);
}
pointer.write(0, buf, 0, read);
total += read;
pointer = pointer.share(read);
}
return total;
} catch (IOException e) {
throw new IllegalStateException();
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/ARMSvcMemory.java | ARMSvcMemory | registerSvc | class ARMSvcMemory implements SvcMemory {
private static final Log log = LogFactory.getLog(ARMSvcMemory.class);
private final Emulator<?> emulator;
private UnidbgPointer base;
public ARMSvcMemory(long base, int size, Emulator<?> emulator) {
this.emulator = emulator;
this.base = UnidbgPointer.pointer(emulator, base);
assert this.base != null;
this.base.setSize(size);
this.baseAddr = base;
this.size = size;
Backend backend = emulator.getBackend();
backend.mem_map(base, size, UnicornConst.UC_PROT_READ | UnicornConst.UC_PROT_EXEC);
}
@Override
public void serialize(DataOutput out) {
throw new UnsupportedOperationException();
}
private final long baseAddr;
private final int size;
@Override
public long getBase() {
return baseAddr;
}
@Override
public int getSize() {
return size;
}
private final List<MemRegion> memRegions = new ArrayList<>();
@Override
public MemRegion findRegion(long addr) {
if (addr >= baseAddr && addr < baseAddr + size) {
for (MemRegion region : memRegions) {
if (addr >= region.begin && addr < region.end) {
return region;
}
}
}
return null;
}
@Override
public UnidbgPointer allocate(int size, final String label) {
size = ARM.alignSize(size);
UnidbgPointer pointer = base.share(0, size);
base = (UnidbgPointer) base.share(size);
if (log.isDebugEnabled()) {
log.debug("allocate size=" + size + ", label=" + label + ", base=" + base);
}
memRegions.add(new MemRegion(pointer.peer, pointer.peer, pointer.peer + size, UnicornConst.UC_PROT_READ | UnicornConst.UC_PROT_EXEC, null, 0) {
@Override
public String getName() {
return label;
}
});
return pointer;
}
private final Map<String, UnidbgPointer> symbolMap = new HashMap<>();
@Override
public UnidbgPointer allocateSymbolName(String name) {
UnidbgPointer ptr = symbolMap.get(name);
if (ptr == null) {
byte[] nameBytes = name.getBytes();
int size = nameBytes.length + 1;
ptr = allocate(size, "Symbol." + name);
ptr.write(0, Arrays.copyOf(nameBytes, size), 0, size);
symbolMap.put(name, ptr);
}
return ptr;
}
private int thumbSvcNumber = 0;
private int armSvcNumber = 0xff;
private final Map<Integer, Svc> svcMap = new HashMap<>();
@Override
public Svc getSvc(int svcNumber) {
return svcMap.get(svcNumber);
}
@Override
public UnidbgPointer registerSvc(Svc svc) {<FILL_FUNCTION_BODY>}
@Override
public final UnidbgPointer writeStackString(String str) {
byte[] data = str.getBytes(StandardCharsets.UTF_8);
return writeStackBytes(Arrays.copyOf(data, data.length + 1));
}
@Override
public final UnidbgPointer writeStackBytes(byte[] data) {
UnidbgPointer pointer = allocate(data.length, "writeStackBytes: " + Hex.encodeHexString(data));
assert pointer != null;
pointer.write(0, data, 0, data.length);
return pointer;
}
} |
final int number;
if (svc instanceof ThumbSvc) {
if (emulator.is64Bit()) {
throw new IllegalStateException("is 64 bit mode");
}
if (++thumbSvcNumber == SyscallHandler.DARWIN_SWI_SYSCALL) {
thumbSvcNumber++;
}
number = thumbSvcNumber;
} else if (svc instanceof ArmSvc || svc instanceof Arm64Svc) {
if (svc instanceof ArmSvc && emulator.is64Bit()) {
throw new IllegalStateException("is 64 bit mode");
}
if (svc instanceof Arm64Svc && !emulator.is64Bit()) {
throw new IllegalStateException("is 32 bit mode");
}
if (++armSvcNumber == SyscallHandler.DARWIN_SWI_SYSCALL) {
armSvcNumber++;
}
number = armSvcNumber;
} else {
throw new IllegalStateException("svc=" + svc);
}
if (svcMap.put(number, svc) != null) {
throw new IllegalStateException();
}
return svc.onRegister(this, number);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/Arm64Hook.java | Arm64Hook | onRegister | class Arm64Hook extends Arm64Svc {
private static final Log log = LogFactory.getLog(Arm64Hook.class);
private final boolean enablePostCall;
protected Arm64Hook() {
this(false);
}
protected Arm64Hook(boolean enablePostCall) {
this.enablePostCall = enablePostCall;
}
@SuppressWarnings("unused")
public Arm64Hook(String name, boolean enablePostCall) {
super(name);
this.enablePostCall = enablePostCall;
}
@Override
public final UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {<FILL_FUNCTION_BODY>}
@Override
public void handlePostCallback(Emulator<?> emulator) {
super.handlePostCallback(emulator);
if (regContext == null) {
throw new IllegalStateException();
} else {
regContext.restore();
}
}
private RegContext regContext;
@Override
public final long handle(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
if (enablePostCall) {
regContext = RegContext.backupContext(emulator, Arm64Const.UC_ARM64_REG_X29,
Arm64Const.UC_ARM64_REG_X30);
}
UnidbgPointer sp = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_SP);
try {
HookStatus status = doHook(emulator);
if (status.forward || !enablePostCall) {
sp = sp.share(-8, 0);
sp.setLong(0, status.jump);
} else {
sp = sp.share(-8, 0);
sp.setLong(0, 0);
}
return status.returnValue;
} finally {
backend.reg_write(Arm64Const.UC_ARM64_REG_SP, sp.peer);
}
}
private HookStatus doHook(Emulator<?> emulator) {
try {
return hook(emulator);
} catch (NestedRun run) {
return HookStatus.RET(emulator, run.pc);
}
}
protected abstract HookStatus hook(Emulator<?> emulator) throws NestedRun;
} |
byte[] code;
if (enablePostCall) {
try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm64, KeystoneMode.LittleEndian)) {
KeystoneEncoded encoded = keystone.assemble(Arrays.asList(
"svc #0x" + Integer.toHexString(svcNumber),
"ldr x13, [sp]",
"add sp, sp, #0x8",
"cmp x13, #0",
"b.eq #0x30",
"blr x13",
"mov x8, #0",
"mov x12, #0x" + Integer.toHexString(svcNumber),
"mov x16, #0x" + Integer.toHexString(Svc.POST_CALLBACK_SYSCALL_NUMBER),
"svc #0",
"ret"));
code = encoded.getMachineCode();
}
} else {
ByteBuffer buffer = ByteBuffer.allocate(12);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(Arm64Svc.assembleSvc(svcNumber)); // svc #0xsvcNumber
buffer.putInt(0xf84087f1); // ldr x17, [sp], #0x8
buffer.putInt(0xd61f0220); // br x17: manipulated stack in handle
code = buffer.array();
}
String name = getName();
UnidbgPointer pointer = svcMemory.allocate(code.length, name == null ? "Arm64Hook" : name);
pointer.write(0, code, 0, code.length);
if (log.isDebugEnabled()) {
log.debug("ARM64 hook: pointer=" + pointer);
}
return pointer;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/Arm64Svc.java | Arm64Svc | register | class Arm64Svc implements Svc {
private static final Log log = LogFactory.getLog(Arm64Svc.class);
public static final int SVC_MAX = 0xffff;
public static int assembleSvc(int svcNumber) {
if (svcNumber >= 0 && svcNumber < SVC_MAX - 1) {
return 0xd4000001 | (svcNumber << 5);
} else {
throw new IllegalStateException("svcNumber=0x" + Integer.toHexString(svcNumber));
}
}
private final String name;
public Arm64Svc() {
this(null);
}
public Arm64Svc(String name) {
this.name = name;
}
@Override
public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
if (log.isDebugEnabled()) {
log.debug("onRegister: " + getClass(), new Exception("svcNumber=0x" + Integer.toHexString(svcNumber)));
}
String name = getName();
return register(svcMemory, svcNumber, name == null ? "Arm64Svc" : name);
}
private static UnidbgPointer register(SvcMemory svcMemory, int svcNumber, String name) {<FILL_FUNCTION_BODY>}
@Override
public void handlePostCallback(Emulator<?> emulator) {
}
@Override
public void handlePreCallback(Emulator<?> emulator) {
}
@Override
public String getName() {
return name;
}
} |
ByteBuffer buffer = ByteBuffer.allocate(8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(assembleSvc(svcNumber)); // "svc #0x" + Integer.toHexString(svcNumber)
buffer.putInt(0xd65f03c0); // ret
byte[] code = buffer.array();
UnidbgPointer pointer = svcMemory.allocate(code.length, name);
pointer.write(0, code, 0, code.length);
return pointer;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/ArmHook.java | ArmHook | doHook | class ArmHook extends ArmSvc {
private static final Log log = LogFactory.getLog(ArmHook.class);
private final boolean enablePostCall;
protected ArmHook() {
this(false);
}
protected ArmHook(boolean enablePostCall) {
this.enablePostCall = enablePostCall;
}
@SuppressWarnings("unused")
public ArmHook(String name, boolean enablePostCall) {
super(name);
this.enablePostCall = enablePostCall;
}
@Override
public final UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
byte[] code;
if (enablePostCall) {
try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm, KeystoneMode.Arm)) {
KeystoneEncoded encoded = keystone.assemble(Arrays.asList(
"svc #0x" + Integer.toHexString(svcNumber),
"pop {r7}",
"cmp r7, #0",
"bxeq lr",
"blx r7",
"mov r7, #0",
"mov r5, #0x" + Integer.toHexString(Svc.POST_CALLBACK_SYSCALL_NUMBER),
"mov r4, #0x" + Integer.toHexString(svcNumber),
"svc #0",
"bx lr"));
code = encoded.getMachineCode();
}
} else {
ByteBuffer buffer = ByteBuffer.allocate(8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(ArmSvc.assembleSvc(svcNumber)); // svc #0xsvcNumber
buffer.putInt(0xe49df004); // pop {pc}: manipulated stack in handle
code = buffer.array();
}
String name = getName();
UnidbgPointer pointer = svcMemory.allocate(code.length, name == null ? "ArmHook" : name);
pointer.write(0, code, 0, code.length);
if (log.isDebugEnabled()) {
log.debug("ARM hook: pointer=" + pointer);
}
return pointer;
}
@Override
public void handlePostCallback(Emulator<?> emulator) {
super.handlePostCallback(emulator);
if (regContext == null) {
throw new IllegalStateException();
} else {
regContext.restore();
}
}
private RegContext regContext;
@Override
public final long handle(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
if (enablePostCall) {
regContext = RegContext.backupContext(emulator, ArmConst.UC_ARM_REG_R4,
ArmConst.UC_ARM_REG_R5,
ArmConst.UC_ARM_REG_R6,
ArmConst.UC_ARM_REG_R7,
ArmConst.UC_ARM_REG_LR);
}
UnidbgPointer sp = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_SP);
try {
HookStatus status = doHook(emulator);
if (status.forward || !enablePostCall) {
sp = sp.share(-4, 0);
sp.setInt(0, (int) status.jump);
} else {
sp = sp.share(-4, 0);
sp.setInt(0, 0);
}
return status.returnValue;
} finally {
backend.reg_write(ArmConst.UC_ARM_REG_SP, sp.peer);
}
}
private HookStatus doHook(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
protected abstract HookStatus hook(Emulator<?> emulator) throws NestedRun;
} |
try {
return hook(emulator);
} catch (NestedRun run) {
return HookStatus.RET(emulator, run.pc);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/ArmSvc.java | ArmSvc | assembleSvc | class ArmSvc implements Svc {
public static final int SVC_MAX = 0xffffff;
public static int assembleSvc(int svcNumber) {<FILL_FUNCTION_BODY>}
private final String name;
public ArmSvc() {
this(null);
}
public ArmSvc(String name) {
this.name = name;
}
@Override
public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
ByteBuffer buffer = ByteBuffer.allocate(8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(assembleSvc(svcNumber)); // svc #svcNumber
buffer.putInt(0xe12fff1e); // bx lr
byte[] code = buffer.array();
String name = getName();
UnidbgPointer pointer = svcMemory.allocate(code.length, name == null ? "ArmSvc" : name);
pointer.write(code);
return pointer;
}
@Override
public void handlePostCallback(Emulator<?> emulator) {
}
@Override
public void handlePreCallback(Emulator<?> emulator) {
}
@Override
public String getName() {
return name;
}
} |
if (svcNumber >= 0 && svcNumber < SVC_MAX - 1) {
return 0xef000000 | svcNumber;
} else {
throw new IllegalStateException("svcNumber=0x" + Integer.toHexString(svcNumber));
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/CodeHistory.java | CodeHistory | disassemble | class CodeHistory {
public final long address;
private final int size;
final boolean thumb;
CodeHistory(long address, int size, boolean thumb) {
this.address = address;
this.size = size;
this.thumb = thumb;
}
Instruction[] disassemble(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
if (size <= 1) {
return null;
}
Backend backend = emulator.getBackend();
try {
byte[] code = backend.mem_read(address, size);
return emulator.disassemble(address, code, thumb, 0);
} catch(BackendException e) {
return null;
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/Cpsr.java | Cpsr | setZero | class Cpsr {
private static boolean hasBit(int value, int offset) {
return ((value >> offset) & 1) == 1;
}
private void setBit(int offset) {
int mask = 1 << offset;
value |= mask;
backend.reg_write(regId, value);
}
private void clearBit(int offset) {
int mask = ~(1 << offset);
value &= mask;
backend.reg_write(regId, value);
}
public static Cpsr getArm(Backend backend) {
return new Cpsr(backend, ArmConst.UC_ARM_REG_CPSR);
}
public static Cpsr getArm64(Backend backend) {
return new Cpsr(backend, Arm64Const.UC_ARM64_REG_NZCV);
}
private final Backend backend;
private final int regId;
private int value;
private Cpsr(Backend backend, int regId) {
this.backend = backend;
this.regId = regId;
this.value = backend.reg_read(regId).intValue();
}
public int getValue() {
return value;
}
private static final int A32_BIT = 4;
public boolean isA32() {
return hasBit(value, A32_BIT);
}
private static final int THUMB_BIT = 5;
public boolean isThumb() {
return hasBit(value, THUMB_BIT);
}
private static final int NEGATIVE_BIT = 31;
public boolean isNegative() {
return hasBit(value, NEGATIVE_BIT);
}
void setNegative(boolean on) {
if (on) {
setBit(NEGATIVE_BIT);
} else {
clearBit(NEGATIVE_BIT);
}
}
private static final int ZERO_BIT = 30;
public boolean isZero() {
return hasBit(value, ZERO_BIT);
}
void setZero(boolean on) {<FILL_FUNCTION_BODY>}
private static final int CARRY_BIT = 29;
/**
* 进位或借位
*/
public boolean hasCarry() {
return hasBit(value, CARRY_BIT);
}
public void setCarry(boolean on) {
if (on) {
setBit(CARRY_BIT);
} else {
clearBit(CARRY_BIT);
}
}
private static final int OVERFLOW_BIT = 28;
public boolean isOverflow() {
return hasBit(value, OVERFLOW_BIT);
}
void setOverflow(boolean on) {
if (on) {
setBit(OVERFLOW_BIT);
} else {
clearBit(OVERFLOW_BIT);
}
}
private static final int MODE_MASK = 0x1f;
public int getMode() {
return value & MODE_MASK;
}
public int getEL() {
return (value >> 2) & 3;
}
public final void switchUserMode() {
value &= ~MODE_MASK;
value |= ARMEmulator.USR_MODE;
backend.reg_write(regId, value);
}
} |
if (on) {
setBit(ZERO_BIT);
} else {
clearBit(ZERO_BIT);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/FunctionCall.java | FunctionCall | toReadableString | class FunctionCall {
public final long callerAddress;
public final long functionAddress;
public final long returnAddress;
public final Number[] args;
public FunctionCall(long callerAddress, long functionAddress, long returnAddress, Number[] args) {
this.callerAddress = callerAddress;
this.functionAddress = functionAddress;
this.returnAddress = returnAddress;
this.args = args;
}
public String toReadableString(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
return "FunctionCall{" +
"callerAddress=" + UnidbgPointer.pointer(emulator, callerAddress) +
", functionAddress=" + UnidbgPointer.pointer(emulator, functionAddress) +
", returnAddress=" + UnidbgPointer.pointer(emulator, returnAddress) +
'}';
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/HookStatus.java | HookStatus | LR | class HookStatus {
final long returnValue;
final long jump;
final boolean forward;
private HookStatus(long returnValue, long jump, boolean forward) {
this.returnValue = returnValue;
this.jump = jump;
this.forward = forward;
}
public static HookStatus RET(Emulator<?> emulator, long pc) {
RegisterContext context = emulator.getContext();
return new HookStatus(context.getLongArg(0), pc, true);
}
public static HookStatus LR(Emulator<?> emulator, long returnValue) {<FILL_FUNCTION_BODY>}
} |
RegisterContext context = emulator.getContext();
return new HookStatus(returnValue, context.getLR(), false);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/InlineHook.java | InlineHook | simpleArmHook | class InlineHook {
/**
* 只能hook thumb指令: PUSH {R4-R7,LR}，即函数入口
*/
public static void simpleThumbHook(Emulator<?> emulator, long address, final HookCallback callback) {
final Backend backend = emulator.getBackend();
final Pointer pointer = UnidbgPointer.pointer(emulator, address);
if (pointer == null) {
throw new IllegalArgumentException();
}
try (Disassembler disassembler = DisassemblerFactory.createArmDisassembler(true)) {
disassembler.setDetail(true);
byte[] code = readThumbCode(pointer);
Instruction[] insns = disassembler.disasm(code, 0, 1);
if (insns == null || insns.length < 1) {
throw new IllegalArgumentException("Invalid hook address: " + pointer);
}
Instruction insn = insns[0];
String asm = insn.toString();
if (!"push {r4, r5, r6, r7, lr}".equals(asm)) {
throw new IllegalArgumentException("Invalid hook address: " + pointer + ", asm: " + asm);
}
emulator.getSvcMemory().registerSvc(new ThumbSvc() {
@Override
public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
if (svcNumber < 0 || svcNumber > 0xff) {
throw new IllegalStateException("service number out of range");
}
try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm, KeystoneMode.ArmThumb)) {
KeystoneEncoded encoded = keystone.assemble(Arrays.asList(
"svc #0x" + Integer.toHexString(svcNumber),
"mov pc, lr"));
byte[] code = encoded.getMachineCode();
pointer.write(0, code, 0, code.length);
return null;
}
}
@Override
public long handle(Emulator<?> emulator) {
if (callback != null) {
return callback.onHook(emulator);
}
return backend.reg_read(ArmConst.UC_ARM_REG_R0).intValue();
}
});
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
/**
* 只能hook arm指令：STMFD SP!, {R4-R9,LR}或STMFD SP!, {R4-R11,LR}，即函数入口
*/
public static void simpleArmHook(Emulator<?> emulator, long address, final HookCallback callback) {<FILL_FUNCTION_BODY>}
private static byte[] readThumbCode(Pointer pointer) {
short ins = pointer.getShort(0);
if(ARM.isThumb32(ins)) { // thumb32
return pointer.getByteArray(0, 4);
} else {
return pointer.getByteArray(0, 2);
}
}
} |
final Pointer pointer = UnidbgPointer.pointer(emulator, address);
if (pointer == null) {
throw new IllegalArgumentException();
}
try (Disassembler disassembler = DisassemblerFactory.createArmDisassembler(false)) {
disassembler.setDetail(true);
byte[] code = pointer.getByteArray(0, 4);
Instruction[] insns = disassembler.disasm(code, 0, 1);
if (insns == null || insns.length < 1) {
throw new IllegalArgumentException("Invalid hook address: " + pointer);
}
Instruction insn = insns[0];
String asm = insn.toString();
if (!"push {r4, r5, r6, r7, r8, sb, lr}".equals(asm) && !"push {r4, r5, r6, r7, r8, sb, sl, fp, lr}".equals(asm)) {
throw new IllegalArgumentException("Invalid hook address: " + pointer + ", asm: " + asm);
}
emulator.getSvcMemory().registerSvc(new ArmSvc() {
@Override
public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm, KeystoneMode.Arm)) {
KeystoneEncoded encoded = keystone.assemble(Arrays.asList(
"svc #0x" + Integer.toHexString(svcNumber),
"mov pc, lr"));
byte[] code = encoded.getMachineCode();
pointer.write(0, code, 0, code.length);
return null;
}
}
@Override
public long handle(Emulator<?> emulator) {
if (callback != null) {
return callback.onHook(emulator);
}
return emulator.getBackend().reg_read(ArmConst.UC_ARM_REG_R0).intValue();
}
});
} catch (IOException e) {
throw new IllegalStateException(e);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/RegContext.java | RegContext | restore | class RegContext {
public static RegContext backupContext(Emulator<?> emulator, int... regs) {
Map<Integer, UnidbgPointer> ctx = new HashMap<>();
for (int reg : regs) {
ctx.put(reg, UnidbgPointer.register(emulator, reg));
}
return new RegContext(emulator.getBackend(), ctx);
}
private final Backend backend;
private final Map<Integer, UnidbgPointer> ctx;
private RegContext(Backend backend, Map<Integer, UnidbgPointer> ctx) {
this.backend = backend;
this.ctx = ctx;
}
public void restore() {<FILL_FUNCTION_BODY>}
} |
for (Map.Entry<Integer, UnidbgPointer> entry : ctx.entrySet()) {
UnidbgPointer ptr = entry.getValue();
backend.reg_write(entry.getKey(), ptr == null ? 0 : ptr.peer);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/ThumbSvc.java | ThumbSvc | assembleSvc | class ThumbSvc implements Svc {
public static final int SVC_MAX = 0xff;
public static short assembleSvc(int svcNumber) {<FILL_FUNCTION_BODY>}
private final String name;
public ThumbSvc() {
this(null);
}
public ThumbSvc(String name) {
this.name = name;
}
@Override
public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {
ByteBuffer buffer = ByteBuffer.allocate(4);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putShort(assembleSvc(svcNumber)); // svc #svcNumber
buffer.putShort((short) 0x4770); // bx lr
byte[] code = buffer.array();
String name = getName();
UnidbgPointer pointer = svcMemory.allocate(code.length, name == null ? "ThumbSvc" : name);
pointer.write(code);
return pointer;
}
@Override
public void handlePostCallback(Emulator<?> emulator) {
}
@Override
public void handlePreCallback(Emulator<?> emulator) {
}
@Override
public String getName() {
return name;
}
} |
if (svcNumber >= 0 && svcNumber < SVC_MAX - 1) {
return (short) (0xdf00 | svcNumber);
} else {
throw new IllegalStateException("svcNumber=0x" + Integer.toHexString(svcNumber));
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/TraceFunctionCall.java | TraceFunctionCall | hook | class TraceFunctionCall implements CodeHook {
private static final Log log = LogFactory.getLog(TraceFunctionCall.class);
protected final Emulator<?> emulator;
private final FunctionCallListener listener;
TraceFunctionCall(Emulator<?> emulator, FunctionCallListener listener) {
this.emulator = emulator;
this.listener = listener;
}
final void pushFunction(long callerAddress, long functionAddress, long returnAddress, Number[] args) {
RunnableTask runningTask = emulator.getThreadDispatcher().getRunningTask();
FunctionCall call = new FunctionCall(callerAddress, functionAddress, returnAddress, args);
runningTask.pushFunction(emulator, call);
listener.onDebugPushFunction(emulator, call);
listener.onCall(emulator, callerAddress, functionAddress);
}
private boolean detectedIllegalState;
@Override
public void hook(Backend backend, long address, int size, Object user) {<FILL_FUNCTION_BODY>}
protected abstract Instruction disassemble(long address, int size);
protected abstract void onInstruction(Instruction instruction);
private UnHook unHook;
@Override
public void onAttach(UnHook unHook) {
this.unHook = unHook;
}
@Override
public void detach() {
if (unHook != null) {
unHook.unhook();
unHook = null;
}
}
} |
if (detectedIllegalState) {
return;
}
RunnableTask runningTask = emulator.getThreadDispatcher().getRunningTask();
FunctionCall call = runningTask.popFunction(emulator, address);
if (call != null) {
listener.onDebugPopFunction(emulator, address, call);
if (call.returnAddress != address) {
log.warn("Illegal state address=" + UnidbgPointer.pointer(emulator, address) + ", call=" + call.toReadableString(emulator));
if (LogFactory.getLog(AbstractEmulator.class).isDebugEnabled() ||
LogFactory.getLog(BaseTask.class).isDebugEnabled()) {
emulator.attach().debug();
}
detectedIllegalState = true;
return;
} else {
listener.postCall(emulator, call.callerAddress, call.functionAddress, call.args);
}
}
try {
Instruction instruction = disassemble(address, size);
if (instruction != null) {
if (log.isDebugEnabled()) {
if (!instruction.getMnemonic().startsWith("bl")) {
log.warn(Inspector.inspectString(backend.mem_read(address, size), "Invalid " + instruction + ": thumb=" + ARM.isThumb(backend)));
}
}
onInstruction(instruction);
} else if (log.isDebugEnabled()) {
Instruction[] instructions = emulator.disassemble(address, size, 1);
if (instructions.length != 1) {
return;
}
instruction = instructions[0];
String mnemonic = instruction.getMnemonic();
if (emulator.is32Bit()) {
if (mnemonic.startsWith("bl") &&
!mnemonic.startsWith("ble") &&
!mnemonic.startsWith("blt") &&
!mnemonic.startsWith("bls") &&
!mnemonic.startsWith("blo")) {
log.warn(Inspector.inspectString(backend.mem_read(address, size), "Unsupported " + instruction + ": thumb=" + ARM.isThumb(backend)));
}
} else {
if (mnemonic.startsWith("bl")) {
log.warn(Inspector.inspectString(backend.mem_read(address, size), "Unsupported " + instruction + ": thumb=" + ARM.isThumb(backend)));
}
}
}
} catch (BackendException e) {
throw new IllegalStateException(e);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/TraceFunctionCall32.java | TraceFunctionCall32 | disassemble | class TraceFunctionCall32 extends TraceFunctionCall {
public TraceFunctionCall32(Emulator<?> emulator, FunctionCallListener listener) {
super(emulator, listener);
}
@Override
protected Instruction disassemble(long address, int size) {<FILL_FUNCTION_BODY>}
private static final int ARM_BL_IMM_MASK = 0xf000000;
private static final int ARM_BL_IMM = 0xb000000; // BL, BLX (immediate)
private static final int ARM_BL_REG_MASK = ~0xf000000f;
private static final int ARM_BL_REG = 0x12fff30; // BLX<c> <Rm>
private Instruction disassembleArm(long address, int size) {
if (size != 4) {
throw new IllegalStateException();
}
byte[] code = emulator.getBackend().mem_read(address, 4);
ByteBuffer buffer = ByteBuffer.wrap(code).order(ByteOrder.LITTLE_ENDIAN);
int value = buffer.getInt();
if ((value & ARM_BL_IMM_MASK) == ARM_BL_IMM ||
(value & 0xfe000000) == 0xfa000000) { // Encoding A2: BLX <label>
Instruction[] instructions = emulator.disassemble(address, code, false, 1);
return instructions[0];
}
if ((value & ARM_BL_REG_MASK) == ARM_BL_REG) {
Instruction[] instructions = emulator.disassemble(address, code, false, 1);
return instructions[0];
}
return null;
}
private static final int THUMB_BL_IMM_MASK = 0xf800c000;
private static final int THUMB_BL_IMM = 0xf000c000; // BL, BLX (immediate)
private static final short THUMB_BL_REG_MASK = ~0x78;
private static final short THUMB_BL_REG = 0x4780; // BLX<c> <Rm>
private Instruction disassembleThumb(long address, int size) {
byte[] code = emulator.getBackend().mem_read(address, size);
if (size == 4) { // thumb2
ByteBuffer buffer = ByteBuffer.wrap(code).order(ByteOrder.LITTLE_ENDIAN);
int t1 = buffer.getShort() & 0xffff;
int t2 = buffer.getShort() & 0xffff;
int value = (t1 << 16) | t2;
if ((value & THUMB_BL_IMM_MASK) == THUMB_BL_IMM) {
Instruction[] instructions = emulator.disassemble(address, code, true, 1);
return instructions[0];
}
} else if (size == 2) {
ByteBuffer buffer = ByteBuffer.wrap(code).order(ByteOrder.LITTLE_ENDIAN);
short value = buffer.getShort();
if ((value & THUMB_BL_REG_MASK) == THUMB_BL_REG) {
Instruction[] instructions = emulator.disassemble(address, code, true, 1);
return instructions[0];
}
} else {
throw new IllegalStateException();
}
return null;
}
@Override
protected void onInstruction(Instruction instruction) {
String mnemonic = instruction.getMnemonic();
RegisterContext context = emulator.getContext();
if ("bl".equals(mnemonic) || "blx".equals(mnemonic)) {
OpInfo operands = (OpInfo) instruction.getOperands();
Operand operand = operands.getOperands()[0];
final long functionAddress;
switch (operand.getType()) {
case capstone.Arm_const.ARM_OP_IMM:
functionAddress = operand.getValue().getImm();
break;
case capstone.Arm_const.ARM_OP_REG:
functionAddress = context.getIntByReg(instruction.mapToUnicornReg(operand.getValue().getReg()));
break;
default:
throw new UnsupportedOperationException("type=" + operand.getType());
}
Number[] args = new Number[4];
for (int i = 0; i < args.length; i++) {
args[i] = context.getIntArg(i);
}
pushFunction(instruction.getAddress(), functionAddress, instruction.getAddress() + instruction.getSize(), args);
} else {
throw new UnsupportedOperationException();
}
}
} |
Backend backend = emulator.getBackend();
boolean thumb = ARM.isThumb(backend);
if (thumb) {
return disassembleThumb(address, size);
} else {
return disassembleArm(address, size);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/TraceFunctionCall64.java | TraceFunctionCall64 | onInstruction | class TraceFunctionCall64 extends TraceFunctionCall {
public TraceFunctionCall64(Emulator<?> emulator, FunctionCallListener listener) {
super(emulator, listener);
}
private static final int BL_MASK = ~0x3ffffff;
private static final int BL = 0x94000000; // BL <label>
private static final int BLR_MASK = ~0x3e0;
private static final int BLR = 0xd63f0000; // BLR <Xn>
@Override
protected Instruction disassemble(long address, int size) {
if (size != 4) {
throw new IllegalStateException();
}
byte[] code = emulator.getBackend().mem_read(address, 4);
ByteBuffer buffer = ByteBuffer.wrap(code).order(ByteOrder.LITTLE_ENDIAN);
int value = buffer.getInt();
if ((value & BL_MASK) == BL) {
Instruction[] instructions = emulator.disassemble(address, code, false, 1);
return instructions[0];
}
if ((value & BLR_MASK) == BLR) {
Instruction[] instructions = emulator.disassemble(address, code, false, 1);
return instructions[0];
}
return null;
}
@Override
protected void onInstruction(Instruction instruction) {<FILL_FUNCTION_BODY>}
} |
String mnemonic = instruction.getMnemonic();
RegisterContext context = emulator.getContext();
if ("bl".equals(mnemonic) || "blr".equals(mnemonic)) {
OpInfo operands = (OpInfo) instruction.getOperands();
Operand operand = operands.getOperands()[0];
final long functionAddress;
switch (operand.getType()) {
case capstone.Arm64_const.ARM64_OP_IMM:
functionAddress = operand.getValue().getImm();
break;
case capstone.Arm64_const.ARM64_OP_REG:
functionAddress = context.getLongByReg(instruction.mapToUnicornReg(operand.getValue().getReg()));
break;
default:
throw new UnsupportedOperationException("type=" + operand.getType());
}
Number[] args = new Number[8];
for (int i = 0; i < args.length; i++) {
args[i] = context.getLongArg(i);
}
pushFunction(instruction.getAddress(), functionAddress, instruction.getAddress() + instruction.getSize(), args);
} else {
throw new UnsupportedOperationException();
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/backend/BackendFactory.java | BackendFactory | createBackend | class BackendFactory {
private final boolean fallbackUnicorn;
protected BackendFactory(boolean fallbackUnicorn) {
this.fallbackUnicorn = fallbackUnicorn;
}
private Backend newBackend(Emulator<?> emulator, boolean is64Bit) {
try {
return newBackendInternal(emulator, is64Bit);
} catch (Throwable e) {
if (fallbackUnicorn) {
return null;
} else {
throw e;
}
}
}
protected abstract Backend newBackendInternal(Emulator<?> emulator, boolean is64Bit);
public static Backend createBackend(Emulator<?> emulator, boolean is64Bit, Collection<BackendFactory> backendFactories) {<FILL_FUNCTION_BODY>}
} |
if (backendFactories != null) {
for (BackendFactory factory : backendFactories) {
Backend backend = factory.newBackend(emulator, is64Bit);
if (backend != null) {
return backend;
}
}
}
return new UnicornBackend(emulator, is64Bit);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/backend/FastBackend.java | FastBackend | addBreakPoint | class FastBackend extends AbstractBackend {
protected final Emulator<?> emulator;
public FastBackend(Emulator<?> emulator) {
this.emulator = emulator;
}
private static class SoftBreakPoint implements BreakPoint {
final long address;
final byte[] backup;
final BreakPointCallback callback;
final boolean thumb;
SoftBreakPoint(long address, byte[] backup, BreakPointCallback callback, boolean thumb) {
this.address = address;
this.backup = backup;
this.callback = callback;
this.thumb = thumb;
}
@Override
public void setTemporary(boolean temporary) {
}
@Override
public boolean isTemporary() {
return true;
}
@Override
public BreakPointCallback getCallback() {
return callback;
}
@Override
public boolean isThumb() {
return thumb;
}
}
private int svcNumber = 1;
private final Map<Integer, SoftBreakPoint> softBreakpointMap = new HashMap<>();
@Override
public BreakPoint addBreakPoint(long address, BreakPointCallback callback, boolean thumb) {<FILL_FUNCTION_BODY>}
protected abstract byte[] addSoftBreakPoint(long address, int svcNumber, boolean thumb);
@Override
public boolean removeBreakPoint(long address) {
address &= (~1);
for (Iterator<Map.Entry<Integer, SoftBreakPoint>> iterator = softBreakpointMap.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<Integer, SoftBreakPoint> entry = iterator.next();
SoftBreakPoint breakPoint = entry.getValue();
if (address == breakPoint.address) {
Pointer pointer = UnidbgPointer.pointer(emulator, address);
assert pointer != null;
pointer.write(0, breakPoint.backup, 0, breakPoint.backup.length);
iterator.remove();
return true;
}
}
return false;
}
@Override
public void setSingleStep(int singleStep) {
}
@Override
public final void setFastDebug(boolean fastDebug) {
}
} |
int svcNumber = ++this.svcNumber; // begin with 2
byte[] code = addSoftBreakPoint(address, svcNumber, thumb);
Pointer pointer = UnidbgPointer.pointer(emulator, address);
assert pointer != null;
byte[] backup = pointer.getByteArray(0, code.length);
pointer.write(0, code, 0, code.length);
SoftBreakPoint breakPoint = new SoftBreakPoint(address, backup, callback, thumb);
softBreakpointMap.put(svcNumber, breakPoint);
return breakPoint;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/backend/UnicornBackend.java | UnicornBackend | hook_add_new | class UnicornBackend extends AbstractBackend implements Backend {
private final Emulator<?> emulator;
private final boolean is64Bit;
private final Unicorn unicorn;
UnicornBackend(Emulator<?> emulator, boolean is64Bit) throws BackendException {
this.emulator = emulator;
this.is64Bit = is64Bit;
try {
this.unicorn = new Unicorn(is64Bit ? UnicornConst.UC_ARCH_ARM64 : UnicornConst.UC_ARCH_ARM, UnicornConst.UC_MODE_ARM);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void switchUserMode() {
if (!is64Bit) {
Cpsr.getArm(this).switchUserMode();
}
}
@Override
public void enableVFP() {
if (is64Bit) {
long value = reg_read(Arm64Const.UC_ARM64_REG_CPACR_EL1).longValue();
value |= 0x300000; // set the FPEN bits
reg_write(Arm64Const.UC_ARM64_REG_CPACR_EL1, value);
} else {
int value = reg_read(ArmConst.UC_ARM_REG_C1_C0_2).intValue();
value |= (0xf << 20);
reg_write(ArmConst.UC_ARM_REG_C1_C0_2, value);
reg_write(ArmConst.UC_ARM_REG_FPEXC, 0x40000000);
}
}
@SuppressWarnings("deprecation")
@Override
public byte[] reg_read_vector(int regId) throws BackendException {
try {
if (is64Bit) {
if (regId < Arm64Const.UC_ARM64_REG_Q0 || regId > Arm64Const.UC_ARM64_REG_Q31) {
throw new UnsupportedOperationException("regId=" + regId);
}
} else {
if (regId < ArmConst.UC_ARM_REG_D0 || regId > ArmConst.UC_ARM_REG_D15) {
throw new UnsupportedOperationException("regId=" + regId);
}
}
return unicorn.reg_read(regId, 16);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@SuppressWarnings("deprecation")
@Override
public void reg_write_vector(int regId, byte[] vector) throws BackendException {
if (vector.length != 16) {
throw new IllegalStateException("Invalid vector size");
}
try {
if (is64Bit) {
if (regId < Arm64Const.UC_ARM64_REG_Q0 || regId > Arm64Const.UC_ARM64_REG_Q31) {
throw new UnsupportedOperationException("regId=" + regId);
}
} else {
if (regId < ArmConst.UC_ARM_REG_D0 || regId > ArmConst.UC_ARM_REG_D15) {
throw new UnsupportedOperationException("regId=" + regId);
}
}
unicorn.reg_write(regId, vector);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public Number reg_read(int regId) throws BackendException {
try {
return (Number) unicorn.reg_read(regId);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void reg_write(int regId, Number value) throws BackendException {
try {
unicorn.reg_write(regId, value);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public byte[] mem_read(long address, long size) throws BackendException {
try {
return unicorn.mem_read(address, size);
} catch (UnicornException e) {
throw new BackendException("mem_read address=0x" + Long.toHexString(address) + ", size=" + size, e);
}
}
@Override
public void mem_write(long address, byte[] bytes) throws BackendException {
try {
unicorn.mem_write(address, bytes);
} catch (UnicornException e) {
throw new BackendException("mem_write address=0x" + Long.toHexString(address), e);
}
}
@Override
public void mem_map(long address, long size, int perms) throws BackendException {
try {
unicorn.mem_map(address, size, perms);
} catch (UnicornException e) {
throw new BackendException("mem_map address=0x" + Long.toHexString(address) + ", size=" + size + ", perms=0x" + Integer.toHexString(perms), e);
}
}
@Override
public void mem_protect(long address, long size, int perms) throws BackendException {
try {
unicorn.mem_protect(address, size, perms);
} catch (UnicornException e) {
throw new BackendException("mem_protect address=0x" + Long.toHexString(address) + ", size=" + size + ", perms=0x" + Integer.toHexString(perms), e);
}
}
@Override
public void mem_unmap(long address, long size) throws BackendException {
try {
unicorn.mem_unmap(address, size);
} catch (UnicornException e) {
throw new BackendException("mem_unmap address=0x" + Long.toHexString(address) + ", size=" + size, e);
}
}
private static class BreakPointImpl implements BreakPoint {
final BreakPointCallback callback;
final boolean thumb;
boolean isTemporary;
public BreakPointImpl(BreakPointCallback callback, boolean thumb) {
this.callback = callback;
this.thumb = thumb;
}
@Override
public void setTemporary(boolean temporary) {
this.isTemporary = true;
}
@Override
public boolean isTemporary() {
return isTemporary;
}
@Override
public BreakPointCallback getCallback() {
return callback;
}
@Override
public boolean isThumb() {
return thumb;
}
}
@Override
public BreakPoint addBreakPoint(long address, BreakPointCallback callback, boolean thumb) {
BreakPointImpl breakPoint = new BreakPointImpl(callback, thumb);
unicorn.addBreakPoint(address);
return breakPoint;
}
@Override
public boolean removeBreakPoint(long address) {
unicorn.removeBreakPoint(address);
return true;
}
@Override
public void setSingleStep(int singleStep) {
unicorn.setSingleStep(singleStep);
}
@Override
public void setFastDebug(boolean fastDebug) {
unicorn.setFastDebug(fastDebug);
}
@Override
public void hook_add_new(final CodeHook callback, long begin, long end, Object user_data) throws BackendException {
try {
final Unicorn.UnHook unHook = unicorn.hook_add_new(new unicorn.CodeHook() {
@Override
public void hook(Unicorn u, long address, int size, Object user) {
callback.hook(UnicornBackend.this, address, size, user);
}
}, begin, end, user_data);
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void debugger_add(final DebugHook callback, long begin, long end, Object user_data) throws BackendException {
try {
final Unicorn.UnHook unHook = unicorn.debugger_add(new unicorn.DebugHook() {
@Override
public void onBreak(Unicorn u, long address, int size, Object user) {
callback.onBreak(UnicornBackend.this, address, size, user);
}
@Override
public void hook(Unicorn u, long address, int size, Object user) {
callback.hook(UnicornBackend.this, address, size, user);
}
}, begin, end, user_data);
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void hook_add_new(final ReadHook callback, long begin, long end, Object user_data) throws BackendException {
try {
final Unicorn.UnHook unHook = unicorn.hook_add_new(new unicorn.ReadHook() {
@Override
public void hook(Unicorn u, long address, int size, Object user) {
callback.hook(UnicornBackend.this, address, size, user);
}
}, begin, end, user_data);
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void hook_add_new(final WriteHook callback, long begin, long end, Object user_data) throws BackendException {
try {
final Unicorn.UnHook unHook = unicorn.hook_add_new(new unicorn.WriteHook() {
@Override
public void hook(Unicorn u, long address, int size, long value, Object user) {
callback.hook(UnicornBackend.this, address, size, value, user);
}
}, begin, end, user_data);
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void hook_add_new(final EventMemHook callback, int type, Object user_data) throws BackendException {
if ((type & UnicornConst.UC_HOOK_MEM_READ_UNMAPPED) != 0) {
hookEventMem(callback, UnicornConst.UC_HOOK_MEM_READ_UNMAPPED, user_data, EventMemHook.UnmappedType.Read);
}
if ((type & UnicornConst.UC_HOOK_MEM_WRITE_UNMAPPED) != 0) {
hookEventMem(callback, UnicornConst.UC_HOOK_MEM_WRITE_UNMAPPED, user_data, EventMemHook.UnmappedType.Write);
}
if ((type & UnicornConst.UC_HOOK_MEM_FETCH_UNMAPPED) != 0) {
hookEventMem(callback, UnicornConst.UC_HOOK_MEM_FETCH_UNMAPPED, user_data, EventMemHook.UnmappedType.Fetch);
}
}
private void hookEventMem(final EventMemHook callback, final int type, Object user_data, final EventMemHook.UnmappedType unmappedType) {
try {
Map<Integer, Unicorn.UnHook> map = unicorn.hook_add_new(new unicorn.EventMemHook() {
@Override
public boolean hook(Unicorn u, long address, int size, long value, Object user) {
return callback.hook(UnicornBackend.this, address, size, value, user, unmappedType);
}
}, type, user_data);
for (final Unicorn.UnHook unHook : map.values()) {
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
}
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void hook_add_new(final InterruptHook callback, Object user_data) throws BackendException {<FILL_FUNCTION_BODY>}
@Override
public void hook_add_new(final BlockHook callback, long begin, long end, Object user_data) throws BackendException {
try {
final Unicorn.UnHook unHook = unicorn.hook_add_new(new unicorn.BlockHook() {
@Override
public void hook(Unicorn u, long address, int size, Object user) {
callback.hookBlock(UnicornBackend.this, address, size, user);
}
}, begin, end, user_data);
callback.onAttach(new UnHook() {
@Override
public void unhook() {
unHook.unhook();
}
});
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public final synchronized void emu_start(long begin, long until, long timeout, long count) throws BackendException {
try {
unicorn.emu_start(begin, until, timeout, count);
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void emu_stop() throws BackendException {
try {
unicorn.emu_stop();
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void destroy() throws BackendException {
try {
unicorn.closeAll();
} catch (UnicornException e) {
throw new BackendException(e);
}
}
@Override
public void context_restore(long context) {
unicorn.context_restore(context);
}
@Override
public void context_save(long context) {
unicorn.context_save(context);
}
@Override
public long context_alloc() {
return unicorn.context_alloc();
}
@Override
public void context_free(long context) {
unicorn.free(context);
}
} |
try {
unicorn.hook_add_new(new unicorn.InterruptHook() {
@Override
public void hook(Unicorn u, int intno, Object user) {
int swi;
if (is64Bit) {
UnidbgPointer pc = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_PC);
swi = (pc.getInt(-4) >> 5) & 0xffff;
} else {
UnidbgPointer pc = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_PC);
boolean isThumb = ARM.isThumb(UnicornBackend.this);
if (isThumb) {
swi = pc.getShort(-2) & 0xff;
} else {
swi = pc.getInt(-4) & 0xffffff;
}
}
callback.hook(UnicornBackend.this, intno, swi, user);
}
}, user_data);
} catch (UnicornException e) {
throw new BackendException(e);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/context/BackendArm64RegisterContext.java | BackendArm64RegisterContext | getXLong | class BackendArm64RegisterContext extends BaseRegisterContext implements EditableArm64RegisterContext {
private final Backend backend;
public BackendArm64RegisterContext(Backend backend, Emulator<?> emulator) {
super(emulator, Arm64Const.UC_ARM64_REG_X0, 8);
this.backend = backend;
}
private long reg(int regId) {
return backend.reg_read(regId).longValue();
}
@Override
public void setXLong(int index, long value) {
if (index >= 0 && index <= 28) {
backend.reg_write(Arm64Const.UC_ARM64_REG_X0 + index, value);
return;
}
throw new IllegalArgumentException("invalid index: " + index);
}
@Override
public long getXLong(int index) {<FILL_FUNCTION_BODY>}
@Override
public int getXInt(int index) {
return (int) getXLong(index);
}
@Override
public UnidbgPointer getXPointer(int index) {
return UnidbgPointer.pointer(emulator, getXLong(index));
}
@Override
public long getFp() {
return reg(Arm64Const.UC_ARM64_REG_FP);
}
@Override
public UnidbgPointer getFpPointer() {
return UnidbgPointer.pointer(emulator, getFp());
}
@Override
public long getLR() {
return reg(Arm64Const.UC_ARM64_REG_LR);
}
@Override
public UnidbgPointer getLRPointer() {
return UnidbgPointer.pointer(emulator, getLR());
}
@Override
public UnidbgPointer getPCPointer() {
return UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_PC);
}
@Override
public UnidbgPointer getStackPointer() {
return UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_SP);
}
@Override
public void setStackPointer(Pointer sp) {
backend.reg_write(Arm64Const.UC_ARM64_REG_SP, ((UnidbgPointer) sp).peer);
}
} |
if (index >= 0 && index <= 28) {
return reg(Arm64Const.UC_ARM64_REG_X0 + index);
}
throw new IllegalArgumentException("invalid index: " + index);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/arm/context/BaseRegisterContext.java | BaseRegisterContext | getLongByReg | class BaseRegisterContext extends AbstractRegisterContext implements RegisterContext {
protected final Emulator<?> emulator;
private final int firstArgReg;
private final int regArgCount;
BaseRegisterContext(Emulator<?> emulator, int firstArgReg, int regArgCount) {
this.emulator = emulator;
this.firstArgReg = firstArgReg;
this.regArgCount = regArgCount;
}
@Override
public UnidbgPointer getPointerArg(int index) {
if (index < regArgCount) {
int reg = firstArgReg + index;
return UnidbgPointer.register(emulator, reg);
}
UnidbgPointer sp = getStackPointer();
return sp.getPointer((long) (index - regArgCount) * emulator.getPointerSize());
}
@Override
public int getIntByReg(int regId) {
Backend backend = emulator.getBackend();
Number number = backend.reg_read(regId);
return number.intValue();
}
@Override
public long getLongByReg(int regId) {<FILL_FUNCTION_BODY>}
} |
Backend backend = emulator.getBackend();
Number number = backend.reg_read(regId);
return number.longValue();
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/AbstractDebugServer.java | AbstractDebugServer | runServer | class AbstractDebugServer extends AbstractARMDebugger implements DebugServer {
private static final Log log = LogFactory.getLog(AbstractDebugServer.class);
private final List<ByteBuffer> pendingWrites;
public AbstractDebugServer(Emulator<?> emulator) {
super(emulator);
pendingWrites = new LinkedList<>();
input = ByteBuffer.allocate(PACKET_SIZE);
setSingleStep(1); // break at attach
Thread thread = new Thread(this, "dbgserver");
thread.start();
}
private Selector selector;
private ServerSocketChannel serverSocketChannel;
private SocketChannel socketChannel;
private final ByteBuffer input;
private boolean serverShutdown, closeConnection;
private boolean serverRunning;
protected final boolean isDebuggerConnected() {
return socketChannel != null;
}
@Override
public final void run() {
runServer();
}
private void runServer() {<FILL_FUNCTION_BODY>}
protected abstract void onServerStart();
protected abstract void processInput(ByteBuffer input);
private void enableNewConnections(boolean enable) {
if (serverSocketChannel == null) {
return;
}
SelectionKey key = serverSocketChannel.keyFor(selector);
key.interestOps(enable ? SelectionKey.OP_ACCEPT : 0);
}
private void onSelectAccept(SelectionKey key) throws IOException {
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
if (sc != null) {
closeConnection = false;
pendingWrites.clear();
input.clear();
sc.configureBlocking(false);
sc.register(key.selector(), SelectionKey.OP_READ);
socketChannel = sc;
enableNewConnections(false);
onDebuggerConnected();
}
}
protected abstract void onDebuggerConnected();
private void onSelectWrite(SelectionKey key) throws IOException {
SocketChannel sc = (SocketChannel) key.channel();
if (pendingWrites.isEmpty() && closeConnection) {
closeSocketChannel();
return;
}
while(!pendingWrites.isEmpty()) {
ByteBuffer bb = pendingWrites.get(0);
try {
sc.write(bb);
} catch(IOException ex) {
closeSocketChannel();
throw ex;
}
if (bb.remaining() > 0) {
break;
}
pendingWrites.remove(0);
}
if (pendingWrites.isEmpty() && !closeConnection) {
enableWrites(false);
}
}
private void onSelectRead(SelectionKey key) {
SocketChannel sc = (SocketChannel) key.channel();
int numRead;
try {
numRead = sc.read(input);
} catch(IOException ex) {
numRead = -1;
}
if (numRead == -1) {
closeSocketChannel();
}
}
private void closeSocketChannel() {
if (socketChannel == null) {
return;
}
SelectionKey key = socketChannel.keyFor(selector);
if (key != null) key.cancel();
IOUtils.close(socketChannel);
socketChannel = null;
if (!serverShutdown) {
enableNewConnections(true);
} else {
serverRunning = false;
}
}
private void enableWrites(boolean enable) {
if (socketChannel == null) {
return;
}
SelectionKey key = socketChannel.keyFor(selector);
key.interestOps(enable ? SelectionKey.OP_WRITE : SelectionKey.OP_READ);
}
protected final void sendData(byte[] data) {
if (log.isDebugEnabled()) {
log.debug(Inspector.inspectString(data, "sendData"));
}
ByteBuffer bb = ByteBuffer.wrap(data);
pendingWrites.add(bb);
enableWrites(true);
}
private Semaphore semaphore;
@Override
protected final void loop(Emulator<?> emulator, long address, int size, DebugRunnable<?> runnable) throws Exception {
if (address <= 0) {
return;
}
semaphore = new Semaphore(0);
onHitBreakPoint(emulator, address);
semaphore.acquire();
}
@Override
public <T> T run(DebugRunnable<T> runnable) {
throw new UnsupportedOperationException();
}
protected abstract void onHitBreakPoint(Emulator<?> emulator, long address);
public final void resumeRun() {
if (semaphore != null) {
semaphore.release();
}
}
public final void singleStep() {
setSingleStep(1);
resumeRun();
}
@Override
public final void close() {
super.close();
if (onDebuggerExit()) {
shutdownServer();
}
}
protected abstract boolean onDebuggerExit();
public final void shutdownServer() {
serverShutdown = true;
closeConnection = true;
enableWrites(true);
}
public final void detachServer() {
closeConnection = true;
enableWrites(true);
}
@Override
protected Keystone createKeystone(boolean isThumb) {
throw new UnsupportedOperationException();
}
} |
selector = null;
serverSocketChannel = null;
socketChannel = null;
try {
serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(DEFAULT_PORT));
selector = Selector.open();
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch(IOException ex) {
throw new IllegalStateException(ex);
}
serverShutdown = false;
serverRunning = true;
System.err.println("Start " + this + " server on port: " + DEFAULT_PORT);
onServerStart();
while(serverRunning) {
try {
int count = selector.select(50);
if (count <= 0) {
if (!isDebuggerConnected() && System.in.available() > 0) {
String line = new Scanner(System.in).nextLine();
if ("c".equals(line)) {
serverRunning = false;
break;
} else {
System.out.println("c: continue");
}
}
continue;
}
Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
while (selectedKeys.hasNext()) {
SelectionKey key = selectedKeys.next();
if (key.isValid()) {
if (key.isAcceptable()) {
onSelectAccept(key);
}
if (key.isReadable()) {
onSelectRead(key);
}
if (key.isWritable()) {
onSelectWrite(key);
}
}
selectedKeys.remove();
}
processInput(input);
} catch(Throwable e) {
if (log.isDebugEnabled()) {
log.debug("run server ex", e);
}
}
}
com.alibaba.fastjson.util.IOUtils.close(serverSocketChannel);
serverSocketChannel = null;
com.alibaba.fastjson.util.IOUtils.close(selector);
selector = null;
closeSocketChannel();
resumeRun();
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/BreakpointCommand.java | BreakpointCommand | processCommand | class BreakpointCommand implements GdbStubCommand {
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
int divider = command.substring(3).indexOf(",");
long address = Long.parseLong(command.substring(3, divider + 3), 16);
/*
* 2: 16-bit Thumb mode breakpoint.
* 3: 32-bit Thumb mode (Thumb-2) breakpoint.
* 4: 32-bit ARM mode breakpoint.
*/
int type = Integer.parseInt(command.substring(divider + 4));
boolean isThumb = type == 2 || type == 3;
if (isThumb) {
address |= 1;
}
if (command.startsWith("Z0")) {
stub.addBreakPoint(address);
} else {
stub.removeBreakPoint(address);
}
stub.makePacketAndSend("OK");
return true;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/ExtendedCommand.java | ExtendedCommand | processCommand | class ExtendedCommand implements GdbStubCommand {
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
if ("vCont?".equals(command)) {
stub.makePacketAndSend("vCont;c;s");
return true;
}
if ("vCont;c".equals(command)) {
stub.resumeRun();
return true;
}
if ("vCont;s".equals(command)) {
stub.singleStep();
return true;
}
return false;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/MemoryCommand.java | MemoryCommand | processCommand | class MemoryCommand implements GdbStubCommand {
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
try {
int divider = command.indexOf(",");
long address = Long.parseLong(command.substring(1, divider), 16);
Pointer pointer = UnidbgPointer.pointer(emulator, address);
if (pointer == null) {
stub.makePacketAndSend("E01");
return true;
}
if (command.startsWith("m")) {
int len = Integer.parseInt(command.substring(divider + 1), 16);
final String resp = Hex.encodeHexString(pointer.getByteArray(0, len)).toUpperCase();
stub.makePacketAndSend(resp);
return true;
} else {
int dividerForValue = command.indexOf(":");
int len = Integer.parseInt(command.substring(divider + 1, dividerForValue), 16);
byte[] val = Hex.decodeHex(command.substring(dividerForValue + 1).toCharArray());
pointer.write(0, val, 0, len);
stub.makePacketAndSend("OK");
return true;
}
} catch (BackendException e) {
stub.makePacketAndSend("E01");
return true;
} catch (DecoderException e) {
throw new IllegalStateException("process memory command failed: " + command, e);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/QueryCommand.java | QueryCommand | processCommand | class QueryCommand implements GdbStubCommand {
private static final Log log = LogFactory.getLog(QueryCommand.class);
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
if (command.startsWith("qSupported")) {
stub.makePacketAndSend("PacketSize=" + DebugServer.PACKET_SIZE + ";vContSupported+;multiprocess-;xmlRegisters=arm");
return true;
}
if (command.startsWith("qAttached")) {
stub.makePacketAndSend("1");
return true;
}
if (command.startsWith("qC")) {
stub.makePacketAndSend("QC1");
return true;
}
if (command.startsWith("qfThreadInfo")) {
stub.makePacketAndSend("m01");
return true;
}
if (command.startsWith("qsThreadInfo")) {
stub.makePacketAndSend("l");
return true;
}
if (command.startsWith("qRcmd,")) {
try {
String cmd = new String(Hex.decodeHex(command.substring(6).toCharArray()), StandardCharsets.UTF_8);
if (log.isDebugEnabled()) {
log.debug("qRcmd=" + cmd);
}
stub.makePacketAndSend("E01");
return true;
} catch (DecoderException e) {
throw new IllegalStateException(e);
}
}
return false;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/RegisterCommand.java | RegisterCommand | writeRegister | class RegisterCommand implements GdbStubCommand {
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {
Backend backend = emulator.getBackend();
int reg;
if (command.startsWith("p")) {
reg = Integer.parseInt(command.substring(1), 16);
long val = readRegister(backend, stub, reg);
if (emulator.is32Bit()) {
stub.makePacketAndSend(String.format("%08x", Integer.reverseBytes((int) (val & 0xffffffffL))));
} else {
stub.makePacketAndSend(String.format("%016x", Long.reverseBytes(val)));
}
} else {
reg = Integer.parseInt(command.substring(1, command.indexOf('=')), 16);
long val = Long.parseLong(command.substring(command.indexOf('=') + 1), 16);
writeRegister(emulator, stub, reg, val);
stub.makePacketAndSend("OK");
}
return true;
}
private long readRegister(Backend backend, GdbStub stub, int reg) {
final int index;
if (reg >= 0 && reg < stub.registers.length) {
index = stub.registers[reg];
} else if(reg == 0x18) { // for arm32
index = ArmConst.UC_ARM_REG_FP;
} else if(reg == 0x19) { // for arm32
index = ArmConst.UC_ARM_REG_CPSR;
} else {
index = -1;
}
if (index != -1) {
return backend.reg_read(index).longValue();
} else {
return 0;
}
}
private void writeRegister(Emulator<?> emulator, GdbStub stub, int reg, long val) {<FILL_FUNCTION_BODY>}
} |
Backend backend = emulator.getBackend();
if (reg >= 0 && reg < stub.registers.length) {
if (emulator.is32Bit()) {
backend.reg_write(stub.registers[reg], (int) (val & 0xffffffffL));
} else {
backend.reg_write(stub.registers[reg], val);
}
} else if (reg == 0x19) { // for arm32
backend.reg_write(ArmConst.UC_ARM_REG_CPSR, Integer.reverseBytes((int) (val & 0xffffffffL)));
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/RegistersCommand.java | RegistersCommand | processCommand | class RegistersCommand implements GdbStubCommand {
private static final Log log = LogFactory.getLog(RegistersCommand.class);
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
Backend backend = emulator.getBackend();
if (log.isDebugEnabled()) {
if (emulator.is32Bit()) {
ARM.showRegs(emulator, null);
} else {
ARM.showRegs64(emulator, null);
}
}
if (command.startsWith("g")) {
StringBuilder sb = new StringBuilder();
for(int i = 0; i < stub.registers.length; i++) {
long value = backend.reg_read(stub.registers[i]).longValue();
if (emulator.is32Bit()) {
String hex = String.format("%08x", Integer.reverseBytes((int) (value & 0xffffffffL)));
sb.append(hex);
} else {
String hex = String.format("%016x", Long.reverseBytes(value));
sb.append(hex);
}
}
stub.makePacketAndSend(sb.toString());
} else {
for (int i = 0; i < stub.registers.length; i++) {
if (emulator.is32Bit()) {
long value = Long.parseLong(command.substring(1 + 8 * i, 9 + 8 * i), 16);
backend.reg_write(stub.registers[i], Integer.reverseBytes((int) (value & 0xffffffffL)));
} else {
long value = Long.parseLong(command.substring(1 + 16 * i, 9 + 16 * i), 16);
backend.reg_write(stub.registers[i], Long.reverseBytes(value));
}
}
}
return true;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/gdb/SetThreadCommand.java | SetThreadCommand | processCommand | class SetThreadCommand implements GdbStubCommand {
private static final Log log = LogFactory.getLog(SetThreadCommand.class);
@Override
public boolean processCommand(Emulator<?> emulator, GdbStub stub, String command) {<FILL_FUNCTION_BODY>}
} |
char type = command.charAt(1);
int thread = Integer.parseInt(command.substring(2), 16);
if (log.isDebugEnabled()) {
log.debug("Set thread type=" + type + ", thread=" + thread);
}
switch (type) {
case 'c':
case 'g':
stub.makePacketAndSend("OK");
break;
default:
stub.makePacketAndSend("E22");
break;
}
return true;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/ida/Utils.java | Utils | readCString | class Utils {
public static String readCString(ByteBuffer buffer) {<FILL_FUNCTION_BODY>}
public static void writeCString(ByteBuffer buffer, String str) {
byte[] data = str.getBytes(StandardCharsets.UTF_8);
buffer.put(Arrays.copyOf(data, data.length + 1));
}
public static long unpack_dd(ByteBuffer buffer) {
byte b = buffer.get();
if ((b & 0xff) == 0xff) {
return buffer.getInt() & 0xffffffffL;
} else if ((b & 0xc0) == 0xc0) {
int b0 = b & 0x3f;
int b1 = buffer.get() & 0xff;
int b2 = buffer.get() & 0xff;
int b3 = buffer.get() & 0xff;
return ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) & 0xffffffffL;
} else if ((b & 0x80) == 0x80) {
int b0 = b & 0x7f;
int b1 = buffer.get() & 0xff;
return (b0 << 8) | b1;
} else {
return b & 0xff;
}
}
public static long unpack_dq(ByteBuffer buffer) {
long low = unpack_dd(buffer);
long high = unpack_dd(buffer);
return (high << 32L) | low;
}
public static byte[] pack_dq(long value) {
byte[] d1 = pack_dd(value);
byte[] d2 = pack_dd(value >> 32);
byte[] data = new byte[d1.length + d2.length];
System.arraycopy(d1, 0, data, 0, d1.length);
System.arraycopy(d2, 0, data, d1.length, d2.length);
return data;
}
public static byte[] pack_dd(long value) {
value &= 0xffffffffL; // unsigned int
ByteBuffer buffer = ByteBuffer.allocate(0x10);
if (value <= 0x7f) {
buffer.put((byte) value);
return flipBuffer(buffer);
}
if ((value >> 14) == 0) {
buffer.put((byte) ((value >> 8) | 0x80));
buffer.put((byte) value);
return flipBuffer(buffer);
}
if ((value >> 29) == 0) {
buffer.putInt((int) (value | 0xc0000000));
} else {
buffer.put((byte) 0xff);
buffer.putInt((int) value);
}
return flipBuffer(buffer);
}
public static byte[] flipBuffer(ByteBuffer buffer) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
return data;
}
} |
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int read;
while ((read = buffer.get() & 0xff) != 0) {
baos.write(read);
}
return baos.toString();
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/ida/event/AttachExecutableEvent.java | AttachExecutableEvent | pack | class AttachExecutableEvent extends DebuggerEvent {
@Override
public byte[] pack(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
ByteBuffer buffer = ByteBuffer.allocate(0x100);
buffer.put(Utils.pack_dd(0x1));
buffer.put(Utils.pack_dd(0x400));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dd(emulator.getPid()));
UnidbgPointer pc = emulator.getContext().getPCPointer();
if (emulator.is32Bit()) {
buffer.put(Utils.pack_dq(pc.toUIntPeer() + 1));
} else {
buffer.put(Utils.pack_dq(pc.peer + 1));
}
buffer.put((byte) 1);
Utils.writeCString(buffer, DebugServer.DEBUG_EXEC_NAME);
buffer.put(Utils.pack_dq(1)); // base
buffer.put(Utils.pack_dq(emulator.getPageAlign() + 1));
buffer.put(Utils.pack_dq(1)); // base
return Utils.flipBuffer(buffer);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/ida/event/DetachEvent.java | DetachEvent | pack | class DetachEvent extends DebuggerEvent {
@Override
public byte[] pack(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
ByteBuffer buffer = ByteBuffer.allocate(0x20);
buffer.put(Utils.pack_dd(0x1));
buffer.put(Utils.pack_dd(0x800));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dq(0x100000000L));
buffer.put((byte) 1);
return Utils.flipBuffer(buffer);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/ida/event/LoadExecutableEvent.java | LoadExecutableEvent | pack | class LoadExecutableEvent extends DebuggerEvent {
@Override
public byte[] pack(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
ByteBuffer buffer = ByteBuffer.allocate(0x100);
buffer.put(Utils.pack_dd(0x2));
buffer.put(Utils.pack_dd(0x1));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dd(emulator.getPid()));
UnidbgPointer pc = emulator.getContext().getPCPointer();
if (emulator.is32Bit()) {
buffer.put(Utils.pack_dq(pc.toUIntPeer() + 1));
} else {
buffer.put(Utils.pack_dq(pc.peer + 1));
}
buffer.put((byte) 1);
Utils.writeCString(buffer, DebugServer.DEBUG_EXEC_NAME);
buffer.put(Utils.pack_dq(1)); // base
buffer.put(Utils.pack_dq(emulator.getPageAlign() + 1));
buffer.put(Utils.pack_dq(1)); // base
return Utils.flipBuffer(buffer);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/debugger/ida/event/LoadModuleEvent.java | LoadModuleEvent | pack | class LoadModuleEvent extends DebuggerEvent {
private final Module module;
public LoadModuleEvent(Module module) {
this.module = module;
}
@Override
public byte[] pack(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
ByteBuffer buffer = ByteBuffer.allocate(0x100);
buffer.put(Utils.pack_dd(0x2));
buffer.put(Utils.pack_dd(0x80));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dd(emulator.getPid()));
buffer.put(Utils.pack_dq(module.base + 1));
buffer.put(Utils.pack_dd(0x1));
Utils.writeCString(buffer, module.getPath());
buffer.put(Utils.pack_dq(module.base + 1));
buffer.put(Utils.pack_dq(module.size + 1));
buffer.put(Utils.pack_dq(0x0));
return Utils.flipBuffer(buffer);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/file/BaseFileSystem.java | BaseFileSystem | open | class BaseFileSystem<T extends NewFileIO> implements FileSystem<T> {
private static final Log log = LogFactory.getLog(BaseFileSystem.class);
protected final Emulator<T> emulator;
protected final File rootDir;
public BaseFileSystem(Emulator<T> emulator, File rootDir) {
this.emulator = emulator;
this.rootDir = rootDir;
try {
initialize(this.rootDir);
} catch (IOException e) {
throw new IllegalStateException("initialize file system failed", e);
}
}
protected void initialize(File rootDir) throws IOException {
FileUtils.forceMkdir(new File(rootDir, "tmp"));
}
@Override
public FileResult<T> open(String pathname, int oflags) {<FILL_FUNCTION_BODY>}
protected abstract T createStdout(int oflags, File stdio, String pathname);
protected abstract T createStdin(int oflags);
private FileResult<T> createFileIO(File file, int oflags, String path) {
boolean directory = hasDirectory(oflags);
if (file.isFile() && directory) {
return FileResult.failed(UnixEmulator.ENOTDIR);
}
boolean create = hasCreat(oflags);
if (file.exists()) {
if (create && hasExcl(oflags)) {
return FileResult.failed(UnixEmulator.EEXIST);
}
return FileResult.success(file.isDirectory() ? createDirectoryFileIO(file, oflags, path) : createSimpleFileIO(file, oflags, path));
}
if (!create) {
return FileResult.failed(UnixEmulator.ENOENT);
}
try {
if (directory) {
FileUtils.forceMkdir(file);
return FileResult.success(createDirectoryFileIO(file, oflags, path));
} else {
if (!file.getParentFile().exists()) {
FileUtils.forceMkdir(file.getParentFile());
}
FileUtils.touch(file);
return FileResult.success(createSimpleFileIO(file, oflags, path));
}
} catch (IOException e) {
throw new IllegalStateException("createNewFile failed: " + file, e);
}
}
@Override
public boolean mkdir(String path, int mode) {
File dir = new File(rootDir, path);
if (emulator.getSyscallHandler().isVerbose()) {
System.out.printf("mkdir '%s' with mode 0x%x from %s%n", path, mode, emulator.getContext().getLRPointer());
}
if (dir.exists()) {
return true;
} else {
return dir.mkdirs();
}
}
@Override
public void rmdir(String path) {
File dir = new File(rootDir, path);
FileUtils.deleteQuietly(dir);
if (emulator.getSyscallHandler().isVerbose()) {
System.out.printf("rmdir '%s' from %s%n", path, emulator.getContext().getLRPointer());
}
}
protected abstract boolean hasCreat(int oflags);
protected abstract boolean hasDirectory(int oflags);
@SuppressWarnings("unused")
protected abstract boolean hasAppend(int oflags);
protected abstract boolean hasExcl(int oflags);
@Override
public void unlink(String path) {
File file = new File(rootDir, path);
FileUtils.deleteQuietly(file);
if (log.isDebugEnabled()) {
log.debug("unlink path=" + path + ", file=" + file);
}
if (emulator.getSyscallHandler().isVerbose()) {
System.out.printf("unlink '%s' from %s%n", path, emulator.getContext().getLRPointer());
}
}
@Override
public File getRootDir() {
return rootDir;
}
@Override
public File createWorkDir() {
File workDir = new File(rootDir, DEFAULT_WORK_DIR);
if (!workDir.exists() && !workDir.mkdirs()) {
throw new IllegalStateException("mkdirs failed: " + workDir);
}
return workDir;
}
@Override
public int rename(String oldPath, String newPath) {
File oldFile = new File(rootDir, oldPath);
File newFile = new File(rootDir, newPath);
try {
FileUtils.forceMkdir(newFile.getParentFile());
if (oldFile.exists()) {
Files.move(oldFile.toPath(), newFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
}
if (emulator.getSyscallHandler().isVerbose()) {
System.out.printf("rename '%s' to '%s' from %s%n", oldPath, newPath, emulator.getContext().getLRPointer());
}
} catch (IOException e) {
throw new IllegalStateException(e);
}
return 0;
}
} |
if ("".equals(pathname)) {
return FileResult.failed(UnixEmulator.ENOENT); // No such file or directory
}
if (IO.STDIN.equals(pathname)) {
return FileResult.success(createStdin(oflags));
}
if (IO.STDOUT.equals(pathname) || IO.STDERR.equals(pathname)) {
try {
File stdio = new File(rootDir, pathname + ".txt");
if (!stdio.exists() && !stdio.createNewFile()) {
throw new IOException("create new file failed: " + stdio);
}
return FileResult.success(createStdout(oflags, stdio, pathname));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
File file = new File(rootDir, pathname);
return createFileIO(file, oflags, pathname);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/file/FileResult.java | FileResult | fallback | class FileResult<T extends NewFileIO> {
private static final int FALLBACK_ERRNO = -1;
public static <T extends NewFileIO> FileResult<T> success(T io) {
if (io == null) {
throw new NullPointerException("io is null");
}
return new FileResult<>(io, 0);
}
public static <T extends NewFileIO> FileResult<T> failed(int errno) {
if (errno == 0) {
throw new IllegalArgumentException("errno=" + errno);
}
return new FileResult<>(null, errno);
}
public static <T extends NewFileIO> FileResult<T> fallback(T io) {<FILL_FUNCTION_BODY>}
public final T io;
public final int errno;
public boolean isSuccess() {
return io != null && errno == 0;
}
public boolean isFallback() {
return io != null && errno == FALLBACK_ERRNO;
}
private FileResult(T io, int errno) {
this.io = io;
this.errno = errno;
}
} |
if (io == null) {
throw new NullPointerException("io is null");
}
return new FileResult<>(io, FALLBACK_ERRNO);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/BaseHook.java | BaseHook | resolveLibrary | class BaseHook implements IHook {
protected final Emulator<?> emulator;
protected final Module module;
public BaseHook(Emulator<?> emulator, String libName) {
this.emulator = emulator;
this.module = emulator.getMemory().load(resolveLibrary(libName));
}
protected Pointer createReplacePointer(final ReplaceCallback callback, final Pointer backup, boolean enablePostCall) {
SvcMemory svcMemory = emulator.getSvcMemory();
return svcMemory.registerSvc(emulator.is64Bit() ? new Arm64Hook(enablePostCall) {
private final Stack<Object> context = new Stack<>();
@Override
protected HookStatus hook(Emulator<?> emulator) {
return callback.onCall(emulator, new Arm64HookContext(context, emulator.<EditableArm64RegisterContext>getContext()), backup.getLong(0));
}
@Override
public void handlePostCallback(Emulator<?> emulator) {
super.handlePostCallback(emulator);
EditableArm64RegisterContext registerContext = emulator.getContext();
callback.postCall(emulator, new Arm64HookContext(context, registerContext));
}
} : new ArmHook(enablePostCall) {
private final Stack<Object> context = new Stack<>();
@Override
protected HookStatus hook(Emulator<?> emulator) {
return callback.onCall(emulator, new Arm32HookContext(context, emulator.<EditableArm32RegisterContext>getContext()), backup.getInt(0) & 0xffffffffL);
}
@Override
public void handlePostCallback(Emulator<?> emulator) {
super.handlePostCallback(emulator);
EditableArm32RegisterContext registerContext = emulator.getContext();
callback.postCall(emulator, new Arm32HookContext(context, registerContext));
}
});
}
protected LibraryFile resolveLibrary(String libName) {<FILL_FUNCTION_BODY>}
@Override
public Module getModule() {
return module;
}
} |
Family family = emulator.getFamily();
String lib = libName + family.getLibraryExtension();
URL url = BaseHook.class.getResource(family.getLibraryPath() + lib);
if (url == null) {
throw new IllegalStateException("resolve library failed: " + lib);
}
return emulator.createURLibraryFile(url, lib);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/HookContext.java | HookContext | push | class HookContext implements RegisterContext, InvocationContext {
private final Stack<Object> stack;
HookContext(Stack<Object> stack) {
this.stack = stack;
}
@Override
public void push(Object... objs) {<FILL_FUNCTION_BODY>}
@SuppressWarnings("unchecked")
@Override
public <T> T pop() {
return (T) stack.pop();
}
} |
for (int i = objs.length - 1; i >= 0; i--) {
stack.push(objs[i]);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/hookzz/Dobby.java | Dobby | replace | class Dobby extends BaseHook implements IHookZz {
private static final Log log = LogFactory.getLog(Dobby.class);
public static Dobby getInstance(Emulator<?> emulator) {
Dobby dobby = emulator.get(Dobby.class.getName());
if (dobby == null) {
dobby = new Dobby(emulator);
emulator.set(Dobby.class.getName(), dobby);
}
return dobby;
}
private static final int RT_SUCCESS = 0;
private final Symbol dobby_enable_near_branch_trampoline, dobby_disable_near_branch_trampoline;
private final Symbol switch_to_file_log;
private final Symbol dobbyHook;
private final Symbol dobbyInstrument;
private Dobby(Emulator<?> emulator) {
super(emulator, "libdobby");
boolean isIOS = emulator.getFamily() == Family.iOS;
dobby_enable_near_branch_trampoline = module.findSymbolByName(isIOS ? "_dobby_enable_near_branch_trampoline" : "dobby_enable_near_branch_trampoline", false);
dobby_disable_near_branch_trampoline = module.findSymbolByName(isIOS ? "_dobby_disable_near_branch_trampoline" : "dobby_disable_near_branch_trampoline", false);
dobbyHook = module.findSymbolByName(isIOS ? "_DobbyHook" : "DobbyHook", false);
dobbyInstrument = module.findSymbolByName(isIOS ? "_DobbyInstrument" : "DobbyInstrument", false);
if (log.isDebugEnabled()) {
log.debug("dobbyHook=" + dobbyHook + ", dobbyInstrument=" + dobbyInstrument);
}
if (dobby_enable_near_branch_trampoline == null && emulator.is64Bit()) {
throw new IllegalStateException("dobby_enable_near_branch_trampoline is null");
}
if (dobby_disable_near_branch_trampoline == null && emulator.is64Bit()) {
throw new IllegalStateException("dobby_disable_near_branch_trampoline is null");
}
if (dobbyHook == null) {
throw new IllegalStateException("dobbyHook is null");
}
if (dobbyInstrument == null) {
throw new IllegalStateException("dobbyInstrument is null");
}
switch_to_file_log = module.findSymbolByName(isIOS ? "_switch_to_file_log" : "switch_to_file_log", false);
}
@Override
public void switch_to_file_log(String path) {
if (switch_to_file_log == null) {
throw new UnsupportedOperationException();
}
switch_to_file_log.call(emulator, path);
}
@Override
public void enable_arm_arm64_b_branch() {
if (dobby_enable_near_branch_trampoline == null) {
return;
}
int ret = dobby_enable_near_branch_trampoline.call(emulator).intValue();
if (ret != RT_SUCCESS) {
throw new IllegalStateException("ret=" + ret);
}
}
@Override
public void disable_arm_arm64_b_branch() {
if (dobby_disable_near_branch_trampoline == null) {
return;
}
int ret = dobby_disable_near_branch_trampoline.call(emulator).intValue();
if (ret != RT_SUCCESS) {
throw new IllegalStateException("ret=" + ret);
}
}
@Override
public void replace(long functionAddress, final ReplaceCallback callback) {
replace(functionAddress, callback, false);
}
@Override
public void replace(Symbol symbol, ReplaceCallback callback) {
replace(symbol, callback, false);
}
@Override
public void replace(long functionAddress, Svc svc) {<FILL_FUNCTION_BODY>}
@Override
public void replace(Symbol symbol, Svc svc) {
replace(symbol.getAddress(), svc);
}
@Override
public void replace(long functionAddress, ReplaceCallback callback, boolean enablePostCall) {
final Pointer originCall = emulator.getMemory().malloc(emulator.getPointerSize(), false).getPointer();
Pointer replaceCall = createReplacePointer(callback, originCall, enablePostCall);
int ret = dobbyHook.call(emulator, UnidbgPointer.pointer(emulator, functionAddress), replaceCall, originCall).intValue();
if (ret != RT_SUCCESS) {
throw new IllegalStateException("ret=" + ret);
}
}
@Override
public void replace(Symbol symbol, ReplaceCallback callback, boolean enablePostCall) {
replace(symbol.getAddress(), callback, enablePostCall);
}
@Override
public <T extends RegisterContext> void wrap(Symbol symbol, WrapCallback<T> callback) {
wrap(symbol.getAddress(), callback);
}
@Override
public <T extends RegisterContext> void wrap(long functionAddress, final WrapCallback<T> callback) {
throw new UnsupportedOperationException();
}
@Override
public <T extends RegisterContext> void instrument(Symbol symbol, InstrumentCallback<T> callback) {
instrument(symbol.getAddress(), callback);
}
@SuppressWarnings("unchecked")
@Override
public <T extends RegisterContext> void instrument(long functionAddress, final InstrumentCallback<T> callback) {
SvcMemory svcMemory = emulator.getSvcMemory();
final Stack<Object> context = new Stack<>();
Pointer dbiCall = svcMemory.registerSvc(emulator.is32Bit() ? new ArmSvc() {
@Override
public long handle(Emulator<?> emulator) {
context.clear();
callback.dbiCall(emulator, (T) new HookZzArm32RegisterContextImpl(emulator, context), new ArmHookEntryInfo(emulator));
return 0;
}
} : new Arm64Svc() {
@Override
public long handle(Emulator<?> emulator) {
context.clear();
callback.dbiCall(emulator, (T) new HookZzArm64RegisterContextImpl(emulator, context), new Arm64HookEntryInfo(emulator));
return 0;
}
});
int ret = dobbyInstrument.call(emulator, UnidbgPointer.pointer(emulator, functionAddress), dbiCall).intValue();
if (ret != RT_SUCCESS) {
throw new IllegalStateException("ret=" + ret);
}
}
} |
if (svc == null) {
throw new NullPointerException();
}
final Pointer originCall = emulator.getMemory().malloc(emulator.getPointerSize(), false).getPointer();
Pointer callback = emulator.getSvcMemory().registerSvc(svc);
int ret = dobbyHook.call(emulator, UnidbgPointer.pointer(emulator, functionAddress), callback, originCall).intValue();
if (ret != RT_SUCCESS) {
throw new IllegalStateException("ret=" + ret);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/hookzz/HookZzArm64RegisterContextImpl.java | HookZzArm64RegisterContextImpl | getPointerArg | class HookZzArm64RegisterContextImpl extends HookZzRegisterContext implements HookZzArm64RegisterContext {
private final Pointer reg_ctx;
private final Emulator<?> emulator;
HookZzArm64RegisterContextImpl(Emulator<?> emulator, Stack<Object> context) {
super(context);
this.reg_ctx = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_X0).share(8); // skip dummy
this.emulator = emulator;
}
@Override
public UnidbgPointer getPointerArg(int index) {<FILL_FUNCTION_BODY>}
@Override
public long getXLong(int index) {
if (index >= 0 && index <= 28) {
return reg_ctx.getLong(index * 8);
}
throw new IllegalArgumentException("invalid index: " + index);
}
@Override
public int getXInt(int index) {
return (int) getXLong(index);
}
@Override
public UnidbgPointer getXPointer(int index) {
return UnidbgPointer.pointer(emulator, getXLong(index));
}
@Override
public long getFp() {
return reg_ctx.getLong(29 * 8);
}
@Override
public void setXLong(int index, long value) {
if (index >= 0 && index <= 28) {
reg_ctx.setLong(index * 8, value);
} else {
throw new IllegalArgumentException("invalid index: " + index);
}
}
@Override
public void setStackPointer(Pointer sp) {
throw new UnsupportedOperationException();
}
@Override
public UnidbgPointer getFpPointer() {
return UnidbgPointer.pointer(emulator, getFp());
}
@Override
public long getLR() {
return reg_ctx.getLong(30 * 8);
}
@Override
public UnidbgPointer getLRPointer() {
return UnidbgPointer.pointer(emulator, getLR());
}
@Override
public UnidbgPointer getStackPointer() {
return (UnidbgPointer) reg_ctx.share(30 * 8 + 8 + 16 * 8);
}
} |
if (index < 8) {
return getXPointer(index);
}
UnidbgPointer sp = getStackPointer();
return sp.getPointer((long) (index - 8) * emulator.getPointerSize());
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/hookzz/HookZzRegisterContext.java | HookZzRegisterContext | push | class HookZzRegisterContext extends AbstractRegisterContext implements RegisterContext, InvocationContext {
private final Stack<Object> stack;
HookZzRegisterContext(Stack<Object> stack) {
this.stack = stack;
}
@Override
public void push(Object... objs) {<FILL_FUNCTION_BODY>}
@SuppressWarnings("unchecked")
@Override
public <T> T pop() {
return (T) stack.pop();
}
@Override
public UnidbgPointer getPCPointer() {
throw new UnsupportedOperationException();
}
@Override
public int getIntByReg(int regId) {
throw new UnsupportedOperationException();
}
@Override
public long getLongByReg(int regId) {
throw new UnsupportedOperationException();
}
} |
for (int i = objs.length - 1; i >= 0; i--) {
stack.push(objs[i]);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/hook/whale/Whale.java | Whale | getInstance | class Whale extends BaseHook implements IWhale {
private static final Log log = LogFactory.getLog(Whale.class);
public static IWhale getInstance(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
private final Symbol WInlineHookFunction, WImportHookFunction;
private Whale(Emulator<?> emulator) {
super(emulator, "libwhale");
boolean isIOS = emulator.getFamily() == Family.iOS;
WInlineHookFunction = module.findSymbolByName(isIOS ? "_WInlineHookFunction" : "WInlineHookFunction", false);
WImportHookFunction = module.findSymbolByName(isIOS ? "_WImportHookFunction" : "WImportHookFunction", false);
if (log.isDebugEnabled()) {
log.debug("WInlineHookFunction=" + WInlineHookFunction + ", WImportHookFunction=" + WImportHookFunction);
}
if (WInlineHookFunction == null) {
throw new IllegalStateException("WInlineHookFunction is null");
}
if (WImportHookFunction == null) {
throw new IllegalStateException("WImportHookFunction is null");
}
}
@Override
public void inlineHookFunction(long address, final ReplaceCallback callback) {
inlineHookFunction(address, callback, false);
}
@Override
public void inlineHookFunction(Symbol symbol, ReplaceCallback callback) {
inlineHookFunction(symbol.getAddress(), callback);
}
@Override
public void replace(long functionAddress, ReplaceCallback callback) {
inlineHookFunction(functionAddress, callback);
}
@Override
public void replace(Symbol symbol, ReplaceCallback callback) {
inlineHookFunction(symbol, callback);
}
@Override
public void replace(long functionAddress, ReplaceCallback callback, boolean enablePostCall) {
inlineHookFunction(functionAddress, callback, enablePostCall);
}
@Override
public void replace(Symbol symbol, ReplaceCallback callback, boolean enablePostCall) {
inlineHookFunction(symbol, callback, enablePostCall);
}
@Override
public void inlineHookFunction(long address, ReplaceCallback callback, boolean enablePostCall) {
final Pointer backup = emulator.getMemory().malloc(emulator.getPointerSize(), false).getPointer();
Pointer replace = createReplacePointer(callback, backup, enablePostCall);
WInlineHookFunction.call(emulator, UnidbgPointer.pointer(emulator, address), replace, backup);
}
@Override
public void replace(long functionAddress, Svc svc) {
if (svc == null) {
throw new NullPointerException();
}
final Pointer originCall = emulator.getMemory().malloc(emulator.getPointerSize(), false).getPointer();
Pointer callback = emulator.getSvcMemory().registerSvc(svc);
WInlineHookFunction.call(emulator, UnidbgPointer.pointer(emulator, functionAddress), callback, originCall);
}
@Override
public void replace(Symbol symbol, Svc svc) {
replace(symbol.getAddress(), svc);
}
@Override
public void inlineHookFunction(Symbol symbol, ReplaceCallback callback, boolean enablePostCall) {
inlineHookFunction(symbol.getAddress(), callback, enablePostCall);
}
@Override
public void importHookFunction(String symbol, final ReplaceCallback callback) {
importHookFunction(symbol, callback, false);
}
@Override
public void importHookFunction(String symbol, ReplaceCallback callback, boolean enablePostCall) {
final Pointer backup = emulator.getMemory().malloc(emulator.getPointerSize(), false).getPointer();
Pointer replace = createReplacePointer(callback, backup, enablePostCall);
WImportHookFunction.call(emulator, symbol, null, replace, backup);
}
} |
IWhale whale = emulator.get(Whale.class.getName());
if (whale == null) {
whale = new Whale(emulator);
emulator.set(Whale.class.getName(), whale);
}
return whale;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/memory/MemRegion.java | MemRegion | create | class MemRegion implements Comparable<MemRegion> {
public final long virtualAddress;
public final long begin;
public final long end;
public final int perms;
private final LibraryFile libraryFile;
public final long offset;
public static MemRegion create(long begin, int size, int perms, final String name) {<FILL_FUNCTION_BODY>}
public MemRegion(long virtualAddress, long begin, long end, int perms, LibraryFile libraryFile, long offset) {
this.virtualAddress = virtualAddress;
this.begin = begin;
this.end = end;
this.perms = perms;
this.libraryFile = libraryFile;
this.offset = offset;
}
public String getName() {
return libraryFile.getMapRegionName();
}
public byte[] readLibrary() throws IOException {
ByteBuffer buffer = libraryFile.mapBuffer();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
return data;
}
@Override
public int compareTo(MemRegion o) {
return Long.compare(begin, o.begin);
}
} |
return new MemRegion(begin, begin, begin + size, perms, new LibraryFile() {
@Override
public String getName() {
return name;
}
@Override
public String getMapRegionName() {
return name;
}
@Override
public LibraryFile resolveLibrary(Emulator<?> emulator, String soName) {
throw new UnsupportedOperationException();
}
@Override
public ByteBuffer mapBuffer() {
throw new UnsupportedOperationException();
}
@Override
public String getPath() {
return name;
}
@Override
public long getFileSize() {
throw new UnsupportedOperationException();
}
}, 0);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/memory/MemoryAllocBlock.java | MemoryAllocBlock | malloc | class MemoryAllocBlock implements MemoryBlock {
public static MemoryBlock malloc(Emulator<?> emulator, Symbol malloc, Symbol free, int length) {<FILL_FUNCTION_BODY>}
private final UnidbgPointer pointer;
private final Emulator<?> emulator;
private final Symbol free;
private MemoryAllocBlock(UnidbgPointer pointer, Emulator<?> emulator, Symbol free) {
this.pointer = pointer;
this.emulator = emulator;
this.free = free;
}
@Override
public UnidbgPointer getPointer() {
return pointer;
}
@Override
public boolean isSame(Pointer p) {
return pointer.equals(p);
}
@Override
public void free() {
if (free == null) {
throw new UnsupportedOperationException();
}
free.call(emulator, pointer);
}
} |
Number number = malloc.call(emulator, length);
long address = emulator.is64Bit() ? number.longValue() : number.intValue() & 0xffffffffL;
final UnidbgPointer pointer = UnidbgPointer.pointer(emulator, address);
return new MemoryAllocBlock(pointer, emulator, free);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/memory/MemoryBlockImpl.java | MemoryBlockImpl | alloc | class MemoryBlockImpl implements MemoryBlock {
public static MemoryBlock alloc(Memory memory, int length) {<FILL_FUNCTION_BODY>}
public static MemoryBlock allocExecutable(Memory memory, int length) {
UnidbgPointer pointer = memory.mmap(length, UnicornConst.UC_PROT_READ | UnicornConst.UC_PROT_EXEC);
return new MemoryBlockImpl(memory, pointer);
}
private final Memory memory;
private final UnidbgPointer pointer;
private MemoryBlockImpl(Memory memory, UnidbgPointer pointer) {
this.memory = memory;
this.pointer = pointer;
}
@Override
public UnidbgPointer getPointer() {
return pointer;
}
@Override
public boolean isSame(Pointer pointer) {
return this.pointer.equals(pointer);
}
@Override
public void free() {
memory.munmap(pointer.peer, (int) pointer.getSize());
}
} |
UnidbgPointer pointer = memory.mmap(length, UnicornConst.UC_PROT_READ | UnicornConst.UC_PROT_WRITE);
return new MemoryBlockImpl(memory, pointer);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/memory/MemoryMap.java | MemoryMap | toString | class MemoryMap implements Serializable {
public final long base;
public final long size;
public int prot;
public MemoryMap(long base, long size, int prot) {
this.base = base;
this.size = size;
this.prot = prot;
}
@Override
public void serialize(DataOutput out) throws IOException {
out.writeLong(base);
out.writeLong(size);
out.writeInt(prot);
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
} |
return "MemoryMap{" +
"base=0x" + Long.toHexString(base) +
", size=0x" + Long.toHexString(size) +
", prot=" + prot +
'}';
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/pointer/UnidbgStructure.java | UnidbgStructure | toString | class UnidbgStructure extends Structure implements PointerArg {
/** Placeholder pointer to help avoid auto-allocation of memory where a
* Structure needs a valid pointer but want to avoid actually reading from it.
*/
private static final Pointer PLACEHOLDER_MEMORY = new UnidbgPointer(null, null) {
@Override
public UnidbgPointer share(long offset, long sz) { return this; }
};
public static int calculateSize(Class<? extends UnidbgStructure> type) {
try {
Constructor<? extends UnidbgStructure> constructor = type.getConstructor(Pointer.class);
return constructor.newInstance(PLACEHOLDER_MEMORY).calculateSize(false);
} catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new IllegalStateException(e);
}
}
private static class ByteArrayPointer extends UnidbgPointer {
private final Emulator<?> emulator;
private final byte[] data;
public ByteArrayPointer(Emulator<?> emulator, byte[] data) {
super(emulator, data);
this.emulator = emulator;
this.data = data;
}
@Override
public UnidbgPointer share(long offset, long sz) {
if (offset == 0) {
return this;
}
if (offset > 0 && offset + sz < data.length) {
if (sz == 0) {
sz = data.length - offset;
}
byte[] tmp = new byte[(int) sz];
System.arraycopy(data, (int) offset, tmp, 0, (int) sz);
return new ByteArrayPointer(emulator, tmp);
}
throw new UnsupportedOperationException("offset=0x" + Long.toHexString(offset) + ", sz=" + sz);
}
}
protected UnidbgStructure(Emulator<?> emulator, byte[] data) {
this(new ByteArrayPointer(emulator, data));
}
protected UnidbgStructure(byte[] data) {
this(null, data);
}
protected UnidbgStructure(Pointer p) {
super(p);
checkPointer(p);
}
private void checkPointer(Pointer p) {
if (p == null) {
throw new NullPointerException("p is null");
}
if (!(p instanceof UnidbgPointer) && !isPlaceholderMemory(p)) {
throw new IllegalArgumentException("p is NOT UnidbgPointer");
}
}
@Override
protected int getNativeSize(Class<?> nativeType, Object value) {
if (Pointer.class.isAssignableFrom(nativeType)) {
throw new UnsupportedOperationException();
}
return super.getNativeSize(nativeType, value);
}
@Override
protected int getNativeAlignment(Class<?> type, Object value, boolean isFirstElement) {
if (Pointer.class.isAssignableFrom(type)) {
throw new UnsupportedOperationException();
}
return super.getNativeAlignment(type, value, isFirstElement);
}
private boolean isPlaceholderMemory(Pointer p) {
return "native@0x0".equals(p.toString());
}
public void pack() {
super.write();
}
public void unpack() {
super.read();
}
/**
* @param debug If true, will include a native memory dump of the
* Structure's backing memory.
* @return String representation of this object.
*/
public String toString(boolean debug) {
return toString(0, true, debug);
}
private String format(Class<?> type) {
String s = type.getName();
int dot = s.lastIndexOf(".");
return s.substring(dot + 1);
}
private String toString(int indent, boolean showContents, boolean dumpMemory) {<FILL_FUNCTION_BODY>}
/** Obtain the value currently in the Java field. Does not read from
* native memory.
* @param field field to look up
* @return current field value (Java-side only)
*/
private Object getFieldValue(Field field) {
try {
return field.get(this);
}
catch (Exception e) {
throw new Error("Exception reading field '" + field.getName() + "' in " + getClass(), e);
}
}
private static final Field FIELD_STRUCT_FIELDS;
static {
try {
FIELD_STRUCT_FIELDS = Structure.class.getDeclaredField("structFields");
FIELD_STRUCT_FIELDS.setAccessible(true);
} catch (NoSuchFieldException e) {
throw new IllegalStateException(e);
}
}
/** Return all fields in this structure (ordered). This represents the
* layout of the structure, and will be shared among Structures of the
* same class except when the Structure can have a variable size.
* NOTE: {@link #ensureAllocated()} <em>must</em> be called prior to
* calling this method.
* @return {@link Map} of field names to field representations.
*/
@SuppressWarnings("unchecked")
private Map<String, StructField> fields() {
try {
return (Map<String, StructField>) FIELD_STRUCT_FIELDS.get(this);
} catch (IllegalAccessException e) {
throw new IllegalStateException(e);
}
}
} |
ensureAllocated();
String LS = System.getProperty("line.separator");
String name = format(getClass()) + "(" + getPointer() + ")";
if (!(getPointer() instanceof Memory)) {
name += " (" + size() + " bytes)";
}
StringBuilder prefix = new StringBuilder();
for (int idx=0;idx < indent;idx++) {
prefix.append(" ");
}
StringBuilder contents = new StringBuilder(LS);
if (!showContents) {
contents = new StringBuilder("...}");
}
else for (Iterator<StructField> i = fields().values().iterator(); i.hasNext();) {
StructField sf = i.next();
Object value = getFieldValue(sf.field);
String type = format(sf.type);
String index = "";
contents.append(prefix);
if (sf.type.isArray() && value != null) {
type = format(sf.type.getComponentType());
index = "[" + Array.getLength(value) + "]";
}
contents.append(String.format(" %s %s%s@0x%X", type, sf.name, index, sf.offset));
if (value instanceof UnidbgStructure) {
value = ((UnidbgStructure)value).toString(indent + 1, !(value instanceof Structure.ByReference), dumpMemory);
}
contents.append("=");
if (value instanceof Long) {
contents.append(String.format("0x%08X", value));
}
else if (value instanceof Integer) {
contents.append(String.format("0x%04X", value));
}
else if (value instanceof Short) {
contents.append(String.format("0x%02X", value));
}
else if (value instanceof Byte) {
contents.append(String.format("0x%01X", value));
}
else if (value instanceof byte[]) {
contents.append(Hex.encodeHexString((byte[]) value));
}
else {
contents.append(String.valueOf(value).trim());
}
contents.append(LS);
if (!i.hasNext())
contents.append(prefix).append("}");
}
if (indent == 0 && dumpMemory) {
final int BYTES_PER_ROW = 4;
contents.append(LS).append("memory dump").append(LS);
byte[] buf = getPointer().getByteArray(0, size());
for (int i=0;i < buf.length;i++) {
if ((i % BYTES_PER_ROW) == 0) contents.append("[");
if (buf[i] >=0 && buf[i] < 16)
contents.append("0");
contents.append(Integer.toHexString(buf[i] & 0xff));
if ((i % BYTES_PER_ROW) == BYTES_PER_ROW-1 && i < buf.length-1)
contents.append("]").append(LS);
}
contents.append("]");
}
return name + " {" + contents;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/signal/UnixSigSet.java | UnixSigSet | containsSigNumber | class UnixSigSet implements SigSet {
private long mask;
public UnixSigSet(long mask) {
this.mask = mask;
}
@Override
public long getMask() {
return mask;
}
@Override
public void setMask(long mask) {
this.mask = mask;
}
@Override
public void blockSigSet(long mask) {
this.mask |= mask;
}
@Override
public void unblockSigSet(long mask) {
this.mask &= ~mask;
}
@Override
public boolean containsSigNumber(int signum) {<FILL_FUNCTION_BODY>}
@Override
public void removeSigNumber(int signum) {
int bit = signum - 1;
this.mask &= (1L << bit);
}
@Override
public void addSigNumber(int signum) {
int bit = signum - 1;
this.mask |= (1L << bit);
}
private class SigSetIterator implements Iterator<Integer> {
public SigSetIterator(UnixSigSet sigSet) {
this.mask = sigSet.mask;
}
private long mask;
private int bit;
private int nextBit;
@Override
public boolean hasNext() {
for (int i = bit; i < 64; i++) {
if ((mask & (1L << i)) != 0) {
nextBit = i;
return true;
}
}
return false;
}
@Override
public Integer next() {
bit = nextBit;
this.mask &= ~(1L << bit);
return bit + 1;
}
@Override
public void remove() {
UnixSigSet.this.mask &= ~(1L << bit);
}
}
@Override
public Iterator<Integer> iterator() {
return new SigSetIterator(this);
}
@Override
public String toString() {
List<Integer> list = new ArrayList<>(10);
for (Integer signum : this) {
list.add(signum);
}
return list.toString();
}
} |
int bit = signum - 1;
return (mask & (1L << bit)) != 0;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/spi/Dlfcn.java | Dlfcn | dlsym | class Dlfcn implements HookListener, Serializable {
private static final Log log = LogFactory.getLog(Dlfcn.class);
protected final UnidbgPointer error;
protected Dlfcn(SvcMemory svcMemory) {
error = svcMemory.allocate(0x80, "Dlfcn.error");
assert error != null;
error.setMemory(0, 0x80, (byte) 0);
}
protected final long dlsym(Emulator<?> emulator, long handle, String symbolName) {<FILL_FUNCTION_BODY>}
@Override
public void serialize(DataOutput out) {
throw new UnsupportedOperationException();
}
} |
Memory memory = emulator.getMemory();
Symbol symbol = memory.dlsym(handle, symbolName);
if (symbol == null) {
log.info("Find symbol \"" + symbolName + "\" failed: handle=0x" + Long.toHexString(handle) + ", LR=" + emulator.getContext().getLRPointer());
this.error.setString(0, "Find symbol " + symbolName + " failed");
return 0;
}
return symbol.getAddress();
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/spi/ModulePatcher.java | ModulePatcher | onLoaded | class ModulePatcher implements ModuleListener {
private final String path;
public ModulePatcher(String path) {
this.path = path;
}
@Override
public final void onLoaded(Emulator<?> emulator, Module module) {<FILL_FUNCTION_BODY>}
protected abstract void patch32(Emulator<?> emulator, Module module);
protected abstract void patch64(Emulator<?> emulator, Module module);
} |
if (module.getPath().equals(path)) {
if (emulator.is32Bit()) {
patch32(emulator, module);
} else {
patch64(emulator, module);
}
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/AbstractTask.java | AbstractTask | addSignalTask | class AbstractTask extends BaseTask implements Task {
protected final int id;
public AbstractTask(int id) {
this.id = id;
}
private SigSet sigMaskSet;
private SigSet sigPendingSet;
@Override
public SigSet getSigMaskSet() {
return sigMaskSet;
}
@Override
public SigSet getSigPendingSet() {
return sigPendingSet;
}
@Override
public void setSigMaskSet(SigSet sigMaskSet) {
this.sigMaskSet = sigMaskSet;
}
@Override
public void setSigPendingSet(SigSet sigPendingSet) {
this.sigPendingSet = sigPendingSet;
}
@Override
public int getId() {
return id;
}
private final List<SignalTask> signalTaskList = new ArrayList<>();
@Override
public final void addSignalTask(SignalTask task) {<FILL_FUNCTION_BODY>}
@Override
public void removeSignalTask(SignalTask task) {
signalTaskList.remove(task);
}
@Override
public List<SignalTask> getSignalTaskList() {
return signalTaskList.isEmpty() ? Collections.<SignalTask>emptyList() : new ArrayList<>(signalTaskList);
}
@Override
public boolean setErrno(Emulator<?> emulator, int errno) {
return false;
}
@Override
protected final String getStatus() {
if (isFinish()) {
return "Finished";
} else if (canDispatch()) {
return "Runnable";
} else {
return "Paused";
}
}
} |
signalTaskList.add(task);
Waiter waiter = getWaiter();
if (waiter != null) {
waiter.onSignal(task);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/BaseTask.java | BaseTask | allocateStack | class BaseTask implements RunnableTask {
private static final Log log = LogFactory.getLog(BaseTask.class);
private Waiter waiter;
@Override
public void setWaiter(Emulator<?> emulator, Waiter waiter) {
this.waiter = waiter;
if (waiter != null &&
log.isTraceEnabled()) {
emulator.attach().debug();
}
}
@Override
public Waiter getWaiter() {
return waiter;
}
@Override
public final boolean canDispatch() {
if (waiter != null) {
return waiter.canDispatch();
}
return true;
}
private long context;
@Override
public final boolean isContextSaved() {
return this.context != 0;
}
@Override
public final void saveContext(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
if (this.context == 0) {
this.context = backend.context_alloc();
}
backend.context_save(this.context);
}
@Override
public void popContext(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
int off = emulator.popContext();
long pc;
if (emulator.is32Bit()) {
pc = backend.reg_read(ArmConst.UC_ARM_REG_PC).intValue() & 0xfffffffeL;
} else {
pc = backend.reg_read(Arm64Const.UC_ARM64_REG_PC).longValue();
}
backend.reg_write(emulator.is32Bit() ? ArmConst.UC_ARM_REG_PC : Arm64Const.UC_ARM64_REG_PC, pc + off);
saveContext(emulator);
}
@Override
public void restoreContext(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
backend.context_restore(this.context);
}
protected final Number continueRun(AbstractEmulator<?> emulator, long until) {
Backend backend = emulator.getBackend();
backend.context_restore(this.context);
long pc;
if (emulator.is32Bit()) {
pc = backend.reg_read(ArmConst.UC_ARM_REG_PC).intValue() & 0xfffffffeL;
if (ARM.isThumb(backend)) {
pc |= 1;
}
} else {
pc = backend.reg_read(Arm64Const.UC_ARM64_REG_PC).longValue();
}
if (log.isDebugEnabled()) {
log.debug("continue run task=" + this + ", pc=" + UnidbgPointer.pointer(emulator, pc) + ", until=0x" + Long.toHexString(until));
}
Waiter waiter = getWaiter();
if (waiter != null) {
waiter.onContinueRun(emulator);
setWaiter(emulator, null);
}
return emulator.emulate(pc, until);
}
@Override
public void destroy(Emulator<?> emulator) {
Backend backend = emulator.getBackend();
if (stackBlock != null) {
stackBlock.free();
stackBlock = null;
}
if (this.context != 0) {
backend.context_free(this.context);
this.context = 0;
}
if (destroyListener != null) {
destroyListener.onDestroy(emulator);
}
}
public static final int THREAD_STACK_SIZE = 0x80000;
private MemoryBlock stackBlock;
protected final UnidbgPointer allocateStack(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
@Override
public void setResult(Emulator<?> emulator, Number ret) {
}
private DestroyListener destroyListener;
@Override
public void setDestroyListener(DestroyListener listener) {
this.destroyListener = listener;
}
private final Stack<FunctionCall> stack = new Stack<>();
private final Bag<Long> bag = new HashBag<>();
@Override
public void pushFunction(Emulator<?> emulator, FunctionCall call) {
stack.push(call);
bag.add(call.returnAddress, 1);
if (log.isDebugEnabled()) {
log.debug("pushFunction call=" + call.toReadableString(emulator) + ", bagCount=" + bag.getCount(call.returnAddress));
}
}
@Override
public FunctionCall popFunction(Emulator<?> emulator, long address) {
if (!bag.contains(address)) {
return null;
}
FunctionCall call;
if (emulator.is64Bit()) { // check LR for aarch64
call = stack.peek();
long lr = emulator.getContext().getLR();
if (lr != call.returnAddress) {
return null;
}
bag.remove(address, 1);
stack.pop();
} else {
bag.remove(address, 1);
call = stack.pop();
}
if (log.isDebugEnabled()) {
log.debug("popFunction call=" + call.toReadableString(emulator) + ", address=" + UnidbgPointer.pointer(emulator, address) + ", stackSize=" + stack.size() + ", bagCount=" + bag.getCount(address));
}
if (call.returnAddress != address) {
for (FunctionCall fc : stack) {
log.warn("stackCall call=" + fc.toReadableString(emulator) + ", bagCount=" + bag.getCount(fc.returnAddress));
}
}
return call;
}
@Override
public final String toString() {
return getStatus() + "|" + toThreadString();
}
protected abstract String getStatus();
protected abstract String toThreadString();
} |
if (stackBlock == null) {
stackBlock = emulator.getMemory().malloc(THREAD_STACK_SIZE, true);
}
return stackBlock.getPointer().share(THREAD_STACK_SIZE, 0);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/Entry.java | Entry | run | class Entry extends MainTask {
private final long entry;
private final long sp;
public Entry(int pid, long entry, long until, long sp) {
super(pid, until);
this.entry = entry;
this.sp = sp;
}
@Override
protected Number run(AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>}
@Override
public String toThreadString() {
return "Executable entry=0x" + Long.toHexString(entry) + ", sp=0x" + Long.toHexString(sp);
}
} |
Backend backend = emulator.getBackend();
Memory memory = emulator.getMemory();
memory.setStackPoint(sp);
backend.reg_write(emulator.is64Bit() ? Arm64Const.UC_ARM64_REG_LR : ArmConst.UC_ARM_REG_LR, until);
return emulator.emulate(entry, until);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/Function32.java | Function32 | run | class Function32 extends MainTask {
private static final Log log = LogFactory.getLog(Function32.class);
private final long address;
private final boolean paddingArgument;
private final Number[] arguments;
public Function32(int pid, long address, long until, boolean paddingArgument, Number... arguments) {
super(pid, until);
this.address = address;
this.paddingArgument = paddingArgument;
this.arguments = arguments;
}
@Override
protected Number run(AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>}
@Override
public String toThreadString() {
return "Function32 address=0x" + Long.toHexString(address) + ", arguments=" + Arrays.toString(arguments);
}
} |
Backend backend = emulator.getBackend();
Memory memory = emulator.getMemory();
ARM.initArgs(emulator, paddingArgument, arguments);
long sp = memory.getStackPoint();
if (sp % 8 != 0) {
log.info("SP NOT 8 bytes aligned", new Exception(emulator.getStackPointer().toString()));
}
backend.reg_write(ArmConst.UC_ARM_REG_LR, until);
return emulator.emulate(address, until);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/Function64.java | Function64 | run | class Function64 extends MainTask {
private static final Log log = LogFactory.getLog(Function64.class);
private final long address;
private final boolean paddingArgument;
private final Number[] arguments;
public Function64(int pid, long address, long until, boolean paddingArgument, Number... arguments) {
super(pid, until);
this.address = address;
this.paddingArgument = paddingArgument;
this.arguments = arguments;
}
@Override
protected Number run(AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>}
@Override
public String toThreadString() {
return "Function64 address=0x" + Long.toHexString(address) + ", arguments=" + Arrays.toString(arguments);
}
} |
Backend backend = emulator.getBackend();
Memory memory = emulator.getMemory();
ARM.initArgs(emulator, paddingArgument, arguments);
long sp = memory.getStackPoint();
if (sp % 16 != 0) {
log.info("SP NOT 16 bytes aligned", new Exception(emulator.getStackPointer().toString()));
}
backend.reg_write(Arm64Const.UC_ARM64_REG_LR, until);
return emulator.emulate(address, until);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/MainTask.java | MainTask | dispatch | class MainTask extends AbstractTask implements Task {
protected final long until;
protected MainTask(int pid, long until) {
super(pid);
this.until = until;
}
@Override
public Number dispatch(AbstractEmulator<?> emulator) throws PopContextException {<FILL_FUNCTION_BODY>}
protected abstract Number run(AbstractEmulator<?> emulator);
@Override
public boolean isMainThread() {
return true;
}
@Override
public boolean isFinish() {
return false;
}
} |
if (isContextSaved()) {
return continueRun(emulator, until);
}
return run(emulator);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/ThreadContextSwitchException.java | ThreadContextSwitchException | syncReturnValue | class ThreadContextSwitchException extends LongJumpException {
private boolean setReturnValue;
private long returnValue;
public ThreadContextSwitchException setReturnValue(long returnValue) {
this.setReturnValue = true;
this.returnValue = returnValue;
return this;
}
private boolean setErrno;
private int errno;
public ThreadContextSwitchException setErrno(int errno) {
this.setErrno = true;
this.errno = errno;
return this;
}
public void syncReturnValue(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
} |
if (setReturnValue) {
Backend backend = emulator.getBackend();
backend.reg_write(emulator.is32Bit() ? ArmConst.UC_ARM_REG_R0 : Arm64Const.UC_ARM64_REG_X0, returnValue);
}
if (setErrno) {
emulator.getMemory().setErrno(errno);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/ThreadTask.java | ThreadTask | dispatch | class ThreadTask extends AbstractTask implements Task {
protected final long until;
protected ThreadTask(int tid, long until) {
super(tid);
this.until = until;
}
@Override
public final boolean isMainThread() {
return false;
}
private boolean finished;
@Override
public boolean isFinish() {
return finished;
}
protected int exitStatus;
public void setExitStatus(int status) {
this.exitStatus = status;
this.finished = true;
}
@Override
public final Number dispatch(AbstractEmulator<?> emulator) throws PopContextException {<FILL_FUNCTION_BODY>}
protected abstract Number runThread(AbstractEmulator<?> emulator);
} |
if (isContextSaved()) {
return continueRun(emulator, until);
}
return runThread(emulator);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/thread/UniThreadDispatcher.java | UniThreadDispatcher | sendSignal | class UniThreadDispatcher implements ThreadDispatcher {
private static final Log log = LogFactory.getLog(UniThreadDispatcher.class);
private final List<Task> taskList = new ArrayList<>();
private final AbstractEmulator<?> emulator;
public UniThreadDispatcher(AbstractEmulator<?> emulator) {
this.emulator = emulator;
}
private final List<ThreadTask> threadTaskList = new ArrayList<>();
@Override
public void addThread(ThreadTask task) {
threadTaskList.add(task);
}
@Override
public List<Task> getTaskList() {
return taskList;
}
@Override
public boolean sendSignal(int tid, int sig, SignalTask signalTask) {<FILL_FUNCTION_BODY>}
private RunnableTask runningTask;
@Override
public RunnableTask getRunningTask() {
return runningTask;
}
@Override
public Number runMainForResult(MainTask main) {
taskList.add(0, main);
if (log.isDebugEnabled()) {
log.debug("runMainForResult main=" + main);
}
Number ret = run(0, null);
for (Iterator<Task> iterator = taskList.iterator(); iterator.hasNext(); ) {
Task task = iterator.next();
if (task.isFinish()) {
if (log.isDebugEnabled()) {
log.debug("Finish task=" + task);
}
task.destroy(emulator);
iterator.remove();
for (SignalTask signalTask : task.getSignalTaskList()) {
signalTask.destroy(emulator);
task.removeSignalTask(signalTask);
}
}
}
return ret;
}
@Override
public void runThreads(long timeout, TimeUnit unit) {
if (timeout <= 0 || unit == null) {
throw new IllegalArgumentException("Invalid timeout.");
}
run(timeout, unit);
}
private Number run(long timeout, TimeUnit unit) {
try {
long start = System.currentTimeMillis();
while (true) {
if (taskList.isEmpty()) {
throw new IllegalStateException();
}
for (Iterator<Task> iterator = taskList.iterator(); iterator.hasNext(); ) {
Task task = iterator.next();
if (task.isFinish()) {
continue;
}
if (task.canDispatch()) {
if (log.isDebugEnabled()) {
log.debug("Start dispatch task=" + task);
}
emulator.set(Task.TASK_KEY, task);
if(task.isContextSaved()) {
task.restoreContext(emulator);
for (SignalTask signalTask : task.getSignalTaskList()) {
if (signalTask.canDispatch()) {
if (log.isDebugEnabled()) {
log.debug("Start run signalTask=" + signalTask);
}
SignalOps ops = task.isMainThread() ? this : task;
try {
this.runningTask = signalTask;
Number ret = signalTask.callHandler(ops, emulator);
if (log.isDebugEnabled()) {
log.debug("End run signalTask=" + signalTask + ", ret=" + ret);
}
if (ret != null) {
signalTask.setResult(emulator, ret);
signalTask.destroy(emulator);
task.removeSignalTask(signalTask);
} else {
signalTask.saveContext(emulator);
}
} catch (PopContextException e) {
this.runningTask.popContext(emulator);
}
} else if (log.isDebugEnabled()) {
log.debug("Skip call handler signalTask=" + signalTask);
}
}
}
try {
this.runningTask = task;
Number ret = task.dispatch(emulator);
if (log.isDebugEnabled()) {
log.debug("End dispatch task=" + task + ", ret=" + ret);
}
if (ret != null) {
task.setResult(emulator, ret);
task.destroy(emulator);
iterator.remove();
if(task.isMainThread()) {
return ret;
}
} else {
task.saveContext(emulator);
}
} catch(PopContextException e) {
this.runningTask.popContext(emulator);
}
} else {
if (log.isTraceEnabled() && task.isContextSaved()) {
task.restoreContext(emulator);
log.trace("Skip dispatch task=" + task);
emulator.getUnwinder().unwind();
} else if (log.isDebugEnabled()) {
log.debug("Skip dispatch task=" + task);
}
}
}
Collections.reverse(threadTaskList);
for (Iterator<ThreadTask> iterator = threadTaskList.iterator(); iterator.hasNext(); ) {
taskList.add(0, iterator.next());
iterator.remove();
}
if (timeout > 0 && unit != null &&
System.currentTimeMillis() - start >= unit.toMillis(timeout)) {
return null;
}
if (taskList.isEmpty()) {
return null;
}
if (log.isDebugEnabled()) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException ignored) {
}
}
}
} finally {
this.runningTask = null;
emulator.set(Task.TASK_KEY, null);
}
}
@Override
public int getTaskCount() {
return taskList.size() + threadTaskList.size();
}
private SigSet mainThreadSigMaskSet;
private SigSet mainThreadSigPendingSet;
@Override
public SigSet getSigMaskSet() {
return mainThreadSigMaskSet;
}
@Override
public void setSigMaskSet(SigSet sigMaskSet) {
this.mainThreadSigMaskSet = sigMaskSet;
}
@Override
public SigSet getSigPendingSet() {
return mainThreadSigPendingSet;
}
@Override
public void setSigPendingSet(SigSet sigPendingSet) {
this.mainThreadSigPendingSet = sigPendingSet;
}
} |
List<Task> list = new ArrayList<>();
list.addAll(taskList);
list.addAll(threadTaskList);
boolean ret = false;
for (Task task : list) {
SignalOps signalOps = null;
if (tid == 0 && task.isMainThread()) {
signalOps = this;
}
if (tid == task.getId()) {
signalOps = task;
}
if (signalOps == null) {
continue;
}
SigSet sigSet = signalOps.getSigMaskSet();
SigSet sigPendingSet = signalOps.getSigPendingSet();
if (sigPendingSet == null) {
sigPendingSet = new UnixSigSet(0);
signalOps.setSigPendingSet(sigPendingSet);
}
if (sigSet != null && sigSet.containsSigNumber(sig)) {
sigPendingSet.addSigNumber(sig);
return false;
}
if (signalTask != null) {
task.addSignalTask(signalTask);
if (log.isTraceEnabled()) {
emulator.attach().debug();
}
} else {
sigPendingSet.addSigNumber(sig);
}
ret = true;
break;
}
return ret;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unix/struct/StdString.java | StdString | createStdString | class StdString extends UnidbgStructure {
public static StdString createStdString(Emulator<?> emulator, Pointer pointer) {<FILL_FUNCTION_BODY>}
StdString(Pointer p) {
super(p);
}
public final String getValue(Emulator<?> emulator) {
return new String(getData(emulator), StandardCharsets.UTF_8);
}
public final byte[] getData(Emulator<?> emulator) {
return getDataPointer(emulator).getByteArray(0, (int) getDataSize());
}
public abstract Pointer getDataPointer(Emulator<?> emulator);
public abstract long getDataSize();
} |
if (emulator.is64Bit()) {
return new StdString64(pointer);
} else {
return new StdString32(pointer);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unix/struct/StdString32.java | StdString32 | getDataPointer | class StdString32 extends StdString {
StdString32(Pointer p) {
super(p);
unpack();
}
public byte isTiny;
public int size;
public int value;
@Override
protected List<String> getFieldOrder() {
return Arrays.asList("isTiny", "size", "value");
}
public Pointer getDataPointer(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
@Override
public long getDataSize() {
boolean isTiny = (this.isTiny & 1) == 0;
if (isTiny) {
return (this.isTiny & 0xff) >> 1;
} else {
return size;
}
}
} |
boolean isTiny = (this.isTiny & 1) == 0;
if (isTiny) {
return getPointer().share(1);
} else {
return UnidbgPointer.pointer(emulator, value);
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unix/struct/StdString64.java | StdString64 | getDataSize | class StdString64 extends StdString {
StdString64(Pointer p) {
super(p);
unpack();
}
public byte isTiny;
public long size;
public long value;
@Override
protected List<String> getFieldOrder() {
return Arrays.asList("isTiny", "size", "value");
}
@Override
public Pointer getDataPointer(Emulator<?> emulator) {
boolean isTiny = (this.isTiny & 1) == 0;
if (isTiny) {
return getPointer().share(1);
} else {
return UnidbgPointer.pointer(emulator, value);
}
}
@Override
public long getDataSize() {<FILL_FUNCTION_BODY>}
} |
boolean isTiny = (this.isTiny & 1) == 0;
if (isTiny) {
return (this.isTiny & 0xff) >> 1;
} else {
return size;
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unix/struct/TimeSpec.java | TimeSpec | createTimeSpec | class TimeSpec extends UnidbgStructure {
public static TimeSpec createTimeSpec(Emulator<?> emulator, Pointer ptr) {<FILL_FUNCTION_BODY>}
public TimeSpec(Pointer p) {
super(p);
}
public abstract long getTvSec();
public abstract long getTvNsec();
public long toMillis() {
return getTvSec() * 1000L + getTvNsec() / 1000000L;
}
public void setMillis(long millis) {
if (millis < 0) {
millis = 0;
}
long tvSec = millis / 1000L;
long tvNsec = millis % 1000L * 1000000L;
setTv(tvSec, tvNsec);
}
protected abstract void setTv(long tvSec, long tvNsec);
} |
if (ptr == null) {
return null;
}
TimeSpec timeSpec = emulator.is32Bit() ? new TimeSpec32(ptr) : new TimeSpec64(ptr);
timeSpec.unpack();
return timeSpec;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unwind/SimpleARM64Unwinder.java | SimpleARM64Unwinder | unw_step | class SimpleARM64Unwinder extends Unwinder {
public SimpleARM64Unwinder(Emulator<?> emulator) {
super(emulator);
}
@Override
protected String getBaseFormat() {
return "[0x%09x]";
}
@Override
public Frame createFrame(UnidbgPointer ip, UnidbgPointer fp) {
if (ip != null) {
if (ip.peer == emulator.getReturnAddress()) {
return new Frame(ip, null);
}
ip = ip.share(-4, 0);
return new Frame(ip, fp);
} else {
return null;
}
}
private Frame initFrame(Emulator<?> emulator) {
UnidbgPointer ip = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_LR);
UnidbgPointer fp = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_FP);
return createFrame(ip, fp);
}
@Override
protected Frame unw_step(Emulator<?> emulator, Frame frame) {<FILL_FUNCTION_BODY>}
} |
if (frame == null) {
return initFrame(emulator);
}
if (frame.fp == null) {
System.err.println("fp is null");
return null;
}
UnidbgPointer ip = frame.fp.getPointer(8);
UnidbgPointer fp = frame.fp.getPointer(0);
return createFrame(ip, fp);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unwind/SimpleARMUnwinder.java | SimpleARMUnwinder | createFrame | class SimpleARMUnwinder extends Unwinder {
public SimpleARMUnwinder(Emulator<?> emulator) {
super(emulator);
}
@Override
protected String getBaseFormat() {
return "[0x%08x]";
}
@Override
public Frame createFrame(UnidbgPointer ip, UnidbgPointer fp) {<FILL_FUNCTION_BODY>}
private Frame initFrame(Emulator<?> emulator) {
UnidbgPointer ip = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_LR);
UnidbgPointer fp = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_R7);
return createFrame(ip, fp);
}
@Override
protected Frame unw_step(Emulator<?> emulator, Frame frame) {
if (frame == null) {
return initFrame(emulator);
}
UnidbgPointer sp = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_SP);
if (frame.fp == null || frame.fp.peer < sp.peer) {
System.err.println("fp=" + frame.fp + ", sp=" + sp);
return null;
}
UnidbgPointer ip = frame.fp.getPointer(4);
UnidbgPointer fp = frame.fp.getPointer(0);
return createFrame(ip, fp);
}
} |
if (ip != null) {
if (ip.peer == emulator.getReturnAddress()) {
return new Frame(ip, null);
}
return new Frame(ARM.adjust_ip(ip), fp);
} else {
return null;
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/unwind/Unwinder.java | Unwinder | unwind | class Unwinder {
public static final int SYMBOL_SIZE = 0x1000;
protected final Emulator<?> emulator;
protected Unwinder(Emulator<?> emulator) {
this.emulator = emulator;
}
public abstract Frame createFrame(UnidbgPointer ip, UnidbgPointer fp);
protected abstract Frame unw_step(Emulator<?> emulator, Frame frame);
protected abstract String getBaseFormat();
public final void unwind() {<FILL_FUNCTION_BODY>}
private void printFrameElement(String maxLengthSoName, Memory memory, UnidbgPointer ip) {
final int maxLength = maxLengthSoName.length();
SvcMemory svcMemory = emulator.getSvcMemory();
MemRegion region = svcMemory.findRegion(ip.peer);
Module module = region != null ? null : AbstractARMDebugger.findModuleByAddress(emulator, ip.peer);
StringBuilder sb = new StringBuilder();
String format = getBaseFormat();
if (module != null) {
sb.append(String.format(format, module.base)).append(String.format(format, ip.peer));
sb.append(String.format("[%" + maxLength + "s]", module.name));
sb.append(String.format("[0x%0" + Long.toHexString(memory.getMaxSizeOfLibrary()).length() + "x]", ip.peer - module.base));
Symbol symbol = module.findClosestSymbolByAddress(ip.peer, false);
if (symbol != null && ip.peer - symbol.getAddress() <= SYMBOL_SIZE) {
GccDemangler demangler = DemanglerFactory.createDemangler();
sb.append(" ").append(demangler.demangle(symbol.getName())).append(" + 0x").append(Long.toHexString(ip.peer - (symbol.getAddress() & ~1)));
}
} else {
sb.append(String.format(format, 0)).append(String.format(format, ip.peer));
if (region == null) {
sb.append(String.format("[%" + maxLength + "s]", "0x" + Long.toHexString(ip.peer)));
} else {
sb.append(String.format("[%" + maxLength + "s]", region.getName().substring(0, Math.min(maxLength, region.getName().length()))));
}
if (ip.peer >= svcMemory.getBase()) {
sb.append(String.format("[0x%0" + Long.toHexString(memory.getMaxSizeOfLibrary()).length() + "x]", ip.peer - svcMemory.getBase()));
}
}
System.out.println(sb);
}
} |
Memory memory = emulator.getMemory();
String maxLengthSoName = memory.getMaxLengthLibraryName();
boolean hasTrace = false;
Frame frame = null;
while((frame = unw_step(emulator, frame)) != null) {
if (frame.isFinish()) {
if (!hasTrace) {
System.out.println("Decode backtrace finish");
}
return;
}
hasTrace = true;
printFrameElement(maxLengthSoName, memory, frame.ip);
}
if (!hasTrace) {
System.err.println("Decode backtrace failed.");
}
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/utils/JarURL.java | JarURL | create | class JarURL implements AutoCloseable {
static JarURL create(URL url) {<FILL_FUNCTION_BODY>}
final File jar;
final String name;
private final List<File> cleanupList;
private JarURL(File jar, String name, List<File> cleanupList) {
this.jar = jar;
this.name = name;
this.cleanupList = cleanupList;
}
@Override
public void close() {
for (File file : cleanupList) {
FileUtils.deleteQuietly(file);
}
}
final JarEntry getJarEntry() {
JarEntry foundEntry = null;
try (JarFile jarFile = new JarFile(jar)) {
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
String entryName = jarEntry.getName();
if (name.equals(entryName) || (name + "/").equals(entryName)) {
foundEntry = jarEntry;
break;
}
}
if (foundEntry == null) {
throw new IllegalStateException("find failed: jar=" + jar + ", name=" + name);
}
return foundEntry;
} catch (IOException e) {
throw new IllegalStateException("jar=" + jar, e);
}
}
} |
String path = url.getPath();
int index = path.indexOf("!");
if (index == -1) {
throw new IllegalStateException(path);
}
String jarPath = path.substring(5, index);
String name = path.substring(index + 2);
File jar;
try {
jar = new File(URLDecoder.decode(jarPath, "UTF-8"));
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("jarPath=" + jarPath);
}
List<File> cleanupList = new ArrayList<>();
while ((index = name.indexOf("!")) != -1) {
String jarEntryName = name.substring(0, index);
name = name.substring(index + 2);
JarEntry foundEntry = null;
try (JarFile jarFile = new JarFile(jar)) {
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
String entryName = jarEntry.getName();
if (jarEntryName.equals(entryName)) {
foundEntry = jarEntry;
break;
}
}
if (foundEntry == null || foundEntry.isDirectory()) {
throw new IllegalStateException("find failed: jar=" + jar + ", jarEntryName=" + jarEntryName + ", name=" + name + ", foundEntry=" + foundEntry);
}
jar = File.createTempFile(FilenameUtils.getName(jarEntryName), "");
try (InputStream inputStream = jarFile.getInputStream(foundEntry);
OutputStream outputStream = new FileOutputStream(jar)) {
IOUtils.copy(inputStream, outputStream);
}
cleanupList.add(jar);
} catch (IOException e) {
throw new IllegalStateException(url.toString(), e);
}
}
return new JarURL(jar, name, cleanupList);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/utils/ResourceUtils.java | ResourceUtils | toFile | class ResourceUtils {
public static File toFile(URL url) {<FILL_FUNCTION_BODY>}
} |
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
try {
return new File(url.toURI());
} catch (URISyntaxException e) {
throw new IllegalStateException(url.toString(), e);
}
}
return null;
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/virtualmodule/VirtualModule.java | VirtualModule | register | class VirtualModule<T> {
private static final Log log = LogFactory.getLog(VirtualModule.class);
private final String name;
private final Map<String, UnidbgPointer> symbols = new HashMap<>();
protected VirtualModule(Emulator<?> emulator, String name) {
this(emulator, null, name);
}
protected VirtualModule(Emulator<?> emulator, T extra, String name) {
this.name = name;
onInitialize(emulator, extra, symbols);
}
protected abstract void onInitialize(Emulator<?> emulator, T extra, Map<String, UnidbgPointer> symbols);
public Module register(Memory memory) {<FILL_FUNCTION_BODY>}
} |
if (name == null || name.trim().length() < 1) {
throw new IllegalArgumentException("name is empty");
}
if (symbols.isEmpty()) {
throw new IllegalArgumentException("symbols is empty");
}
if (log.isDebugEnabled()) {
log.debug(String.format("Register virtual module[%s]: (%s)", name, symbols));
}
return memory.loadVirtualModule(name, symbols);
|
zhkl0228_unidbg | unidbg/unidbg-api/src/main/java/com/github/unidbg/worker/DefaultWorkerPool.java | DefaultWorkerPool | run | class DefaultWorkerPool implements WorkerPool, Runnable {
private static final Log log = LogFactory.getLog(DefaultWorkerPool.class);
private final BlockingQueue<Worker> releaseQueue = new LinkedBlockingQueue<>();
private final BlockingQueue<Worker> workers;
private final WorkerFactory factory;
private final int workerCount;
DefaultWorkerPool(WorkerFactory factory, int workerCount) {
if (NativeLibraryUtil.getArchitecture() == NativeLibraryUtil.Architecture.OSX_ARM64 && workerCount > 1) { // bug fix: unicorn backend for m1
workerCount = 1;
}
this.factory = factory;
this.workerCount = workerCount;
this.workers = new LinkedBlockingQueue<>(workerCount == 1 ? 1 : workerCount - 1);
Thread thread = new Thread(this, "worker pool for " + factory);
thread.start();
}
private boolean stopped;
private int created;
@Override
public void run() {<FILL_FUNCTION_BODY>}
private static void closeWorkers(BlockingQueue<Worker> queue) {
Worker worker;
while ((worker = queue.poll()) != null) {
worker.destroy();
}
}
@Override
public void close() {
stopped = true;
closeWorkers(workers);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Worker> T borrow(long timeout, TimeUnit unit) {
if (stopped) {
return null;
}
try {
return (T) workers.poll(timeout, unit);
} catch (InterruptedException e) {
log.warn("borrow failed", e);
return null;
}
}
@Override
public void release(Worker worker) {
if (stopped) {
worker.destroy();
} else {
if (!releaseQueue.offer(worker)) {
throw new IllegalStateException("Release worker failed.");
}
}
}
} |
while (!stopped) {
try {
Worker release = created >= workerCount ? releaseQueue.poll(10, TimeUnit.MILLISECONDS) : releaseQueue.poll();
if (release != null) {
workers.put(release);
continue;
}
if (created < workerCount) {
workers.put(factory.createWorker(this));
created++;
}
} catch (InterruptedException e) {
log.warn("worker pool loop failed", e);
break;
}
}
closeWorkers(releaseQueue);
closeWorkers(workers);
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/file/ios/DarwinFileSystem.java | DarwinFileSystem | unlink | class DarwinFileSystem extends BaseFileSystem<DarwinFileIO> implements FileSystem<DarwinFileIO>, IOConstants {
public DarwinFileSystem(Emulator<DarwinFileIO> emulator, File rootDir) {
super(emulator, rootDir);
}
@Override
protected void initialize(File rootDir) throws IOException {
super.initialize(rootDir);
FileUtils.forceMkdir(new File(rootDir, "private"));
}
@Override
public DarwinFileIO createSimpleFileIO(File file, int oflags, String path) {
return new SimpleFileIO(oflags, file, path);
}
@Override
public DarwinFileIO createDirectoryFileIO(File file, int oflags, String path) {
return new DirectoryFileIO(oflags, path, file);
}
@Override
protected DarwinFileIO createStdin(int oflags) {
return new Stdin(oflags);
}
@Override
protected DarwinFileIO createStdout(int oflags, File stdio, String pathname) {
return new Stdout(oflags, stdio, pathname, IO.STDERR.equals(pathname), null);
}
@Override
protected boolean hasCreat(int oflags) {
return (oflags & O_CREAT) != 0;
}
@Override
protected boolean hasDirectory(int oflags) {
return (oflags & O_DIRECTORY) != 0;
}
@Override
protected boolean hasAppend(int oflags) {
return (oflags & O_APPEND) != 0;
}
@Override
protected boolean hasExcl(int oflags) {
return (oflags & O_EXCL) != 0;
}
@Override
public void rmdir(String path) {
File dir = new File(rootDir, path);
if (dir.exists()) {
FileUtils.deleteQuietly(BaseDarwinFileIO.createAttrFile(dir));
}
super.rmdir(path);
}
@Override
public void unlink(String path) {<FILL_FUNCTION_BODY>}
@Override
public int rename(String oldPath, String newPath) {
File oldFile = new File(rootDir, oldPath);
if (oldFile.exists()) {
FileUtils.deleteQuietly(BaseDarwinFileIO.createAttrFile(oldFile));
}
return super.rename(oldPath, newPath);
}
} |
File file = new File(rootDir, path);
if (file.exists()) {
FileUtils.deleteQuietly(BaseDarwinFileIO.createAttrFile(file));
}
super.unlink(path);
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/file/ios/StatStructure.java | StatStructure | setLastModification | class StatStructure extends UnidbgStructure {
protected StatStructure(byte[] data) {
super(data);
}
public StatStructure(Pointer p) {
super(p);
}
public int st_dev; /* [XSI] ID of device containing file */
public short st_mode; /* [XSI] Mode of file (see below) */
public short st_nlink; /* [XSI] Number of hard links */
public long st_ino; /* [XSI] File serial number */
public int st_uid; /* [XSI] User ID of the file */
public int st_gid; /* [XSI] Group ID of the file */
public int st_rdev; /* [XSI] Device ID */
public long st_size; /* [XSI] file size, in bytes */
public long st_blocks; /* [XSI] blocks allocated for file */
public int st_blksize; /* [XSI] optimal blocksize for I/O */
public int st_flags; /* user defined flags for file */
public int st_gen; /* file generation number */
public void setSize(long size) {
this.st_size = size;
}
public void setBlockCount(long count) {
this.st_blocks = count;
}
public final void setLastModification(long lastModified) {<FILL_FUNCTION_BODY>}
public abstract void setSt_atimespec(long tv_sec, long tv_nsec);
public abstract void setSt_mtimespec(long tv_sec, long tv_nsec);
public abstract void setSt_ctimespec(long tv_sec, long tv_nsec);
public abstract void setSt_birthtimespec(long tv_sec, long tv_nsec);
} |
long tv_sec = lastModified / 1000L;
long tv_nsec = (lastModified % 1000) * 1000000L;
setSt_atimespec(tv_sec, tv_nsec);
setSt_mtimespec(tv_sec, tv_nsec);
setSt_ctimespec(tv_sec, tv_nsec);
setSt_birthtimespec(tv_sec, tv_nsec);
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/hook/HookLoader.java | HookLoader | load | class HookLoader extends BaseHook {
private static final Log log = LogFactory.getLog(HookLoader.class);
public static HookLoader load(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
private final Symbol _hook_objc_msgSend;
private final Symbol _hook_dispatch_async;
private HookLoader(Emulator<?> emulator) {
super(emulator, "libhook");
_hook_objc_msgSend = module.findSymbolByName("_hook_objc_msgSend", false);
if (_hook_objc_msgSend == null) {
throw new IllegalStateException("find _hook_objc_msgSend failed");
}
_hook_dispatch_async = module.findSymbolByName("_hook_dispatch_async", false);
if (_hook_dispatch_async == null) {
throw new IllegalStateException("find _hook_dispatch_async failed");
}
}
private boolean objcMsgSendHooked;
public synchronized void hookObjcMsgSend(final MsgSendCallback callback) {
if (objcMsgSendHooked) {
throw new IllegalStateException("objc_msgSend already hooked.");
}
SvcMemory svcMemory = emulator.getSvcMemory();
Pointer pointer = callback == null ? null : svcMemory.registerSvc(emulator.is64Bit() ? new Arm64Svc() {
@Override
public long handle(Emulator<?> emulator) {
return objc_msgSend_callback(emulator, callback);
}
} : new ArmSvc() {
@Override
public long handle(Emulator<?> emulator) {
return objc_msgSend_callback(emulator, callback);
}
});
_hook_objc_msgSend.call(emulator, pointer);
objcMsgSendHooked = true;
}
private boolean dispatchAsyncHooked;
public synchronized void hookDispatchAsync(final DispatchAsyncCallback callback) {
if (dispatchAsyncHooked) {
throw new IllegalStateException("dispatch_async already hooked.");
}
if (emulator.is32Bit()) {
throw new UnsupportedOperationException();
}
SvcMemory svcMemory = emulator.getSvcMemory();
Pointer pointer = callback == null ? null : svcMemory.registerSvc(new Arm64Svc() {
@Override
public long handle(Emulator<?> emulator) {
return dispatch_callback(emulator, callback);
}
});
_hook_dispatch_async.call(emulator, pointer);
dispatchAsyncHooked = true;
}
private long dispatch_callback(Emulator<?> emulator, DispatchAsyncCallback callback) {
RegisterContext context = emulator.getContext();
Pointer dq = context.getPointerArg(0);
Pointer block = context.getPointerArg(1);
Pointer fun = block.getPointer(0x10);
boolean is_barrier_async = context.getIntArg(2) != 0;
boolean dispatch = callback.canDispatch(emulator, dq, fun, is_barrier_async);
if (!dispatch && (log.isDebugEnabled() || LogFactory.getLog(AbstractEmulator.class).isDebugEnabled())) {
System.err.println("Skip dispatch_async dq=" + dq + ", fun=" + fun);
}
return dispatch ? 1 : 0;
}
private long objc_msgSend_callback(Emulator<?> emulator, MsgSendCallback callback) {
RegisterContext context = emulator.getContext();
boolean systemClass = context.getIntArg(0) != 0;
Pointer classNamePointer = context.getPointerArg(1);
String cmd = context.getPointerArg(2).getString(0);
Pointer lr = context.getPointerArg(3);
callback.onMsgSend(emulator, systemClass, classNamePointer == null ? null : classNamePointer.getString(0), cmd, lr);
return 0;
}
} |
Substrate.getInstance(emulator); // load substrate first
FishHook.getInstance(emulator); // load fishhook
HookLoader loader = emulator.get(HookLoader.class.getName());
if (loader == null) {
loader = new HookLoader(emulator);
emulator.set(HookLoader.class.getName(), loader);
}
return loader;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/BaseLoader.java | BaseLoader | addEnv | class BaseLoader implements Loader {
private static final Log log = LogFactory.getLog(BaseLoader.class);
protected final List<BackendFactory> backendFactories = new ArrayList<>(5);
public void addBackendFactory(BackendFactory backendFactory) {
this.backendFactories.add(backendFactory);
}
protected boolean overrideResolver;
public void useOverrideResolver() {
this.overrideResolver = true;
}
protected DarwinResolver createLibraryResolver() {
return new DarwinResolver();
}
protected static String parseExecutable(NSDictionary info) throws IOException {
NSString bundleExecutable = (NSString) info.get("CFBundleExecutable");
return bundleExecutable.getContent();
}
protected static String parseVersion(NSDictionary info) throws IOException {
NSString bundleVersion = (NSString) info.get("CFBundleVersion");
return bundleVersion.getContent();
}
protected static String parseCFBundleIdentifier(NSDictionary info) throws IOException {
NSString bundleIdentifier = (NSString) info.get("CFBundleIdentifier");
return bundleIdentifier.getContent();
}
public static void addEnv(List<String> list) {<FILL_FUNCTION_BODY>}
protected boolean forceCallInit;
@SuppressWarnings("unused")
public void setForceCallInit(boolean forceCallInit) {
this.forceCallInit = forceCallInit;
}
public static final String APP_DIR = "/var/containers/Bundle/Application/";
} |
list.add("OBJC_DISABLE_PREOPTIMIZATION=YES"); // disable preoptimization courtesy of dyld shared cache
list.add("OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES"); // disable safety checks for +initialize after fork
list.add("OBJC_DISABLE_TAGGED_POINTERS=YES");
list.add("OBJC_DISABLE_TAG_OBFUSCATION=YES");
if (log.isDebugEnabled()) {
list.add("OBJC_HELP=YES"); // describe available environment variables
list.add("OBJC_PRINT_OPTIONS=YES"); // list which options are set
list.add("OBJC_PRINT_CLASS_SETUP=YES"); // log progress of class and category setup
list.add("OBJC_PRINT_INITIALIZE_METHODS=YES"); // log calls to class +initialize methods
list.add("OBJC_PRINT_PROTOCOL_SETUP=YES"); // log progress of protocol setup
list.add("OBJC_PRINT_IVAR_SETUP=YES"); // log processing of non-fragile ivars
list.add("OBJC_PRINT_VTABLE_SETUP=YES"); // log processing of class vtables
list.add("OBJC_PRINT_IMAGES=YES"); // log image and library names as they are loaded
list.add("OBJC_PRINT_IMAGE_TIMES=YES"); // measure duration of image loading steps
list.add("OBJC_PRINT_LOAD_METHODS=YES"); // log calls to class and category +load methods
list.add("OBJC_PRINT_RESOLVED_METHODS=YES"); // log methods created by +resolveClassMethod: and +resolveInstanceMethod:
list.add("OBJC_PRINT_PREOPTIMIZATION=YES"); // log preoptimization courtesy of dyld shared cache
list.add("OBJC_PRINT_EXCEPTIONS=YES"); // log exception handling
list.add("OBJC_DEBUG_FRAGILE_SUPERCLASSES=YES"); // warn about subclasses that may have been broken by subsequent changes to superclasses
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/DarwinARM64Emulator.java | DarwinARM64Emulator | setupTraps | class DarwinARM64Emulator extends AbstractARM64Emulator<DarwinFileIO> {
protected DarwinARM64Emulator(String processName, File rootDir, Collection<BackendFactory> backendFactories, String... envs) {
super(processName, rootDir, Family.iOS, backendFactories, envs);
}
@Override
protected FileSystem<DarwinFileIO> createFileSystem(File rootDir) {
return new DarwinFileSystem(this, rootDir);
}
protected void setupTraps() {<FILL_FUNCTION_BODY>}
@Override
protected Memory createMemory(UnixSyscallHandler<DarwinFileIO> syscallHandler, String[] envs) {
return new MachOLoader(this, syscallHandler, envs);
}
@Override
protected Dlfcn createDyld(SvcMemory svcMemory) {
return new Dyld64((MachOLoader) memory, svcMemory);
}
@Override
protected UnixSyscallHandler<DarwinFileIO> createSyscallHandler(SvcMemory svcMemory) {
return new ARM64SyscallHandler(svcMemory);
}
@Override
public LibraryFile createURLibraryFile(URL url, String libName) {
return new URLibraryFile(url, "/vendor/lib/" + libName, null);
}
@Override
protected int getPageAlignInternal() {
return 0x4000;
}
@Override
protected boolean isPaddingArgument() {
return false;
}
@Override
protected void dumpClass(String className) {
IClassDumper classDumper = ClassDumper.getInstance(this);
String classData = classDumper.dumpClass(className);
System.out.println("dumpClass\n" + classData);
}
@Override
protected void searchClass(String keywords) {
IClassDumper classDumper = ClassDumper.getInstance(this);
classDumper.searchClass(keywords);
}
@Override
protected void dumpGPBProtobufMsg(String className) {
System.out.println(GPBDescriptor.toProtobufDef(this, ObjC.getInstance(this), className));
}
} |
super.setupTraps();
try {
int size = 0x10000;
backend.mem_map(MachO._KERNEL_BASE64, size, UnicornConst.UC_PROT_READ | UnicornConst.UC_PROT_EXEC);
long _COMM_PAGE_MEMORY_SIZE = (MachO._COMM_PAGE64_BASE_ADDRESS+0x038); // uint64_t max memory size */
Pointer commPageMemorySize = UnidbgPointer.pointer(this, _COMM_PAGE_MEMORY_SIZE);
if (commPageMemorySize != null) {
commPageMemorySize.setLong(0, 0);
}
long _COMM_PAGE_NCPUS = (MachO._COMM_PAGE64_BASE_ADDRESS+0x022); // uint8_t number of configured CPUs
Pointer commPageNCpus = UnidbgPointer.pointer(this, _COMM_PAGE_NCPUS);
if (commPageNCpus != null) {
commPageNCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_ACTIVE_CPUS = (MachO._COMM_PAGE64_BASE_ADDRESS+0x034); // uint8_t number of active CPUs (hw.activecpu)
Pointer commPageActiveCpus = UnidbgPointer.pointer(this, _COMM_PAGE_ACTIVE_CPUS);
if (commPageActiveCpus != null) {
commPageActiveCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_PHYSICAL_CPUS = (MachO._COMM_PAGE64_BASE_ADDRESS+0x035); // uint8_t number of physical CPUs (hw.physicalcpu_max)
Pointer commPagePhysicalCpus = UnidbgPointer.pointer(this, _COMM_PAGE_PHYSICAL_CPUS);
if (commPagePhysicalCpus != null) {
commPagePhysicalCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_LOGICAL_CPUS = (MachO._COMM_PAGE64_BASE_ADDRESS+0x036); // uint8_t number of logical CPUs (hw.logicalcpu_max)
Pointer commPageLogicalCpus = UnidbgPointer.pointer(this, _COMM_PAGE_LOGICAL_CPUS);
if (commPageLogicalCpus != null) {
commPageLogicalCpus.setByte(0, (byte) 1);
}
} catch(BackendException ignored) { // hypervisor backend
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/DarwinARMEmulator.java | DarwinARMEmulator | setupTraps | class DarwinARMEmulator extends AbstractARMEmulator<DarwinFileIO> {
protected DarwinARMEmulator(String processName, File rootDir, Collection<BackendFactory> backendFactories, String... envs) {
super(processName, rootDir, Family.iOS, backendFactories, envs);
}
@Override
protected FileSystem<DarwinFileIO> createFileSystem(File rootDir) {
return new DarwinFileSystem(this, rootDir);
}
@Override
protected void setupTraps() {<FILL_FUNCTION_BODY>}
@Override
protected Memory createMemory(UnixSyscallHandler<DarwinFileIO> syscallHandler, String[] envs) {
return new MachOLoader(this, syscallHandler, envs);
}
@Override
protected Dlfcn createDyld(SvcMemory svcMemory) {
return new Dyld32((MachOLoader) memory, svcMemory);
}
@Override
protected UnixSyscallHandler<DarwinFileIO> createSyscallHandler(SvcMemory svcMemory) {
return new ARM32SyscallHandler(svcMemory);
}
@Override
public LibraryFile createURLibraryFile(URL url, String libName) {
return new URLibraryFile(url, "/vendor/lib/" + libName, null);
}
@Override
protected boolean isPaddingArgument() {
return false;
}
@Override
protected void dumpClass(String className) {
IClassDumper classDumper = ClassDumper.getInstance(this);
String classData = classDumper.dumpClass(className);
System.out.println("dumpClass\n" + classData);
}
@Override
protected void searchClass(String keywords) {
IClassDumper classDumper = ClassDumper.getInstance(this);
classDumper.searchClass(keywords);
}
} |
super.setupTraps();
long _COMM_PAGE_MEMORY_SIZE = (MachO._COMM_PAGE32_BASE_ADDRESS+0x038); // uint64_t max memory size */
Pointer commPageMemorySize = UnidbgPointer.pointer(this, _COMM_PAGE_MEMORY_SIZE);
if (commPageMemorySize != null) {
commPageMemorySize.setLong(0, 0);
}
long _COMM_PAGE_NCPUS = (MachO._COMM_PAGE32_BASE_ADDRESS+0x022); // uint8_t number of configured CPUs
Pointer commPageNCpus = UnidbgPointer.pointer(this, _COMM_PAGE_NCPUS);
if (commPageNCpus != null) {
commPageNCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_ACTIVE_CPUS = (MachO._COMM_PAGE32_BASE_ADDRESS+0x034); // uint8_t number of active CPUs (hw.activecpu)
Pointer commPageActiveCpus = UnidbgPointer.pointer(this, _COMM_PAGE_ACTIVE_CPUS);
if (commPageActiveCpus != null) {
commPageActiveCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_PHYSICAL_CPUS = (MachO._COMM_PAGE32_BASE_ADDRESS+0x035); // uint8_t number of physical CPUs (hw.physicalcpu_max)
Pointer commPagePhysicalCpus = UnidbgPointer.pointer(this, _COMM_PAGE_PHYSICAL_CPUS);
if (commPagePhysicalCpus != null) {
commPagePhysicalCpus.setByte(0, (byte) 1);
}
long _COMM_PAGE_LOGICAL_CPUS = (MachO._COMM_PAGE32_BASE_ADDRESS+0x036); // uint8_t number of logical CPUs (hw.logicalcpu_max)
Pointer commPageLogicalCpus = UnidbgPointer.pointer(this, _COMM_PAGE_LOGICAL_CPUS);
if (commPageLogicalCpus != null) {
commPageLogicalCpus.setByte(0, (byte) 1);
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/DarwinEmulatorBuilder.java | DarwinEmulatorBuilder | build | class DarwinEmulatorBuilder extends EmulatorBuilder<ARMEmulator<DarwinFileIO>> {
public static DarwinEmulatorBuilder for32Bit() {
return new DarwinEmulatorBuilder(false);
}
public static DarwinEmulatorBuilder for64Bit() {
return new DarwinEmulatorBuilder(true);
}
protected DarwinEmulatorBuilder(boolean is64Bit) {
super(is64Bit);
IpaLoader.addEnv(envList);
}
protected final List<String> envList = new ArrayList<>();
public DarwinEmulatorBuilder addEnv(String env) {
envList.add(env);
return this;
}
@Override
public ARMEmulator<DarwinFileIO> build() {<FILL_FUNCTION_BODY>}
} |
return is64Bit ?
new DarwinARM64Emulator(processName, rootDir, backendFactories, envList.toArray(new String[0])) :
new DarwinARMEmulator(processName, rootDir, backendFactories, envList.toArray(new String[0]));
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/DarwinResolver.java | DarwinResolver | resolve | class DarwinResolver implements LibraryResolver, IOResolver<DarwinFileIO> {
private static final String LIB_VERSION = "7.1";
private static final String OVERRIDE_VERSION = "override";
private final String version;
private final List<String> excludeLibs = new ArrayList<>();
public DarwinResolver(String... excludeLibs) {
this(LIB_VERSION, excludeLibs);
}
private DarwinResolver(String version, String... excludeLibs) {
this.version = version;
Collections.addAll(this.excludeLibs, excludeLibs);
}
private boolean override;
public DarwinResolver setOverride() {
this.override = true;
return this;
}
@Override
public LibraryFile resolveLibrary(Emulator<?> emulator, String libraryName) {
return resolveLibrary(libraryName, getClass());
}
private static final Pattern SYSTEM_LIBRARY_FRAMEWORK_PATTERN = Pattern.compile("/System/Library/Frameworks/(\\w+).framework/Versions/[A-C]/(\\w+)");
LibraryFile resolveLibrary(String libraryName, Class<?> resClass) {
if (libraryName.contains("@")) {
return null;
}
if (libraryName.startsWith(IpaLoader.APP_DIR)) {
return null;
}
libraryName = FilenameUtils.normalize(libraryName, true);
if (!excludeLibs.isEmpty() && excludeLibs.contains(FilenameUtils.getName(libraryName))) {
return null;
}
Matcher systemLibraryFrameworkMatcher = SYSTEM_LIBRARY_FRAMEWORK_PATTERN.matcher(libraryName);
if (systemLibraryFrameworkMatcher.find()) {
String f1 = systemLibraryFrameworkMatcher.group(1);
String f2 = systemLibraryFrameworkMatcher.group(2);
if (f1.equals(f2)) {
libraryName = "/System/Library/Frameworks/" + f1 + ".framework/" + f1;
}
}
if (override) {
String name = "/ios/" + OVERRIDE_VERSION + libraryName.replace('+', 'p');
URL url = resClass.getResource(name);
if (url != null) {
return new URLibraryFile(url, libraryName, this);
}
}
String name = "/ios/" + version + libraryName.replace('+', 'p');
URL url = resClass.getResource(name);
if (url != null) {
return new URLibraryFile(url, libraryName, this);
}
return null;
}
@Override
public FileResult<DarwinFileIO> resolve(Emulator<DarwinFileIO> emulator, String path, int oflags) {<FILL_FUNCTION_BODY>}
private DarwinFileIO createFileIO(URL url, String pathname, int oflags) {
File file = ResourceUtils.toFile(url);
if (file != null) {
return createFileIO(file, pathname, oflags);
}
try {
URLConnection connection = url.openConnection();
try (InputStream inputStream = connection.getInputStream()) {
if (connection instanceof JarURLConnection) {
JarURLConnection jarURLConnection = (JarURLConnection) connection;
JarFile jarFile = jarURLConnection.getJarFile();
JarEntry entry = jarURLConnection.getJarEntry();
if (entry.isDirectory()) {
Enumeration<JarEntry> entryEnumeration = jarFile.entries();
List<DirectoryFileIO.DirectoryEntry> list = new ArrayList<>();
while (entryEnumeration.hasMoreElements()) {
JarEntry check = entryEnumeration.nextElement();
if (entry.getName().equals(check.getName())) {
continue;
}
if (check.getName().startsWith(entry.getName())) {
boolean isDir = check.isDirectory();
String sub = check.getName().substring(entry.getName().length());
if (isDir) {
sub = sub.substring(0, sub.length() - 1);
}
if (!sub.contains("/")) {
list.add(new DirectoryFileIO.DirectoryEntry(true, sub));
}
}
}
return new DirectoryFileIO(oflags, pathname, null, list.toArray(new DirectoryFileIO.DirectoryEntry[0]));
} else {
byte[] data = IOUtils.toByteArray(inputStream);
return new ByteArrayFileIO(oflags, pathname, data);
}
} else {
throw new IllegalStateException(connection.getClass().getName());
}
}
} catch (Exception e) {
throw new IllegalStateException(pathname, e);
}
}
private byte[] _GlobalPreferences;
private DarwinFileIO createFileIO(File file, String pathname, int oflags) {
if (file.canRead()) {
return file.isDirectory() ? new DirectoryFileIO(oflags, pathname, file) : new SimpleFileIO(oflags, file, pathname);
}
return null;
}
@Override
public void onSetToLoader(Emulator<?> emulator) {
Memory memory = emulator.getMemory();
memory.addModuleListener(new LibDispatchPatcher());
if (override) {
memory.addModuleListener(new NewObjcPatcher());
} else {
memory.addHookListener(new OldObjcPatcher());
}
}
} |
if ("".equals(path)) {
return FileResult.failed(UnixEmulator.ENOENT);
}
FileSystem<DarwinFileIO> fileSystem = emulator.getFileSystem();
if (".".equals(path)) {
return FileResult.success(createFileIO(fileSystem.createWorkDir(), path, oflags));
}
if (path.endsWith("/Library/Preferences/.GlobalPreferences.plist")) {
if (_GlobalPreferences == null) {
Locale locale = Locale.getDefault();
Map<String, Object> map = new HashMap<>();
map.put("AppleICUForce24HourTime", true);
map.put("AppleLanguages", new String[] { locale.getLanguage() });
map.put("AppleLocale", locale.toString());
NSDictionary root = (NSDictionary) NSDictionary.fromJavaObject(map);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try {
PropertyListParser.saveAsBinary(root, outputStream);
} catch (IOException e) {
throw new IllegalStateException("save .GlobalPreferences.plist failed", e);
}
_GlobalPreferences = outputStream.toByteArray();
}
return FileResult.<DarwinFileIO>success(new ByteArrayFileIO(oflags, path, _GlobalPreferences));
}
String iosResource = FilenameUtils.normalize("/ios/" + version + "/" + path, true);
URL url = getClass().getResource(iosResource);
if (url != null) {
return FileResult.fallback(createFileIO(url, path, oflags));
}
return null;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/DarwinUtils.java | DarwinUtils | getNetworkIFs | class DarwinUtils {
private static final Log log = LogFactory.getLog(DarwinUtils.class);
static class NetworkIF {
final NetworkInterface networkInterface;
public NetworkIF(NetworkInterface networkInterface) {
this.networkInterface = networkInterface;
}
@Override
public String toString() {
return networkInterface.getName();
}
}
static List<NetworkIF> getNetworkIFs(boolean verbose) throws SocketException {<FILL_FUNCTION_BODY>}
} |
Enumeration<NetworkInterface> enumeration = NetworkInterface.getNetworkInterfaces();
List<NetworkIF> list = new ArrayList<>();
while (enumeration.hasMoreElements()) {
NetworkInterface networkInterface = enumeration.nextElement();
if (networkInterface.getHardwareAddress() == null) {
continue;
}
Enumeration<InetAddress> addressEnumeration = networkInterface.getInetAddresses();
if (addressEnumeration.hasMoreElements()) {
list.add(new NetworkIF(networkInterface));
}
}
if (log.isDebugEnabled()) {
log.debug("Return host network ifs: " + list);
}
if (verbose) {
System.out.println("Return host network ifs: " + list);
}
return list;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/Dyld.java | Dyld | computeSlide | class Dyld extends Dlfcn {
private static final Log log = LogFactory.getLog(Dyld.class);
static final int dyld_image_state_bound = 40;
static final int dyld_image_state_dependents_initialized = 45; // Only single notification for this
static final int dyld_image_state_initialized = 50;
static final int dyld_image_state_terminated = 60; // Only single notification for this
static final int RTLD_FIRST = 0x100; /* Mac OS X 10.5 and later */
static final int RTLD_NEXT = (-1); /* Search subsequent objects. */
static final int RTLD_DEFAULT = (-2); /* Use default search algorithm. */
static final int RTLD_SELF = (-3); /* Search this and subsequent objects (Mac OS X 10.5 and later) */
static final int RTLD_MAIN_ONLY = (-5); /* Search main executable only (Mac OS X 10.5 and later) */
static final int ASL_OPT_STDERR = 0x00000001;
Dyld(SvcMemory svcMemory) {
super(svcMemory);
}
abstract int _stub_binding_helper();
public static long computeSlide(Emulator<?> emulator, long machHeader) {<FILL_FUNCTION_BODY>}
abstract int _dyld_func_lookup(Emulator<?> emulator, String name, Pointer address);
protected final UnidbgStructure[] registerImageStateBatchChangeHandler(MachOLoader loader, int state, UnidbgPointer handler, Emulator<?> emulator) {
if (log.isDebugEnabled()) {
log.debug("registerImageStateBatchChangeHandler state=" + state + ", handler=" + handler);
}
if (state != dyld_image_state_bound) {
throw new UnsupportedOperationException("state=" + state);
}
if (loader.boundHandlers.contains(handler)) {
return null;
}
loader.boundHandlers.add(handler);
return generateDyldImageInfo(emulator, loader, state, handler);
}
private UnidbgStructure[] generateDyldImageInfo(Emulator<?> emulator, MachOLoader loader, int state, UnidbgPointer handler) {
SvcMemory svcMemory = emulator.getSvcMemory();
List<UnidbgStructure> list = new ArrayList<>(loader.getLoadedModulesNoVirtual().size());
int elementSize = UnidbgStructure.calculateSize(emulator.is64Bit() ? DyldImageInfo64.class : DyldImageInfo32.class);
Pointer pointer = svcMemory.allocate(elementSize * loader.getLoadedModulesNoVirtual().size(), "DyldImageInfo");
List<Module> loadedModules = new ArrayList<>(loader.getLoadedModulesNoVirtual());
for (Module module : loadedModules) {
if (module == loader.getExecutableModule()) {
continue;
}
if (loader.isPayloadModule(module)) {
continue;
}
if (log.isDebugEnabled()) {
log.debug("generateDyldImageInfo: " + module.name);
}
MachOModule mm = (MachOModule) module;
if (emulator.is64Bit()) {
DyldImageInfo64 info = new DyldImageInfo64(pointer);
info.imageFilePath = UnidbgPointer.nativeValue(mm.createPathMemory(svcMemory));
info.imageLoadAddress = mm.machHeader;
info.imageFileModDate = 0;
info.pack();
list.add(info);
} else {
DyldImageInfo32 info = new DyldImageInfo32(pointer);
info.imageFilePath = (int) UnidbgPointer.nativeValue(mm.createPathMemory(svcMemory));
info.imageLoadAddress = (int) mm.machHeader;
info.imageFileModDate = 0;
info.pack();
list.add(info);
}
pointer = pointer.share(elementSize);
if (state == dyld_image_state_bound) {
mm.boundCallSet.add(handler);
mm.initializedCallSet.add(handler);
} else if (state == dyld_image_state_dependents_initialized) {
mm.dependentsInitializedCallSet.add(handler);
}
}
return list.toArray(new UnidbgStructure[0]);
}
protected final UnidbgStructure[] registerImageStateSingleChangeHandler(MachOLoader loader, int state, UnidbgPointer handler, Emulator<?> emulator) {
if (log.isDebugEnabled()) {
log.debug("registerImageStateSingleChangeHandler state=" + state + ", handler=" + handler);
}
if (state == dyld_image_state_terminated) {
return null;
}
if (state != dyld_image_state_dependents_initialized) {
throw new UnsupportedOperationException("state=" + state);
}
if (loader.initializedHandlers.contains(handler)) {
return null;
}
loader.initializedHandlers.add(handler);
return generateDyldImageInfo(emulator, loader, state, handler);
}
} |
Pointer pointer = UnidbgPointer.pointer(emulator, machHeader);
assert pointer != null;
MachHeader header = emulator.is32Bit() ? new MachHeader(pointer) : new MachHeader64(pointer);
header.unpack();
Pointer loadPointer = pointer.share(header.size());
for (int i = 0; i < header.ncmds; i++) {
LoadCommand loadCommand = new LoadCommand(loadPointer);
loadCommand.unpack();
if (loadCommand.type == io.kaitai.MachO.LoadCommandType.SEGMENT.id() ||
loadCommand.type == MachO.LoadCommandType.SEGMENT_64.id()) {
SegmentCommand segmentCommand = emulator.is64Bit() ? new SegmentCommand64(loadPointer) : new SegmentCommand32(loadPointer);
segmentCommand.unpack();
if ("__TEXT".equals(segmentCommand.getSegName())) {
return (machHeader - segmentCommand.getVmAddress());
}
}
loadPointer = loadPointer.share(loadCommand.size);
}
return 0;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/ExportSymbol.java | ExportSymbol | getValue | class ExportSymbol extends Symbol implements MachO {
private final long address;
private final MachOModule module;
private final long other;
private final int flags;
public ExportSymbol(String name, long address, Module module, long other, int flags) {
super(name);
this.address = address;
this.module = (MachOModule) module;
this.other = other;
this.flags = flags;
}
public boolean isReExport() {
return (flags & EXPORT_SYMBOL_FLAGS_REEXPORT) != 0;
}
public long getOtherWithBase() {
return module.base + other;
}
@Override
public Number call(Emulator<?> emulator, Object... args) {
return module.callFunction(emulator, getValue(), args);
}
private boolean isAbsoluteSymbol() {
return (flags & EXPORT_SYMBOL_FLAGS_KIND_MASK) == EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE;
}
private boolean isRegularSymbol() {
return (flags & EXPORT_SYMBOL_FLAGS_KIND_MASK) == EXPORT_SYMBOL_FLAGS_KIND_REGULAR;
}
@Override
public long getAddress() {
if (isAbsoluteSymbol()) {
return address;
} else if(isRegularSymbol()) {
return module.machHeader + address;
} else {
throw new IllegalStateException("flags=0x" + Integer.toHexString(flags));
}
}
@Override
public long getValue() {<FILL_FUNCTION_BODY>}
@Override
public boolean isUndef() {
return false;
}
@Override
public String getModuleName() {
return module.name;
}
public long getOther() {
return other;
}
} |
if (isRegularSymbol()) {
return address;
} else {
throw new UnsupportedOperationException("flags=0x" + Integer.toHexString(flags));
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/IndirectSymbol.java | IndirectSymbol | checkSymbol | class IndirectSymbol extends Symbol {
private final MachOModule module;
final String symbol;
IndirectSymbol(String name, MachOModule module, String symbol) {
super(name);
this.module = module;
this.symbol = symbol;
}
private Symbol actualSymbol;
final Symbol resolveSymbol() {
if (actualSymbol != null) {
return actualSymbol;
}
actualSymbol = module.findSymbolByName(symbol, false);
if (actualSymbol == null) {
MachOSymbol ms = module.otherSymbols.get(symbol);
if (ms != null) {
if (!ms.isExternalSymbol()) {
throw new UnsupportedOperationException(symbol);
}
int ordinal = ms.getLibraryOrdinal();
if (ordinal <= module.ordinalList.size()) {
String path = module.ordinalList.get(ordinal - 1);
MachOModule reexportedFrom = module.loader.modules.get(FilenameUtils.getName(path));
if (reexportedFrom != null) {
actualSymbol = reexportedFrom.findSymbolByName(symbol, false);
}
} else {
throw new IllegalStateException("ordinal=" + ordinal);
}
}
}
if (actualSymbol == null) {
throw new IllegalStateException("symbol=" + symbol);
}
return actualSymbol;
}
private Symbol checkSymbol() {<FILL_FUNCTION_BODY>}
@Override
public Number call(Emulator<?> emulator, Object... args) {
return checkSymbol().call(emulator, args);
}
@Override
public long getAddress() {
return checkSymbol().getAddress();
}
@Override
public long getValue() {
return checkSymbol().getValue();
}
@Override
public boolean isUndef() {
return checkSymbol().isUndef();
}
@Override
public String getModuleName() {
return checkSymbol().getModuleName();
}
} |
Symbol symbol = resolveSymbol();
if (symbol == null) {
throw new IllegalStateException("symbol is null");
}
return symbol;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/MachOLibraryFile.java | MachOLibraryFile | resolveLibrary | class MachOLibraryFile implements LibraryFile {
protected final File file;
protected MachOLibraryFile(File file) {
this.file = file;
}
@Override
public long getFileSize() {
return file.length();
}
@Override
public String getName() {
return file.getName();
}
@Override
public String getMapRegionName() {
return getPath();
}
@Override
public LibraryFile resolveLibrary(Emulator<?> emulator, String soName) {<FILL_FUNCTION_BODY>}
@Override
public ByteBuffer mapBuffer() throws IOException {
return Utils.mapBuffer(file);
}
@Override
public String getPath() {
return "/vendor/lib/" + file.getName();
}
} |
File file = new File(this.file.getParentFile(), soName);
return file.canRead() ? new MachOLibraryFile(file) : null;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/MachOModuleInit.java | MachOModuleInit | call | class MachOModuleInit extends InitFunction {
private static final Log log = LogFactory.getLog(MachOModuleInit.class);
private final UnidbgPointer envp;
private final UnidbgPointer apple;
private final UnidbgPointer vars;
private final boolean isModInit;
MachOModuleInit(MachOModule module, UnidbgPointer envp, UnidbgPointer apple, UnidbgPointer vars, boolean isModInit, long address) {
super(module.base, module.name, address);
this.envp = envp;
this.apple = apple;
this.vars = vars;
this.isModInit = isModInit;
}
@Override
public long getAddress() {
return load_base + address;
}
/**
* initializer(int argc, const char* argv[], const char* envp[], const char* apple[], const struct ProgramVars* vars)
*/
public long call(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
// (int argc, const char* argv[], const char* envp[], const char* apple[], const struct ProgramVars* vars)
private static void callModInit(Emulator<?> emulator, long address, int argc, UnidbgPointer argv, UnidbgPointer envp, UnidbgPointer apple, UnidbgPointer vars) {
List<Number> list = new ArrayList<>(5);
list.add(argc);
list.add(argv == null ? null : new PointerNumber(UnidbgPointer.pointer(emulator, argv.peer)));
list.add(envp == null ? null : new PointerNumber(UnidbgPointer.pointer(emulator, envp.peer)));
list.add(apple == null ? null : new PointerNumber(UnidbgPointer.pointer(emulator, apple.peer)));
list.add(vars == null ? null : new PointerNumber(UnidbgPointer.pointer(emulator, vars.peer)));
emulator.eFunc(address, list.toArray(new Number[0]));
}
} |
// emulator.traceCode();
if (isModInit) {
log.debug("[" + libName + "]CallInitFunction: 0x" + Long.toHexString(address));
} else {
log.debug("[" + libName + "]CallRoutineFunction: 0x" + Long.toHexString(address));
}
// emulator.attach().addBreakPoint(null, 0x401d6be6);
// emulator.attach().addBreakPoint(null, 0x402fb538);
long start = System.currentTimeMillis();
callModInit(emulator, load_base + address, 0, null, envp, apple, vars);
if (log.isDebugEnabled()) {
if (isModInit) {
System.err.println("[" + libName + "]CallInitFunction: 0x" + Long.toHexString(address) + ", offset=" + (System.currentTimeMillis() - start) + "ms");
} else {
System.err.println("[" + libName + "]CallRoutineFunction: 0x" + Long.toHexString(address) + ", offset=" + (System.currentTimeMillis() - start) + "ms");
}
}
return load_base + address;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/MachOSymbol.java | MachOSymbol | call | class MachOSymbol extends Symbol implements com.github.unidbg.ios.MachO {
private final MachOModule module;
final MachO.SymtabCommand.Nlist nlist;
private final int type;
MachOSymbol(MachOModule module, MachO.SymtabCommand.Nlist nlist, String name) {
super(name);
this.module = module;
this.nlist = nlist;
this.type = nlist.type() & N_TYPE;
}
@Override
public Number call(Emulator<?> emulator, Object... args) {<FILL_FUNCTION_BODY>}
@Override
public long getAddress() {
if (type == N_ABS) {
return getValue();
}
return module.base + getValue();
}
@Override
public long getValue() {
boolean isThumb = (nlist.desc() & N_ARM_THUMB_DEF) != 0;
return nlist.value() + (isThumb ? 1 : 0);
}
public int getLibraryOrdinal() {
return (nlist.desc() >> 8) & 0xff;
}
@Override
public boolean isUndef() {
return type == N_UNDF;
}
public boolean isExternalSymbol() {
return (nlist.type() & N_EXT) != 0;
}
@Override
public String getModuleName() {
return module.name;
}
} |
if (type == N_ABS) {
throw new UnsupportedOperationException();
}
return module.callFunction(emulator, getValue(), args);
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/Segment.java | Segment | toString | class Segment {
final long vmAddr;
final long vmSize;
final long fileOffset;
final long fileSize;
Segment(long vmAddr, long vmSize, long fileOffset, long fileSize) {
this.vmAddr = vmAddr;
this.vmSize = vmSize;
this.fileOffset = fileOffset;
this.fileSize = fileSize;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
} |
return "Segment{" +
"vmAddr=0x" + Long.toHexString(vmAddr) +
", vmSize=0x" + Long.toHexString(vmSize) +
", offset=" + fileOffset +
", fileSize=0x" + Long.toHexString(fileSize) +
'}';
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/URLibraryFile.java | URLibraryFile | mapBuffer | class URLibraryFile implements LibraryFile {
private final URL url;
private final String path;
private final DarwinResolver resolver;
public URLibraryFile(URL url, String path, DarwinResolver resolver) {
this.url = url;
this.path = path;
this.resolver = resolver;
}
@Override
public String getName() {
return FilenameUtils.getName(path);
}
@Override
public String getMapRegionName() {
return getPath();
}
@Override
public LibraryFile resolveLibrary(Emulator<?> emulator, String dylibName) {
if (resolver == null) {
return null;
}
return resolver.resolveLibrary(dylibName, resolver.getClass());
}
@Override
public ByteBuffer mapBuffer() throws IOException {<FILL_FUNCTION_BODY>}
@Override
public long getFileSize() {
if ("file".equalsIgnoreCase(url.getProtocol())) {
return new File(url.getPath()).length();
} else {
try {
return IOUtils.toByteArray(url).length;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
@Override
public String getPath() {
return path;
}
} |
if ("file".equalsIgnoreCase(url.getProtocol())) {
return Utils.mapBuffer(new File(url.getPath()));
} else {
return ByteBuffer.wrap(IOUtils.toByteArray(url));
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/classdump/ClassDumper.java | ClassDumper | getInstance | class ClassDumper extends BaseHook implements IClassDumper {
public static ClassDumper getInstance(Emulator<?> emulator) {<FILL_FUNCTION_BODY>}
private ClassDumper(Emulator<?> emulator) {
super(emulator, "libclassdump");
}
@Override
public String dumpClass(String className) {
ObjC objc = ObjC.getInstance(emulator);
ObjcClass oClassDump = objc.getClass("ClassDump");
ObjcObject str = oClassDump.callObjc("my_dump_class:", className);
return str == null ? null : str.getDescription();
}
@Override
public void searchClass(String keywords) {
ObjC objc = ObjC.getInstance(emulator);
ObjcClass oClassDump = objc.getClass("ClassDump");
oClassDump.callObjc("search_class:", keywords);
}
} |
ClassDumper classDumper = emulator.get(ClassDumper.class.getName());
if (classDumper == null) {
classDumper = new ClassDumper(emulator);
emulator.set(ClassDumper.class.getName(), classDumper);
}
return classDumper;
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/dmg/DmgLibraryFile.java | DmgLibraryFile | resolveLibrary | class DmgLibraryFile implements LibraryFile {
private static final Log log = LogFactory.getLog(DmgLibraryFile.class);
private final String appDir;
private final String executable;
private final File file;
private final String bundleAppDir;
DmgLibraryFile(String appDir, String executable, String bundleAppDir, File file, String... loads) {
this(appDir, executable, bundleAppDir, file, Arrays.asList(loads));
}
private final List<String> loadList;
private DmgLibraryFile(String appDir, String executable, String bundleAppDir, File file, List<String> loadList) {
this.appDir = appDir;
this.executable = executable;
this.file = file;
this.bundleAppDir = bundleAppDir;
this.loadList = loadList;
}
@Override
public long getFileSize() {
return file.length();
}
@Override
public String getName() {
return executable;
}
@Override
public String getMapRegionName() {
return getPath();
}
@Override
public LibraryFile resolveLibrary(Emulator<?> emulator, String soName) {<FILL_FUNCTION_BODY>}
@Override
public ByteBuffer mapBuffer() throws IOException {
return Utils.mapBuffer(file);
}
@Override
public String getPath() {
return FilenameUtils.normalize(file.getPath(), true);
}
} |
if (!soName.contains("@")) {
return null;
}
String path = soName.replace("@executable_path", appDir);
if (log.isDebugEnabled()) {
log.debug("Try resolve library soName=" + soName + ", path=" + path);
}
if (path.contains("@")) {
log.warn("Try resolve library soName=" + soName + ", path=" + path);
return null;
}
if (!loadList.isEmpty() && !loadList.contains(FilenameUtils.getName(path))) {
return null;
}
File file = new File(path);
if (!file.exists() || !file.isFile()) {
return null;
} else {
return new DmgLibraryFile(appDir, soName, bundleAppDir, file, loadList);
}
|
zhkl0228_unidbg | unidbg/unidbg-ios/src/main/java/com/github/unidbg/ios/dmg/DmgLoader.java | DmgLoader | load64 | class DmgLoader extends BaseLoader {
private static final Log log = LogFactory.getLog(DmgLoader.class);
@SuppressWarnings("unused")
public final LoadedDmg load(String... loads) {
return load(null, loads);
}
public abstract LoadedDmg load(EmulatorConfigurator configurator, String... loads);
private final String appDir;
protected final File dmgDir;
protected final File rootDir;
private final String executable;
private final String bundleVersion;
private final String bundleIdentifier;
protected final String executableBundlePath;
DmgLoader(File dmgDir, File rootDir) {
this.dmgDir = dmgDir;
this.rootDir = rootDir;
this.appDir = FilenameUtils.normalize(dmgDir.getPath(), true);
File infoFile = new File(dmgDir, "Contents/Info.plist");
if (!infoFile.exists() || !infoFile.isFile()) {
throw new IllegalStateException("Invalid dmg app dir: " + dmgDir);
}
try {
NSDictionary info = (NSDictionary) PropertyListParser.parse(infoFile);
this.executable = parseExecutable(info);
this.bundleVersion = parseVersion(info);
this.bundleIdentifier = parseCFBundleIdentifier(info);
} catch (IOException | PropertyListFormatException | ParseException | ParserConfigurationException | SAXException e) {
throw new IllegalStateException("load " + dmgDir.getAbsolutePath() + " failed", e);
}
this.executableBundlePath = generateExecutableBundlePath();
}
private String generateExecutableBundlePath() {
File executable = new File(dmgDir, "Contents/MacOS/" + this.executable);
if (!executable.exists() || !executable.isFile()) {
throw new IllegalStateException("Invalid executable: " + executable);
}
return executable.getAbsolutePath();
}
protected void config(final Emulator<DarwinFileIO> emulator, File dmgDir) {
SyscallHandler<DarwinFileIO> syscallHandler = emulator.getSyscallHandler();
syscallHandler.addIOResolver(new DmgResolver(dmgDir));
emulator.getMemory().addHookListener(new SymbolResolver(emulator));
}
protected Emulator<DarwinFileIO> createEmulator(File rootDir) throws IOException {
return new DarwinARM64Emulator(executableBundlePath, rootDir, backendFactories, getEnvs(rootDir)) {
};
}
LoadedDmg load64(EmulatorConfigurator configurator, String... loads) throws IOException {<FILL_FUNCTION_BODY>}
protected String[] getEnvs(File rootDir) throws IOException {
List<String> list = new ArrayList<>();
list.add("OBJC_PRINT_EXCEPTION_THROW=YES"); // log backtrace of every objc_exception_throw()
addEnv(list);
UUID uuid = UUID.nameUUIDFromBytes((bundleIdentifier + "_Documents").getBytes(StandardCharsets.UTF_8));
String homeDir = "/var/mobile/Containers/Data/Application/" + uuid.toString().toUpperCase();
list.add("CFFIXED_USER_HOME=" + homeDir);
FileUtils.forceMkdir(new File(rootDir, homeDir));
return list.toArray(new String[0]);
}
private LoadedDmg load(Emulator<DarwinFileIO> emulator, String bundleAppDir, EmulatorConfigurator configurator, String... loads) {
MachOLoader loader = (MachOLoader) emulator.getMemory();
loader.setLoader(this);
File executableFile = new File(executableBundlePath);
Module module = loader.load(new DmgLibraryFile(executableFile.getParent(), executable, bundleAppDir, executableFile, loads), forceCallInit);
if (configurator != null) {
configurator.onExecutableLoaded(emulator, (MachOModule) module);
}
loader.onExecutableLoaded(executable);
return new LoadedDmg(emulator, module, bundleIdentifier, bundleVersion);
}
@Override
public final boolean isPayloadModule(String path) {
return path.startsWith(appDir);
}
} |
String bundleAppDir = new File(executableBundlePath).getParentFile().getParentFile().getPath();
File rootDir = new File(this.rootDir, bundleVersion);
Emulator<DarwinFileIO> emulator = createEmulator(rootDir);
emulator.getSyscallHandler().setVerbose(log.isDebugEnabled());
if (configurator != null) {
configurator.configure(emulator, executableBundlePath, rootDir, bundleIdentifier);
}
config(emulator, dmgDir);
Memory memory = emulator.getMemory();
DarwinResolver resolver = createLibraryResolver();
if (overrideResolver) {
resolver.setOverride();
}
memory.setLibraryResolver(resolver);
return load(emulator, bundleAppDir, configurator, loads);
|