black-internet-days-ahead/sing-box
1
0
Fork 0
mirror of https://github.com/SagerNet/sing-box.git synced 2024-11-22 00:21:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix decompile rule-set

Browse source
This commit is contained in:
世界 2024-11-11 16:27:28 +08:00
parent 84a102a6ef
commit e3e203844e
No known key found for this signature in database
GPG key ID: CD109927C34A63C4
9 changed files with 49 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
cmd/sing-box/cmd_rule_set_compile.go
View file

@ -6,7 +6,6 @@ import (
"strings" "strings"
"github.com/sagernet/sing-box/common/srs" "github.com/sagernet/sing-box/common/srs"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log" "github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option" "github.com/sagernet/sing-box/option"
"github.com/sagernet/sing/common/json" "github.com/sagernet/sing/common/json"
@ -56,10 +55,6 @@ func compileRuleSet(sourcePath string) error {
if err != nil { if err != nil {
return err return err
} }
ruleSet, err := plainRuleSet.Upgrade()
if err != nil {
return err
}
var outputPath string var outputPath string
if flagRuleSetCompileOutput == flagRuleSetCompileDefaultOutput { if flagRuleSetCompileOutput == flagRuleSetCompileDefaultOutput {
if strings.HasSuffix(sourcePath, ".json") { if strings.HasSuffix(sourcePath, ".json") {
@ -74,7 +69,7 @@ func compileRuleSet(sourcePath string) error {
if err != nil { if err != nil {
return err return err
} }
err = srs.Write(outputFile, ruleSet, plainRuleSet.Version == C.RuleSetVersion2) err = srs.Write(outputFile, plainRuleSet.Options, plainRuleSet.Version)
if err != nil { if err != nil {
outputFile.Close() outputFile.Close()
os.Remove(outputPath) os.Remove(outputPath)

3
cmd/sing-box/cmd_rule_set_convert.go
View file

@ -7,6 +7,7 @@ import (
"github.com/sagernet/sing-box/cmd/sing-box/internal/convertor/adguard" "github.com/sagernet/sing-box/cmd/sing-box/internal/convertor/adguard"
"github.com/sagernet/sing-box/common/srs" "github.com/sagernet/sing-box/common/srs"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log" "github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option" "github.com/sagernet/sing-box/option"
E "github.com/sagernet/sing/common/exceptions" E "github.com/sagernet/sing/common/exceptions"
@ -77,7 +78,7 @@ func convertRuleSet(sourcePath string) error {
return err return err
} }
defer outputFile.Close() defer outputFile.Close()
err = srs.Write(outputFile, option.PlainRuleSet{Rules: rules}, true) err = srs.Write(outputFile, option.PlainRuleSet{Rules: rules}, C.RuleSetVersion2)
if err != nil { if err != nil {
outputFile.Close() outputFile.Close()
os.Remove(outputPath) os.Remove(outputPath)

8
cmd/sing-box/cmd_rule_set_decompile.go
View file

@ -6,9 +6,7 @@ import (
"strings" "strings"
"github.com/sagernet/sing-box/common/srs" "github.com/sagernet/sing-box/common/srs"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log" "github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing/common/json" "github.com/sagernet/sing/common/json"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -48,14 +46,10 @@ func decompileRuleSet(sourcePath string) error {
return err return err
} }
} }
plainRuleSet, err := srs.Read(reader, true) ruleSet, err := srs.Read(reader, true)
if err != nil { if err != nil {
return err return err
} }
ruleSet := option.PlainRuleSetCompat{
Version: C.RuleSetVersion1,
Options: plainRuleSet,
}
var outputPath string var outputPath string
if flagRuleSetDecompileOutput == flagRuleSetDecompileDefaultOutput { if flagRuleSetDecompileOutput == flagRuleSetDecompileDefaultOutput {
if strings.HasSuffix(sourcePath, ".srs") { if strings.HasSuffix(sourcePath, ".srs") {

15
cmd/sing-box/cmd_rule_set_match.go
View file

@ -55,26 +55,25 @@ func ruleSetMatch(sourcePath string, domain string) error {
if err != nil { if err != nil {
return E.Cause(err, "read rule-set") return E.Cause(err, "read rule-set")
} }
var plainRuleSet option.PlainRuleSet var ruleSet option.PlainRuleSetCompat
switch flagRuleSetMatchFormat { switch flagRuleSetMatchFormat {
case C.RuleSetFormatSource: case C.RuleSetFormatSource:
var compat option.PlainRuleSetCompat ruleSet, err = json.UnmarshalExtended[option.PlainRuleSetCompat](content)
compat, err = json.UnmarshalExtended[option.PlainRuleSetCompat](content)
if err != nil {
return err
}
plainRuleSet, err = compat.Upgrade()
if err != nil { if err != nil {
return err return err
} }
case C.RuleSetFormatBinary: case C.RuleSetFormatBinary:
plainRuleSet, err = srs.Read(bytes.NewReader(content), false) ruleSet, err = srs.Read(bytes.NewReader(content), false)
if err != nil { if err != nil {
return err return err
} }
default: default:
return E.New("unknown rule-set format: ", flagRuleSetMatchFormat) return E.New("unknown rule-set format: ", flagRuleSetMatchFormat)
} }
plainRuleSet, err := ruleSet.Upgrade()
if err != nil {
return err
}
ipAddress := M.ParseAddr(domain) ipAddress := M.ParseAddr(domain)
var metadata adapter.InboundContext var metadata adapter.InboundContext
if ipAddress.IsValid() { if ipAddress.IsValid() {

42
common/srs/binary.go
View file

@ -41,7 +41,7 @@ const (
ruleItemFinal uint8 = 0xFF ruleItemFinal uint8 = 0xFF
) )
func Read(reader io.Reader, recover bool) (ruleSet option.PlainRuleSet, err error) { func Read(reader io.Reader, recover bool) (ruleSetCompat option.PlainRuleSetCompat, err error) {
var magicBytes [3]byte var magicBytes [3]byte
_, err = io.ReadFull(reader, magicBytes[:]) _, err = io.ReadFull(reader, magicBytes[:])
if err != nil { if err != nil {
@ -54,10 +54,10 @@ func Read(reader io.Reader, recover bool) (ruleSet option.PlainRuleSet, err erro
var version uint8 var version uint8
err = binary.Read(reader, binary.BigEndian, &version) err = binary.Read(reader, binary.BigEndian, &version)
if err != nil { if err != nil {
return ruleSet, err return ruleSetCompat, err
} }
if version > C.RuleSetVersion2 { if version > C.RuleSetVersionCurrent {
return ruleSet, E.New("unsupported version: ", version) return ruleSetCompat, E.New("unsupported version: ", version)
} }
compressReader, err := zlib.NewReader(reader) compressReader, err := zlib.NewReader(reader)
if err != nil { if err != nil {
@ -68,9 +68,10 @@ func Read(reader io.Reader, recover bool) (ruleSet option.PlainRuleSet, err erro
if err != nil { if err != nil {
return return
} }
ruleSet.Rules = make([]option.HeadlessRule, length) ruleSetCompat.Version = version
ruleSetCompat.Options.Rules = make([]option.HeadlessRule, length)
for i := uint64(0); i < length; i++ { for i := uint64(0); i < length; i++ {
ruleSet.Rules[i], err = readRule(bReader, recover) ruleSetCompat.Options.Rules[i], err = readRule(bReader, recover)
if err != nil { if err != nil {
err = E.Cause(err, "read rule[", i, "]") err = E.Cause(err, "read rule[", i, "]")
return return
@ -79,18 +80,12 @@ func Read(reader io.Reader, recover bool) (ruleSet option.PlainRuleSet, err erro
return return
} }
func Write(writer io.Writer, ruleSet option.PlainRuleSet, generateUnstable bool) error { func Write(writer io.Writer, ruleSet option.PlainRuleSet, generateVersion uint8) error {
_, err := writer.Write(MagicBytes[:]) _, err := writer.Write(MagicBytes[:])
if err != nil { if err != nil {
return err return err
} }
var version uint8 err = binary.Write(writer, binary.BigEndian, generateVersion)
if generateUnstable {
version = C.RuleSetVersion2
} else {
version = C.RuleSetVersion1
}
err = binary.Write(writer, binary.BigEndian, version)
if err != nil { if err != nil {
return err return err
} }
@ -104,7 +99,7 @@ func Write(writer io.Writer, ruleSet option.PlainRuleSet, generateUnstable bool)
return err return err
} }
for _, rule := range ruleSet.Rules { for _, rule := range ruleSet.Rules {
err = writeRule(bWriter, rule, generateUnstable) err = writeRule(bWriter, rule, generateVersion)
if err != nil { if err != nil {
return err return err
} }
@ -135,12 +130,12 @@ func readRule(reader varbin.Reader, recover bool) (rule option.HeadlessRule, err
return return
} }
func writeRule(writer varbin.Writer, rule option.HeadlessRule, generateUnstable bool) error { func writeRule(writer varbin.Writer, rule option.HeadlessRule, generateVersion uint8) error {
switch rule.Type { switch rule.Type {
case C.RuleTypeDefault: case C.RuleTypeDefault:
return writeDefaultRule(writer, rule.DefaultOptions, generateUnstable) return writeDefaultRule(writer, rule.DefaultOptions, generateVersion)
case C.RuleTypeLogical: case C.RuleTypeLogical:
return writeLogicalRule(writer, rule.LogicalOptions, generateUnstable) return writeLogicalRule(writer, rule.LogicalOptions, generateVersion)
default: default:
panic("unknown rule type: " + rule.Type) panic("unknown rule type: " + rule.Type)
} }
@ -240,7 +235,7 @@ func readDefaultRule(reader varbin.Reader, recover bool) (rule option.DefaultHea
} }
} }
func writeDefaultRule(writer varbin.Writer, rule option.DefaultHeadlessRule, generateUnstable bool) error { func writeDefaultRule(writer varbin.Writer, rule option.DefaultHeadlessRule, generateVersion uint8) error {
err := binary.Write(writer, binary.BigEndian, uint8(0)) err := binary.Write(writer, binary.BigEndian, uint8(0))
if err != nil { if err != nil {
return err return err
@ -264,7 +259,7 @@ func writeDefaultRule(writer varbin.Writer, rule option.DefaultHeadlessRule, gen
if err != nil { if err != nil {
return err return err
} }
err = domain.NewMatcher(rule.Domain, rule.DomainSuffix, !generateUnstable).Write(writer) err = domain.NewMatcher(rule.Domain, rule.DomainSuffix, generateVersion == C.RuleSetVersion1).Write(writer)
if err != nil { if err != nil {
return err return err
} }
@ -354,6 +349,9 @@ func writeDefaultRule(writer varbin.Writer, rule option.DefaultHeadlessRule, gen
} }
} }
if len(rule.AdGuardDomain) > 0 { if len(rule.AdGuardDomain) > 0 {
if generateVersion < C.RuleSetVersion2 {
return E.New("AdGuard rule items is only supported in version 2 or later")
}
err = binary.Write(writer, binary.BigEndian, ruleItemAdGuardDomain) err = binary.Write(writer, binary.BigEndian, ruleItemAdGuardDomain)
if err != nil { if err != nil {
return err return err
@ -457,7 +455,7 @@ func readLogicalRule(reader varbin.Reader, recovery bool) (logicalRule option.Lo
return return
} }
func writeLogicalRule(writer varbin.Writer, logicalRule option.LogicalHeadlessRule, generateUnstable bool) error { func writeLogicalRule(writer varbin.Writer, logicalRule option.LogicalHeadlessRule, generateVersion uint8) error {
err := binary.Write(writer, binary.BigEndian, uint8(1)) err := binary.Write(writer, binary.BigEndian, uint8(1))
if err != nil { if err != nil {
return err return err
@ -478,7 +476,7 @@ func writeLogicalRule(writer varbin.Writer, logicalRule option.LogicalHeadlessRu
return err return err
} }
for _, rule := range logicalRule.Rules { for _, rule := range logicalRule.Rules {
err = writeRule(writer, rule, generateUnstable) err = writeRule(writer, rule, generateVersion)
if err != nil { if err != nil {
return err return err
} }

1
constant/rule.go
View file

@ -21,4 +21,5 @@ const (
const ( const (
RuleSetVersion1 = 1 + iota RuleSetVersion1 = 1 + iota
RuleSetVersion2 RuleSetVersion2
RuleSetVersionCurrent = RuleSetVersion2
) )

2
option/rule_set.go
View file

@ -189,7 +189,7 @@ func (r LogicalHeadlessRule) IsValid() bool {
} }
type _PlainRuleSetCompat struct { type _PlainRuleSetCompat struct {
Version int `json:"version"` Version uint8 `json:"version"`
Options PlainRuleSet `json:"-"` Options PlainRuleSet `json:"-"`
} }

15
route/rule_set_local.go
View file

@ -95,33 +95,34 @@ func (s *LocalRuleSet) StartContext(ctx context.Context, startContext *adapter.H
} }
func (s *LocalRuleSet) reloadFile(path string) error { func (s *LocalRuleSet) reloadFile(path string) error {
var plainRuleSet option.PlainRuleSet var ruleSet option.PlainRuleSetCompat
switch s.fileFormat { switch s.fileFormat {
case C.RuleSetFormatSource, "": case C.RuleSetFormatSource, "":
content, err := os.ReadFile(path) content, err := os.ReadFile(path)
if err != nil { if err != nil {
return err return err
} }
compat, err := json.UnmarshalExtended[option.PlainRuleSetCompat](content) ruleSet, err = json.UnmarshalExtended[option.PlainRuleSetCompat](content)
if err != nil {
return err
}
plainRuleSet, err = compat.Upgrade()
if err != nil { if err != nil {
return err return err
} }
case C.RuleSetFormatBinary: case C.RuleSetFormatBinary:
setFile, err := os.Open(path) setFile, err := os.Open(path)
if err != nil { if err != nil {
return err return err
} }
plainRuleSet, err = srs.Read(setFile, false) ruleSet, err = srs.Read(setFile, false)
if err != nil { if err != nil {
return err return err
} }
default: default:
return E.New("unknown rule-set format: ", s.fileFormat) return E.New("unknown rule-set format: ", s.fileFormat)
} }
plainRuleSet, err := ruleSet.Upgrade()
if err != nil {
return err
}
return s.reloadRules(plainRuleSet.Rules) return s.reloadRules(plainRuleSet.Rules)
} }

17
route/rule_set_remote.go
View file

@ -159,28 +159,27 @@ func (s *RemoteRuleSet) UnregisterCallback(element *list.Element[adapter.RuleSet
func (s *RemoteRuleSet) loadBytes(content []byte) error { func (s *RemoteRuleSet) loadBytes(content []byte) error {
var ( var (
plainRuleSet option.PlainRuleSet ruleSet option.PlainRuleSetCompat
err error err error
) )
switch s.options.Format { switch s.options.Format {
case C.RuleSetFormatSource: case C.RuleSetFormatSource:
var compat option.PlainRuleSetCompat ruleSet, err = json.UnmarshalExtended[option.PlainRuleSetCompat](content)
compat, err = json.UnmarshalExtended[option.PlainRuleSetCompat](content)
if err != nil {
return err
}
plainRuleSet, err = compat.Upgrade()
if err != nil { if err != nil {
return err return err
} }
case C.RuleSetFormatBinary: case C.RuleSetFormatBinary:
plainRuleSet, err = srs.Read(bytes.NewReader(content), false) ruleSet, err = srs.Read(bytes.NewReader(content), false)
if err != nil { if err != nil {
return err return err
} }
default: default:
return E.New("unknown rule-set format: ", s.options.Format) return E.New("unknown rule-set format: ", s.options.Format)
} }
plainRuleSet, err := ruleSet.Upgrade()
if err != nil {
return err
}
rules := make([]adapter.HeadlessRule, len(plainRuleSet.Rules)) rules := make([]adapter.HeadlessRule, len(plainRuleSet.Rules))
for i, ruleOptions := range plainRuleSet.Rules { for i, ruleOptions := range plainRuleSet.Rules {
rules[i], err = NewHeadlessRule(s.router, ruleOptions) rules[i], err = NewHeadlessRule(s.router, ruleOptions)