抖音資料采集教程，Unicorn 模擬 CPU 執行 JNI_Onload 動態注冊
短視頻、直播資料實時采集介面，請查看檔案： TiToData
免責宣告：本檔案僅供學習與參考，請勿用于非法用途！否則一切后果自負，
Unicorn 模擬 JNI_Onload
目標 呼叫 JNI_OnLoad
JNI_OnLoad 如圖
步驟：
先實作 javavm 中的 GetEnv， （與模擬 jni 程序類似）一共八個函式
初始化
# 1. 開始映射
mu.mem_map(0, 0x1000) # 初始化映射 引數1：地址 引數2:空間大小 默認初始化后默認值：0
# 1.1 初始化 java vm 中的每一個函式
java_vm_base = 700*4 # 從 700*4 開始
for i in range(0, 10, 1): # 一共8個函式（5個+3個預留） 這里我預留了10個多寫幾個預備，也就是 10*4
mu.mem_write(i*4+java_vm_base, b'\x00\xb5\x00\xbd') # 先隨便填充，保持堆疊平衡 push {lr} pop {pc}
# 1.2 初始化填充 JNIInvokeInterface 結構體
for i in range(0, 10, 1):
mu.mem_write(i*4+java_vm_base+40, struct.pack("I", i*4+java_vm_base+1)) # 注意第二個引數，要 pack 一下為 bytes， 而且是 thmob 指令集都要+1
# 1.3 初始化 Java vm 指標
javavm_pointer=700*4+80
mu.mem_write(javavm_pointer,struct.pack("I",java_vm_base+40)) # 內容指標，頁就是 JNIInvokeInterface 的第一個位置所以要加 40
**
然后添加 Hook 代碼，模擬cpu 執行
- 注意： 想要直接通過 R2 的地址讀出函式的資訊，是有問題的
- 因為： linker 對加載的時候并不是直接映射的，而是分不通的段進行加載的！！所以位置是不通的，
- 解決： 要模擬加載 和 重定位
- 涉及： 依賴庫加載，符號的決議等等作業
- 便捷解決： AndroidNativeEmu 已經封裝好了 linker， 并且可以模擬 syscall 的執行，還提供了對函式的 hook 功能
代碼如下
tool
import unicorn
import capstone
import struct
class Tool:
"""工具類"""
def __init__(self):
self.CP = capstone.Cs(capstone.CS_ARCH_ARM, capstone.CS_MODE_THUMB)
def capstone_print(self, code, offset, total=20):
"""
code: 代碼
offset: 偏移位置
total: 最大列印行
"""
for i in self.CP.disasm(code[offset:], 0, total):
print('\033[1;32m地址: 0x%x | 操作碼: %s | %s\033[0m'%(offset + i.address, i.mnemonic, i.op_str))
def readstring(self, mu,address):
"""讀字串"""
result=''
tmp=mu.mem_read(address,1)
while(tmp[0]!=0):
result=result+chr(tmp[0])
address=address+1
tmp = mu.mem_read(address, 1)
return result
def printArm32Regs(self, mu, end=78):
"""列印暫存器"""
for i in range(66, end):
print("\033[1;30m【R%d】, value:%x\033[0m"%(i-66,mu.reg_read(i)))
print("\033[1;30mSP->value:%x\033[0m" % (mu.reg_read(unicorn.arm_const.UC_ARM_REG_SP)))
print("\033[1;30mPC->value:%x\033[0m" % (mu.reg_read(unicorn.arm_const.UC_ARM_REG_PC)))
tl = Tool()
if __name__ == "__main__":
with open("so/testcalljni.so",'rb') as f:
CODE=f.read()
# tl.capstone_print(CODE, 0x0B58, 10)
**
_ _
core
import unicorn
import struct
import capstone
from arm_tool import tl
def init_java_vm(mu):
"""初始化 java vm
java vm 5+3 個函式
"""
# 1. 開始映射
mu.mem_map(0, 0x1000) # 初始化映射 引數1：地址 引數2:空間大小 默認初始化后默認值：0
"""注意：要模擬 JNI_OnLoad 同樣也需要先初始化 JNI"""
# 0.1 初始化填充 jni 函式
JniFuntionListbase=0x0
for i in range(0, 300): # 接近 300 個jni函式 (指標是 4 個位元組)
mu.mem_write(i*4+JniFuntionListbase, b'\x00\xb5\x00\xbd') # 先隨便填充，保持堆疊平衡 push {lr} pop {pc}
# 0.2 初始化填充 JNINaviteInterface 結構體， 每一項都是，jni函式的地址
# JniNativeInterFace=301 # 前面300個用于指標了，從301個開始
for i in range(300, 600): # 4 個位元組都是地址
mu.mem_write(i*4, struct.pack("I", (i-300)*4+1)) # 注意第二個引數，要 pack 一下為 bytes， 而且是 thmob 指令集都要+1
# 0.3 初始化 jnienv 指標
jnienv_pointer = 601*4
mu.mem_write(jnienv_pointer, struct.pack("I", 300*4)) # 內容指標，頁就是 JniNativeInterFace 的第一個 300
"""初始化 java vm"""
# 1.1 初始化 java vm 中的每一個函式
java_vm_base = 700*4 # 從 700*4 開始
for i in range(0, 10, 1): # 一共8個函式（5個+3個預留） 這里我預留了10個多寫幾個預備，也就是 10*4
mu.mem_write(i*4+java_vm_base, b'\x00\xb5\x00\xbd') # 先隨便填充，保持堆疊平衡 push {lr} pop {pc}
# 1.2 初始化填充 JNIInvokeInterface 結構體
for i in range(0, 10, 1):
mu.mem_write(i*4+java_vm_base+40, struct.pack("I", i*4+java_vm_base+1)) # 注意第二個引數，要 pack 一下為 bytes， 而且是 thmob 指令集都要+1
# 1.3 初始化 Java vm 指標
javavm_pointer=700*4+80
mu.mem_write(javavm_pointer,struct.pack("I",java_vm_base+40)) # 內容指標，頁就是 JNIInvokeInterface 的第一個位置所以要加 40
# 2. 將代碼片段映射到模擬器的虛擬地址
ADDRESS = 0x1000 # 映射開始地址
SIZE = 1024*1024*10 # 分配映射大小(多分一點)
# 3. 開始映射
mu.mem_map(ADDRESS, SIZE) # 初始化映射 引數1：地址 引數2:空間大小 默認初始化后默認值：0
mu.mem_write(ADDRESS, CODE) # 寫入指令 引數1: 寫入位置 引數2:寫入內容
# 4. 暫存器初始化 函式2個引數 (JNI_OnLoad 有兩個引數)
mu.reg_write(unicorn.arm_const.UC_ARM_REG_R0, javavm_pointer) # 引數 javavm 指標
mu.reg_write(unicorn.arm_const.UC_ARM_REG_R1, 0x0) # 0
# 5. 初始化堆疊，因為要對記憶體進行操作 設定 SP
SP = ADDRESS+SIZE-16 # 多減點，預留 sp 剩下兩個引數的位置
mu.reg_write(unicorn.arm_const.UC_ARM_REG_SP,SP)
# 6. 添加 hook 代碼
"""注意： hook 的時候加上區間可以極大的提升hook效率！！"""
mu.hook_add(unicorn.UC_HOOK_CODE, hook_code)
# mu.hook_add(unicorn.UC_HOOK_MEM_WRITE, hook_mem) # 跟蹤 cpu 執行記憶體操作， 需要自寫回呼函式
# mu.hook_add(unicorn.UC_HOOK_INTR,hook_syscall) # hook 系統呼叫函式
# mu.hook_add(unicorn.UC_HOOK_BLOCK,hook_block) # hook 基本塊
# 7. 開始運行
add_satrt = ADDRESS+0xc00+1 # 偏移位置 ida 查看 THUMB 指令集奇數所以要 ADDRESS +1,
add_end = ADDRESS+0xC66 # 呼叫完 registnative 回傳即可
try:
mu.emu_start(add_satrt, add_end) # 引數1:起始位置，引數2:結束位置
print('-------- unicorn 執行后--------')
r0value = https://www.cnblogs.com/titodata/p/mu.reg_read(unicorn.arm_const.UC_ARM_REG_R0)
print('執行結果: ', tl.readstring(mu, r0value))
except unicorn.UcError as e:
print('\033[1;31mError: %s \033[0m' % e)
def hook_code(mu,address,size,user_data):
"""定義回呼函式， 在進入匯編指令之前就會先運行這里
mu: 模擬器
address: 執行地址
size: 匯編指令大小
user_data: 通過 hook_add 添加的引數
"""
code=mu.mem_read(address,size) # 讀取
if address>=700*4 and address<=710*4:
index=(address-700*4)/4
print('進入 Javavm 函式: '+str(index))
if index==6:
print("呼叫 javavm->GetEnv---------------：" + str(index))
# jint (*GetEnv)(JavaVM*, void**, jint); 第二個引數才是，回傳的值，所以要用 R1 ！！！！！
"""第二個引數才是，回傳的值，所以要用 R1 ！！！！！"""
r1value = https://www.cnblogs.com/titodata/p/mu.reg_read(unicorn.arm_const.UC_ARM_REG_R1) # 將 ENV 指標 寫入 jni 第一個引數中，即可
mu.mem_write(r1value,struct.pack("I",601*4)) # 也就是我們初始化 jni 的時候的指標地址
CP=capstone.Cs(capstone.CS_ARCH_ARM,capstone.CS_MODE_THUMB)
for i in CP.disasm(code,0,len(code)):
print("\033[1;32mHook jni ｜ 地址:0x%x | 指令:%s | 內容:%s\033[0m"%(address,i.mnemonic,i.op_str))
tl.printArm32Regs(mu)
elif address>=0 and address<=300*4: # 回傳屬于我們自己寫的 jni 函式的區域的時候
index=(address-0)/4 # 拿到第幾個 jni 函式
if index==6: # 676/4 6 = FindClass 就可以捕獲到，類的完整類名
print("------[jnienv] FindClass-------")
# jclass (*FindClass)(JNIEnv*, const char*); 是第二個引數回傳的值 所以是 R1
r1value = https://www.cnblogs.com/titodata/p/mu.reg_read(unicorn.arm_const.UC_ARM_REG_R1)
classname=tl.readstring(mu,r1value)
#666 com/example/unicorncourse05/MainActivity
print("\033[1;33mjnienv FindClass: %s\033[0m" %classname)
mu.reg_write(unicorn.arm_const.UC_ARM_REG_R0,666) # 隨便寫一個值來代表這個參考！
elif index == 215: # 第二部，呼叫 注冊函式
# jint (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,jint);
print("------[jnienv] RegisterNatives-------")
r0value = https://www.cnblogs.com/titodata/p/mu.reg_read(unicorn.arm_const.UC_ARM_REG_R0) # 也就是我們前面寫好的 601 * 4 = 2404
r1value = mu.reg_read(unicorn.arm_const.UC_ARM_REG_R1) # 也就是上面隨便寫的一個值
r2value = mu.reg_read(unicorn.arm_const.UC_ARM_REG_R2) # JNINativeMethod 地址 （陣列）"""
注意： 想要直接通過 R2 的地址讀出函式的資訊，是有問題的
因為： linker 對加載的時候并不是直接映射的，而是分不通的段進行加載的！！所以位置是不通的，
解決： 要模擬加載 和 重定位
涉及： 依賴庫加載，符號的決議等等作業
便捷解決： AndroidNativeEmu 已經封裝好了 linker， 并且可以模擬 syscall 的執行，還提供了對函式的 hook 功能
"""
# funcname_bytearray=mu.mem_read(r2value,4)
# funcname_addr=struct.unpack("I",funcname_bytearray);
# print(tl.readstring(mu,funcname_addr))
r3value = https://www.cnblogs.com/titodata/p/mu.reg_read(unicorn.arm_const.UC_ARM_REG_R3)
print("\033[1;33menv地址："+str(r0value)+" ｜ 函式jclass："+str(r1value)+" ｜ JNINativeMethod[陣列]地址："+str(r2value)+" ｜ 注冊個數："+str(r3value)+"\033[0m")
CP=capstone.Cs(capstone.CS_ARCH_ARM,capstone.CS_MODE_THUMB)
for i in CP.disasm(code,0,len(code)):
print("\033[1;32mHook jni ｜ 地址:0x%x | 指令:%s | 內容:%s\033[0m"%(address,i.mnemonic,i.op_str))
return
def hook_mem(mu, type, address, size, value, user_data):
"""
讀和寫記憶體的 mem hook 回呼
"""
msg = None
print('\033[1;32m=== Hook cpu ===\033[0m')
if type==unicorn.UC_MEM_WRITE:
msg = """\033[1;32m記憶體操作 %s 地址: 0x%x ｜ hook_mem 型別: %s｜ 大小: %s ｜ 值: 0x%x\033[0m"""%('寫入',address,type,size,value)
if type==unicorn.UC_MEM_READ:
msg = """\033[1;32m記憶體操作 %s 地址: 0x%x ｜ hook_mem 型別: %s｜ 大小: %s ｜ 值: 0x%x\033[0m"""%('讀取',address,type,size,value)
print(msg)
return
def hook_syscall(mu,intno,user_data):
print("\033[1;36mhook 系統呼叫 系統呼叫號: 0x%d"%intno)
if intno==2: # 例子 2 是退出
print("系統呼叫退出!!")
# print_result(mu)
print("\033[0m")
return
def hook_block(mu, address, size, user_data):
# code = mu.mem_read(address,size)
print("\033[1;36mhook 基本塊")
# print_result(mu)
print("\033[0m")
return
if __name__ == "__main__":
with open("so/unicorn05.so",'rb') as sofile:
CODE=sofile.read()
mu = unicorn.Uc(unicorn.UC_ARCH_ARM, unicorn.UC_MODE_THUMB)
tl.capstone_print(CODE, 0xc00)
init_java_vm(mu) # 初始化 java vm
**
_ _
運行效果
轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/254388.html
標籤：大數據