x64dbg 远程调试插件API手册

简体中文 | 繁體中文(中國) | ENGLISH | русский язык 

一款 x64dbg 自动化控制插件，通过Python控制x64dbg的行为，实现远程动态调试，解决了逆向工作者分析程序，反病毒人员脱壳，漏洞分析者寻找指令片段，原生脚本不够强大的问题，通过与Python相结合利用Python语法的灵活性以及其丰富的第三方库，加速漏洞利用程序的开发，辅助漏洞挖掘以及恶意软件分析。

Python 包请安装与插件一致的版本，在cmd命令行下执行pip命令即可安装，推荐两个包全部安装。

• 安装标准包：

  pip install LyScript32

  或者

  pip install LyScript64

• 安装扩展包：

  pip install LyScriptTools32

  或者

  pip install LyScriptTools64

其次您需要手动下载对应

x64dbg

版本的驱动文件，并放入指定的

plugins

目录下。

• 调试器下载：snapshot_2022-09-11_15-59.zip
• 插件下载：LyScript32-1.0.13 (32位插件) 或者 LyScript64-1.0.13 (64位插件)

插件下载好以后，请将该插件复制到x64dbg的plugins目录下，程序运行后会自动加载插件。

当插件加载成功后，会在日志位置看到具体的绑定信息以及输出调试，该插件并不会在插件栏显示。

如果需要远程调试，则只需要在初始化

MyDebug()

类时传入对端IP地址即可，如果不填写参数则默认使用

127.0.0.1

地址，请确保对端放行了

6589

端口，否则无法连接。

运行x64dbg程序并手动载入需要分析的可执行文件，然后我们可以通过

connect()

方法连接到调试器，连接后会创建一个持久会话直到python脚本结束则连接会被强制断开，在此期间可调用

is_connect()

检查该链接是否还存在，具体代码如下所示。

from LyScript32 import MyDebug

if __name__ == "__main__":
    # 初始化
    dbg = MyDebug()

    # 连接到调试器
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    # 检测套接字是否还在
    ref = dbg.is_connect()
    print("是否在连接: ", ref)

    dbg.close()
           

寄存器系列函数

get_register() 函数: 该函数主要用于实现，对特定寄存器的获取操作，用户需传入需要获取的寄存器名字即可。

• 参数1：传入寄存器字符串

可用范围："DR0", "DR1", "DR2", "DR3", "DR6", "DR7", "EAX", "AX", "AH", "AL", "EBX", "BX", "BH", "BL", "ECX", "CX", "CH", "CL", "EDX", "DX", "DH", "DL", "EDI", "DI","ESI", "SI", "EBP", "BP", "ESP", "SP", "EIP", "CIP", "CSP", "CAX", "CBX", "CCX", "CDX", "CDI", "CSI", "CBP", "CFLAGS"

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eax = dbg.get_register("eax")
    ebx = dbg.get_register("ebx")

    print("eax = {}".format(hex(eax)))
    print("ebx = {}".format(hex(ebx)))

    dbg.close()
           

如果您使用的是64位插件，则寄存器的支持范围将变为E系列加R系列。

可用范围扩展： "DR0", "DR1", "DR2", "DR3", "DR6", "DR7", "EAX", "AX", "AH", "AL", "EBX", "BX", "BH", "BL", "ECX", "CX", "CH", "CL", "EDX", "DX", "DH", "DL", "EDI", "DI", "ESI", "SI", "EBP", "BP", "ESP", "SP", "EIP", "RAX", "RBX", "RCX", "RDX", "RSI", "SIL", "RDI", "DIL", "RBP", "BPL", "RSP", "SPL", "RIP", "R8", "R8D", "R8W", "R8B", "R9", "R9D", "R9W", "R9B", "R10", "R10D", "R10W", "R10B", "R11", "R11D", "R11W", "R11B", "R12", "R12D", "R12W", "R12B", "R13", "R13D", "R13W", "R13B", "R14", "R14D", "R14W", "R14B", "R15", "R15D", "R15W", "R15B"

from LyScript64 import MyDebug

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

    rax = dbg.get_register("rax")
    eax = dbg.get_register("eax")
    ax = dbg.get_register("ax")

    print("rax = {} eax = {} ax ={}".format(hex(rax),hex(eax),hex(ax)))

    r8 = dbg.get_register("r8")
    print("获取R系列寄存器: {}".format(hex(r8)))

    dbg.close()
           

set_register() 函数: 该函数实现设置指定寄存器参数，同理64位将支持更多寄存器的参数修改。

• 参数1：传入寄存器字符串
• 参数2：十进制数值

