4.5 x64dbg 探索勾點劫持技術

勾點劫持技術是計算機程式設計中的一種技術，它們可以讓開發者攔截系統函數或應用程式函數的呼叫，並在函數呼叫前或呼叫後執行自定義程式碼，勾點劫持技術通常用於病毒和惡意軟體，也可以讓開發者擴充套件或修改系統函數的功能，從而提高軟體的效能和增加新功能。

4.5.1 探索反組合寫出函數原理

勾點劫持技術的實現一般需要在對端記憶體中通過create_alloc()函數準備一塊空間，並通過assemble_write_memory()函數，將一段組合程式碼轉為機器碼，並回圈寫出自定義指令集到堆中，函數write_opcode_from_assemble()就是我們自己實現的，該函數傳入一個組合指令列表，自動轉為機器碼並寫出到堆內，函數的核心程式碼如下所示。

def write_opcode_from_assemble(dbg_ptr,asm_list):
    addr_count = 0
    addr = dbg_ptr.create_alloc(1024)
    if addr != 0:
        for index in asm_list:
            asm_size = dbg_ptr.assemble_code_size(index)
            if asm_size != 0:
                # print("長度: {}".format(asm_size))
                write = dbg_ptr.assemble_write_memory(addr + addr_count, index)
                if write == True:
                    addr_count = addr_count + asm_size
                else:
                    dbg_ptr.delete_alloc(addr)
                    return 0
            else:
                dbg_ptr.delete_alloc(addr)
                return 0
    else:
        return 0
    return addr

我們以寫出一段MessageBox彈窗程式碼為例，首先通過get_module_from_function函數獲取到位於user32.dll模組內MessageBoxA的函數地址，該函數的棧傳引數為五個，其中前四個為push壓棧，最後一個則是呼叫call，為了構建這個指令集需要在asm_list寫出所需參數列及呼叫函數地址，並通過set_local_protect設定可執行屬性，通過set_register將當前EIP設定到寫出位置，並執行程式。

from LyScript32 import MyDebug

def write_opcode_from_assemble(dbg_ptr,asm_list):
              pass

if __name__ == "__main__":
    dbg = MyDebug()
    dbg.connect()

    # 得到messagebox記憶體地址
    msg_ptr = dbg.get_module_from_function("user32.dll","MessageBoxA")
    call = "call {}".format(str(hex(msg_ptr)))
    print("函數地址: {}".format(call))

    # 寫出指令集到記憶體
    asm_list = ['push 0','push 0','push 0','push 0',call]
    write_addr = write_opcode_from_assemble(dbg,asm_list)
    print("寫出地址: {}".format(hex(write_addr)))

    # 設定執行屬性
    dbg.set_local_protect(write_addr,32,1024)

    # 將EIP設定到指令集位置
    dbg.set_register("eip",write_addr)

    # 執行程式碼
    dbg.set_debug("Run")
    dbg.close()

執行上述程式碼片段，則首先會在0x3130000的位置處寫出呼叫MessageBox的指令集。

當執行set_debug("Run")則會執行如下圖所示程式碼，這些程式碼則是經過填充的，由於此處僅僅只是一個演示案例，所以不具備任何實戰性，讀者在該案例中學會指令的替換是如何實現的即可；

4.5.2 實現Hook改寫MsgBox彈窗

在之前的內容中筆者通過封裝write_opcode_from_assemble函數實現了自定義寫出記憶體的功能，本章將繼續探索Hook劫持技術的實現原理，如下案例中我們先來實現一個Hook通用模板，在程式碼中實現中轉機制，程式碼中以MessageBoxA函數為案例實現修改組合引數傳遞。

from LyScript32 import MyDebug

