添加新模块 ​

type YourModuleConfig struct {
    BaseConfig                    // 嵌入基础配置
    YourModulePath string         // 模块特定路径
    Model          string         // 捕获模式：text、pcap、keylog
    PcapFile       string         // 输出 pcap 文件
    PcapFilter     string         // BPF 过滤表达式
    // 添加模块特定字段
}

func NewYourModuleConfig() *YourModuleConfig {
    return &YourModuleConfig{
        BaseConfig: BaseConfig{},
    }
}

func (y *YourModuleConfig) Check() error {
    // 验证配置
    return nil
}

var ymc = config.NewYourModuleConfig()

var yourmoduleCmd = &cobra.Command{
    Use:     "yourmodule",
    Aliases: []string{"ym"},
    Short:   "从目标捕获数据",
    Long:    `关于模块功能的详细描述`,
    RunE:    yourmoduleCommandFunc,
}

func init() {
    yourmoduleCmd.PersistentFlags().StringVar(&ymc.YourModulePath, "path", "", "目标二进制路径")
    yourmoduleCmd.PersistentFlags().StringVarP(&ymc.Model, "model", "m", "text", "捕获模式：text、pcap、keylog")
    yourmoduleCmd.PersistentFlags().StringVarP(&ymc.PcapFile, "pcapfile", "w", "save.pcapng", "pcapng 输出文件")
    rootCmd.AddCommand(yourmoduleCmd)
}

func yourmoduleCommandFunc(command *cobra.Command, args []string) error {
    return runModule(module.ModuleNameYourModule, ymc)
}

type MYourModuleProbe struct {
    Module                                     // 嵌入基础模块
    bpfManager        *manager.Manager         // eBPF 程序管理器
    bpfManagerOptions manager.Options          // 管理器配置
    eventFuncMaps     map[*ebpf.Map]event.IEventStruct  // 映射 -> 解码器
    eventMaps         []*ebpf.Map              // 事件数据映射
    // 在此添加模块特定字段
    targetPath        string                   // 目标二进制路径
    targetFuncName    string                   // 要钩取的函数
}

func (m *MYourModuleProbe) Init(ctx context.Context, logger *zerolog.Logger, conf config.IConfig, ecw io.Writer) error {
    // 调用基础 Init()
    err := m.Module.Init(ctx, logger, conf, ecw)
    if err != nil {
        return err
    }
    
    // 设置配置
    m.conf = conf
    m.Module.SetChild(m)
    
    // 初始化事件映射和解码器
    m.eventMaps = make([]*ebpf.Map, 0, 2)
    m.eventFuncMaps = make(map[*ebpf.Map]event.IEventStruct)
    
    // 模块特定初始化
    ymc := conf.(*config.YourModuleConfig)
    m.targetPath = ymc.YourModulePath
    
    // 验证目标二进制文件存在
    if _, err := os.Stat(m.targetPath); err != nil {
        return fmt.Errorf("目标二进制文件未找到: %w", err)
    }
    
    return nil
}

func (m *MYourModuleProbe) setupManagers() error {
    // 定义 uprobe 附加点
    m.bpfManager = &manager.Manager{
        Probes: []*manager.Probe{
            {
                Section:          "uprobe/your_target_function",
                EbpfFuncName:     "probe_your_function",
                AttachToFuncName: "your_target_function",
                BinaryPath:       m.targetPath,
            },
            {
                Section:          "uretprobe/your_target_function",
                EbpfFuncName:     "probe_your_function_ret",
                AttachToFuncName: "your_target_function",
                BinaryPath:       m.targetPath,
            },
        },
        Maps: []*manager.Map{
            {
                Name: "events",
            },
        },
    }
    
    // 设置管理器选项
    m.bpfManagerOptions = manager.Options{
        DefaultKProbeMaxActive: 512,
        VerifierOptions: ebpf.CollectionOptions{
            Programs: ebpf.ProgramOptions{
                LogSize: 2097152,
            },
        },
        RLimit: &unix.Rlimit{
            Cur: math.MaxUint64,
            Max: math.MaxUint64,
        },
    }
    
    return nil
}

func (m *MYourModuleProbe) Start() error {
    // 设置管理器
    err := m.setupManagers()
    if err != nil {
        return err
    }
    
    // 获取 eBPF 字节码文件
    bpfFileName := m.geteBPFName("user/bytecode/yourmodule_kern.o")
    byteBuf, err := assets.Asset(bpfFileName)
    if err != nil {
        return fmt.Errorf("找不到资源: %w", err)
    }
    
    // 使用字节码初始化 eBPF 管理器
    if err = m.bpfManager.InitWithOptions(bytes.NewReader(byteBuf), m.bpfManagerOptions); err != nil {
        return fmt.Errorf("无法初始化管理器: %w", err)
    }
    
    // 启动 eBPF 管理器（附加探针）
    if err = m.bpfManager.Start(); err != nil {
        return fmt.Errorf("无法启动管理器: %w", err)
    }
    
    // 初始化事件解码器
    err = m.initDecodeFun()
    if err != nil {
        return err
    }
    
    return nil
}