可用范围："DR0", "DR1", "DR2", "DR3", "DR6", "DR7", "EAX", "AX", "AH", "AL", "EBX", "BX", "BH", "BL", "ECX", "CX", "CH", "CL", "EDX", "DX", "DH", "DL", "EDI", "DI", "ESI", "SI", "EBP", "BP", "ESP", "SP", "EIP"

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eax = dbg.get_register("eax")
    
    dbg.set_register("eax",100)

    print("eax = {}".format(hex(eax)))

    dbg.close()
           

get_flag_register() 函数: 用于获取某个标志位参数，返回值只有真或者假。

• 参数1：寄存器字符串

可用寄存器范围："ZF", "OF", "CF", "PF", "SF", "TF", "AF", "DF", "IF"

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    cf = dbg.get_flag_register("cf")
    print("标志: {}".format(cf))
    
    dbg.close()
           

set_flag_register() 函数: 用于设置某个标志位参数，返回值只有真或者假。

• 参数1：寄存器字符串
• 参数2：[ 设置为真 True] / [设置为假 False]

可用寄存器范围："ZF", "OF", "CF", "PF", "SF", "TF", "AF", "DF", "IF"

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    zf = dbg.get_flag_register("zf")
    print(zf)

    dbg.set_flag_register("zf",False)

    zf = dbg.get_flag_register("zf")
    print(zf)

    dbg.close()
           

调试系列函数

set_debug() 函数: 用于影响调试器，例如前进一次，后退一次，暂停调试，终止等。

• 参数1: 传入需要执行的动作

可用动作范围：[暂停 Pause] [运行 Run] [步入 StepIn] [步过 StepOut] [到结束 StepOver] [停止 Stop] [等待 Wait]

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    while True:
        dbg.set_debug("StepIn")
        
        eax = dbg.get_register("eax")
        
        if eax == 0:
            print("找到了")
            break
        
    dbg.close()
           

set_debug_count() 函数: 该函数是

set_debug()

函数的延续，目的是执行自动步过次数。

• 参数1：传入需要执行的动作
• 参数2：执行重复次数

可用动作范围：[暂停 Pause] [运行 Run] [步入 StepIn] [步过 StepOut] [到结束 StepOver] [停止 Stop] [等待 Wait]

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    dbg.set_debug_count("StepIn",10)

    dbg.close()
           

is_debugger() /is_running()/is_run_locked() 函数: 函数

is_debugger

可用于验证当前调试器是否处于调试状态，

is_running

则用于验证是否在运行，

is_run_locked()

用于检查调试器是否被锁定(暂停)。

• 无参数传递

from LyScript32 import MyDebug

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

    ref = dbg.is_debugger()
    print(ref)

    ref = dbg.is_running()
    print(ref)

    ref = dbg.is_run_locked()
    print(ref)

    dbg.close()
           

set_breakpoint() 函数: 设置断点与取消断点进行了分离，设置断点只需要传入十进制内存地址。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    ref = dbg.set_breakpoint(eip)

    print("设置状态: {}".format(ref))
    dbg.close()
           

delete_breakpoint() 函数: 该函数传入一个内存地址，可取消一个内存断点。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    ref = dbg.set_breakpoint(eip)
    print("设置状态: {}".format(ref))

    del_ref = dbg.delete_breakpoint(eip)
    print("取消状态: {}".format(del_ref))

    dbg.close()
           

check_breakpoint() 函数: 用于检查下过的断点是否被命中，命中返回True否则返回False。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    ref = dbg.set_breakpoint(eip)
    print("设置状态: {}".format(ref))

    is_check = dbg.check_breakpoint(4134331)
    print("是否命中: {}".format(is_check))

    dbg.close()
           

get_all_breakpoint() 函数: 用于获取当前调试程序中，所有下过的断点信息，包括是否开启，命中次数等。

• 无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    ref = dbg.get_all_breakpoint()
    print(ref)
    dbg.close()
           

set_hardware_breakpoint() 函数: 用于设置一个硬件断点，硬件断点在32位系统中最多设置4个。

• 参数1：内存地址（十进制）
• 参数2：断点类型

断点类型可用范围：[类型 0 = HardwareAccess / 1 = HardwareWrite / 2 = HardwareExecute]

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug(address="127.0.0.1",port=6666)
    connect_flag = dbg.connect()

    eip = dbg.get_register("eip")

    ref = dbg.set_hardware_breakpoint(eip,2)
    print(ref)

    dbg.close()
           

delete_hardware_breakpoint() 函数: 用于删除一个硬件断点，只需要传入地址即可，无需传入类型。

• 参数1：内存地址（十进制）

