mirror of
https://github.com/v2rayA/v2rayA.git
synced 2026-11-20 23:02:25 +03:00
Merge pull request #2052 from Zakkaus/iptables-ipset
fix(iptables): match the transparent-proxy whitelist with ipset
This commit is contained in:
7 files changed
+526
-43
No files matched your search
@@ -12,6 +12,16 @@ func IsCommandValid(command string) bool {
|
||||
return err == nil
|
||||
}
|
||||
|
||||
func ExecCommandWithInput(command string, args []string, input string) error {
|
||||
cmd := exec.Command(command, args...)
|
||||
cmd.Stdin = strings.NewReader(input)
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
return fmt.Errorf("ExecCommandWithInput: %s %s: %s: %w", command, strings.Join(args, " "), out, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ExecCommands(commands string, stopWhenError bool) error {
|
||||
lines := strings.Split(commands, "\n")
|
||||
var e error
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
package cmds
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestExecCommandWithInput(t *testing.T) {
|
||||
output := filepath.Join(t.TempDir(), "stdin")
|
||||
err := ExecCommandWithInput("sh", []string{"-c", `IFS= read -r value; printf %s "$value" > "$1"`, "sh", output}, "payload\n")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got, err := os.ReadFile(output)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(got) != "payload" {
|
||||
t.Fatalf("stdin payload = %q, want payload", got)
|
||||
}
|
||||
}
|
||||
@@ -13,13 +13,19 @@ import (
|
||||
|
||||
const watcherInterval = 3 * time.Second
|
||||
|
||||
var watcher *LocalIPWatcher
|
||||
var mutex sync.Mutex
|
||||
var (
|
||||
watcher *LocalIPWatcher
|
||||
mutex sync.Mutex
|
||||
commandAvailable = cmds.IsCommandValid
|
||||
executeCommands = cmds.ExecCommands
|
||||
executeCommandWithInput = cmds.ExecCommandWithInput
|
||||
)
|
||||
|
||||
type Setter struct {
|
||||
Cmds string
|
||||
AfterFunc func() error
|
||||
PreFunc func() error
|
||||
steps []setterStep
|
||||
}
|
||||
|
||||
func NewErrorSetter(err error) Setter {
|
||||
@@ -53,15 +59,26 @@ func CloseWatcher() {
|
||||
func (c Setter) Run(stopAtError bool) error {
|
||||
mutex.Lock()
|
||||
defer mutex.Unlock()
|
||||
commands := c.Cmds
|
||||
return c.run(stopAtError, rewriteIptablesCommands)
|
||||
}
|
||||
|
||||
func rewriteIptablesCommands(commands string) string {
|
||||
if common.IsDocker() {
|
||||
commands = strings.ReplaceAll(commands, "iptables", "iptables-legacy")
|
||||
commands = strings.ReplaceAll(commands, "ip6tables", "ip6tables-legacy")
|
||||
} else if (!cmds.IsCommandValid("iptables") || IsNftablesSupported()) &&
|
||||
cmds.IsCommandValid("iptables-nft") {
|
||||
commands = strings.ReplaceAll(commands, "iptables", "iptables-nft")
|
||||
commands = strings.ReplaceAll(commands, "ip6tables", "ip6tables-nft")
|
||||
return rewriteIptablesBinaries(commands, "legacy")
|
||||
}
|
||||
if (!commandAvailable("iptables") || IsNftablesSupported()) &&
|
||||
commandAvailable("iptables-nft") {
|
||||
return rewriteIptablesBinaries(commands, "nft")
|
||||
}
|
||||
return commands
|
||||
}
|
||||
|
||||
func rewriteIptablesBinaries(commands, variant string) string {
|
||||
commands = strings.ReplaceAll(commands, "iptables", "iptables-"+variant)
|
||||
return strings.ReplaceAll(commands, "ip6tables", "ip6tables-"+variant)
|
||||
}
|
||||
|
||||
func (c Setter) run(stopAtError bool, rewrite func(string) string) error {
|
||||
var errs []error
|
||||
if c.PreFunc != nil {
|
||||
e := c.PreFunc()
|
||||
@@ -72,11 +89,26 @@ func (c Setter) Run(stopAtError bool) error {
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(commands) > 0 {
|
||||
e := cmds.ExecCommands(commands, stopAtError)
|
||||
if len(c.steps) > 0 {
|
||||
for _, step := range c.steps {
|
||||
var e error
|
||||
if step.whitelist != nil {
|
||||
e = step.whitelist.run(stopAtError, rewrite)
|
||||
} else if len(step.commands) > 0 {
|
||||
e = executeCommands(rewrite(step.commands), stopAtError)
|
||||
}
|
||||
if e != nil {
|
||||
errs = append(errs, e)
|
||||
if stopAtError {
|
||||
return errs[0]
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if len(c.Cmds) > 0 {
|
||||
e := executeCommands(rewrite(c.Cmds), stopAtError)
|
||||
if e != nil {
|
||||
errs = append(errs, e)
|
||||
if stopAtError && len(errs) > 0 {
|
||||
if stopAtError {
|
||||
return errs[0]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
package iptables
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/v2rayA/v2rayA/pkg/util/log"
|
||||
)
|
||||
|
||||
const (
|
||||
legacyWhitelist4Marker = "__V2RAYA_WHITE4__"
|
||||
legacyWhitelist6Marker = "__V2RAYA_WHITE6__"
|
||||
)
|
||||
|
||||
var (
|
||||
legacySetupValues = getTproxySetupValues
|
||||
legacyIPv6Supported = IsIPv6Supported
|
||||
)
|
||||
|
||||
type setterStep struct {
|
||||
commands string
|
||||
whitelist *legacyWhitelist
|
||||
}
|
||||
|
||||
type legacyWhitelist struct {
|
||||
binary string
|
||||
table string
|
||||
setName string
|
||||
family string
|
||||
cidrs []string
|
||||
warnOnce *sync.Once
|
||||
}
|
||||
|
||||
func newLegacyWhitelistSetter(commands, table string, ipv4, ipv6 []string) Setter {
|
||||
warnOnce := &sync.Once{}
|
||||
families := []struct {
|
||||
marker string
|
||||
binary string
|
||||
setName string
|
||||
setFamily string
|
||||
cidrs []string
|
||||
}{
|
||||
{legacyWhitelist4Marker, "iptables", "v2raya_white4", "inet", ipv4},
|
||||
{legacyWhitelist6Marker, "ip6tables", "v2raya_white6", "inet6", ipv6},
|
||||
}
|
||||
var steps []setterStep
|
||||
for _, family := range families {
|
||||
before, after, found := strings.Cut(commands, family.marker)
|
||||
if !found {
|
||||
continue
|
||||
}
|
||||
steps = append(steps, setterStep{commands: before})
|
||||
if len(family.cidrs) > 0 {
|
||||
steps = append(steps, setterStep{whitelist: &legacyWhitelist{
|
||||
binary: family.binary,
|
||||
table: table,
|
||||
setName: family.setName,
|
||||
family: family.setFamily,
|
||||
cidrs: family.cidrs,
|
||||
warnOnce: warnOnce,
|
||||
}})
|
||||
}
|
||||
commands = after
|
||||
}
|
||||
steps = append(steps, setterStep{commands: commands})
|
||||
return Setter{steps: steps}
|
||||
}
|
||||
|
||||
func (w *legacyWhitelist) run(stopAtError bool, rewrite func(string) string) error {
|
||||
if commandAvailable("ipset") {
|
||||
if err := executeCommandWithInput("ipset", []string{"restore", "-!"}, w.ipsetPayload()); err == nil {
|
||||
args := []string{"-w", "2", "-t", w.table, "-A", "TP_RULE", "-m", "set", "--match-set", w.setName, "dst", "-j", "RETURN"}
|
||||
if err := executeCommandWithInput(rewrite(w.binary), args, ""); err == nil {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
_ = executeCommandWithInput("ipset", []string{"destroy", w.setName}, "")
|
||||
}
|
||||
|
||||
w.warnOnce.Do(func() {
|
||||
log.Warn("transparent proxy IP whitelist matching remains linear; install ipset with xt_set support or use nftables")
|
||||
})
|
||||
restore := rewrite(w.binary + "-restore")
|
||||
if commandAvailable(restore) {
|
||||
if err := executeCommandWithInput(restore, []string{"-w", "2", "--noflush"}, w.restorePayload()); err == nil {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return executeCommands(rewrite(w.perLineCommands()), stopAtError)
|
||||
}
|
||||
|
||||
func (w *legacyWhitelist) ipsetPayload() string {
|
||||
var payload strings.Builder
|
||||
fmt.Fprintf(&payload, "create %s hash:net family %s maxelem 65536\n", w.setName, w.family)
|
||||
fmt.Fprintf(&payload, "flush %s\n", w.setName)
|
||||
for _, cidr := range w.cidrs {
|
||||
fmt.Fprintf(&payload, "add %s %s\n", w.setName, cidr)
|
||||
}
|
||||
return payload.String()
|
||||
}
|
||||
|
||||
func (w *legacyWhitelist) restorePayload() string {
|
||||
var payload strings.Builder
|
||||
fmt.Fprintf(&payload, "*%s\n", w.table)
|
||||
for _, cidr := range w.cidrs {
|
||||
fmt.Fprintf(&payload, "-A TP_RULE -d %s -j RETURN\n", cidr)
|
||||
}
|
||||
payload.WriteString("COMMIT\n")
|
||||
return payload.String()
|
||||
}
|
||||
|
||||
func (w *legacyWhitelist) perLineCommands() string {
|
||||
var commands strings.Builder
|
||||
for _, cidr := range w.cidrs {
|
||||
fmt.Fprintf(&commands, "%s -w 2 -t %s -A TP_RULE -d %s -j RETURN\n", w.binary, w.table, cidr)
|
||||
}
|
||||
return commands.String()
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
package iptables
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type recordedCommand struct {
|
||||
name string
|
||||
args []string
|
||||
input string
|
||||
}
|
||||
|
||||
func recordLegacyWhitelistCommands(t *testing.T, available map[string]bool, failSetMatch bool, failCommands ...string) *[]recordedCommand {
|
||||
t.Helper()
|
||||
oldAvailable := commandAvailable
|
||||
oldCommands := executeCommands
|
||||
oldWithInput := executeCommandWithInput
|
||||
var calls []recordedCommand
|
||||
commandAvailable = func(command string) bool { return available[command] }
|
||||
executeCommands = func(commands string, _ bool) error {
|
||||
calls = append(calls, recordedCommand{name: "commands", input: commands})
|
||||
return nil
|
||||
}
|
||||
executeCommandWithInput = func(command string, args []string, input string) error {
|
||||
calls = append(calls, recordedCommand{name: command, args: args, input: input})
|
||||
if failSetMatch && command != "ipset" && containsArg(args, "--match-set") {
|
||||
return errors.New("xt_set unavailable")
|
||||
}
|
||||
for _, failCommand := range failCommands {
|
||||
if command+" "+strings.Join(args, " ") == failCommand {
|
||||
return errors.New("command failed")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
commandAvailable = oldAvailable
|
||||
executeCommands = oldCommands
|
||||
executeCommandWithInput = oldWithInput
|
||||
})
|
||||
return &calls
|
||||
}
|
||||
|
||||
func containsArg(args []string, want string) bool {
|
||||
for _, arg := range args {
|
||||
if arg == want {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func testWhitelistSetter(table string, ipv4, ipv6 []string) Setter {
|
||||
commands := "before\n" + legacyWhitelist4Marker + "\nbetween\n" + legacyWhitelist6Marker + "\nafter\n"
|
||||
return newLegacyWhitelistSetter(commands, table, ipv4, ipv6)
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistUsesIPSetInChainOrder(t *testing.T) {
|
||||
ipv4 := []string{"1.0.0.0/8", "2.0.0.0/8", "3.0.0.0/8"}
|
||||
ipv6 := []string{"2001:db8:1::/48", "2001:db8:2::/48", "2001:db8:3::/48"}
|
||||
calls := recordLegacyWhitelistCommands(t, map[string]bool{"ipset": true}, false)
|
||||
|
||||
if err := testWhitelistSetter("mangle", ipv4, ipv6).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(*calls) != 7 {
|
||||
t.Fatalf("calls = %#v", *calls)
|
||||
}
|
||||
if !strings.Contains((*calls)[0].input, "before") || !strings.Contains((*calls)[3].input, "between") || !strings.Contains((*calls)[6].input, "after") {
|
||||
t.Fatalf("command chunks are out of order: %#v", *calls)
|
||||
}
|
||||
want4 := "create v2raya_white4 hash:net family inet maxelem 65536\nflush v2raya_white4\nadd v2raya_white4 1.0.0.0/8\nadd v2raya_white4 2.0.0.0/8\nadd v2raya_white4 3.0.0.0/8\n"
|
||||
want6 := "create v2raya_white6 hash:net family inet6 maxelem 65536\nflush v2raya_white6\nadd v2raya_white6 2001:db8:1::/48\nadd v2raya_white6 2001:db8:2::/48\nadd v2raya_white6 2001:db8:3::/48\n"
|
||||
if (*calls)[1].name != "ipset" || !reflect.DeepEqual((*calls)[1].args, []string{"restore", "-!"}) || (*calls)[1].input != want4 {
|
||||
t.Errorf("IPv4 ipset call = %#v", (*calls)[1])
|
||||
}
|
||||
if (*calls)[4].name != "ipset" || !reflect.DeepEqual((*calls)[4].args, []string{"restore", "-!"}) || (*calls)[4].input != want6 {
|
||||
t.Errorf("IPv6 ipset call = %#v", (*calls)[4])
|
||||
}
|
||||
wantMatch4 := []string{"-w", "2", "-t", "mangle", "-A", "TP_RULE", "-m", "set", "--match-set", "v2raya_white4", "dst", "-j", "RETURN"}
|
||||
wantMatch6 := []string{"-w", "2", "-t", "mangle", "-A", "TP_RULE", "-m", "set", "--match-set", "v2raya_white6", "dst", "-j", "RETURN"}
|
||||
if (*calls)[2].name != "iptables" || !reflect.DeepEqual((*calls)[2].args, wantMatch4) {
|
||||
t.Errorf("IPv4 match call = %#v", (*calls)[2])
|
||||
}
|
||||
if (*calls)[5].name != "ip6tables" || !reflect.DeepEqual((*calls)[5].args, wantMatch6) {
|
||||
t.Errorf("IPv6 match call = %#v", (*calls)[5])
|
||||
}
|
||||
for _, call := range *calls {
|
||||
if call.name == "commands" && (strings.Contains(call.input, "1.0.0.0/8") || strings.Contains(call.input, "2001:db8:1::/48")) {
|
||||
t.Errorf("per-CIDR rule leaked into command chunks: %q", call.input)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistFallsBackToRestore(t *testing.T) {
|
||||
ipv4 := []string{"1.0.0.0/8", "2.0.0.0/8", "3.0.0.0/8"}
|
||||
ipv6 := []string{"2001:db8:1::/48", "2001:db8:2::/48", "2001:db8:3::/48"}
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
available map[string]bool
|
||||
failSetMatch bool
|
||||
}{
|
||||
{name: "without ipset", available: map[string]bool{"iptables-restore": true, "ip6tables-restore": true}},
|
||||
{name: "without xt_set", available: map[string]bool{"ipset": true, "iptables-restore": true, "ip6tables-restore": true}, failSetMatch: true},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
calls := recordLegacyWhitelistCommands(t, tc.available, tc.failSetMatch)
|
||||
if err := testWhitelistSetter("nat", ipv4, ipv6).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var restores []recordedCommand
|
||||
for _, call := range *calls {
|
||||
if strings.HasSuffix(call.name, "tables-restore") {
|
||||
restores = append(restores, call)
|
||||
}
|
||||
}
|
||||
if len(restores) != 2 {
|
||||
t.Fatalf("restore calls = %#v", restores)
|
||||
}
|
||||
wantArgs := []string{"-w", "2", "--noflush"}
|
||||
if restores[0].name != "iptables-restore" || !reflect.DeepEqual(restores[0].args, wantArgs) || restores[0].input != "*nat\n-A TP_RULE -d 1.0.0.0/8 -j RETURN\n-A TP_RULE -d 2.0.0.0/8 -j RETURN\n-A TP_RULE -d 3.0.0.0/8 -j RETURN\nCOMMIT\n" {
|
||||
t.Errorf("IPv4 restore call = %#v", restores[0])
|
||||
}
|
||||
if restores[1].name != "ip6tables-restore" || !reflect.DeepEqual(restores[1].args, wantArgs) || restores[1].input != "*nat\n-A TP_RULE -d 2001:db8:1::/48 -j RETURN\n-A TP_RULE -d 2001:db8:2::/48 -j RETURN\n-A TP_RULE -d 2001:db8:3::/48 -j RETURN\nCOMMIT\n" {
|
||||
t.Errorf("IPv6 restore call = %#v", restores[1])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistFallsBackWhenIPSetRestoreFails(t *testing.T) {
|
||||
ipv4 := []string{"1.0.0.0/8", "2.0.0.0/8"}
|
||||
ipv6 := []string{"2001:db8:1::/48", "2001:db8:2::/48"}
|
||||
calls := recordLegacyWhitelistCommands(t, map[string]bool{"ipset": true, "iptables-restore": true, "ip6tables-restore": true}, false, "ipset restore -!")
|
||||
|
||||
if err := testWhitelistSetter("nat", ipv4, ipv6).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var fallbackCalls []recordedCommand
|
||||
for _, call := range *calls {
|
||||
if (call.name == "ipset" && containsArg(call.args, "destroy")) || strings.HasSuffix(call.name, "tables-restore") {
|
||||
fallbackCalls = append(fallbackCalls, call)
|
||||
}
|
||||
if call.name == "commands" && strings.Contains(call.input, "-d ") {
|
||||
t.Errorf("unexpected per-line commands: %q", call.input)
|
||||
}
|
||||
}
|
||||
want := []recordedCommand{
|
||||
{name: "ipset", args: []string{"destroy", "v2raya_white4"}},
|
||||
{name: "iptables-restore", args: []string{"-w", "2", "--noflush"}, input: "*nat\n-A TP_RULE -d 1.0.0.0/8 -j RETURN\n-A TP_RULE -d 2.0.0.0/8 -j RETURN\nCOMMIT\n"},
|
||||
{name: "ipset", args: []string{"destroy", "v2raya_white6"}},
|
||||
{name: "ip6tables-restore", args: []string{"-w", "2", "--noflush"}, input: "*nat\n-A TP_RULE -d 2001:db8:1::/48 -j RETURN\n-A TP_RULE -d 2001:db8:2::/48 -j RETURN\nCOMMIT\n"},
|
||||
}
|
||||
if !reflect.DeepEqual(fallbackCalls, want) {
|
||||
t.Fatalf("fallback calls = %#v, want %#v", fallbackCalls, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistFallsBackWhenRestoreFails(t *testing.T) {
|
||||
ipv4 := []string{"1.0.0.0/8", "2.0.0.0/8"}
|
||||
ipv6 := []string{"2001:db8:1::/48", "2001:db8:2::/48"}
|
||||
calls := recordLegacyWhitelistCommands(t, map[string]bool{"iptables-restore": true, "ip6tables-restore": true}, false, "iptables-restore -w 2 --noflush", "ip6tables-restore -w 2 --noflush")
|
||||
|
||||
if err := testWhitelistSetter("mangle", ipv4, ipv6).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var fallbackCalls []recordedCommand
|
||||
for _, call := range *calls {
|
||||
if strings.HasSuffix(call.name, "tables-restore") || (call.name == "commands" && strings.Contains(call.input, "-d ")) {
|
||||
fallbackCalls = append(fallbackCalls, call)
|
||||
}
|
||||
}
|
||||
want := []recordedCommand{
|
||||
{name: "iptables-restore", args: []string{"-w", "2", "--noflush"}, input: "*mangle\n-A TP_RULE -d 1.0.0.0/8 -j RETURN\n-A TP_RULE -d 2.0.0.0/8 -j RETURN\nCOMMIT\n"},
|
||||
{name: "commands", input: "iptables -w 2 -t mangle -A TP_RULE -d 1.0.0.0/8 -j RETURN\niptables -w 2 -t mangle -A TP_RULE -d 2.0.0.0/8 -j RETURN\n"},
|
||||
{name: "ip6tables-restore", args: []string{"-w", "2", "--noflush"}, input: "*mangle\n-A TP_RULE -d 2001:db8:1::/48 -j RETURN\n-A TP_RULE -d 2001:db8:2::/48 -j RETURN\nCOMMIT\n"},
|
||||
{name: "commands", input: "ip6tables -w 2 -t mangle -A TP_RULE -d 2001:db8:1::/48 -j RETURN\nip6tables -w 2 -t mangle -A TP_RULE -d 2001:db8:2::/48 -j RETURN\n"},
|
||||
}
|
||||
if !reflect.DeepEqual(fallbackCalls, want) {
|
||||
t.Fatalf("fallback calls = %#v, want %#v", fallbackCalls, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistFallsBackToPerLineCommands(t *testing.T) {
|
||||
calls := recordLegacyWhitelistCommands(t, nil, false)
|
||||
if err := testWhitelistSetter("mangle", []string{"1.0.0.0/8", "2.0.0.0/8", "3.0.0.0/8"}, []string{"2001:db8:1::/48", "2001:db8:2::/48", "2001:db8:3::/48"}).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var cidrCommands []string
|
||||
for _, call := range *calls {
|
||||
if call.name == "commands" && strings.Contains(call.input, "-d ") {
|
||||
cidrCommands = append(cidrCommands, call.input)
|
||||
}
|
||||
}
|
||||
want := []string{
|
||||
"iptables -w 2 -t mangle -A TP_RULE -d 1.0.0.0/8 -j RETURN\niptables -w 2 -t mangle -A TP_RULE -d 2.0.0.0/8 -j RETURN\niptables -w 2 -t mangle -A TP_RULE -d 3.0.0.0/8 -j RETURN\n",
|
||||
"ip6tables -w 2 -t mangle -A TP_RULE -d 2001:db8:1::/48 -j RETURN\nip6tables -w 2 -t mangle -A TP_RULE -d 2001:db8:2::/48 -j RETURN\nip6tables -w 2 -t mangle -A TP_RULE -d 2001:db8:3::/48 -j RETURN\n",
|
||||
}
|
||||
if !reflect.DeepEqual(cidrCommands, want) {
|
||||
t.Fatalf("per-line commands = %#v", cidrCommands)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyWhitelistSkipsEmptyFamilies(t *testing.T) {
|
||||
calls := recordLegacyWhitelistCommands(t, map[string]bool{"ipset": true, "iptables-restore": true, "ip6tables-restore": true}, false)
|
||||
if err := testWhitelistSetter("nat", nil, nil).run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, call := range *calls {
|
||||
if call.name != "commands" {
|
||||
t.Fatalf("empty whitelist executed %#v", call)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyCleanupDestroysWhitelistSetsAfterRules(t *testing.T) {
|
||||
for _, commands := range []string{(&legacyTproxy{}).GetCleanCommands().Cmds, (&legacyRedirect{}).GetCleanCommands().Cmds} {
|
||||
destroy4 := strings.LastIndex(commands, "ipset destroy v2raya_white4")
|
||||
destroy6 := strings.LastIndex(commands, "ipset destroy v2raya_white6")
|
||||
deleteRules := strings.LastIndex(commands, "-X TP_RULE")
|
||||
if destroy4 < deleteRules || destroy6 < deleteRules {
|
||||
t.Fatalf("cleanup order is wrong:\n%s", commands)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRewriteIptablesBinariesIncludesRestore(t *testing.T) {
|
||||
commands := "iptables -L\nip6tables -L\niptables-restore\nip6tables-restore\n"
|
||||
if got, want := rewriteIptablesBinaries(commands, "legacy"), "iptables-legacy -L\nip6tables-legacy -L\niptables-legacy-restore\nip6tables-legacy-restore\n"; got != want {
|
||||
t.Errorf("legacy rewrite = %q, want %q", got, want)
|
||||
}
|
||||
if got, want := rewriteIptablesBinaries(commands, "nft"), "iptables-nft -L\nip6tables-nft -L\niptables-nft-restore\nip6tables-nft-restore\n"; got != want {
|
||||
t.Errorf("nft rewrite = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacySetupPlacesSetRulesAtWhitelistPosition(t *testing.T) {
|
||||
oldValues := legacySetupValues
|
||||
oldIPv6 := legacyIPv6Supported
|
||||
ipv4 := []string{"1.0.0.0/8", "2.0.0.0/8", "3.0.0.0/8"}
|
||||
ipv6 := []string{"2001:db8:1::/48", "2001:db8:2::/48", "2001:db8:3::/48"}
|
||||
legacySetupValues = func() ([]string, []string, []string, error) {
|
||||
return nil, ipv4, ipv6, nil
|
||||
}
|
||||
legacyIPv6Supported = func() bool { return true }
|
||||
t.Cleanup(func() {
|
||||
legacySetupValues = oldValues
|
||||
legacyIPv6Supported = oldIPv6
|
||||
})
|
||||
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
setter Setter
|
||||
table string
|
||||
before4 string
|
||||
after4 string
|
||||
before6 string
|
||||
after6 string
|
||||
}{
|
||||
{
|
||||
name: "tproxy",
|
||||
setter: (&legacyTproxy{}).GetSetupCommands(),
|
||||
table: "mangle",
|
||||
before4: "iptables -w 2 -t mangle -A TP_RULE -m mark --mark 0x40/0xc0 -j RETURN",
|
||||
after4: "iptables -w 2 -t mangle -A TP_RULE -j TP_MARK",
|
||||
before6: "ip6tables -w 2 -t mangle -A TP_RULE -m mark --mark 0x40/0xc0 -j RETURN",
|
||||
after6: "ip6tables -w 2 -t mangle -A TP_RULE -j TP_MARK",
|
||||
},
|
||||
{
|
||||
name: "redirect",
|
||||
setter: (&legacyRedirect{}).GetSetupCommands(),
|
||||
table: "nat",
|
||||
before4: "iptables -w 2 -t nat -A TP_RULE -m mark --mark 0x80/0x80 -j RETURN",
|
||||
after4: "iptables -w 2 -t nat -A TP_RULE -p tcp -j REDIRECT --to-ports 52345",
|
||||
before6: "ip6tables -w 2 -t nat -A TP_RULE -m mark --mark 0x80/0x80 -j RETURN",
|
||||
after6: "ip6tables -w 2 -t nat -A TP_RULE -p tcp -j REDIRECT --to-ports 52345",
|
||||
},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
calls := recordLegacyWhitelistCommands(t, map[string]bool{"ipset": true}, false)
|
||||
if err := tc.setter.run(false, func(command string) string { return command }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertSetRulePosition(t, *calls, "iptables", tc.table, "v2raya_white4", tc.before4, tc.after4)
|
||||
assertSetRulePosition(t, *calls, "ip6tables", tc.table, "v2raya_white6", tc.before6, tc.after6)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func assertSetRulePosition(t *testing.T, calls []recordedCommand, binary, table, setName, before, after string) {
|
||||
t.Helper()
|
||||
var matches []int
|
||||
for i, call := range calls {
|
||||
if call.name == binary && containsArg(call.args, setName) {
|
||||
matches = append(matches, i)
|
||||
}
|
||||
}
|
||||
if len(matches) != 1 {
|
||||
t.Fatalf("%s match rules = %d in %#v", setName, len(matches), calls)
|
||||
}
|
||||
i := matches[0]
|
||||
if i < 2 || i+1 >= len(calls) ||
|
||||
calls[i-2].name != "commands" || !strings.Contains(calls[i-2].input, before) ||
|
||||
calls[i+1].name != "commands" || !strings.Contains(calls[i+1].input, after) {
|
||||
t.Fatalf("%s rule is out of position in %#v", setName, calls)
|
||||
}
|
||||
wantArgs := []string{"-w", "2", "-t", table, "-A", "TP_RULE", "-m", "set", "--match-set", setName, "dst", "-j", "RETURN"}
|
||||
if !reflect.DeepEqual(calls[i].args, wantArgs) {
|
||||
t.Errorf("%s match args = %#v, want %#v", setName, calls[i].args, wantArgs)
|
||||
}
|
||||
}
|
||||
@@ -52,7 +52,7 @@ func (r *legacyRedirect) RemoveIPWhitelist(cidr string) {
|
||||
}
|
||||
|
||||
func (r *legacyRedirect) GetSetupCommands() Setter {
|
||||
excludedInterfaces, whiteIpv4List, whiteIpv6List, err := getTproxySetupValues()
|
||||
excludedInterfaces, whiteIpv4List, whiteIpv6List, err := legacySetupValues()
|
||||
if err != nil {
|
||||
return NewErrorSetter(err)
|
||||
}
|
||||
@@ -91,11 +91,7 @@ iptables -w 2 -t nat -A DNS_REDIRECT -p udp -j REDIRECT --to-port 52353
|
||||
for _, v := range excludedInterfaces {
|
||||
commands += fmt.Sprintf("iptables -w 2 -t nat -A TP_RULE -o %s -j RETURN\n", strings.ReplaceAll(v, "*", "+"))
|
||||
}
|
||||
if len(whiteIpv4List) > 0 {
|
||||
for _, v := range whiteIpv4List {
|
||||
commands += fmt.Sprintf("iptables -w 2 -t nat -A TP_RULE -d %s -j RETURN\n", v)
|
||||
}
|
||||
}
|
||||
commands += legacyWhitelist4Marker + "\n"
|
||||
commands += `
|
||||
iptables -w 2 -t nat -A TP_RULE -p tcp -j REDIRECT --to-ports 52345
|
||||
|
||||
@@ -111,7 +107,7 @@ iptables -w 2 -t nat -I PREROUTING -p tcp --dport 53 -j DNS_REDIRECT
|
||||
iptables -w 2 -t nat -I OUTPUT -p udp --dport 53 -j DNS_REDIRECT
|
||||
iptables -w 2 -t nat -I OUTPUT -p tcp --dport 53 -j DNS_REDIRECT
|
||||
`
|
||||
if IsIPv6Supported() {
|
||||
if legacyIPv6Supported() {
|
||||
commands += `
|
||||
ip6tables -w 2 -t nat -N TP_OUT
|
||||
ip6tables -w 2 -t nat -N TP_PRE
|
||||
@@ -141,11 +137,7 @@ ip6tables -w 2 -t nat -A TP_RULE -m mark --mark 0x80/0x80 -j RETURN
|
||||
for _, v := range excludedInterfaces {
|
||||
commands += fmt.Sprintf("ip6tables -w 2 -t nat -A TP_RULE -o %s -j RETURN\n", strings.ReplaceAll(v, "*", "+"))
|
||||
}
|
||||
if len(whiteIpv6List) > 0 {
|
||||
for _, v := range whiteIpv6List {
|
||||
commands += fmt.Sprintf("ip6tables -w 2 -t nat -A TP_RULE -d %s -j RETURN\n", v)
|
||||
}
|
||||
}
|
||||
commands += legacyWhitelist6Marker + "\n"
|
||||
commands += `
|
||||
ip6tables -w 2 -t nat -A TP_RULE -p tcp -j REDIRECT --to-ports 52345
|
||||
|
||||
@@ -160,9 +152,7 @@ ip6tables -w 2 -t nat -I OUTPUT -p udp --dport 53 -j DNS_REDIRECT
|
||||
ip6tables -w 2 -t nat -I OUTPUT -p tcp --dport 53 -j DNS_REDIRECT
|
||||
`
|
||||
}
|
||||
return Setter{
|
||||
Cmds: withDnsModulePort(commands),
|
||||
}
|
||||
return newLegacyWhitelistSetter(withDnsModulePort(commands), "nat", whiteIpv4List, whiteIpv6List)
|
||||
}
|
||||
|
||||
func (r *legacyRedirect) GetCleanCommands() Setter {
|
||||
@@ -200,6 +190,9 @@ ip6tables -w 2 -t nat -F TP_RULE
|
||||
ip6tables -w 2 -t nat -X TP_RULE
|
||||
`
|
||||
}
|
||||
commands += `ipset destroy v2raya_white4 2>/dev/null || true
|
||||
ipset destroy v2raya_white6 2>/dev/null || true
|
||||
`
|
||||
return Setter{
|
||||
Cmds: withDnsModulePort(commands),
|
||||
}
|
||||
|
||||
@@ -63,7 +63,7 @@ func (t *legacyTproxy) RemoveIPWhitelist(cidr string) {
|
||||
}
|
||||
|
||||
func (t *legacyTproxy) GetSetupCommands() Setter {
|
||||
excludedInterfaces, whiteIpv4List, whiteIpv6List, err := getTproxySetupValues()
|
||||
excludedInterfaces, whiteIpv4List, whiteIpv6List, err := legacySetupValues()
|
||||
if err != nil {
|
||||
return NewErrorSetter(err)
|
||||
}
|
||||
@@ -120,11 +120,7 @@ iptables -w 2 -t mangle -A TP_RULE -p tcp --dport 53 -j TP_MARK
|
||||
iptables -w 2 -t mangle -A TP_RULE -m mark --mark 0x40/0xc0 -j RETURN
|
||||
`
|
||||
|
||||
if len(whiteIpv4List) > 0 {
|
||||
for _, v := range whiteIpv4List {
|
||||
commands += fmt.Sprintf("iptables -w 2 -t mangle -A TP_RULE -d %s -j RETURN\n", v)
|
||||
}
|
||||
}
|
||||
commands += legacyWhitelist4Marker + "\n"
|
||||
commands += `
|
||||
iptables -w 2 -t mangle -A TP_RULE -j TP_MARK
|
||||
|
||||
@@ -136,7 +132,7 @@ iptables -w 2 -t mangle -A DNS_MARK -m mark --mark 0x80/0x80 -j RETURN
|
||||
iptables -w 2 -t mangle -A DNS_MARK -j MARK --set-xmark 0x40/0x40
|
||||
iptables -w 2 -t mangle -A DNS_MARK -j ACCEPT
|
||||
`
|
||||
if IsIPv6Supported() {
|
||||
if legacyIPv6Supported() {
|
||||
commands += `
|
||||
ip -6 rule add fwmark 0x40/0xc0 table 100
|
||||
ip -6 route add local ::/0 dev lo table 100
|
||||
@@ -188,11 +184,7 @@ ip6tables -w 2 -t mangle -A TP_RULE -p udp --dport 53 -j TP_MARK
|
||||
ip6tables -w 2 -t mangle -A TP_RULE -p tcp --dport 53 -j TP_MARK
|
||||
ip6tables -w 2 -t mangle -A TP_RULE -m mark --mark 0x40/0xc0 -j RETURN
|
||||
`
|
||||
if len(whiteIpv6List) > 0 {
|
||||
for _, v := range whiteIpv6List {
|
||||
commands += fmt.Sprintf("ip6tables -w 2 -t mangle -A TP_RULE -d %s -j RETURN\n", v)
|
||||
}
|
||||
}
|
||||
commands += legacyWhitelist6Marker + "\n"
|
||||
commands += `
|
||||
ip6tables -w 2 -t mangle -A TP_RULE -j TP_MARK
|
||||
|
||||
@@ -205,9 +197,7 @@ ip6tables -w 2 -t mangle -A DNS_MARK -j MARK --set-xmark 0x40/0x40
|
||||
ip6tables -w 2 -t mangle -A DNS_MARK -j ACCEPT
|
||||
`
|
||||
}
|
||||
return Setter{
|
||||
Cmds: withDnsModulePort(commands),
|
||||
}
|
||||
return newLegacyWhitelistSetter(withDnsModulePort(commands), "mangle", whiteIpv4List, whiteIpv6List)
|
||||
}
|
||||
|
||||
func (t *legacyTproxy) GetCleanCommands() Setter {
|
||||
@@ -255,7 +245,10 @@ ip6tables -w 2 -t mangle -D OUTPUT -p tcp --dport 53 -j DNS_MARK
|
||||
ip6tables -w 2 -t mangle -X DNS_MARK
|
||||
`
|
||||
}
|
||||
commands += "conntrack -D --mark 0x40 2>/dev/null || true\n"
|
||||
commands += `conntrack -D --mark 0x40 2>/dev/null || true
|
||||
ipset destroy v2raya_white4 2>/dev/null || true
|
||||
ipset destroy v2raya_white6 2>/dev/null || true
|
||||
`
|
||||
return Setter{
|
||||
Cmds: withDnsModulePort(commands),
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user