mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 08:36:52 +01:00
Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fcc6008a78 | ||
|
|
8589b76e1f | ||
|
|
28cff022ee | ||
|
|
8cbee0e965 | ||
|
|
72bf111209 |
No files matched your search
@@ -222,11 +222,14 @@ test-cov-html:
|
||||
go test -coverprofile=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:
|
||||
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=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 -o /dev/null ${NEBULA_CMD_PATH}
|
||||
|
||||
bench:
|
||||
go test -bench=.
|
||||
|
||||
@@ -0,0 +1,136 @@
|
||||
//go:build e2e_testing
|
||||
// +build e2e_testing
|
||||
|
||||
package e2e
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/slackhq/nebula"
|
||||
"github.com/slackhq/nebula/cert"
|
||||
"github.com/slackhq/nebula/cert_test"
|
||||
"github.com/slackhq/nebula/e2e/router"
|
||||
"github.com/slackhq/nebula/udp"
|
||||
)
|
||||
|
||||
// TestRecoveryTiming measures how long a tunnel takes to come back after the peer stops accepting our traffic,
|
||||
// which is what a laptop waking on a new network looks like from the peer's side: its NAT has no state for where
|
||||
// we are now, so everything we send disappears.
|
||||
//
|
||||
// It is a measurement, not a pass/fail assertion. Recovery is timed to the moment the peer punches back at us,
|
||||
// since that is when its NAT opens and the tunnel is usable again.
|
||||
//
|
||||
// go test -tags e2e_testing -v -run TestRecoveryTiming ./e2e/
|
||||
func TestRecoveryTiming(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
rebind bool
|
||||
}{
|
||||
{"no trigger", false},
|
||||
{"rebind counter", true},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
d, lost := measureRecovery(t, tc.rebind)
|
||||
t.Logf("RESULT %-16s recovered in %-9v (%d packets lost)", tc.name, d.Round(time.Millisecond), lost)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// measureRecovery returns how long until the peer punched back, and how many of our packets died meanwhile. When
|
||||
// rebind is true we call RebindUDPServer once the tunnel goes dark, which is what the darwin network change
|
||||
// monitor does and what iOS has always done. When false, nothing tells nebula anything is wrong.
|
||||
func measureRecovery(t *testing.T, rebind bool) (time.Duration, int) {
|
||||
t.Helper()
|
||||
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
||||
|
||||
lhControl, lhVpnIpNet, lhUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "lh", "10.128.0.1/24", m{
|
||||
"lighthouse": m{"am_lighthouse": true},
|
||||
})
|
||||
|
||||
peerCfg := m{
|
||||
"lighthouse": m{
|
||||
"hosts": []any{lhVpnIpNet[0].Addr().String()},
|
||||
"interval": 600,
|
||||
"local_allow_list": m{
|
||||
"10.0.0.0/24": true,
|
||||
"::/0": false,
|
||||
},
|
||||
},
|
||||
"static_host_map": m{
|
||||
lhVpnIpNet[0].Addr().String(): []any{lhUdpAddr.String()},
|
||||
},
|
||||
}
|
||||
|
||||
myControl, myVpnIpNet, myUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "me", "10.128.0.2/24", peerCfg)
|
||||
theirControl, theirVpnIpNet, theirUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "them", "10.128.0.3/24", peerCfg)
|
||||
|
||||
r := router.NewR(t, lhControl, myControl, theirControl)
|
||||
defer r.RenderFlow()
|
||||
defer func() {
|
||||
lhControl.Stop()
|
||||
myControl.Stop()
|
||||
theirControl.Stop()
|
||||
}()
|
||||
|
||||
lhControl.Start()
|
||||
myControl.Start()
|
||||
theirControl.Start()
|
||||
r.RouteFor(time.Millisecond * 500)
|
||||
|
||||
myControl.InjectLightHouseAddr(theirVpnIpNet[0].Addr(), theirUdpAddr)
|
||||
theirControl.InjectLightHouseAddr(myVpnIpNet[0].Addr(), myUdpAddr)
|
||||
|
||||
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("establish")))
|
||||
r.RouteFor(time.Second)
|
||||
if myControl.GetHostInfoByVpnAddr(theirVpnIpNet[0].Addr(), false) == nil {
|
||||
t.Fatal("failed to establish the tunnel we are measuring")
|
||||
}
|
||||
r.RouteFor(time.Millisecond * 500)
|
||||
|
||||
// From here the peer's NAT has no state for us, everything we send it disappears
|
||||
start := time.Now()
|
||||
blackholed := 0
|
||||
var recovered time.Duration
|
||||
|
||||
if rebind {
|
||||
myControl.RebindUDPServer()
|
||||
}
|
||||
|
||||
// Keep the tun busy the way someone retrying a stalled connection would
|
||||
stop := make(chan struct{})
|
||||
defer close(stop)
|
||||
go func() {
|
||||
tick := time.NewTicker(time.Millisecond * 200)
|
||||
defer tick.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-stop:
|
||||
return
|
||||
case <-tick.C:
|
||||
myControl.InjectTunPacket(BuildTunUDPPacket(
|
||||
theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("retry")))
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
r.RouteForAllExitFuncOrTimeout(time.Second*30, func(p *udp.Packet, c *nebula.Control) router.ExitType {
|
||||
if c == theirControl && p.From == myControl.GetUDPAddr() {
|
||||
blackholed++
|
||||
return router.Drop
|
||||
}
|
||||
|
||||
// The peer reaching us directly is the moment its NAT opened, whether that is a punch or a handshake
|
||||
if c == myControl && p.From == theirUdpAddr {
|
||||
recovered = time.Since(start)
|
||||
return router.RouteAndExit
|
||||
}
|
||||
|
||||
return router.KeepRouting
|
||||
})
|
||||
|
||||
if recovered == 0 {
|
||||
t.Fatalf("no recovery within 30s (%d packets blackholed)", blackholed)
|
||||
}
|
||||
return recovered, blackholed
|
||||
}
|
||||
+19
-2
@@ -153,6 +153,9 @@ const (
|
||||
ExitNow ExitType = 1
|
||||
// RouteAndExit routes this packet and exits immediately afterwards
|
||||
RouteAndExit ExitType = 2
|
||||
// Drop discards this packet without delivering it and keeps routing. Use it to simulate a blackhole, such as
|
||||
// a restrictive NAT refusing traffic from an address it has not seen.
|
||||
Drop ExitType = 3
|
||||
)
|
||||
|
||||
type ExitFunc func(packet *udp.Packet, receiver *nebula.Control) ExitType
|
||||
@@ -163,7 +166,9 @@ type ExitFunc func(packet *udp.Packet, receiver *nebula.Control) ExitType
|
||||
func NewR(t testing.TB, controls ...*nebula.Control) *R {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
|
||||
if err := os.MkdirAll("mermaid", 0755); err != nil {
|
||||
// t.Name() contains a slash for subtests, so the flow log can land in a nested directory
|
||||
fn := filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name()))
|
||||
if err := os.MkdirAll(filepath.Dir(fn), 0755); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
@@ -174,7 +179,7 @@ func NewR(t testing.TB, controls ...*nebula.Control) *R {
|
||||
outNat: make(map[outNatKey]netip.AddrPort),
|
||||
flow: []flowEntry{},
|
||||
ignoreFlows: []ignoreFlow{},
|
||||
fn: filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name())),
|
||||
fn: fn,
|
||||
t: t,
|
||||
cancelRender: cancel,
|
||||
}
|
||||
@@ -687,6 +692,10 @@ func (r *R) RouteExitFunc(sender *nebula.Control, whatDo ExitFunc) {
|
||||
p.Release()
|
||||
return
|
||||
|
||||
case Drop:
|
||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
||||
r.unlockedInjectFlow(sender, receiver, p, false)
|
||||
|
||||
case KeepRouting:
|
||||
fp := r.unlockedInjectFlow(sender, receiver, p, false)
|
||||
receiver.InjectUDPPacket(p)
|
||||
@@ -779,6 +788,10 @@ func (r *R) RouteForAllExitFuncOrTimeout(timeout time.Duration, whatDo ExitFunc)
|
||||
p.Release()
|
||||
return true
|
||||
|
||||
case Drop:
|
||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
||||
r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||
|
||||
case KeepRouting:
|
||||
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||
receiver.InjectUDPPacket(p)
|
||||
@@ -884,6 +897,10 @@ func (r *R) RouteForAllExitFunc(whatDo ExitFunc) {
|
||||
p.Release()
|
||||
return
|
||||
|
||||
case Drop:
|
||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
||||
r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||
|
||||
case KeepRouting:
|
||||
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||
receiver.InjectUDPPacket(p)
|
||||
|
||||
+34
-4
@@ -868,10 +868,35 @@ func (i *HostInfo) logger(l *slog.Logger) *slog.Logger {
|
||||
|
||||
// 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
|
||||
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 {
|
||||
allow := allowList.AllowName(i.Name)
|
||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
||||
@@ -884,7 +909,12 @@ func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
||||
if !allow {
|
||||
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 {
|
||||
var addr netip.Addr
|
||||
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
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net"
|
||||
"net/netip"
|
||||
"slices"
|
||||
"testing"
|
||||
@@ -401,3 +403,94 @@ func TestHostMap_RelayState(t *testing.T) {
|
||||
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.
|
||||
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
|
||||
// map of vpn addr to answers
|
||||
addrMap map[netip.Addr]*RemoteList
|
||||
@@ -112,7 +116,9 @@ func NewLightHouseFromConfig(ctx context.Context, l *slog.Logger, c *config.C, c
|
||||
l: l,
|
||||
}
|
||||
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)
|
||||
@@ -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() {
|
||||
var v4 []*V4AddrPort
|
||||
var v6 []*V6AddrPort
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/netip"
|
||||
"testing"
|
||||
@@ -738,3 +740,32 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
||||
out = lh.Query(testHost)
|
||||
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
|
||||
}
|
||||
Reference in new issue
Block a user