断点类型可用范围：[类型 0 = HardwareAccess / 1 = HardwareWrite / 2 = HardwareExecute]

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug(address="127.0.0.1",port=6666)
    connect_flag = dbg.connect()

    eip = dbg.get_register("eip")

    ref = dbg.set_hardware_breakpoint(eip,2)
    print(ref)

    # 删除断点
    ref = dbg.delete_hardware_breakpoint(eip)
    print(ref)

    dbg.close()
           

is_bp_disable() 函数: 该函数用于验证指定地址处BP断点是否被禁用。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    is_false = dbg.is_bp_disable(eip)
    print("bp断点状态: {}".format(is_false))

    dbg.close()
           

get_xref_count_at() 函数: 获取指定内存地址位置处交叉引用计数。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    types = dbg.get_xref_count_at(eip)
    print("引用计数: {}".format(types))

    dbg.close()
           

get_function_type_at() 函数: 获取指定内存地址位置处函数类型，函数

FUNCTYPE

枚举类型。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    types = dbg.get_function_type_at(eip)
    print("函数类型: {}".format(types))

    if(types == 0):
        print("FUNC_NONE")
    elif(types == 1):
        print("FUNC_BEGIN")
    elif(types == 2):
        print("FUNC_MIDDLE")
    elif(types == 3):
        print("FUNC_END")
    elif(types == 4):
        print("FUNC_SINGLE")
    else:
        print("error")

    dbg.close()
           

get_bpx_type_at() 函数: 获取指定地址处BP断点类型，类型

BPXTYPE

枚举。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    types = dbg.get_bpx_type_at(eip)
    print("BPX类型: {}".format(types))

    if(types == 0):
        print("bp_none")
    elif(types == 1):
        print("bp_normal")
    elif(types == 2):
        print("bp_hardware")
    elif(types == 4):
        print("bp_memory")
    elif(types == 8):
        print("bp_dll")
    elif(types == 16):
        print("bp_exception")
    else:
        print("error")

    dbg.close()
           

get_xref_type_at() 函数: 得到指定内存地址位置处交叉引用类型，枚举

XREFTYPE

类型。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    types = dbg.get_xref_type_at(eip)
    print("引用类型: {}".format(types))

    if(types == 0):
        print("XREF_NONE")
    elif(types == 1):
        print("XREF_DATA")
    elif(types == 2):
        print("XREF_JMP")
    elif(types == 3):
        print("XREF_CALL")
    else:
        print("error")

    dbg.close()
           

模块系列函数

get_module_base() 函数: 该函数可用于获取程序载入的指定一个模块的基地址。

• 参数1：模块名字符串

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    
    user32_base = dbg.get_module_base("user32.dll")
    print(user32_base)

    dbg.close()
           

get_all_module() 函数: 用于输出当前加载程序的所有模块信息，以字典的形式返回。

• 参数：无参数

from LyScript32 import MyDebug

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

    ref = dbg.get_all_module()

    for i in ref:
        print(i)

    print(ref[0])
    print(ref[1].get("name"))
    print(ref[1].get("path"))

    dbg.close()
           

get_local_() 系列函数: 获取当前EIP所在模块基地址，长度，以及内存属性，此功能无参数传递，获取的是当前EIP所指向模块的数据。

• dbg.get_local_base() 获取模块基地址
• dbg.get_local_size() 获取模块长度
• dbg.get_local_protect() 获取模块保护属性

from LyScript32 import MyDebug

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

    ref = dbg.get_local_base()
    print(hex(ref))

    ref2 = dbg.get_local_size()
    print(hex(ref2))

    ref3 = dbg.get_local_protect()
    print(ref3)

    dbg.close()
           

get_module_from_function() 函数: 获取指定模块中指定函数的内存地址，可用于验证当前程序在内存中指定函数的虚拟地址。

• 参数1：模块名
• 参数2：函数名

成功返回地址，失败返回false

from LyScript32 import MyDebug

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

    ref = dbg.get_module_from_function("user32.dll","MessageBoxW")
    print(hex(ref))

    ref2 = dbg.get_module_from_function("kernel32.dll","test")
    print(ref2)

    dbg.close()
           

get_module_from_import() 函数: 获取当前程序中指定模块的导入表信息，输出为列表嵌套字典。

• 参数1：传入模块名称

from LyScript32 import MyDebug

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

    ref = dbg.get_module_from_import("ucrtbase.dll")
    print(ref)

    ref1 = dbg.get_module_from_import("win32project1.exe")

    for i in ref1:
        print(i.get("name"))

    dbg.close()
           

get_module_from_export() 函数: 该函数用于获取当前加载程序中的导出表信息。

• 参数1：传入模块名

from LyScript32 import MyDebug

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

    ref = dbg.get_module_from_export("msvcr120d.dll")

    for i in ref:
        print(i.get("name"), hex(i.get("va")))

    dbg.close()
           

