mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 18:16:52 +01:00
Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fcc6008a78 | ||
|
|
8589b76e1f | ||
|
|
28cff022ee | ||
|
|
8cbee0e965 |
No files matched your search
@@ -222,11 +222,14 @@ test-cov-html:
|
|||||||
go test -coverprofile=coverage.out
|
go test -coverprofile=coverage.out
|
||||||
go tool cover -html=coverage.out
|
go tool cover -html=coverage.out
|
||||||
|
|
||||||
|
# The package builds only compile. The final line links an android binary so a linker-only failure
|
||||||
|
# cannot pass CI.
|
||||||
build-test-mobile:
|
build-test-mobile:
|
||||||
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
|
GOARCH=arm64 GOOS=android go build -o /dev/null ${NEBULA_CMD_PATH}
|
||||||
|
|
||||||
bench:
|
bench:
|
||||||
go test -bench=.
|
go test -bench=.
|
||||||
|
|||||||
+34
-4
@@ -868,10 +868,35 @@ func (i *HostInfo) logger(l *slog.Logger) *slog.Logger {
|
|||||||
|
|
||||||
// Utility functions
|
// Utility functions
|
||||||
|
|
||||||
func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
// localInterface is what localAddrs needs from a net.Interface, provided per platform by
|
||||||
|
// localInterfaces. Addrs is deferred so platforms where address lookup is a separate kernel round
|
||||||
|
// trip only pay for interfaces the allow list accepts.
|
||||||
|
type localInterface struct {
|
||||||
|
Name string
|
||||||
|
Addrs func() ([]net.Addr, error)
|
||||||
|
}
|
||||||
|
|
||||||
|
func localAddrs(l *slog.Logger, allowList *LocalAllowList) ([]netip.Addr, error) {
|
||||||
|
return collectLocalAddrs(l, allowList, localInterfaces)
|
||||||
|
}
|
||||||
|
|
||||||
|
// collectLocalAddrs takes its enumerator as an argument so tests can drive the filtering and the
|
||||||
|
// failure branches without depending on the addresses of whatever host they run on. It reports
|
||||||
|
// failures to the caller rather than logging them, because it runs on every lighthouse update and
|
||||||
|
// only the caller can tell a new failure from a repeat of the same one.
|
||||||
|
func collectLocalAddrs(
|
||||||
|
l *slog.Logger,
|
||||||
|
allowList *LocalAllowList,
|
||||||
|
interfaces func() ([]localInterface, error),
|
||||||
|
) ([]netip.Addr, error) {
|
||||||
//FIXME: This function is pretty garbage
|
//FIXME: This function is pretty garbage
|
||||||
var finalAddrs []netip.Addr
|
var finalAddrs []netip.Addr
|
||||||
ifaces, _ := net.Interfaces()
|
var errs []error
|
||||||
|
ifaces, err := interfaces()
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("failed to enumerate local interfaces: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
for _, i := range ifaces {
|
for _, i := range ifaces {
|
||||||
allow := allowList.AllowName(i.Name)
|
allow := allowList.AllowName(i.Name)
|
||||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
if l.Enabled(context.Background(), logging.LevelTrace) {
|
||||||
@@ -884,7 +909,12 @@ func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
|||||||
if !allow {
|
if !allow {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
addrs, _ := i.Addrs()
|
addrs, err := i.Addrs()
|
||||||
|
if err != nil {
|
||||||
|
errs = append(errs, fmt.Errorf("failed to get addresses for %s: %w", i.Name, err))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
for _, rawAddr := range addrs {
|
for _, rawAddr := range addrs {
|
||||||
var addr netip.Addr
|
var addr netip.Addr
|
||||||
switch v := rawAddr.(type) {
|
switch v := rawAddr.(type) {
|
||||||
@@ -919,5 +949,5 @@ func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return finalAddrs
|
return finalAddrs, errors.Join(errs...)
|
||||||
}
|
}
|
||||||
@@ -1,6 +1,8 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"errors"
|
||||||
|
"net"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -401,3 +403,94 @@ func TestHostMap_RelayState(t *testing.T) {
|
|||||||
assert.Equal(t, []netip.Addr{}, h1.relayState.relays)
|
assert.Equal(t, []netip.Addr{}, h1.relayState.relays)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestCollectLocalAddrs(t *testing.T) {
|
||||||
|
ifaces := []net.Interface{
|
||||||
|
{Index: 1, Name: "lo"},
|
||||||
|
{Index: 2, Name: "eth0"},
|
||||||
|
{Index: 3, Name: "docker0"},
|
||||||
|
}
|
||||||
|
addrs := map[string][]net.Addr{
|
||||||
|
"lo": {
|
||||||
|
&net.IPNet{IP: net.ParseIP("127.0.0.1"), Mask: net.CIDRMask(8, 32)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("::1"), Mask: net.CIDRMask(128, 128)},
|
||||||
|
},
|
||||||
|
"eth0": {
|
||||||
|
&net.IPNet{IP: net.ParseIP("10.0.0.5"), Mask: net.CIDRMask(24, 32)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("fe80::1"), Mask: net.CIDRMask(64, 128)},
|
||||||
|
&net.IPAddr{IP: net.ParseIP("fd00::5")},
|
||||||
|
},
|
||||||
|
"docker0": {
|
||||||
|
&net.IPNet{IP: net.ParseIP("172.17.0.1"), Mask: net.CIDRMask(16, 32)},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
// enumerate wraps ifaces with the given address lookup.
|
||||||
|
enumerate := func(addrsFor func(name string) ([]net.Addr, error)) func() ([]localInterface, error) {
|
||||||
|
return func() ([]localInterface, error) {
|
||||||
|
out := make([]localInterface, 0, len(ifaces))
|
||||||
|
for _, i := range ifaces {
|
||||||
|
name := i.Name
|
||||||
|
out = append(out, localInterface{
|
||||||
|
Name: name,
|
||||||
|
Addrs: func() ([]net.Addr, error) { return addrsFor(name) },
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return out, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
addrsFor := func(name string) ([]net.Addr, error) { return addrs[name], nil }
|
||||||
|
|
||||||
|
// Loopback and link local are dropped, everything else on every interface is kept.
|
||||||
|
out, err := collectLocalAddrs(test.NewLogger(), nil, enumerate(addrsFor))
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []netip.Addr{
|
||||||
|
netip.MustParseAddr("10.0.0.5"),
|
||||||
|
netip.MustParseAddr("fd00::5"),
|
||||||
|
netip.MustParseAddr("172.17.0.1"),
|
||||||
|
}, out)
|
||||||
|
|
||||||
|
// An interface the allow list rejects by name is never asked for its addresses.
|
||||||
|
c := config.NewC(test.NewLogger())
|
||||||
|
c.Settings["allowlist"] = map[string]any{
|
||||||
|
"interfaces": map[string]any{`docker.*`: false},
|
||||||
|
}
|
||||||
|
al, err := NewLocalAllowListFromConfig(c, "allowlist")
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
asked := make(map[string]struct{})
|
||||||
|
countingAddrsFor := func(name string) ([]net.Addr, error) {
|
||||||
|
asked[name] = struct{}{}
|
||||||
|
return addrs[name], nil
|
||||||
|
}
|
||||||
|
out, err = collectLocalAddrs(test.NewLogger(), al, enumerate(countingAddrsFor))
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []netip.Addr{
|
||||||
|
netip.MustParseAddr("10.0.0.5"),
|
||||||
|
netip.MustParseAddr("fd00::5"),
|
||||||
|
}, out)
|
||||||
|
assert.NotContains(t, asked, "docker0")
|
||||||
|
|
||||||
|
// A failure to enumerate interfaces at all is reported rather than silently advertising nothing.
|
||||||
|
out, err = collectLocalAddrs(
|
||||||
|
test.NewLogger(),
|
||||||
|
nil,
|
||||||
|
func() ([]localInterface, error) { return nil, errors.New("netlinkrib: permission denied") },
|
||||||
|
)
|
||||||
|
assert.Nil(t, out)
|
||||||
|
require.EqualError(t, err, "failed to enumerate local interfaces: netlinkrib: permission denied")
|
||||||
|
|
||||||
|
// One interface failing is reported and skipped, the rest are still collected.
|
||||||
|
out, err = collectLocalAddrs(
|
||||||
|
test.NewLogger(),
|
||||||
|
nil,
|
||||||
|
enumerate(func(name string) ([]net.Addr, error) {
|
||||||
|
if name == "eth0" {
|
||||||
|
return nil, errors.New("nope")
|
||||||
|
}
|
||||||
|
return addrs[name], nil
|
||||||
|
}),
|
||||||
|
)
|
||||||
|
assert.Equal(t, []netip.Addr{netip.MustParseAddr("172.17.0.1")}, out)
|
||||||
|
require.EqualError(t, err, "failed to get addresses for eth0: nope")
|
||||||
|
}
|
||||||
+27
-1
@@ -40,6 +40,10 @@ type LightHouse struct {
|
|||||||
// addresses rather than whatever this machine's NICs happen to be. Set it before Start.
|
// addresses rather than whatever this machine's NICs happen to be. Set it before Start.
|
||||||
localAddrsFn func(*LocalAllowList) []netip.Addr
|
localAddrsFn func(*LocalAllowList) []netip.Addr
|
||||||
|
|
||||||
|
// lastLocalAddrsErr is the previous localAddrsFn failure. Enumeration runs on every update, so an
|
||||||
|
// unchanged failure is demoted to Debug rather than warning every lighthouse.interval forever.
|
||||||
|
lastLocalAddrsErr atomic.Pointer[string]
|
||||||
|
|
||||||
// Local cache of answers from light houses
|
// Local cache of answers from light houses
|
||||||
// map of vpn addr to answers
|
// map of vpn addr to answers
|
||||||
addrMap map[netip.Addr]*RemoteList
|
addrMap map[netip.Addr]*RemoteList
|
||||||
@@ -112,7 +116,9 @@ func NewLightHouseFromConfig(ctx context.Context, l *slog.Logger, c *config.C, c
|
|||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
||||||
return localAddrs(h.l, al)
|
addrs, err := localAddrs(h.l, al)
|
||||||
|
h.logLocalAddrsErr(err)
|
||||||
|
return addrs
|
||||||
}
|
}
|
||||||
|
|
||||||
lighthouses := make([]netip.Addr, 0)
|
lighthouses := make([]netip.Addr, 0)
|
||||||
@@ -913,6 +919,26 @@ func (lh *LightHouse) TriggerUpdate() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logLocalAddrsErr reports a localAddrs failure at Warn the first time it is seen and at Debug while
|
||||||
|
// it persists unchanged, so a permanent failure does not warn on every update forever.
|
||||||
|
func (lh *LightHouse) logLocalAddrsErr(err error) {
|
||||||
|
if err == nil {
|
||||||
|
lh.lastLocalAddrsErr.Store(nil)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
msg := err.Error()
|
||||||
|
prev := lh.lastLocalAddrsErr.Swap(&msg)
|
||||||
|
if prev != nil && *prev == msg {
|
||||||
|
if lh.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
|
lh.l.Debug("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
lh.l.Warn("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
|
||||||
func (lh *LightHouse) SendUpdate() {
|
func (lh *LightHouse) SendUpdate() {
|
||||||
var v4 []*V4AddrPort
|
var v4 []*V4AddrPort
|
||||||
var v6 []*V6AddrPort
|
var v6 []*V6AddrPort
|
||||||
|
|||||||
@@ -1,7 +1,9 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -738,3 +740,32 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
|||||||
out = lh.Query(testHost)
|
out = lh.Query(testHost)
|
||||||
assert.Nil(t, out)
|
assert.Nil(t, out)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestLightHouse_logLocalAddrsErr(t *testing.T) {
|
||||||
|
out := &bytes.Buffer{}
|
||||||
|
lh := &LightHouse{l: test.NewLoggerWithOutput(out)}
|
||||||
|
|
||||||
|
// The first sighting of a failure warns.
|
||||||
|
lh.logLocalAddrsErr(errors.New("permission denied"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
assert.Contains(t, out.String(), "permission denied")
|
||||||
|
|
||||||
|
// Repeating unchanged does not warn again, which is what keeps a permanent failure from warning
|
||||||
|
// on every lighthouse.interval for the life of the process.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(errors.New("permission denied"))
|
||||||
|
assert.NotContains(t, out.String(), "level=WARN")
|
||||||
|
|
||||||
|
// A different failure is a new event and warns.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(errors.New("something else"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
assert.Contains(t, out.String(), "something else")
|
||||||
|
|
||||||
|
// Recovering resets, so the same failure returning later warns again.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(nil)
|
||||||
|
assert.Empty(t, out.String())
|
||||||
|
lh.logLocalAddrsErr(errors.New("something else"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
}
|
||||||
@@ -0,0 +1,18 @@
|
|||||||
|
//go:build !android
|
||||||
|
|
||||||
|
package nebula
|
||||||
|
|
||||||
|
import "net"
|
||||||
|
|
||||||
|
func localInterfaces() ([]localInterface, error) {
|
||||||
|
ifaces, err := net.Interfaces()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
out := make([]localInterface, len(ifaces))
|
||||||
|
for n, i := range ifaces {
|
||||||
|
out[n] = localInterface{Name: i.Name, Addrs: i.Addrs}
|
||||||
|
}
|
||||||
|
return out, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,213 @@
|
|||||||
|
//go:build android
|
||||||
|
|
||||||
|
package nebula
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
"os"
|
||||||
|
"slices"
|
||||||
|
"syscall"
|
||||||
|
"unsafe"
|
||||||
|
|
||||||
|
"golang.org/x/sys/unix"
|
||||||
|
)
|
||||||
|
|
||||||
|
// The Android app sandbox denies bind() on netlink route sockets and RTM_GETLINK, so
|
||||||
|
// net.Interfaces fails with EACCES. Enumerate with an RTM_GETADDR dump on an unbound socket instead.
|
||||||
|
func localInterfaces() ([]localInterface, error) {
|
||||||
|
return netlinkInterfaceAddrs()
|
||||||
|
}
|
||||||
|
|
||||||
|
// netlinkInterfaceAddrs returns every interface that has an address, with its addresses. It dumps
|
||||||
|
// RTM_GETADDR on a netlink socket that is never bound and names each index with SIOCGIFNAME, the
|
||||||
|
// same operations Bionic's getifaddrs uses for app UIDs, which the sandbox permits.
|
||||||
|
func netlinkInterfaceAddrs() ([]localInterface, error) {
|
||||||
|
dump, err := netlinkAddrDump()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
msgs, err := syscall.ParseNetlinkMessage(dump)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
// Any socket will do for SIOCGIFNAME.
|
||||||
|
sfd, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM|unix.SOCK_CLOEXEC, 0)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("socket", err)
|
||||||
|
}
|
||||||
|
defer unix.Close(sfd)
|
||||||
|
|
||||||
|
type iface struct {
|
||||||
|
index uint32
|
||||||
|
name string
|
||||||
|
addrs []net.Addr
|
||||||
|
}
|
||||||
|
var ifaces []*iface
|
||||||
|
byIndex := make(map[uint32]*iface) // nil marks an index that vanished before we could name it
|
||||||
|
for _, m := range msgs {
|
||||||
|
if m.Header.Type != unix.RTM_NEWADDR {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if len(m.Data) < unix.SizeofIfAddrmsg {
|
||||||
|
return nil, fmt.Errorf("short RTM_NEWADDR message: %d bytes", len(m.Data))
|
||||||
|
}
|
||||||
|
ifam := (*unix.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
|
||||||
|
|
||||||
|
i, seen := byIndex[ifam.Index]
|
||||||
|
if !seen {
|
||||||
|
name, err := interfaceNameByIndex(sfd, ifam.Index)
|
||||||
|
if err != nil && !errors.Is(err, unix.ENODEV) {
|
||||||
|
return nil, fmt.Errorf("failed to resolve name of interface %d: %w", ifam.Index, err)
|
||||||
|
}
|
||||||
|
if err == nil {
|
||||||
|
i = &iface{index: ifam.Index, name: name}
|
||||||
|
ifaces = append(ifaces, i)
|
||||||
|
}
|
||||||
|
byIndex[ifam.Index] = i
|
||||||
|
}
|
||||||
|
if i == nil {
|
||||||
|
// The interface went away between the dump and the ioctl.
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
attrs, err := syscall.ParseNetlinkRouteAttr(&m)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if a := newNetlinkAddr(ifam, attrs); a != nil {
|
||||||
|
i.addrs = append(i.addrs, a)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// The dump is grouped by address family. Sort by index to match net.Interfaces.
|
||||||
|
slices.SortFunc(ifaces, func(a, b *iface) int { return int(a.index) - int(b.index) })
|
||||||
|
out := make([]localInterface, 0, len(ifaces))
|
||||||
|
for _, i := range ifaces {
|
||||||
|
addrs := i.addrs
|
||||||
|
out = append(out, localInterface{
|
||||||
|
Name: i.name,
|
||||||
|
Addrs: func() ([]net.Addr, error) { return addrs, nil },
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return out, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// netlinkAddrDump is syscall.NetlinkRIB(RTM_GETADDR, AF_UNSPEC) without the bind() call. The
|
||||||
|
// kernel autobinds the socket on the first send, which the sandbox permits.
|
||||||
|
func netlinkAddrDump() ([]byte, error) {
|
||||||
|
fd, err := unix.Socket(unix.AF_NETLINK, unix.SOCK_RAW|unix.SOCK_CLOEXEC, unix.NETLINK_ROUTE)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("socket", err)
|
||||||
|
}
|
||||||
|
defer unix.Close(fd)
|
||||||
|
|
||||||
|
const seq = 1
|
||||||
|
req := make([]byte, unix.SizeofNlMsghdr+unix.SizeofRtGenmsg)
|
||||||
|
h := (*unix.NlMsghdr)(unsafe.Pointer(&req[0]))
|
||||||
|
h.Len = uint32(len(req))
|
||||||
|
h.Type = unix.RTM_GETADDR
|
||||||
|
h.Flags = unix.NLM_F_DUMP | unix.NLM_F_REQUEST
|
||||||
|
h.Seq = seq
|
||||||
|
req[unix.SizeofNlMsghdr] = unix.AF_UNSPEC // rtgenmsg.rtgen_family
|
||||||
|
|
||||||
|
if err := unix.Sendto(fd, req, 0, &unix.SockaddrNetlink{Family: unix.AF_NETLINK}); err != nil {
|
||||||
|
return nil, os.NewSyscallError("sendto", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Read back the port id the kernel assigned on send so replies can be matched.
|
||||||
|
lsa, err := unix.Getsockname(fd)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("getsockname", err)
|
||||||
|
}
|
||||||
|
nl, ok := lsa.(*unix.SockaddrNetlink)
|
||||||
|
if !ok {
|
||||||
|
return nil, errors.New("netlink socket returned a non-netlink local address")
|
||||||
|
}
|
||||||
|
|
||||||
|
var out []byte
|
||||||
|
buf := make([]byte, os.Getpagesize())
|
||||||
|
for {
|
||||||
|
n, _, err := unix.Recvfrom(fd, buf, 0)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("recvfrom", err)
|
||||||
|
}
|
||||||
|
if n < unix.NLMSG_HDRLEN {
|
||||||
|
return nil, fmt.Errorf("short netlink read: %d bytes", n)
|
||||||
|
}
|
||||||
|
msgs, err := syscall.ParseNetlinkMessage(buf[:n])
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
for _, m := range msgs {
|
||||||
|
if m.Header.Seq != seq || m.Header.Pid != nl.Pid {
|
||||||
|
return nil, fmt.Errorf("netlink reply for another request: seq %d pid %d", m.Header.Seq, m.Header.Pid)
|
||||||
|
}
|
||||||
|
switch m.Header.Type {
|
||||||
|
case unix.NLMSG_DONE:
|
||||||
|
return out, nil
|
||||||
|
case unix.NLMSG_ERROR:
|
||||||
|
if len(m.Data) < 4 {
|
||||||
|
return nil, errors.New("short NLMSG_ERROR")
|
||||||
|
}
|
||||||
|
errno := *(*int32)(unsafe.Pointer(&m.Data[0]))
|
||||||
|
return nil, os.NewSyscallError("RTM_GETADDR", unix.Errno(-errno))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out = append(out, buf[:n]...)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// interfaceNameByIndex resolves an interface index with SIOCGIFNAME.
|
||||||
|
func interfaceNameByIndex(fd int, index uint32) (string, error) {
|
||||||
|
var ifr unix.Ifreq
|
||||||
|
ifr.SetUint32(index) // ifr_ifindex is in the ifr_ifru union
|
||||||
|
if err := unix.IoctlIfreq(fd, unix.SIOCGIFNAME, &ifr); err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return ifr.Name(), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// newNetlinkAddr builds the address for one RTM_NEWADDR message. On a point-to-point link
|
||||||
|
// IFA_LOCAL is our side and IFA_ADDRESS the peer, so IFA_LOCAL wins when both are present.
|
||||||
|
func newNetlinkAddr(ifam *unix.IfAddrmsg, attrs []syscall.NetlinkRouteAttr) net.Addr {
|
||||||
|
var pointToPoint bool
|
||||||
|
for _, a := range attrs {
|
||||||
|
if a.Attr.Type == unix.IFA_LOCAL {
|
||||||
|
pointToPoint = true
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, a := range attrs {
|
||||||
|
if pointToPoint && a.Attr.Type == unix.IFA_ADDRESS {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
switch ifam.Family {
|
||||||
|
case unix.AF_INET:
|
||||||
|
if a.Attr.Type != unix.IFA_LOCAL && a.Attr.Type != unix.IFA_ADDRESS {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if len(a.Value) < net.IPv4len {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
return &net.IPNet{
|
||||||
|
IP: net.IPv4(a.Value[0], a.Value[1], a.Value[2], a.Value[3]),
|
||||||
|
Mask: net.CIDRMask(int(ifam.Prefixlen), 8*net.IPv4len),
|
||||||
|
}
|
||||||
|
case unix.AF_INET6:
|
||||||
|
if a.Attr.Type != unix.IFA_LOCAL && a.Attr.Type != unix.IFA_ADDRESS {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if len(a.Value) < net.IPv6len {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
ifa := &net.IPNet{IP: make(net.IP, net.IPv6len), Mask: net.CIDRMask(int(ifam.Prefixlen), 8*net.IPv6len)}
|
||||||
|
copy(ifa.IP, a.Value[:net.IPv6len])
|
||||||
|
return ifa
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
@@ -22,12 +22,9 @@ type m = map[string]any
|
|||||||
|
|
||||||
func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, deviceFactory overlay.DeviceFactory) (retcon *Control, reterr error) {
|
func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, deviceFactory overlay.DeviceFactory) (retcon *Control, reterr error) {
|
||||||
ctx, cancel := context.WithCancel(context.Background())
|
ctx, cancel := context.WithCancel(context.Background())
|
||||||
// The goroutines started below stop only when this context does, and only a caller holding the
|
// Automatically cancel the context if Main returns an error, to signal all created goroutines to quit.
|
||||||
// Control can arrange that. Cancel whenever we are not handing one back, which covers an error
|
|
||||||
// and a config test alike: a config test used to leave the lighthouse query worker, and a
|
|
||||||
// hostname resolver per dns named static host, running for the life of the process.
|
|
||||||
defer func() {
|
defer func() {
|
||||||
if retcon == nil {
|
if reterr != nil {
|
||||||
cancel()
|
cancel()
|
||||||
}
|
}
|
||||||
}()
|
}()
|
||||||
|
|||||||
@@ -1,82 +0,0 @@
|
|||||||
package nebula
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net/netip"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/cert"
|
|
||||||
cert_test "github.com/slackhq/nebula/cert_test"
|
|
||||||
"github.com/slackhq/nebula/config"
|
|
||||||
"github.com/slackhq/nebula/test"
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
"go.uber.org/goleak"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestMain_ConfigTestReleasesItsGoroutines pins the rule that Main only leaves goroutines running
|
|
||||||
// when it hands back a Control to stop them with.
|
|
||||||
//
|
|
||||||
// A config test gets no Control, so anything it started had nothing to stop it: the lighthouse
|
|
||||||
// query worker, and a hostname resolver per dns named static host, ran for the life of the
|
|
||||||
// process. That matters to every embedder that validates a config in process rather than by
|
|
||||||
// exec'ing, dnclient and the apple clients included, because they do it on each config load and
|
|
||||||
// the leak accumulates.
|
|
||||||
func TestMain_ConfigTestReleasesItsGoroutines(t *testing.T) {
|
|
||||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
|
||||||
|
|
||||||
l := test.NewLogger()
|
|
||||||
dir := t.TempDir()
|
|
||||||
|
|
||||||
before := time.Now().Add(-time.Hour)
|
|
||||||
after := time.Now().Add(time.Hour)
|
|
||||||
ca, _, caKey, caPEM := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, before, after, nil, nil, nil)
|
|
||||||
networks := []netip.Prefix{netip.MustParsePrefix("10.0.0.1/24")}
|
|
||||||
_, _, keyPEM, certPEM := cert_test.NewTestCert(
|
|
||||||
cert.Version2, cert.Curve_CURVE25519, ca, caKey, "config-test", before, after, networks, nil, nil)
|
|
||||||
|
|
||||||
caPath := filepath.Join(dir, "ca.pem")
|
|
||||||
certPath := filepath.Join(dir, "cert.pem")
|
|
||||||
keyPath := filepath.Join(dir, "key.pem")
|
|
||||||
require.NoError(t, os.WriteFile(caPath, caPEM, 0o600))
|
|
||||||
require.NoError(t, os.WriteFile(certPath, certPEM, 0o600))
|
|
||||||
require.NoError(t, os.WriteFile(keyPath, keyPEM, 0o600))
|
|
||||||
|
|
||||||
// A static host by address, not by name: the query worker is the goroutine under test and a
|
|
||||||
// hostname would drag a real dns lookup into a unit test.
|
|
||||||
configBody := fmt.Sprintf(`
|
|
||||||
pki:
|
|
||||||
ca: %s
|
|
||||||
cert: %s
|
|
||||||
key: %s
|
|
||||||
static_host_map:
|
|
||||||
"10.0.0.2": ["192.0.2.1:4242"]
|
|
||||||
lighthouse:
|
|
||||||
hosts:
|
|
||||||
- "10.0.0.2"
|
|
||||||
listen:
|
|
||||||
host: 127.0.0.1
|
|
||||||
port: 0
|
|
||||||
tun:
|
|
||||||
disabled: true
|
|
||||||
firewall:
|
|
||||||
outbound:
|
|
||||||
- port: any
|
|
||||||
proto: any
|
|
||||||
host: any
|
|
||||||
inbound:
|
|
||||||
- port: any
|
|
||||||
proto: any
|
|
||||||
host: any
|
|
||||||
`, caPath, certPath, keyPath)
|
|
||||||
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yml"), []byte(configBody), 0o600))
|
|
||||||
|
|
||||||
c := config.NewC(l)
|
|
||||||
require.NoError(t, c.Load(dir))
|
|
||||||
|
|
||||||
ctrl, err := Main(c, true, "config-test", l, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.Nil(t, ctrl, "a config test hands back nothing to stop, so it must stop itself")
|
|
||||||
}
|
|
||||||
+3
-61
@@ -30,10 +30,7 @@ type tun struct {
|
|||||||
Routes atomic.Pointer[[]Route]
|
Routes atomic.Pointer[[]Route]
|
||||||
routeTree atomic.Pointer[bart.Table[routing.Gateways]]
|
routeTree atomic.Pointer[bart.Table[routing.Gateways]]
|
||||||
linkAddr *netroute.LinkAddr
|
linkAddr *netroute.LinkAddr
|
||||||
// hostOwned means the fd arrived from the OS, which has already configured addressing, mtu
|
l *slog.Logger
|
||||||
// and routes for it. NEPacketTunnelProvider on darwin does this.
|
|
||||||
hostOwned bool
|
|
||||||
l *slog.Logger
|
|
||||||
}
|
}
|
||||||
|
|
||||||
type ifReq struct {
|
type ifReq struct {
|
||||||
@@ -153,48 +150,8 @@ func (t *tun) deviceBytes() (o [16]byte) {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
// newTunFromFd adopts a utun the host already created and configured, which is how a darwin
|
func newTunFromFd(_ *config.C, _ *slog.Logger, _ int, _ []netip.Prefix) (*tun, error) {
|
||||||
// network extension is handed its device. Everything about moving packets is shared with newTun,
|
return nil, fmt.Errorf("newTunFromFd not supported in Darwin")
|
||||||
// only the setup differs: the host owns addressing and routing here.
|
|
||||||
func newTunFromFd(c *config.C, l *slog.Logger, deviceFd int, vpnNetworks []netip.Prefix) (*tun, error) {
|
|
||||||
if err := unix.SetNonblock(deviceFd, true); err != nil {
|
|
||||||
// We own the fd from the moment it is handed to us
|
|
||||||
_ = unix.Close(deviceFd)
|
|
||||||
return nil, fmt.Errorf("failed to set the tun fd to non-blocking mode: %w", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
file := os.NewFile(uintptr(deviceFd), "/dev/tun")
|
|
||||||
t := &tun{
|
|
||||||
f: file,
|
|
||||||
Device: utunNameFromFd(deviceFd),
|
|
||||||
vpnNetworks: vpnNetworks,
|
|
||||||
DefaultMTU: c.GetInt("tun.mtu", DefaultMTU),
|
|
||||||
hostOwned: true,
|
|
||||||
l: l,
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := t.reload(c, true); err != nil {
|
|
||||||
_ = file.Close()
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
c.RegisterReloadCallback(func(c *config.C) {
|
|
||||||
if err := t.reload(c, false); err != nil {
|
|
||||||
util.LogWithContextIfNeeded("failed to reload tun device", err, t.l)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
return t, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// utunNameFromFd asks the socket what interface it is, for logs. A blank name is not worth
|
|
||||||
// failing a tunnel over, so an error just leaves it empty.
|
|
||||||
func utunNameFromFd(fd int) string {
|
|
||||||
name, err := unix.GetsockoptString(fd, unix.AF_SYS_CONTROL, _UTUN_OPT_IFNAME)
|
|
||||||
if err != nil {
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
return name
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) Close() error {
|
func (t *tun) Close() error {
|
||||||
@@ -205,12 +162,6 @@ func (t *tun) Close() error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) Activate() error {
|
func (t *tun) Activate() error {
|
||||||
// The host handed us a configured device. Its addresses, mtu and routes come from the network
|
|
||||||
// settings it applied, and a sandboxed extension cannot change them anyway.
|
|
||||||
if t.hostOwned {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
devName := t.deviceBytes()
|
devName := t.deviceBytes()
|
||||||
|
|
||||||
s, err := unix.Socket(
|
s, err := unix.Socket(
|
||||||
@@ -424,11 +375,6 @@ func getLinkAddr(name string) (*netroute.LinkAddr, error) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) addRoutes(logErrors bool) error {
|
func (t *tun) addRoutes(logErrors bool) error {
|
||||||
// The route tree is still ours, the system routing table is not
|
|
||||||
if t.hostOwned {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
routes := *t.Routes.Load()
|
routes := *t.Routes.Load()
|
||||||
|
|
||||||
for _, r := range routes {
|
for _, r := range routes {
|
||||||
@@ -458,10 +404,6 @@ func (t *tun) addRoutes(logErrors bool) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (t *tun) removeRoutes(routes []Route) error {
|
func (t *tun) removeRoutes(routes []Route) error {
|
||||||
if t.hostOwned {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, r := range routes {
|
for _, r := range routes {
|
||||||
if !r.Install {
|
if !r.Install {
|
||||||
continue
|
continue
|
||||||
|
|||||||
Reference in new issue
Block a user