mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 11:06:52 +01:00
Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
729301b409 | ||
|
|
a8c52f5c13 | ||
|
|
13af8dd6f3 |
No files matched your search
@@ -13,11 +13,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|||||||
down with it. A hostinfo returned by StartHandshake had no RemoteList until the handshake loop's first
|
down with it. A hostinfo returned by StartHandshake had no RemoteList until the handshake loop's first
|
||||||
pass attached one, and `create-tunnel -address` set the remote before that. The list is now attached when
|
pass attached one, and `create-tunnel -address` set the remote before that. The list is now attached when
|
||||||
the handshake starts, so a pending hostinfo never exists without one.
|
the handshake starts, so a pending hostinfo never exists without one.
|
||||||
- A firewall rule with `group: []`, `groups:` with no value, or a `groups` entry that isn't a string, such as
|
|
||||||
`groups: [1, 2]`, no longer crashes Nebula on startup or reload. A null `group` or `groups` means none was
|
|
||||||
provided. An unquoted int or bool group, such as `group: 7`, is still read as a string but logs a warning to
|
|
||||||
quote it, since YAML has already turned a value like `007` into `7`. A float, a date, an empty array, a null
|
|
||||||
entry, a nested array, or a map is rejected with an error.
|
|
||||||
|
|
||||||
## [1.11.1] - 2026-08-21
|
## [1.11.1] - 2026-08-21
|
||||||
|
|
||||||
|
|||||||
@@ -2,6 +2,8 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"net/netip"
|
"net/netip"
|
||||||
|
"strconv"
|
||||||
|
"sync"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
@@ -11,6 +13,7 @@ import (
|
|||||||
ct "github.com/slackhq/nebula/cert_test"
|
ct "github.com/slackhq/nebula/cert_test"
|
||||||
"github.com/slackhq/nebula/handshake"
|
"github.com/slackhq/nebula/handshake"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/slackhq/nebula/overlay"
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
@@ -147,6 +150,122 @@ func TestSendNoMetricsCloseTunnelKeepsRebindEpoch(t *testing.T) {
|
|||||||
assert.True(t, hostinfo.markOut(1), "a CloseTunnel send must not consume the rebind epoch")
|
assert.True(t, hostinfo.markOut(1), "a CloseTunnel send must not consume the rebind epoch")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// capturingConn is a udp.Conn that records every WriteTo.
|
||||||
|
type capturingConn struct {
|
||||||
|
udp.NoopConn
|
||||||
|
writes [][]byte
|
||||||
|
addrs []netip.AddrPort
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *capturingConn) WriteTo(b []byte, addr netip.AddrPort) error {
|
||||||
|
c.writes = append(c.writes, append([]byte(nil), b...))
|
||||||
|
c.addrs = append(c.addrs, addr)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestSendNoMetricsViaRelay sends through a relay from the mtu sized buffer the cached packet flush uses. Payloads up
|
||||||
|
// to overlay.MaxMTU go out intact, anything bigger is dropped rather than outgrowing the buffer, which once panicked.
|
||||||
|
func TestSendNoMetricsViaRelay(t *testing.T) {
|
||||||
|
tests := []struct {
|
||||||
|
n int
|
||||||
|
sent bool
|
||||||
|
}{
|
||||||
|
{0, true},
|
||||||
|
{1300, true},
|
||||||
|
{overlay.MaxMTU, true},
|
||||||
|
{overlay.MaxMTU + 1, false}, // too big for the relay's tag
|
||||||
|
{mtu - 47, false}, // too big for the inner tag, this panicked
|
||||||
|
{9000, false}, // a full packet at tun.mtu 9000
|
||||||
|
}
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(strconv.Itoa(tt.n), func(t *testing.T) {
|
||||||
|
// One tunnel to the target, carried end to end, and one to the relay that wraps it
|
||||||
|
targetInit, targetResp := runTestHandshake(t)
|
||||||
|
relayInit, relayResp := runTestHandshake(t)
|
||||||
|
ci, err := newConnectionStateFromResult(targetInit)
|
||||||
|
require.NoError(t, err)
|
||||||
|
relayCI, err := newConnectionStateFromResult(relayInit)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
targetAddr := netip.MustParseAddr("10.0.0.2")
|
||||||
|
relayAddr := netip.MustParseAddr("10.0.0.3")
|
||||||
|
relayRemote := netip.MustParseAddrPort("192.0.2.1:4242")
|
||||||
|
|
||||||
|
relay := &Relay{Type: TerminalType, State: Established, LocalIndex: 5, RemoteIndex: 6, PeerAddr: targetAddr}
|
||||||
|
relayHI := &HostInfo{
|
||||||
|
vpnAddrs: []netip.Addr{relayAddr},
|
||||||
|
ConnectionState: relayCI,
|
||||||
|
relayState: RelayState{
|
||||||
|
relayForByAddr: map[netip.Addr]*Relay{targetAddr: relay},
|
||||||
|
relayForByIdx: map[uint32]*Relay{relay.LocalIndex: relay},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
relayHI.remote.Store(&relayRemote)
|
||||||
|
|
||||||
|
// No remote of its own, so the send has to go via the relay
|
||||||
|
hostinfo := &HostInfo{
|
||||||
|
vpnAddrs: []netip.Addr{targetAddr},
|
||||||
|
ConnectionState: ci,
|
||||||
|
remoteIndexId: 7,
|
||||||
|
relayState: RelayState{
|
||||||
|
relays: []netip.Addr{relayAddr},
|
||||||
|
relayForByAddr: map[netip.Addr]*Relay{},
|
||||||
|
relayForByIdx: map[uint32]*Relay{},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
l := test.NewLogger()
|
||||||
|
hm := newHostMap(l)
|
||||||
|
hm.Hosts[relayAddr] = relayHI
|
||||||
|
conn := &capturingConn{}
|
||||||
|
f := &Interface{
|
||||||
|
l: l,
|
||||||
|
hostMap: hm,
|
||||||
|
messageMetrics: &MessageMetrics{txExhausted: metrics.NewCounter()},
|
||||||
|
writers: []udp.Conn{conn},
|
||||||
|
}
|
||||||
|
f.connectionManager = &connectionManager{intf: f, relayUsed: map[uint32]struct{}{}, relayUsedLock: &sync.RWMutex{}}
|
||||||
|
|
||||||
|
payload := make([]byte, tt.n)
|
||||||
|
for i := range payload {
|
||||||
|
payload[i] = byte(i)
|
||||||
|
}
|
||||||
|
counter := ci.messageCounter.Load()
|
||||||
|
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, payload, make([]byte, 12), make([]byte, mtu), 0)
|
||||||
|
|
||||||
|
if !tt.sent {
|
||||||
|
assert.Empty(t, conn.writes)
|
||||||
|
assert.Equal(t, counter, ci.messageCounter.Load(), "a dropped packet must not spend a counter")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
require.Len(t, conn.writes, 1)
|
||||||
|
assert.Equal(t, relayRemote, conn.addrs[0])
|
||||||
|
pkt := conn.writes[0]
|
||||||
|
|
||||||
|
// The relay authenticates the whole packet under its own header
|
||||||
|
outer := &header.H{}
|
||||||
|
require.NoError(t, outer.Parse(pkt))
|
||||||
|
assert.Equal(t, header.MessageRelay, outer.Subtype)
|
||||||
|
assert.Equal(t, relay.RemoteIndex, outer.RemoteIndex)
|
||||||
|
relayPeer, err := newConnectionStateFromResult(relayResp)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.NoError(t, relayPeer.VerifyRelay(l, outer.MessageCounter, pkt, make([]byte, 12)))
|
||||||
|
|
||||||
|
// Inside it, the target decrypts the end to end packet back to the payload
|
||||||
|
inner := pkt[header.Len : len(pkt)-relayPeer.dKey.Overhead()]
|
||||||
|
h := &header.H{}
|
||||||
|
require.NoError(t, h.Parse(inner))
|
||||||
|
assert.Equal(t, header.Message, h.Type)
|
||||||
|
assert.Equal(t, hostinfo.remoteIndexId, h.RemoteIndex)
|
||||||
|
targetPeer, err := newConnectionStateFromResult(targetResp)
|
||||||
|
require.NoError(t, err)
|
||||||
|
got, err := targetPeer.Decrypt(l, h.MessageCounter, inner, make([]byte, 12))
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, payload, got)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
func TestNewConnectionStateFromResult(t *testing.T) {
|
func TestNewConnectionStateFromResult(t *testing.T) {
|
||||||
initR, respR := runTestHandshake(t)
|
initR, respR := runTestHandshake(t)
|
||||||
|
|
||||||
|
|||||||
@@ -265,6 +265,7 @@ tun:
|
|||||||
# Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 500
|
# Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 500
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
# Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
|
# Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
|
||||||
|
# Anything above 8937, here or on a route below, is capped to 8937 with a warning
|
||||||
mtu: 1300
|
mtu: 1300
|
||||||
|
|
||||||
# the use_offloads setting controls if Nebula will attempt to enable GSO and GRO for the tun device. Linux only, not reloadable.
|
# the use_offloads setting controls if Nebula will attempt to enable GSO and GRO for the tun device. Linux only, not reloadable.
|
||||||
|
|||||||
+17
-65
@@ -967,54 +967,33 @@ func convertRule(l *slog.Logger, p any, table string, i int) (rule, error) {
|
|||||||
r.CAName = toString("ca_name", m)
|
r.CAName = toString("ca_name", m)
|
||||||
r.CASha = toString("ca_sha", m)
|
r.CASha = toString("ca_sha", m)
|
||||||
|
|
||||||
// A null value, `group:` with nothing after it, is the same as no group
|
// Make sure group isn't an array
|
||||||
var singleGroup string
|
if v, ok := m["group"].([]any); ok {
|
||||||
if g, ok := m["group"]; ok && g != nil {
|
if len(v) > 1 {
|
||||||
// Make sure group isn't an array
|
return r, errors.New("group should contain a single value, an array with more than one entry was provided")
|
||||||
v, isArray := g.([]any)
|
|
||||||
if isArray {
|
|
||||||
if len(v) > 1 {
|
|
||||||
return r, errors.New("group should contain a single value, an array with more than one entry was provided")
|
|
||||||
}
|
|
||||||
if len(v) == 0 {
|
|
||||||
return r, errors.New("group should contain a single value, an empty array was provided")
|
|
||||||
}
|
|
||||||
g = v[0]
|
|
||||||
}
|
}
|
||||||
|
|
||||||
var err error
|
l.Warn("group was an array with a single value, converting to simple value",
|
||||||
singleGroup, err = groupName(l, g, table, i)
|
"table", table,
|
||||||
if err != nil {
|
"rule", i,
|
||||||
return r, fmt.Errorf("group should contain a single value, %w", err)
|
)
|
||||||
}
|
m["group"] = v[0]
|
||||||
|
|
||||||
if isArray {
|
|
||||||
l.Warn("group was an array with a single value, converting to simple value",
|
|
||||||
"table", table,
|
|
||||||
"rule", i,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// A null value, `groups:` with nothing after it, is the same as no groups
|
singleGroup := toString("group", m)
|
||||||
if rg, ok := m["groups"]; ok && rg != nil {
|
|
||||||
|
if rg, ok := m["groups"]; ok {
|
||||||
switch reflect.TypeOf(rg).Kind() {
|
switch reflect.TypeOf(rg).Kind() {
|
||||||
case reflect.Slice:
|
case reflect.Slice:
|
||||||
v := reflect.ValueOf(rg)
|
v := reflect.ValueOf(rg)
|
||||||
r.Groups = make([]string, v.Len())
|
r.Groups = make([]string, v.Len())
|
||||||
for gi := 0; gi < v.Len(); gi++ {
|
for i := 0; i < v.Len(); i++ {
|
||||||
name, err := groupName(l, v.Index(gi).Interface(), table, i)
|
r.Groups[i] = v.Index(i).Interface().(string)
|
||||||
if err != nil {
|
|
||||||
return r, fmt.Errorf("groups entry #%d should contain a single value, %w", gi, err)
|
|
||||||
}
|
|
||||||
r.Groups[gi] = name
|
|
||||||
}
|
}
|
||||||
|
case reflect.String:
|
||||||
|
r.Groups = []string{rg.(string)}
|
||||||
default:
|
default:
|
||||||
name, err := groupName(l, rg, table, i)
|
r.Groups = []string{fmt.Sprintf("%v", rg)}
|
||||||
if err != nil {
|
|
||||||
return r, fmt.Errorf("groups should contain an array or a single value, %w", err)
|
|
||||||
}
|
|
||||||
r.Groups = []string{name}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1030,33 +1009,6 @@ func convertRule(l *slog.Logger, p any, table string, i int) (rule, error) {
|
|||||||
return r, nil
|
return r, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// groupName reads a group name from config. YAML has already parsed an unquoted value by the time we see it, so `007`
|
|
||||||
// arrives as 7, `1.10` as 1.1, and a date as a time.Time, and the text that was written is gone. Strings are used as
|
|
||||||
// is. Ints and bools are converted so `group: 7` keeps working, with a warning to quote them. Anything else would
|
|
||||||
// become a name that may not match what was written, or matches nothing like "<nil>" or "map[a:b]", so it is rejected.
|
|
||||||
func groupName(l *slog.Logger, v any, table string, i int) (string, error) {
|
|
||||||
if v == nil {
|
|
||||||
return "", errors.New("a null was provided")
|
|
||||||
}
|
|
||||||
switch reflect.TypeOf(v).Kind() {
|
|
||||||
case reflect.String:
|
|
||||||
return reflect.ValueOf(v).String(), nil
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
|
|
||||||
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Bool:
|
|
||||||
l.Warn("group was not a string and should be quoted to match as written",
|
|
||||||
"table", table,
|
|
||||||
"rule", i,
|
|
||||||
"group", v,
|
|
||||||
)
|
|
||||||
return fmt.Sprintf("%v", v), nil
|
|
||||||
case reflect.Slice, reflect.Array:
|
|
||||||
return "", errors.New("an array was provided")
|
|
||||||
case reflect.Map:
|
|
||||||
return "", errors.New("a map was provided")
|
|
||||||
}
|
|
||||||
return "", fmt.Errorf("%v was read as a %T, quote it to use it as a group name", v, v)
|
|
||||||
}
|
|
||||||
|
|
||||||
// sanity returns an error if the rule would be evaluated in a way that would short-circuit a configured check on a wildcard value
|
// sanity returns an error if the rule would be evaluated in a way that would short-circuit a configured check on a wildcard value
|
||||||
// rules are evaluated as "port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr) AND local_cidr"
|
// rules are evaluated as "port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr) AND local_cidr"
|
||||||
func (r *rule) sanity() error {
|
func (r *rule) sanity() error {
|
||||||
|
|||||||
@@ -1439,56 +1439,6 @@ func TestAddFirewallRulesFromConfig(t *testing.T) {
|
|||||||
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
|
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
|
||||||
assert.Equal(t, addRuleCall{incoming: true, proto: firewall.ProtoAny, startPort: 1, endPort: 1, groups: []string{"a", "b"}, ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: true, proto: firewall.ProtoAny, startPort: 1, endPort: 1, groups: []string{"a", "b"}, ip: "", localIp: ""}, mf.lastCall)
|
||||||
|
|
||||||
// Test group and groups values that used to crash or become a group that matches nothing: an empty array,
|
|
||||||
// a null, an array, or a map is rejected
|
|
||||||
badGroups := []struct {
|
|
||||||
key string
|
|
||||||
value any
|
|
||||||
err string
|
|
||||||
}{
|
|
||||||
{"group", []any{}, "group should contain a single value, an empty array was provided"},
|
|
||||||
{"group", []any{nil}, "group should contain a single value, a null was provided"},
|
|
||||||
{"group", []any{[]any{"a"}}, "group should contain a single value, an array was provided"},
|
|
||||||
{"group", map[string]any{"a": "b"}, "group should contain a single value, a map was provided"},
|
|
||||||
{"groups", []any{nil}, "groups entry #0 should contain a single value, a null was provided"},
|
|
||||||
{"groups", []any{"a", []any{"b"}}, "groups entry #1 should contain a single value, an array was provided"},
|
|
||||||
{"groups", []any{map[string]any{"a": "b"}}, "groups entry #0 should contain a single value, a map was provided"},
|
|
||||||
{"groups", map[string]any{"a": "b"}, "groups should contain an array or a single value, a map was provided"},
|
|
||||||
{"group", 1.1, "group should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
|
|
||||||
{"group", []any{1.1}, "group should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
|
|
||||||
{"groups", []any{"a", 1.1}, "groups entry #1 should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
|
|
||||||
{"groups", time.Date(2001, 12, 14, 0, 0, 0, 0, time.UTC), "groups should contain an array or a single value, 2001-12-14 00:00:00 +0000 UTC was read as a time.Time, quote it to use it as a group name"},
|
|
||||||
}
|
|
||||||
for _, tc := range badGroups {
|
|
||||||
conf = config.NewC(test.NewLogger())
|
|
||||||
mf = &mockFirewall{}
|
|
||||||
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", tc.key: tc.value}}}
|
|
||||||
require.EqualError(t, AddFirewallRulesFromConfig(l, true, conf, mf), "firewall.inbound rule #0; "+tc.err, "%s: %v", tc.key, tc.value)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test int and bool groups entries are read as strings
|
|
||||||
conf = config.NewC(test.NewLogger())
|
|
||||||
mf = &mockFirewall{}
|
|
||||||
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", "groups": []any{1, true}}}}
|
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
|
|
||||||
assert.Equal(t, []string{"1", "true"}, mf.lastCall.groups)
|
|
||||||
|
|
||||||
conf = config.NewC(test.NewLogger())
|
|
||||||
mf = &mockFirewall{}
|
|
||||||
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", "group": 1}}}
|
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
|
|
||||||
assert.Equal(t, []string{"1"}, mf.lastCall.groups)
|
|
||||||
|
|
||||||
// Test a null group or groups is the same as not providing it
|
|
||||||
for _, key := range []string{"group", "groups"} {
|
|
||||||
conf = config.NewC(test.NewLogger())
|
|
||||||
mf = &mockFirewall{}
|
|
||||||
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", key: nil, "host": "a"}}}
|
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
|
|
||||||
assert.Empty(t, mf.lastCall.groups)
|
|
||||||
assert.Equal(t, "a", mf.lastCall.host)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test Add error
|
// Test Add error
|
||||||
conf = config.NewC(test.NewLogger())
|
conf = config.NewC(test.NewLogger())
|
||||||
mf = &mockFirewall{}
|
mf = &mockFirewall{}
|
||||||
|
|||||||
@@ -24,6 +24,11 @@ type m = map[string]any
|
|||||||
const (
|
const (
|
||||||
Version uint8 = 1
|
Version uint8 = 1
|
||||||
Len = 16
|
Len = 16
|
||||||
|
|
||||||
|
// MaxOverhead is the most a payload grows on its way to the underlay.
|
||||||
|
// A relayed packet has two headers and two AEAD tags, one for the inner tunnel and another for the relay tunnel.
|
||||||
|
// Every supported cipher (today) has a 16 byte tag.
|
||||||
|
MaxOverhead = 2 * (Len + 16)
|
||||||
)
|
)
|
||||||
|
|
||||||
type MessageType uint8
|
type MessageType uint8
|
||||||
|
|||||||
@@ -199,8 +199,8 @@ func (f *Interface) sendInsideMessage(hostinfo *HostInfo, pkt tio.Packet, nb []b
|
|||||||
}
|
}
|
||||||
|
|
||||||
err = tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
err = tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
||||||
//relay header + header + plaintext + AEAD tag (16 bytes for both AES-GCM and ChaCha20-Poly1305) + relay tag
|
//relay header + header + plaintext + AEAD tag + relay tag
|
||||||
scratch := sendBatch.Reserve(header.Len + header.Len + len(seg) + 16 + 16)
|
scratch := sendBatch.Reserve(len(seg) + header.MaxOverhead)
|
||||||
|
|
||||||
innerPacket := f.sendInsideEncrypt(hostinfo, ci, seg, scratch[header.Len:], nb)
|
innerPacket := f.sendInsideEncrypt(hostinfo, ci, seg, scratch[header.Len:], nb)
|
||||||
if innerPacket == nil {
|
if innerPacket == nil {
|
||||||
@@ -529,16 +529,26 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
||||||
fullOut := out
|
|
||||||
|
|
||||||
|
// The encrypt appends to out in place and a relayed packet is then wrapped in place,
|
||||||
|
// so out has to fit the whole packet up front or the encrypt reallocates out from under SendVia.
|
||||||
|
// We cap the MTU of tun devices and routes we create ourselves, so only a host that set a bigger MTU than we allow gets here.
|
||||||
|
need := header.Len + len(p) + ci.eKey.Overhead()
|
||||||
if useRelay {
|
if useRelay {
|
||||||
if len(out) < header.Len {
|
// The relay tunnel runs the same cipher, and adds its own header and tag
|
||||||
// out always has a capacity of mtu, but not always a length greater than the header.Len.
|
need += header.Len + ci.eKey.Overhead()
|
||||||
// Grow it to make sure the next operation works.
|
}
|
||||||
out = out[:header.Len]
|
if cap(out) < need {
|
||||||
|
if l, ok := logging.RateLimited(f.l, f.txOversizeLimiter); ok {
|
||||||
|
hostinfo.logger(l).Error("Dropping outbound packet, out buffer not large enough", "outCap", cap(out), "payloadLen", len(p), "relayed", useRelay)
|
||||||
}
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
fullOut := out
|
||||||
|
if useRelay {
|
||||||
// Save a header's worth of data at the front of the 'out' buffer.
|
// Save a header's worth of data at the front of the 'out' buffer.
|
||||||
out = out[header.Len:]
|
out = out[header.Len:header.Len]
|
||||||
}
|
}
|
||||||
|
|
||||||
if noiseutil.EncryptLockNeeded {
|
if noiseutil.EncryptLockNeeded {
|
||||||
|
|||||||
@@ -127,6 +127,7 @@ type Interface struct {
|
|||||||
|
|
||||||
udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter
|
udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter
|
||||||
udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter
|
udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter
|
||||||
|
txOversizeLimiter *ratelimit.Limiter // oversized outbound packet drop log limiter
|
||||||
|
|
||||||
// fatalErr holds the first unexpected reader error that caused shutdown.
|
// fatalErr holds the first unexpected reader error that caused shutdown.
|
||||||
// nil means "no fatal error" (yet)
|
// nil means "no fatal error" (yet)
|
||||||
@@ -210,6 +211,10 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
|
txOversizeLimiter, err := ratelimit.New(1, time.Second)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
if c.routines <= 1 {
|
if c.routines <= 1 {
|
||||||
c.PinThreads = false //pinning is not useful unless there's more than one tun reader
|
c.PinThreads = false //pinning is not useful unless there's more than one tun reader
|
||||||
@@ -245,6 +250,7 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
|||||||
pinThreads: c.PinThreads,
|
pinThreads: c.PinThreads,
|
||||||
udpTxErrLimiter: udpTxErrLimiter,
|
udpTxErrLimiter: udpTxErrLimiter,
|
||||||
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
|
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
|
||||||
|
txOversizeLimiter: txOversizeLimiter,
|
||||||
|
|
||||||
metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)),
|
metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)),
|
||||||
metricTxDropped: metrics.GetOrRegisterCounter("udp.tx.dropped", nil),
|
metricTxDropped: metrics.GetOrRegisterCounter("udp.tx.dropped", nil),
|
||||||
|
|||||||
+1
-3
@@ -160,9 +160,7 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
case header.TestReply:
|
case header.TestReply:
|
||||||
// No-op, useful for the Roaming and connectionManager side-effects above
|
// No-op, useful for the Roaming and connectionManager side-effects above
|
||||||
case header.TestRequest:
|
case header.TestRequest:
|
||||||
const maxCipherOverhead = 16 //todo we use this too often, needs a real importable const
|
if header.MaxOverhead+len(out) > len(rxc.scratch) {
|
||||||
const maxOverhead = header.Len + header.Len + maxCipherOverhead + maxCipherOverhead
|
|
||||||
if maxOverhead+len(out) > len(rxc.scratch) {
|
|
||||||
// A reply that cannot fit in scratch is dropped no matter the log level.
|
// A reply that cannot fit in scratch is dropped no matter the log level.
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
hostinfo.logger(f.l).Debug("dropping oversized test request", "payloadLen", len(out), "from", via)
|
hostinfo.logger(f.l).Debug("dropping oversized test request", "payloadLen", len(out), "from", via)
|
||||||
|
|||||||
+28
-4
@@ -50,7 +50,13 @@ func (r Route) String() string {
|
|||||||
|
|
||||||
func makeRouteTree(l *slog.Logger, routes []Route, allowMTU bool) (*bart.Table[routing.Gateways], error) {
|
func makeRouteTree(l *slog.Logger, routes []Route, allowMTU bool) (*bart.Table[routing.Gateways], error) {
|
||||||
routeTree := new(bart.Table[routing.Gateways])
|
routeTree := new(bart.Table[routing.Gateways])
|
||||||
|
seen := make(map[netip.Prefix]bool, len(routes))
|
||||||
for _, r := range routes {
|
for _, r := range routes {
|
||||||
|
if seen[r.Cidr] {
|
||||||
|
l.Warn("route is listed more than once, only the last entry's via is used", "route", r)
|
||||||
|
}
|
||||||
|
seen[r.Cidr] = true
|
||||||
|
|
||||||
if !allowMTU && r.MTU > 0 {
|
if !allowMTU && r.MTU > 0 {
|
||||||
l.Warn("route MTU is not supported on this platform",
|
l.Warn("route MTU is not supported on this platform",
|
||||||
"goos", runtime.GOOS,
|
"goos", runtime.GOOS,
|
||||||
@@ -98,7 +104,11 @@ func parseRoutes(c *config.C, networks []netip.Prefix) ([]Route, error) {
|
|||||||
|
|
||||||
mtu, ok := rMtu.(int)
|
mtu, ok := rMtu.(int)
|
||||||
if !ok {
|
if !ok {
|
||||||
mtu, err = strconv.Atoi(rMtu.(string))
|
s, ok := rMtu.(string)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("entry %v.mtu in tun.routes is not an integer: %v", i+1, rMtu)
|
||||||
|
}
|
||||||
|
mtu, err = strconv.Atoi(s)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, fmt.Errorf("entry %v.mtu in tun.routes is not an integer: %v", i+1, err)
|
return nil, fmt.Errorf("entry %v.mtu in tun.routes is not an integer: %v", i+1, err)
|
||||||
}
|
}
|
||||||
@@ -174,7 +184,11 @@ func parseUnsafeRoutes(c *config.C, networks []netip.Prefix) ([]Route, error) {
|
|||||||
if rMtu, ok := m["mtu"]; ok {
|
if rMtu, ok := m["mtu"]; ok {
|
||||||
mtu, ok = rMtu.(int)
|
mtu, ok = rMtu.(int)
|
||||||
if !ok {
|
if !ok {
|
||||||
mtu, err = strconv.Atoi(rMtu.(string))
|
s, ok := rMtu.(string)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("entry %v.mtu in tun.unsafe_routes is not an integer: %v", i+1, rMtu)
|
||||||
|
}
|
||||||
|
mtu, err = strconv.Atoi(s)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, fmt.Errorf("entry %v.mtu in tun.unsafe_routes is not an integer: %v", i+1, err)
|
return nil, fmt.Errorf("entry %v.mtu in tun.unsafe_routes is not an integer: %v", i+1, err)
|
||||||
}
|
}
|
||||||
@@ -192,10 +206,15 @@ func parseUnsafeRoutes(c *config.C, networks []netip.Prefix) ([]Route, error) {
|
|||||||
|
|
||||||
metric, ok := rMetric.(int)
|
metric, ok := rMetric.(int)
|
||||||
if !ok {
|
if !ok {
|
||||||
_, err = strconv.ParseInt(rMetric.(string), 10, 32)
|
s, ok := rMetric.(string)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("entry %v.metric in tun.unsafe_routes is not an integer: %v", i+1, rMetric)
|
||||||
|
}
|
||||||
|
n, err := strconv.ParseInt(s, 10, 32)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, fmt.Errorf("entry %v.metric in tun.unsafe_routes is not an integer: %v", i+1, err)
|
return nil, fmt.Errorf("entry %v.metric in tun.unsafe_routes is not an integer: %v", i+1, err)
|
||||||
}
|
}
|
||||||
|
metric = int(n)
|
||||||
}
|
}
|
||||||
|
|
||||||
if metric < 0 || metric > math.MaxInt32 {
|
if metric < 0 || metric > math.MaxInt32 {
|
||||||
@@ -248,10 +267,15 @@ func parseUnsafeRoutes(c *config.C, networks []netip.Prefix) ([]Route, error) {
|
|||||||
|
|
||||||
gatewayWeight, ok := rGatewayWeight.(int)
|
gatewayWeight, ok := rGatewayWeight.(int)
|
||||||
if !ok {
|
if !ok {
|
||||||
_, err = strconv.ParseInt(rGatewayWeight.(string), 10, 32)
|
s, ok := rGatewayWeight.(string)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("entry .weight in tun.unsafe_routes[%v].via[%v] is not an integer", i+1, ig+1)
|
||||||
|
}
|
||||||
|
w, err := strconv.ParseInt(s, 10, 32)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, fmt.Errorf("entry .weight in tun.unsafe_routes[%v].via[%v] is not an integer", i+1, ig+1)
|
return nil, fmt.Errorf("entry .weight in tun.unsafe_routes[%v].via[%v] is not an integer", i+1, ig+1)
|
||||||
}
|
}
|
||||||
|
gatewayWeight = int(w)
|
||||||
}
|
}
|
||||||
|
|
||||||
if gatewayWeight < 1 || gatewayWeight > math.MaxInt32 {
|
if gatewayWeight < 1 || gatewayWeight > math.MaxInt32 {
|
||||||
|
|||||||
@@ -1,13 +1,17 @@
|
|||||||
package overlay
|
package overlay
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
|
"strings"
|
||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/routing"
|
"github.com/slackhq/nebula/routing"
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
|
"github.com/slackhq/nebula/udp"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
@@ -402,3 +406,115 @@ func Test_makeMultipathUnsafeRouteTree(t *testing.T) {
|
|||||||
routing.CalculateBucketsForGateways(expectedGateways)
|
routing.CalculateBucketsForGateways(expectedGateways)
|
||||||
assert.ElementsMatch(t, expectedGateways, r)
|
assert.ElementsMatch(t, expectedGateways, r)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func Test_getMTU(t *testing.T) {
|
||||||
|
l := test.NewLogger()
|
||||||
|
c := config.NewC(l)
|
||||||
|
|
||||||
|
// unset
|
||||||
|
assert.Equal(t, DefaultMTU, getMTU(l, c))
|
||||||
|
|
||||||
|
// the largest a relayed packet can carry in one underlay buffer
|
||||||
|
require.Equal(t, udp.MTU, MaxMTU+header.MaxOverhead)
|
||||||
|
c.Settings["tun"] = map[string]any{"mtu": MaxMTU}
|
||||||
|
assert.Equal(t, MaxMTU, getMTU(l, c))
|
||||||
|
|
||||||
|
// too big is capped
|
||||||
|
c.Settings["tun"] = map[string]any{"mtu": 9000}
|
||||||
|
assert.Equal(t, MaxMTU, getMTU(l, c))
|
||||||
|
}
|
||||||
|
|
||||||
|
func Test_getAllRoutesFromConfigCapsMTU(t *testing.T) {
|
||||||
|
l := test.NewLogger()
|
||||||
|
c := config.NewC(l)
|
||||||
|
c.Settings["tun"] = map[string]any{
|
||||||
|
"routes": []any{
|
||||||
|
map[string]any{"mtu": "9000", "route": "10.0.0.0/29"},
|
||||||
|
map[string]any{"mtu": "1300", "route": "10.0.0.8/29"},
|
||||||
|
},
|
||||||
|
"unsafe_routes": []any{
|
||||||
|
map[string]any{"via": "127.0.0.1", "mtu": "9000", "route": "1.0.0.0/29"},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
changed, routes, err := getAllRoutesFromConfig(l, c, []netip.Prefix{netip.MustParsePrefix("10.0.0.0/24")}, true)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.True(t, changed)
|
||||||
|
|
||||||
|
mtus := map[string]int{}
|
||||||
|
for _, r := range routes {
|
||||||
|
mtus[r.Cidr.String()] = r.MTU
|
||||||
|
}
|
||||||
|
assert.Equal(t, map[string]int{"10.0.0.0/29": MaxMTU, "10.0.0.8/29": 1300, "1.0.0.0/29": MaxMTU}, mtus)
|
||||||
|
}
|
||||||
|
|
||||||
|
// The route tree keeps one entry per CIDR, so a CIDR listed twice only routes by the last one. Say so instead of
|
||||||
|
// letting the earlier via, or on Windows the earlier metric, quietly lose
|
||||||
|
func Test_makeRouteTree_WarnsOnDuplicate(t *testing.T) {
|
||||||
|
buf := &bytes.Buffer{}
|
||||||
|
l := test.NewLoggerWithOutput(buf)
|
||||||
|
via := func(s string) routing.Gateways {
|
||||||
|
return routing.Gateways{routing.NewGateway(netip.MustParseAddr(s), 1)}
|
||||||
|
}
|
||||||
|
cidr := netip.MustParsePrefix("10.251.1.0/24")
|
||||||
|
|
||||||
|
_, err := makeRouteTree(l, []Route{
|
||||||
|
{Cidr: cidr, Via: via("10.250.0.2"), Install: true, Metric: 100},
|
||||||
|
{Cidr: netip.MustParsePrefix("10.251.2.0/24"), Via: via("10.250.0.2"), Install: true},
|
||||||
|
}, false)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Empty(t, buf.String())
|
||||||
|
|
||||||
|
tree, err := makeRouteTree(l, []Route{
|
||||||
|
{Cidr: cidr, Via: via("10.250.0.2"), Install: true, Metric: 100},
|
||||||
|
{Cidr: cidr, Via: via("10.250.0.3"), Install: true, Metric: 200},
|
||||||
|
}, false)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, 1, strings.Count(buf.String(), "route is listed more than once, only the last entry's via is used"))
|
||||||
|
gw, ok := tree.Lookup(netip.MustParseAddr("10.251.1.1"))
|
||||||
|
require.True(t, ok)
|
||||||
|
assert.Equal(t, netip.MustParseAddr("10.250.0.3"), gw[0].Addr(), "the last entry wins")
|
||||||
|
}
|
||||||
|
|
||||||
|
// A quoted metric or weight is a number written as a string, it means that number. Anything else is an error, not a
|
||||||
|
// panic
|
||||||
|
func Test_parseUnsafeRoutes_QuotedNumbers(t *testing.T) {
|
||||||
|
c := config.NewC(test.NewLogger())
|
||||||
|
n := netip.MustParsePrefix("10.0.0.1/24")
|
||||||
|
route := func(metric, weight any) {
|
||||||
|
c.Settings["tun"] = map[string]any{"unsafe_routes": []any{map[string]any{
|
||||||
|
"route": "1.0.0.0/8",
|
||||||
|
"metric": metric,
|
||||||
|
"via": []any{map[string]any{"gateway": "10.0.0.2", "weight": weight}},
|
||||||
|
}}}
|
||||||
|
}
|
||||||
|
|
||||||
|
route("100", "5")
|
||||||
|
routes, err := parseUnsafeRoutes(c, []netip.Prefix{n})
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Len(t, routes, 1)
|
||||||
|
assert.Equal(t, 100, routes[0].Metric)
|
||||||
|
assert.Equal(t, "{addr: 10.0.0.2, weight: 5}", routes[0].Via[0].String())
|
||||||
|
|
||||||
|
route(1.5, 1)
|
||||||
|
_, err = parseUnsafeRoutes(c, []netip.Prefix{n})
|
||||||
|
require.EqualError(t, err, "entry 1.metric in tun.unsafe_routes is not an integer: 1.5")
|
||||||
|
|
||||||
|
route(1, true)
|
||||||
|
_, err = parseUnsafeRoutes(c, []netip.Prefix{n})
|
||||||
|
require.EqualError(t, err, "entry .weight in tun.unsafe_routes[1].via[1] is not an integer")
|
||||||
|
}
|
||||||
|
|
||||||
|
// An mtu that is neither a number nor a quoted one is an error, not a panic
|
||||||
|
func Test_parseRoutes_MTUNotANumber(t *testing.T) {
|
||||||
|
c := config.NewC(test.NewLogger())
|
||||||
|
n := netip.MustParsePrefix("10.0.0.1/24")
|
||||||
|
|
||||||
|
c.Settings["tun"] = map[string]any{"routes": []any{map[string]any{"route": "1.0.0.0/8", "mtu": 1500.5}}}
|
||||||
|
_, err := parseRoutes(c, []netip.Prefix{n})
|
||||||
|
require.EqualError(t, err, "entry 1.mtu in tun.routes is not an integer: 1500.5")
|
||||||
|
|
||||||
|
c.Settings["tun"] = map[string]any{"unsafe_routes": []any{map[string]any{"route": "1.0.0.0/8", "via": "10.0.0.2", "mtu": 1500.5}}}
|
||||||
|
_, err = parseUnsafeRoutes(c, []netip.Prefix{n})
|
||||||
|
require.EqualError(t, err, "entry 1.mtu in tun.unsafe_routes is not an integer: 1500.5")
|
||||||
|
}
|
||||||
+23
-1
@@ -7,11 +7,27 @@ import (
|
|||||||
"net/netip"
|
"net/netip"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/slackhq/nebula/udp"
|
||||||
"github.com/slackhq/nebula/util"
|
"github.com/slackhq/nebula/util"
|
||||||
)
|
)
|
||||||
|
|
||||||
const DefaultMTU = 1300
|
const DefaultMTU = 1300
|
||||||
|
|
||||||
|
// MaxMTU is the largest tun.mtu, or route mtu, the underlay can carry.
|
||||||
|
// Every underlay buffer is udp.MTU bytes, and a relayed packet adds header.MaxOverhead to its plaintext.
|
||||||
|
const MaxMTU = udp.MTU - header.MaxOverhead
|
||||||
|
|
||||||
|
// getMTU reads tun.mtu, capping a value too big for the underlay to carry.
|
||||||
|
func getMTU(l *slog.Logger, c *config.C) int {
|
||||||
|
mtu := c.GetInt("tun.mtu", DefaultMTU)
|
||||||
|
if mtu > MaxMTU {
|
||||||
|
l.Warn("tun.mtu is too big for the underlay to carry, capping it", "mtu", mtu, "maxMTU", MaxMTU)
|
||||||
|
return MaxMTU
|
||||||
|
}
|
||||||
|
return mtu
|
||||||
|
}
|
||||||
|
|
||||||
type NameError struct {
|
type NameError struct {
|
||||||
Name string
|
Name string
|
||||||
Underlying error
|
Underlying error
|
||||||
@@ -41,7 +57,7 @@ func NewFdDeviceFromConfig(fd *int) DeviceFactory {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func getAllRoutesFromConfig(c *config.C, vpnNetworks []netip.Prefix, initial bool) (bool, []Route, error) {
|
func getAllRoutesFromConfig(l *slog.Logger, c *config.C, vpnNetworks []netip.Prefix, initial bool) (bool, []Route, error) {
|
||||||
if !initial && !c.HasChanged("tun.routes") && !c.HasChanged("tun.unsafe_routes") {
|
if !initial && !c.HasChanged("tun.routes") && !c.HasChanged("tun.unsafe_routes") {
|
||||||
return false, nil, nil
|
return false, nil, nil
|
||||||
}
|
}
|
||||||
@@ -57,6 +73,12 @@ func getAllRoutesFromConfig(c *config.C, vpnNetworks []netip.Prefix, initial boo
|
|||||||
}
|
}
|
||||||
|
|
||||||
routes = append(routes, unsafeRoutes...)
|
routes = append(routes, unsafeRoutes...)
|
||||||
|
for i, r := range routes {
|
||||||
|
if r.MTU > MaxMTU {
|
||||||
|
l.Warn("route mtu is too big for the underlay to carry, capping it", "route", r.Cidr, "mtu", r.MTU, "maxMTU", MaxMTU)
|
||||||
|
routes[i].MTU = MaxMTU
|
||||||
|
}
|
||||||
|
}
|
||||||
return true, routes, nil
|
return true, routes, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -68,7 +68,7 @@ func (t *tun) Activate() error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -126,7 +126,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*t
|
|||||||
f: os.NewFile(uintptr(fd), ""),
|
f: os.NewFile(uintptr(fd), ""),
|
||||||
Device: name,
|
Device: name,
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
DefaultMTU: c.GetInt("tun.mtu", DefaultMTU),
|
DefaultMTU: getMTU(l, c),
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -167,7 +167,7 @@ func newTunFromFd(c *config.C, l *slog.Logger, deviceFd int, vpnNetworks []netip
|
|||||||
f: file,
|
f: file,
|
||||||
Device: utunNameFromFd(deviceFd),
|
Device: utunNameFromFd(deviceFd),
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
DefaultMTU: c.GetInt("tun.mtu", DefaultMTU),
|
DefaultMTU: getMTU(l, c),
|
||||||
hostOwned: true,
|
hostOwned: true,
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
@@ -350,7 +350,7 @@ func (t *tun) activate6(network netip.Prefix) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -370,7 +370,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*t
|
|||||||
t := &tun{
|
t := &tun{
|
||||||
Device: deviceName,
|
Device: deviceName,
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
MTU: c.GetInt("tun.mtu", DefaultMTU),
|
MTU: getMTU(l, c),
|
||||||
l: l,
|
l: l,
|
||||||
fd: fd,
|
fd: fd,
|
||||||
shutdownR: shutdownR,
|
shutdownR: shutdownR,
|
||||||
@@ -510,7 +510,7 @@ func (t *tun) setMTU() error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
+1
-1
@@ -68,7 +68,7 @@ func (t *tun) Activate() error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -244,7 +244,7 @@ func newTunGeneric(c *config.C, l *slog.Logger, fd int, vnetHdr bool, offloadFla
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
routeChange, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
routeChange, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -256,7 +256,7 @@ func (t *tun) reload(c *config.C, initial bool) error {
|
|||||||
// Only the mtu changed. The routes are the same, parse them again so the ones without their own mtu pick up the
|
// Only the mtu changed. The routes are the same, parse them again so the ones without their own mtu pick up the
|
||||||
// new default. Without this an mtu change would remove them all
|
// new default. Without this an mtu change would remove them all
|
||||||
if !routeChange {
|
if !routeChange {
|
||||||
_, routes, err = getAllRoutesFromConfig(c, t.vpnNetworks, true)
|
_, routes, err = getAllRoutesFromConfig(t.l, c, t.vpnNetworks, true)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -276,7 +276,7 @@ func (t *tun) reload(c *config.C, initial bool) error {
|
|||||||
|
|
||||||
oldDefaultMTU := t.DefaultMTU
|
oldDefaultMTU := t.DefaultMTU
|
||||||
oldMaxMTU := t.MaxMTU
|
oldMaxMTU := t.MaxMTU
|
||||||
newDefaultMTU := c.GetInt("tun.mtu", DefaultMTU)
|
newDefaultMTU := getMTU(t.l, c)
|
||||||
newMaxMTU := newDefaultMTU
|
newMaxMTU := newDefaultMTU
|
||||||
for i, r := range routes {
|
for i, r := range routes {
|
||||||
if r.MTU == 0 {
|
if r.MTU == 0 {
|
||||||
|
|||||||
@@ -99,7 +99,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*t
|
|||||||
fd: fd,
|
fd: fd,
|
||||||
Device: deviceName,
|
Device: deviceName,
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
MTU: c.GetInt("tun.mtu", DefaultMTU),
|
MTU: getMTU(l, c),
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -340,7 +340,7 @@ func (t *tun) doIoctlByName(ctl uintptr, value uint32) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -90,7 +90,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*t
|
|||||||
fd: fd,
|
fd: fd,
|
||||||
Device: deviceName,
|
Device: deviceName,
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
MTU: c.GetInt("tun.mtu", DefaultMTU),
|
MTU: getMTU(l, c),
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -319,7 +319,7 @@ func (t *tun) doIoctlByName(ctl uintptr, value uint32) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) reload(c *config.C, initial bool) error {
|
func (t *tun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -31,7 +31,7 @@ type TestTun struct {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*TestTun, error) {
|
func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*TestTun, error) {
|
||||||
_, routes, err := getAllRoutesFromConfig(c, vpnNetworks, true)
|
_, routes, err := getAllRoutesFromConfig(l, c, vpnNetworks, true)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
|
|||||||
+77
-6
@@ -4,6 +4,7 @@ package overlay
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto"
|
"crypto"
|
||||||
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
@@ -75,7 +76,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*w
|
|||||||
t := &winTun{
|
t := &winTun{
|
||||||
Device: deviceName,
|
Device: deviceName,
|
||||||
vpnNetworks: vpnNetworks,
|
vpnNetworks: vpnNetworks,
|
||||||
MTU: c.GetInt("tun.mtu", DefaultMTU),
|
MTU: getMTU(l, c),
|
||||||
guid: *guid,
|
guid: *guid,
|
||||||
networkCategory: cat,
|
networkCategory: cat,
|
||||||
setCategory: setCat,
|
setCategory: setCat,
|
||||||
@@ -118,7 +119,7 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*w
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *winTun) reload(c *config.C, initial bool) error {
|
func (t *winTun) reload(c *config.C, initial bool) error {
|
||||||
change, routes, err := getAllRoutesFromConfig(c, t.vpnNetworks, initial)
|
change, routes, err := getAllRoutesFromConfig(t.l, c, t.vpnNetworks, initial)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -138,7 +139,7 @@ func (t *winTun) reload(c *config.C, initial bool) error {
|
|||||||
|
|
||||||
if !initial {
|
if !initial {
|
||||||
// Remove first, if the system removes a wanted route hopefully it will be re-added next
|
// Remove first, if the system removes a wanted route hopefully it will be re-added next
|
||||||
err := t.removeRoutes(findRemovedRoutes(routes, *oldRoutes))
|
err := t.removeRoutes(findRemovedSystemRoutes(routes, *oldRoutes))
|
||||||
if err != nil {
|
if err != nil {
|
||||||
util.LogWithContextIfNeeded("Failed to remove routes", err, t.l)
|
util.LogWithContextIfNeeded("Failed to remove routes", err, t.l)
|
||||||
}
|
}
|
||||||
@@ -187,17 +188,27 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
foundDefault4 := false
|
foundDefault4 := false
|
||||||
carriesV6 := slices.ContainsFunc(t.vpnNetworks, func(p netip.Prefix) bool { return p.Addr().Is6() })
|
carriesV6 := slices.ContainsFunc(t.vpnNetworks, func(p netip.Prefix) bool { return p.Addr().Is6() })
|
||||||
|
|
||||||
for _, r := range routes {
|
// A CIDR listed twice routes by its last entry, install only that one or each reload would flip between them. The
|
||||||
|
// same rule as systemRoutes
|
||||||
|
last := make(map[netip.Prefix]int, len(routes))
|
||||||
|
for i, r := range routes {
|
||||||
|
last[r.Cidr] = i
|
||||||
|
}
|
||||||
|
|
||||||
|
for i, r := range routes {
|
||||||
if len(r.Via) == 0 || !r.Install {
|
if len(r.Via) == 0 || !r.Install {
|
||||||
// We don't allow route MTUs so only install routes with a via
|
// We don't allow route MTUs so only install routes with a via
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
|
if last[r.Cidr] != i {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
// A v6 unsafe_route is legal under a v4-only cert; uninstalled ones put nothing on the adapter.
|
// A v6 unsafe_route is legal under a v4-only cert; uninstalled ones put nothing on the adapter.
|
||||||
carriesV6 = carriesV6 || r.Cidr.Addr().Is6()
|
carriesV6 = carriesV6 || r.Cidr.Addr().Is6()
|
||||||
|
|
||||||
// Add our unsafe route as an on-link route to the nebula tun device.
|
// Add our unsafe route as an on-link route to the nebula tun device.
|
||||||
err := luid.AddRoute(r.Cidr, unspecifiedNextHop(r.Cidr), uint32(r.Metric))
|
result, err := addRoute(luid, r)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
retErr := util.NewContextualError("Failed to add route", map[string]any{"route": r}, err)
|
retErr := util.NewContextualError("Failed to add route", map[string]any{"route": r}, err)
|
||||||
if logErrors {
|
if logErrors {
|
||||||
@@ -207,7 +218,12 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
return retErr
|
return retErr
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
t.l.Info("Added route", "route", r)
|
switch result {
|
||||||
|
case routeAdded:
|
||||||
|
t.l.Info("Added route", "route", r)
|
||||||
|
case routeMetricUpdated:
|
||||||
|
t.l.Info("Updated route metric", "route", r)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if !foundDefault4 {
|
if !foundDefault4 {
|
||||||
@@ -319,6 +335,61 @@ func (t *winTun) Close() error {
|
|||||||
return t.tun.Close()
|
return t.tun.Close()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// systemRoutes maps each CIDR to the route that puts it in the system table. A CIDR's last entry decides, including
|
||||||
|
// one that says not to install it
|
||||||
|
func systemRoutes(routes []Route) map[netip.Prefix]Route {
|
||||||
|
out := make(map[netip.Prefix]Route, len(routes))
|
||||||
|
for _, r := range routes {
|
||||||
|
if len(r.Via) > 0 && r.Install {
|
||||||
|
out[r.Cidr] = r
|
||||||
|
} else {
|
||||||
|
delete(out, r.Cidr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// findRemovedSystemRoutes is the routes to delete from the system table. Windows deletes by destination and next hop,
|
||||||
|
// so only a CIDR nothing installs anymore goes, a changed metric is set on the route in place by addRoute
|
||||||
|
func findRemovedSystemRoutes(newRoutes, oldRoutes []Route) []Route {
|
||||||
|
keep := systemRoutes(newRoutes)
|
||||||
|
var removed []Route
|
||||||
|
for _, r := range systemRoutes(oldRoutes) {
|
||||||
|
if _, ok := keep[r.Cidr]; !ok {
|
||||||
|
removed = append(removed, r)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return removed
|
||||||
|
}
|
||||||
|
|
||||||
|
type routeResult int
|
||||||
|
|
||||||
|
const (
|
||||||
|
routeAdded routeResult = iota
|
||||||
|
routeMetricUpdated
|
||||||
|
routeAlreadyInstalled
|
||||||
|
)
|
||||||
|
|
||||||
|
// addRoute installs r on the interface. A reload re-adds every route to catch any the system dropped, and Windows
|
||||||
|
// refuses one it has with the same destination and next hop whatever its metric. One that is there with another
|
||||||
|
// metric, ours from before a metric change or someone else's, is brought to ours in place
|
||||||
|
func addRoute(luid winipcfg.LUID, r Route) (routeResult, error) {
|
||||||
|
nextHop := unspecifiedNextHop(r.Cidr)
|
||||||
|
err := luid.AddRoute(r.Cidr, nextHop, uint32(r.Metric))
|
||||||
|
if !errors.Is(err, windows.ERROR_OBJECT_ALREADY_EXISTS) {
|
||||||
|
return routeAdded, err
|
||||||
|
}
|
||||||
|
row, err := luid.Route(r.Cidr, nextHop)
|
||||||
|
if err != nil {
|
||||||
|
return routeAlreadyInstalled, err
|
||||||
|
}
|
||||||
|
if row.Metric != uint32(r.Metric) {
|
||||||
|
row.Metric = uint32(r.Metric)
|
||||||
|
return routeMetricUpdated, row.Set()
|
||||||
|
}
|
||||||
|
return routeAlreadyInstalled, nil
|
||||||
|
}
|
||||||
|
|
||||||
func unspecifiedNextHop(p netip.Prefix) netip.Addr {
|
func unspecifiedNextHop(p netip.Prefix) netip.Addr {
|
||||||
if p.Addr().Is4() {
|
if p.Addr().Is4() {
|
||||||
return netip.IPv4Unspecified()
|
return netip.IPv4Unspecified()
|
||||||
|
|||||||
@@ -0,0 +1,168 @@
|
|||||||
|
//go:build windows && !e2e_testing
|
||||||
|
|
||||||
|
package overlay
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"net/netip"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/config"
|
||||||
|
"github.com/slackhq/nebula/test"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
"golang.org/x/sys/windows"
|
||||||
|
"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
|
||||||
|
)
|
||||||
|
|
||||||
|
type routeTest struct {
|
||||||
|
c *config.C
|
||||||
|
tun *winTun
|
||||||
|
luid winipcfg.LUID
|
||||||
|
log *bytes.Buffer
|
||||||
|
}
|
||||||
|
|
||||||
|
// newRouteTest makes a wintun device of its own, before installing tun.unsafe_routes from cfg
|
||||||
|
func newRouteTest(t *testing.T, cfg string) *routeTest {
|
||||||
|
t.Helper()
|
||||||
|
if !windows.GetCurrentProcessToken().IsElevated() {
|
||||||
|
t.Skip("creating a wintun device needs an elevated process")
|
||||||
|
}
|
||||||
|
if err := checkWinTunExists(); err != nil {
|
||||||
|
t.Skipf("wintun.dll is not where nebula looks for it: %v", err)
|
||||||
|
}
|
||||||
|
rt := &routeTest{log: &bytes.Buffer{}}
|
||||||
|
l := test.NewLoggerWithOutput(rt.log)
|
||||||
|
rt.c = config.NewC(l)
|
||||||
|
require.NoError(t, rt.c.LoadString(cfg))
|
||||||
|
var err error
|
||||||
|
rt.tun, err = newTun(rt.c, l, []netip.Prefix{netip.MustParsePrefix("10.250.0.1/24")}, false)
|
||||||
|
require.NoError(t, err)
|
||||||
|
t.Cleanup(func() { _ = rt.tun.Close() })
|
||||||
|
rt.luid = winipcfg.LUID(rt.tun.tun.LUID())
|
||||||
|
return rt
|
||||||
|
}
|
||||||
|
|
||||||
|
func (rt *routeTest) metric(t *testing.T, cidr string) uint32 {
|
||||||
|
t.Helper()
|
||||||
|
p := netip.MustParsePrefix(cidr)
|
||||||
|
row, err := rt.luid.Route(p, unspecifiedNextHop(p))
|
||||||
|
require.NoError(t, err)
|
||||||
|
return row.Metric
|
||||||
|
}
|
||||||
|
|
||||||
|
func unsafeRoutes(routes ...string) string {
|
||||||
|
var b strings.Builder
|
||||||
|
b.WriteString("tun:\n dev: nebroutetest\n unsafe_routes:\n")
|
||||||
|
// cidr[@metric][!], the ! for install: false
|
||||||
|
for _, r := range routes {
|
||||||
|
r, noInstall := strings.CutSuffix(r, "!")
|
||||||
|
cidr, metric, _ := strings.Cut(r, "@")
|
||||||
|
fmt.Fprintf(&b, " - route: %s\n via: 10.250.0.2\n", cidr)
|
||||||
|
if metric != "" {
|
||||||
|
fmt.Fprintf(&b, " metric: %s\n", metric)
|
||||||
|
}
|
||||||
|
if noInstall {
|
||||||
|
b.WriteString(" install: false\n")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return b.String()
|
||||||
|
}
|
||||||
|
|
||||||
|
// A reload that adds a route re-adds the ones already installed, Windows refusing those as already there isn't a failure
|
||||||
|
func TestWinTun_ReloadKeepsInstalledRoutes(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a))
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
|
||||||
|
require.NoError(t, rt.c.ReloadConfigString(unsafeRoutes(a, b)))
|
||||||
|
assert.NotContains(t, rt.log.String(), "Failed to add route")
|
||||||
|
rt.metric(t, a)
|
||||||
|
rt.metric(t, b)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// Windows calls a route the same by destination and next hop, so a changed metric is set on the installed route in
|
||||||
|
// place rather than deleted and added, which would leave a moment with no route
|
||||||
|
func TestWinTun_ReloadMetricChangeApplies(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a+"@100"))
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
require.Equal(t, uint32(100), rt.metric(t, a))
|
||||||
|
|
||||||
|
require.NoError(t, rt.c.ReloadConfigString(unsafeRoutes(a+"@200")))
|
||||||
|
assert.NotContains(t, rt.log.String(), "Failed to add route")
|
||||||
|
assert.NotContains(t, rt.log.String(), "Removed route")
|
||||||
|
assert.Equal(t, uint32(200), rt.metric(t, a))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// A route someone else put on the device with another metric is brought to ours, at startup too
|
||||||
|
func TestWinTun_ForeignRouteGetsOurMetric(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a+"@100"))
|
||||||
|
p := netip.MustParsePrefix(a)
|
||||||
|
require.NoError(t, rt.luid.AddRoute(p, unspecifiedNextHop(p), 50))
|
||||||
|
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
assert.Equal(t, uint32(100), rt.metric(t, a))
|
||||||
|
assert.Contains(t, rt.log.String(), "level=INFO msg=\"Updated route metric\"")
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// A CIDR listed twice is installed once, by its last entry, and reloads leave it there instead of flipping between the
|
||||||
|
// two metrics
|
||||||
|
func TestWinTun_DuplicateCidrInstallsTheLastEntry(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a+"@100", a+"@200"))
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
assert.Equal(t, uint32(200), rt.metric(t, a))
|
||||||
|
|
||||||
|
require.NoError(t, rt.c.ReloadConfigString(unsafeRoutes(a+"@100", a+"@200", b)))
|
||||||
|
assert.Equal(t, uint32(200), rt.metric(t, a))
|
||||||
|
assert.NotContains(t, rt.log.String(), "Updated route metric")
|
||||||
|
assert.NotContains(t, rt.log.String(), "Failed to add route")
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// Dropping the duplicate that wasn't installed leaves the installed route alone. Windows deletes by destination and
|
||||||
|
// next hop, deleting the dropped one would take the live route with it
|
||||||
|
func TestWinTun_DroppingAnUninstalledDuplicateKeepsTheRoute(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a+"@100", a+"@200"))
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
|
||||||
|
require.NoError(t, rt.c.ReloadConfigString(unsafeRoutes(a+"@200")))
|
||||||
|
assert.NotContains(t, rt.log.String(), "Removed route")
|
||||||
|
assert.Equal(t, uint32(200), rt.metric(t, a))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// A reload ends where a fresh start with the same config would, a CIDR whose last entry says not to install it is
|
||||||
|
// removed
|
||||||
|
func TestWinTun_ReloadMatchesAFreshStart(t *testing.T) {
|
||||||
|
forFamilies(t, func(t *testing.T, a, b string) {
|
||||||
|
cidr := netip.MustParsePrefix(a)
|
||||||
|
routes := unsafeRoutes(a+"@100", a+"@100!")
|
||||||
|
|
||||||
|
fresh := newRouteTest(t, routes)
|
||||||
|
require.NoError(t, fresh.tun.Activate())
|
||||||
|
_, err := fresh.luid.Route(cidr, unspecifiedNextHop(cidr))
|
||||||
|
require.Error(t, err, "a fresh start installed it")
|
||||||
|
require.NoError(t, fresh.tun.Close())
|
||||||
|
|
||||||
|
rt := newRouteTest(t, unsafeRoutes(a+"@100"))
|
||||||
|
require.NoError(t, rt.tun.Activate())
|
||||||
|
require.NoError(t, rt.c.ReloadConfigString(routes))
|
||||||
|
_, err = rt.luid.Route(cidr, unspecifiedNextHop(cidr))
|
||||||
|
assert.Error(t, err, "the reload left it installed")
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// forFamilies runs f with two unsafe_routes CIDRs of each address family, the tun's own network stays IPv4
|
||||||
|
func forFamilies(t *testing.T, f func(t *testing.T, a, b string)) {
|
||||||
|
t.Run("ipv4", func(t *testing.T) { f(t, "10.251.1.0/24", "10.251.2.0/24") })
|
||||||
|
t.Run("ipv6", func(t *testing.T) { f(t, "fd00:251:1::/64", "fd00:251:2::/64") })
|
||||||
|
}
|
||||||
+24
-4
@@ -135,12 +135,23 @@ func (u *StdConn) Rebind() error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// SetRecvBuffer tries SO_RCVBUFFORCE, which needs CAP_NET_ADMIN. Without it we
|
||||||
|
// fall back to SO_RCVBUF, which the kernel clamps to net.core.rmem_max.
|
||||||
func (u *StdConn) SetRecvBuffer(n int) error {
|
func (u *StdConn) SetRecvBuffer(n int) error {
|
||||||
return unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_RCVBUFFORCE, n)
|
err := unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_RCVBUFFORCE, n)
|
||||||
|
if errors.Is(err, unix.EPERM) {
|
||||||
|
err = unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_RCVBUF, n)
|
||||||
|
}
|
||||||
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// SetSendBuffer is SetRecvBuffer for SO_SNDBUFFORCE/SO_SNDBUF and net.core.wmem_max.
|
||||||
func (u *StdConn) SetSendBuffer(n int) error {
|
func (u *StdConn) SetSendBuffer(n int) error {
|
||||||
return unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_SNDBUFFORCE, n)
|
err := unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_SNDBUFFORCE, n)
|
||||||
|
if errors.Is(err, unix.EPERM) {
|
||||||
|
err = unix.SetsockoptInt(u.sysFd, unix.SOL_SOCKET, unix.SO_SNDBUF, n)
|
||||||
|
}
|
||||||
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
func (u *StdConn) SetSoMark(mark int) error {
|
func (u *StdConn) SetSoMark(mark int) error {
|
||||||
@@ -396,8 +407,13 @@ func (u *StdConn) ReloadConfig(c *config.C) {
|
|||||||
b := c.GetInt("listen.read_buffer", 0)
|
b := c.GetInt("listen.read_buffer", 0)
|
||||||
if b > 0 {
|
if b > 0 {
|
||||||
if err := u.SetRecvBuffer(b); err == nil {
|
if err := u.SetRecvBuffer(b); err == nil {
|
||||||
if s, err := u.GetRecvBuffer(); err == nil {
|
// The kernel reports double the requested size
|
||||||
|
if s, err := u.GetRecvBuffer(); err == nil && s >= 2*b {
|
||||||
u.l.Info("listen.read_buffer was set", "size", s)
|
u.l.Info("listen.read_buffer was set", "size", s)
|
||||||
|
} else if err == nil {
|
||||||
|
u.l.Warn("listen.read_buffer was limited by the system",
|
||||||
|
"requested", b, "size", s,
|
||||||
|
"hint", "raise net.core.rmem_max or grant CAP_NET_ADMIN")
|
||||||
} else {
|
} else {
|
||||||
u.l.Warn("Failed to get listen.read_buffer", "error", err)
|
u.l.Warn("Failed to get listen.read_buffer", "error", err)
|
||||||
}
|
}
|
||||||
@@ -409,8 +425,12 @@ func (u *StdConn) ReloadConfig(c *config.C) {
|
|||||||
b = c.GetInt("listen.write_buffer", 0)
|
b = c.GetInt("listen.write_buffer", 0)
|
||||||
if b > 0 {
|
if b > 0 {
|
||||||
if err := u.SetSendBuffer(b); err == nil {
|
if err := u.SetSendBuffer(b); err == nil {
|
||||||
if s, err := u.GetSendBuffer(); err == nil {
|
if s, err := u.GetSendBuffer(); err == nil && s >= 2*b {
|
||||||
u.l.Info("listen.write_buffer was set", "size", s)
|
u.l.Info("listen.write_buffer was set", "size", s)
|
||||||
|
} else if err == nil {
|
||||||
|
u.l.Warn("listen.write_buffer was limited by the system",
|
||||||
|
"requested", b, "size", s,
|
||||||
|
"hint", "raise net.core.wmem_max or grant CAP_NET_ADMIN")
|
||||||
} else {
|
} else {
|
||||||
u.l.Warn("Failed to get listen.write_buffer", "error", err)
|
u.l.Warn("Failed to get listen.write_buffer", "error", err)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,124 @@
|
|||||||
|
//go:build linux && !android && !e2e_testing
|
||||||
|
|
||||||
|
package udp
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"log/slog"
|
||||||
|
"net/netip"
|
||||||
|
"os"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/config"
|
||||||
|
)
|
||||||
|
|
||||||
|
func readSysctlInt(t *testing.T, path string) int {
|
||||||
|
t.Helper()
|
||||||
|
b, err := os.ReadFile(path)
|
||||||
|
if err != nil {
|
||||||
|
t.Skipf("can't read %s: %v", path, err)
|
||||||
|
}
|
||||||
|
n, err := strconv.Atoi(strings.TrimSpace(string(b)))
|
||||||
|
if err != nil {
|
||||||
|
t.Skipf("can't parse %s: %v", path, err)
|
||||||
|
}
|
||||||
|
return n
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestSetBufferAboveSysctlMax asks for more than net.core.{r,w}mem_max. With
|
||||||
|
// CAP_NET_ADMIN the FORCE variant takes it as is; without it we must fall back
|
||||||
|
// to the plain option and get the clamped size instead of EPERM.
|
||||||
|
func TestSetBufferAboveSysctlMax(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
name string
|
||||||
|
sysctl string
|
||||||
|
set func(*StdConn, int) error
|
||||||
|
get func(*StdConn) (int, error)
|
||||||
|
}{
|
||||||
|
{"read", "/proc/sys/net/core/rmem_max", (*StdConn).SetRecvBuffer, (*StdConn).GetRecvBuffer},
|
||||||
|
{"write", "/proc/sys/net/core/wmem_max", (*StdConn).SetSendBuffer, (*StdConn).GetSendBuffer},
|
||||||
|
}
|
||||||
|
for _, tc := range cases {
|
||||||
|
t.Run(tc.name, func(t *testing.T) {
|
||||||
|
sysMax := readSysctlInt(t, tc.sysctl)
|
||||||
|
c, err := NewListener(testLogger(), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Batch: 1})
|
||||||
|
if err != nil {
|
||||||
|
t.Skipf("NewListener: %v", err)
|
||||||
|
}
|
||||||
|
sc := c.(*StdConn)
|
||||||
|
defer sc.Close()
|
||||||
|
|
||||||
|
want := sysMax + 1<<20
|
||||||
|
if err := tc.set(sc, want); err != nil {
|
||||||
|
t.Fatalf("set %d: %v", want, err)
|
||||||
|
}
|
||||||
|
got, err := tc.get(sc)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("get: %v", err)
|
||||||
|
}
|
||||||
|
// The kernel doubles the value; either path gives at least the clamped size.
|
||||||
|
if got < 2*sysMax {
|
||||||
|
t.Fatalf("effective size %d, want >= %d", got, 2*sysMax)
|
||||||
|
}
|
||||||
|
t.Logf("requested %d, %s=%d, effective %d (forced=%v)", want, tc.sysctl, sysMax, got, got >= 2*want)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestReloadConfigBufferLogLevel checks that a clamped buffer is a Warn, and a
|
||||||
|
// buffer that fits is still the Info it always was.
|
||||||
|
func TestReloadConfigBufferLogLevel(t *testing.T) {
|
||||||
|
sysMax := readSysctlInt(t, "/proc/sys/net/core/rmem_max")
|
||||||
|
if wmax := readSysctlInt(t, "/proc/sys/net/core/wmem_max"); wmax < sysMax {
|
||||||
|
sysMax = wmax
|
||||||
|
}
|
||||||
|
cases := []struct {
|
||||||
|
name string
|
||||||
|
size int
|
||||||
|
want []string
|
||||||
|
}{
|
||||||
|
{"fits", 64 * 1024, []string{"level=INFO msg=\"listen.read_buffer was set\"", "level=INFO msg=\"listen.write_buffer was set\""}},
|
||||||
|
{"too big", sysMax + 1<<20, []string{"level=WARN msg=\"listen.read_buffer was limited by the system\"", "level=WARN msg=\"listen.write_buffer was limited by the system\""}},
|
||||||
|
}
|
||||||
|
for _, tc := range cases {
|
||||||
|
t.Run(tc.name, func(t *testing.T) {
|
||||||
|
var buf bytes.Buffer
|
||||||
|
l := slog.New(slog.NewTextHandler(&buf, nil))
|
||||||
|
c, err := NewListener(l, Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Batch: 1})
|
||||||
|
if err != nil {
|
||||||
|
t.Skipf("NewListener: %v", err)
|
||||||
|
}
|
||||||
|
sc := c.(*StdConn)
|
||||||
|
defer sc.Close()
|
||||||
|
|
||||||
|
if tc.size > sysMax {
|
||||||
|
// With CAP_NET_ADMIN the FORCE variant takes any size, nothing gets limited.
|
||||||
|
if err := sc.SetRecvBuffer(tc.size); err == nil {
|
||||||
|
if got, _ := sc.GetRecvBuffer(); got >= 2*tc.size {
|
||||||
|
t.Skip("FORCE path took the full size, can't observe the limit")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
cfg := config.NewC(l)
|
||||||
|
if err := cfg.LoadString(fmt.Sprintf("listen:\n read_buffer: %d\n write_buffer: %d\n", tc.size, tc.size)); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
buf.Reset()
|
||||||
|
sc.ReloadConfig(cfg)
|
||||||
|
out := buf.String()
|
||||||
|
for _, w := range tc.want {
|
||||||
|
if !strings.Contains(out, w) {
|
||||||
|
t.Errorf("missing %s in:\n%s", w, out)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if strings.Contains(out, "level=ERROR") {
|
||||||
|
t.Errorf("unexpected error log:\n%s", out)
|
||||||
|
}
|
||||||
|
t.Log(out)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -30,7 +30,7 @@ func procyield(cycles uint32)
|
|||||||
|
|
||||||
const (
|
const (
|
||||||
packetsPerRing = 1024
|
packetsPerRing = 1024
|
||||||
// Caps tun.mtu at MTU-32 direct, MTU-64 relayed, unenforced anywhere else. 17.6MB page locked per socket.
|
// Fits a relayed packet at overlay.MaxMTU, which tun.mtu and route mtus are capped to. 17.6MB page locked per socket.
|
||||||
bytesPerPacket = MTU
|
bytesPerPacket = MTU
|
||||||
receiveSpins = 15
|
receiveSpins = 15
|
||||||
)
|
)
|
||||||
|
|||||||
Reference in new issue
Block a user