Datasets:

echodrift

/

java-dataset-filtered-19.05.24

like 0

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/NetworkIF.java

NetworkIF

getIfName

class NetworkIF { public final int index; public final String ifName; public final Inet4Address ipv4; public final Inet4Address broadcast; public NetworkIF(int index, String ifName, Inet4Address ipv4) { this(index, ifName, ipv4, null); } public NetworkIF(int index, String ifName, Inet4Address ipv4, Inet4Address broadcast) { this.index = index; this.ifName = getIfName(ifName); this.ipv4 = ipv4; this.broadcast = broadcast; } private String getIfName(String ifName) {<FILL_FUNCTION_BODY>} public boolean isLoopback() { return ifName.startsWith("lo"); } @Override public String toString() { return ifName; } }

if ("lo0".equals(ifName)) { return "lo"; } if ("en0".equals(ifName)) { return "wlan0"; } return ifName;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/NullFileIO.java

NullFileIO

read

class NullFileIO extends BaseAndroidFileIO implements FileIO { private final String path; public NullFileIO(String path) { super(IOConstants.O_RDWR); this.path = path; } private boolean isTTY() { return "/dev/tty".equals(path); } @Override public void close() { } @Override public int write(byte[] data) { if (isTTY()) { try { System.out.write(data); } catch (IOException e) { throw new IllegalStateException(e); } } return data.length; } @Override public int lseek(int offset, int whence) { return 0; } @Override public int read(Backend backend, Pointer buffer, int count) {<FILL_FUNCTION_BODY>} @Override public int fstat(Emulator<?> emulator, StatStructure stat) { stat.st_size = 0; stat.st_blksize = 0; stat.pack(); return 0; } @Override public int ioctl(Emulator<?> emulator, long request, long argp) { return 0; } @Override public String toString() { return path; } }

if (isTTY()) { try { byte[] buf = new byte[count]; int read = System.in.read(buf); if (read <= 0) { return read; } buffer.write(0, Arrays.copyOf(buf, read), 0, read); return read; } catch (IOException e) { throw new IllegalStateException(e); } } return 0;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/PipedReadFileIO.java

PipedReadFileIO

canRead

class PipedReadFileIO extends BaseAndroidFileIO implements AndroidFileIO { private static final Log log = LogFactory.getLog(PipedReadFileIO.class); private final int writefd; private final PipedInputStream inputStream; public PipedReadFileIO(PipedInputStream inputStream, int writefd) { super(IOConstants.O_RDONLY); this.inputStream = inputStream; this.writefd = writefd; } @Override public int read(Backend backend, Pointer buffer, int count) { try { byte[] receiveBuf = new byte[Math.min(count, inputStream.available())]; int read = inputStream.read(receiveBuf, 0, receiveBuf.length); if (read <= 0) { return read; } byte[] data = Arrays.copyOf(receiveBuf, read); buffer.write(0, data, 0, data.length); if (log.isDebugEnabled()) { log.debug(Inspector.inspectString(data, "read fd=" + writefd)); } return data.length; } catch (IOException e) { throw new IllegalStateException(e); } } @Override public boolean canRead() {<FILL_FUNCTION_BODY>} @Override public void close() { try { inputStream.close(); } catch (IOException e) { throw new IllegalStateException(e); } } @Override public String toString() { return "PipedRead: " + writefd; } }

