mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 17:46:52 +01:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
aa1338b984 | ||
|
|
599620f6ab |
No files matched your search
@@ -222,14 +222,11 @@ 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=.
|
||||||
|
|||||||
+4
-34
@@ -868,35 +868,10 @@ func (i *HostInfo) logger(l *slog.Logger) *slog.Logger {
|
|||||||
|
|
||||||
// Utility functions
|
// Utility functions
|
||||||
|
|
||||||
// localInterface is what localAddrs needs from a net.Interface, provided per platform by
|
func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
||||||
// 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
|
||||||
var errs []error
|
ifaces, _ := net.Interfaces()
|
||||||
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) {
|
||||||
@@ -909,12 +884,7 @@ func collectLocalAddrs(
|
|||||||
if !allow {
|
if !allow {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
addrs, err := i.Addrs()
|
addrs, _ := 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) {
|
||||||
@@ -949,5 +919,5 @@ func collectLocalAddrs(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return finalAddrs, errors.Join(errs...)
|
return finalAddrs
|
||||||
}
|
}
|
||||||
@@ -1,8 +1,6 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"errors"
|
|
||||||
"net"
|
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -403,94 +401,3 @@ 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")
|
|
||||||
}
|
|
||||||
+1
-27
@@ -40,10 +40,6 @@ 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
|
||||||
@@ -116,9 +112,7 @@ 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 {
|
||||||
addrs, err := localAddrs(h.l, al)
|
return localAddrs(h.l, al)
|
||||||
h.logLocalAddrsErr(err)
|
|
||||||
return addrs
|
|
||||||
}
|
}
|
||||||
|
|
||||||
lighthouses := make([]netip.Addr, 0)
|
lighthouses := make([]netip.Addr, 0)
|
||||||
@@ -919,26 +913,6 @@ 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,9 +1,7 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
"errors"
|
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -740,32 +738,3 @@ 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")
|
|
||||||
}
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
//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
|
|
||||||
}
|
|
||||||
@@ -1,213 +0,0 @@
|
|||||||
//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,9 +22,12 @@ 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())
|
||||||
// Automatically cancel the context if Main returns an error, to signal all created goroutines to quit.
|
// The goroutines started below stop only when this context does, and only a caller holding the
|
||||||
|
// 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 reterr != nil {
|
if retcon == nil {
|
||||||
cancel()
|
cancel()
|
||||||
}
|
}
|
||||||
}()
|
}()
|
||||||
|
|||||||
@@ -0,0 +1,82 @@
|
|||||||
|
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")
|
||||||
|
}
|
||||||
+61
-3
@@ -30,7 +30,10 @@ 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
|
||||||
l *slog.Logger
|
// hostOwned means the fd arrived from the OS, which has already configured addressing, mtu
|
||||||
|
// and routes for it. NEPacketTunnelProvider on darwin does this.
|
||||||
|
hostOwned bool
|
||||||
|
l *slog.Logger
|
||||||
}
|
}
|
||||||
|
|
||||||
type ifReq struct {
|
type ifReq struct {
|
||||||
@@ -150,8 +153,48 @@ func (t *tun) deviceBytes() (o [16]byte) {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func newTunFromFd(_ *config.C, _ *slog.Logger, _ int, _ []netip.Prefix) (*tun, error) {
|
// newTunFromFd adopts a utun the host already created and configured, which is how a darwin
|
||||||
return nil, fmt.Errorf("newTunFromFd not supported in Darwin")
|
// network extension is handed its device. Everything about moving packets is shared with newTun,
|
||||||
|
// 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 {
|
||||||
@@ -162,6 +205,12 @@ 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(
|
||||||
@@ -375,6 +424,11 @@ 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 {
|
||||||
@@ -404,6 +458,10 @@ 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