1. 项目概述：为什么选择Cutter作为逆向工程的起点

如果你正在逆向工程的世界门口徘徊，或者已经用惯了IDA Pro、Ghidra这类工具，却总觉得少了点什么——比如，一个真正开源、免费、可深度定制且现代化的界面，那么Cutter绝对值得你花时间深入了解。我最初接触Cutter，是因为厌倦了老牌工具的笨重和昂贵的授权费用。Cutter基于rizin（一个强大的开源逆向工程框架）构建，不仅继承了rizin的命令行威力，还提供了一个直观的图形界面。但Cutter最吸引我的，是它从设计之初就拥抱了插件化。这意味着，你可以用Python快速验证一个想法，也可以用C++打造一个高性能、深度集成的核心功能。这篇指南，就是带你从零开始，打通从Python脚本到C++插件的完整开发链路，让你能真正“拥有”自己的逆向工具。

对于逆向工程师、安全研究员，甚至是想要理解二进制程序内部机制的学生来说，掌握插件开发意味着你能将重复性工作自动化，能将独特的分析思路固化为工具，甚至能创造出全新的分析方法。无论是想批量重命名函数、自动化识别加密算法，还是想为某个特定架构或文件格式添加支持，插件都是最直接的途径。本教程将假设你具备基本的编程知识（Python或C++），但无需任何逆向工程或插件开发经验。我们会从环境搭建开始，一步步深入到两种语言开发的核心差异、实战案例，以及如何将你的插件分享给社区。

2. Cutter插件生态与开发环境全解析

在动手写代码之前，我们必须先理解Cutter插件的运行机制和两种开发语言（Python/C++）的定位。这决定了你后续的技术选型和开发体验。

2.1 Python插件 vs C++插件：定位与抉择

Cutter的插件体系是双轨制的，理解它们的区别是做出正确选择的第一步。

Python插件 ，我称之为“快速原型与脚本利器”。它的核心优势在于开发速度极快。你几乎可以在几分钟内就写出一个能运行的插件，用于执行一些临时的分析任务、批量处理，或者测试某个想法是否可行。Python插件运行在Cutter内置的Python解释器中，可以直接调用Cutter提供的丰富API，与界面元素（如反汇编视图、图表、侧边栏）进行交互。它的典型应用场景包括：自动化标注、批量字符串解密、与外部工具（如Yara、Capstone）集成、生成简单的报告等。然而，Python插件的性能瓶颈是显而易见的，尤其是在处理大型二进制文件或进行密集计算时。此外，它的分发相对简单，通常就是一个 .py 文件，用户直接丢进插件目录即可。

C++插件 ，则是“高性能与深度集成的终极选择”。当你需要开发一个功能复杂、对性能要求极高，或者需要深度修改Cutter核心行为（例如，添加一个新的反汇编后端、实现一个全新的图形视图）时，C++是唯一的选择。C++插件被编译为动态链接库（在Windows上是 .dll ，在Linux/macOS上是 .so ），直接加载到Cutter的进程空间，因此可以调用更底层的API，实现无性能损耗的紧密集成。它的开发门槛更高，涉及到CMake构建、C++编译环境配置、以及更复杂的插件生命周期管理。但带来的回报是极致的性能和无限的可能性。社区中许多重量级插件，如对某些冷门CPU架构的深度支持、高级的漏洞模式检测引擎，都是用C++实现的。

我的经验之谈 ：对于绝大多数日常需求和个人项目，从Python开始。它能让你快速获得正反馈，验证想法的价值。只有当你的Python插件因为性能问题成为瓶颈，或者你确实需要C++才能实现的底层功能时，再考虑迁移到C++。很多优秀的插件都是先用Python实现核心逻辑，验证市场，再用C++重写核心计算模块。

2.2 一站式开发环境搭建指南

一个顺畅的开发环境能避免无数“玄学”错误。下面是我经过多次踩坑后总结的、当前（2024年）最稳定的配置方案。

1. 安装Cutter（开发版或稳定版） 首先，你需要Cutter本身。对于插件开发，我强烈建议直接从GitHub仓库克隆并编译最新开发版，因为你能第一时间用到最新的API，并且便于调试。