try { return inputStream.available() > 0; } catch (IOException e) { throw new IllegalStateException(e); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/PipedSocketIO.java

PipedSocketIO

sendto

class PipedSocketIO extends TcpSocket implements FileIO { private final PipedInputStream pipedInputStream = new PipedInputStream(); public PipedSocketIO(Emulator<?> emulator) { super(emulator); this.inputStream = new BufferedInputStream(pipedInputStream); this.outputStream = new PipedOutputStream(); } public void connectPeer(PipedSocketIO io) { try { ((PipedOutputStream) this.outputStream).connect(io.pipedInputStream); ((PipedOutputStream) io.outputStream).connect(this.pipedInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } @Override public int sendto(byte[] data, int flags, Pointer dest_addr, int addrlen) {<FILL_FUNCTION_BODY>} }

flags &= ~MSG_NOSIGNAL; final int MSG_EOR = 0x80; if (flags == MSG_EOR && dest_addr == null && addrlen == 0) { return write(data); } return super.sendto(data, flags, dest_addr, addrlen);

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/PipedWriteFileIO.java

PipedWriteFileIO

close

class PipedWriteFileIO extends BaseAndroidFileIO implements AndroidFileIO { private static final Log log = LogFactory.getLog(PipedWriteFileIO.class); private final int writefd; private final PipedOutputStream outputStream; public PipedWriteFileIO(PipedOutputStream outputStream, int writefd) { super(IOConstants.O_WRONLY); this.outputStream = outputStream; this.writefd = writefd; } @Override public int write(byte[] data) { try { if (log.isDebugEnabled()) { log.debug(Inspector.inspectString(data, "write fd=" + writefd)); } outputStream.write(data); return data.length; } catch (IOException e) { throw new IllegalStateException(e); } } @Override public void close() {<FILL_FUNCTION_BODY>} @Override public String toString() { return "PipedWrite: " + writefd; } }

try { outputStream.close(); } catch (IOException e) { throw new IllegalStateException(e); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/RandomFileIO.java

RandomFileIO

read

class RandomFileIO extends DriverFileIO { public RandomFileIO(Emulator<?> emulator, String path) { super(emulator, IOConstants.O_RDONLY, path); } @Override public int read(Backend backend, Pointer buffer, int count) {<FILL_FUNCTION_BODY>} protected void randBytes(byte[] bytes) { ThreadLocalRandom.current().nextBytes(bytes); } }

int total = 0; byte[] buf = new byte[Math.min(0x1000, count)]; randBytes(buf); Pointer pointer = buffer; while (total < count) { int read = Math.min(buf.length, count - total); pointer.write(0, buf, 0, read); total += read; pointer = pointer.share(read); } return total;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/SimpleFileIO.java

SimpleFileIO

lseek

class SimpleFileIO extends BaseAndroidFileIO implements NewFileIO { private static final Log log = LogFactory.getLog(SimpleFileIO.class); protected final File file; protected final String path; private RandomAccessFile _randomAccessFile; private synchronized RandomAccessFile checkOpenFile() { try { if (_randomAccessFile == null) { FileUtils.forceMkdir(file.getParentFile()); if (!file.exists() && !file.createNewFile()) { throw new IOException("createNewFile failed: " + file); } _randomAccessFile = new RandomAccessFile(file, "rws"); onFileOpened(_randomAccessFile); } return _randomAccessFile; } catch (IOException e) { throw new IllegalStateException(e); } } public SimpleFileIO(int oflags, File file, String path) { super(oflags); this.file = file; this.path = path; if (file.isDirectory()) { throw new IllegalArgumentException("file is directory: " + file); } if (!file.exists()) { throw new IllegalArgumentException("file not exists: " + file); } } void onFileOpened(RandomAccessFile randomAccessFile) throws IOException { } @Override public void close() { IOUtils.close(_randomAccessFile); if (debugStream != null) { try { debugStream.flush(); } catch (IOException ignored) { } } } @Override public int write(byte[] data) { try { if (debugStream != null) { debugStream.write(data); debugStream.flush(); } if (log.isDebugEnabled() && data.length < 0x3000) { Inspector.inspect(data, "write"); } RandomAccessFile randomAccessFile = checkOpenFile(); if ((oflags & IOConstants.O_APPEND) != 0) { randomAccessFile.seek(randomAccessFile.length()); } randomAccessFile.write(data); return data.length; } catch (IOException e) { throw new IllegalStateException(e); } } OutputStream debugStream; void setDebugStream(OutputStream stream) { this.debugStream = new BufferedOutputStream(stream); } @Override public int read(Backend backend, Pointer pointer, final int _count) { RandomAccessFile randomAccessFile = checkOpenFile(); return Utils.readFile(randomAccessFile, pointer, _count); } @Override public int fstat(Emulator<?> emulator, StatStructure stat) { int st_mode; if (IO.STDOUT.equals(file.getName())) { st_mode = IO.S_IFCHR | 0x777; } else if(Files.isSymbolicLink(file.toPath())) { st_mode = IO.S_IFLNK; } else { st_mode = IO.S_IFREG; } stat.st_dev = 1; stat.st_mode = st_mode; stat.st_uid = 0; stat.st_gid = 0; stat.st_size = file.length(); stat.st_blksize = emulator.getPageAlign(); stat.st_ino = 1; stat.st_blocks = ((file.length() + emulator.getPageAlign() - 1) / emulator.getPageAlign()); stat.setLastModification(file.lastModified()); stat.pack(); return 0; } @Override protected byte[] getMmapData(long addr, int offset, int length) throws IOException { RandomAccessFile randomAccessFile = checkOpenFile(); randomAccessFile.seek(offset); int remaining = (int) (randomAccessFile.length() - randomAccessFile.getFilePointer()); ByteArrayOutputStream baos = remaining <= 0 ? new ByteArrayOutputStream() : new ByteArrayOutputStream(Math.min(length, remaining)); byte[] buf = new byte[1024]; do { int count = length - baos.size(); if (count == 0) { break; } if (count > buf.length) { count = buf.length; } int read = randomAccessFile.read(buf, 0, count); if (read == -1) { break; } baos.write(buf, 0, read); } while (true); return baos.toByteArray(); } @Override public String toString() { return path; } @Override public int ioctl(Emulator<?> emulator, long request, long argp) { if (IO.STDOUT.equals(path) || IO.STDERR.equals(path)) { return 0; } return super.ioctl(emulator, request, argp); } @Override public FileIO dup2() { SimpleFileIO dup = new SimpleFileIO(oflags, file, path); dup.debugStream = debugStream; dup.op = op; dup.oflags = oflags; return dup; } @Override public int lseek(int offset, int whence) {<FILL_FUNCTION_BODY>} @Override public int llseek(long offset, Pointer result, int whence) { try { RandomAccessFile randomAccessFile = checkOpenFile(); switch (whence) { case SEEK_SET: randomAccessFile.seek(offset); result.setLong(0, randomAccessFile.getFilePointer()); return 0; case SEEK_END: randomAccessFile.seek(randomAccessFile.length() - offset); result.setLong(0, randomAccessFile.getFilePointer()); return 0; } } catch (IOException e) { throw new IllegalStateException(e); } return super.llseek(offset, result, whence); } @Override public int ftruncate(int length) { try (FileChannel channel = new FileOutputStream(file, true).getChannel()) { channel.truncate(length); return 0; } catch (IOException e) { log.debug("ftruncate failed", e); return -1; } } @Override public String getPath() { return path; } }

try { RandomAccessFile randomAccessFile = checkOpenFile(); switch (whence) { case SEEK_SET: randomAccessFile.seek(offset); return (int) randomAccessFile.getFilePointer(); case SEEK_CUR: randomAccessFile.seek(randomAccessFile.getFilePointer() + offset); return (int) randomAccessFile.getFilePointer(); case SEEK_END: randomAccessFile.seek(randomAccessFile.length() + offset); return (int) randomAccessFile.getFilePointer(); } } catch (IOException e) { throw new IllegalStateException(e); } return super.lseek(offset, whence);

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/Stdin.java

Stdin

read

class Stdin extends BaseAndroidFileIO implements AndroidFileIO { public Stdin(int oflags) { super(oflags); stdio = true; } @Override public void close() { } @Override public int write(byte[] data) { throw new AbstractMethodError(new String(data)); } @Override public int read(Backend backend, Pointer buffer, int count) {<FILL_FUNCTION_BODY>} @Override public int fstat(Emulator<?> emulator, com.github.unidbg.file.linux.StatStructure stat) { stat.st_mode = 0x0; stat.st_size = 0; stat.pack(); return 0; } @Override public FileIO dup2() { return this; } @Override public int ioctl(Emulator<?> emulator, long request, long argp) { return 0; } @Override public int getdents64(Pointer dirp, int size) { throw new UnsupportedOperationException(); } @Override public String toString() { return "stdin"; } }

try { byte[] data = new byte[count]; int read = System.in.read(data, 0, count); if (read <= 0) { return read; } buffer.write(0, Arrays.copyOf(data, read), 0, read); return read; } catch (IOException e) { throw new IllegalStateException(e); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/Stdout.java

Stdout

dup2

class Stdout extends SimpleFileIO { private static final Log log = LogFactory.getLog(Stdout.class); private final boolean err; private final PrintStream out; private final StdoutCallback callback; public Stdout(int oflags, File file, String path, boolean err, StdoutCallback callback) { super(oflags, file, path); this.callback = callback; this.err = err; out = err ? System.err : System.out; if (log.isDebugEnabled()) { setDebugStream(err ? System.err : System.out); } stdio = true; } @Override public void close() { super.close(); IOUtils.close(output); } private RandomAccessFile output; @Override public int write(byte[] data) { try { if (output == null) { output = new RandomAccessFile(file, "rw"); output.getChannel().truncate(0); } if (debugStream != null) { debugStream.write(data); } if (log.isWarnEnabled()) { out.write(data); out.flush(); } if (callback != null) { callback.notifyOut(data, err); } output.write(data); return data.length; } catch (IOException e) { throw new IllegalStateException(e); } } @Override public int lseek(int offset, int whence) { try { switch (whence) { case FileIO.SEEK_SET: output.seek(offset); return (int) output.getFilePointer(); case FileIO.SEEK_CUR: output.seek(output.getFilePointer() + offset); return (int) output.getFilePointer(); } } catch (IOException e) { throw new IllegalStateException(e); } return super.lseek(offset, whence); } @Override public int ftruncate(int length) { try { output.getChannel().truncate(length); return 0; } catch (IOException e) { throw new IllegalStateException(e); } } @Override public FileIO dup2() {<FILL_FUNCTION_BODY>} }

Stdout dup = new Stdout(0, file, path, err, callback); dup.debugStream = debugStream; dup.op = op; dup.oflags = oflags; return dup;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/file/ZeroFileIO.java

ZeroFileIO

read

class ZeroFileIO extends DriverFileIO { public ZeroFileIO(Emulator<?> emulator, int oflags, String path) { super(emulator, oflags, path); } @Override public int read(Backend backend, Pointer buffer, int count) {<FILL_FUNCTION_BODY>} @Override public int write(byte[] data) { return data.length; } @Override protected byte[] getMmapData(long addr, int offset, int length) { return new byte[length]; } }

int total = 0; byte[] buf = new byte[Math.min(0x1000, count)]; Pointer pointer = buffer; while (total < count) { int read = Math.min(buf.length, count - total); pointer.write(0, buf, 0, read); total += read; pointer = pointer.share(read); } return total;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/signal/SigAction.java

SigAction

create

class SigAction extends UnidbgStructure { private static final int SA_SIGINFO = 0x00000004; public static SigAction create(Emulator<?> emulator, Pointer ptr) {<FILL_FUNCTION_BODY>} public abstract long getSaHandler(); public abstract void setSaHandler(long sa_handler); public abstract long getSaRestorer(); public abstract void setSaRestorer(long sa_restorer); public boolean needSigInfo() { return (getFlags() & SA_SIGINFO) != 0; } public abstract long getMask(); public abstract void setMask(long mask); public abstract int getFlags(); public abstract void setFlags(int flags); public SigAction(Pointer p) { super(p); } }

if (ptr == null) { return null; } SigAction action; if (emulator.is32Bit()) { action = new SigAction32(ptr); } else { action = new SigAction64(ptr); } action.unpack(); return action;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/signal/SignalFunction.java

SignalFunction

run

class SignalFunction extends MainTask { private final int signum; private final SigAction action; public SignalFunction(Emulator<?> emulator, int signum, SigAction action) { super(emulator.getPid(), emulator.getReturnAddress()); this.signum = signum; this.action = action; } @Override public String toThreadString() { return "SignalFunction sa_handler=" + action.getSaHandler() + ", signum=" + signum; } private MemoryBlock infoBlock; @Override public void destroy(Emulator<?> emulator) { super.destroy(emulator); if (infoBlock != null) { infoBlock.free(); infoBlock = null; } } @Override protected Number run(AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>} }

Backend backend = emulator.getBackend(); if (action.needSigInfo() && infoBlock == null) { infoBlock = emulator.getMemory().malloc(128, true); infoBlock.getPointer().setInt(0, signum); } UnidbgPointer stack = allocateStack(emulator); if (emulator.is32Bit()) { backend.reg_write(ArmConst.UC_ARM_REG_SP, stack.peer); backend.reg_write(ArmConst.UC_ARM_REG_R0, signum); backend.reg_write(ArmConst.UC_ARM_REG_R1, infoBlock == null ? 0 : infoBlock.getPointer().peer); // siginfo_t *info backend.reg_write(ArmConst.UC_ARM_REG_R2, 0); // void *ucontext backend.reg_write(ArmConst.UC_ARM_REG_LR, until); } else { backend.reg_write(Arm64Const.UC_ARM64_REG_SP, stack.peer); backend.reg_write(Arm64Const.UC_ARM64_REG_X0, signum); backend.reg_write(Arm64Const.UC_ARM64_REG_X1, infoBlock == null ? 0 : infoBlock.getPointer().peer); // siginfo_t *info backend.reg_write(Arm64Const.UC_ARM64_REG_X2, 0); // void *ucontext backend.reg_write(Arm64Const.UC_ARM64_REG_LR, until); } return emulator.emulate(action.getSaHandler(), until);

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/signal/SignalTask.java

SignalTask

callHandler

class SignalTask extends AbstractSignalTask { private final SigAction action; public SignalTask(int signum, SigAction action) { this(signum, action, null); } public SignalTask(int signum, SigAction action, Pointer sig_info) { super(signum); this.action = action; this.sig_info = sig_info; } private Pointer sig_info; private UnidbgPointer stack; @Override public Number callHandler(SignalOps signalOps, AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>} private MemoryBlock ucontext; private Number runHandler(AbstractEmulator<?> emulator) { Backend backend = emulator.getBackend(); if (stack == null) { stack = allocateStack(emulator); } if (action.needSigInfo() && infoBlock == null && sig_info == null) { infoBlock = emulator.getMemory().malloc(128, true); infoBlock.getPointer().setInt(0, signum); sig_info = infoBlock.getPointer(); } if (ucontext == null) { ucontext = emulator.getMemory().malloc(0x1000, true); } if (emulator.is32Bit()) { backend.reg_write(ArmConst.UC_ARM_REG_SP, stack.peer); backend.reg_write(ArmConst.UC_ARM_REG_R0, signum); backend.reg_write(ArmConst.UC_ARM_REG_R1, UnidbgPointer.nativeValue(sig_info)); // siginfo_t *info backend.reg_write(ArmConst.UC_ARM_REG_R2, UnidbgPointer.nativeValue(ucontext.getPointer())); backend.reg_write(ArmConst.UC_ARM_REG_LR, emulator.getReturnAddress()); } else { backend.reg_write(Arm64Const.UC_ARM64_REG_SP, stack.peer); backend.reg_write(Arm64Const.UC_ARM64_REG_X0, signum); backend.reg_write(Arm64Const.UC_ARM64_REG_X1, UnidbgPointer.nativeValue(sig_info)); // siginfo_t *info backend.reg_write(Arm64Const.UC_ARM64_REG_X2, UnidbgPointer.nativeValue(ucontext.getPointer())); backend.reg_write(Arm64Const.UC_ARM64_REG_LR, emulator.getReturnAddress()); } return emulator.emulate(action.getSaHandler(), emulator.getReturnAddress()); } @Override public String toThreadString() { return "SignalTask sa_handler=0x" + Long.toHexString(action.getSaHandler()) + ", stack=" + stack + ", signum=" + signum; } private MemoryBlock infoBlock; @Override public void destroy(Emulator<?> emulator) { super.destroy(emulator); if (ucontext != null) { ucontext.free(); ucontext = null; } if (infoBlock != null) { infoBlock.free(); infoBlock = null; } } }

SigSet sigSet = signalOps.getSigMaskSet(); try { long sa_mask = action.getMask(); if (sigSet == null) { SigSet newSigSet = new UnixSigSet(sa_mask); signalOps.setSigMaskSet(newSigSet); } else { sigSet.blockSigSet(sa_mask); } if (isContextSaved()) { return continueRun(emulator, emulator.getReturnAddress()); } return runHandler(emulator); } finally { signalOps.setSigMaskSet(sigSet); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/struct/IFReq.java

IFReq

setName

class IFReq extends UnidbgStructure { static final int IFNAMSIZ = 16; public static IFReq createIFReq(Emulator<?> emulator, Pointer pointer) { return emulator.is64Bit() ? new IFReq64(pointer) : new IFReq32(pointer); } IFReq(Pointer p) { super(p); } public Pointer getAddrPointer() { return getPointer().share(IFNAMSIZ); } public void setName(String name) {<FILL_FUNCTION_BODY>} public byte[] ifrn_name = new byte[IFNAMSIZ]; }

byte[] data = name.getBytes(StandardCharsets.UTF_8); if (data.length >= IFNAMSIZ) { throw new IllegalStateException("name=" + name); } ifrn_name = Arrays.copyOf(data, IFNAMSIZ);

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/ClonePatcher32.java

ClonePatcher32

handle

class ClonePatcher32 extends ArmSvc { private static final Log log = LogFactory.getLog(ClonePatcher32.class); private final ThreadJoinVisitor visitor; private final AtomicLong value_ptr; private int threadId; public ClonePatcher32(ThreadJoinVisitor visitor, AtomicLong value_ptr) { this.visitor = visitor; this.value_ptr = value_ptr; } @Override public long handle(Emulator<?> emulator) {<FILL_FUNCTION_BODY>} @Override public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) { try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm, KeystoneMode.Arm)) { KeystoneEncoded encoded = keystone.assemble(Arrays.asList( "push {r4-r7, lr}", "svc #0x" + Integer.toHexString(svcNumber), "pop {r7}", "cmp r7, #0", "popeq {r0, r4-r7, pc}", "pop {r0, ip}", "mov r7, #0", "mov r5, #0x" + Integer.toHexString(Svc.PRE_CALLBACK_SYSCALL_NUMBER), "mov r4, #0x" + Integer.toHexString(svcNumber), "svc #0", "blx ip", "mov r7, #0", "mov r5, #0x" + Integer.toHexString(Svc.POST_CALLBACK_SYSCALL_NUMBER), "mov r4, #0x" + Integer.toHexString(svcNumber), "svc #0", "pop {r0, r4-r7, pc}")); byte[] code = encoded.getMachineCode(); UnidbgPointer pointer = svcMemory.allocate(code.length, getClass().getSimpleName()); pointer.write(code); return pointer; } } @Override public void handlePreCallback(Emulator<?> emulator) { if (visitor.isSaveContext()) { emulator.pushContext(0x4); } } @Override public void handlePostCallback(Emulator<?> emulator) { super.handlePostCallback(emulator); value_ptr.set(emulator.getContext().getIntArg(0)); } }

RegisterContext context = emulator.getContext(); Pointer pthread_start = context.getPointerArg(0); Pointer child_stack = context.getPointerArg(1); int flags = context.getIntArg(2); Pointer thread = context.getPointerArg(3); Pointer start_routine = thread.getPointer(0x30); Pointer arg = thread.getPointer(0x34); log.info("clone start_routine=" + start_routine + ", child_stack=" + child_stack + ", flags=0x" + Integer.toHexString(flags) + ", arg=" + arg + ", pthread_start=" + pthread_start); Backend backend = emulator.getBackend(); boolean join = visitor == null || visitor.canJoin(start_routine, ++threadId); UnidbgPointer pointer = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_SP); try { pointer = pointer.share(-4, 0); // threadId pointer.setInt(0, threadId); if (join) { pointer = pointer.share(-4, 0); pointer.setPointer(0, start_routine); pointer = pointer.share(-4, 0); pointer.setPointer(0, arg); } pointer = pointer.share(-4, 0); // can join pointer.setInt(0, join ? 1 : 0); } finally { backend.reg_write(ArmConst.UC_ARM_REG_SP, pointer.peer); } return 0;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/ClonePatcher64.java

ClonePatcher64

handle

class ClonePatcher64 extends Arm64Svc { private static final Log log = LogFactory.getLog(ClonePatcher64.class); private final ThreadJoinVisitor visitor; private final AtomicLong value_ptr; private int threadId; public ClonePatcher64(ThreadJoinVisitor visitor, AtomicLong value_ptr) { this.visitor = visitor; this.value_ptr = value_ptr; } @Override public long handle(Emulator<?> emulator) {<FILL_FUNCTION_BODY>} @Override public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) { try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm64, KeystoneMode.LittleEndian)) { KeystoneEncoded encoded = keystone.assemble(Arrays.asList( "sub sp, sp, #0x10", "stp x29, x30, [sp]", "svc #0x" + Integer.toHexString(svcNumber), "ldr x13, [sp]", "add sp, sp, #0x8", "cmp x13, #0", "b.eq #0x48", "ldp x0, x13, [sp]", "add sp, sp, #0x10", "mov x8, #0", "mov x12, #0x" + Integer.toHexString(svcNumber), "mov x16, #0x" + Integer.toHexString(Svc.PRE_CALLBACK_SYSCALL_NUMBER), "svc #0", "blr x13", "mov x8, #0", "mov x12, #0x" + Integer.toHexString(svcNumber), "mov x16, #0x" + Integer.toHexString(Svc.POST_CALLBACK_SYSCALL_NUMBER), "svc #0", "ldr x0, [sp]", "add sp, sp, #0x8", "ldp x29, x30, [sp]", "add sp, sp, #0x10", "ret")); byte[] code = encoded.getMachineCode(); UnidbgPointer pointer = svcMemory.allocate(code.length, getClass().getSimpleName()); pointer.write(code); return pointer; } } @Override public void handlePreCallback(Emulator<?> emulator) { if (visitor.isSaveContext()) { emulator.pushContext(0x4); } } @Override public void handlePostCallback(Emulator<?> emulator) { super.handlePostCallback(emulator); value_ptr.set(emulator.getContext().getLongArg(0)); } }

RegisterContext context = emulator.getContext(); Pointer pthread_start = context.getPointerArg(0); Pointer child_stack = context.getPointerArg(1); int flags = context.getIntArg(2); Pointer thread = context.getPointerArg(3); Pointer start_routine = thread.getPointer(0x60); Pointer arg = thread.getPointer(0x68); log.info("clone start_routine=" + start_routine + ", child_stack=" + child_stack + ", flags=0x" + Integer.toHexString(flags) + ", arg=" + arg + ", pthread_start=" + pthread_start); Backend backend = emulator.getBackend(); boolean join = visitor == null || visitor.canJoin(start_routine, ++threadId); UnidbgPointer pointer = UnidbgPointer.register(emulator, Arm64Const.UC_ARM64_REG_SP); try { pointer = pointer.share(-8, 0); // threadId pointer.setLong(0, threadId); if (join) { pointer = pointer.share(-8, 0); pointer.setPointer(0, start_routine); pointer = pointer.share(-8, 0); pointer.setPointer(0, arg); } pointer = pointer.share(-8, 0); // can join pointer.setLong(0, join ? 1 : 0); } finally { backend.reg_write(Arm64Const.UC_ARM64_REG_SP, pointer.peer); } return 0;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/FutexNanoSleepWaiter.java

FutexNanoSleepWaiter

canDispatch

class FutexNanoSleepWaiter extends FutexWaiter { private final long waitMillis; private final long startWaitTimeInMillis; public FutexNanoSleepWaiter(Pointer uaddr, int val, TimeSpec timeSpec) { super(uaddr, val); this.waitMillis = timeSpec.toMillis(); this.startWaitTimeInMillis = System.currentTimeMillis(); if (this.waitMillis <= 0) { throw new IllegalStateException(); } } @Override public boolean canDispatch() {<FILL_FUNCTION_BODY>} @Override protected void onContinueRunInternal(Emulator<?> emulator) { super.onContinueRunInternal(emulator); emulator.getBackend().reg_write(emulator.is32Bit() ? ArmConst.UC_ARM_REG_R0 : Arm64Const.UC_ARM64_REG_X0, -AndroidSyscallHandler.ETIMEDOUT); } }

boolean ret = super.canDispatch(); if (ret) { return true; } if (System.currentTimeMillis() - startWaitTimeInMillis >= waitMillis) { return true; } Thread.yield(); return false;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/FutexWaiter.java

FutexWaiter

canDispatch

class FutexWaiter extends AndroidWaiter { private final Pointer uaddr; private final int val; public FutexWaiter(Pointer uaddr, int val) { this.uaddr = uaddr; this.val = val; } @Override public boolean canDispatch() {<FILL_FUNCTION_BODY>} @Override public final void onContinueRun(Emulator<?> emulator) { super.onContinueRun(emulator); if (wokenUp) { emulator.getBackend().reg_write(emulator.is32Bit() ? ArmConst.UC_ARM_REG_R0 : Arm64Const.UC_ARM64_REG_X0, 0); } else { onContinueRunInternal(emulator); } } protected void onContinueRunInternal(Emulator<?> emulator) { } protected boolean wokenUp; public boolean wakeUp(Pointer uaddr) { if (this.uaddr.equals(uaddr)) { this.wokenUp = true; return true; } else { return false; } } }

if (wokenUp) { return true; } int old = uaddr.getInt(0); return old != val;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/KitKatThread.java

KitKatThread

runThread

class KitKatThread extends ThreadTask { private final UnidbgPointer child_stack; private final UnidbgPointer fn; private final UnidbgPointer arg; public KitKatThread(int tid, long until, UnidbgPointer child_stack, UnidbgPointer fn, UnidbgPointer arg) { super(tid, until); this.child_stack = child_stack; this.fn = fn; this.arg = arg; } private Pointer errno; @Override public boolean setErrno(Emulator<?> emulator, int errno) { if (this.errno != null) { this.errno.setInt(0, errno); return true; } return super.setErrno(emulator, errno); } @Override public String toThreadString() { return "KitKatThread fn=" + fn + ", arg=" + arg + ", child_stack=" + child_stack; } @Override protected Number runThread(AbstractEmulator<?> emulator) {<FILL_FUNCTION_BODY>} }

Backend backend = emulator.getBackend(); UnidbgPointer stack = allocateStack(emulator); backend.reg_write(ArmConst.UC_ARM_REG_SP, stack.peer); this.errno = child_stack.share(8); backend.reg_write(ArmConst.UC_ARM_REG_R0, this.fn.peer); backend.reg_write(ArmConst.UC_ARM_REG_R1, this.arg == null ? 0 : this.arg.peer); backend.reg_write(ArmConst.UC_ARM_REG_R2, this.child_stack.peer); backend.reg_write(ArmConst.UC_ARM_REG_LR, until); Module libc = emulator.getMemory().findModule("libc.so"); Symbol __thread_entry = libc.findSymbolByName("__thread_entry", false); if (__thread_entry == null) { throw new IllegalStateException(); } return emulator.emulate(__thread_entry.getAddress(), until);

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/MarshmallowThread.java

MarshmallowThread

setExitStatus

class MarshmallowThread extends ThreadTask { private final UnidbgPointer fn; private final UnidbgPointer thread; public MarshmallowThread(Emulator<?> emulator, UnidbgPointer fn, UnidbgPointer thread, Pointer tidptr, int tid) { super(tid, emulator.getReturnAddress()); this.fn = fn; this.thread = thread; this.tidptr = tidptr; } @Override public void setExitStatus(int status) {<FILL_FUNCTION_BODY>} private Pointer errno; @Override public boolean setErrno(Emulator<?> emulator, int errno) { if (this.errno != null) { this.errno.setInt(0, errno); return true; } return super.setErrno(emulator, errno); } @Override public String toThreadString() { return String.format("MarshmallowThread tid=%d, fn=%s, arg=%s", id, fn, thread); } @Override protected Number runThread(AbstractEmulator<?> emulator) { Backend backend = emulator.getBackend(); UnidbgPointer stack = allocateStack(emulator); if (emulator.is32Bit()) { Pointer tls = thread.share(0x48); this.errno = tls.share(8); backend.reg_write(ArmConst.UC_ARM_REG_R0, UnidbgPointer.nativeValue(thread)); backend.reg_write(ArmConst.UC_ARM_REG_SP, stack.peer); backend.reg_write(ArmConst.UC_ARM_REG_C13_C0_3, UnidbgPointer.nativeValue(tls)); backend.reg_write(ArmConst.UC_ARM_REG_LR, until); } else { Pointer tls = thread.share(0xb0); this.errno = tls.share(16); backend.reg_write(Arm64Const.UC_ARM64_REG_X0, UnidbgPointer.nativeValue(thread)); backend.reg_write(Arm64Const.UC_ARM64_REG_SP, stack.peer); backend.reg_write(Arm64Const.UC_ARM64_REG_TPIDR_EL0, UnidbgPointer.nativeValue(tls)); backend.reg_write(Arm64Const.UC_ARM64_REG_LR, until); } return emulator.emulate(this.fn.peer, until); } private Pointer tidptr; public void set_tid_address(Pointer tidptr) { this.tidptr = tidptr; } }

super.setExitStatus(status); if (tidptr != null) { // set tid tidptr.setInt(0, 0); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/NanoSleepWaiter.java

NanoSleepWaiter

onSignal

class NanoSleepWaiter extends AndroidWaiter { private final Emulator<?> emulator; private final Pointer rem; private final long waitMillis; private final long startWaitTimeInMillis; public NanoSleepWaiter(Emulator<?> emulator, Pointer rem, TimeSpec timeSpec) { this.emulator = emulator; this.rem = rem; this.waitMillis = timeSpec.toMillis(); this.startWaitTimeInMillis = System.currentTimeMillis(); if (this.waitMillis <= 0) { throw new IllegalStateException(); } } private boolean onSignal; @Override public void onSignal(SignalTask task) {<FILL_FUNCTION_BODY>} @Override public void onContinueRun(Emulator<?> emulator) { super.onContinueRun(emulator); if (onSignal) { emulator.getBackend().reg_write(emulator.is32Bit() ? ArmConst.UC_ARM_REG_R0 : Arm64Const.UC_ARM64_REG_X0, -UnixEmulator.EINTR); } } @Override public boolean canDispatch() { if (onSignal) { return true; } if (System.currentTimeMillis() - startWaitTimeInMillis >= waitMillis) { return true; } Thread.yield(); return false; } }

super.onSignal(task); onSignal = true; if (rem != null) { TimeSpec timeSpec = TimeSpec.createTimeSpec(emulator, rem); long elapsed = System.currentTimeMillis() - startWaitTimeInMillis; timeSpec.setMillis(waitMillis - elapsed); }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/ThreadClonePatcher32.java

ThreadClonePatcher32

onRegister

class ThreadClonePatcher32 extends ArmSvc { private static final Log log = LogFactory.getLog(ThreadClonePatcher32.class); private final ThreadJoinVisitor visitor; private final AtomicInteger value_ptr; private int threadId; public ThreadClonePatcher32(ThreadJoinVisitor visitor, AtomicInteger value_ptr) { this.visitor = visitor; this.value_ptr = value_ptr; } @Override public long handle(Emulator<?> emulator) { EditableArm32RegisterContext context = emulator.getContext(); Pointer start_routine = context.getPointerArg(0); Pointer child_stack = context.getPointerArg(1); int flags = context.getIntArg(2); Pointer arg = context.getPointerArg(3); log.info("pthread_clone start_routine=" + start_routine + ", child_stack=" + child_stack + ", flags=0x" + Integer.toHexString(flags) + ", arg=" + arg); Backend backend = emulator.getBackend(); boolean join = visitor == null || visitor.canJoin(start_routine, ++threadId); UnidbgPointer pointer = UnidbgPointer.register(emulator, ArmConst.UC_ARM_REG_SP); try { pointer = pointer.share(-4, 0); // threadId pointer.setInt(0, threadId); pointer = pointer.share(-4, 0); // can join pointer.setInt(0, join ? 1 : 0); } finally { backend.reg_write(ArmConst.UC_ARM_REG_SP, pointer.peer); } return context.getR0Int(); } @Override public UnidbgPointer onRegister(SvcMemory svcMemory, int svcNumber) {<FILL_FUNCTION_BODY>} @Override public void handlePreCallback(Emulator<?> emulator) { if (visitor.isSaveContext()) { emulator.pushContext(0x4); } } @Override public void handlePostCallback(Emulator<?> emulator) { super.handlePostCallback(emulator); value_ptr.set(emulator.getContext().getIntArg(0)); } }

try (Keystone keystone = new Keystone(KeystoneArchitecture.Arm, KeystoneMode.Arm)) { KeystoneEncoded encoded = keystone.assemble(Arrays.asList( "push {r4-r7, lr}", "svc #0x" + Integer.toHexString(svcNumber), "pop {r7}", "cmp r7, #0", "popeq {r0, r4-r7, pc}", "mov ip, r0", "mov r0, r3", "mov r7, #0", "mov r5, #0x" + Integer.toHexString(Svc.PRE_CALLBACK_SYSCALL_NUMBER), "mov r4, #0x" + Integer.toHexString(svcNumber), "svc #0", "blx ip", "mov r7, #0", "mov r5, #0x" + Integer.toHexString(Svc.POST_CALLBACK_SYSCALL_NUMBER), "mov r4, #0x" + Integer.toHexString(svcNumber), "svc #0", "pop {r0, r4-r7, pc}")); byte[] code = encoded.getMachineCode(); UnidbgPointer pointer = svcMemory.allocate(code.length, getClass().getSimpleName()); pointer.write(code); return pointer; }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/ThreadJoin19.java

ThreadJoin19

patch

class ThreadJoin19 { public static void patch(final Emulator<?> emulator, InlineHook inlineHook, final ThreadJoinVisitor visitor) {<FILL_FUNCTION_BODY>} }

if (emulator.is64Bit()) { throw new IllegalStateException(); } Memory memory = emulator.getMemory(); Module libc = memory.findModule("libc.so"); Symbol _pthread_clone = libc.findSymbolByName("__pthread_clone", false); Symbol pthread_join = libc.findSymbolByName("pthread_join", false); if (_pthread_clone == null || pthread_join == null) { throw new IllegalStateException("_pthread_clone=" + _pthread_clone + ", pthread_join=" + pthread_join); } final AtomicInteger value_ptr = new AtomicInteger(); inlineHook.replace(pthread_join, new ReplaceCallback() { @Override public HookStatus onCall(Emulator<?> emulator, HookContext context, long originFunction) { Pointer ptr = context.getPointerArg(1); if (ptr != null) { ptr.setInt(0, value_ptr.get()); } return HookStatus.LR(emulator, 0); } }); inlineHook.replace(_pthread_clone, new ThreadClonePatcher32(visitor, value_ptr));

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/thread/ThreadJoin23.java

ThreadJoin23

patch

class ThreadJoin23 { public static void patch(final Emulator<?> emulator, InlineHook inlineHook, final ThreadJoinVisitor visitor) {<FILL_FUNCTION_BODY>} }

Memory memory = emulator.getMemory(); Module libc = memory.findModule("libc.so"); Symbol clone = libc.findSymbolByName("clone", false); Symbol pthread_join = libc.findSymbolByName("pthread_join", false); if (clone == null || pthread_join == null) { throw new IllegalStateException("clone=" + clone + ", pthread_join=" + pthread_join); } final AtomicLong value_ptr = new AtomicLong(); inlineHook.replace(pthread_join, new ReplaceCallback() { @Override public HookStatus onCall(Emulator<?> emulator, HookContext context, long originFunction) { Pointer ptr = context.getPointerArg(1); if (ptr != null) { if (emulator.is64Bit()) { ptr.setLong(0, value_ptr.get()); } else { ptr.setInt(0, (int) value_ptr.get()); } } return HookStatus.LR(emulator, 0); } }); inlineHook.replace(clone, emulator.is32Bit() ? new ClonePatcher32(visitor, value_ptr) : new ClonePatcher64(visitor, value_ptr));

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/linux/unpack/ElfUnpacker.java

ElfUnpacker

register

class ElfUnpacker { private final byte[] elfFile; private final File outFile; public ElfUnpacker(byte[] elfFile, File outFile) { this.elfFile = elfFile; this.outFile = outFile; if (outFile.isDirectory()) { throw new IllegalStateException("isDirectory"); } this.buffer = ByteBuffer.allocate(8); this.buffer.order(ByteOrder.LITTLE_ENDIAN); } private final ByteBuffer buffer; private boolean dirty; public void register(final Emulator<?> emulator, final Module module) {<FILL_FUNCTION_BODY>} }

module.setInitFunctionListener(new InitFunctionListener() { @Override public void onPreCallInitFunction(Module module, long initFunction, int index) { dirty = false; } @Override public void onPostCallInitFunction(Module module, long initFunction, int index) { try { if (dirty) { System.out.println("Unpack initFunction=" + UnidbgPointer.pointer(emulator, module.base + initFunction)); FileUtils.writeByteArrayToFile(outFile, elfFile); } } catch (IOException e) { throw new IllegalStateException(e); } } }); for (MemRegion region : module.getRegions()) { if ((region.perms & UnicornConst.UC_PROT_WRITE) == 0 && (region.perms & UnicornConst.UC_PROT_EXEC) == UnicornConst.UC_PROT_EXEC) { // 只读代码段 System.out.println("Begin unpack " + module.name + ": 0x" + Long.toHexString(region.begin) + "-0x" + Long.toHexString(region.end)); emulator.getBackend().hook_add_new(new WriteHook() { private UnHook unHook; @Override public void hook(Backend backend, long address, int size, long value, Object user) { long offset = address - module.base; int fileOffset = module.virtualMemoryAddressToFileOffset(offset); if (size < 1 || size > 8) { throw new IllegalStateException("size=" + size); } if (fileOffset >= 0) { buffer.clear(); buffer.putLong(value); System.arraycopy(buffer.array(), 0, elfFile, fileOffset, size); dirty = true; } } @Override public void onAttach(UnHook unHook) { this.unHook = unHook; } @Override public void detach() { this.unHook.unhook(); } }, region.begin, region.end, emulator); } }

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/virtualmodule/android/AndroidModule.java

AndroidModule

onInitialize

class AndroidModule extends VirtualModule<VM> { private static final Log log = LogFactory.getLog(AndroidModule.class); public AndroidModule(Emulator<?> emulator, VM vm) { super(emulator, vm, "libandroid.so"); } @Override protected void onInitialize(Emulator<?> emulator, final VM vm, Map<String, UnidbgPointer> symbols) {<FILL_FUNCTION_BODY>} private static long fromJava(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); Pointer env = context.getPointerArg(0); UnidbgPointer assetManager = context.getPointerArg(1); DvmObject<?> obj = vm.getObject(assetManager.toIntPeer()); if (log.isDebugEnabled()) { log.debug("AAssetManager_fromJava env=" + env + ", assetManager=" + obj.getObjectType() + ", LR=" + context.getLRPointer()); } return assetManager.peer; } private static long open(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); Pointer amgr = context.getPointerArg(0); String filename = context.getPointerArg(1).getString(0); int mode = context.getIntArg(2); if (log.isDebugEnabled()) { log.debug("AAssetManager_open amgr=" + amgr + ", filename=" + filename + ", mode=" + mode + ", LR=" + context.getLRPointer()); } final int AASSET_MODE_UNKNOWN = 0; final int AASSET_MODE_RANDOM = 1; final int AASSET_MODE_STREAMING = 2; final int AASSET_MODE_BUFFER = 3; if (mode == AASSET_MODE_STREAMING || AASSET_MODE_BUFFER == mode || mode == AASSET_MODE_UNKNOWN || mode == AASSET_MODE_RANDOM) { byte[] data = vm.openAsset(filename); if (data == null) { return 0L; } Asset asset = new Asset(vm, filename); asset.open(emulator, data); return vm.addLocalObject(asset); } throw new BackendException("filename=" + filename + ", mode=" + mode + ", LR=" + context.getLRPointer()); } private static long close(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); UnidbgPointer pointer = context.getPointerArg(0); Asset asset = vm.getObject(pointer.toIntPeer()); asset.close(); if (log.isDebugEnabled()) { log.debug("AAsset_close pointer=" + pointer + ", LR=" + context.getLRPointer()); } return 0; } private static long getBuffer(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); UnidbgPointer pointer = context.getPointerArg(0); Asset asset = vm.getObject(pointer.toIntPeer()); UnidbgPointer buffer = asset.getBuffer(); if (log.isDebugEnabled()) { log.debug("AAsset_getBuffer pointer=" + pointer + ", buffer=" + buffer + ", LR=" + context.getLRPointer()); } return buffer.peer; } private static long getLength(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); UnidbgPointer pointer = context.getPointerArg(0); Asset asset = vm.getObject(pointer.toIntPeer()); int length = asset.getLength(); if (log.isDebugEnabled()) { log.debug("AAsset_getLength pointer=" + pointer + ", length=" + length + ", LR=" + context.getLRPointer()); } return length; } private static long read(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); UnidbgPointer pointer = context.getPointerArg(0); Pointer buf = context.getPointerArg(1); int count = context.getIntArg(2); Asset asset = vm.getObject(pointer.toIntPeer()); byte[] bytes = asset.read(count); if (log.isDebugEnabled()) { log.debug("AAsset_read pointer=" + pointer + ", buf=" + buf + ", count=" + count + ", LR=" + context.getLRPointer()); } buf.write(0, bytes, 0, bytes.length); return bytes.length; } }

boolean is64Bit = emulator.is64Bit(); SvcMemory svcMemory = emulator.getSvcMemory(); symbols.put("AAssetManager_fromJava", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return fromJava(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return fromJava(emulator, vm); } })); symbols.put("AAssetManager_open", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return open(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return open(emulator, vm); } })); symbols.put("AAsset_close", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return close(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return close(emulator, vm); } })); symbols.put("AAsset_getBuffer", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return getBuffer(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return getBuffer(emulator, vm); } })); symbols.put("AAsset_getLength", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return getLength(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return getLength(emulator, vm); } })); symbols.put("AAsset_read", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { throw new BackendException(); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return read(emulator, vm); } }));

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/virtualmodule/android/JniGraphics.java

