fscan/Common/base/Plugin.go

package base

import (
	"fmt"
	"sync"
)

/*
Plugin.go - 插件系统管理

整合Types.go中的插件系统，提供统一的插件注册和管理机制。
*/

// =============================================================================
// 核心数据结构 (从Types.go迁移)
// =============================================================================

// HostInfo 主机信息结构
type HostInfo struct {
	Host    string   // 主机地址
	Ports   string   // 端口范围
	Url     string   // URL地址
	Infostr []string // 附加信息
}

// =============================================================================
// 插件类型常量
// =============================================================================

const (
	PluginTypeService = "service" // 服务类型插件
	PluginTypeWeb     = "web"     // Web类型插件
	PluginTypeLocal   = "local"   // 本地类型插件
	PluginTypeBrute   = "brute"   // 暴力破解插件
	PluginTypePoc     = "poc"     // POC验证插件
	PluginTypeScan    = "scan"    // 扫描探测插件
)

// =============================================================================
// 插件定义和管理
// =============================================================================

// ScanPlugin 定义扫描插件的结构
type ScanPlugin struct {
	Name        string                // 插件名称
	Version     string                // 插件版本
	Description string                // 插件描述
	Author      string                // 插件作者
	Ports       []int                 // 适用端口
	Types       []string              // 插件类型标签，一个插件可以有多个类型
	Priority    int                   // 插件优先级(数字越小优先级越高)
	Enabled     bool                  // 是否启用
	ScanFunc    func(*HostInfo) error // 扫描函数
}

// PluginManager 插件管理器
type PluginManager struct {
	mu      sync.RWMutex
	plugins map[string]*ScanPlugin
	types   map[string][]*ScanPlugin // 按类型索引的插件
	ports   map[int][]*ScanPlugin    // 按端口索引的插件
}

// 全局插件管理器实例
var globalPluginManager = NewPluginManager()

// NewPluginManager 创建新的插件管理器
func NewPluginManager() *PluginManager {
	return &PluginManager{
		plugins: make(map[string]*ScanPlugin),
		types:   make(map[string][]*ScanPlugin),
		ports:   make(map[int][]*ScanPlugin),
	}
}

// =============================================================================
// 插件基础方法
// =============================================================================

// HasType 检查插件是否具有指定类型
func (p *ScanPlugin) HasType(typeName string) bool {
	for _, t := range p.Types {
		if t == typeName {
			return true
		}
	}
	return false
}

// HasPort 检查插件是否支持指定端口
func (p *ScanPlugin) HasPort(port int) bool {
	// 如果没有指定端口列表，表示支持所有端口
	if len(p.Ports) == 0 {
		return true
	}

	// 检查端口是否在支持列表中
	for _, supportedPort := range p.Ports {
		if port == supportedPort {
			return true
		}
	}
	return false
}

// IsEnabled 检查插件是否启用
func (p *ScanPlugin) IsEnabled() bool {
	return p.Enabled
}

// GetInfo 获取插件基本信息
func (p *ScanPlugin) GetInfo() map[string]interface{} {
	return map[string]interface{}{
		"name":        p.Name,
		"version":     p.Version,
		"description": p.Description,
		"author":      p.Author,
		"types":       p.Types,
		"ports":       p.Ports,
		"priority":    p.Priority,
		"enabled":     p.Enabled,
	}
}

// =============================================================================
// 插件管理器方法
// =============================================================================

// RegisterPlugin 注册插件
func (pm *PluginManager) RegisterPlugin(plugin *ScanPlugin) error {
	if plugin == nil {
		return fmt.Errorf("plugin cannot be nil")
	}
	if plugin.Name == "" {
		return fmt.Errorf("plugin name cannot be empty")
	}
	if plugin.ScanFunc == nil {
		return fmt.Errorf("plugin scan function cannot be nil")
	}

	pm.mu.Lock()
	defer pm.mu.Unlock()

	// 检查插件是否已存在
	if _, exists := pm.plugins[plugin.Name]; exists {
		return fmt.Errorf("plugin %s already registered", plugin.Name)
	}

	// 注册插件
	pm.plugins[plugin.Name] = plugin

	// 按类型索引
	for _, pluginType := range plugin.Types {
		pm.types[pluginType] = append(pm.types[pluginType], plugin)
	}

	// 按端口索引
	for _, port := range plugin.Ports {
		pm.ports[port] = append(pm.ports[port], plugin)
	}

	return nil
}

// ========================================================================================
// 未使用的插件管理器方法已删除（死代码清理）
// 包括：GetPlugin, GetPluginsByType, GetPluginsByPort, GetAllPlugins,
// EnablePlugin, DisablePlugin, UnregisterPlugin, GetPluginCount, GetEnabledPluginCount
// ========================================================================================

// =============================================================================
// 全局插件管理函数 (保持向后兼容)
// =============================================================================

// RegisterPlugin 注册插件到全局管理器
func RegisterPlugin(name string, plugin ScanPlugin) error {
	// 转换为新的插件结构
	newPlugin := &ScanPlugin{
		Name:     name,
		Ports:    plugin.Ports,
		Types:    plugin.Types,
		Enabled:  true,
		ScanFunc: plugin.ScanFunc,
	}
	
	// 注册到新的插件管理器
	err := globalPluginManager.RegisterPlugin(newPlugin)
	if err != nil {
		return err
	}
	
	// 同时更新Legacy管理器以保持向后兼容
	LegacyPluginManager[name] = plugin
	
	return nil
}

// Clear 清理所有插件（防止内存泄漏）
func (pm *PluginManager) Clear() {
	pm.mu.Lock()
	defer pm.mu.Unlock()
	
	// 清理插件实例
	for name, plugin := range pm.plugins {
		// ScanPlugin结构不包含Cleanup方法，直接删除即可
		_ = plugin // 避免未使用变量警告
		delete(pm.plugins, name)
	}
	
	// 清理索引
	for typeKey := range pm.types {
		delete(pm.types, typeKey)
	}
	for portKey := range pm.ports {
		delete(pm.ports, portKey)
	}
	
	// 清理Legacy管理器
	for k := range LegacyPluginManager {
		delete(LegacyPluginManager, k)
	}
}

// ClearPluginsByType 清理指定类型的插件
func (pm *PluginManager) ClearPluginsByType(pluginType string) {
	pm.mu.Lock()
	defer pm.mu.Unlock()
	
	plugins := pm.types[pluginType]
	for _, plugin := range plugins {
		// ScanPlugin结构不包含Cleanup方法，直接删除即可
		delete(pm.plugins, plugin.Name)
	}
	delete(pm.types, pluginType)
	
	// 同步清理端口索引
	for port, portPlugins := range pm.ports {
		filtered := make([]*ScanPlugin, 0)
		for _, plugin := range portPlugins {
			found := false
			for _, typePlugin := range plugins {
				if plugin == typePlugin {
					found = true
					break
				}
			}
			if !found {
				filtered = append(filtered, plugin)
			}
		}
		if len(filtered) == 0 {
			delete(pm.ports, port)
		} else {
			pm.ports[port] = filtered
		}
	}
}

// GetGlobalPluginManager 方法已删除（死代码清理）

// 向后兼容的全局变量 (已废弃，建议使用PluginManager)
var LegacyPluginManager = make(map[string]ScanPlugin)