git clone --recursive https://github.com/rizinorg/cutter.git
cd cutter
# 根据你的平台，参考官方文档进行编译。通常需要安装Qt、CMake、编译工具链。
# 例如在Ubuntu上：
sudo apt install build-essential cmake qt6-base-dev qt6-tools-dev-tools libqt6svg6-dev
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DCUTTER_ENABLE_PYTHON=ON -DCUTTER_ENABLE_PYTHON_BINDINGS=ON ..
make -j$(nproc)
sudo make install

如果编译遇到困难，也可以直接从 发布页面 下载最新的稳定版安装包。但请注意，预编译版本的Python绑定可能不是最新的。

2. Python开发环境配置 Cutter内置了Python（通常是3.8+），但你也可以让插件使用系统Python。为了隔离和依赖管理，我推荐使用 venv 。

# 在项目目录下
python3 -m venv cutter-plugin-env
source cutter-plugin-env/bin/activate  # Linux/macOS
# 或 cutter-plugin-env\Scripts\activate  # Windows

关键一步是确保Cutter能找到你的插件。Cutter会在以下位置查找Python插件：

• 用户目录： ~/.local/share/rizin/cutter/plugins/python (Linux), %APPDATA%\rizin\cutter\plugins\python (Windows)
• Cutter安装目录下的 plugins/python 文件夹。 我通常会在用户目录下创建一个软链接，指向我的插件项目目录，这样开发时修改代码，Cutter能即时加载。

3. C++开发环境配置 C++插件开发的核心是CMake。你需要一个C++编译器（GCC/Clang/MSVC）和CMake（3.15+）。此外，由于Cutter基于Qt，你还需要安装Qt开发库（Qt6是当前主流）。

• Windows : 安装Visual Studio 2019/2022（包含MSVC和CMake支持），并通过Qt官方安装器安装Qt6。
• macOS : brew install cmake qt6
• Linux : sudo apt install build-essential cmake qt6-base-dev 配置好环境后，你可以用Cutter源码树中自带的插件模板作为起点，这能帮你处理好所有依赖和编译配置。

4. IDE选择：VSCode是绝佳伴侣 无论是Python还是C++，Visual Studio Code都是我的首选。对于Python，安装Python和Pylance扩展即可获得优秀的代码补全和调试支持。对于C++，需要安装C/C++扩展和CMake Tools扩展。 关键技巧 ：为了让VSCode能正确索引Cutter的API，你需要配置 c_cpp_properties.json （C++）和 settings.json （Python）。

• C++ : 在 .vscode/c_cpp_properties.json 中，将Cutter和Qt的头文件路径添加到 includePath 中。
• Python : 如果你使用虚拟环境，在VSCode中选择该环境作为解释器。更高级的做法是，利用 stub 文件或手动为Cutter模块添加类型提示，来获得API自动补全。你可以从Cutter源码的 bindings 目录找到一些线索，或者使用 pyi 文件生成工具。

3. Python插件开发：从“Hello World”到实战工具

让我们从最快速的Python插件开始，这是感受Cutter插件开发魅力的最佳方式。

3.1 第一个插件：解剖“Hello World”

一个最简单的Cutter Python插件结构如下：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from cutter import CutterPlugin

class MyFirstPlugin(CutterPlugin):
    name = "MyFirstPlugin"
    description = "This is my first Cutter plugin!"
    version = "1.0"

    def setupPlugin(self):
        # 插件初始化逻辑，例如创建菜单项、工具栏按钮
        pass

    def setupInterface(self, main):
        # 创建插件界面元素的主要入口
        action = main.createAction("My Action", "Trigger my plugin")
        action.triggered.connect(self.onActionTriggered)

    def onActionTriggered(self):
        # 动作触发后的回调函数
        print("Hello from MyFirstPlugin!")
        # 获取当前分析的二进制信息
        core = self.core() # 获取CutterCore实例，这是与逆向引擎交互的核心
        info = core.getFileInfo()
        print(f"Analyzing: {info.name}, Size: {info.size} bytes")

def createPlugin():
    return MyFirstPlugin()

逐行解析 ：