# 傳入組合列表,寫出到記憶體
def assemble(dbg, address=0, asm_list=[]):
    asm_len_count = 0
    for index in range(0,len(asm_list)):
        # 寫出到記憶體
        dbg.assemble_at(address, asm_list[index])
        # print("地址: {} --> 長度計數器: {} --> 寫出: {}".format(hex(address + asm_len_count), asm_len_count,asm_list[index]))
        # 得到asm長度
        asm_len_count = dbg.assemble_code_size(asm_list[index])
        # 地址每次遞增
        address = address + asm_len_count

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("連線狀態: {}".format(connect_flag))

    # 找到MessageBoxA
    messagebox_address = dbg.get_module_from_function("user32.dll","MessageBoxA")
    print("MessageBoxA記憶體地址 = {}".format(hex(messagebox_address)))

    # 分配空間
    HookMem = dbg.create_alloc(1024)
    print("自定義記憶體空間: {}".format(hex(HookMem)))

    # 寫出MessageBoxA記憶體地址,跳轉地址
    asm = [
        f"push {hex(HookMem)}",
        "ret"
    ]

    # 將列表中的組合指令寫出到記憶體
    assemble(dbg,messagebox_address,asm)

    dbg.close()

如上程式碼中，通過找到user32.dll庫中的MessageBoxA函數，並返回其記憶體地址。接著，程式會分配1024位元組大小的自定義記憶體空間，獲取剛剛寫入的記憶體地址，並將其寫入到MessageBoxA函數的記憶體地址中，程式碼執行後讀者可看到如下圖所示的提示資訊；

提示：解釋一下為什麼需要增加asm列表中的指令集，此處的指令集作用只有一個那就是跳轉，當原始MessageBoxA函數被呼叫時，則此處通過push;ret的組合跳轉到我們自定義的HookMem記憶體空間中，而此記憶體空間中後期則需要填充我們自己的彈窗程式碼片段，所以需要提前通過HookMem = dbg.create_alloc(1024)構建出這段記憶體區域；

由於MessageBox彈窗需要使用兩個變數這兩個變數依次代表標題和內容，所以我們通過create_alloc函數在對端記憶體中分配兩塊堆空間，並依次將彈窗字串通過write_memory_byte寫出到記憶體中，至此彈窗內容也算填充好了，其中txt代表標題，而box則代表內容；

    # 定義兩個變數,存放字串
    MsgBoxAddr = dbg.create_alloc(512)
    MsgTextAddr = dbg.create_alloc(512)

    # 填充字串內容
    # lyshark 標題
    txt = [0x6c, 0x79, 0x73, 0x68, 0x61, 0x72, 0x6b]
    # 內容 lyshark.com
    box = [0x6C, 0x79, 0x73, 0x68, 0x61, 0x72, 0x6B, 0x2E, 0x63, 0x6F, 0x6D]

    for txt_count in range(0,len(txt)):
        dbg.write_memory_byte(MsgBoxAddr + txt_count, txt[txt_count])

    for box_count in range(0,len(box)):
        dbg.write_memory_byte(MsgTextAddr + box_count, box[box_count])

    print("標題地址: {} 內容: {}".format(hex(MsgBoxAddr),hex(MsgTextAddr)))

緊接著，我們需要跳轉到MessageBoxA函數所在記憶體中，並提取出該函數呼叫時的核心組合指令集，如下圖所示則是彈窗的具體實現流程；

而對於一個完整的彈窗來說，只需要提取出核心程式碼即可不必提取所有指令集，但需要注意的是圖中的call 0x75B20E20地址需要進行替換，根據系統的不同此處的地址也不會相同，在提取時需要格外注意；

    # 此處是MessageBox替換後的片段
    PatchCode =\
    [
        "mov edi, edi",
        "push ebp",
        "mov ebp,esp",
        "push -1",
        "push 0",
        "push dword ptr ss:[ebp+0x14]",
        f"push {hex(MsgBoxAddr)}",
        f"push {hex(MsgTextAddr)}",
        "push dword ptr ss:[ebp+0x8]",
        "call 0x75B20E20",
        "pop ebp",
        "ret 0x10"
    ]

    # 寫出到自定義記憶體
    assemble(dbg, HookMem, PatchCode)