get_section() 函数: 该函数用于输出主程序中的节表信息。

• 无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
   dbg = MyDebug(address="127.0.0.1",port=6666)
   connect_flag = dbg.connect()

   ref = dbg.get_section()
   print(ref)

   dbg.close()
           

get_base_from_address() 函数: 根据传入的内存地址得到该模块首地址。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    ref = dbg.get_base_from_address(eip)
    print("模块首地址: {}".format(hex(ref)))
           

get_base_from_name() 函数: 根据传入的模块名得到该模块所在内存首地址。

• 参数1：传入模块名

from LyScript32 import MyDebug

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

    ref_base = dbg.get_base_from_name("win32project.exe")
    print("模块首地址: {}".format(hex(ref_base)))

    dbg.close()
           

get_oep_from_name() 函数: 根据传入的模块名，获取该模块实际装载OEP位置。

• 参数1：传入模块名

from LyScript32 import MyDebug

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

    oep = dbg.get_oep_from_name("win32project.exe")
    print(hex(oep))

    dbg.close()
           

get_oep_from_address() 函数: 根据传入内存地址，得到该地址模块的OEP位置。

• 参数1：传入内存地址

from LyScript32 import MyDebug

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

    oep = dbg.get_oep_from_address(eip)
    print(hex(oep))

    dbg.close()
           

get_section_from_module_name() 函数: 用户可传入当前载入的模块名，即可直接取出指定模块的节表信息。

• 参数1：模块名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    section_user32 = dbg.get_section_from_module_name("user32.dll")
    print(section_user32)

    section_ntdll = dbg.get_section_from_module_name("ntdll.dll")
    print(section_ntdll)

    dbg.close()
           

size_from_address() 函数: 传入一个模块的基地址得到该模块占用总大小。

• 参数1：模块地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    base = dbg.get_local_base()
    print("模块基地址: {}".format(hex(base)))

    size = dbg.size_from_address(base)
    print("模块长度: {}".format(size))

    dbg.close()
           

size_from_name() 函数: 传入模块名称得到模块占用总大小。

• 参数1：模块名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    size = dbg.size_from_name("win32.exe")
    print("长度: {}".format(size))

    dbg.close()
           

section_count_from_name() 函数: 传入模块名称得到模块有多少个节区。

• 参数1：模块名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    size = dbg.section_count_from_name("win32.exe")
    print("节区个数: {}".format(size))

    dbg.close()
           

section_count_from_address() 函数: 传入模块基址得到模块有多少个节区。

• 参数1：模块地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    base = dbg.get_local_base()
    print("模块基地址: {}".format(hex(base)))

    size = dbg.section_count_from_address(base)
    print("节个数: {}".format(size))

    dbg.close()
           

path_from_name() 函数: 传入模块名称得到模块路径。

• 参数1：模块名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    size = dbg.path_from_name("win32.exe")
    print("模块路径: {}".format(size))

    dbg.close()
           

path_from_address() 函数: 传入模块地址得到模块路径。

• 参数1：模块地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    base = dbg.get_local_base()
    print("模块基地址: {}".format(hex(base)))

    path = dbg.path_from_address(base)
    print("模块路径: {}".format(path))

    dbg.close()
           

name_from_address() 函数: 传入模块地址得到模块名称。

• 参数1：模块地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    base = dbg.get_local_base()
    print("模块基地址: {}".format(hex(base)))

    path = dbg.name_from_address(base)
    print("模块名: {}".format(path))

    dbg.close()
           

get_window_handle() 函数: 取出自身进程模块句柄。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    base = dbg.get_window_handle()
    print("进程句柄: {}".format(base))

    dbg.close()
           

get_module_at() 函数: 获取指定内存地址处模块名，此处得到的模块名无后缀。

• 参数1：模块地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    ref = dbg.get_module_at(eip)
    print("模块名: {}".format(ref))

    dbg.close()
           

get_local_module() 函数: 该系列函数可用于得到当前载入程序停留EIP位置的模块详细信息。

• get_local_module_size() 获取当前程序的大小
• get_local_module_section_Count() 获取自身节数量
• get_local_module_path() 获取被调试程序完整路径
• get_local_module_name() 获取自身模块名
• get_local_module_entry() 获取自身模块入口
• get_local_module_base() 获取自身模块基地址

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    print("程序大小: {}".format( dbg.get_local_module_size()))
    print("节个数: {}".format(dbg.get_local_module_section_Count()))
    print("完整路径: {}".format(dbg.get_local_module_path()))
    print("模块名: {}".format(dbg.get_local_module_name()))
    print("模块入口: {}".format(dbg.get_local_module_entry()))
    print("模块基地址: {}".format(dbg.get_local_module_base()))

    dbg.close()
           