JniGraphics

lockPixels

class JniGraphics extends VirtualModule<VM> { private static final Log log = LogFactory.getLog(JniGraphics.class); public JniGraphics(Emulator<?> emulator, VM vm) { super(emulator, vm, "libjnigraphics.so"); } @Override protected void onInitialize(Emulator<?> emulator, final VM vm, Map<String, UnidbgPointer> symbols) { boolean is64Bit = emulator.is64Bit(); SvcMemory svcMemory = emulator.getSvcMemory(); symbols.put("AndroidBitmap_getInfo", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return getInfo(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return getInfo(emulator, vm); } })); symbols.put("AndroidBitmap_lockPixels", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return lockPixels(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return lockPixels(emulator, vm); } })); symbols.put("AndroidBitmap_unlockPixels", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return unlockPixels(emulator, vm); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return unlockPixels(emulator, vm); } })); } private static final int ANDROID_BITMAP_FORMAT_RGBA_8888 = 1; private static final int ANDROID_BITMAP_RESULT_SUCCESS = 0; private static long getInfo(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); Pointer env = context.getPointerArg(0); UnidbgPointer jbitmap = context.getPointerArg(1); Pointer info = context.getPointerArg(2); Bitmap bitmap = vm.getObject(jbitmap.toIntPeer()); BufferedImage image = bitmap.getValue(); if (log.isDebugEnabled()) { log.debug("AndroidBitmap_getInfo env=" + env + ", width=" + image.getWidth() + ", height=" + image.getHeight() + ", stride=" + image.getWidth() * 4 + ", info=" + info); } info.setInt(0, image.getWidth()); info.setInt(4, image.getHeight()); info.setInt(8, image.getWidth() * 4); // stride info.setInt(12, ANDROID_BITMAP_FORMAT_RGBA_8888); info.setInt(16, 0); // flags return ANDROID_BITMAP_RESULT_SUCCESS; } private static long lockPixels(Emulator<?> emulator, VM vm) {<FILL_FUNCTION_BODY>} private static long unlockPixels(Emulator<?> emulator, VM vm) { RegisterContext context = emulator.getContext(); Pointer env = context.getPointerArg(0); UnidbgPointer jbitmap = context.getPointerArg(1); Bitmap bitmap = vm.getObject(jbitmap.toIntPeer()); bitmap.unlockPixels(); if (log.isDebugEnabled()) { log.debug("AndroidBitmap_unlockPixels env=" + env + ", bitmap=" + bitmap); } return ANDROID_BITMAP_RESULT_SUCCESS; } }