1. 导入与继承 ：必须从 cutter 模块导入 CutterPlugin 基类，你的插件类需要继承它。
2. 元信息 ： name , description , version 是必须定义的类属性，它们会在Cutter的插件管理器中显示。
3. setupPlugin 方法：在插件被加载时调用一次。适合做一些一次性的初始化，比如读取配置文件、初始化全局对象。在这个简单例子里我们留空。
4. setupInterface 方法：这是 最关键 的方法。参数 main 是一个 CutterMainWindow 对象，代表Cutter的主窗口。在这里，你可以创建菜单项、工具栏按钮、停靠窗口等所有UI元素。我们使用 main.createAction 创建了一个动作，并连接到 onActionTriggered 方法。
5. onActionTriggered 方法：这是我们动作的实际响应函数。这里我们打印了一条消息，并演示了如何通过 self.core() 获取 CutterCore 实例。 CutterCore 是通往所有逆向分析功能的门户，从读取文件信息、反汇编、到修改字节，都通过它。
6. createPlugin 函数：Cutter加载插件时寻找的工厂函数，必须返回你的插件类实例。

如何安装与测试 ：

1. 将上述代码保存为 my_first_plugin.py 。
2. 将其复制到Cutter的Python插件目录（例如 ~/.local/share/rizin/cutter/plugins/python/ ）。
3. 启动Cutter，打开任意一个二进制文件（比如 /bin/ls ）。
4. 点击顶部菜单 Plugins -> Python Plugins 。你应该能看到“MyFirstPlugin”被列出并已加载。
5. 在菜单栏或工具栏上找到“My Action”并点击，你会在Cutter的日志输出窗口（通常在下方面板）看到打印的消息。

3.2 深入核心：CutterCore API实战

CutterCore 是你的瑞士军刀。下面通过几个常见场景，展示其强大功能。

场景一：遍历所有函数并提取信息

def analyze_functions(self):
    core = self.core()
    # 获取所有函数地址的列表
    func_addrs = core.getFunctions()
    
    for addr in func_addrs:
        # 获取函数对象
        func = core.getFunction(addr)
        print(f"Function: {func.name} at 0x{addr:x}")
        print(f"  Size: {func.size} bytes")
        # 获取函数的反汇编指令
        instructions = core.getInstructions(addr, func.size)
        for instr in instructions:
            print(f"    0x{instr.addr:x}: {instr.mnemonic} {instr.op_str}")
        print("-" * 40)

这个脚本展示了如何获取二进制中所有函数的地址，然后遍历每个函数，打印其名称、大小和反汇编指令。这在批量分析或生成函数概览报告时非常有用。

场景二：在指定地址添加注释

def add_comment_at_entry(self):
    core = self.core()
    # 获取程序的入口点（例如，main函数）
    entry_addr = core.getEntryPoint()
    if entry_addr != 0xffffffffffffffff: # 检查是否有效
        comment = "// Program entry point - analyzed by MyPlugin"
        core.setComment(entry_addr, comment)
        print(f"Comment added at 0x{entry_addr:x}")

逆向分析中，添加注释是理清思路的关键。 setComment API允许你在任何地址添加注释，这些注释会显示在反汇编视图中。

场景三：查找并重命名特定模式的字符串 假设你想找到所有看起来像API密钥的字符串（例如，以 sk_ 开头）并重命名它们所在的变量。

def rename_api_key_strings(self):
    core = self.core()
    # 获取所有字符串
    strings = core.getStrings()
    for s in strings:
        if s.string.startswith('sk_'):
            # 获取引用此字符串的地址（可能不止一个）
            xrefs = core.getXRefs(s.vaddr, False) # False表示查找谁引用了这个地址
            for xref in xrefs:
                # 在引用处，尝试将其重命名
                # 这里简化处理：在字符串地址本身定义一个更有意义的名字
                new_name = f"str_api_key_{s.vaddr:x}"
                core.renameAddress(s.vaddr, new_name)
                print(f"Renamed string at 0x{s.vaddr:x} to {new_name}")

这个例子结合了字符串检索、交叉引用分析和重命名功能，展示了如何将多个简单API组合起来实现一个有用的自动化任务。

3.3 构建交互界面：让你的插件更友好

一个只有命令行输出的插件是简陋的。Cutter的Python绑定允许你创建丰富的Qt界面。

创建停靠窗口（Dock Widget） 停靠窗口可以嵌入到Cutter主界面的四周，提供持久化的交互面板。

