Improve

Author: Simple-Tracker

BTN.go

@@ -9,10 +9,14 @@ import (
 	"fmt"
 	"hash/crc32"
 	"math/rand"
+	"net"
+	"strconv"
 	"strings"
+	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/dlclark/regexp2"
 	"github.com/tidwall/jsonc"
 )
 
@@ -80,11 +84,11 @@ type BTN_BanInfo struct {
 }
 
 type BTN_RulesStruct struct {
-	Version    string                 `json:"version"`
-	PeerID     map[string][]RuleEntry `json:"peer_id"`
-	ClientName map[string][]RuleEntry `json:"client_name"`
-	IP         map[string][]string    `json:"ip"`
-	Port       map[string][]string    `json:"port"`
+	Version    string              `json:"version"`
+	PeerID     map[string][]string `json:"peer_id"`
+	ClientName map[string][]string `json:"client_name"`
+	IP         map[string][]string `json:"ip"`
+	Port       map[string][]string `json:"port"`
 }
 
 type RuleEntry struct {
@@ -93,11 +97,11 @@ type RuleEntry struct {
 }
 
 type BTN_ExceptionStruct struct {
-	Version    string                 `json:"version"`
-	PeerID     map[string][]RuleEntry `json:"peer_id"`
-	ClientName map[string][]RuleEntry `json:"client_name"`
-	IP         map[string][]string    `json:"ip"`
-	Port       map[string][]string    `json:"port"`
+	Version    string              `json:"version"`
+	PeerID     map[string][]string `json:"peer_id"`
+	ClientName map[string][]string `json:"client_name"`
+	IP         map[string][]string `json:"ip"`
+	Port       map[string][]string `json:"port"`
 }
 
 var btnProtocol = "BTN-Protocol/3.0.0"
@@ -131,6 +135,124 @@ var btn_isTaskRunning atomic.Bool
 
 var btnRules BTN_RulesStruct
 var btnExceptions BTN_ExceptionStruct
+var btn_regexCache sync.Map // map[string]*regexp2.Regexp
+
+func BTN_MatchEntry(value string, ruleRaw string) bool {
+	var rule RuleEntry
+	if err := json.Unmarshal([]byte(ruleRaw), &rule); err != nil {
+		// 某些规则可能直接是字符串内容 (Legacy).
+		return strings.Contains(value, ruleRaw)
+	}
+
+	switch strings.ToUpper(rule.Method) {
+	case "EQUALS":
+		return value == rule.Content
+	case "STARTS_WITH":
+		return strings.HasPrefix(value, rule.Content)
+	case "ENDS_WITH":
+		return strings.HasSuffix(value, rule.Content)
+	case "CONTAINS":
+		return strings.Contains(value, rule.Content)
+	case "REGEX":
+		var re *regexp2.Regexp
+		if val, ok := btn_regexCache.Load(rule.Content); ok {
+			re = val.(*regexp2.Regexp)
+		} else {
+			var err error
+			re, err = regexp2.Compile(rule.Content, regexp2.IgnoreCase)
+			if err != nil {
+				Log("BTN_MatchEntry", "Invalid regex: %s", true, rule.Content)
+				return false
+			}
+			btn_regexCache.Store(rule.Content, re)
+		}
+		match, _ := re.MatchString(value)
+		return match
+	}
+	return false
+}
+
+func BTN_CheckPeer(peerIP, peerID, peerClient string, peerPort int) (bool, int, string) {
+	if btnConfig == nil {
+		return false, 0, ""
+	}
+
+	ipObj := net.ParseIP(peerIP)
+	peerPortStr := strconv.Itoa(peerPort)
+
+	// 1. 检查例外规则 (WhiteList).
+	for _, rules := range btnExceptions.IP {
+		for _, rule := range rules {
+			_, subnet, err := net.ParseCIDR(rule)
+			if err == nil {
+				if subnet.Contains(ipObj) {
+					return false, 0, ""
+				}
+			} else if rule == peerIP {
+				return false, 0, ""
+			}
+		}
+	}
+	for _, rules := range btnExceptions.Port {
+		for _, rule := range rules {
+			if rule == peerPortStr || rule == "ALL" {
+				return false, 0, ""
+			}
+		}
+	}
+	for _, rules := range btnExceptions.PeerID {
+		for _, rule := range rules {
+			if BTN_MatchEntry(peerID, rule) {
+				return false, 0, ""
+			}
+		}
+	}
+	for _, rules := range btnExceptions.ClientName {
+		for _, rule := range rules {
+			if BTN_MatchEntry(peerClient, rule) {
+				return false, 0, ""
+			}
+		}
+	}
+
+	// 2. 检查封禁规则 (BlockList).
+	// 处理顺序: IP -> Port -> PeerID -> ClientName.
+	for reason, rules := range btnRules.IP {
+		for _, rule := range rules {
+			_, subnet, err := net.ParseCIDR(rule)
+			if err == nil {
+				if subnet.Contains(ipObj) {
+					return true, -1, "Bad-IP_FromBTN (" + reason + ")"
+				}
+			} else if rule == peerIP {
+				return true, -1, "Bad-IP_FromBTN (" + reason + ")"
+			}
+		}
+	}
+	for reason, rules := range btnRules.Port {
+		for _, rule := range rules {
+			if rule == peerPortStr || rule == "ALL" {
+				return true, peerPort, "Bad-IP_FromBTN (" + reason + ")"
+			}
+		}
+	}
+	for reason, rules := range btnRules.PeerID {
+		for _, rule := range rules {
+			if BTN_MatchEntry(peerID, rule) {
+				return true, peerPort, "Bad-IP_FromBTN (" + reason + ")"
+			}
+		}
+	}
+	for reason, rules := range btnRules.ClientName {
+		for _, rule := range rules {
+			if BTN_MatchEntry(peerClient, rule) {
+				return true, peerPort, "Bad-IP_FromBTN (" + reason + ")"
+			}
+		}
+	}
+
+	return false, 0, ""
+}
 
 func BTN_GetConfig() {
 	if config.BTNConfigureURL == "" || (atomic.LoadInt64(&btn_lastGetConfig)+int64(btn_configureInterval)) > atomic.LoadInt64(&currentTimestamp) {

SyncServer.go

@@ -20,14 +20,19 @@ type SyncServer_SubmitStruct struct {
 	TorrentMap map[string]TorrentInfoStruct `json:"torrentMap"`
 }
 
+type SyncServer_RuleStruct struct {
+	Net    *net.IPNet
+	Reason string
+}
+
 var syncServer_isSubmiting atomic.Bool
 var syncServer_lastSync int64 = 0
 var syncServer_syncConfig = SyncServer_ConfigStruct{
 	Interval:    60,
 	Status:      "",
 	BlockIPRule: make(map[string][]string),
 }
-var ipBlockCIDRMapFromSyncServerCompiled = make(map[string]*net.IPNet)
+var syncServer_CompiledRules []SyncServer_RuleStruct
 var ipBlockCIDRMapMutex sync.RWMutex
 
 func SyncWithServer_PrepareJSON(torrentMap map[string]TorrentInfoStruct) (bool, string) {
@@ -64,7 +69,7 @@ func SyncWithServer_Submit(syncJSON string) bool {
 		return false
 	}
 
-	tmpIPBlockCIDRMapFromSyncServerCompiled := make(map[string]*net.IPNet)
+	var tmpSyncServerCompiledRules []SyncServer_RuleStruct
 
 	for reason, ipArr := range syncServer_syncConfig.BlockIPRule {
 		logReason := false
@@ -76,11 +81,6 @@ func SyncWithServer_Submit(syncJSON string) bool {
 				continue
 			}
 
-			if cidr, exists := ipBlockCIDRMapFromSyncServerCompiled[ipBlockListLine]; exists {
-				tmpIPBlockCIDRMapFromSyncServerCompiled[ipBlockListLine] = cidr
-				continue
-			}
-
 			Log("Debug-SyncWithServer_Compile", ":%d %s", false, ipBlockListLineNum, ipBlockListLine)
 			cidr := ParseIPCIDR(ipBlockListLine)
 			if cidr == nil {
@@ -93,18 +93,35 @@ func SyncWithServer_Submit(syncJSON string) bool {
 				Log("SyncWithServer", GetLangText("SyncWithServer_Compile-BlockByReason"), true, reason)
 			}
 
-			tmpIPBlockCIDRMapFromSyncServerCompiled[ipBlockListLine] = cidr
+			tmpSyncServerCompiledRules = append(tmpSyncServerCompiledRules, SyncServer_RuleStruct{Net: cidr, Reason: reason})
 			Log("SyncWithServer_BlockCIDR", ":%d %s", false, ipBlockListLineNum, ipBlockListLine)
 		}
 	}
 
 	ipBlockCIDRMapMutex.Lock()
-	ipBlockCIDRMapFromSyncServerCompiled = tmpIPBlockCIDRMapFromSyncServerCompiled
+	syncServer_CompiledRules = tmpSyncServerCompiledRules
 	ipBlockCIDRMapMutex.Unlock()
 
-	Log("Debug-SyncWithServer", GetLangText("Success-SyncWithServer"), true, len(ipBlockCIDRMapFromSyncServerCompiled))
+	Log("Debug-SyncWithServer", GetLangText("Success-SyncWithServer"), true, len(syncServer_CompiledRules))
 	return true
 }
+
+func SyncServer_CheckPeer(ipObj net.IP) (bool, string) {
+	if ipObj == nil {
+		return false, ""
+	}
+
+	ipBlockCIDRMapMutex.RLock()
+	defer ipBlockCIDRMapMutex.RUnlock()
+
+	for _, rule := range syncServer_CompiledRules {
+		if rule.Net != nil && rule.Net.Contains(ipObj) {
+			return true, "Bad-IP_FromSyncServer (" + rule.Reason + ")"
+		}
+	}
+
+	return false, ""
+}
 func SyncWithServer_FullSubmit(syncJSON string) bool {
 	syncStatus := SyncWithServer_Submit(syncJSON)
 	syncServer_isSubmiting.Store(false)

syncserver_test.go SyncServer_test.gosyncserver_test.go renamed to SyncServer_test.go

@@ -56,12 +56,12 @@ func TestSyncWithServerSubmitCompilesCIDRs(t *testing.T) {
 	oldClientExternal := httpClientExternal
 	oldConfig := config
 	oldSyncConfig := syncServer_syncConfig
-	oldCIDRMap := ipBlockCIDRMapFromSyncServerCompiled
+	oldRules := syncServer_CompiledRules
 	defer func() {
 		httpClientExternal = oldClientExternal
 		config = oldConfig
 		syncServer_syncConfig = oldSyncConfig
-		ipBlockCIDRMapFromSyncServerCompiled = oldCIDRMap
+		syncServer_CompiledRules = oldRules
 	}()
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -84,21 +84,54 @@ func TestSyncWithServerSubmitCompilesCIDRs(t *testing.T) {
 		Status:      "",
 		BlockIPRule: map[string][]string{},
 	}
-	ipBlockCIDRMapFromSyncServerCompiled = map[string]*net.IPNet{}
+	syncServer_CompiledRules = []SyncServer_RuleStruct{}
 
 	if !SyncWithServer_Submit(`{"dummy":true}`) {
 		t.Fatal("SyncWithServer_Submit should succeed")
 	}
 	if syncServer_syncConfig.Interval != 90 {
 		t.Fatalf("Interval=%d, want 90", syncServer_syncConfig.Interval)
 	}
-	if len(ipBlockCIDRMapFromSyncServerCompiled) != 2 {
-		t.Fatalf("compiled CIDR count=%d, want 2", len(ipBlockCIDRMapFromSyncServerCompiled))
+	if len(syncServer_CompiledRules) != 2 {
+		t.Fatalf("compiled Rule count=%d, want 2", len(syncServer_CompiledRules))
 	}
-	if _, ok := ipBlockCIDRMapFromSyncServerCompiled["1.2.3.4"]; !ok {
-		t.Fatal("compiled CIDRs should contain IPv4 entry")
+
+	foundIPv4 := false
+	foundIPv6 := false
+	for _, rule := range syncServer_CompiledRules {
+		if rule.Net.String() == "1.2.3.4/32" {
+			foundIPv4 = true
+		}
+		if rule.Net.String() == "2001:db8::/64" {
+			foundIPv6 = true
+		}
+	}
+	if !foundIPv4 {
+		t.Fatal("compiled Rules should contain IPv4 entry")
+	}
+	if !foundIPv6 {
+		t.Fatal("compiled Rules should contain IPv6 entry")
+	}
+}
+
+func TestSyncServerCheckPeer(t *testing.T) {
+	oldRules := syncServer_CompiledRules
+	defer func() {
+		syncServer_CompiledRules = oldRules
+	}()
+
+	_, subnet, _ := net.ParseCIDR("10.0.0.0/24")
+	syncServer_CompiledRules = []SyncServer_RuleStruct{
+		{Net: subnet, Reason: "local-network"},
 	}
-	if _, ok := ipBlockCIDRMapFromSyncServerCompiled["2001:db8::/64"]; !ok {
-		t.Fatal("compiled CIDRs should contain IPv6 entry")
+
+	ok, reason := SyncServer_CheckPeer(net.ParseIP("10.0.0.5"))
+	if !ok || reason != "Bad-IP_FromSyncServer (local-network)" {
+		t.Fatalf("SyncServer_CheckPeer(10.0.0.5) = (%v, %q), want (true, \"Bad-IP_FromSyncServer (local-network)\")", ok, reason)
+	}
+
+	ok, _ = SyncServer_CheckPeer(net.ParseIP("10.0.1.5"))
+	if ok {
+		t.Fatal("SyncServer_CheckPeer(10.0.1.5) should be false")
 	}
 }

console.go

@@ -258,7 +258,7 @@ func Task() {
 			return true
 		})
 
-		if !config.IPUploadedCheck && iblcLen <= 0 && len(ipBlockCIDRMapFromSyncServerCompiled) <= 0 {
+		if !config.IPUploadedCheck && iblcLen <= 0 && len(syncServer_CompiledRules) <= 0 {
 			Log("Task", GetLangText("Task_BanInfo"), true, blockCount, len(blockPeerMap))
 		} else {
 			Log("Task", GetLangText("Task_BanInfoWithIP"), true, blockCount, ipBlockCount, len(blockPeerMap))