fscan/Common/config/ServiceDict.go

package config

import (
	"strings"
	"sync"
)

// ServiceDictionary 服务字典管理器
type ServiceDictionary struct {
	mu          sync.RWMutex
	userDict    map[string][]string
	passwords   []string
	initialized bool
}

// NewServiceDictionary 创建服务字典管理器
func NewServiceDictionary() *ServiceDictionary {
	return &ServiceDictionary{
		userDict:    getDefaultUserDict(),
		passwords:   getDefaultPasswords(),
		initialized: true,
	}
}

// getDefaultUserDict 获取默认用户字典
func getDefaultUserDict() map[string][]string {
	return map[string][]string{
		"ftp":        {"ftp", "admin", "www", "web", "root", "db", "wwwroot", "data"},
		"mysql":      {"root", "mysql"},
		"mssql":      {"sa", "sql"},
		"smb":        {"administrator", "admin", "guest"},
		"rdp":        {"administrator", "admin", "guest"},
		"postgresql": {"postgres", "admin"},
		"ssh":        {"root", "admin"},
		"mongodb":    {"root", "admin"},
		"oracle":     {"sys", "system", "admin", "test", "web", "orcl"},
		"telnet":     {"root", "admin", "test"},
		"elastic":    {"elastic", "admin", "kibana"},
		"rabbitmq":   {"guest", "admin", "administrator", "rabbit", "rabbitmq", "root"},
		"kafka":      {"admin", "kafka", "root", "test"},
		"activemq":   {"admin", "root", "activemq", "system", "user"},
		"ldap":       {"admin", "administrator", "root", "cn=admin", "cn=administrator", "cn=manager"},
		"smtp":       {"admin", "root", "postmaster", "mail", "smtp", "administrator"},
		"imap":       {"admin", "mail", "postmaster", "root", "user", "test"},
		"pop3":       {"admin", "root", "mail", "user", "test", "postmaster"},
		"zabbix":     {"Admin", "admin", "guest", "user"},
		"rsync":      {"rsync", "root", "admin", "backup"},
		"cassandra":  {"cassandra", "admin", "root", "system"},
		"neo4j":      {"neo4j", "admin", "root", "test"},
	}
}

// getDefaultPasswords 获取默认密码字典
func getDefaultPasswords() []string {
	return []string{
		"123456", "admin", "admin123", "root", "", "pass123", "pass@123",
		"password", "Password", "P@ssword123", "123123", "654321", "111111",
		"123", "1", "admin@123", "Admin@123", "admin123!@#", "{user}",
		"{user}1", "{user}111", "{user}123", "{user}@123", "{user}_123",
		"{user}#123", "{user}@111", "{user}@2019", "{user}@123#4",
		"P@ssw0rd!", "P@ssw0rd", "Passw0rd", "qwe123", "12345678", "test",
		"test123", "123qwe", "123qwe!@#", "123456789", "123321", "666666",
		"a123456.", "123456~a", "123456!a", "000000", "1234567890", "8888888",
		"!QAZ2wsx", "1qaz2wsx", "abc123", "abc123456", "1qaz@WSX", "a11111",
		"a12345", "Aa1234", "Aa1234.", "Aa12345", "a123456", "a123123",
		"Aa123123", "Aa123456", "Aa12345.", "sysadmin", "system", "1qaz!QAZ",
		"2wsx@WSX", "qwe123!@#", "Aa123456!", "A123456s!", "sa123456",
		"1q2w3e", "Charge123", "Aa123456789", "elastic123",
	}
}

// GetUserDict 获取指定服务的用户字典
func (sd *ServiceDictionary) GetUserDict(service string) []string {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	service = strings.ToLower(service)
	if users, exists := sd.userDict[service]; exists {
		// 返回副本，避免外部修改
		result := make([]string, len(users))
		copy(result, users)
		return result
	}

	// 返回默认的通用用户名
	return []string{"admin", "root", "test", "user"}
}