from PySide6.QtWidgets import QDockWidget, QTextEdit, QVBoxLayout, QWidget, QPushButton
from PySide6.QtCore import Qt

class MyDockWidget(QDockWidget):
    def __init__(self, parent=None, core=None):
        super().__init__("My Analysis Dock", parent)
        self.core = core
        self.setObjectName("MyAnalysisDock") # 重要：用于保存布局
        self.setupUI()

    def setupUI(self):
        central_widget = QWidget()
        self.setWidget(central_widget)
        layout = QVBoxLayout(central_widget)

        self.text_edit = QTextEdit()
        self.text_edit.setReadOnly(True)
        layout.addWidget(self.text_edit)

        self.analyze_btn = QPushButton("Analyze Current Function")
        self.analyze_btn.clicked.connect(self.analyze_current)
        layout.addWidget(self.analyze_btn)

    def analyze_current(self):
        # 获取当前光标所在的地址
        current_addr = self.core.getCurrentAddress()
        func = self.core.getFunction(current_addr)
        if func:
            info = f"Function: {func.name}\nAddress: 0x{current_addr:x}\nSize: {func.size} bytes"
            self.text_edit.setText(info)
        else:
            self.text_edit.setText("Not inside a function.")

# 在你的插件类中创建并添加这个停靠窗口
def setupInterface(self, main):
    self.dock_widget = MyDockWidget(parent=main, core=self.core())
    main.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget)

这个停靠窗口包含一个文本显示区域和一个按钮。点击按钮，它会分析当前反汇编视图光标所在的函数，并将信息显示在文本框中。 setObjectName 非常重要，它允许Cutter记住这个窗口的位置和状态。

与图形视图交互：在反汇编图上高亮 Cutter的反汇编图（Graph View）是核心视图之一。你可以通过API与之交互。

def highlight_basic_blocks(self):
    core = self.core()
    # 获取当前函数的图形视图控制器
    graph_view = self.main.getGraphWidget() # 需要从main窗口获取
    if graph_view:
        # 获取当前函数的所有基本块
        func_addr = core.getCurrentAddress()
        func = core.getFunction(func_addr)
        if func:
            # 这里简化处理，实际高亮需要操作GraphWidget的API
            # 一种常见模式是发射一个信号，或者调用一个高亮方法
            # 例如，Cutter内部可能提供：graph_view.highlightBlock(block_address)
            print(f"Function {func.name} has graph available.")
            # 更实际的做法可能是通过修改主题或添加自定义装饰器来实现，
            # 这通常涉及到更底层的C++ API或特定的Python绑定。

需要注意的是，对图形视图的深度操作（如自定义渲染、高亮算法）往往更依赖于C++插件，因为涉及到底层的绘图和性能优化。Python更适合做一些轻量的标记和信息展示。

4. C++插件开发：迈向高性能与深度集成

当你需要极致的性能，或者Python API无法满足你的需求时，就该转向C++了。C++插件开发更像是在为Cutter本身添加一个原生模块。

4.1 项目结构与CMake构建

一个标准的C++插件项目结构如下：

MyCppPlugin/
├── CMakeLists.txt
├── MyCppPlugin.cpp
├── MyCppPlugin.h
└── resources.qrc (可选，用于图标等资源)

CMakeLists.txt 解析 这是构建系统的核心。一个最小化的示例如下：

cmake_minimum_required(VERSION 3.15)
project(MyCppPlugin VERSION 1.0.0 LANGUAGES CXX)

# 查找Cutter的包配置。Cutter安装后应提供CutterConfig.cmake
find_package(Cutter REQUIRED)

# 定义你的插件
add_library(MyCppPlugin MODULE
    MyCppPlugin.cpp
    MyCppPlugin.h
)

# 链接必要的库
target_link_libraries(MyCppPlugin PRIVATE
    Cutter::Cutter
    # 可能还需要其他库，如Qt6::Core, Qt6::Widgets
)

# 设置插件属性
set_target_properties(MyCppPlugin PROPERTIES
    CUTTER_MODULE_TYPE "plugin"
    CUTTER_MODULE_NAME "MyCppPlugin"
    # 确保输出到正确的插件目录（可选，方便开发）
    # LIBRARY_OUTPUT_DIRECTORY "${CUTTER_PLUGINS_INSTALL_DIR}"
)