内存系列函数

read_memory_() 系列函数: 读内存系列函数，包括 ReadByte,ReadWord,ReadDword 三种格式，在64位下才支持Qword

• 参数1：需要读取的内存地址（十进制）

目前支持：

• read_memory_byte() 读字节
• read_memory_word() 读word
• read_memory_dword() 读dword
• read_memory_qword() 读qword （仅支持64位）
• read_memory_ptr() 读指针

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")

    ref = dbg.read_memory_byte(eip)
    print(hex(ref))

    ref2 = dbg.read_memory_word(eip)
    print(hex(ref2))

    ref3 = dbg.read_memory_dword(eip)
    print(hex(ref3))

    ref4 = dbg.read_memory_ptr(eip)
    print(hex(ref4))

    dbg.close()
           

write_memory_() 系列函数: 写内存系列函数，WriteByte,WriteWord,WriteDWORD,WriteQword

• 参数1：需要写入的内存
• 参数2：需要写入的byte字节

目前支持：

• write_memory_byte() 写字节
• write_memory_word() 写word
• write_memory_dword() 写dword
• write_memory_qword() 写qword （仅支持64位）
• write_memory_ptr() 写指针

from LyScript32 import MyDebug

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

    addr = dbg.create_alloc(1024)
    print(hex(addr))

    ref = dbg.write_memory_byte(addr,10)

    print(ref)

    dbg.close()
           

scan_memory_one() 函数: 实现了内存扫描，当扫描到第一个符合条件的特征时，自动输出。

• 参数1：特征码字段

这个函数需要注意，如果我们的x64dbg工具停在系统领空，则会默认搜索系统领空下的特征，如果想要搜索程序领空里面的数据，需要先将EIP切过去在操作。

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    ref = dbg.scan_memory_one("ff 25")
    print(ref)
    dbg.close()
           

scan_memory_all() 函数: 实现了扫描所有符合条件的特征字段，找到后返回一个列表。

• 参数1：特征码字段

from LyScript32 import MyDebug

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

    ref = dbg.scan_memory_all("ff 25")

    for index in ref:
        print(hex(index))

    dbg.close()
           

scan_memory_any() 函数: 该函数可实现对特定位置，向下扫描特定长度的特征字段。

• 参数1：扫描起始地址（十进制）
• 参数2：扫描长度（十进制）
• 参数3：特征码字段

from LyScript32 import MyDebug

if __name__ == "__main__":
    # 初始化
    dbg = MyDebug()

    # 连接到调试器
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    # 任意地址扫描
    eip = dbg.get_register("eip")
    ref = dbg.scan_memory_any(eip,1024,"8b 50 04 8b fe")
    print("得到扫描结果: {}".format(hex(ref)))

    dbg.close()
           

get_local_protect() 函数: 获取内存属性传值，该函数进行更新，取消了只能得到EIP所指的位置的内存属性，用户可随意检测。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    print(eip)

    ref = dbg.get_local_protect(eip)
    print(ref)
           

set_local_protect() 函数: 新增设置内存属性函数，传入eip内存地址，设置属性32，以及设置内存长度1024即可。

• 参数1：内存地址（十进制）
• 参数2：权限类型（32=执行/读取 30=执行 2=读取/写入）
• 参数3：属性长度（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    
    eip = dbg.get_register("eip")
    print(eip)

    b = dbg.set_local_protect(eip,32,1024)
    print("设置属性状态: {}".format(b))

    dbg.close()
           

get_local_page_size() 函数: 用于获取当前EIP所指领空下，内存pagesize分页大小。

• 无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    size = dbg.get_local_page_size()
    print("pagesize = {}".format(size))

    dbg.close()
           

get_memory_section() 函数: 该函数主要用于获取内存映像中，当前调试程序的内存节表数据。

• 无参数传递

from LyScript32 import MyDebug

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

    ref = dbg.get_memory_section()
    print(ref)
    dbg.close()
           

is_jmp_going_to_execute() 函数: 判断内存地址是否跳转到可执行内存块。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    flag = dbg.is_jmp_going_to_execute(eip)
    print("是否是跳转(是否可执行): {}".format(flag))

    dbg.close()
           

mem_find_base_addr() 函数: 返回特定位置处内存模块基地址和大小，以字典形式返回。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    dic = dbg.mem_find_base_addr(eip)

    print("内存基地址: {}".format(hex(dic.get("base"))))
    print("内存大小: {}".format(dic.get("size")))

    dbg.close()
           

