• LyScript 插件官方API调用案例

    本人结合LyScript插件API函数实现的一些通用案例，用于演示插件内置方法是如何灵活组合运用的，其目的是让用户可以自行研究学习API函数的参数传递，并能够通过案例的学习快速掌握官方API函数的使用方法。

    LyScript 项目地址: https://github.com/lyshark/LyScript

    PEFile载入PE程序到内存: 将PE可执行文件中的内存数据通过PEfile模块打开并读入内存，实现PE参数解析。

    1. from LyScript32 import MyDebug
    2. import pefile
    3.  
    4. if __name__ == "__main__":
    5.     # 初始化
    6.     dbg = MyDebug()
    7.     dbg.connect()
    8.  
    9.     # 得到text节基地址
    10.     local_base = dbg.get_local_base()
    11.  
    12.     # 根据text节得到程序首地址
    13.     base = dbg.get_base_from_address(local_base)
    14.  
    15.     byte_array = bytearray()
    16.     for index in range(0,4096):
    17.         read_byte = dbg.read_memory_byte(base + index)
    18.         byte_array.append(read_byte)
    19.  
    20.     oPE = pefile.PE(data = byte_array)
    21.     timedate = oPE.OPTIONAL_HEADER.dump_dict()
    22.     print(timedate)

    如下通过LyScirpt模块配合PEFile模块解析内存镜像中的section节表属性。

    1. from LyScript32 import MyDebug
    2. import pefile
    3.  
    4. if __name__ == "__main__":
    5.     # 初始化
    6.     dbg = MyDebug()
    7.     dbg.connect()
    8.  
    9.     # 得到text节基地址
    10.     local_base = dbg.get_local_base()
    11.  
    12.     # 根据text节得到程序首地址
    13.     base = dbg.get_base_from_address(local_base)
    14.  
    15.     byte_array = bytearray()
    16.     for index in range(0,8192):
    17.         read_byte = dbg.read_memory_byte(base + index)
    18.         byte_array.append(read_byte)
    19.  
    20.     oPE = pefile.PE(data = byte_array)
    21.  
    22.     for section in oPE.sections:
    23.         print("%10s %10x %10x %10x" 
    24. 	%(section.Name.decode("utf-8"), section.VirtualAddress, 
    25. 	section.Misc_VirtualSize, section.SizeOfRawData))
    26.     dbg.close()

    验证PE启用的保护方式: 验证保护方式需要通过dbg.get_all_module()遍历加载过的模块，并依次读入DllCharacteristics与操作数进行与运算得到保护方式。

    1. from LyScript32 import MyDebug
    2. import pefile
    3.  
    4. if __name__ == "__main__":
    5.     # 初始化
    6.     dbg = MyDebug()
    7.     dbg.connect()
    8.  
    9.     # 得到所有加载过的模块
    10.     module_list = dbg.get_all_module()
    11.  
    12.     print("-" * 100)
    13.     print("模块名 \t\t\t 基址随机化 \t\t DEP保护 \t\t 强制完整性 \t\t SEH异常保护 \t\t")
    14.     print("-" * 100)
    15.  
    16.     for module_index in module_list:
    17.         print("{:15}\t\t".format(module_index.get("name")),end="")
    18.  
    19.         # 依次读入程序所载入的模块
    20.         byte_array = bytearray()
    21.         for index in range(0, 4096):
    22.             read_byte = dbg.read_memory_byte(module_index.get("base") + index)
    23.             byte_array.append(read_byte)
    24.  
    25.         oPE = pefile.PE(data=byte_array)
    26.  
    27.         # 随机基址 => hex(pe.OPTIONAL_HEADER.DllCharacteristics) & 0x40 == 0x40
    28.         if ((oPE.OPTIONAL_HEADER.DllCharacteristics & 64) == 64):
    29.             print("True\t\t\t",end="")
    30.         else:
    31.             print("False\t\t\t",end="")
    32.         # 数据不可执行 DEP => hex(pe.OPTIONAL_HEADER.DllCharacteristics) & 0x100 == 0x100
    33.         if ((oPE.OPTIONAL_HEADER.DllCharacteristics & 256) == 256):
    34.             print("True\t\t\t",end="")
    35.         else:
    36.             print("False\t\t\t",end="")
    37.         # 强制完整性=> hex(pe.OPTIONAL_HEADER.DllCharacteristics) & 0x80 == 0x80
    38.         if ((oPE.OPTIONAL_HEADER.DllCharacteristics & 128) == 128):
    39.             print("True\t\t\t",end="")
    40.         else:
    41.             print("False\t\t\t",end="")
    42.         if ((oPE.OPTIONAL_HEADER.DllCharacteristics & 1024) == 1024):
    43.             print("True\t\t\t",end="")
    44.         else:
    45.             print("False\t\t\t",end="")
    46.         print()
    47.     dbg.close()

    计算PE节区内存特征: 通过循环读入节区数据，并动态计算出该节的MD5以及CRC32特征值输出。

    1. import binascii
    2. import hashlib
    3. from LyScript32 import MyDebug
    4.  
    5. def crc32(data):
    6.     return "0x{:X}".format(binascii.crc32(data) & 0xffffffff)
    7.  
    8. def md5(data):
    9.     md5 = hashlib.md5(data)
    10.     return md5.hexdigest()
    11.  
    12. if __name__ == "__main__":
    13.     dbg = MyDebug()
    14.     dbg.connect()
    15.  
    16.     # 循环节
    17.     section = dbg.get_section()
    18.     for index in section:
    19.         # 定义字节数组
    20.         mem_byte = bytearray()
    21.  
    22.         address = index.get("addr")
    23.         section_name = index.get("name")
    24.         section_size = index.get("size")
    25.  
    26.         # 读出节内的所有数据
    27.         for item in range(0,int(section_size)):
    28.             mem_byte.append( dbg.read_memory_byte(address + item))
    29.  
    30.         # 开始计算特征码
    31.         md5_sum = md5(mem_byte)
    32.         crc32_sum = crc32(mem_byte)
    33.  
    34.         print("[*] 节名: {:10s} | 节长度: {:10d} | MD5特征: {} | CRC32特征: {}"
    35.               .format(section_name,section_size,md5_sum,crc32_sum))
    36.  
    37.     dbg.close()

    文件FOA与内存VA转换: 封装实现get_offset_from_va()用于将VA内存虚拟地址转为FOA文件偏移地址，封装实现get_va_from_foa()用于将FOA文件偏移地址转为VA内存虚拟地址。

    1. from LyScript32 import MyDebug
    2. import pefile
    3.  
    4. # 传入一个VA值获取到FOA文件地址
    5. def get_offset_from_va(pe_ptr, va_address):
    6.     # 得到内存中的程序基地址
    7.     memory_image_base = dbg.get_base_from_address(dbg.get_local_base())
    8.  
    9.     # 与VA地址相减得到内存中的RVA地址
    10.     memory_local_rva = va_address - memory_image_base
    11.  
    12.     # 根据RVA得到文件内的FOA偏移地址
    13.     foa = pe_ptr.get_offset_from_rva(memory_local_rva)
    14.     return foa
    15.  
    16. # 传入一个FOA文件地址得到VA虚拟地址
    17. def get_va_from_foa(pe_ptr, foa_address):
    18.     # 先得到RVA相对偏移
    19.     rva = pe_ptr.get_rva_from_offset(foa_address)
    20.  
    21.     # 得到内存中程序基地址,然后计算VA地址
    22.     memory_image_base = dbg.get_base_from_address(dbg.get_local_base())
    23.     va = memory_image_base + rva
    24.     return va
    25.  
    26. # 传入一个FOA文件地址转为RVA地址
    27. def get_rva_from_foa(pe_ptr, foa_address):
    28.     sections = [s for s in pe_ptr.sections if s.contains_offset(foa_address)]
    29.     if sections:
    30.         section = sections[0]
    31.         return (foa_address - section.PointerToRawData) + section.VirtualAddress
    32.     else:
    33.         return 0
    34.  
    35. if __name__ == "__main__":
    36.     dbg = MyDebug()
    37.     dbg.connect()
    38.  
    39.     # 载入文件PE
    40.     pe = pefile.PE(name=dbg.get_local_module_path())
    41.  
    42.     # 读取文件中的地址
    43.     rva = pe.OPTIONAL_HEADER.AddressOfEntryPoint
    44.     va = pe.OPTIONAL_HEADER.ImageBase + pe.OPTIONAL_HEADER.AddressOfEntryPoint
    45.     foa = pe.get_offset_from_rva(pe.OPTIONAL_HEADER.AddressOfEntryPoint)
    46.     print("文件VA地址: {} 文件FOA地址: {} 从文件获取RVA地址: {}".format(hex(va), foa, hex(rva)))
    47.  
    48.     # 将VA虚拟地址转为FOA文件偏移
    49.     eip = dbg.get_register("eip")
    50.     foa = get_offset_from_va(pe, eip)
    51.     print("虚拟地址: 0x{:x} 对应文件偏移: {}".format(eip, foa))
    52.  
    53.     # 将FOA文件偏移转为VA虚拟地址
    54.     va = get_va_from_foa(pe, foa)
    55.     print("文件地址: {} 对应虚拟地址: 0x{:x}".format(foa, va))
    56.  
    57.     # 将FOA文件偏移地址转为RVA相对地址
    58.     rva = get_rva_from_foa(pe, foa)
    59.     print("文件地址: {} 对应的RVA相对地址: 0x{:x}".format(foa, rva))
    60.  
    61.     dbg.close()

    查找SafeSEH内存地址: 读入PE文件到内存，验证该程序的SEH保护是否开启，如果开启则尝试输出SEH内存地址。

    1. from LyScript32 import MyDebug
    2. import struct
    3.  
    4. LOG_HANDLERS = True
    5.  
    6. if __name__ == "__main__":
    7.     dbg = MyDebug()
    8.     dbg.connect()
    9.  
    10.     # 得到PE头部基地址
    11.     memory_image_base = dbg.get_base_from_address(dbg.get_local_base())
    12.  
    13.     peoffset = dbg.read_memory_dword(memory_image_base + int(0x3c))
    14.     pebase = memory_image_base + peoffset
    15.  
    16.     flags = dbg.read_memory_word(pebase + int(0x5e))
    17.     if(flags & int(0x400)) != 0:
    18.         print("SafeSEH | NoHandler")
    19.  
    20.     numberofentries = dbg.read_memory_dword(pebase + int(0x74))
    21.     if numberofentries > 10:
    22.  
    23.         # 读取 pebase+int(0x78)+8*10 | pebase+int(0x78)+8*10+4  读取八字节,分成两部分读取
    24.         sectionaddress, sectionsize = [dbg.read_memory_dword(pebase+int(0x78)+8*10),
    25.                                        dbg.read_memory_dword(pebase+int(0x78)+8*10 + 4)
    26.                                        ]
    27.         sectionaddress += memory_image_base
    28.         data = dbg.read_memory_dword(sectionaddress)
    29.         condition = (sectionsize != 0) and ((sectionsize == int(0x40)) or (sectionsize == data))
    30.  
    31.         if condition == False:
    32.             print("[-] SafeSEH 无保护")
    33.         if data < int(0x48):
    34.             print("[-] 无法识别的DLL/EXE程序")
    35.  
    36.         sehlistaddress, sehlistsize = [dbg.read_memory_dword(sectionaddress+int(0x40)),
    37.                                        dbg.read_memory_dword(sectionaddress+int(0x40) + 4)
    38.                                        ]
    39.         if sehlistaddress != 0 and sehlistsize != 0:
    40.             print("[+] SafeSEH 保护中 | 长度: {}".format(sehlistsize))
    41.             if LOG_HANDLERS == True:
    42.                 for i in range(sehlistsize):
    43.                     sehaddress = dbg.read_memory_dword(sehlistaddress + 4 * i)
    44.                     sehaddress += memory_image_base
    45.                     print("SEHAddress = {}".format(hex(sehaddress)))
    46.  
    47.     dbg.close()

    扫描所有模块匹配特征: 针对程序内加载的所有模块扫描特征码，如果找到了会返回内存地址，以及模块详细参数。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug()
    5.     dbg.connect()
    6.  
    7.     # 获取所有模块
    8.     for entry in dbg.get_all_module():
    9.         eip = entry.get("entry")
    10.         base = entry.get("base")
    11.         name = entry.get("name")
    12.  
    13.         if eip != 0:
    14.             # 设置EIP到模块入口处
    15.             dbg.set_register("eip",eip)
    16.  
    17.             # 开始搜索特征
    18.             search = dbg.scan_memory_one("ff 25 ??")
    19.             if search != 0 or search != None:
    20.  
    21.                 # 如果找到了,则反汇编此行
    22.                 dasm = dbg.disasm_fast_at(search)
    23.  
    24.                 print("addr = {} | base = {} | module = {} | search_addr = {} | dasm = {}"
    25.                       .format(eip,base,name,eip,dasm.get("disasm")))
    26.  
    27.     dbg.close()

    绕过反调试机制: 最常用的反调试机制就是用IsDebuggerPresent该标志检查PEB+2位置处的内容，如果为1则表示正在被调试，我们运行脚本直接将其设置为0即可绕过反调试机制。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     # 初始化
    5.     dbg = MyDebug()
    6.     dbg.connect()
    7.  
    8.     # 通过PEB找到调试标志位
    9.     peb = dbg.get_peb_address(dbg.get_process_id())
    10.     print("调试标志地址: 0x{:x}".format(peb+2))
    11.  
    12.     flag = dbg.read_memory_byte(peb+2)
    13.     print("调试标志位: {}".format(flag))
    14.  
    15.     # 将调试标志设置为0即可过掉反调试
    16.     nop_debug = dbg.write_memory_byte(peb+2,0)
    17.     print("反调试绕过状态: {}".format(nop_debug))
    18.     
    19.     dbg.close()

    绕过进程枚举: 病毒会枚举所有运行的进程以确认是否有调试器在运行，我们可以在特定的函数开头处写入SUB EAX,EAX RET指令让其无法调用枚举函数从而失效。

    1. from LyScript32 import MyDebug
    2.  
    3. # 得到所需要的机器码
    4. def set_assemble_opcde(dbg,address):
    5.     # 得到第一条长度
    6.     opcode_size = dbg.assemble_code_size("sub eax,eax")
    7.  
    8.     # 写出汇编指令
    9.     dbg.assemble_at(address, "sub eax,eax")
    10.     dbg.assemble_at(address + opcode_size , "ret")
    11.  
    12. if __name__ == "__main__":
    13.     # 初始化
    14.     dbg = MyDebug()
    15.     dbg.connect()
    16.  
    17.     # 得到函数所在内存地址
    18.     process32first = dbg.get_module_from_function("kernel32","Process32FirstW")
    19.     process32next = dbg.get_module_from_function("kernel32","Process32NextW")
    20.     print("process32first = 0x{:x} | process32next = 0x{:x}".format(process32first,process32next))
    21.  
    22.     # 替换函数位置为sub eax,eax ret
    23.     set_assemble_opcde(dbg, process32first)
    24.     set_assemble_opcde(dbg, process32next)
    25.  
    26.     dbg.close()

    简单的搜索汇编特征: 使用python实现方法，通过特定方法扫描内存范围，如果出现我们所需要的指令集序列，则输出该指令的具体内存地址。

    1. from LyScript32 import MyDebug
    2.  
    3. # 检索指定序列中是否存在一段特定的指令集
    4. def SearchOpCode(OpCodeList,SearchCode,ReadByte):
    5.             pass
    6.  
    7. if __name__ == "__main__":
    8.     dbg = MyDebug()
    9.     connect_flag = dbg.connect()
    10.     print("连接状态: {}".format(connect_flag))
    11.  
    12.     # 得到EIP位置
    13.     eip = dbg.get_register("eip")
    14.  
    15.     # 反汇编前1000行
    16.     disasm_dict = dbg.get_disasm_code(eip,1000)
    17.  
    18.     # 搜索一个指令序列,用于快速查找构建漏洞利用代码
    19.     SearchCode = [
    20.         ["push 0xC0000409", "call 0x003F1B38", "pop ecx"],
    21.         ["mov ebp, esp", "sub esp, 0x324"]
    22.     ]
    23.  
    24.     # 检索内存指令集
    25.     for item in range(0,len(SearchCode)):
    26.         Search = SearchCode[item]
    27.         # disasm_dict = 返回汇编指令 Search = 寻找指令集 1000 = 向下检索长度
    28.         ret = SearchOpCode(disasm_dict,Search,1000)
    29.         if ret != None:
    30.             print("指令集: {} --> 首次出现地址: {}".format(SearchCode[item],hex(ret)))
    31.  
    32.     dbg.close()

    批量搜索反汇编代码: 与搜索机器码类似，此功能实现了搜索代码段中所有指令集，匹配列表中是否存在，存在则返回地址。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug()
    5.     dbg.connect()
    6.  
    7.     local_base_start = dbg.get_local_base()
    8.     local_base_end = local_base_start + dbg.get_local_size()
    9.     print("开始地址: {} --> 结束地址: {}".format(hex(local_base_start),hex(local_base_end)))
    10.  
    11.     search_asm = ['test eax,eax', 'cmp esi, edi', 'pop edi', 'cmp esi,edi', 'jmp esp']
    12.  
    13.     while local_base_start <= local_base_end:
    14.         disasm = dbg.get_disasm_one_code(local_base_start)
    15.         print("地址: 0x{:08x} --> 反汇编: {}".format(local_base_start,disasm))
    16.  
    17.         # 寻找指令
    18.         for index in range(0, len(search_asm)):
    19.             if disasm == search_asm[index]:
    20.                 print("地址: {} --> 反汇编: {}".format(hex(local_base_start), disasm))
    21.  
    22.         # 递增计数器
    23.         local_base_start = local_base_start + dbg.get_disasm_operand_size(local_base_start)
    24.  
    25.     dbg.close()

    得到汇编指令机器码: 该功能主要实现，得到用户传入汇编指令所对应的机器码，这段代码你可以这样来实现。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug()
    5.     connect_flag = dbg.connect()
    6.     print("连接状态: {}".format(connect_flag))
    7.  
    8.     addr = dbg.create_alloc(1024)
    9.  
    10.     print("堆空间: {}".format(hex(addr)))
    11.  
    12.     asm_size = dbg.assemble_code_size("mov eax,1")
    13.     print("汇编代码占用字节: {}".format(asm_size))
    14.  
    15.     write = dbg.assemble_write_memory(addr,"mov eax,1")
    16.  
    17.     byte_code = bytearray()
    18.  
    19.     for index in range(0,asm_size):
    20.         read = dbg.read_memory_byte(addr + index)
    21.         print("{:02x} ".format(read),end="")
    22.  
    23.     dbg.delete_alloc(addr)

    封装上方代码，你就可以实现一个汇编指令获取工具了，如下get_opcode_from_assemble()函数。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编代码,得到对应机器码
    4. def get_opcode_from_assemble(dbg_ptr,asm):
    5.               pass
    6.  
    7. if __name__ == "__main__":
    8.     dbg = MyDebug()
    9.     connect_flag = dbg.connect()
    10.     print("连接状态: {}".format(connect_flag))
    11.  
    12.     # 获取汇编代码
    13.     byte_array = get_opcode_from_assemble(dbg,"xor eax,eax")
    14.     for index in byte_array:
    15.         print(hex(index),end="")
    16.     print()
    17.  
    18.     # 汇编一个序列
    19.     asm_list = ["xor eax,eax", "xor ebx,ebx", "mov eax,1"]
    20.     for index in asm_list:
    21.         byte_array = get_opcode_from_assemble(dbg, index)
    22.         for index in byte_array:
    23.             print(hex(index),end="")
    24.         print()
    25.  
    26.     dbg.close()

    传入汇编指令得到机器码: 封装接口实现get_opcode_from_assemble()用户传入汇编指令，得到该指令对应机器码。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编代码,得到对应机器码
    4. def get_opcode_from_assemble(dbg_ptr,asm):
    5.     byte_code = bytearray()
    6.  
    7.     addr = dbg_ptr.create_alloc(1024)
    8.     if addr != 0:
    9.         asm_size = dbg_ptr.assemble_code_size(asm)
    10.         # print("汇编代码占用字节: {}".format(asm_size))
    11.  
    12.         write = dbg_ptr.assemble_write_memory(addr,asm)
    13.         if write == True:
    14.             for index in range(0,asm_size):
    15.                 read = dbg_ptr.read_memory_byte(addr + index)
    16.                 # print("{:02x} ".format(read),end="")
    17.                 byte_code.append(read)
    18.         dbg_ptr.delete_alloc(addr)
    19.         return byte_code
    20.     else:
    21.         return bytearray(0)
    22.  
    23. if __name__ == "__main__":
    24.     dbg = MyDebug()
    25.     connect_flag = dbg.connect()
    26.     print("连接状态: {}".format(connect_flag))
    27.  
    28.     # 获取汇编代码
    29.     byte_array = get_opcode_from_assemble(dbg,"xor eax,eax")
    30.     for index in byte_array:
    31.         print(hex(index),end="")
    32.     print()
    33.  
    34.     # 汇编一个序列
    35.     asm_list = ["xor eax,eax", "xor ebx,ebx", "mov eax,1"]
    36.     for index in asm_list:
    37.         byte_array = get_opcode_from_assemble(dbg, index)
    38.         for index in byte_array:
    39.             print(hex(index),end="")
    40.         print()
    41.  
    42.     dbg.close()

    指令机器码内存搜索: 在当前载入程序的所有模块中搜索特定的一组机器码指令，找到后返回该指令集内存地址。

    1. from LyScript32 import MyDebug
    2. import time
    3.  
    4. if __name__ == "__main__":
    5.     dbg = MyDebug()
    6.     dbg.connect()
    7.  
    8.     # 需要搜索的指令集片段
    9.     opcode = ['ff 25','ff 55 fc','8b fe']
    10.  
    11.     # 循环搜索指令集内存地址
    12.     for index,entry in zip(range(0,len(opcode)), dbg.get_all_module()):
    13.         eip = entry.get("entry")
    14.         base_name = entry.get("name")
    15.         if eip != 0:
    16.             dbg.set_register("eip",eip)
    17.             search_address = dbg.scan_memory_all(opcode[index])
    18.  
    19.             if search_address != False:
    20.                 print("搜索模块: {} --> 匹配个数: {} --> 机器码: {}"
    21. 			.format(base_name,len(search_address),opcode[index]))
    22.                 # 输出地址
    23.                 for search_index in search_address:
    24.                     print("[*] {}".format(hex(search_index)))
    25.  
    26.         time.sleep(0.3)
    27.     dbg.close()

    逐条进行反汇编输出: 封装函数disasm_code()实现了通过循环的方式逐条输出反汇编代码完整信息，并打印到屏幕。

    1. from LyScript32 import MyDebug
    2.  
    3. # 封装反汇编多条函数
    4. def disasm_code(dbg_ptr, eip, count):
    5.     disasm_length = 0
    6.  
    7.     for index in range(0, count):
    8.         # 获取一条反汇编代码
    9.         disasm_asm = dbg_ptr.get_disasm_one_code(eip + disasm_length)
    10.         disasm_addr = eip + disasm_length
    11.         disasm_size = dbg_ptr.assemble_code_size(disasm_asm)
    12.  
    13.         print("内存地址: 0x{:08x} | 反汇编: {:35} | 长度: {}  | 机器码: "
    14. 		.format(disasm_addr, disasm_asm, disasm_size),end="")
    15.  
    16.         # 逐字节读入机器码
    17.         for length in range(0, disasm_size):
    18.             read = dbg_ptr.read_memory_byte(disasm_addr + length)
    19.             print("{:02x} ".format(read),end="")
    20.         print()
    21.  
    22.         # 递增地址
    23.         disasm_length = disasm_length + disasm_size
    24.  
    25. if __name__ == "__main__":
    26.     dbg = MyDebug()
    27.     dbg.connect()
    28.  
    29.     eip = dbg.get_register("eip")
    30.     disasm_code(dbg, eip, 25)
    31.  
    32.     dbg.close()

    实现劫持EIP指针: 这里我们演示一个案例，你可以自己实现一个write_opcode_from_assemble()函数批量将列表中的指令集写出到内存。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编指令列表,直接将机器码写入对端内存
    4. def write_opcode_from_assemble(dbg_ptr,asm_list):
    5.               pass
    6.  
    7. if __name__ == "__main__":
    8.     dbg = MyDebug()
    9.     dbg.connect()
    10.  
    11.     # 写出指令集到内存
    12.     asm_list = ['mov eax,1','mov ebx,2','add eax,ebx']
    13.     write_addr = write_opcode_from_assemble(dbg,asm_list)
    14.     print("写出地址: {}".format(hex(write_addr)))
    15.  
    16.     # 设置执行属性
    17.     dbg.set_local_protect(write_addr,32,1024)
    18.  
    19.     # 将EIP设置到指令集位置
    20.     dbg.set_register("eip",write_addr)
    21.  
    22.     dbg.close()

    封装实现write_opcode_from_assemble()函数，传入一个汇编指令列表，自动转为机器码并写出到堆内，控制EIP执行流实现劫持指令的目的。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编指令列表,直接将机器码写入对端内存
    4. def write_opcode_from_assemble(dbg_ptr,asm_list):
    5.     addr_count = 0
    6.     addr = dbg_ptr.create_alloc(1024)
    7.     if addr != 0:
    8.         for index in asm_list:
    9.             asm_size = dbg_ptr.assemble_code_size(index)
    10.             if asm_size != 0:
    11.                 # print("长度: {}".format(asm_size))
    12.                 write = dbg_ptr.assemble_write_memory(addr + addr_count, index)
    13.                 if write == True:
    14.                     addr_count = addr_count + asm_size
    15.                 else:
    16.                     dbg_ptr.delete_alloc(addr)
    17.                     return 0
    18.             else:
    19.                 dbg_ptr.delete_alloc(addr)
    20.                 return 0
    21.     else:
    22.         return 0
    23.     return addr
    24.  
    25. if __name__ == "__main__":
    26.     dbg = MyDebug()
    27.     dbg.connect()
    28.  
    29.     # 得到messagebox内存地址
    30.     msg_ptr = dbg.get_module_from_function("user32.dll","MessageBoxA")
    31.     call = "call {}".format(str(hex(msg_ptr)))
    32.     print("函数地址: {}".format(call))
    33.  
    34.     # 写出指令集到内存
    35.     asm_list = ['push 0','push 0','push 0','push 0',call]
    36.     write_addr = write_opcode_from_assemble(dbg,asm_list)
    37.     print("写出地址: {}".format(hex(write_addr)))
    38.  
    39.     # 设置执行属性
    40.     dbg.set_local_protect(write_addr,32,1024)
    41.  
    42.     # 将EIP设置到指令集位置
    43.     dbg.set_register("eip",write_addr)
    44.  
    45.     # 执行代码
    46.     dbg.set_debug("Run")
    47.     dbg.close()

    执行劫持函数很简单，运行后会看到一个错误弹窗，说明程序执行流已经被转向了。

    得到_PEB_LDR_DATA线程环境块: 想要得到线程环境块最好的办法就是在目标内存中执行获取线程块的汇编指令，我们可以写出到内存并执行取值。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug(address="127.0.0.1")
    5.     dbg.connect()
    6.  
    7.     # 保存当前EIP
    8.     eip = dbg.get_register("eip")
    9.  
    10.     # 创建堆
    11.     heap_addres = dbg.create_alloc(1024)
    12.     print("堆空间地址: {}".format(hex(heap_addres)))
    13.  
    14.     # 写出汇编指令
    15.     # mov eax,fs:[0x30] 得到 _PEB
    16.     dbg.assemble_at(heap_addres,"mov eax,fs:[0x30]")
    17.     asmfs_size = dbg.get_disasm_operand_size(heap_addres)
    18.  
    19.     # 写出汇编指令
    20.     # mov eax,[eax+0x0C] 得到 _PEB_LDR_DATA
    21.     dbg.assemble_at(heap_addres + asmfs_size, "mov eax, [eax + 0x0C]")
    22.     asmeax_size = dbg.get_disasm_operand_size(heap_addres + asmfs_size)
    23.  
    24.     # 跳转回EIP位置
    25.     dbg.assemble_at(heap_addres+ asmfs_size + asmeax_size , "jmp {}".format(hex(eip)))
    26.  
    27.     # 设置EIP到堆首地址
    28.     dbg.set_register("eip",heap_addres)
    29.  
    30.     dbg.close()

    实现脱UPX压缩壳: 将当前EIP停留在UPX壳的首地址处，执行如下脚本，将可以自动寻找到当前EIP的具体位置。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     # 初始化
    5.     dbg = MyDebug()
    6.  
    7.     # 连接到调试器
    8.     connect_flag = dbg.connect()
    9.     print("连接状态: {}".format(connect_flag))
    10.  
    11.     # 检测套接字是否还在
    12.     ref = dbg.is_connect()
    13.     print("是否在连接: ", ref)
    14.  
    15.     is_64 = False
    16.  
    17.     # 判断是否时64位数
    18.     if is_64 == False:
    19.         currentIP = dbg.get_register("eip")
    20.  
    21.         if dbg.read_memory_word(currentIP) != int(0xBE60):
    22.             print("[-] 可能不是UPX")
    23.             dbg.close()
    24.  
    25.         patternAddr = dbg.scan_memory_one("83 EC ?? E9 ?? ?? ?? ?? 00")
    26.         print("匹配到的地址: {}".format(hex(patternAddr)))
    27.  
    28.         dbg.set_breakpoint(patternAddr)
    29.         dbg.set_debug("Run")
    30.         dbg.set_debug("Wait")
    31.         dbg.delete_breakpoint(patternAddr)
    32.  
    33.         dbg.set_debug("StepOver")
    34.         dbg.set_debug("StepOver")
    35.         print("[+] 程序OEP = 0x{:x}".format(dbg.get_register("eip")))
    36.  
    37.     else:
    38.         currentIP = dbg.get_register("rip")
    39.  
    40.         if dbg.read_memory_dword(currentIP) != int(0x55575653):
    41.             print("[-] 可能不是UPX")
    42.             dbg.close()
    43.  
    44.         patternAddr = dbg.scan_memory_one("48 83 EC ?? E9")
    45.         print("匹配到的地址: {}".format(hex(patternAddr)))
    46.  
    47.         dbg.set_breakpoint(patternAddr)
    48.         dbg.set_debug("Run")
    49.         dbg.set_debug("Wait")
    50.         dbg.delete_breakpoint(patternAddr)
    51.  
    52.         dbg.set_debug("StepOver")
    53.         dbg.set_debug("StepOver")
    54.         print("[+] 程序OEP = 0x{:x}".format(dbg.get_register("eip")))
    55.  
    56.     dbg.close()

    通过断点检测监视函数: 通过运用check_breakpoint()断点检测函数，在断下后遍历堆栈，即可实现特定函数参数枚举。

    1. import time
    2. from LyScript32 import MyDebug
    3.  
    4. if __name__ == "__main__":
    5.     dbg = MyDebug()
    6.  
    7.     # 连接到调试器
    8.     connect_flag = dbg.connect()
    9.     dbg.is_connect()
    10.  
    11.     # 获取函数内存地址
    12.     addr = dbg.get_module_from_function("user32.dll","MessageBoxA")
    13.  
    14.     # 设置断点
    15.     dbg.set_breakpoint(addr)
    16.  
    17.     # 循环监视
    18.     while True:
    19.         # 检查断点是否被命中
    20.         check = dbg.check_breakpoint(addr)
    21.         if check == True:
    22.             # 命中则取出堆栈参数
    23.             esp = dbg.get_register("esp")
    24.             arg4 = dbg.read_memory_dword(esp)
    25.             arg3 = dbg.read_memory_dword(esp + 4)
    26.             arg2 = dbg.read_memory_dword(esp + 8)
    27.             arg1 = dbg.read_memory_dword(esp + 12)
    28.             print("arg1 = {:x} arg2 = {:x} arg3 = {:x} arg4 = {:x}".
    29.                   format(arg1,arg2,arg3,arg4))
    30.  
    31.             dbg.set_debug("Run")
    32.             time.sleep(1)
    33.     dbg.close()

    内存字节变更后回写: 封装字节函数write_opcode_list()传入内存地址，对该地址中的字节更改后再回写到原来的位置。

    • 加密算法在内存中会通过S盒展开解密，有时需要特殊需求，捕捉解密后的S-box写入内存，或对矩阵进行特殊处理后替换，这样写即可实现。
    1. from LyScript32 import MyDebug
    2.  
    3. # 对每一个字节如何处理
    4. def write_func(x):
    5.     x = x + 10
    6.     return x
    7.  
    8. # 对指定内存地址机器码进行相应处理
    9. def write_opcode_list(dbg_ptr, address, count, function_ptr):
    10.     for index in range(0, count):
    11.         read = dbg_ptr.read_memory_byte(address + index)
    12.  
    13.         ref = function_ptr(read)
    14.         print("处理后结果: {}".format(ref))
    15.  
    16.         dbg.write_memory_byte(address + index, ref)
    17.     return True
    18.  
    19. if __name__ == "__main__":
    20.     dbg = MyDebug()
    21.     dbg.connect()
    22.  
    23.     # 得到EIP
    24.     eip = dbg.get_register("eip")
    25.  
    26.     # 对指定内存中的数据+10后写回去
    27.     write_opcode_list(dbg,eip,100,write_func)
    28.  
    29.     dbg.close()

    将ShellCode从文本中注入到内存: 从文本中读取ShellCode代码，将该代码注入到目标进程的堆中，并把当前内存属性设置为可执行。

    1. from LyScript32 import MyDebug
    2.  
    3. # 将shellcode读入内存
    4. def read_shellcode(path):
    5.     shellcode_list = []
    6.     with open(path,"r",encoding="utf-8") as fp:
    7.         for index in fp.readlines():
    8.             shellcode_line = index.replace('"',"").replace(" ","").replace("\n","").replace(";","")
    9.             for code in shellcode_line.split("\\x"):
    10.                 if code != "" and code != "\\n":
    11.                     shellcode_list.append("0x" + code)
    12.     return shellcode_list
    13.  
    14. if __name__ == "__main__":
    15.     dbg = MyDebug()
    16.     dbg.connect()
    17.  
    18.     # 开辟堆空间
    19.     address = dbg.create_alloc(1024)
    20.     print("开辟堆空间: {}".format(hex(address)))
    21.     if address == False:
    22.         exit()
    23.  
    24.     # 设置内存可执行属性
    25.     dbg.set_local_protect(address,32,1024)
    26.  
    27.     # 从文本中读取shellcode
    28.     shellcode = read_shellcode("d://shellcode.txt")
    29.  
    30.     # 循环写入到内存
    31.     for code_byte in range(0,len(shellcode)):
    32.         bytef = int(shellcode[code_byte],16)
    33.         dbg.write_memory_byte(code_byte + address, bytef)
    34.  
    35.     # 设置EIP位置
    36.     dbg.set_register("eip",address)
    37.  
    38.     input()
    39.     dbg.delete_alloc(address)
    40.  
    41.     dbg.close()

    如果把这个过程反过来，就是将特定位置的汇编代码保存到本地。

    1. from LyScript32 import MyDebug
    2.  
    3. # 将特定内存保存到文本中
    4. def write_shellcode(dbg,address,size,path):
    5.     with open(path,"a+",encoding="utf-8") as fp:
    6.         for index in range(0, size - 1):
    7.             # 读取机器码
    8.             read_code = dbg.read_memory_byte(address + index)
    9.  
    10.             if (index+1) % 16 == 0:
    11.                 print("\\x" + str(read_code))
    12.                 fp.write("\\x" + str(read_code) + "\n")
    13.             else:
    14.                 print("\\x" + str(read_code),end="")
    15.                 fp.write("\\x" + str(read_code))
    16.  
    17. if __name__ == "__main__":
    18.     dbg = MyDebug()
    19.     dbg.connect()
    20.  
    21.     eip = dbg.get_register("eip")
    22.     write_shellcode(dbg,eip,128,"d://lyshark.txt")
    23.     dbg.close()

    指令集探针快速检索: 快速检索当前程序中所有模块中是否存在特定的指令集片段，存在则返回内存地址。

    1. from LyScript32 import MyDebug
    2.  
    3. # 将bytearray转为字符串
    4. def get_string(byte_array):
    5.     ref_string = str()
    6.     for index in byte_array:
    7.         ref_string = ref_string + "".join(str(index))
    8.     return ref_string
    9.  
    10. # 传入汇编代码,得到对应机器码
    11. def get_opcode_from_assemble(dbg_ptr,asm):
    12.   pass
    13.  
    14. if __name__ == "__main__":
    15.     dbg = MyDebug()
    16.     dbg.connect()
    17.  
    18.     # 需要搜索的指令集片段
    19.     search_asm = ['pop ecx','mov edi,edi', 'push eax', 'jmp esp']
    20.     opcode = []
    21.  
    22.     # 将汇编指令转为机器码,放入opcode
    23.     for index in range(len(search_asm)):
    24.         byt = bytearray()
    25.         byt = get_opcode_from_assemble(dbg, search_asm[index])
    26.         opcode.append(get_string(byt))
    27.  
    28.     # 循环搜索指令集内存地址
    29.     for index,entry in zip(range(0,len(opcode)), dbg.get_all_module()):
    30.         eip = entry.get("entry")
    31.         base_name = entry.get("name")
    32.         if eip != 0:
    33.             dbg.set_register("eip",eip)
    34.             search_address = dbg.scan_memory_all(opcode[index])
    35.  
    36.             if search_address != False:
    37.                 print("指令: {} --> 模块: {} --> 个数: {}".
    38. 		format(search_asm[index],base_name,len(search_address)))
    39.  
    40.                 for search_index in search_address:
    41.                     print("[*] {}".format(hex(search_index)))
    42.             else:
    43.                 print("a")
    44.  
    45.         time.sleep(0.3)
    46.     dbg.close()

    使用内置脚本得到返回值: 使用内置run_command_exec()函数时，用户只能得到内置脚本执行后的状态值，如果想要得到内置命令的返回值则你可以这样写。

    1. from LyScript32 import MyDebug
    2.  
    3. dbg = MyDebug()
    4. conn = dbg.connect()
    5.  
    6. # 首先定义一个脚本变量
    7. ref = dbg.run_command_exec("$addr=1024")
    8.  
    9. # 将脚本返回值放到eax寄存器，或者开辟一个堆放到堆里
    10. dbg.run_command_exec("eax=$addr")
    11.  
    12. # 最后拿到寄存器的值
    13. hex(dbg.get_register("eax"))

    通过中转的方式，可以很好的得到内置脚本的返回值，如下我将其封装成了一个独立的方法。

    1. from LyScript32 import MyDebug
    2.  
    3. # 得到脚本返回值
    4. def GetScriptValue(dbg,script):
    5.     try:
    6.         ref = dbg.run_command_exec("push eax")
    7.         if ref != True:
    8.             return None
    9.         ref = dbg.run_command_exec(f"eax={script}")
    10.         if ref != True:
    11.             return None
    12.         reg = dbg.get_register("eax")
    13.         ref = dbg.run_command_exec("pop eax")
    14.         if ref != True:
    15.             return None
    16.         return reg
    17.     except Exception:
    18.         return None
    19.     return None
    20.  
    21. if __name__ == "__main__":
    22.     dbg = MyDebug()
    23.     dbg.connect()
    24.  
    25.     eax = "401000"
    26.     ref = GetScriptValue(dbg,"mod.base({})".format(eax))
    27.     print(hex(ref))
    28.     
    29.     dbg.close()

    获取节表内存属性: 默认情况下插件可以得到当前节表，但无法直接取到节表内存属性，如果需要得到某个节的内存属性，可以这样写。

    节表属性是一个数字，数字含义如下:

    • ER 执行/读取 32
    • E 执行 30
    • R 读取 2
    • W 写入 2
    • C 未知 4
    • N 空属性 1
    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug()
    5.     conn = dbg.connect()
    6.  
    7.     section = dbg.get_section()
    8.     for i in section:
    9.         section_address = hex(i.get("addr"))
    10.         section_name = i.get("name")
    11.         section_size = i.get("size")
    12.         section_type = dbg.get_local_protect(i.get("addr"))
    13.         print(f"地址: {section_address} -> 名字: {section_name} -> 大小: {section_size}bytes -> ",end="")
    14.  
    15.         if(section_type == 32):
    16.             print("属性: 执行/读取")
    17.         elif(section_type == 30):
    18.             print("属性: 执行")
    19.         elif(section_type == 2):
    20.             print("属性: 只读")
    21.         elif(section_type == 4):
    22.             print("属性: 读写")
    23.         elif(section_type == 1):
    24.             print("属性: 空属性")
    25.         else:
    26.             print("属性: 读/写/控制")
    27.  
    28.     dbg.close()
    29.     pass

    封装获取反汇编代码: 反汇编时可以使用get_disasm_code()函数，但如果想要自己实现可以这样写。

    1. from LyScript32 import MyDebug
    2.  
    3. if __name__ == "__main__":
    4.     dbg = MyDebug()
    5.     conn = dbg.connect()
    6.  
    7.     # 获取当前EIP地址
    8.     eip = dbg.get_register("eip")
    9.     print("eip = {}".format(hex(eip)))
    10.  
    11.     # 向下反汇编字节数
    12.     count = eip + 15
    13.     while True:
    14.         # 每次得到一条反汇编指令
    15.         dissasm = dbg.get_disasm_one_code(eip)
    16.  
    17.         print("0x{:08x} | {}".format(eip, dissasm))
    18.  
    19.         # 判断是否满足退出条件
    20.         if eip >= count:
    21.             break
    22.         else:
    23.             # 得到本条反汇编代码的长度
    24.             dis_size = dbg.assemble_code_size(dissasm)
    25.             eip = eip + dis_size
    26.  
    27.     dbg.close()
    28.     pass

    得到当前EIP机器码: 获取到当前EIP指针所在位置的机器码，你可以灵活运用反汇编代码的组合实现。

    1. from LyScript32 import MyDebug
    2.  
    3. # 得到机器码
    4. def GetHexCode(dbg,address):
    5.     ref_bytes = []
    6.     # 首先得到反汇编指令,然后得到该指令的长度
    7.     asm_len = dbg.assemble_code_size( dbg.get_disasm_one_code(address) )
    8.  
    9.     # 循环得到每个机器码
    10.     for index in range(0,asm_len):
    11.         ref_bytes.append(dbg.read_memory_byte(address))
    12.         address = address + 1
    13.     return ref_bytes
    14.  
    15. if __name__ == "__main__":
    16.     dbg = MyDebug()
    17.     conn = dbg.connect()
    18.  
    19.     # 获取当前EIP地址
    20.     eip = dbg.get_register("eip")
    21.     print("eip = {}".format(hex(eip)))
    22.  
    23.     # 得到机器码
    24.     ref = GetHexCode(dbg,eip)
    25.     for i in range(0,len(ref)):
    26.         print("0x{:02x} ".format(ref[i]),end="")
    27.  
    28.     dbg.close()
    29.     pass

    如果将如上的两个方法结合起来，那么基本上就实现了获取反汇编窗口中的所有内容。

    1. from LyScript32 import MyDebug
    2.  
    3. # 得到机器码
    4. def GetHexCode(dbg,address):
    5.     ref_bytes = []
    6.     # 首先得到反汇编指令,然后得到该指令的长度
    7.     asm_len = dbg.assemble_code_size( dbg.get_disasm_one_code(address) )
    8.     # 循环得到每个机器码
    9.     for index in range(0,asm_len):
    10.         ref_bytes.append(dbg.read_memory_byte(address))
    11.         address = address + 1
    12.     return ref_bytes
    13.  
    14. if __name__ == "__main__":
    15.     dbg = MyDebug()
    16.     conn = dbg.connect()
    17.  
    18.     # 获取当前EIP地址
    19.     eip = dbg.get_register("eip")
    20.     print("eip = {}".format(hex(eip)))
    21.  
    22.     # 向下反汇编字节数
    23.     count = eip + 20
    24.     while True:
    25.         # 每次得到一条反汇编指令
    26.         dissasm = dbg.get_disasm_one_code(eip)
    27.  
    28.         print("0x{:08x} | {:50} | ".format(eip, dissasm),end="")
    29.  
    30.         # 得到机器码
    31.         ref = GetHexCode(dbg, eip)
    32.         for i in range(0, len(ref)):
    33.             print("0x{:02x} ".format(ref[i]), end="")
    34.         print()
    35.  
    36.         # 判断是否满足退出条件
    37.         if eip >= count:
    38.             break
    39.         else:
    40.             # 得到本条反汇编代码的长度
    41.             dis_size = dbg.assemble_code_size(dissasm)
    42.             eip = eip + dis_size
    43.  
    44.     dbg.close()
    45.     pass

    封装汇编指令提取器: 当用户传入指定汇编指令的时候，自动的将其转换成对应的机器码，代码很简单，首先dbg.create_alloc(1024)在进程内存中开辟堆空间，用于存放我们的机器码，然后调用dbg.assemble_write_memory(alloc_address,"sub esp,10")将一条汇编指令变成机器码写到对端内存，然后再op = dbg.read_memory_byte(alloc_address + index)依次将其读取出来即可。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编指令,获取该指令的机器码
    4. def get_assembly_machine_code(dbg,asm):
    5.     pass
    6.  
    7. if __name__ == "__main__":
    8.     dbg = MyDebug()
    9.     connect_flag = dbg.connect()
    10.     print("连接状态: {}".format(connect_flag))
    11.  
    12.     machine_code_list = []
    13.  
    14.     # 开辟堆空间
    15.     alloc_address = dbg.create_alloc(1024)
    16.     print("分配堆: {}".format(hex(alloc_address)))
    17.  
    18.     # 得到汇编机器码
    19.     machine_code = dbg.assemble_write_memory(alloc_address,"sub esp,10")
    20.     if machine_code == False:
    21.         dbg.delete_alloc(alloc_address)
    22.  
    23.     # 得到汇编指令长度
    24.     machine_code_size = dbg.assemble_code_size("sub esp,10")
    25.     if machine_code == False:
    26.         dbg.delete_alloc(alloc_address)
    27.  
    28.     # 读取机器码
    29.     for index in range(0,machine_code_size):
    30.         op = dbg.read_memory_byte(alloc_address + index)
    31.         machine_code_list.append(op)
    32.  
    33.     # 释放堆空间
    34.     dbg.delete_alloc(alloc_address)
    35.  
    36.     # 输出机器码
    37.     print(machine_code_list)
    38.     dbg.close()

    我们继续封装如上方法，封装成一个可以直接使用的get_assembly_machine_code函数。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编指令,获取该指令的机器码
    4. def get_assembly_machine_code(dbg,asm):
    5.     machine_code_list = []
    6.  
    7.     # 开辟堆空间
    8.     alloc_address = dbg.create_alloc(1024)
    9.     print("分配堆: {}".format(hex(alloc_address)))
    10.  
    11.     # 得到汇编机器码
    12.     machine_code = dbg.assemble_write_memory(alloc_address,asm)
    13.     if machine_code == False:
    14.         dbg.delete_alloc(alloc_address)
    15.  
    16.     # 得到汇编指令长度
    17.     machine_code_size = dbg.assemble_code_size(asm)
    18.     if machine_code == False:
    19.         dbg.delete_alloc(alloc_address)
    20.  
    21.     # 读取机器码
    22.     for index in range(0,machine_code_size):
    23.         op = dbg.read_memory_byte(alloc_address + index)
    24.         machine_code_list.append(op)
    25.  
    26.     # 释放堆空间
    27.     dbg.delete_alloc(alloc_address)
    28.     return machine_code_list
    29.  
    30. if __name__ == "__main__":
    31.     dbg = MyDebug()
    32.     connect_flag = dbg.connect()
    33.     print("连接状态: {}".format(connect_flag))
    34.  
    35.     # 转换第一对
    36.     opcode = get_assembly_machine_code(dbg,"mov eax,1")
    37.     for index in opcode:
    38.         print("0x{:02X} ".format(index),end="")
    39.     print()
    40.  
    41.     # 转换第二对
    42.     opcode = get_assembly_machine_code(dbg,"sub esp,10")
    43.     for index in opcode:
    44.         print("0x{:02X} ".format(index),end="")
    45.     print()
    46.  
    47.     dbg.close()

    扫描符合条件的内存: 通过使用上方封装的get_assembly_machine_code()并配合scan_memory_one(scan_string)函数，在对端内存搜索是否存在符合条件的指令。

    1. from LyScript32 import MyDebug
    2.  
    3. # 传入汇编指令,获取该指令的机器码
    4. def get_assembly_machine_code(dbg,asm):
    5.     machine_code_list = []
    6.  
    7.     # 开辟堆空间
    8.     alloc_address = dbg.create_alloc(1024)
    9.     print("分配堆: {}".format(hex(alloc_address)))
    10.  
    11.     # 得到汇编机器码
    12.     machine_code = dbg.assemble_write_memory(alloc_address,asm)
    13.     if machine_code == False:
    14.         dbg.delete_alloc(alloc_address)
    15.  
    16.     # 得到汇编指令长度
    17.     machine_code_size = dbg.assemble_code_size(asm)
    18.     if machine_code == False:
    19.         dbg.delete_alloc(alloc_address)
    20.  
    21.     # 读取机器码
    22.     for index in range(0,machine_code_size):
    23.         op = dbg.read_memory_byte(alloc_address + index)
    24.         machine_code_list.append(op)
    25.  
    26.     # 释放堆空间
    27.     dbg.delete_alloc(alloc_address)
    28.     return machine_code_list
    29.  
    30. if __name__ == "__main__":
    31.     dbg = MyDebug()
    32.     connect_flag = dbg.connect()
    33.     print("连接状态: {}".format(connect_flag))
    34.  
    35.     for item in ["push eax","mov eax,1","jmp eax","pop eax"]:
    36.         # 转换成列表
    37.         opcode = get_assembly_machine_code(dbg,item)
    38.         #print("得到机器码列表: ",opcode)
    39.  
    40.         # 列表转换成字符串
    41.         scan_string = " ".join([str(_) for _ in opcode])
    42.         #print("搜索机器码字符串: ", scan_string)
    43.  
    44.         address = dbg.scan_memory_one(scan_string)
    45.         print("第一个符合条件的内存块: {}".format(hex(address)))
    46.  
    47.     dbg.close()

    获取下一条汇编指令: 下一条汇编指令的获取需要注意如果是被命中的指令则此处应该是CC断点占用一个字节，如果不是则正常获取到当前指令即可。

    • 1.我们需要检查当前内存断点是否被命中，如果没有命中则说明此处我们需要获取到原始的汇编指令长度，然后与当前eip地址相加获得。
    • 2.如果命中了断点，则此处有两种情况
      • 1.1 如果是用户下的断点，则此处调试器会在指令位置替换为CC，也就是汇编中的init停机指令，该指令占用1个字节，需要eip+1得到。
      • 1.2 如果是系统断点，EIP所停留的位置，则我们需要正常获取当前指令地址，此处调试器没有改动汇编指令仅仅只下下了异常断点。
    1. from LyScript32 import MyDebug
    2.  
    3. # 获取当前EIP指令的下一条指令
    4. def get_disasm_next(dbg,eip):
    5.     next = 0
    6.  
    7.     # 检查当前内存地址是否被下了绊子
    8.     check_breakpoint = dbg.check_breakpoint(eip)
    9.  
    10.     # 说明存在断点，如果存在则这里就是一个字节了
    11.     if check_breakpoint == True:
    12.  
    13.         # 接着判断当前是否是EIP，如果是EIP则需要使用原来的字节
    14.         local_eip = dbg.get_register("eip")
    15.  
    16.         # 说明是EIP并且命中了断点
    17.         if local_eip == eip:
    18.             dis_size = dbg.get_disasm_operand_size(eip)
    19.             next = eip + dis_size
    20.             next_asm = dbg.get_disasm_one_code(next)
    21.             return next_asm
    22.         else:
    23.             next = eip + 1
    24.             next_asm = dbg.get_disasm_one_code(next)
    25.             return next_asm
    26.         return None
    27.  
    28.     # 不是则需要获取到原始汇编代码的长度
    29.     elif check_breakpoint == False:
    30.         # 得到当前指令长度
    31.         dis_size = dbg.get_disasm_operand_size(eip)
    32.         next = eip + dis_size
    33.         next_asm = dbg.get_disasm_one_code(next)
    34.         return next_asm
    35.     else:
    36.         return None
    37.  
    38. if __name__ == "__main__":
    39.     dbg = MyDebug()
    40.     dbg.connect()
    41.  
    42.     eip = dbg.get_register("eip")
    43.  
    44.     next = get_disasm_next(dbg,eip)
    45.     print("下一条指令: {}".format(next))
    46.  
    47.     prev = get_disasm_next(dbg,12391436)
    48.     print("下一条指令: {}".format(prev))
    49.  
    50.     dbg.close()

    获取上一条汇编指令: 上一条指令的获取难点就在于，我们无法确定当前指令的上一条指令到底有多长，所以只能用笨办法，逐行扫描对比汇编指令，如果找到则取出其上一条指令即可。

    1. from LyScript32 import MyDebug
    2.  
    3. # 获取当前EIP指令的上一条指令
    4. def get_disasm_prev(dbg,eip):
    5.     prev_dasm = None
    6.     # 得到当前汇编指令
    7.     local_disasm = dbg.get_disasm_one_code(eip)
    8.  
    9.     # 只能向上扫描10行
    10.     eip = eip - 10
    11.     disasm = dbg.get_disasm_code(eip,10)
    12.  
    13.     # 循环扫描汇编代码
    14.     for index in range(0,len(disasm)):
    15.         # 如果找到了,就取出他的上一个汇编代码
    16.         if disasm[index].get("opcode") == local_disasm:
    17.             prev_dasm = disasm[index-1].get("opcode")
    18.             break
    19.  
    20.     return prev_dasm
    21.  
    22. if __name__ == "__main__":
    23.     dbg = MyDebug()
    24.     dbg.connect()
    25.  
    26.     eip = dbg.get_register("eip")
    27.  
    28.     next = get_disasm_prev(dbg,eip)
    29.     print("上一条指令: {}".format(next))
    30.  
    31.     dbg.close()

    判断是否为特定指令: 判断当前传入的内存地址处的汇编指令集，看是否是call,nop,jmp,ret指令，如果是返回True否则返回False。

    1. from LyScript32 import MyDebug
    2.  
    3. # 是否是跳转指令
    4. def is_call(dbg,address):
    5.     try:
    6.         dis = dbg.get_disasm_one_code(address)
    7.         if dis != False or dis != None:
    8.             if dis.split(" ")[0].replace(" ","") == "call":
    9.                 return True
    10.             return False
    11.         return False
    12.     except Exception:
    13.         return False
    14.     return False
    15.  
    16. # 是否是jmp
    17. def is_jmp(dbg,address):
    18.     try:
    19.         dis = dbg.get_disasm_one_code(address)
    20.         if dis != False or dis != None:
    21.             if dis.split(" ")[0].replace(" ","") == "jmp":
    22.                 return True
    23.             return False
    24.         return False
    25.     except Exception:
    26.         return False
    27.     return False
    28.  
    29. # 是否是ret
    30. def is_ret(dbg,address):
    31.     try:
    32.         dis = dbg.get_disasm_one_code(address)
    33.         if dis != False or dis != None:
    34.             if dis.split(" ")[0].replace(" ","") == "ret":
    35.                 return True
    36.             return False
    37.         return False
    38.     except Exception:
    39.         return False
    40.     return False
    41.  
    42. # 是否是nop
    43. def is_nop(dbg,address):
    44.     try:
    45.         dis = dbg.get_disasm_one_code(address)
    46.         if dis != False or dis != None:
    47.             if dis.split(" ")[0].replace(" ","") == "nop":
    48.                 return True
    49.             return False
    50.         return False
    51.     except Exception:
    52.         return False
    53.     return False
    54.  
    55. if __name__ == "__main__":
    56.     dbg = MyDebug()
    57.     dbg.connect()
    58.  
    59.     eip = dbg.get_register("eip")
    60.  
    61.     call = is_call(dbg, eip)
    62.     print("是否是Call指令: {}".format(call))
    63.     dbg.close()

    同如上所示，我们也可以验证指令集是否是条件跳转命令，验证方式只需要稍微改动代码即可。

    1. from LyScript32 import MyDebug
    2.  
    3. # 是否是条件跳转指令
    4. def is_cond(dbg,address):
    5.     try:
    6.         dis = dbg.get_disasm_one_code(address)
    7.         if dis != False or dis != None:
    8.  
    9.             if dis.split(" ")[0].replace(" ","") 
    10. 	    	in ["je","jne","jz","jnz","ja","jna","jp","jnp","jb","jnb","jg","jng","jge","jl","jle"]:
    11.                 return True
    12.             return False
    13.         return False
    14.     except Exception:
    15.         return False
    16.     return False
    17.  
    18. if __name__ == "__main__":
    19.     dbg = MyDebug()
    20.     dbg.connect()
    21.  
    22.     eip = dbg.get_register("eip")
    23.  
    24.     call = is_cond(dbg, eip)
    25.     print("是否是条件跳转指令: {}".format(call))
    26.     dbg.close()

    内存区域交换与差异对比: 内存交换可调用memory_xchage将两个内存颠倒顺序，内存差异对比可调用memory_cmp对比内存差异并返回列表。

    1. from LyScript32 import MyDebug
    2.  
    3. # 交换两个内存区域
    4. def memory_xchage(dbg,memory_ptr_x,memory_ptr_y,bytes):
    5.     ref = False
    6.     for index in range(0,bytes):
    7.         # 读取两个内存区域
    8.         read_byte_x = dbg.read_memory_byte(memory_ptr_x + index)
    9.         read_byte_y = dbg.read_memory_byte(memory_ptr_y + index)
    10.  
    11.         # 交换内存
    12.         ref = dbg.write_memory_byte(memory_ptr_x + index,read_byte_y)
    13.         ref = dbg.write_memory_byte(memory_ptr_y + index, read_byte_x)
    14.     return ref
    15.  
    16. # 对比两个内存区域
    17. def memory_cmp(dbg,memory_ptr_x,memory_ptr_y,bytes):
    18.     cmp_memory = []
    19.     for index in range(0,bytes):
    20.  
    21.         item = {"addr":0, "x": 0, "y": 0}
    22.  
    23.         # 读取两个内存区域
    24.         read_byte_x = dbg.read_memory_byte(memory_ptr_x + index)
    25.         read_byte_y = dbg.read_memory_byte(memory_ptr_y + index)
    26.  
    27.         if read_byte_x != read_byte_y:
    28.             item["addr"] = memory_ptr_x + index
    29.             item["x"] = read_byte_x
    30.             item["y"] = read_byte_y
    31.             cmp_memory.append(item)
    32.     return cmp_memory
    33.  
    34. if __name__ == "__main__":
    35.     dbg = MyDebug()
    36.     dbg.connect()
    37.  
    38.     eip = dbg.get_register("eip")
    39.  
    40.     # 内存交换
    41.     flag = memory_xchage(dbg, 12386320,12386352,4)
    42.     print("内存交换状态: {}".format(flag))
    43.  
    44.     # 内存对比
    45.     cmp_ref = memory_cmp(dbg, 12386320,12386352,4)
    46.     for index in range(0,len(cmp_ref)):
    47.         print("地址: 0x{:08X} -> X: 0x{:02x} -> y: 0x{:02x}"
    48. 		.format(cmp_ref[index].get("addr"),cmp_ref[index].get("x"),cmp_ref[index].get("y")))
    49.  
    50.     dbg.close()

    内存与磁盘机器码比较: 通过调用read_memory_byte()函数，或者open()打开文件，等就可以得到程序磁盘与内存中特定位置的机器码参数，然后通过对每一个列表中的字节进行比较，就可得到特定位置下磁盘与内存中的数据是否一致的判断。

    1. #coding: utf-8
    2. import binascii,os,sys
    3. from LyScript32 import MyDebug
    4.  
    5. # 得到程序的内存镜像中的机器码
    6. def get_memory_hex_ascii(address,offset,len):
    7.     count = 0
    8.     ref_memory_list = []
    9.     for index in range(offset,len):
    10.         # 读出数据
    11.         char = dbg.read_memory_byte(address + index)
    12.         count = count + 1
    13.  
    14.         if count % 16 == 0:
    15.             if (char) < 16:
    16.                 print("0" + hex((char))[2:])
    17.                 ref_memory_list.append("0" + hex((char))[2:])
    18.             else:
    19.                 print(hex((char))[2:])
    20.                 ref_memory_list.append(hex((char))[2:])
    21.         else:
    22.             if (char) < 16:
    23.                 print("0" + hex((char))[2:] + " ",end="")
    24.                 ref_memory_list.append("0" + hex((char))[2:])
    25.             else:
    26.                 print(hex((char))[2:] + " ",end="")
    27.                 ref_memory_list.append(hex((char))[2:])
    28.     return ref_memory_list
    29.  
    30. # 读取程序中的磁盘镜像中的机器码
    31. def get_file_hex_ascii(path,offset,len):
    32.     count = 0
    33.     ref_file_list = []
    34.  
    35.     with open(path, "rb") as fp:
    36.         # file_size = os.path.getsize(path)
    37.         fp.seek(offset)
    38.  
    39.         for item in range(offset,offset + len):
    40.             char = fp.read(1)
    41.             count = count + 1
    42.             if count % 16 == 0:
    43.                 if ord(char) < 16:
    44.                     print("0" + hex(ord(char))[2:])
    45.                     ref_file_list.append("0" + hex(ord(char))[2:])
    46.                 else:
    47.                     print(hex(ord(char))[2:])
    48.                     ref_file_list.append(hex(ord(char))[2:])
    49.             else:
    50.                 if ord(char) < 16:
    51.                     print("0" + hex(ord(char))[2:] + " ", end="")
    52.                     ref_file_list.append("0" + hex(ord(char))[2:])
    53.                 else:
    54.                     print(hex(ord(char))[2:] + " ", end="")
    55.                     ref_file_list.append(hex(ord(char))[2:])
    56.     return ref_file_list
    57.  
    58. if __name__ == "__main__":
    59.     dbg = MyDebug()
    60.  
    61.     connect_flag = dbg.connect()
    62.     print("连接状态: {}".format(connect_flag))
    63.  
    64.     module_base = dbg.get_base_from_address(dbg.get_local_base())
    65.     print("模块基地址: {}".format(hex(module_base)))
    66.  
    67.     # 得到内存机器码
    68.     memory_hex_byte = get_memory_hex_ascii(module_base,0,1024)
    69.  
    70.     # 得到磁盘机器码
    71.     file_hex_byte = get_file_hex_ascii("d://Win32Project1.exe",0,1024)
    72.  
    73.     # 输出机器码
    74.     for index in range(0,len(memory_hex_byte)):
    75.         # 比较磁盘与内存是否存在差异
    76.         if memory_hex_byte[index] != file_hex_byte[index]:
    77.             # 存在差异则输出
    78.             print("\n相对位置: [{}] --> 磁盘字节: 0x{} --> 内存字节: 0x{}".
    79.                   format(index,memory_hex_byte[index],file_hex_byte[index]))
    80.     dbg.close()

    内存ASCII码解析: 通过封装的get_memory_hex_ascii得到内存机器码，然后再使用如下过程实现输出该内存中的机器码所对应的ASCII码。

    1. from LyScript32 import MyDebug
    2. import os,sys
    3.  
    4. # 转为ascii
    5. def to_ascii(h):
    6.     list_s = []
    7.     for i in range(0, len(h), 2):
    8.         list_s.append(chr(int(h[i:i+2], 16)))
    9.     return ''.join(list_s)
    10.  
    11. # 转为16进制
    12. def to_hex(s):
    13.     list_h = []
    14.     for c in s:
    15.         list_h.append(hex(ord(c))[2:])
    16.     return ''.join(list_h)
    17.  
    18. # 得到程序的内存镜像中的机器码
    19. def get_memory_hex_ascii(address,offset,len):
    20.     count = 0
    21.     ref_memory_list = []
    22.     for index in range(offset,len):
    23.         # 读出数据
    24.         char = dbg.read_memory_byte(address + index)
    25.         count = count + 1
    26.  
    27.         if count % 16 == 0:
    28.             if (char) < 16:
    29.                 ref_memory_list.append("0" + hex((char))[2:])
    30.             else:
    31.                 ref_memory_list.append(hex((char))[2:])
    32.         else:
    33.             if (char) < 16:
    34.                 ref_memory_list.append("0" + hex((char))[2:])
    35.             else:
    36.                 ref_memory_list.append(hex((char))[2:])
    37.     return ref_memory_list
    38.  
    39.  
    40. if __name__ == "__main__":
    41.     dbg = MyDebug()
    42.     dbg.connect()
    43.  
    44.     eip = dbg.get_register("eip")
    45.  
    46.     # 得到模块基地址
    47.     module_base = dbg.get_base_from_address(dbg.get_local_base())
    48.  
    49.     # 得到指定区域内存机器码
    50.     ref_memory_list = get_memory_hex_ascii(module_base,0,1024)
    51.  
    52.     # 解析ascii码
    53.     break_count = 1
    54.     for index in ref_memory_list:
    55.         if break_count %32 == 0:
    56.             print(to_ascii(hex(int(index, 16))[2:]))
    57.         else:
    58.             print(to_ascii(hex(int(index, 16))[2:]),end="")
    59.         break_count = break_count + 1
    60.  
    61.     dbg.close()

    内存特征码匹配: 通过二次封装get_memory_hex_ascii()实现扫描内存特征码功能，如果存在则返回True否则返回False。

    1. from LyScript32 import MyDebug
    2. import os,sys
    3.  
    4. # 得到程序的内存镜像中的机器码
    5. def get_memory_hex_ascii(address,offset,len):
    6.     count = 0
    7.     ref_memory_list = []
    8.     for index in range(offset,len):
    9.         # 读出数据
    10.         char = dbg.read_memory_byte(address + index)
    11.         count = count + 1
    12.  
    13.         if count % 16 == 0:
    14.             if (char) < 16:
    15.                 ref_memory_list.append("0" + hex((char))[2:])
    16.             else:
    17.                 ref_memory_list.append(hex((char))[2:])
    18.         else:
    19.             if (char) < 16:
    20.                 ref_memory_list.append("0" + hex((char))[2:])
    21.             else:
    22.                 ref_memory_list.append(hex((char))[2:])
    23.     return ref_memory_list
    24.  
    25.  
    26. # 在指定区域内搜索特定的机器码,如果完全匹配则返回
    27. def search_hex_ascii(address,offset,len,hex_array):
    28.     # 得到指定区域内存机器码
    29.     ref_memory_list = get_memory_hex_ascii(address,offset,len)
    30.  
    31.     array = []
    32.  
    33.     # 循环输出字节
    34.     for index in range(0,len + len(hex_array)):
    35.  
    36.         # 如果有则继续装
    37.         if len(hex_array) != len(array):
    38.             array.append(ref_memory_list[offset + index])
    39.  
    40.         else:
    41.             for y in range(0,len(array)):
    42.                 if array[y] != ref_memory_list[offset + index + y]:
    43.                     return False
    44.  
    45.         array.clear()
    46.     return False
    47.  
    48. if __name__ == "__main__":
    49.     dbg = MyDebug()
    50.     dbg.connect()
    51.  
    52.     eip = dbg.get_register("eip")
    53.  
    54.     # 得到模块基地址
    55.     module_base = dbg.get_base_from_address(dbg.get_local_base())
    56.     
    57.     re = search_hex_ascii(module_base,0,100,hex_array=["0x4d","0x5a"])
    58.     
    59.     dbg.close()

    特征码扫描一般不需要自己写，自己写的麻烦，而且不支持通配符，可以直接调用我们API中封装好的scan_memory_one()它可以支持??通配符模糊匹配，且效率要高许多。

    堆栈地址有符号无符号转换: peek_stack命令传入的是堆栈下标位置默认从0开始，并输出一个十进制有符号长整数，首先实现有符号与无符号数之间的转换操作，为后续堆栈扫描做准备。

    1. from LyScript32 import MyDebug
    2.  
    3. # 有符号整数转无符号数
    4. def long_to_ulong(inter,is_64 = False):
    5.     if is_64 == False:
    6.         return inter & ((1 << 32) - 1)
    7.     else:
    8.         return inter & ((1 << 64) - 1)
    9.  
    10. # 无符号整数转有符号数
    11. def ulong_to_long(inter,is_64 = False):
    12.     if is_64 == False:
    13.         return (inter & ((1 << 31) - 1)) - (inter & (1 << 31))
    14.     else:
    15.         return (inter & ((1 << 63) - 1)) - (inter & (1 << 63))
    16.  
    17. if __name__ == "__main__":
    18.     dbg = MyDebug()
    19.  
    20.     connect_flag = dbg.connect()
    21.     print("连接状态: {}".format(connect_flag))
    22.  
    23.     for index in range(0,10):
    24.  
    25.         # 默认返回有符号数
    26.         stack_address = dbg.peek_stack(index)
    27.  
    28.         # 使用转换
    29.         print("默认有符号数: {:15} --> 转为无符号数: {:15} --> 转为有符号数: {:15}".
    30.               format(stack_address, 
    31. 	      long_to_ulong(stack_address),
    32. 	      ulong_to_long(long_to_ulong(stack_address))))
    33.  
    34.     dbg.close()

    扫描堆栈并反汇编一条: 我们使用get_disasm_one_code()函数，扫描堆栈地址并得到该地址处的第一条反汇编代码。

    1. from LyScript32 import MyDebug
    2.  
    3. # 有符号整数转无符号数
    4. def long_to_ulong(inter,is_64 = False):
    5.     if is_64 == False:
    6.         return inter & ((1 << 32) - 1)
    7.     else:
    8.         return inter & ((1 << 64) - 1)
    9.  
    10. # 无符号整数转有符号数
    11. def ulong_to_long(inter,is_64 = False):
    12.     if is_64 == False:
    13.         return (inter & ((1 << 31) - 1)) - (inter & (1 << 31))
    14.     else:
    15.         return (inter & ((1 << 63) - 1)) - (inter & (1 << 63))
    16.  
    17. if __name__ == "__main__":
    18.     dbg = MyDebug()
    19.  
    20.     connect_flag = dbg.connect()
    21.     print("连接状态: {}".format(connect_flag))
    22.  
    23.     for index in range(0,10):
    24.  
    25.         # 默认返回有符号数
    26.         stack_address = dbg.peek_stack(index)
    27.  
    28.         # 反汇编一行
    29.         dasm = dbg.get_disasm_one_code(stack_address)
    30.  
    31.         # 根据地址得到模块基址
    32.         if stack_address <= 0:
    33.             mod_base = 0
    34.         else:
    35.             mod_base = dbg.get_base_from_address(long_to_ulong(stack_address))
    36.  
    37.         print("stack => [{}] addr = {:10} base = {:10} dasm = {}".
    38. 		format(index, hex(long_to_ulong(stack_address)),hex(mod_base), dasm))
    39.  
    40.     dbg.close()

    得到堆栈返回模块基址: 首先我们需要得到程序全局状态下的所有加载模块的基地址，然后得到当前堆栈内存地址内的实际地址，并通过实际内存地址得到模块基地址，对比全局表即可拿到当前模块是返回到了哪里。

    1. from LyScript32 import MyDebug
    2.  
    3. # 有符号整数转无符号数
    4. def long_to_ulong(inter,is_64 = False):
    5.     if is_64 == False:
    6.         return inter & ((1 << 32) - 1)
    7.     else:
    8.         return inter & ((1 << 64) - 1)
    9.  
    10. # 无符号整数转有符号数
    11. def ulong_to_long(inter,is_64 = False):
    12.     if is_64 == False:
    13.         return (inter & ((1 << 31) - 1)) - (inter & (1 << 31))
    14.     else:
    15.         return (inter & ((1 << 63) - 1)) - (inter & (1 << 63))
    16.  
    17. if __name__ == "__main__":
    18.     dbg = MyDebug()
    19.  
    20.     connect_flag = dbg.connect()
    21.     print("连接状态: {}".format(connect_flag))
    22.  
    23.     # 得到程序加载过的所有模块信息
    24.     module_list = dbg.get_all_module()
    25.  
    26.     # 向下扫描堆栈
    27.     for index in range(0,10):
    28.  
    29.         # 默认返回有符号数
    30.         stack_address = dbg.peek_stack(index)
    31.  
    32.         # 反汇编一行
    33.         dasm = dbg.get_disasm_one_code(stack_address)
    34.  
    35.         # 根据地址得到模块基址
    36.         if stack_address <= 0:
    37.             mod_base = 0
    38.         else:
    39.             mod_base = dbg.get_base_from_address(long_to_ulong(stack_address))
    40.  
    41.         # print("stack => [{}] addr = {:10} base = {:10} dasm = {}"
    42. 		.format(index, hex(long_to_ulong(stack_address)),hex(mod_base), dasm))
    43.         if mod_base > 0:
    44.             for x in module_list:
    45.                 if mod_base == x.get("base"):
    46.                     print("stack => [{}] addr = {:10} base = {:10} dasm = {:15} return = {:10}"
    47.                           .format(index,hex(long_to_ulong(stack_address)),hex(mod_base), dasm,
    48.                                   x.get("name")))
    49.  
    50.     dbg.close()

    第三方反汇编库应用: 通过LyScript插件读取出内存中的机器码，然后交给capstone反汇编库执行，并将结果输出成字典格式。

    1. #coding: utf-8
    2. import binascii,os,sys
    3. import pefile
    4. from capstone import *
    5. from LyScript32 import MyDebug
    6.  
    7. # 得到内存反汇编代码
    8. def get_memory_disassembly(address,offset,len):
    9.     # 反汇编列表
    10.     dasm_memory_dict = []
    11.  
    12.     # 内存列表
    13.     ref_memory_list = bytearray()
    14.  
    15.     # 读取数据
    16.     for index in range(offset,len):
    17.         char = dbg.read_memory_byte(address + index)
    18.         ref_memory_list.append(char)
    19.  
    20.     # 执行反汇编
    21.     md = Cs(CS_ARCH_X86,CS_MODE_32)
    22.     for item in md.disasm(ref_memory_list,0x1):
    23.         addr = int(pe_base) + item.address
    24.         dasm_memory_dict.append({"address": str(addr), "opcode": item.mnemonic + " " + item.op_str})
    25.     return dasm_memory_dict
    26.  
    27. if __name__ == "__main__":
    28.     dbg = MyDebug()
    29.     dbg.connect()
    30.  
    31.     pe_base = dbg.get_local_base()
    32.     pe_size = dbg.get_local_size()
    33.  
    34.     print("模块基地址: {}".format(hex(pe_base)))
    35.     print("模块大小: {}".format(hex(pe_size)))
    36.  
    37.     # 得到内存反汇编代码
    38.     dasm_memory_list = get_memory_disassembly(pe_base,0,pe_size)
    39.     print(dasm_memory_list)
    40.  
    41.     dbg.close()

    如果我们将磁盘文件也反汇编到一个列表内，然后对比两者就实现了一个简易版应用层钩子扫描器。

    1. #coding: utf-8
    2. import binascii,os,sys
    3. import pefile
    4. from capstone import *
    5. from LyScript32 import MyDebug
    6.  
    7. # 得到内存反汇编代码
    8. def get_memory_disassembly(address,offset,len):
    9.     # 反汇编列表
    10.     dasm_memory_dict = []
    11.  
    12.     # 内存列表
    13.     ref_memory_list = bytearray()
    14.  
    15.     # 读取数据
    16.     for index in range(offset,len):
    17.         char = dbg.read_memory_byte(address + index)
    18.         ref_memory_list.append(char)
    19.  
    20.     # 执行反汇编
    21.     md = Cs(CS_ARCH_X86,CS_MODE_32)
    22.     for item in md.disasm(ref_memory_list,0x1):
    23.         addr = int(pe_base) + item.address
    24.         dic = {"address": str(addr), "opcode": item.mnemonic + " " + item.op_str}
    25.         dasm_memory_dict.append(dic)
    26.     return dasm_memory_dict
    27.  
    28. # 反汇编文件中的机器码
    29. def get_file_disassembly(path):
    30.     opcode_list = []
    31.     pe = pefile.PE(path)
    32.     ImageBase = pe.OPTIONAL_HEADER.ImageBase
    33.  
    34.     for item in pe.sections:
    35.         if str(item.Name.decode('UTF-8').strip(b'\x00'.decode())) == ".text":
    36.             # print("虚拟地址: 0x%.8X 虚拟大小: 0x%.8X" %(item.VirtualAddress,item.Misc_VirtualSize))
    37.             VirtualAddress = item.VirtualAddress
    38.             VirtualSize = item.Misc_VirtualSize
    39.             ActualOffset = item.PointerToRawData
    40.     StartVA = ImageBase + VirtualAddress
    41.     StopVA = ImageBase + VirtualAddress + VirtualSize
    42.     with open(path,"rb") as fp:
    43.         fp.seek(ActualOffset)
    44.         HexCode = fp.read(VirtualSize)
    45.  
    46.     md = Cs(CS_ARCH_X86, CS_MODE_32)
    47.     for item in md.disasm(HexCode, 0):
    48.         addr = hex(int(StartVA) + item.address)
    49.         dic = {"address": str(addr) , "opcode": item.mnemonic + " " + item.op_str}
    50.         # print("{}".format(dic))
    51.         opcode_list.append(dic)
    52.     return opcode_list
    53.  
    54. if __name__ == "__main__":
    55.     dbg = MyDebug()
    56.     dbg.connect()
    57.  
    58.     pe_base = dbg.get_local_base()
    59.     pe_size = dbg.get_local_size()
    60.  
    61.     print("模块基地址: {}".format(hex(pe_base)))
    62.     print("模块大小: {}".format(hex(pe_size)))
    63.  
    64.     # 得到内存反汇编代码
    65.     dasm_memory_list = get_memory_disassembly(pe_base,0,pe_size)
    66.     dasm_file_list = get_file_disassembly("d://win32project1.exe")
    67.  
    68.     # 循环对比内存与文件中的机器码
    69.     for index in range(0,len(dasm_file_list)):
    70.         if dasm_memory_list[index] != dasm_file_list[index]:
    71.             print("地址: {:8} --> 内存反汇编: {:32} --> 磁盘反汇编: {:32}".
    72.                   format(dasm_memory_list[index].get("address"),
    73. 		  	dasm_memory_list[index].get("opcode"),dasm_file_list[index].get("opcode")))
    74.     dbg.close()
  • 相关阅读:
    Uniapp 酷炫钱包页面模板 直接引用
    Golang 串口通信
    【计算机网络】初识网络
    AtCoder Beginner Contest 233 (A-Ex)
    Python入门教程之基本语法详解，收藏慢慢学~
    Struct模块到底有多实用？一个知识点立马学习
    【神经网络】【VggNet】
    《计算机工程》期刊投稿记录（实时更新）
    SQL题目记录
    死锁详解
  • 原文地址：https://blog.csdn.net/lyshark_csdn/article/details/126335639