# 安装目标
install(TARGETS MyCppPlugin
    LIBRARY DESTINATION ${CUTTER_PLUGINS_INSTALL_DIR}
)

关键点：

• find_package(Cutter REQUIRED) ：这行命令会设置 CUTTER_INCLUDE_DIRS 、 CUTTER_LIBRARIES 等变量，以及最重要的 CUTTER_PLUGINS_INSTALL_DIR （插件安装路径）。
• MODULE ：指定生成动态库（插件）。
• CUTTER_MODULE_TYPE 和 CUTTER_MODULE_NAME ：这些属性会被Cutter的构建系统识别，确保插件被正确打包和处理。

头文件与类定义 (MyCppPlugin.h)

#pragma once

#include <CutterPlugin.h>

class MyCppPlugin : public QObject, public CutterPlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.rizin.cutter.plugin" FILE "mycppplugin.json")
    Q_INTERFACES(CutterPlugin)

public:
    void setupPlugin() override;
    void setupInterface(MainWindow *main) override;
    QString getName() const override { return "MyCppPlugin"; }
    QString getAuthor() const override { return "Your Name"; }
    QString getDescription() const override { return "A powerful C++ plugin."; }
    QString getVersion() const override { return "1.0"; }
};

• 必须继承 QObject 和 CutterPlugin 。
• 必须使用Qt的元对象系统宏（ Q_OBJECT , Q_PLUGIN_METADATA , Q_INTERFACES ）。 mycppplugin.json 是一个可选的元数据文件，可以包含插件图标等信息。
• 重写纯虚函数 setupPlugin 和 setupInterface 。

4.2 核心类实现与插件生命周期

源文件实现 (MyCppPlugin.cpp)

#include "MyCppPlugin.h"
#include <QAction>
#include <QMessageBox>
#include <core/Cutter.h>

void MyCppPlugin::setupPlugin()
{
    // C++插件的初始化，比Python的setupPlugin更早。
    // 在这里可以初始化一些全局资源，但注意不能创建UI（因为主窗口可能还没创建）。
    qDebug("MyCppPlugin: setupPlugin() called.");
}

void MyCppPlugin::setupInterface(MainWindow *main)
{
    // 创建UI元素的主要场所
    auto action = new QAction(tr("My C++ Action"), main);
    action->setShortcut(QKeySequence("Ctrl+Shift+P")); // 设置快捷键
    connect(action, &QAction::triggered, this, [this, main]() {
        // 使用CutterCore
        auto core = main->getCore();
        RVA entry = core->getEntryPoint();
        QString info = QString("Binary Entry Point: 0x%1").arg(entry, 0, 16);
        QMessageBox::information(main, "C++ Plugin Info", info);

        // 演示高性能操作：批量分析所有字符串的熵值
        QList<StringDescription> strings = core->getAllStrings();
        qDebug() << "Found" << strings.size() << "strings.";
        // ... 进行复杂的计算，比如熵值分析
    });

    // 将动作添加到菜单
    main->getMenuByType(MainWindow::MenuType::PluginsMenu)->addAction(action);
    // 也可以添加到工具栏
    // main->addToolbarAction(action);
}

生命周期详解 ：

1. 加载 ：Cutter启动时，扫描插件目录，发现符合规范的动态库（ .so / .dll ），通过Qt的插件机制加载。
2. setupPlugin() ：插件实例创建后立即调用。此时主窗口( MainWindow )可能尚未创建。 适合进行非UI相关的初始化 ，例如注册自定义的rizin命令、初始化算法库、连接数据库等。
3. setupInterface(MainWindow *) ：主窗口创建完成后调用。参数 main 就是Cutter的主窗口对象。 所有UI相关的创建都必须在这里进行 ，如创建菜单、工具栏、停靠窗口。这也是连接信号槽的最佳位置。
4. 运行 ：插件保持加载状态，其创建的对象（如QAction）由Qt的对象树管理生命周期。
5. 卸载 ：当Cutter关闭或用户禁用插件时，插件对象及其所有子QObject会被析构。如果你的插件持有需要手动释放的非Qt资源（如原生句柄、内存），需要在析构函数或重写的 terminate 函数中释放。

4.3 高级主题：自定义反汇编器与架构支持

