Merge pull request 'Match dest zone oif on output-chain rules and policies' (#20) from benvin/output-oif into main

Reviewed-on: #20

internal/nftables/compiler.go

@@ -205,7 +205,7 @@ func (c *Compiler) compileBlrules(state *FirewallState) error {
 		}
 		if err := c.compileOneRule(state, tag, rule.Source, rule.Dest,
 			rule.Proto, rule.DPort, rule.SPort,
-			action, rule.Log, "", fwZone, ""); err != nil {
+			action, rule.Log, "", "", fwZone, ""); err != nil {
 			return fmt.Errorf("blrule[%d]: %w", i, err)
 		}
 	}
@@ -276,14 +276,14 @@ func (c *Compiler) compileRules(state *FirewallState) error {
 			if err != nil {
 				return fmt.Errorf("rule[%d]: %w", i, err)
 			}
-			if len(matches)*specCount(rule.Source, rule.Dest, rule.Action) > 1 {
+			if len(matches)*specCount(rule.Source, rule.Dest, rule.OrigDest, rule.Action) > 1 {
 				return fmt.Errorf("rule[%d]: ratelimit/connlimit cannot be combined with proto, port, zone or address lists (each expanded rule would get its own limiter)", i)
 			}
 		}
 
 		if err := c.compileOneRule(state, tag, rule.Source, rule.Dest,
 			proto, dports, sport,
-			rule.Action, rule.Log, rule.Dest, fwZone, rule.Section); err != nil {
+			rule.Action, rule.Log, rule.Dest, rule.OrigDest, fwZone, rule.Section); err != nil {
 			return fmt.Errorf("rule[%d]: %w", i, err)
 		}
 
@@ -360,22 +360,24 @@ func (c *Compiler) applyChainExtras(state *FirewallState, chain, tag string, rul
 
 func (c *Compiler) compileOneRule(state *FirewallState, tag, srcSpec, dstSpec, proto string,
 	dports, sports config.PortSpec, action config.RuleAction, logLevel string,
-	dnatDest string, fwZone string, section config.RuleSection) error {
+	dnatDest, origDest string, fwZone string, section config.RuleSection) error {
 
 	for _, src := range zoneSpecs(srcSpec) {
 		for _, srcAddr := range splitAddrs(src.Addr) {
-			if action == config.RuleDNAT || action == config.RuleRedirect {
-				if err := c.compileDNATRule(state, tag, src.Zone, srcAddr, dstSpec, proto, dports, action, logLevel); err != nil {
-					return err
-				}
-				continue
-			}
-			for _, dst := range zoneSpecs(dstSpec) {
-				for _, dstAddr := range splitAddrs(dst.Addr) {
-					if err := c.compileZonePair(state, tag, src.Zone, srcAddr, dst.Zone, dstAddr, proto,
-						dports, sports, action, logLevel, fwZone, section); err != nil {
+			for _, od := range splitAddrs(origDest) {
+				if action == config.RuleDNAT || action == config.RuleRedirect {
+					if err := c.compileDNATRule(state, tag, src.Zone, srcAddr, od, dstSpec, proto, dports, action, logLevel); err != nil {
 						return err
 					}
+					continue
+				}
+				for _, dst := range zoneSpecs(dstSpec) {
+					for _, dstAddr := range splitAddrs(dst.Addr) {
+						if err := c.compileZonePair(state, tag, src.Zone, srcAddr, dst.Zone, dstAddr, od, proto,
+							dports, sports, action, logLevel, fwZone, section); err != nil {
+							return err
+						}
+					}
 				}
 			}
 		}
@@ -384,17 +386,18 @@ func (c *Compiler) compileOneRule(state *FirewallState, tag, srcSpec, dstSpec, p
 }
 
 // specCount is how many zone/address combinations compileOneRule expands src and dst into.
-func specCount(srcSpec, dstSpec string, action config.RuleAction) int {
+func specCount(srcSpec, dstSpec, origDest string, action config.RuleAction) int {
 	count := func(spec string) (n int) {
 		for _, z := range zoneSpecs(spec) {
 			n += len(splitAddrs(z.Addr))
 		}
 		return n
 	}
+	n := count(srcSpec) * len(splitAddrs(origDest))
 	if action == config.RuleDNAT || action == config.RuleRedirect {
-		return count(srcSpec)
+		return n
 	}
-	return count(srcSpec) * count(dstSpec)
+	return n * count(dstSpec)
 }
 
 // zoneSpecs expands a comma zone list; "all"/"any" forms keep their own comma (exclusion) syntax.
@@ -414,12 +417,16 @@ func splitAddrs(addr string) []string {
 	return strings.Split(addr, ",")
 }
 
-func (c *Compiler) compileZonePair(state *FirewallState, tag, srcZone, srcAddr, dstZone, dstAddr, proto string,
+func (c *Compiler) compileZonePair(state *FirewallState, tag, srcZone, srcAddr, dstZone, dstAddr, origDest, proto string,
 	dports, sports config.PortSpec, action config.RuleAction, logLevel string,
 	fwZone string, section config.RuleSection) error {
-	srcIfaces := c.resolveZoneInterfaces(srcZone)
-	dstIfaces := c.resolveZoneInterfaces(dstZone)
+	srcIfaces := c.resolveZoneInterfaces(srcZone, srcAddr)
+	dstIfaces := c.resolveZoneInterfaces(dstZone, dstAddr)
 	chain := c.selectChain(srcZone, dstZone, fwZone)
+	// ponytail: forward daddr is post-DNAT; lift with `ct original daddr` (expr.Ct Direction, google/nftables v0.3.0).
+	if origDest != "" && chain == "forward" {
+		return fmt.Errorf("origdest: ORIGDEST on forwarded rules is not supported yet")
+	}
 
 	for _, srcIface := range srcIfaces {
 		for _, dstIface := range dstIfaces {
@@ -427,6 +434,15 @@ func (c *Compiler) compileZonePair(state *FirewallState, tag, srcZone, srcAddr,
 			if err != nil {
 				return err
 			}
+			if origDest != "" {
+				od, err := matchOrigDest(origDest)
+				if err != nil {
+					return fmt.Errorf("origdest: %w", err)
+				}
+				for i := range matches {
+					matches[i].exprs = append(matches[i].exprs, od...)
+				}
+			}
 
 			for _, m := range matches {
 				exprs := m.exprs
@@ -455,7 +471,7 @@ func (c *Compiler) compileZonePair(state *FirewallState, tag, srcZone, srcAddr,
 	return nil
 }
 
-func (c *Compiler) compileDNATRule(state *FirewallState, tag, srcZone, srcAddr, dstSpec, proto string,
+func (c *Compiler) compileDNATRule(state *FirewallState, tag, srcZone, srcAddr, origDest, dstSpec, proto string,
 	dports config.PortSpec, action config.RuleAction, logLevel string) error {
 	chain := "prerouting"
 
@@ -474,7 +490,15 @@ func (c *Compiler) compileDNATRule(state *FirewallState, tag, srcZone, srcAddr,
 		dnatPort = uint16(p)
 	}
 
-	srcIfaces := c.resolveZoneInterfaces(srcZone)
+	srcIfaces := c.resolveZoneInterfaces(srcZone, srcAddr)
+
+	var odExprs []expr.Any
+	if origDest != "" {
+		var err error
+		if odExprs, err = matchOrigDest(origDest); err != nil {
+			return fmt.Errorf("origdest: %w", err)
+		}
+	}
 
 	matches, err := l4Matches(proto, dports, nil)
 	if err != nil {
@@ -501,6 +525,7 @@ func (c *Compiler) compileDNATRule(state *FirewallState, tag, srcZone, srcAddr,
 				}
 				exprs = append(exprs, src...)
 			}
+			exprs = append(exprs, odExprs...)
 
 			exprs = append(exprs, m.exprs...)
 
@@ -589,8 +614,8 @@ func (c *Compiler) compilePolicies(state *FirewallState) error {
 				}
 
 				chain := c.selectChain(sz, dz, fwZone)
-				srcIfaces := c.resolveZoneInterfaces(sz)
-				dstIfaces := c.resolveZoneInterfaces(dz)
+				srcIfaces := c.resolveZoneInterfaces(sz, "")
+				dstIfaces := c.resolveZoneInterfaces(dz, "")
 
 				for _, si := range srcIfaces {
 					for _, di := range dstIfaces {
@@ -599,7 +624,7 @@ func (c *Compiler) compilePolicies(state *FirewallState) error {
 						if si != "" {
 							exprs = append(exprs, matchIfaceName(true, si)...)
 						}
-						if di != "" && chain == "forward" {
+						if di != "" && chain != "input" {
 							exprs = append(exprs, matchIfaceName(false, di)...)
 						}
 
@@ -932,34 +957,25 @@ func (c *Compiler) selectChain(srcZone, dstZone, fwZone string) string {
 	return "forward"
 }
 
-func (c *Compiler) resolveZoneInterfaces(zone string) []string {
-	if zone == "all" || zone == "" {
+// resolveZoneInterfaces returns nil (fail closed) for a zone with no interfaces unless a non-negated address match narrows the rule.
+func (c *Compiler) resolveZoneInterfaces(zone, addr string) []string {
+	if z, ok := c.cfg.Zones[zone]; !ok || z.Type == config.ZoneFirewall {
 		return []string{""}
 	}
-	ifaces := c.cfg.ZoneInterfaces(zone)
-	if len(ifaces) > 0 {
+	if ifaces := c.cfg.ZoneInterfaces(zone); len(ifaces) > 0 {
 		return ifaces
 	}
-	if z, ok := c.cfg.Zones[zone]; ok && z.Type == config.ZoneIP && !c.zoneHasHosts(zone) {
-		if !c.warned[zone] {
-			if c.warned == nil {
-				c.warned = map[string]bool{}
-			}
-			c.warned[zone] = true
-			slog.Warn("compiler: zone has no interfaces, skipping its rules", "zone", zone)
-		}
-		return nil
+	if addr != "" && !strings.HasPrefix(addr, "!") {
+		return []string{""}
 	}
-	return []string{""}
-}
-
-func (c *Compiler) zoneHasHosts(zone string) bool {
-	for _, h := range c.cfg.Hosts {
-		if h.Zone == zone {
-			return true
+	if !c.warned[zone] {
+		if c.warned == nil {
+			c.warned = map[string]bool{}
 		}
+		c.warned[zone] = true
+		slog.Warn("compiler: zone has no interfaces, skipping its rules", "zone", zone)
 	}
-	return false
+	return nil
 }
 
 func (c *Compiler) expandZoneRef(ref string) []string {
@@ -997,7 +1013,7 @@ func (c *Compiler) buildMatchExprs(srcIface, dstIface, chain, proto string, dpor
 	if srcIface != "" {
 		exprs = append(exprs, matchIfaceName(true, srcIface)...)
 	}
-	if dstIface != "" && chain == "forward" {
+	if dstIface != "" && chain != "input" {
 		exprs = append(exprs, matchIfaceName(false, dstIface)...)
 	}
 
@@ -1386,6 +1402,30 @@ func matchDestCIDR(cidr string) ([]expr.Any, error) {
 	return matchAddrCIDR(cidr, false)
 }
 
+// matchOrigDest guards the daddr match with the address's nfproto so it is family-correct in the inet table.
+func matchOrigDest(addr string) ([]expr.Any, error) {
+	var proto byte
+	for i, a := range strings.Split(strings.TrimPrefix(addr, "!"), ",") {
+		a, _, _ = strings.Cut(a, "/")
+		p := byte(unix.NFPROTO_IPV6)
+		if ip := net.ParseIP(a); ip != nil && ip.To4() != nil {
+			p = unix.NFPROTO_IPV4
+		}
+		if i > 0 && p != proto {
+			return nil, fmt.Errorf("%q mixes IPv4 and IPv6 addresses", addr)
+		}
+		proto = p
+	}
+	dst, err := matchDestCIDR(addr)
+	if err != nil {
+		return nil, err
+	}
+	return append([]expr.Any{
+		&expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1},
+		&expr.Cmp{Op: expr.CmpOpEq, Register: 1, Data: []byte{proto}},
+	}, dst...), nil
+}
+
 func matchAddrCIDR(cidr string, isSrc bool) ([]expr.Any, error) {
 	negated := false
 	if strings.HasPrefix(cidr, "!") {

internal/nftables/compiler_test.go

@@ -1,8 +1,11 @@
 package nftables
 
 import (
+	"bytes"
 	"encoding/binary"
 	"fmt"
+	"log/slog"
+	"net"
 	"reflect"
 	"strings"
 	"testing"
@@ -141,17 +144,17 @@ func TestCompiler_ResolveZoneInterfaces(t *testing.T) {
 	}
 	c := NewCompiler(cfg)
 
-	ifaces := c.resolveZoneInterfaces("net")
+	ifaces := c.resolveZoneInterfaces("net", "")
 	if len(ifaces) != 1 || ifaces[0] != "eth0" {
 		t.Errorf("resolveZoneInterfaces(net) = %v, want [eth0]", ifaces)
 	}
 
-	ifaces = c.resolveZoneInterfaces("all")
+	ifaces = c.resolveZoneInterfaces("all", "")
 	if len(ifaces) != 1 || ifaces[0] != "" {
 		t.Errorf("resolveZoneInterfaces(all) = %v, want [\"\"]", ifaces)
 	}
 
-	ifaces = c.resolveZoneInterfaces("fw")
+	ifaces = c.resolveZoneInterfaces("fw", "")
 	if len(ifaces) != 1 || ifaces[0] != "" {
 		t.Errorf("resolveZoneInterfaces(fw) = %v, want [\"\"]", ifaces)
 	}
@@ -1758,6 +1761,83 @@ func TestCompile_PortAndProtoLists(t *testing.T) {
 	}
 }
 
+func TestCompile_OutputPolicyMatchesOif(t *testing.T) {
+	cfg := listCfg(func(c *config.Config) {
+		c.Zones["lan"] = config.Zone{Type: config.ZoneIP}
+		c.Interfaces = append(c.Interfaces, config.Interface{Zone: "lan", Interface: "eth1"})
+		c.Policy = []config.Policy{{Source: "fw", Dest: "lan", Action: config.PolicyAccept}}
+	})
+	got := taggedRules(mustCompile(t, cfg), "output", "policy:0")
+	if len(got) != 1 || describeRule(got[0]) != "oif=eth1" {
+		t.Fatalf("fw->lan policy = %v, want one rule oif=eth1", got)
+	}
+}
+
+func TestCompile_InterfacelessZonesFailClosed(t *testing.T) {
+	ipsec := func(c *config.Config) { c.Zones["ips"] = config.Zone{Type: config.ZoneIPSec} }
+	rule := func(dest string) func(*config.Config) {
+		return func(c *config.Config) {
+			ipsec(c)
+			c.Rules = []config.Rule{{Action: config.RuleAccept, Source: "fw", Dest: dest}}
+		}
+	}
+	tests := []struct {
+		name  string
+		mod   func(*config.Config)
+		tag   string
+		want  int
+		warns []string
+	}{
+		{"ipsec zone without interface", func(c *config.Config) {
+			ipsec(c)
+			c.Policy = []config.Policy{{Source: "fw", Dest: "ips", Action: config.PolicyAccept}}
+		}, "policy:0", 0, []string{"ips"}},
+		{"hosts-only zone", func(c *config.Config) {
+			c.Zones["hst"] = config.Zone{Type: config.ZoneIP}
+			c.Hosts = []config.Host{{Zone: "hst", Interface: "eth0", Addresses: []string{"192.0.2.0/24"}}}
+			c.Policy = []config.Policy{{Source: "fw", Dest: "hst", Action: config.PolicyAccept}}
+		}, "policy:0", 0, []string{"hst"}},
+		{"fw all expansion keeps zones with interfaces", func(c *config.Config) {
+			ipsec(c)
+			c.Zones["hst"] = config.Zone{Type: config.ZoneIP}
+			c.Hosts = []config.Host{{Zone: "hst", Interface: "eth0", Addresses: []string{"192.0.2.0/24"}}}
+			c.Policy = []config.Policy{{Source: "fw", Dest: "all", Action: config.PolicyDrop}}
+		}, "policy:0", 1, []string{"hst", "ips"}},
+		{"negated address does not scope", rule("ips:!192.0.2.1"), "rule:0", 0, []string{"ips"}},
+		{"address scopes", rule("ips:192.0.2.1"), "rule:0", 1, []string{"ips"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var logs bytes.Buffer
+			prev := slog.Default()
+			slog.SetDefault(slog.New(slog.NewTextHandler(&logs, nil)))
+			defer slog.SetDefault(prev)
+
+			state := mustCompile(t, listCfg(tt.mod))
+			got := 0
+			for chain := range state.Rules {
+				for _, r := range taggedRules(state, chain, tt.tag) {
+					got++
+					if describeRule(r) == "" {
+						t.Errorf("%s: un-scoped rule", chain)
+					}
+				}
+			}
+			if got != tt.want {
+				t.Errorf("got %d %s rules, want %d", got, tt.tag, tt.want)
+			}
+			if n := strings.Count(logs.String(), "zone has no interfaces"); n != len(tt.warns) {
+				t.Errorf("got %d warnings, want %d:\n%s", n, len(tt.warns), logs.String())
+			}
+			for _, z := range tt.warns {
+				if n := strings.Count(logs.String(), "zone="+z+"\n"); n != 1 {
+					t.Errorf("zone %s warned %d times, want 1", z, n)
+				}
+			}
+		})
+	}
+}
+
 // describeRule renders a rule's iif/oif/saddr/daddr matches, e.g. "iif=eth1 oif=eth2 daddr=192.0.2.1".
 func describeRule(r ManagedRule) string {
 	var parts []string
@@ -1781,12 +1861,12 @@ func describeRule(r ManagedRule) string {
 				parts = append(parts, "oif="+strings.TrimRight(string(cmp.Data), "\x00"))
 			}
 		case *expr.Payload:
-			if m.Base == expr.PayloadBaseNetworkHeader && m.Len == 4 {
-				name := map[uint32]string{12: "saddr", 16: "daddr"}[m.Offset]
+			if m.Base == expr.PayloadBaseNetworkHeader && (m.Len == 4 || m.Len == 16) {
+				name := map[uint32]string{12: "saddr", 16: "daddr", 8: "saddr", 24: "daddr"}[m.Offset]
 				if cmp.Op == expr.CmpOpNeq {
 					name = "!" + name
 				}
-				parts = append(parts, fmt.Sprintf("%s=%d.%d.%d.%d", name, cmp.Data[0], cmp.Data[1], cmp.Data[2], cmp.Data[3]))
+				parts = append(parts, name+"="+net.IP(cmp.Data).String())
 			}
 		}
 	}
@@ -1803,7 +1883,7 @@ func TestCompile_CommaZoneLists(t *testing.T) {
 		{
 			name: "fw in source list goes to output",
 			rule: config.Rule{Action: config.RuleAccept, Source: "fw,lan", Dest: "svr", Proto: "tcp", DPort: config.PortSpec{"22"}},
-			want: map[string][]string{"output": {""}, "forward": {"iif=eth1 oif=eth2"}},
+			want: map[string][]string{"output": {"oif=eth2"}, "forward": {"iif=eth1 oif=eth2"}},
 		},
 		{
 			name: "dest list with fw splits input and forward",
@@ -1846,9 +1926,54 @@ func TestCompile_CommaZoneLists(t *testing.T) {
 			want: map[string][]string{"forward": {"iif=eth1 oif=eth3", "iif=eth1 oif=eth0"}},
 		},
 		{
-			name: "interface-less ipsec zone keeps zone-agnostic rule, ip zone skipped",
+			name: "interface-less zones are skipped",
 			rule: config.Rule{Action: config.RuleAccept, Source: "lan", Dest: "vpn,dmz"},
-			want: map[string][]string{"forward": {"iif=eth1"}},
+			want: map[string][]string{},
+		},
+		{
+			name: "interface-less zone kept when address narrows it",
+			rule: config.Rule{Action: config.RuleAccept, Source: "lan", Dest: "vpn:192.0.2.1"},
+			want: map[string][]string{"forward": {"iif=eth1 daddr=192.0.2.1"}},
+		},
+		{
+			name: "fw source matches dest zone oif",
+			rule: config.Rule{Action: config.RuleAccept, Source: "fw", Dest: "lan,vpn,dmz", Proto: "tcp", DPort: config.PortSpec{"22"}},
+			want: map[string][]string{"output": {"oif=eth1"}},
+		},
+		{
+			name: "fw to all has no oif",
+			rule: config.Rule{Action: config.RuleAccept, Source: "fw", Dest: "all:192.0.2.1"},
+			want: map[string][]string{"output": {"daddr=192.0.2.1"}},
+		},
+		{
+			name: "dnat origdest",
+			rule: config.Rule{Action: config.RuleDNAT, Source: "net", Dest: "svr:192.0.2.17", Proto: "tcp", DPort: config.PortSpec{"80"}, OrigDest: "203.0.113.5"},
+			want: map[string][]string{"prerouting": {"iif=eth0 daddr=203.0.113.5"}},
+		},
+		{
+			name: "dnat origdest list",
+			rule: config.Rule{Action: config.RuleDNAT, Source: "net", Dest: "svr:192.0.2.17", Proto: "tcp", DPort: config.PortSpec{"80"}, OrigDest: "203.0.113.5,203.0.113.6"},
+			want: map[string][]string{"prerouting": {"iif=eth0 daddr=203.0.113.5", "iif=eth0 daddr=203.0.113.6"}},
+		},
+		{
+			name: "dnat negated origdest list",
+			rule: config.Rule{Action: config.RuleDNAT, Source: "net", Dest: "svr:192.0.2.17", Proto: "tcp", DPort: config.PortSpec{"80"}, OrigDest: "!203.0.113.5,203.0.113.6"},
+			want: map[string][]string{"prerouting": {"iif=eth0 !daddr=203.0.113.5 !daddr=203.0.113.6"}},
+		},
+		{
+			name: "accept origdest",
+			rule: config.Rule{Action: config.RuleAccept, Source: "net", Dest: "fw", Proto: "tcp", DPort: config.PortSpec{"22"}, OrigDest: "203.0.113.5"},
+			want: map[string][]string{"input": {"iif=eth0 daddr=203.0.113.5"}},
+		},
+		{
+			name: "origdest does not scope interface-less zone",
+			rule: config.Rule{Action: config.RuleAccept, Source: "vpn", Dest: "fw", Proto: "tcp", DPort: config.PortSpec{"22"}, OrigDest: "203.0.113.5"},
+			want: map[string][]string{},
+		},
+		{
+			name: "accept ipv6 origdest",
+			rule: config.Rule{Action: config.RuleAccept, Source: "net", Dest: "fw", Proto: "tcp", DPort: config.PortSpec{"22"}, OrigDest: "2001:db8::5"},
+			want: map[string][]string{"input": {"iif=eth0 daddr=2001:db8::5"}},
 		},
 		{
 			name:   "blrule zone list",
@@ -2255,3 +2380,36 @@ func TestCompile_ColonRanges(t *testing.T) {
 		})
 	}
 }
+
+func TestMatchOrigDest_FamilyGuard(t *testing.T) {
+	for addr, want := range map[string]byte{
+		"203.0.113.5":               unix.NFPROTO_IPV4,
+		"!203.0.113.0/24,192.0.2.1": unix.NFPROTO_IPV4,
+		"2001:db8::5":               unix.NFPROTO_IPV6,
+	} {
+		e, err := matchOrigDest(addr)
+		if err != nil {
+			t.Fatalf("%s: %v", addr, err)
+		}
+		if m, ok := e[0].(*expr.Meta); !ok || m.Key != expr.MetaKeyNFPROTO || e[1].(*expr.Cmp).Data[0] != want {
+			t.Errorf("%s: missing nfproto %d guard: %v", addr, want, e[:2])
+		}
+	}
+	if _, err := matchOrigDest("!203.0.113.5,2001:db8::5"); err == nil {
+		t.Error("mixed IPv4/IPv6 origdest: want error")
+	}
+}
+
+func TestCompile_OrigDestForwardRejected(t *testing.T) {
+	cfg := &config.Config{
+		Settings:   config.Settings{TableName: "test", AddressFamily: config.FamilyINET},
+		Zones:      map[string]config.Zone{"fw": {Type: config.ZoneFirewall}, "net": {Type: config.ZoneIP}, "svr": {Type: config.ZoneIP}},
+		Interfaces: []config.Interface{{Zone: "net", Interface: "eth0"}, {Zone: "svr", Interface: "eth2"}},
+		Rules:      []config.Rule{{Action: config.RuleAccept, Source: "net", Dest: "svr", Proto: "tcp", DPort: config.PortSpec{"80"}, OrigDest: "203.0.113.5"}},
+		PortGroups: make(map[string]config.PortGroup),
+	}
+	_, err := NewCompiler(cfg).Compile()
+	if err == nil || !strings.Contains(err.Error(), "not supported yet") {
+		t.Fatalf("Compile() error = %v, want forwarded ORIGDEST rejection", err)
+	}
+}