// SetUserDict 设置指定服务的用户字典
func (sd *ServiceDictionary) SetUserDict(service string, users []string) {
	sd.mu.Lock()
	defer sd.mu.Unlock()

	service = strings.ToLower(service)
	if len(users) > 0 {
		// 创建副本，避免外部修改影响内部数据
		usersCopy := make([]string, len(users))
		copy(usersCopy, users)
		sd.userDict[service] = usersCopy
	}
}

// AddUsersToService 向指定服务添加用户名
func (sd *ServiceDictionary) AddUsersToService(service string, users []string) {
	sd.mu.Lock()
	defer sd.mu.Unlock()

	service = strings.ToLower(service)
	if existing, exists := sd.userDict[service]; exists {
		// 合并并去重
		userSet := make(map[string]struct{})
		for _, user := range existing {
			userSet[user] = struct{}{}
		}
		for _, user := range users {
			if user != "" {
				userSet[user] = struct{}{}
			}
		}

		// 转换回切片
		result := make([]string, 0, len(userSet))
		for user := range userSet {
			result = append(result, user)
		}
		sd.userDict[service] = result
	} else {
		// 新服务，直接设置
		sd.SetUserDict(service, users)
	}
}

// GetAllUserDicts 获取所有服务的用户字典
func (sd *ServiceDictionary) GetAllUserDicts() map[string][]string {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	result := make(map[string][]string)
	for service, users := range sd.userDict {
		usersCopy := make([]string, len(users))
		copy(usersCopy, users)
		result[service] = usersCopy
	}
	return result
}

// GetPasswords 获取默认密码字典
func (sd *ServiceDictionary) GetPasswords() []string {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	// 返回副本，避免外部修改
	result := make([]string, len(sd.passwords))
	copy(result, sd.passwords)
	return result
}

// SetPasswords 设置密码字典
func (sd *ServiceDictionary) SetPasswords(passwords []string) {
	sd.mu.Lock()
	defer sd.mu.Unlock()

	if len(passwords) > 0 {
		// 创建副本
		passwordsCopy := make([]string, len(passwords))
		copy(passwordsCopy, passwords)
		sd.passwords = passwordsCopy
	}
}

// AddPasswords 添加密码到字典
func (sd *ServiceDictionary) AddPasswords(passwords []string) {
	sd.mu.Lock()
	defer sd.mu.Unlock()

	// 使用map去重
	passwordSet := make(map[string]struct{})
	for _, pwd := range sd.passwords {
		passwordSet[pwd] = struct{}{}
	}

	for _, pwd := range passwords {
		if pwd != "" {
			passwordSet[pwd] = struct{}{}
		}
	}

	// 转换回切片
	result := make([]string, 0, len(passwordSet))
	for pwd := range passwordSet {
		result = append(result, pwd)
	}
	sd.passwords = result
}

// GetServiceNames 获取所有支持的服务名称
func (sd *ServiceDictionary) GetServiceNames() []string {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	services := make([]string, 0, len(sd.userDict))
	for service := range sd.userDict {
		services = append(services, service)
	}
	return services
}

// HasService 检查是否支持指定服务
func (sd *ServiceDictionary) HasService(service string) bool {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	_, exists := sd.userDict[strings.ToLower(service)]
	return exists
}

// GetUserCount 获取指定服务的用户数量
func (sd *ServiceDictionary) GetUserCount(service string) int {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	if users, exists := sd.userDict[strings.ToLower(service)]; exists {
		return len(users)
	}
	return 0
}

// GetPasswordCount 获取密码数量
func (sd *ServiceDictionary) GetPasswordCount() int {
	sd.mu.RLock()
	defer sd.mu.RUnlock()

	return len(sd.passwords)
}

// ResetToDefaults 重置为默认配置
func (sd *ServiceDictionary) ResetToDefaults() {
	sd.mu.Lock()
	defer sd.mu.Unlock()

	sd.userDict = getDefaultUserDict()
	sd.passwords = getDefaultPasswords()
}

// 全局服务字典实例
var (
	globalServiceDict *ServiceDictionary
	serviceDictOnce   sync.Once
)

// GetGlobalServiceDict 获取全局服务字典实例
func GetGlobalServiceDict() *ServiceDictionary {
	serviceDictOnce.Do(func() {
		globalServiceDict = NewServiceDictionary()
	})
	return globalServiceDict
}