如上則是替換彈窗的程式碼解釋，將這段程式碼整合在一起，讀者則可實現一段替換彈窗功能的程式碼，如下彈窗中的訊息替換成我們自己的版權資訊，此處完整程式碼實現如下所示；

from LyScript32 import MyDebug

# 傳入組合列表,寫出到記憶體
def assemble(dbg, address=0, asm_list=[]):
    asm_len_count = 0
    for index in range(0,len(asm_list)):
        # 寫出到記憶體
        dbg.assemble_at(address, asm_list[index])
        # print("地址: {} --> 長度計數器: {} --> 寫出: {}".format(hex(address + asm_len_count), asm_len_count,asm_list[index]))
        # 得到asm長度
        asm_len_count = dbg.assemble_code_size(asm_list[index])
        # 地址每次遞增
        address = address + asm_len_count

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("連線狀態: {}".format(connect_flag))

    # 找到MessageBoxA
    messagebox_address = dbg.get_module_from_function("user32.dll","MessageBoxA")
    print("MessageBoxA記憶體地址 = {}".format(hex(messagebox_address)))

    # 分配空間
    HookMem = dbg.create_alloc(1024)
    print("自定義記憶體空間: {}".format(hex(HookMem)))

    # 寫出FindWindowA記憶體地址,跳轉地址
    asm = [
        f"push {hex(HookMem)}",
        "ret"
    ]

    # 將列表中的組合指令寫出到記憶體
    assemble(dbg,messagebox_address,asm)

    # 定義兩個變數,存放字串
    MsgBoxAddr = dbg.create_alloc(512)
    MsgTextAddr = dbg.create_alloc(512)

    # 填充字串內容
    # lyshark 標題
    txt = [0x6c, 0x79, 0x73, 0x68, 0x61, 0x72, 0x6b]
    # 內容 lyshark.com
    box = [0x6C, 0x79, 0x73, 0x68, 0x61, 0x72, 0x6B, 0x2E, 0x63, 0x6F, 0x6D]

    for txt_count in range(0,len(txt)):
        dbg.write_memory_byte(MsgBoxAddr + txt_count, txt[txt_count])

    for box_count in range(0,len(box)):
        dbg.write_memory_byte(MsgTextAddr + box_count, box[box_count])

    print("標題地址: {} 內容: {}".format(hex(MsgBoxAddr),hex(MsgTextAddr)))

    # 此處是MessageBox替換後的片段
    PatchCode =\
    [
        "mov edi, edi",
        "push ebp",
        "mov ebp,esp",
        "push -1",
        "push 0",
        "push dword ptr ss:[ebp+0x14]",
        f"push {hex(MsgBoxAddr)}",
        f"push {hex(MsgTextAddr)}",
        "push dword ptr ss:[ebp+0x8]",
        "call 0x75B20E20",
        "pop ebp",
        "ret 0x10"
    ]

    # 寫出到自定義記憶體
    assemble(dbg, HookMem, PatchCode)

    print("地址已被替換,可以執行了.")
    dbg.set_debug("Run")
    dbg.set_debug("Run")

    dbg.close()

當如上程式碼被執行後，則會替換程序內MessageBoxA函數為我們自己的地址，執行輸出效果如下圖所示；

讀者可通過Ctrl+G並輸入MessageBoxA跳轉到原函數彈窗位置，此時輸出的則是一個跳轉地址0x6C0000該地址則代表我們自己的自定義記憶體區域，如下圖所示；

繼續跟進這記憶體區域，讀者可看到我們自己構建的MessageBoxA彈窗的核心程式碼片段，當這段程式碼被執行結束後則通過ret會返回到程式領空，如下圖所示；

至此，當用戶再次開啟彈窗按鈕時，則不會提示原始內容，而是提示自定義彈窗，如下圖所示；

原文地址

https://www.lyshark.com/post/6b7ca168.html