mem_get_page_size() 函数: 得到指定位置处内存页面长度。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    addr = dbg.mem_get_page_size(eip)

    print("内存页面长度: {}".format(hex(addr)))

    dbg.close()
           

mem_is_valid() 函数: 验证指定位置处内存地址是否可读取。

• 参数1：内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    is_read = dbg.mem_is_valid(eip)
    print("内存地址属性: {}".format(is_read))

    dbg.close()
           

堆栈系列函数

create_alloc() 函数： 函数

create_alloc()

可在远程开辟一段堆空间，成功返回内存首地址。

• 参数1：开辟的堆长度（十进制）

from LyScript32 import MyDebug

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

    ref = dbg.create_alloc(1024)
    print("开辟地址: ", hex(ref))

    dbg.close()
           

delete_alloc() 函数： 函数

delete_alloc()

用于注销一个远程堆空间。

• 参数1：传入需要删除的堆空间内存地址。

from LyScript32 import MyDebug

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

    ref = dbg.create_alloc(1024)
    print("开辟地址: ", hex(ref))

    flag = dbg.delete_alloc(ref)
    print("删除状态: ",flag)

    dbg.close()
           

push_stack() 函数: 将一个十进制数压入堆栈中，默认在堆栈栈顶。

• 参数1：十进制数据

from LyScript32 import MyDebug

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

    ref = dbg.push_stack(10)

    print(ref)

    dbg.close()
           

pop_stack() 函数: pop函数用于从堆栈中推出一个元素，默认从栈顶弹出。

• 无参数传递

from LyScript32 import MyDebug

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

    tt = dbg.pop_stack()
    print(tt)

    dbg.close()
           

peek_stack() 函数: peek则用于检查堆栈内的参数，可设置偏移值，不设置则默认检查第一个也就是栈顶。

• 参数1：十进制偏移

from LyScript32 import MyDebug

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

    # 无参数检查
    check = dbg.peek_stack()
    print(check)

    # 携带参数检查
    check_1 = dbg.peek_stack(2)
    print(check_1)

    dbg.close()
           

进程线程系列函数

get_thread_list() 函数: 该函数可输出当前进程所有在运行的线程信息。

• 无参数传递

from LyScript32 import MyDebug

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

    ref = dbg.get_thread_list()
    print(ref[0])
    print(ref[1])

    dbg.close()
           

get_process_handle() 函数: 用于获取当前进程句柄信息。

• 无参数传递

from LyScript32 import MyDebug

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

    ref = dbg.get_process_handle()
    print(ref)

    dbg.close()
           

get_process_id() 函数: 用于获取当前加载程序的PID

• 无参数传递

from LyScript32 import MyDebug

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

    ref = dbg.get_process_id()
    print(ref)

    dbg.close()
           

get_teb_address() / get_peb_address() 系列函数: 用于获取当前进程环境块，和线程环境快。

• get_teb_address() 传入参数是线程ID
• get_peb_address() 传入参数是进程ID

from LyScript32 import MyDebug

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

    ref = dbg.get_teb_address(6128)
    print(ref)

    ref = dbg.get_peb_address(9012)
    print(ref)

    dbg.close()
           

反汇编系列函数

get_disasm_code() 函数: 该函数主要用于对特定内存地址进行反汇编，传入两个参数。

• 参数1：需要反汇编的地址(十进制)
• 参数2：需要向下反汇编的长度

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    # 得到EIP位置
    eip = dbg.get_register("eip")

    # 反汇编前100行
    disasm_dict = dbg.get_disasm_code(eip,100)

    for ds in disasm_dict:
        print("地址: {} 反汇编: {}".format(hex(ds.get("addr")),ds.get("opcode")))

    dbg.close()
           

get_disasm_one_code() 函数: 在用户指定的位置读入一条汇编指令，用户可根据需要对其进行判断。

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    print("EIP = {}".format(eip))

    disasm = dbg.get_disasm_one_code(eip)
    print("反汇编一条: {}".format(disasm))

    dbg.close()
           

get_disasm_operand_code() 函数: 用于获取汇编指令中的操作数，例如

jmp 0x0401000

其操作数就是

0x0401000

。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    print("EIP = {}".format(eip))

    opcode = dbg.get_disasm_operand_code(eip)
    print("操作数: {}".format(hex(opcode)))

    dbg.close()
           

get_disasm_operand_size() 函数: 用于得当前内存地址下汇编代码的机器码长度。

• 参数1：传入内存地址（十进制）

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    print("EIP = {}".format(eip))

    opcode = dbg.get_disasm_operand_size(eip)

    print("机器码长度: {}".format(hex(opcode)))

    dbg.close()
           

assemble_write_memory() 函数: 实现了用户传入一段正确的汇编指令，程序自动将该指令转为机器码，并写入到指定位置。