RegisterContext context = emulator.getContext(); Pointer env = context.getPointerArg(0); UnidbgPointer jbitmap = context.getPointerArg(1); Pointer addrPtr = context.getPointerArg(2); Bitmap bitmap = vm.getObject(jbitmap.toIntPeer()); BufferedImage image = bitmap.getValue(); if (image.getType() != BufferedImage.TYPE_4BYTE_ABGR) { throw new IllegalStateException("image type=" + image.getType()); } if (addrPtr != null) { ByteBuffer buffer = ByteBuffer.allocate(image.getWidth() * image.getHeight() * 4); buffer.order(ByteOrder.LITTLE_ENDIAN); for (int y = 0; y < image.getHeight(); y++) { for (int x = 0; x < image.getWidth(); x++) { int rgb = image.getRGB(x, y); buffer.putInt((((rgb >> 24) & 0xff) << 24) | ((rgb & 0xff) << 16) | (((rgb >> 8) & 0xff) << 8) | ((rgb >> 16) & 0xff)); // convert TYPE_4BYTE_ABGR to ARGB_8888 } } Pointer pointer = bitmap.lockPixels(emulator, image, buffer); addrPtr.setPointer(0, pointer); if (log.isDebugEnabled()) { log.debug(Inspector.inspectString(buffer.array(), "AndroidBitmap_lockPixels buffer=" + buffer)); } } if (log.isDebugEnabled()) { log.debug("AndroidBitmap_lockPixels env=" + env + ", bitmap=" + bitmap + ", addrPtr=" + addrPtr); } return ANDROID_BITMAP_RESULT_SUCCESS;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/virtualmodule/android/MediaNdkModule.java

MediaNdkModule

release

class MediaNdkModule extends VirtualModule<VM> { private static final Log log = LogFactory.getLog(MediaNdkModule.class); public MediaNdkModule(Emulator<?> emulator, VM vm) { super(emulator, vm, "libmediandk.so"); } @Override protected void onInitialize(Emulator<?> emulator, VM extra, Map<String, UnidbgPointer> symbols) { boolean is64Bit = emulator.is64Bit(); SvcMemory svcMemory = emulator.getSvcMemory(); symbols.put("AMediaDrm_createByUUID", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return createByUUID(emulator); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return createByUUID(emulator); } })); symbols.put("AMediaDrm_getPropertyByteArray", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return getPropertyByteArray(emulator); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return getPropertyByteArray(emulator); } })); symbols.put("AMediaDrm_getPropertyString", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return getPropertyString(emulator); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return getPropertyString(emulator); } })); symbols.put("AMediaDrm_release", svcMemory.registerSvc(is64Bit ? new Arm64Svc() { @Override public long handle(Emulator<?> emulator) { return release(); } } : new ArmSvc() { @Override public long handle(Emulator<?> emulator) { return release(); } })); } public static final byte[] WIDE_VINE_UUID = {(byte) 0xed, (byte) 0xef, (byte) 0x8b, (byte) 0xa9,0x79, (byte) 0xd6,0x4a, (byte) 0xce, (byte) 0xa3, (byte) 0xc8,0x27, (byte) 0xdc, (byte) 0xd5,0x1d,0x21, (byte) 0xed}; private long createByUUID(Emulator<?> emulator) { if (log.isDebugEnabled()) { log.debug("call createByUUID"); } RegisterContext context = emulator.getContext(); Pointer uuidPtr = context.getPointerArg(0); byte[] uuid = uuidPtr.getByteArray(0, 0x10); if(Arrays.equals(uuid, WIDE_VINE_UUID)){ return emulator.getMemory().malloc(0x8, true).getPointer().peer; } throw new UnsupportedOperationException("createByUUID"); } private long getPropertyByteArray(Emulator<?> emulator){ RegisterContext context = emulator.getContext(); Pointer propertyNamePtr = context.getPointerArg(1); Pointer propertyValuePtr = context.getPointerArg(2); String propertyName = propertyNamePtr.getString(0); if(propertyName.equals("deviceUniqueId")){ MemoryBlock memoryBlock = emulator.getMemory().malloc(0x20, true); byte[] b = new byte[0x20]; new Random().nextBytes(b); memoryBlock.getPointer().write(0, b, 0, 0x20); propertyValuePtr.setPointer(0, memoryBlock.getPointer()); propertyValuePtr.setLong(emulator.getPointerSize(), 0x20); return 0; } throw new UnsupportedOperationException("getPropertyByteArray"); } private MemoryBlock vendorPropertyBlock; private long getPropertyString(Emulator<?> emulator){ RegisterContext context = emulator.getContext(); Pointer propertyNamePtr = context.getPointerArg(1); Pointer propertyValuePtr = context.getPointerArg(2); String propertyName = propertyNamePtr.getString(0); if ("vendor".equals(propertyName)) { final String value = "Google"; if (vendorPropertyBlock == null) { vendorPropertyBlock = emulator.getMemory().malloc(value.length(), true); } vendorPropertyBlock.getPointer().setString(0, value); propertyValuePtr.setPointer(0, vendorPropertyBlock.getPointer()); if (emulator.is32Bit()) { propertyValuePtr.setInt(4, value.length()); } else { propertyValuePtr.setLong(8, value.length()); } return 0; } throw new UnsupportedOperationException("getPropertyString: " + propertyName); } private long release(){<FILL_FUNCTION_BODY>} }