func (m *MYourModuleProbe) initDecodeFun() error {
    // 获取 eBPF 映射
    eventsMap, found, err := m.bpfManager.GetMap("events")
    if err != nil {
        return err
    }
    if !found {
        return errors.New("未找到 events 映射")
    }
    
    // 创建事件解码器实例
    yourEvent := &event.YourModuleEvent{}
    
    // 将解码器映射到映射
    m.eventFuncMaps[eventsMap] = yourEvent
    
    // 将映射添加到事件映射列表
    m.eventMaps = append(m.eventMaps, eventsMap)
    
    return nil
}

// Events 返回要从中读取事件的 eBPF 映射
func (m *MYourModuleProbe) Events() []*ebpf.Map {
    return m.eventMaps
}

// DecodeFun 返回给定 eBPF 映射的解码器
func (m *MYourModuleProbe) DecodeFun(em *ebpf.Map) (event.IEventStruct, bool) {
    fun, found := m.eventFuncMaps[em]
    return fun, found
}

// Dispatcher 处理已解码的事件
func (m *MYourModuleProbe) Dispatcher(e event.IEventStruct) {
    switch ev := e.(type) {
    case *event.YourModuleEvent:
        // 处理您的事件
        m.logger.Info().Str("data", ev.String()).Msg("捕获的事件")
        // 写入事件收集器
        m.processor.Write(ev)
    }
}

// Close 清理资源
func (m *MYourModuleProbe) Close() error {
    if err := m.bpfManager.Stop(manager.CleanAll); err != nil {
        return err
    }
    return m.Module.Close()
}

func init() {
    RegisteFunc(NewYourModuleProbe)
}

func NewYourModuleProbe() IModule {
    mod := &MYourModuleProbe{}
    mod.name = ModuleNameYourModule  // 定义此常量
    mod.mType = ProbeTypeUprobe
    return mod
}

const (
    ModuleNameYourModule = "yourmodule"
)

type YourModuleEvent struct {
    eventType EventType
    Pid       uint32
    Uid       uint32
    Timestamp uint64
    Comm      [16]byte
    // 与 eBPF 结构匹配的模块特定字段
    DataLen   uint32
    Data      [MAX_DATA_SIZE]byte
}

// Clone 创建新实例
func (e *YourModuleEvent) Clone() IEventStruct {
    return new(YourModuleEvent)
}

// EventType 返回用于路由的事件类型
func (e *YourModuleEvent) EventType() EventType {
    return e.eventType
}

// Decode 从 eBPF 解析原始字节
func (e *YourModuleEvent) Decode(payload []byte) error {
    buf := bytes.NewBuffer(payload)
    if err := binary.Read(buf, binary.LittleEndian, &e.Pid); err != nil {
        return err
    }
    if err := binary.Read(buf, binary.LittleEndian, &e.Uid); err != nil {
        return err
    }
    // 解码剩余字段...
    return nil
}

// String 返回人类可读格式
func (e *YourModuleEvent) String() string {
    s := fmt.Sprintf("PID:%d UID:%d Data:%s",
        e.Pid, e.Uid, string(e.Data[:e.DataLen]))
    return s
}

// StringHex 返回十六进制格式
func (e *YourModuleEvent) StringHex() string {
    return fmt.Sprintf("%s\n%s", e.String(), 
        hex.Dump(e.Data[:e.DataLen]))
}

type YourModuleConfig struct {
    BaseConfig               // 继承：Pid、Uid、Debug、IsHex、BtfMode、PerCpuMapSize
    YourModulePath string    // 目标二进制路径
    Model          string    // 输出模式：text、pcap、keylog
    // 根据需要添加更多字段
}

func (c *YourModuleConfig) Check() error {
    // 验证 YourModulePath 存在
    if c.YourModulePath == "" {
        return errors.New("需要目标路径")
    }
    return nil
}

func (m *MYourModuleProbe) Init(ctx context.Context, logger *zerolog.Logger, conf config.IConfig, ecw io.Writer) error {
    // ...
    ymc := conf.(*config.YourModuleConfig)
    m.targetPath = ymc.YourModulePath
    // ...
}