• 参数1：写出内存地址（十进制）
• 参数2：写出汇编指令

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    print(eip)

    ref = dbg.assemble_write_memory(eip,"mov eax,1")
    print("是否写出: {}".format(ref))

    dbg.close()
           

assemble_code_size() 函数: 该函数实现了用户传入一个汇编指令，自动计算出该指令占多少个字节。

• 参数1：汇编指令字符串

from LyScript32 import MyDebug

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

    ref = dbg.assemble_code_size("sub esp, 0x324")
    print(ref)

    dbg.close()
           

get_branch_destination() 函数: 获取call或者是jx跳转指令的跳转地址。

• 参数1：获取内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    print("当前EIP地址: {}".format(hex(eip)))

    value = dbg.get_branch_destination(eip)
    print("操作数: {}".format(hex(value)))

    dbg.close()
           

get_disassembly() 函数: 反汇编一条指令，此函数直接输出调试其中看到的，包括符号。

• 参数1：获取内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    print("当前EIP地址: {}".format(hex(eip)))

    dasm = dbg.get_disassembly(eip)
    print("反汇编一条: {}".format(dasm))

    dbg.close()
           

assemble_at() 函数: 汇编系列函数，传入一条汇编指令，直接将指令写出到内存。

• 参数1：获取内存地址（十进制）
• 参数2：汇编指令（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    print("当前EIP地址: {}".format(hex(eip)))

    ref = dbg.assemble_at(eip,"nop")
    print("写出状态: {}".format(ref))

    dbg.close()
           

disasm_fast_at() 函数: 该函数同样是反汇编一行并返回字典，但它可以获取到更多有效参数。

• 参数1：获取内存地址（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    print("当前EIP地址: {}".format(hex(eip)))

    dasm = dbg.disasm_fast_at(eip)
    print("地址: {}".format(hex(dasm.get("addr"))))
    print("汇编指令: {}".format(dasm.get("disasm")))
    print("汇编长度: {}".format(dasm.get("size")))
    print("是否分支: {}".format(dasm.get("is_branch")))
    print("是否call: {}".format(dasm.get("is_call")))
    print("类型: {}".format(dasm.get("type")))

    dbg.close()
           

其他系列函数

set_comment_notes() 函数: 给指定位置代码增加一段注释，如下演示在eip位置增加注释。

• 参数1：注释内存地址
• 参数2：注释内容

from LyScript32 import MyDebug

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

    eip = dbg.get_register("eip")
    ref = dbg.set_comment_notes(eip,"hello lyshark")
    print(ref)

    dbg.close()
           

run_command_exec() 函数: 执行内置命令，例如bp,dump等。

• 参数1：命令语句

from LyScript32 import MyDebug

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

    ref = dbg.run_command_exec("bp MessageBoxA")
    print(ref)

    dbg.close()
           

set_loger_output() 函数: 日志的输出尤为重要，该模块提供了自定义日志输出功能，可将指定日志输出到x64dbg日志位置。

• 参数1：日志内容

from LyScript32 import MyDebug

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

    for i in range(0,100):
        ref = dbg.set_loger_output("hello lyshark -> {} \n".format(i))
        print(ref)

    dbg.close()
           

run_command_exe_ref() 函数: 该函数是

run_command_exec()

的延申，其主要增加了传出参数的功能，目前可传出整数类型。

• 参数1：命令语句

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    ref = dbg.run_command_exe_ref("mod.base(eip)")
    print("返回参数: {}".format(hex(ref)))

    dbg.close()
           

set_status_bar_message() 函数: 该函数可实现在x64dbg底部状态栏上面输出一个用户传入的字符串。

• 参数1：输出字符串

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    dbg.set_status_bar_message("EIP => {}".format(hex(eip)))

    dbg.close()
           

script_loader() 函数: 该函数接收用户传入的内置脚本所在路径，并将该脚本加载到x64dbg中。

• 参数1：脚本路径

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.script_loader("d://x64dbg_script.txt")
    print("返回值: {}".format(flag))

    dbg.close()
           

script_unloader() 函数: 该函数用于关闭x64dbg中打开的脚本。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.script_loader("d://x64dbg_script.txt")
    print("返回值: {}".format(flag))
    
    dbg.script_unloader()

    dbg.close()
           

script_run() 函数: 该函数用于运行一个已经载入到x64dbg中的脚本。

• 参数1：运行条数(可空)

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.script_loader("d://x64dbg_script.txt")
    print("返回值: {}".format(flag))

    dbg.script_run()

    dbg.close()
           

script_set_ip() 函数: 该函数用于指定从第几行开始运行脚本。