if (vendorPropertyBlock != null) { vendorPropertyBlock.free(); vendorPropertyBlock = null; } return 0;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/com/github/unidbg/virtualmodule/android/SystemProperties.java

SystemProperties

onInitialize

class SystemProperties extends VirtualModule<Void> { private static final Logger log = LoggerFactory.getLogger(SystemProperties.class); public SystemProperties(Emulator<?> emulator, Void extra) { super(emulator, extra, "libsystemproperties.so"); } @Override protected void onInitialize(Emulator<?> emulator, Void extra, Map<String, UnidbgPointer> symbols) {<FILL_FUNCTION_BODY>} }

boolean is64Bit = emulator.is64Bit(); SvcMemory svcMemory = emulator.getSvcMemory(); symbols.put("__system_property_read_callback", svcMemory.registerSvc(is64Bit ? new Arm64Hook() { @Override public HookStatus hook(Emulator<?> emulator) { EditableArm64RegisterContext context = emulator.getContext(); Pointer pi = context.getPointerArg(0); Pointer callback = context.getPointerArg(1); Pointer cookie = context.getPointerArg(2); log.debug("__system_property_read_callback pi={}, callback={}, cookie={}", pi, callback, cookie); Pointer key = pi.share(SystemPropertyHook.PROP_VALUE_MAX + 4); Pointer value = pi.share(4); context.setXLong(0, UnidbgPointer.nativeValue(cookie)); context.setXLong(1, UnidbgPointer.nativeValue(value)); context.setXLong(2, UnidbgPointer.nativeValue(key)); context.setXLong(3, pi.getInt(0)); return HookStatus.RET(emulator, UnidbgPointer.nativeValue(callback)); } } : new ArmHook() { @Override protected HookStatus hook(Emulator<?> emulator) throws NestedRun { EditableArm32RegisterContext context = emulator.getContext(); Pointer pi = context.getPointerArg(0); Pointer callback = context.getPointerArg(1); Pointer cookie = context.getPointerArg(2); log.debug("__system_property_read_callback pi={}, callback={}, cookie={}", pi, callback, cookie); Pointer key = pi.share(SystemPropertyHook.PROP_VALUE_MAX + 4); Pointer value = pi.share(4); context.setR0((int) UnidbgPointer.nativeValue(cookie)); context.setR1((int) UnidbgPointer.nativeValue(value)); context.setR2((int) UnidbgPointer.nativeValue(key)); context.setR3(pi.getInt(0)); return HookStatus.RET(emulator, UnidbgPointer.nativeValue(callback)); } }));

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/net/fornwall/jelf/AndroidRelocationIterator.java