这是C++插件真正发挥威力的领域。假设你想为一种自定义的字节码（比如一个游戏机的虚拟指令集）添加支持。

1. 实现分析器 (RzAnalysisPlugin) 你需要创建一个类，实现 RzAnalysisPlugin 接口（这是rizin框架的接口）。核心是实现反汇编( op )和代码分析( analyze )回调。

// 伪代码，展示概念
class MyCustomAnalysisPlugin : public RzAnalysisPlugin {
public:
    MyCustomAnalysisPlugin() {
        name = "my_custom";
        desc = "Analysis plugin for MyCustom VM";
        arch = "mycustom";
        bits = 32;
        // 注册回调函数
        op = &mycustom_op;
        analyze = &mycustom_analyze;
    }

    static int mycustom_op(RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8 *buf, int len) {
        // 解析buf中的字节，填充op结构体：类型、大小、操作数等
        op->type = RZ_ANALYSIS_OP_TYPE_MOV;
        op->size = 4;
        // ... 具体解析逻辑
        return op->size; // 返回指令长度
    }

    static bool mycustom_analyze(RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8 *buf, int len) {
        // 更深入的分析，例如识别函数边界、控制流等
        return true;
    }
};

2. 在C++插件中注册 在你的Cutter插件初始化时，将这个分析器注册到核心的 RzAnalysis 中。

void MyCppPlugin::setupPlugin() {
    auto core = CutterCore::getInstance(); // 获取核心实例
    RzAnalysis *analysis = core->getAnalysis(); // 获取分析器上下文

    // 创建并注册我们的插件
    RzAnalysisPlugin *myPlugin = new MyCustomAnalysisPlugin();
    rz_analysis_plugin_add(analysis, myPlugin);
}

3. 关联反汇编器 (RzAsmPlugin) 类似地，你可能还需要实现一个 RzAsmPlugin 来负责将指令汇编成字节码。过程与分析器类似。

4. 在Cutter中启用 完成以上步骤后，当用户打开一个被识别为 mycustom 架构的文件（或手动选择架构），Cutter就会使用你的插件进行反汇编和分析。你还可以进一步提供自定义的寄存器视图、堆栈视图等。

这个过程非常复杂，需要对rizin的插件架构有深入理解。通常，你需要参考rizin源码中已有的架构插件（如x86、ARM）来编写。但这正是C++插件强大之处——你可以在最底层扩展Cutter的能力。

5. 调试、打包与发布全流程

开发完成后，让插件稳定运行并分享出去，是最后也是最重要的一步。

5.1 调试技巧：Python与C++的排错之道

Python插件调试

1. 打印日志 ：最直接的方法。使用 print() 或Python的 logging 模块。输出会显示在Cutter的“输出”面板（需确保日志级别足够）。
2. 使用外部调试器 ：虽然麻烦但强大。你可以在插件代码开头插入 import pdb; pdb.set_trace() ，然后通过命令行用 python -m pdb 启动Cutter（如果Cutter是用Python脚本启动的）。更实用的方法是使用远程调试。
3. VSCode远程调试 ：配置VSCode的 launch.json ，附加到Cutter的Python进程上。这需要一些配置，但一旦设好，可以设置断点、单步执行、查看变量，体验极佳。

{
    "name": "Python: Attach to Cutter",
    "type": "python",
    "request": "attach",
    "connect": {
        "host": "localhost",
        "port": 5678
    },
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "."
        }
    ]
}

在插件代码中需要先安装并启用 debugpy ： import debugpy; debugpy.listen(5678); debugpy.wait_for_client() 。

C++插件调试

1. 日志输出 ：使用Qt的 qDebug() , qInfo() , qWarning() , qCritical() 。这些信息也会输出到Cutter的日志中。
2. 使用IDE调试器 ：这是最有效的方法。

• Linux/macOS ：在终端用 gdb 或 lldb 启动Cutter， gdb --args cutter /path/to/binary ，然后设置断点 b MyCppPlugin::setupInterface 。
• Windows (Visual Studio) ：将Cutter项目作为启动项目，或者将你的插件项目设为启动项并配置调试命令指向Cutter可执行文件。可以直接在源码中设置断点。
• VSCode ：配置 launch.json ，使用 cppvsdbg （Windows）或 cppdbg （Linux/macOS）调试配置，附加到Cutter进程或直接启动Cutter。