• 参数1：运行下标

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.script_loader("d://x64dbg_script.txt")
    print("返回值: {}".format(flag))

    dbg.script_set_ip(3)

    dbg.close()
           

open_debug() 函数: 该函数用于打开磁盘中的一个被调试程序。

• 参数1：被打开程序完整路径

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.open_debug("d://win32.exe")

    dbg.close()
           

close_debug() 函数: 该函数用于关闭当前打开的调试程序，之关闭程序不关闭调试器。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.open_debug("d://win32.exe")
    
    if flag == True:
        dbg.close_debug()
    
    dbg.close()
           

detach_debug() 函数: 该函数用于让调试器脱离进程，进程会被运行起来。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    flag = dbg.open_debug("d://win32.exe")

    if flag == True:
        dbg.detach_debug()

    dbg.close()
           

message_box() 函数: 此功能提供了三种对话框，一种可输入文本，一种判断是否选中，另一种则是普通弹窗。

• 参数1：弹出的提示信息

from LyScript32 import MyDebug

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

    # 弹出输入框
    flag = dbg.input_string_box("请输入反汇编入口地址?")
    print("用户的输入: {}".format(flag))

    # 弹出是否框
    flag = dbg.message_box_yes_no("是否继续执行脱壳操作?")
    if flag == True:
        print("脱壳")
    else:
        print("退出")

    # 提示框
    flag = dbg.message_box("这是第 {} 次,异常了".format(1))
    print("状态: {}".format(flag))

    dbg.close()
           

set_argument_brackets() 函数: 该函数可在

注释

处增加括号。

• 参数1：开始位置（十进制）
• 参数2：结束位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    ref = dbg.set_argument_brackets(eip, eip +100)
    print("是否增加注释: {}".format(ref))
    
    dbg.close()
           

del_argument_brackets() 函数: 该函数可清除通过

set_argument_brackets

设置的括号。

• 参数1：开始位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    
    dbg.del_argument_brackets(eip)

    dbg.close()
           

set_function_brackets() 函数: 该函数可实现在

机器码

位置增加括号。

• 参数1：开始位置（十进制）
• 参数2：结束位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    flag = dbg.set_function_brackets(eip,eip+10)

    dbg.close()
           

del_function_brackets() 函数: 该函数可清除通过

del_function_brackets

设置的括号。

• 参数1：开始位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    
    dbg.del_function_brackets(eip)

    dbg.close()
           

set_loop_brackets() 函数: 该函数可实现在

反汇编

位置增加括号。

• 参数1：开始位置（十进制）
• 参数2：结束位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    ref = dbg.set_loop_brackets(eip,eip + 10)
    print("设置状态: {}".format(ref))

    dbg.close()
           

del_loop_brackets() 函数: 该函数可清除通过

set_loop_brackets

设置的括号。

• 参数1：清除层级（默认1）
• 参数2：开始位置（十进制）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")

    ref = dbg.del_loop_brackets(1,eip)
    print("清除状态: {}".format(ref))

    dbg.close()
           

set_label_at() 函数: 该函数可在特定位置设置一个标签。

• 参数1：设置标签的地址（十进制）
• 参数2：标签名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    
    dbg.set_label_at(eip,"test1")
    dbg.set_label_at(eip+10,"test2")

    dbg.close()
           

location_label_at() 函数: 该函数可通过已有的标签定位到所在位置，并返回内存地址。

• 参数1：标签名（字符串）

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    eip = dbg.get_register("eip")
    
    lab_addr = dbg.location_label_at("test2")
    print("标签所在内存: {}".format(hex(lab_addr)))

    dbg.close()
           

clear_label() 函数: 该函数用于清除当前程序内所有的标签。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    ref = dbg.clear_label()

    dbg.close()
           

update_all_view() 函数: 刷新试图函数，与切换CPU位置。

• 参数：无参数传递

from LyScript32 import MyDebug

if __name__ == "__main__":
    dbg = MyDebug()
    connect_flag = dbg.connect()
    print("连接状态: {}".format(connect_flag))

    # 刷新试图
    dbg.update_all_view()
    
    # 切换到CPU窗口
    dbg.switch_cpu()
    
    # 清除所有日志
    dbg.clear_log()

    dbg.close()
           

文章作者：

lyshark (王瑞)

文章出处：

https://www.cnblogs.com/LyShark/p/16053906.html

版权声明：

本博客文章与代码均为学习时整理的笔记，文章

[均为原创]

作品，转载请

[添加出处]

，您添加出处是我创作的动力！

转载文章，请遵守

《中华人民共和国著作权法》

相关规定或遵守

《署名CC BY-ND 4.0国际》

禁止演绎规范，合理合规，携带原创出处转载。