AndroidRelocationIterator

read_group_fields

class AndroidRelocationIterator implements Iterator<MemoizedObject<ElfRelocation>> { private static final Log log = LogFactory.getLog(AndroidRelocationIterator.class); private static final int RELOCATION_GROUPED_BY_INFO_FLAG = 1; private static final int RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG = 2; private static final int RELOCATION_GROUPED_BY_ADDEND_FLAG = 4; private static final int RELOCATION_GROUP_HAS_ADDEND_FLAG = 8; private long readSleb128() { return Utils.readSignedLeb128(buffer, objectSize == ElfFile.CLASS_32 ? 32 : 64); } private final int objectSize; private final ByteBuffer buffer; private long relocation_count_; private final ElfRelocation reloc_; private final boolean rela; public AndroidRelocationIterator(int objectSize, SymbolLocator symtab, ByteBuffer buffer, boolean rela) { this.objectSize = objectSize; this.buffer = buffer; this.rela = rela; reloc_ = new ElfRelocation(objectSize, symtab); relocation_count_ = readSleb128(); reloc_.offset = readSleb128(); relocation_index_ = 0; relocation_group_index_ = 0; group_size_ = 0; } private long relocation_index_, relocation_group_index_, group_size_; @Override public boolean hasNext() { boolean next = relocation_index_ < relocation_count_; if (!next && log.isDebugEnabled()) { byte[] remaining = new byte[buffer.remaining()]; buffer.get(remaining); Inspector.inspect(remaining, "end"); } return next; } @Override public MemoizedObject<ElfRelocation> next() { if (relocation_group_index_ == group_size_) { if (!read_group_fields()) { // Iterator is inconsistent state; it should not be called again // but in case it is let's make sure has_next() returns false. relocation_index_ = 0; relocation_count_ = 0; return null; } } if (is_relocation_grouped_by_offset_delta()) { reloc_.offset += group_r_offset_delta_; } else { reloc_.offset += readSleb128(); } if (!is_relocation_grouped_by_info()) { reloc_.info = readSleb128(); } if (is_relocation_group_has_addend() && !is_relocation_grouped_by_addend()) { if (!rela) { throw new IllegalStateException("unexpected r_addend in android.rel section"); } reloc_.addend += readSleb128(); } relocation_index_++; relocation_group_index_++; try { final ElfRelocation copy = reloc_.clone(); return new MemoizedObject<ElfRelocation>() { @Override protected ElfRelocation computeValue() throws ElfException { return copy; } }; } catch (CloneNotSupportedException e) { throw new IllegalStateException(e); } } private long group_flags_; private long group_r_offset_delta_; private boolean read_group_fields() {<FILL_FUNCTION_BODY>} private boolean is_relocation_grouped_by_info() { return (group_flags_ & RELOCATION_GROUPED_BY_INFO_FLAG) != 0; } private boolean is_relocation_grouped_by_offset_delta() { return (group_flags_ & RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG) != 0; } private boolean is_relocation_grouped_by_addend() { return (group_flags_ & RELOCATION_GROUPED_BY_ADDEND_FLAG) != 0; } private boolean is_relocation_group_has_addend() { return (group_flags_ & RELOCATION_GROUP_HAS_ADDEND_FLAG) != 0; } @Override public void remove() { throw new UnsupportedOperationException(); } }

group_size_ = readSleb128(); group_flags_ = readSleb128(); if (is_relocation_grouped_by_offset_delta()) { group_r_offset_delta_ = readSleb128(); } if (is_relocation_grouped_by_info()) { reloc_.info = readSleb128(); } if (is_relocation_group_has_addend() && is_relocation_grouped_by_addend()) { if (!rela) { throw new IllegalStateException("unexpected r_addend in android.rel section"); } reloc_.addend += readSleb128(); } else if (!is_relocation_group_has_addend()) { if (rela) { reloc_.addend = 0; } } relocation_group_index_ = 0; return true;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfGnuHashTable.java

ElfGnuHashTable

getSymbol

class ElfGnuHashTable implements HashTable { private interface HashChain { int chain(int index); } private final int nbucket; private final int maskwords; private final int shift2; private final long[] bloom_filters; private final int[] buckets; private final HashChain chains; private final int bloom_mask_bits; ElfGnuHashTable(final ElfParser parser, long offset) { parser.seek(offset); nbucket = parser.readInt(); int symndx = parser.readInt(); int gnu_maskwords_ = parser.readInt(); shift2 = parser.readInt(); bloom_filters = new long[gnu_maskwords_]; for (int i = 0; i < bloom_filters.length; i++) { bloom_filters[i] = parser.readIntOrLong(); } buckets = new int[nbucket]; for (int i = 0; i < nbucket; i++) { buckets[i] = parser.readInt(); } final long chain_base = offset + 16 + (long) gnu_maskwords_ * (parser.elfFile.objectSize == ElfFile.CLASS_32 ? 4 : 8) + nbucket * 4L - symndx * 4L; chains = new HashChain() { @Override public int chain(int index) { parser.seek(chain_base + index * 4L); return parser.readInt(); } }; maskwords = gnu_maskwords_ - 1; bloom_mask_bits = parser.elfFile.objectSize == ElfFile.CLASS_32 ? 32 : 64; } /** * This method doesn't work every time and is unreliable. Use ELFSection.getELFSymbol(String) to retrieve symbols by * name. NOTE: since this method is currently broken it will always return null. */ @Override public ElfSymbol getSymbol(ElfSymbolStructure symbolStructure, String symbolName) throws IOException {<FILL_FUNCTION_BODY>} @Override public ElfSymbol findSymbolByAddress(ElfSymbolStructure symbolStructure, long soaddr) throws IOException { for (int i = 0; i < nbucket; i++) { int n = buckets[i]; if (n == 0) { continue; } do { ElfSymbol symbol = symbolStructure.getELFSymbol(n); if (symbol.matches(soaddr)) { return symbol; } } while ((chains.chain(n++) & 1) == 0); } return null; } private static long elf_hash(String name) { long h = 5381; for(char c : name.toCharArray()) { h += (h << 5) + c; // h*33 + c = h + h * 32 + c = h + h << 5 + c } return h & 0xffffffffL; } @Override public int getNumBuckets() { return nbucket; } }

if (symbolName == null) { return null; } final long hash = elf_hash(symbolName); final long h2 = hash >> shift2; long word_num = (hash / bloom_mask_bits) & maskwords; long bloom_word = bloom_filters[(int) word_num]; // test against bloom filter if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) { return null; } // bloom test says "probably yes"... int n = buckets[(int) (hash % nbucket)]; if (n == 0) { return null; } do { ElfSymbol symbol = symbolStructure.getELFSymbol(n); if (symbolName.equals(symbol.getName())) { return symbol; } } while ((chains.chain(n++) & 1) == 0); return null;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfHashTable.java

ElfHashTable

findSymbolByAddress

class ElfHashTable implements HashTable { /** * Returns the ELFSymbol that has the specified name or null if no symbol with that name exists. NOTE: Currently * this method does not work and will always return null. */ private final int num_buckets; // These could probably be memoized. private final int[] buckets; private final int[] chains; ElfHashTable(ElfParser parser, long offset, int length) { parser.seek(offset); num_buckets = parser.readInt(); int num_chains = parser.readInt(); buckets = new int[num_buckets]; chains = new int[num_chains]; // Read the bucket data. for (int i = 0; i < num_buckets; i++) { buckets[i] = parser.readInt(); } // Read the chain data. for (int i = 0; i < num_chains; i++) { chains[i] = parser.readInt(); } // Make sure that the amount of bytes we were supposed to read // was what we actually read. int actual = num_buckets * 4 + num_chains * 4 + 8; if (length != -1 && length != actual) { throw new ElfException("Error reading string table (read " + actual + "bytes, expected to " + "read " + length + "bytes)."); } } private static long elf_hash(String name) { long h = 0, g; for(char c : name.toCharArray()) { h = (h << 4) + c; g = h & 0xf0000000L; h ^= g; h ^= g >> 24; } return h; } /** * This method doesn't work every time and is unreliable. Use ELFSection.getELFSymbol(String) to retrieve symbols by * name. NOTE: since this method is currently broken it will always return null. */ @Override public ElfSymbol getSymbol(ElfSymbolStructure symbolStructure, String symbolName) throws IOException { if (symbolName == null) { return null; } final long hash = elf_hash(symbolName); int index = buckets[(int)hash % num_buckets]; while(index != 0) { ElfSymbol symbol = symbolStructure.getELFSymbol(index); if (symbolName.equals(symbol.getName())) { return symbol; } index = chains[index]; } return null; } @Override public ElfSymbol findSymbolByAddress(ElfSymbolStructure symbolStructure, long soaddr) throws IOException {<FILL_FUNCTION_BODY>} @Override public int getNumBuckets() { return num_buckets; } }

// Search the library's symbol table for any defined symbol which // contains this address. for (int i = 0; i < chains.length; i++) { ElfSymbol symbol = symbolStructure.getELFSymbol(i); if (symbol.matches(soaddr)) { return symbol; } } return null;

zhkl0228_unidbg

unidbg/unidbg-android/src/main/java/net/fornwall/jelf/ElfParser.java

ElfParser

unsignedByte

class ElfParser implements ElfDataIn { final ElfFile elfFile; private final ByteBuffer fsFile; ElfParser(ElfFile elfFile, ByteBuffer fsFile) { this.elfFile = elfFile; this.fsFile = fsFile; } void seek(long offset) { fsFile.position((int) offset); } /** * Signed byte utility functions used for converting from big-endian (MSB) to little-endian (LSB). */ short byteSwap(short arg) { return (short) ((arg << 8) | ((arg >>> 8) & 0xFF)); } int byteSwap(int arg) { return ((byteSwap((short) arg)) << 16) | (((byteSwap((short) (arg >>> 16)))) & 0xFFFF); } long byteSwap(long arg) { return ((((long) byteSwap((int) arg)) << 32) | (((long) byteSwap((int) (arg >>> 32))))); } @Override public short readUnsignedByte() { int val = fsFile.get() & 0xff; return (short) val; } @Override public short readShort() throws ElfException { int ch1 = readUnsignedByte(); int ch2 = readUnsignedByte(); short val = (short) ((ch1 << 8) + (ch2)); if (elfFile.encoding == ElfFile.DATA_LSB) val = byteSwap(val); return val; } @Override public int readInt() throws ElfException { int ch1 = readUnsignedByte(); int ch2 = readUnsignedByte(); int ch3 = readUnsignedByte(); int ch4 = readUnsignedByte(); int val = ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4)); if (elfFile.encoding == ElfFile.DATA_LSB) { val = byteSwap(val); } return val; } @Override public long readLong() { int ch1 = readUnsignedByte(); int ch2 = readUnsignedByte(); int ch3 = readUnsignedByte(); int ch4 = readUnsignedByte(); int val1 = ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4)); int ch5 = readUnsignedByte(); int ch6 = readUnsignedByte(); int ch7 = readUnsignedByte(); int ch8 = readUnsignedByte(); int val2 = ((ch5 << 24) + (ch6 << 16) + (ch7 << 8) + (ch8)); long val = ((long) (val1) << 32) + (val2 & 0xFFFFFFFFL); if (elfFile.encoding == ElfFile.DATA_LSB) { val = byteSwap(val); } return val; } /** Read four-byte int or eight-byte long depending on if {@link ElfFile#objectSize}. */ long readIntOrLong() { return elfFile.objectSize == ElfFile.CLASS_32 ? readInt() : readLong(); } /** Returns a big-endian unsigned representation of the int. */ @SuppressWarnings("unused") long unsignedByte(int arg) {<FILL_FUNCTION_BODY>} int read(byte[] data) { fsFile.get(data); return data.length; } ByteBuffer readBuffer(int length) { int limit = fsFile.limit(); try { fsFile.limit(fsFile.position() + length); return fsFile.slice(); } finally { fsFile.limit(limit); } } }

long val; if (arg >= 0) { val = arg; } else { val = (unsignedByte((short) (arg >>> 16)) << 16) | ((short) arg); } return val;

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

SoftBreakPoint

addBreakPoint

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>

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

BreakPointImpl

hook_add_new

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>

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

ByteArrayPointer

toString

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>

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); }