BinSentry 1.0.0__tar.gz

binsentry-1.0.0/BinSentry/__init__.py

@@ -0,0 +1,906 @@
+import json
+import socket
+from urllib.parse import urlparse
+from typing import List, Dict, Union, Optional, Callable
+from functools import wraps
+
+def check_server_available(func: Callable) -> Callable:
+    """装饰器：检测服务是否可用，不可用直接返回error json"""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if not self.config.is_server_available():
+            return json.dumps({
+                "status": "error",
+                "message": "Server unavailable"
+            }, ensure_ascii=False)
+        return func(self, *args, **kwargs)
+    return wrapper
+
+def validate_hex_address(address: Union[int, str]) -> Optional[str]:
+    """校验并格式化十六进制地址，返回 0xxxxx 格式字符串，非法返回None"""
+    if isinstance(address, int):
+        return hex(address)
+    addr_str = str(address).strip()
+    if not addr_str:
+        return None
+    if addr_str.startswith(('0x', '0X')):
+        try:
+            int(addr_str, 16)
+            return addr_str
+        except ValueError:
+            return None
+    try:
+        int(addr_str, 10)
+        return addr_str
+    except ValueError:
+        return None
+
+class Config:
+    def __init__(self, address: str = "127.0.0.1", port: int = 6891):
+        self.address = address
+        self.port = port
+        self.server_addr = f"http://{address}:{port}"
+        self.timeout = 5
+
+    def is_server_available(self, timeout: Optional[int] = None) -> bool:
+        """检测端口是否开放"""
+        timeout = timeout or self.timeout
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.settimeout(timeout)
+                result = sock.connect_ex((self.address, self.port))
+                return result == 0
+        except socket.error as e:
+            print(f"WARNING: Server check failed: {str(e)}")
+            return False
+
+class BaseHttpClient:
+    def __init__(self, config: Optional[Config] = None):
+        self.config = config or Config()
+        parsed_url = urlparse(self.config.server_addr)
+        self.address = parsed_url.hostname
+        self.port = parsed_url.port
+        self.scheme = parsed_url.scheme
+        self.path = parsed_url.path or '/'
+        self.verify_ssl = True
+
+    def custom_post(self, payload: Optional[Dict] = None, timeout: Optional[int] = None) -> str:
+        """发送POST请求，payload对应BinSentry接口 {interface, params}"""
+        import http.client
+        headers = {"Content-Type": "application/json"}
+        body = json.dumps(payload).encode("utf-8") if payload else None
+        timeout = timeout or self.config.timeout
+        try:
+            if self.scheme == "https":
+                import ssl
+                context = ssl._create_unverified_context() if not self.verify_ssl else None
+                conn = http.client.HTTPSConnection(self.address, self.port, timeout=timeout, context=context)
+            else:
+                conn = http.client.HTTPConnection(self.address, self.port, timeout=timeout)
+            conn.request("POST", self.path, body=body, headers=headers)
+            response = conn.getresponse()
+            response_text = response.read().decode("utf-8", errors="ignore")
+            conn.close()
+            return response_text
+        except socket.timeout:
+            return json.dumps({"status": "error", "message": "Request timed out"}, ensure_ascii=False)
+        except ConnectionRefusedError:
+            return json.dumps({"status": "error", "message": "Connection refused by server"}, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"status": "error", "message": f"Request failed: {str(e)}"}, ensure_ascii=False)
+
+class SystemApi(BaseHttpClient):
+    """系统与进程相关接口"""
+    @check_server_available
+    def system_info(self) -> str:
+        return self.custom_post({"interface": "SystemInfo", "params": {}})
+
+    @check_server_available
+    def process_list(self) -> str:
+        return self.custom_post({"interface": "ProcessList", "params": {}})
+
+    @check_server_available
+    def enum_windows(self, pid: int) -> str:
+        return self.custom_post({"interface": "EnumWindows", "params": {"pid": pid}})
+
+    @check_server_available
+    def is_process_elevated(self) -> str:
+        return self.custom_post({"interface": "IsProcessElevated", "params": {}})
+
+    @check_server_available
+    def enum_error_codes(self) -> str:
+        return self.custom_post({"interface": "EnumErrorCodes", "params": {}})
+
+    @check_server_available
+    def enum_exceptions(self) -> str:
+        return self.custom_post({"interface": "EnumExceptions", "params": {}})
+
+    @check_server_available
+    def help(self) -> str:
+        return self.custom_post({"interface": "Help", "params": {}})
+
+    @check_server_available
+    def get_jit(self) -> str:
+        return self.custom_post({"interface": "GetJIT", "params": {}})
+
+    @check_server_available
+    def set_jit(self, path: str) -> str:
+        return self.custom_post({"interface": "SetJIT", "params": {"path": path}})
+
+    @check_server_available
+    def get_command_line(self) -> str:
+        return self.custom_post({"interface": "GetCommandLine", "params": {}})
+
+    @check_server_available
+    def set_command_line(self, args: str) -> str:
+        return self.custom_post({"interface": "SetCommandLine", "params": {"args": args}})
+
+class LogConfigApi(BaseHttpClient):
+    """日志与配置数据库"""
+    @check_server_available
+    def clear_log(self) -> str:
+        return self.custom_post({"interface": "ClearLog", "params": {}})
+
+    @check_server_available
+    def logs(self) -> str:
+        return self.custom_post({"interface": "Logs", "params": {}})
+
+    @check_server_available
+    def save_log(self, path: str) -> str:
+        return self.custom_post({"interface": "SaveLog", "params": {"path": path}})
+
+    @check_server_available
+    def load_database(self, path: str) -> str:
+        return self.custom_post({"interface": "LoadDatabase", "params": {"path": path}})
+
+    @check_server_available
+    def save_database(self, path: str) -> str:
+        return self.custom_post({"interface": "SaveDatabase", "params": {"path": path}})
+
+    @check_server_available
+    def load_config(self, module: str) -> str:
+        return self.custom_post({"interface": "LoadConfig", "params": {"module": module}})
+
+class SymbolVarApi(BaseHttpClient):
+    """变量、参数、注释、标签、函数"""
+    @check_server_available
+    def set_var(self, name: str, value: str) -> str:
+        return self.custom_post({"interface": "SetVar", "params": {"name": name, "value": value}})
+
+    @check_server_available
+    def del_var(self, name: str) -> str:
+        return self.custom_post({"interface": "DelVar", "params": {"name": name}})
+
+    @check_server_available
+    def get_vars(self) -> str:
+        return self.custom_post({"interface": "GetVars", "params": {}})
+
+    @check_server_available
+    def add_argument(self, start: Union[int, str], end: Union[int, str] = "", name: str = "") -> str:
+        start_addr = validate_hex_address(start)
+        payload: Dict = {"start": start_addr}
+        if end:
+            payload["end"] = validate_hex_address(end)
+        if name:
+            payload["name"] = name
+        return self.custom_post({"interface": "AddArgument", "params": payload})
+
+    @check_server_available
+    def del_argument(self, start: Union[int, str]) -> str:
+        s = validate_hex_address(start)
+        return self.custom_post({"interface": "DelArgument", "params": {"start": s}})
+
+    @check_server_available
+    def get_arguments(self) -> str:
+        return self.custom_post({"interface": "GetArguments", "params": {}})
+
+    @check_server_available
+    def get_comments(self) -> str:
+        return self.custom_post({"interface": "GetComments", "params": {}})
+
+    @check_server_available
+    def get_labels(self) -> str:
+        return self.custom_post({"interface": "GetLabels", "params": {}})
+
+    @check_server_available
+    def get_bookmarks(self) -> str:
+        return self.custom_post({"interface": "GetBookMarks", "params": {}})
+
+    @check_server_available
+    def functions(self) -> str:
+        return self.custom_post({"interface": "Functions", "params": {}})
+
+class BreakPointApi(BaseHttpClient):
+    """断点：软件/硬件/内存/api/异常/dll断点"""
+    @check_server_available
+    def show_breakpoint(self) -> str:
+        return self.custom_post({"interface": "ShowBreakPoint", "params": {}})
+
+    @check_server_available
+    def show_hbreakpoint(self) -> str:
+        return self.custom_post({"interface": "ShowHbreakPoint", "params": {}})
+
+    @check_server_available
+    def show_mem_breakpoint(self) -> str:
+        return self.custom_post({"interface": "ShowMemBreakPoint", "params": {}})
+
+    @check_server_available
+    def show_api_breakpoint(self) -> str:
+        return self.custom_post({"interface": "ShowApiBreakPoint", "params": {}})
+
+    @check_server_available
+    def set_bpx_options(self, option: str, enable: int) -> str:
+        return self.custom_post({"interface": "SetBPXOptions", "params": {"option": option, "enable": enable}})
+
+    @check_server_available
+    def set_exception_bpx(self, code: str) -> str:
+        return self.custom_post({"interface": "SetExceptionBPX", "params": {"code": code}})
+
+    @check_server_available
+    def del_exception_bpx(self, code: str) -> str:
+        return self.custom_post({"interface": "DelExceptionBPX", "params": {"code": code}})
+
+    @check_server_available
+    def get_exception_bpx_list(self) -> str:
+        return self.custom_post({"interface": "GetExceptionBPXList", "params": {}})
+
+    @check_server_available
+    def set_dll_breakpoint(self, dll: str) -> str:
+        return self.custom_post({"interface": "SetDllBreakPoint", "params": {"dll": dll}})
+
+    @check_server_available
+    def del_dll_breakpoint(self, dll: str) -> str:
+        return self.custom_post({"interface": "DelDllBreakPoint", "params": {"dll": dll}})
+
+    @check_server_available
+    def get_dll_breakpoints(self) -> str:
+        return self.custom_post({"interface": "GetDllBreakPoints", "params": {}})
+
+    @check_server_available
+    def set_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakPoint", "params": {"address": addr}})
+
+    @check_server_available
+    def del_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DelBreakPoint", "params": {"address": addr}})
+
+    @check_server_available
+    def get_breakpoint_info(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetBreakpointInfo", "params": {"address": addr}})
+
+    @check_server_available
+    def get_breakpoint_type(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetBreakpointType", "params": {"address": addr}})
+
+    @check_server_available
+    def set_breakpoint_name(self, address: Union[int, str], name: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointName", "params": {"address": addr, "name": name}})
+
+    @check_server_available
+    def set_breakpoint_singleshoot(self, address: Union[int, str], enable: int = 0) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointSingleshoot", "params": {"address": addr, "enable": enable}})
+
+    @check_server_available
+    def set_breakpoint_fast_resume(self, address: Union[int, str], enable: int = 0) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointFastResume", "params": {"address": addr, "enable": enable}})
+
+    @check_server_available
+    def set_breakpoint_silent(self, address: Union[int, str], enable: int = 0) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointSilent", "params": {"address": addr, "enable": enable}})
+
+    @check_server_available
+    def set_breakpoint_log(self, address: Union[int, str], text: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointLog", "params": {"address": addr, "text": text}})
+
+    @check_server_available
+    def set_breakpoint_log_file(self, address: Union[int, str], file: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointLogFile", "params": {"address": addr, "file": file}})
+
+    @check_server_available
+    def set_breakpoint_hit_count(self, address: Union[int, str], count: int) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetBreakpointHitCount", "params": {"address": addr, "count": count}})
+
+    @check_server_available
+    def get_breakpoint_hit_count(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetBreakpointHitCount", "params": {"address": addr}})
+
+    @check_server_available
+    def reset_breakpoint_hit_count(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "ResetBreakpointHitCount", "params": {"address": addr}})
+
+    @check_server_available
+    def set_cond_breakpoint(self, address: Union[int, str], cond: str, thread: int = 0) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetCondBreakPoint", "params": {"address": addr, "cond": cond, "thread": thread}})
+
+    @check_server_available
+    def del_cond_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DelCondBreakPoint", "params": {"address": addr}})
+
+    @check_server_available
+    def set_hbreakpoint(self, address: Union[int, str], len_: str = "1", flag: str = "e") -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetHbreakPoint", "params": {"address": addr, "len": len_, "flag": flag}})
+
+    @check_server_available
+    def del_hbreakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DelHbreakPoint", "params": {"address": addr}})
+
+    @check_server_available
+    def set_mem_breakpoint(self, address: Union[int, str], flag: str = "e") -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetMemBreakPoint", "params": {"address": addr, "flag": flag}})
+
+    @check_server_available
+    def del_mem_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DelMemBreakPoint", "params": {"address": addr}})
+
+    @check_server_available
+    def set_api_breakpoint(self, dll: str, api: str) -> str:
+        return self.custom_post({"interface": "SetApiBreakPoint", "params": {"dll": dll, "api": api}})
+
+    @check_server_available
+    def del_api_breakpoint(self, dll: str, api: str) -> str:
+        return self.custom_post({"interface": "DelApiBreakPoint", "params": {"dll": dll, "api": api}})
+
+    @check_server_available
+    def disable_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DisableBreakpoint", "params": {"address": addr}})
+
+    @check_server_available
+    def enable_breakpoint(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "EnableBreakpoint", "params": {"address": addr}})
+
+    @check_server_available
+    def breakpoint_command(self, address: Union[int, str], command: str = "") -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "BreakpointCommand", "params": {"address": addr, "command": command}})
+
+class DebugSessionApi(BaseHttpClient):
+    """会话管理：启动调试、停止、分离、dump"""
+    @check_server_available
+    def debug(self, path: str, args: str = "", cwd: str = "") -> str:
+        return self.custom_post({"interface": "Debug", "params": {"path": path, "args": args, "cwd": cwd}})
+
+    @check_server_available
+    def set_debug(self, command: str = "Logs") -> str:
+        return self.custom_post({"interface": "SetDebug", "params": command})
+
+    @check_server_available
+    def stop(self) -> str:
+        return self.custom_post({"interface": "Stop", "params": {}})
+
+    @check_server_available
+    def detach(self) -> str:
+        return self.custom_post({"interface": "Detach", "params": {}})
+
+    @check_server_available
+    def restart(self) -> str:
+        return self.custom_post({"interface": "Restart", "params": {}})
+
+    @check_server_available
+    def dump_process(self, path: str, base: Union[int, str], size: int) -> str:
+        base_addr = validate_hex_address(base)
+        return self.custom_post({"interface": "DumpProcess", "params": {"path": path, "base": base_addr, "size": size}})
+
+    @check_server_available
+    def minidump(self, path: str) -> str:
+        return self.custom_post({"interface": "minidump", "params": {"path": path}})
+
+    @check_server_available
+    def status(self) -> str:
+        return self.custom_post({"interface": "Status", "params": {}})
+
+class RegisterThreadApi(BaseHttpClient):
+    """寄存器、线程操作"""
+    @check_server_available
+    def register(self) -> str:
+        return self.custom_post({"interface": "Register", "params": {}})
+
+    @check_server_available
+    def set_register(self, reg: str, value: str) -> str:
+        return self.custom_post({"interface": "SetRegister", "params": {"reg": reg, "value": value}})
+
+    @check_server_available
+    def threads(self) -> str:
+        return self.custom_post({"interface": "Threads", "params": {}})
+
+    @check_server_available
+    def thread_info(self, tid: int) -> str:
+        return self.custom_post({"interface": "ThreadInfo", "params": {"tid": tid}})
+
+    @check_server_available
+    def get_active_thread(self) -> str:
+        return self.custom_post({"interface": "GetActiveThread", "params": {}})
+
+    @check_server_available
+    def set_active_thread(self, tid: int) -> str:
+        return self.custom_post({"interface": "SetActiveThread", "params": {"tid": tid}})
+
+    @check_server_available
+    def get_thread_last_error(self, tid: int) -> str:
+        return self.custom_post({"interface": "GetThreadLastError", "params": {"tid": tid}})
+
+    @check_server_available
+    def get_thread_priority(self, tid: int) -> str:
+        return self.custom_post({"interface": "GetThreadPriority", "params": {"tid": tid}})
+
+    @check_server_available
+    def set_thread_priority(self, tid: int, priority: str = "NORMAL") -> str:
+        return self.custom_post({"interface": "SetThreadPriority", "params": {"tid": tid, "priority": priority}})
+
+    @check_server_available
+    def set_thread_name(self, tid: int, name: str) -> str:
+        return self.custom_post({"interface": "SetThreadName", "params": {"tid": tid, "name": name}})
+
+    @check_server_available
+    def set_flag(self, flag: str, value: int) -> str:
+        return self.custom_post({"interface": "SetFlag", "params": {"flag": flag, "value": value}})
+
+class ModulePeApi(BaseHttpClient):
+    """模块、PE、导入导出、符号"""
+    @check_server_available
+    def modules(self) -> str:
+        return self.custom_post({"interface": "Modules", "params": {}})
+
+    @check_server_available
+    def module_info(self, module: str) -> str:
+        return self.custom_post({"interface": "ModuleInfo", "params": {"module": module}})
+
+    @check_server_available
+    def sections(self, module: str) -> str:
+        return self.custom_post({"interface": "Sections", "params": {"module": module}})
+
+    @check_server_available
+    def pe_info(self, path: str) -> str:
+        return self.custom_post({"interface": "PEInfo", "params": {"path": path}})
+
+    @check_server_available
+    def rich_header(self, module: str) -> str:
+        return self.custom_post({"interface": "RichHeader", "params": {"module": module}})
+
+    @check_server_available
+    def tls_callbacks(self, module: str) -> str:
+        return self.custom_post({"interface": "TLSCallbacks", "params": {"module": module}})
+
+    @check_server_available
+    def relocation_list(self, module: str) -> str:
+        return self.custom_post({"interface": "RelocationList", "params": {"module": module}})
+
+    @check_server_available
+    def debug_directory(self, module: str) -> str:
+        return self.custom_post({"interface": "DebugDirectory", "params": {"module": module}})
+
+    @check_server_available
+    def import_list(self, module: str) -> str:
+        return self.custom_post({"interface": "ImportList", "params": {"module": module}})
+
+    @check_server_available
+    def export_list(self, module: str) -> str:
+        return self.custom_post({"interface": "ExportList", "params": {"module": module}})
+
+    @check_server_available
+    def get_import_address(self, module: str, name: str) -> str:
+        return self.custom_post({"interface": "GetImportAddress", "params": {"module": module, "name": name}})
+
+    @check_server_available
+    def get_export_address(self, module: str, name: str) -> str:
+        return self.custom_post({"interface": "GetExportAddress", "params": {"module": module, "name": name}})
+
+    @check_server_available
+    def gpa(self, dll: str, api: str) -> str:
+        return self.custom_post({"interface": "gpa", "params": {"dll": dll, "api": api}})
+
+    @check_server_available
+    def addr_to_module(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "AddrToModule", "params": {"address": addr}})
+
+    @check_server_available
+    def get_section_data(self, module: str, name: str) -> str:
+        return self.custom_post({"interface": "GetSectionData", "params": {"module": module, "name": name}})
+
+    @check_server_available
+    def get_section_info(self, module: str, name: str) -> str:
+        return self.custom_post({"interface": "GetSectionInfo", "params": {"module": module, "name": name}})
+
+    @check_server_available
+    def symbol(self, expr: str) -> str:
+        return self.custom_post({"interface": "Symbol", "params": {"expr": expr}})
+
+    @check_server_available
+    def get_symbol_info(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetSymbolInfo", "params": {"address": addr}})
+
+    @check_server_available
+    def get_function_size(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetFunctionSize", "params": {"address": addr}})
+
+    @check_server_available
+    def heaps(self) -> str:
+        return self.custom_post({"interface": "Heaps", "params": {}})
+
+    @check_server_available
+    def handles(self, max_num: int = 20) -> str:
+        return self.custom_post({"interface": "Handles", "params": {"max": max_num}})
+
+    @check_server_available
+    def seh_list(self) -> str:
+        return self.custom_post({"interface": "SEHList", "params": {}})
+
+class MemoryApi(BaseHttpClient):
+    """内存读写、搜索、补丁、内存分配"""
+    @check_server_available
+    def memory_info(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "MemoryInfo", "params": {"address": addr}})
+
+    @check_server_available
+    def regions(self) -> str:
+        return self.custom_post({"interface": "Regions", "params": {}})
+
+    @check_server_available
+    def memory(self, address: Union[int, str], size: int = 16) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "Memory", "params": {"address": addr, "size": size}})
+
+    @check_server_available
+    def read_memory_value(self, address: Union[int, str], size: int = 4) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "ReadMemoryValue", "params": {"address": addr, "size": size}})
+
+    @check_server_available
+    def write_memory(self, address: Union[int, str], hex_: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "WriteMemory", "params": {"address": addr, "hex": hex_}})
+
+    @check_server_available
+    def get_page_rights(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetPageRights", "params": {"address": addr}})
+
+    @check_server_available
+    def set_page_rights(self, address: Union[int, str], protect: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetPageRights", "params": {"address": addr, "protect": protect}})
+
+    @check_server_available
+    def set_page_memory(self, address: Union[int, str], protect: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetPageMemory", "params": {"address": addr, "protect": protect}})
+
+    @check_server_available
+    def allocate_memory(self, size: int) -> str:
+        return self.custom_post({"interface": "AllocateMemory", "params": {"size": size}})
+
+    @check_server_available
+    def free_memory(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "FreeMemory", "params": {"address": addr}})
+
+    @check_server_available
+    def set_memory(self, address: Union[int, str], hex_: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SetMemory", "params": {"address": addr, "hex": hex_}})
+
+    @check_server_available
+    def fill_memory(self, address: Union[int, str], size: int, value: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "FillMemory", "params": {"address": addr, "size": size, "value": value}})
+
+    @check_server_available
+    def memcpy(self, src: Union[int, str], dst: Union[int, str], size: int) -> str:
+        src_a = validate_hex_address(src)
+        dst_a = validate_hex_address(dst)
+        return self.custom_post({"interface": "Memcpy", "params": {"src": src_a, "dst": dst_a, "size": size}})
+
+    @check_server_available
+    def va_to_file_offset(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "VaToFileOffset", "params": {"address": addr}})
+
+    @check_server_available
+    def file_offset_to_va(self, offset: str) -> str:
+        return self.custom_post({"interface": "FileOffsetToVa", "params": {"offset": offset}})
+
+    @check_server_available
+    def get_string(self, address: Union[int, str], max_num: int = 64, type_: str = "ascii") -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetString", "params": {"address": addr, "max": max_num, "type": type_}})
+
+    @check_server_available
+    def search_memory(self, pattern: str, start: Union[int, str], size: int) -> str:
+        s = validate_hex_address(start)
+        return self.custom_post({"interface": "SearchMemory", "params": {"pattern": pattern, "start": s, "size": size}})
+
+    @check_server_available
+    def search_all_memory(self, pattern: str, max_num: int = 5) -> str:
+        return self.custom_post({"interface": "SearchAllMemory", "params": {"pattern": pattern, "max": max_num}})
+
+    @check_server_available
+    def search_strings(self, address: Union[int, str], size: int) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "SearchStrings", "params": {"address": addr, "size": size}})
+
+    @check_server_available
+    def match_pattern(self, address: Union[int, str], pattern: str, size: int) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "MatchPattern", "params": {"address": addr, "pattern": pattern, "size": size}})
+
+    @check_server_available
+    def hash_memory(self, address: Union[int, str], size: int, algo: str = "md5") -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "HashMemory", "params": {"address": addr, "size": size, "algo": algo}})
+
+    @check_server_available
+    def patch_memory(self, address: Union[int, str], hex_: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "PatchMemory", "params": {"address": addr, "hex": hex_}})
+
+    @check_server_available
+    def patches(self) -> str:
+        return self.custom_post({"interface": "Patches", "params": {}})
+
+    @check_server_available
+    def revert_patch(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "RevertPatch", "params": {"address": addr}})
+
+    @check_server_available
+    def delete_patch(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DeletePatch", "params": {"address": addr}})
+
+class DisasmXrefApi(BaseHttpClient):
+    """反汇编、汇编、交叉引用"""
+    @check_server_available
+    def disassemble_at(self, address: Union[int, str], count: int = 5) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "DisassembleAt", "params": {"address": addr, "count": count}})
+
+    @check_server_available
+    def dissasembler(self, address: Union[int, str], count: int = 5) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "Dissasembler", "params": {"address": addr, "count": count}})
+
+    @check_server_available
+    def get_opcode_size(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetOpcodeSize", "params": {"address": addr}})
+
+    @check_server_available
+    def mnemonicbrief(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "mnemonicbrief", "params": {"address": addr}})
+
+    @check_server_available
+    def get_branch_target(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "GetBranchTarget", "params": {"address": addr}})
+
+    @check_server_available
+    def assemble(self, instr: str, cip: Union[int, str]) -> str:
+        c = validate_hex_address(cip)
+        return self.custom_post({"interface": "Assemble", "params": {"instr": instr, "cip": c}})
+
+    @check_server_available
+    def assemble_at(self, address: Union[int, str], instr: str) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "AssembleAt", "params": {"address": addr, "instr": instr}})
+
+    @check_server_available
+    def xrefs(self, address: Union[int, str], max_num: int = 5) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "xrefs", "params": {"address": addr, "max": max_num}})
+
+    @check_server_available
+    def find_ref(self, address: Union[int, str], max_num: int = 5) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "FindRef", "params": {"address": addr, "max": max_num}})
+
+class StackTraceApi(BaseHttpClient):
+    """栈、调用栈、追踪记录"""
+    @check_server_available
+    def call_stack(self, max_num: int = 16) -> str:
+        return self.custom_post({"interface": "CallStack", "params": {"max": max_num}})
+
+    @check_server_available
+    def stack(self, count: int = 8) -> str:
+        return self.custom_post({"interface": "Stack", "params": {"count": count}})
+
+    @check_server_available
+    def stack_push(self, value: str) -> str:
+        return self.custom_post({"interface": "StackPush", "params": {"value": value}})
+
+    @check_server_available
+    def stack_pop(self) -> str:
+        return self.custom_post({"interface": "StackPop", "params": {}})
+
+    @check_server_available
+    def stack_peek(self, offset: int = 0) -> str:
+        return self.custom_post({"interface": "StackPeek", "params": {"offset": offset}})
+
+    @check_server_available
+    def start_trace_record(self) -> str:
+        return self.custom_post({"interface": "StartTraceRecord", "params": {}})
+
+    @check_server_available
+    def get_trace_record(self, count: int = 5) -> str:
+        return self.custom_post({"interface": "GetTraceRecord", "params": {"count": count}})
+
+    @check_server_available
+    def stop_trace_record(self) -> str:
+        return self.custom_post({"interface": "StopTraceRecord", "params": {}})
+
+    @check_server_available
+    def jmp_history(self) -> str:
+        return self.custom_post({"interface": "JmpHistory", "params": {}})
+
+    @check_server_available
+    def last_exception(self) -> str:
+        return self.custom_post({"interface": "LastException", "params": {}})
+
+    @check_server_available
+    def eval_expr(self, expr: str) -> str:
+        return self.custom_post({"interface": "Eval", "params": {"expr": expr}})
+
+    @check_server_available
+    def show_debugger(self) -> str:
+        return self.custom_post({"interface": "ShowDebugger", "params": {}})
+
+    @check_server_available
+    def hide_debugger(self) -> str:
+        return self.custom_post({"interface": "HideDebugger", "params": {}})
+
+class ExecutionControlApi(BaseHttpClient):
+    """执行控制：运行、单步、暂停、run_to"""
+    @check_server_available
+    def run(self) -> str:
+        return self.custom_post({"interface": "Run", "params": {}})
+
+    @check_server_available
+    def pause(self) -> str:
+        return self.custom_post({"interface": "Pause", "params": {}})
+
+    @check_server_available
+    def e_run(self) -> str:
+        return self.custom_post({"interface": "ERun", "params": {}})
+
+    @check_server_available
+    def se_run(self) -> str:
+        return self.custom_post({"interface": "SERun", "params": {}})
+
+    @check_server_available
+    def step_in(self) -> str:
+        return self.custom_post({"interface": "StepIn", "params": {}})
+
+    @check_server_available
+    def step_over(self) -> str:
+        return self.custom_post({"interface": "StepOver", "params": {}})
+
+    @check_server_available
+    def step_out(self) -> str:
+        return self.custom_post({"interface": "StepOut", "params": {}})
+
+    @check_server_available
+    def e_step_into(self) -> str:
+        return self.custom_post({"interface": "EStepInto", "params": {}})
+
+    @check_server_available
+    def e_step_over(self) -> str:
+        return self.custom_post({"interface": "EStepOver", "params": {}})
+
+    @check_server_available
+    def e_step_out(self) -> str:
+        return self.custom_post({"interface": "EStepOut", "params": {}})
+
+    @check_server_available
+    def step_user(self) -> str:
+        return self.custom_post({"interface": "StepUser", "params": {}})
+
+    @check_server_available
+    def step_system(self) -> str:
+        return self.custom_post({"interface": "StepSystem", "params": {}})
+
+    @check_server_available
+    def skip(self, count: int = 1) -> str:
+        return self.custom_post({"interface": "Skip", "params": {"count": count}})
+
+    @check_server_available
+    def instr_undo(self) -> str:
+        return self.custom_post({"interface": "InstrUndo", "params": {}})
+
+    @check_server_available
+    def execute_command(self, command: str) -> str:
+        return self.custom_post({"interface": "ExecuteCommand", "params": command})
+
+    @check_server_available
+    def trace_into(self, count: int = 3) -> str:
+        return self.custom_post({"interface": "TraceInto", "params": {"count": count}})
+
+    @check_server_available
+    def trace_over(self, count: int = 3) -> str:
+        return self.custom_post({"interface": "TraceOver", "params": {"count": count}})
+
+    @check_server_available
+    def trace_line(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "TraceLine", "params": {"address": addr}})
+
+    @check_server_available
+    def run_to(self, address: Union[int, str]) -> str:
+        addr = validate_hex_address(address)
+        return self.custom_post({"interface": "RunTo", "params": {"address": addr}})
+
+    @check_server_available
+    def run_to_user_code(self) -> str:
+        return self.custom_post({"interface": "RunToUserCode", "params": {}})
+
+    @check_server_available
+    def debug_continue(self, status: int = 0) -> str:
+        return self.custom_post({"interface": "DebugContinue", "params": {"status": status}})
+
+    @check_server_available
+    def pause_all_threads(self) -> str:
+        return self.custom_post({"interface": "PauseAllThreads", "params": {}})
+
+    @check_server_available
+    def resume_all_threads(self) -> str:
+        return self.custom_post({"interface": "ResumeAllThreads", "params": {}})
+
+    @check_server_available
+    def thread_pause(self, tid: int) -> str:
+        return self.custom_post({"interface": "ThreadPause", "params": {"tid": tid}})
+
+    @check_server_available
+    def thread_resume(self, tid: int) -> str:
+        return self.custom_post({"interface": "ThreadResume", "params": {"tid": tid}})
+
+    @check_server_available
+    def animate_into(self, count: int = 3) -> str:
+        return self.custom_post({"interface": "AnimateInto", "params": {"count": count}})
+
+    @check_server_available
+    def animate_over(self, count: int = 3) -> str:
+        return self.custom_post({"interface": "AnimateOver", "params": {"count": count}})
+
+    @check_server_available
+    def animate_stop(self) -> str:
+        return self.custom_post({"interface": "AnimateStop", "params": {}})
+
+# 统一入口类 把所有API聚合在一起
+class BinSentryClient(
+    SystemApi,
+    LogConfigApi,
+    SymbolVarApi,
+    BreakPointApi,
+    DebugSessionApi,
+    RegisterThreadApi,
+    ModulePeApi,
+    MemoryApi,
+    DisasmXrefApi,
+    StackTraceApi,
+    ExecutionControlApi
+):
+    def __init__(self, config: Optional[Config] = None):
+        super().__init__(config)