3. 处理崩溃 ：C++插件崩溃可能导致Cutter一起崩溃。务必使用智能指针管理资源，在边界处检查指针有效性。对于复杂的插件，可以考虑在单独的线程中进行耗时计算，避免阻塞UI线程。

5.2 插件打包与分发指南

Python插件打包 最简单的方式就是直接分发 .py 文件。但为了更专业，可以考虑：

1. 添加元数据 ：在插件文件顶部使用标准的Python模块文档字符串，包含名称、版本、作者、描述。
2. 依赖管理 ：如果你的插件依赖第三方库（如 yara-python , capstone ），需要在文档中明确说明。由于插件运行在Cutter的Python环境中，用户可能需要手动安装这些依赖。一个友好的做法是在插件启动时检查并提示。
3. 使用 setup.py 或 pyproject.toml ：你可以将插件打包成一个Python包，这样用户可以用 pip install 安装。但这需要处理好插件文件的安装路径（必须放到Cutter的插件目录）。这更适合高级用户或通过Cutter插件商店分发。

C++插件打包 C++插件必须编译为平台特定的二进制文件。

1. 编译为Release ：确保使用Release模式编译，以优化性能和大小。
2. 处理依赖 ：C++插件动态链接到Cutter和Qt的核心库。在Linux上，要注意 LD_LIBRARY_PATH ；在Windows上，可能需要将必要的DLL（如QtCore.dll）与你的插件一起分发，或者确保用户环境已安装相应的Visual C++ Redistributable和Qt运行时。
3. 创建安装包 ：

• Linux : 可以制作 .deb 或 .rpm 包，将插件库文件安装到 /usr/lib/cutter/plugins/ 或用户目录。
• Windows : 使用NSIS、Inno Setup等工具制作安装程序。
• macOS : 创建 .dmg 镜像或 .pkg 安装包。 安装包应该将编译好的 .so / .dll 文件复制到Cutter的插件目录。你可以通过查询注册表（Windows）、环境变量或标准路径来定位这个目录。

发布到Cutter插件商店（如果存在） Cutter社区正在推动建立官方的插件商店。一旦上线，发布流程可能包括：

1. 将插件代码托管在GitHub等平台。
2. 提供清晰的 README.md ，包含截图、功能说明、安装指南。
3. 遵循商店的元数据格式（可能是一个JSON文件），描述插件名称、版本、兼容的Cutter版本、作者、许可证等。
4. 通过提交流程将插件添加到商店仓库。

5.3 版本兼容性与维护建议

逆向工具和其插件生态发展迅速，保持兼容性至关重要。

1. 明确声明兼容性 ：在你的插件文档中，明确说明它兼容的Cutter版本（例如，“Cutter 2.x”）。Cutter的API并非完全稳定，尤其是Python绑定和C++ API，在主要版本间可能会有变动。
2. 使用特性检测 ：在代码中，可以检查Cutter核心的版本或某个特定API是否存在。

# Python 示例
import cutter
if hasattr(cutter, 'some_new_api'):
    # 使用新API
    pass
else:
    # 回退到旧方法
    pass

// C++ 示例
#if defined(CUTTER_API_VERSION) && (CUTTER_API_VERSION >= 202400)
    // 使用新API
#else
    // 使用旧API或编译错误
#endif

3. 关注更新日志 ：密切关注Cutter项目的更新日志和GitHub提交，了解API的废弃和新增情况。
4. 建立CI/CD ：如果你的插件是开源项目，使用GitHub Actions、GitLab CI等自动化工具，针对不同版本的Cutter进行构建和测试，可以及早发现兼容性问题。
5. 用户反馈渠道 ：提供Issue页面或讨论区，让用户报告问题。对于C++插件，崩溃报告尤其重要，可以要求用户提供Cutter的版本、操作系统信息和崩溃堆栈。

开发Cutter插件，尤其是C++插件，是一个深入理解逆向工程框架的绝佳机会。从简单的Python脚本自动化繁琐任务，到用C++打造专属的分析引擎，这条路径充满了挑战和乐趣。最重要的是，你的工作可以直接回馈给开源社区，让全世界的逆向工程师受益。