mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 08:16:52 +01:00
Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
556b457389 | ||
|
|
5bba4de3c6 | ||
|
|
06035252b2 | ||
|
|
1fb77bdda5 | ||
|
|
556747d9b7 | ||
|
|
8f34981764 | ||
|
|
4d6f757d1f | ||
|
|
94372f4f51 | ||
|
|
42280f04ce | ||
|
|
11c1917387 | ||
|
|
5ba7aff4b3 |
No files matched your search
+12
-3
@@ -103,14 +103,23 @@ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, packet
|
||||
if !result {
|
||||
return nil, ErrAlreadySeen
|
||||
}
|
||||
out, err := cs.decryptPacket(messageCounter, packet, nb)
|
||||
return cs.acceptDecrypted(l, messageCounter, out, err)
|
||||
}
|
||||
|
||||
out, err := cs.dKey.DecryptDanger(packet[header.Len:header.Len], packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
||||
// decryptPacket authenticates and decrypts packet in place, leaving the replay window to the caller.
|
||||
func (cs *ConnectionState) decryptPacket(messageCounter uint64, packet, nb []byte) ([]byte, error) {
|
||||
return cs.dKey.DecryptDanger(packet[header.Len:header.Len], packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
||||
}
|
||||
|
||||
// acceptDecrypted finishes a decryptPacket result: an authenticated packet is recorded in the replay window, and
|
||||
// rejected if its counter was recorded since it was checked.
|
||||
func (cs *ConnectionState) acceptDecrypted(l *slog.Logger, messageCounter uint64, out []byte, err error) ([]byte, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cs.decryptLock.Lock()
|
||||
result = cs.window.Update(l, messageCounter)
|
||||
result := cs.window.Update(l, messageCounter)
|
||||
cs.decryptLock.Unlock()
|
||||
if !result {
|
||||
return nil, ErrAlreadySeen
|
||||
|
||||
@@ -23,11 +23,20 @@ import (
|
||||
// runTestHandshake runs a complete IX handshake between two freshly-built
|
||||
// peers and returns the initiator and responder Results. Used to produce
|
||||
// real cipher states for tests that need to exercise post-handshake glue.
|
||||
func runTestHandshake(t *testing.T) (initR, respR *handshake.Result) {
|
||||
func runTestHandshake(t testing.TB) (initR, respR *handshake.Result) {
|
||||
t.Helper()
|
||||
return runTestHandshakeWith(t, noise.CipherChaChaPoly)
|
||||
}
|
||||
|
||||
// runTestHandshakeWith is runTestHandshake with the data plane cipher picked by the caller.
|
||||
func runTestHandshakeWith(t testing.TB, cipher noise.CipherFunc) (initR, respR *handshake.Result) {
|
||||
t.Helper()
|
||||
|
||||
// Valid around now rather than the cert_test default, which is fixed at process start and lapses a minute
|
||||
// later, inside a long -count run
|
||||
now := time.Now()
|
||||
ca, _, caKey, _ := ct.NewTestCaCert(
|
||||
cert.Version2, cert.Curve_CURVE25519, time.Time{}, time.Time{}, nil, nil, nil,
|
||||
cert.Version2, cert.Curve_CURVE25519, now.Add(-time.Minute), now.Add(time.Hour), nil, nil, nil,
|
||||
)
|
||||
caPool := ct.NewTestCAPool(ca)
|
||||
|
||||
@@ -40,7 +49,7 @@ func runTestHandshake(t *testing.T) (initR, respR *handshake.Result) {
|
||||
require.NoError(t, err)
|
||||
hsBytes, err := c.MarshalForHandshakes()
|
||||
require.NoError(t, err)
|
||||
ncs := noise.NewCipherSuite(noise.DH25519, noise.CipherChaChaPoly, noise.HashSHA256)
|
||||
ncs := noise.NewCipherSuite(noise.DH25519, cipher, noise.HashSHA256)
|
||||
cred := handshake.NewCredential(c, hsBytes, priv, ncs)
|
||||
return func(v cert.Version) *handshake.Credential {
|
||||
if v == cert.Version2 {
|
||||
|
||||
@@ -144,10 +144,10 @@ type fakeConn struct {
|
||||
rebinds int
|
||||
}
|
||||
|
||||
func (c *fakeConn) Rebind() error { c.rebinds++; return nil }
|
||||
func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil }
|
||||
func (c *fakeConn) ListenOut(_ udp.EncReader, _ func()) error { return nil }
|
||||
func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil }
|
||||
func (c *fakeConn) Rebind() error { c.rebinds++; return nil }
|
||||
func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil }
|
||||
func (c *fakeConn) ListenOut(_ udp.EncReader, _ func([][]byte) [][]byte) error { return nil }
|
||||
func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil }
|
||||
func (c *fakeConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
|
||||
return len(bufs), nil
|
||||
}
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
# vpnemu
|
||||
|
||||
Reproduces, on macOS and without Tailscale, the way a VPN with an exit node takes nebula's vpn network route
|
||||
away from its utun (#1931).
|
||||
|
||||
A macOS network extension never touches the routing table. Its routes are published in configd's dynamic store
|
||||
under `State:/Network/Service/<id>/IPv4` and `/IPv6`, and configd's IPMonitor installs them. vpnemu creates a
|
||||
utun and publishes those keys itself, so configd does exactly what it would do for the real app. It publishes
|
||||
the routes Tailscale would with an exit node: every interface prefix that isn't a single IP, the rule in
|
||||
Tailscale's `ipnlocal.internalAndExternalInterfacesFrom`.
|
||||
|
||||
| mode | Tailscale setting | published as | where nebula's prefix goes |
|
||||
| --- | --- | --- | --- |
|
||||
| `claim` | exit node, no LAN access | `AdditionalRoutes` | into vpnemu's utun |
|
||||
| `exclude` | exit node, LAN access | `ExcludedRoutes`, service overrides primary | out the next interface (en0) |
|
||||
|
||||
configd answers `EEXIST` with a delete and an add, so whatever held the prefix loses it. When the service is
|
||||
withdrawn, configd deletes its routes by prefix alone, whoever holds them by then.
|
||||
|
||||
## Build
|
||||
|
||||
It is its own module, so `purego` stays out of nebula's `go.mod`. purego reaches CoreFoundation and
|
||||
SystemConfiguration without cgo, so it cross compiles and runs on a mac with no developer tools.
|
||||
|
||||
```sh
|
||||
cd e2e/darwin/vpnemu
|
||||
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -o vpnemu .
|
||||
# a cross compiled binary copied to a mac may need: codesign -s - -f vpnemu
|
||||
```
|
||||
|
||||
## Run
|
||||
|
||||
```sh
|
||||
sudo ./vpnemu -mode claim -keep en0 # runs until ctrl-c, then withdraws and closes its utun
|
||||
sudo ./vpnemu -clear # withdraw a service a crashed run left behind
|
||||
```
|
||||
|
||||
`-keep` names interfaces whose prefixes are never published. Keep the one your ssh session arrives on, or
|
||||
`claim` takes your LAN into a utun nobody reads. `exclude` makes vpnemu primary, so anything off a kept
|
||||
interface's subnet, internet included, goes into its utun and is dropped while it runs.
|
||||
|
||||
`-follow` (default on) republishes when interface prefixes change, as Tailscale does on link changes. With
|
||||
`-follow=false` a route stays published after its interface is gone, which stages the route configd leaves
|
||||
behind for a nebula that restarts before the VPN has caught up.
|
||||
|
||||
## A/B a nebula build
|
||||
|
||||
`repro.sh` starts nebula, then runs vpnemu, and reports egress and ping per peer before, during and after:
|
||||
|
||||
```sh
|
||||
sudo ./repro.sh -n ./nebula -c config.yml -p 192.168.212.1 -p fd19:31::1 -m claim -k en0
|
||||
```
|
||||
|
||||
Before #1931 (utun holds `/24` and `/64`):
|
||||
|
||||
```
|
||||
during 192.168.212.1 egress=utun2 ping=FAIL
|
||||
after 192.168.212.1 egress=en0 ping=FAIL
|
||||
```
|
||||
|
||||
With #1931 (utun holds `/32` and `/128`, network routes added explicitly) every phase stays on nebula's utun.
|
||||
|
||||
### Leftover route
|
||||
|
||||
Run an old nebula, start `vpnemu -follow=false`, then restart onto a new nebula while vpnemu is still up. The
|
||||
new nebula finds the vpn network routed to vpnemu's utun, replaces it and starts. Stop vpnemu and configd deletes
|
||||
the prefix, taking nebula's route with it until nebula restarts. With real Tailscale this needs nebula to restart
|
||||
before Tailscale notices the old utun is gone, a one time window when upgrading from a nebula without #1931.
|
||||
@@ -1,8 +0,0 @@
|
||||
module github.com/slackhq/nebula/e2e/darwin/vpnemu
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require (
|
||||
github.com/ebitengine/purego v0.9.1
|
||||
golang.org/x/sys v0.48.0
|
||||
)
|
||||
@@ -1,4 +0,0 @@
|
||||
github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s0A=
|
||||
github.com/ebitengine/purego v0.9.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
|
||||
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
|
||||
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
@@ -1,292 +0,0 @@
|
||||
//go:build darwin
|
||||
|
||||
// vpnemu stands in for a macOS VPN app with an exit node in use, so route hijacks like the one
|
||||
// Tailscale causes can be reproduced without Tailscale.
|
||||
//
|
||||
// A network extension does not touch the routing table itself. It hands its routes to
|
||||
// nesessionmanager, which publishes them in configd's dynamic store under
|
||||
// State:/Network/Service/<id>/IPv4 and /IPv6, and configd's IPMonitor installs them. vpnemu
|
||||
// creates a utun and publishes the same keys directly, so configd does exactly what it would do
|
||||
// for the real thing.
|
||||
//
|
||||
// Which routes it publishes follows Tailscale's rule for exit nodes
|
||||
// (ipnlocal.internalAndExternalInterfacesFrom): every interface address prefix that is not a
|
||||
// single IP counts as an attached LAN. With LAN access off those prefixes are claimed into the
|
||||
// tunnel (-mode claim, published as AdditionalRoutes). With LAN access on they are excluded and
|
||||
// leave through the next interface (-mode exclude, published as ExcludedRoutes on a service that
|
||||
// overrides the primary).
|
||||
//
|
||||
// It runs until interrupted, then withdraws the service and closes its utun. Needs root.
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"net"
|
||||
"net/netip"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/signal"
|
||||
"slices"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/ebitengine/purego"
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
const (
|
||||
serviceID = "VPNEMU"
|
||||
// Tailscale's own addresses, single IPs, so the rule skips them like Tailscale skips its own
|
||||
addr4 = "100.100.0.1"
|
||||
addr6 = "fd7a:115c:a1e0::1"
|
||||
|
||||
utunControlName = "com.apple.net.utun_control"
|
||||
utunOptIfname = 2
|
||||
cfStringUTF8 = 0x08000100
|
||||
)
|
||||
|
||||
var (
|
||||
cfStringCreateWithCString func(alloc uintptr, s *byte, enc uint32) uintptr
|
||||
cfDataCreate func(alloc uintptr, b *byte, n int) uintptr
|
||||
cfPropertyListCreateWithData func(alloc, data uintptr, opts uint, format *int, err *uintptr) uintptr
|
||||
cfRelease func(ref uintptr)
|
||||
scDynamicStoreCreate func(alloc, name, callout, ctx uintptr) uintptr
|
||||
scDynamicStoreSetValue func(store, key, value uintptr) bool
|
||||
scDynamicStoreRemoveValue func(store, key uintptr) bool
|
||||
scError func() int32
|
||||
)
|
||||
|
||||
// loadFrameworks binds the few CoreFoundation and SystemConfiguration calls we need. purego does
|
||||
// it without cgo, so this cross compiles and runs on a mac with no developer tools. JXA can read
|
||||
// the dynamic store but its writes fail, and scutil cannot build the arrays of dictionaries the
|
||||
// route keys hold.
|
||||
func loadFrameworks() {
|
||||
cf, err := purego.Dlopen("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", purego.RTLD_NOW|purego.RTLD_GLOBAL)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
sc, err := purego.Dlopen("/System/Library/Frameworks/SystemConfiguration.framework/SystemConfiguration", purego.RTLD_NOW|purego.RTLD_GLOBAL)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
purego.RegisterLibFunc(&cfStringCreateWithCString, cf, "CFStringCreateWithCString")
|
||||
purego.RegisterLibFunc(&cfDataCreate, cf, "CFDataCreate")
|
||||
purego.RegisterLibFunc(&cfPropertyListCreateWithData, cf, "CFPropertyListCreateWithData")
|
||||
purego.RegisterLibFunc(&cfRelease, cf, "CFRelease")
|
||||
purego.RegisterLibFunc(&scDynamicStoreCreate, sc, "SCDynamicStoreCreate")
|
||||
purego.RegisterLibFunc(&scDynamicStoreSetValue, sc, "SCDynamicStoreSetValue")
|
||||
purego.RegisterLibFunc(&scDynamicStoreRemoveValue, sc, "SCDynamicStoreRemoveValue")
|
||||
purego.RegisterLibFunc(&scError, sc, "SCError")
|
||||
}
|
||||
|
||||
func cfString(s string) uintptr {
|
||||
b := append([]byte(s), 0)
|
||||
return cfStringCreateWithCString(0, &b[0], cfStringUTF8)
|
||||
}
|
||||
|
||||
// cfPlist builds a property list from its xml form, the least code way to make nested CF values
|
||||
func cfPlist(xml string) uintptr {
|
||||
b := []byte(xml)
|
||||
d := cfDataCreate(0, &b[0], len(b))
|
||||
defer cfRelease(d)
|
||||
var errRef uintptr
|
||||
p := cfPropertyListCreateWithData(0, d, 0, nil, &errRef)
|
||||
if p == 0 {
|
||||
log.Fatalf("invalid property list:\n%s", xml)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
type store struct {
|
||||
ref uintptr
|
||||
k4, k6 uintptr
|
||||
}
|
||||
|
||||
func openStore() *store {
|
||||
return &store{
|
||||
ref: scDynamicStoreCreate(0, cfString("vpnemu"), 0, 0),
|
||||
k4: cfString("State:/Network/Service/" + serviceID + "/IPv4"),
|
||||
k6: cfString("State:/Network/Service/" + serviceID + "/IPv6"),
|
||||
}
|
||||
}
|
||||
|
||||
func (s *store) set(key uintptr, xml string) {
|
||||
v := cfPlist(xml)
|
||||
defer cfRelease(v)
|
||||
if !scDynamicStoreSetValue(s.ref, key, v) {
|
||||
log.Fatalf("SCDynamicStoreSetValue failed: SCError %d", scError())
|
||||
}
|
||||
}
|
||||
|
||||
func (s *store) withdraw() {
|
||||
scDynamicStoreRemoveValue(s.ref, s.k4)
|
||||
scDynamicStoreRemoveValue(s.ref, s.k6)
|
||||
}
|
||||
|
||||
// createUtun opens a utun the kernel numbers for us and gives it Tailscale-like single addresses.
|
||||
// The interface lives as long as the returned fd.
|
||||
func createUtun() (int, string) {
|
||||
fd, err := unix.Socket(unix.AF_SYSTEM, unix.SOCK_DGRAM, unix.AF_SYS_CONTROL)
|
||||
if err != nil {
|
||||
log.Fatalf("system socket: %v", err)
|
||||
}
|
||||
info := &unix.CtlInfo{}
|
||||
copy(info.Name[:], utunControlName)
|
||||
if err = unix.IoctlCtlInfo(fd, info); err != nil {
|
||||
log.Fatalf("CTLIOCGINFO: %v", err)
|
||||
}
|
||||
if err = unix.Connect(fd, &unix.SockaddrCtl{ID: info.Id, Unit: 0}); err != nil {
|
||||
log.Fatalf("connect utun control: %v", err)
|
||||
}
|
||||
name, err := unix.GetsockoptString(fd, unix.AF_SYS_CONTROL, utunOptIfname)
|
||||
if err != nil {
|
||||
log.Fatalf("utun name: %v", err)
|
||||
}
|
||||
|
||||
for _, args := range [][]string{
|
||||
{name, "inet", addr4, addr4, "netmask", "255.255.255.255", "up"},
|
||||
{name, "inet6", addr6, "prefixlen", "128"},
|
||||
} {
|
||||
if out, err := exec.Command("ifconfig", args...).CombinedOutput(); err != nil {
|
||||
log.Fatalf("ifconfig %s: %v: %s", strings.Join(args, " "), err, out)
|
||||
}
|
||||
}
|
||||
return fd, name
|
||||
}
|
||||
|
||||
// lanPrefixes applies Tailscale's attached-LAN rule to every interface but those in skip
|
||||
func lanPrefixes(skip []string) (v4, v6 []netip.Prefix) {
|
||||
ifs, err := net.Interfaces()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
for _, i := range ifs {
|
||||
if slices.Contains(skip, i.Name) || i.Flags&net.FlagLoopback != 0 {
|
||||
continue
|
||||
}
|
||||
addrs, _ := i.Addrs()
|
||||
for _, a := range addrs {
|
||||
n, ok := a.(*net.IPNet)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
ip, _ := netip.AddrFromSlice(n.IP)
|
||||
ip = ip.Unmap()
|
||||
ones, _ := n.Mask.Size()
|
||||
pfx := netip.PrefixFrom(ip, ones).Masked()
|
||||
// Tailscale skips single IPs. Link-local is our addition, every interface has the
|
||||
// same fe80::/64 and claiming it would only break the harness's own host.
|
||||
if pfx.IsSingleIP() || ip.IsLinkLocalUnicast() {
|
||||
continue
|
||||
}
|
||||
if ip.Is4() {
|
||||
v4 = append(v4, pfx)
|
||||
} else {
|
||||
v6 = append(v6, pfx)
|
||||
}
|
||||
}
|
||||
}
|
||||
slices.SortFunc(v4, func(a, b netip.Prefix) int { return a.Addr().Compare(b.Addr()) })
|
||||
slices.SortFunc(v6, func(a, b netip.Prefix) int { return a.Addr().Compare(b.Addr()) })
|
||||
return v4, v6
|
||||
}
|
||||
|
||||
func routes4(ps []netip.Prefix) string {
|
||||
var b strings.Builder
|
||||
for _, p := range ps {
|
||||
mask := net.IP(net.CIDRMask(p.Bits(), 32)).String()
|
||||
fmt.Fprintf(&b, "<dict><key>DestinationAddress</key><string>%s</string><key>SubnetMask</key><string>%s</string></dict>", p.Addr(), mask)
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func routes6(ps []netip.Prefix) string {
|
||||
var b strings.Builder
|
||||
for _, p := range ps {
|
||||
fmt.Fprintf(&b, "<dict><key>DestinationAddress</key><string>%s</string><key>PrefixLength</key><integer>%d</integer></dict>", p.Addr(), p.Bits())
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (s *store) publish(ifName string, exclude bool, v4, v6 []netip.Prefix) {
|
||||
routesKey, primary := "AdditionalRoutes", ""
|
||||
if exclude {
|
||||
// configd only steers excluded routes for a service with a default route that is primary.
|
||||
// While this runs, everything not on a kept interface's subnet goes into the utun and dies.
|
||||
routesKey = "ExcludedRoutes"
|
||||
primary = "<key>Router</key><string>" + addr4 + "</string><key>OverridePrimary</key><integer>1</integer>"
|
||||
}
|
||||
|
||||
const head = `<?xml version="1.0" encoding="UTF-8"?><plist version="1.0"><dict>`
|
||||
s.set(s.k4, head+
|
||||
"<key>InterfaceName</key><string>"+ifName+"</string>"+
|
||||
"<key>Addresses</key><array><string>"+addr4+"</string></array>"+
|
||||
"<key>SubnetMasks</key><array><string>255.255.255.255</string></array>"+primary+
|
||||
"<key>"+routesKey+"</key><array>"+routes4(v4)+"</array></dict></plist>")
|
||||
s.set(s.k6, head+
|
||||
"<key>InterfaceName</key><string>"+ifName+"</string>"+
|
||||
"<key>Addresses</key><array><string>"+addr6+"</string></array>"+
|
||||
"<key>PrefixLength</key><array><integer>128</integer></array>"+
|
||||
"<key>"+routesKey+"</key><array>"+routes6(v6)+"</array></dict></plist>")
|
||||
|
||||
log.Printf("published %s on %s, %s: %v %v", serviceID, ifName, routesKey, v4, v6)
|
||||
}
|
||||
|
||||
func main() {
|
||||
mode := flag.String("mode", "claim", "claim: exit node without LAN access, the prefixes are routed into the vpn\n"+
|
||||
"exclude: exit node with LAN access, the prefixes leave via the next interface and the vpn becomes primary")
|
||||
keep := flag.String("keep", "en0", "comma separated interfaces whose prefixes are never published, keep the one your ssh session uses")
|
||||
follow := flag.Bool("follow", true, "republish when interface prefixes change, as Tailscale does on link changes.\n"+
|
||||
"Off, a route stays published after its interface is gone, which is how a leftover route is staged")
|
||||
clear := flag.Bool("clear", false, "withdraw a service a crashed run left behind, then exit")
|
||||
flag.Parse()
|
||||
|
||||
if *mode != "claim" && *mode != "exclude" {
|
||||
log.Fatalf("unknown -mode %q", *mode)
|
||||
}
|
||||
if os.Geteuid() != 0 {
|
||||
log.Fatal("needs root, to create the utun and write configd's dynamic store")
|
||||
}
|
||||
|
||||
loadFrameworks()
|
||||
s := openStore()
|
||||
if *clear {
|
||||
s.withdraw()
|
||||
log.Print("withdrawn")
|
||||
return
|
||||
}
|
||||
|
||||
fd, ifName := createUtun()
|
||||
exclude := *mode == "exclude"
|
||||
skip := append(strings.Split(*keep, ","), ifName)
|
||||
|
||||
v4, v6 := lanPrefixes(skip)
|
||||
s.publish(ifName, exclude, v4, v6)
|
||||
|
||||
sig := make(chan os.Signal, 1)
|
||||
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
|
||||
tick := time.NewTicker(time.Second)
|
||||
defer tick.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-sig:
|
||||
s.withdraw()
|
||||
_ = unix.Close(fd)
|
||||
log.Print("withdrawn")
|
||||
return
|
||||
case <-tick.C:
|
||||
if !*follow {
|
||||
continue
|
||||
}
|
||||
n4, n6 := lanPrefixes(skip)
|
||||
if !slices.Equal(n4, v4) || !slices.Equal(n6, v6) {
|
||||
v4, v6 = n4, n6
|
||||
s.publish(ifName, exclude, v4, v6)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
#!/bin/sh
|
||||
# Reports where traffic to nebula peers goes before, during and after a vpnemu exit node.
|
||||
#
|
||||
# usage: sudo ./repro.sh -n <nebula binary> -c <nebula config> -p <peer vpn addr> [-p <peer>...]
|
||||
# [-m claim|exclude] [-k <keep interfaces>]
|
||||
#
|
||||
# Each peer should answer pings over the overlay. A healthy run shows the nebula utun as egress
|
||||
# and the ping working in all three phases.
|
||||
set -u
|
||||
|
||||
MODE=claim
|
||||
KEEP=en0
|
||||
PEERS=""
|
||||
NEBULA=""
|
||||
CONFIG=""
|
||||
while getopts n:c:p:m:k: o; do
|
||||
case $o in
|
||||
n) NEBULA=$OPTARG ;;
|
||||
c) CONFIG=$OPTARG ;;
|
||||
p) PEERS="$PEERS $OPTARG" ;;
|
||||
m) MODE=$OPTARG ;;
|
||||
k) KEEP=$OPTARG ;;
|
||||
*) exit 2 ;;
|
||||
esac
|
||||
done
|
||||
if [ -z "$NEBULA" ] || [ -z "$CONFIG" ] || [ -z "$PEERS" ]; then
|
||||
sed -n '4,5p' "$0"
|
||||
exit 2
|
||||
fi
|
||||
|
||||
HERE=$(cd "$(dirname "$0")" && pwd)
|
||||
VPNEMU=${VPNEMU:-$HERE/vpnemu}
|
||||
LOG=$(mktemp -t nebula-repro)
|
||||
|
||||
report() {
|
||||
for p in $PEERS; do
|
||||
case $p in
|
||||
*:*) fam=-inet6 ping=ping6 ;;
|
||||
*) fam=-inet ping="ping -t 3" ;;
|
||||
esac
|
||||
egress=$(route -n get $fam "$p" 2>/dev/null | awk '/interface:/{print $2}')
|
||||
if $ping -c 2 "$p" >/dev/null 2>&1; then ok=ok; else ok=FAIL; fi
|
||||
printf '%-8s %-24s egress=%-8s ping=%s\n' "$1" "$p" "${egress:-none}" "$ok"
|
||||
done
|
||||
}
|
||||
|
||||
cleanup() {
|
||||
[ -n "${EMU:-}" ] && kill "$EMU" 2>/dev/null
|
||||
[ -n "${NEB:-}" ] && kill "$NEB" 2>/dev/null
|
||||
wait 2>/dev/null
|
||||
}
|
||||
trap cleanup EXIT INT TERM
|
||||
|
||||
"$NEBULA" -config "$CONFIG" >"$LOG" 2>&1 &
|
||||
NEB=$!
|
||||
sleep 3
|
||||
if ! kill -0 $NEB 2>/dev/null; then
|
||||
echo "nebula exited:"
|
||||
tail -5 "$LOG"
|
||||
exit 1
|
||||
fi
|
||||
echo "nebula on $(grep -o 'interface=utun[0-9]*' "$LOG" | head -1 | cut -d= -f2), log in $LOG"
|
||||
report before
|
||||
|
||||
"$VPNEMU" -mode "$MODE" -keep "$KEEP" &
|
||||
EMU=$!
|
||||
sleep 3
|
||||
report during
|
||||
|
||||
kill $EMU
|
||||
wait $EMU 2>/dev/null
|
||||
EMU=
|
||||
sleep 2
|
||||
report after
|
||||
|
||||
grep -E 'level=(WARN|ERROR).*(route|Route)' "$LOG"
|
||||
@@ -5,9 +5,11 @@ package e2e
|
||||
import (
|
||||
"fmt"
|
||||
"net/netip"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/rcrowley/go-metrics"
|
||||
"github.com/slackhq/nebula/cert"
|
||||
"github.com/slackhq/nebula/cert_test"
|
||||
"github.com/slackhq/nebula/e2e/router"
|
||||
@@ -570,3 +572,29 @@ func TestCloseTunnelAuthenticated(t *testing.T) {
|
||||
myControl.Stop()
|
||||
theirControl.Stop()
|
||||
}
|
||||
|
||||
// TestStagedTunnel completes a handshake and traffic both ways with staged receive. Every received packet,
|
||||
// handshakes included, uses the receive pipeline on Linux. Other platforms must do the same over the inline fallback.
|
||||
func TestStagedTunnel(t *testing.T) {
|
||||
t.Parallel()
|
||||
received := metrics.GetOrRegisterCounter("flow.rx.inline", nil)
|
||||
before := received.Count()
|
||||
staged := m{"tun": m{"staged": m{"workers": 2}}}
|
||||
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version1, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
||||
myControl, myVpnIpNet, myUdpAddr, _ := newSimpleServer(cert.Version1, ca, caKey, "me", "10.128.0.1/24", staged)
|
||||
theirControl, theirVpnIpNet, theirUdpAddr, _ := newSimpleServer(cert.Version1, ca, caKey, "them", "10.128.0.2/24", staged)
|
||||
myControl.InjectLightHouseAddr(theirVpnIpNet[0].Addr(), theirUdpAddr)
|
||||
theirControl.InjectLightHouseAddr(myVpnIpNet[0].Addr(), myUdpAddr)
|
||||
myControl.Start()
|
||||
theirControl.Start()
|
||||
r := router.NewR(t, myControl, theirControl)
|
||||
defer r.RenderFlow()
|
||||
assertTunnel(t, myVpnIpNet[0].Addr(), theirVpnIpNet[0].Addr(), myControl, theirControl, r)
|
||||
myControl.Stop()
|
||||
theirControl.Stop()
|
||||
if runtime.GOOS != "linux" {
|
||||
assert.Zero(t, received.Count()-before)
|
||||
return
|
||||
}
|
||||
assert.GreaterOrEqual(t, received.Count()-before, int64(2))
|
||||
}
|
||||
@@ -271,6 +271,14 @@ tun:
|
||||
# the use_offloads setting controls if Nebula will attempt to enable GSO and GRO for the tun device. Linux only, not reloadable.
|
||||
#use_offloads: false
|
||||
|
||||
# Linux only. staged.workers enables staged receive: each routine hands its received batches to this many decrypt
|
||||
# workers, then an ordered writer commits them in arrival order through the same replay, roaming and firewall
|
||||
# handling as inline receive. 0, the default, keeps receive inline. Batches below 256 packets on an idle listener
|
||||
# stay on the listener. Needs no support from peers. Costs about 24 MiB of buffers per routine at listen.batch 64
|
||||
# with GRO. Not reloadable.
|
||||
#staged:
|
||||
# workers: 0
|
||||
|
||||
# Linux only. pin_threads pins each tun reader/encrypt OS thread to a single CPU. This keeps every goroutine's
|
||||
# batched sends flowing through one XPS-selected NIC TX ring, so packets within a flow stay ordered on the wire
|
||||
# instead of being sprayed across multiple TX rings and reordered. Not reloadable. Coerced to false if routines <= 1.
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"runtime"
|
||||
|
||||
"github.com/slackhq/nebula/config"
|
||||
)
|
||||
|
||||
// Staged receive (tun.staged.workers) moves decryption off each udp listener onto worker goroutines, behind which an
|
||||
// ordered writer commits every batch in arrival order. It reuses the inline packet handlers: staging changes ownership
|
||||
// and scheduling, not policy. Each routine has its own workers and writer, so order is per routine. Full queues block
|
||||
// the listener. A read error drains the batches in flight, while shutdown waits for the workers and then drops what
|
||||
// is left. Each routine keeps six batches; at listen.batch=64 with GRO their buffers take about 24 MiB per routine.
|
||||
//
|
||||
// Metrics are registered only for active pipelines. flow.rx.batches counts batches handed to the writer and
|
||||
// flow.rx.inline those an idle listener handled itself; their rates show whether staging is used.
|
||||
|
||||
// stagedConfig is tun.staged. workers is per routine; zero keeps receive inline.
|
||||
type stagedConfig struct {
|
||||
workers int
|
||||
// inlineBelow is the packet count below which an idle listener skips the worker handoff
|
||||
inlineBelow int
|
||||
}
|
||||
|
||||
// parseStagedConfig enables staging on Linux only; conns that cannot hand off batches also stay inline.
|
||||
func parseStagedConfig(c *config.C, l *slog.Logger) stagedConfig {
|
||||
sc := stagedConfig{workers: c.GetInt("tun.staged.workers", 0)}
|
||||
if sc.workers <= 0 {
|
||||
return stagedConfig{}
|
||||
}
|
||||
if runtime.GOOS != "linux" {
|
||||
l.Warn("tun.staged is only supported on Linux; packet processing stays inline")
|
||||
return stagedConfig{}
|
||||
}
|
||||
// 256 is the measured crossover
|
||||
sc.inlineBelow = 256
|
||||
l.Info("Staged receive processing enabled", "workers", sc.workers)
|
||||
return sc
|
||||
}
|
||||
+303
@@ -0,0 +1,303 @@
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"net/netip"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/rcrowley/go-metrics"
|
||||
"github.com/slackhq/nebula/header"
|
||||
"github.com/slackhq/nebula/udp"
|
||||
)
|
||||
|
||||
// handoffConn is a udp conn that receives in batches of a fixed shape, so staged receive can have replacement buffers
|
||||
// ready for every batch it keeps.
|
||||
type handoffConn interface {
|
||||
ListenOut(udp.EncReader, func([][]byte) [][]byte) error
|
||||
HandoffShape() (n, size int)
|
||||
}
|
||||
|
||||
const stagedRxSlots = 6
|
||||
const rxChunkMin = 16
|
||||
|
||||
// rxItem is one received packet. A data packet for an established tunnel has ci set; out and err are written by
|
||||
// whoever decrypts it.
|
||||
type rxItem struct {
|
||||
packet []byte
|
||||
ci *ConnectionState
|
||||
counter uint64
|
||||
via netip.AddrPort
|
||||
out []byte
|
||||
err error
|
||||
}
|
||||
|
||||
// rxChunk is a contiguous run of a batch's items for one worker to decrypt.
|
||||
type rxChunk struct {
|
||||
items []rxItem
|
||||
done chan struct{}
|
||||
}
|
||||
|
||||
// decryptRxItems decrypts the data packets among items in place, skipping the replays checkReplays marked. Recording
|
||||
// the counters is left to readOutsidePackets on the writer, which also handles the packets without a tunnel.
|
||||
func decryptRxItems(items []rxItem, nb []byte) {
|
||||
for i := range items {
|
||||
it := &items[i]
|
||||
if it.ci == nil || it.err != nil {
|
||||
continue
|
||||
}
|
||||
it.out, it.err = it.ci.decryptPacket(it.counter, it.packet, nb)
|
||||
}
|
||||
}
|
||||
|
||||
// rxBatch is one recvmmsg batch moving through the staged receive pipeline.
|
||||
type rxBatch struct {
|
||||
// items is every packet of the batch in arrival order. Data packets are decrypted by a worker; anything else is
|
||||
// handled whole by the writer, in its place.
|
||||
items []rxItem
|
||||
// bufs is the set of recvmmsg buffers the items point into, owned by the batch from handoff until it is reused.
|
||||
bufs [][]byte
|
||||
// chunks are the decrypt jobs, nChunks of them in use.
|
||||
chunks []rxChunk
|
||||
nChunks int
|
||||
}
|
||||
|
||||
func (b *rxBatch) reset() {
|
||||
clear(b.items)
|
||||
b.items = b.items[:0]
|
||||
for i := range b.nChunks {
|
||||
b.chunks[i].items = nil
|
||||
}
|
||||
b.nChunks = 0
|
||||
}
|
||||
|
||||
// stagedRx is the staged receive pipeline of one udp listener. deliver and handoff run on the listener goroutine.
|
||||
type stagedRx struct {
|
||||
f *Interface
|
||||
q int
|
||||
conn handoffConn
|
||||
// jobs feeds the decrypt workers. The listener is the only producer and closes it once the writer has drained.
|
||||
jobs chan *rxChunk
|
||||
workers sync.WaitGroup
|
||||
// h and hostmapCache are the listener's own. wrxc is the commit context: the writer's, or the listener's while
|
||||
// nothing is in flight.
|
||||
h *header.H
|
||||
hostmapCache map[uint32]*HostInfo
|
||||
wrxc *rxContext
|
||||
|
||||
// cur is the batch the listener is filling. The others wait in free, or travel to the writer on ordered and come
|
||||
// back through free; inFlight counts those, and the writer drops it only once it is done with a batch.
|
||||
cur *rxBatch
|
||||
free chan *rxBatch
|
||||
ordered chan *rxBatch
|
||||
inFlight atomic.Int32
|
||||
writerDone chan struct{}
|
||||
|
||||
metricBatches metrics.Counter
|
||||
metricInline metrics.Counter
|
||||
}
|
||||
|
||||
func newStagedRx(f *Interface, q int, wrxc *rxContext, conn handoffConn) *stagedRx {
|
||||
p := &stagedRx{
|
||||
f: f,
|
||||
q: q,
|
||||
conn: conn,
|
||||
h: &header.H{},
|
||||
hostmapCache: map[uint32]*HostInfo{},
|
||||
wrxc: wrxc,
|
||||
free: make(chan *rxBatch, stagedRxSlots),
|
||||
ordered: make(chan *rxBatch, stagedRxSlots),
|
||||
writerDone: make(chan struct{}),
|
||||
metricBatches: metrics.GetOrRegisterCounter("flow.rx.batches", nil),
|
||||
metricInline: metrics.GetOrRegisterCounter("flow.rx.inline", nil),
|
||||
}
|
||||
n := f.staged.workers
|
||||
p.jobs = make(chan *rxChunk, stagedRxSlots*2*n)
|
||||
for range n {
|
||||
p.workers.Go(p.decrypt)
|
||||
}
|
||||
bufs, size := conn.HandoffShape()
|
||||
for i := range stagedRxSlots {
|
||||
// Two chunks per worker, so the writer can start committing while the workers are still on the rest
|
||||
b := &rxBatch{items: make([]rxItem, 0, 256), chunks: make([]rxChunk, 2*n)}
|
||||
for j := range b.chunks {
|
||||
b.chunks[j].done = make(chan struct{}, 1)
|
||||
}
|
||||
if i == 0 {
|
||||
// The first batch reads into the conn's own buffers; every other one brings its own
|
||||
p.cur = b
|
||||
continue
|
||||
}
|
||||
b.bufs = make([][]byte, bufs)
|
||||
for j := range b.bufs {
|
||||
b.bufs[j] = make([]byte, size)
|
||||
}
|
||||
p.free <- b
|
||||
}
|
||||
go p.writer()
|
||||
return p
|
||||
}
|
||||
|
||||
// decrypt is a worker: it decrypts the chunks it is handed and signals each one done.
|
||||
func (p *stagedRx) decrypt() {
|
||||
nb := make([]byte, 12)
|
||||
for c := range p.jobs {
|
||||
decryptRxItems(c.items, nb)
|
||||
c.done <- struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
// listen runs the conn's receive loop through the pipeline until it fails, then drains the pipeline. The conn hands
|
||||
// its buffers over, so a batch moves between stages without a copy.
|
||||
func (p *stagedRx) listen() error {
|
||||
defer p.close()
|
||||
return p.conn.ListenOut(p.deliver, p.handoff)
|
||||
}
|
||||
|
||||
// deliver is the listener's per-packet work: classify the packet and add it to the current batch. Nothing here
|
||||
// decrypts or touches the tun.
|
||||
func (p *stagedRx) deliver(via netip.AddrPort, packet []byte) {
|
||||
it := rxItem{packet: packet, via: via}
|
||||
p.classify(&it)
|
||||
p.cur.items = append(p.cur.items, it)
|
||||
}
|
||||
|
||||
// classify fills in the tunnel for a plain data packet of an established, non-relayed tunnel, leaving anything else
|
||||
// for the writer to handle whole. It is speculative: readOutsidePackets resolves the tunnel again on the writer and
|
||||
// uses the worker's result only when it is still the same one.
|
||||
func (p *stagedRx) classify(it *rxItem) {
|
||||
f := p.f
|
||||
h := p.h
|
||||
packet := it.packet
|
||||
if h.Parse(packet) != nil || h.Version != header.Version || h.Type != header.Message || h.Subtype != header.MessageNone {
|
||||
return
|
||||
}
|
||||
if f.myVpnNetworksTable.Contains(it.via.Addr()) {
|
||||
return
|
||||
}
|
||||
hostinfo := f.hostMap.QueryIndexCached(h.RemoteIndex, p.hostmapCache)
|
||||
if hostinfo == nil || hostinfo.ConnectionState == nil {
|
||||
return
|
||||
}
|
||||
ci := hostinfo.ConnectionState
|
||||
if len(packet) < header.Len+ci.dKey.Overhead() {
|
||||
return
|
||||
}
|
||||
it.ci, it.counter = ci, h.MessageCounter
|
||||
}
|
||||
|
||||
// handoff ends a batch: the batch takes bufs, and the conn reads the next batch into the buffers of the next free
|
||||
// batch.
|
||||
func (p *stagedRx) handoff(bufs [][]byte) [][]byte {
|
||||
p.cur.bufs = bufs
|
||||
p.endBatch()
|
||||
return p.cur.bufs
|
||||
}
|
||||
|
||||
// endBatch hands the batch to the workers and the ordered writer, then takes a free batch.
|
||||
func (p *stagedRx) endBatch() {
|
||||
clear(p.hostmapCache)
|
||||
b := p.cur
|
||||
n := len(b.items)
|
||||
if n == 0 {
|
||||
b.reset()
|
||||
return
|
||||
}
|
||||
p.checkReplays(b.items)
|
||||
|
||||
if p.inFlight.Load() == 0 && n < p.f.staged.inlineBelow {
|
||||
// The writer is idle with nothing in flight, so the listener may commit with its context and flush the tun
|
||||
p.metricInline.Inc(1)
|
||||
p.processInline(b, p.wrxc)
|
||||
b.reset()
|
||||
return
|
||||
}
|
||||
|
||||
parts := max(1, min(len(b.chunks), n/rxChunkMin))
|
||||
size := (n + parts - 1) / parts
|
||||
for off := 0; off < n; off += size {
|
||||
c := &b.chunks[b.nChunks]
|
||||
c.items = b.items[off:min(off+size, n)]
|
||||
b.nChunks++
|
||||
}
|
||||
// The jobs go out before the batch does: once the writer has it, it may finish and reset it at any moment
|
||||
for i := range b.nChunks {
|
||||
p.jobs <- &b.chunks[i]
|
||||
}
|
||||
p.metricBatches.Inc(1)
|
||||
p.inFlight.Add(1)
|
||||
p.ordered <- b
|
||||
// With every batch in flight this waits for the writer, the socket buffer absorbs the backlog meanwhile
|
||||
p.cur = <-p.free
|
||||
}
|
||||
|
||||
// checkReplays marks the replays among items before anything decrypts them, as Decrypt checks before it decrypts,
|
||||
// taking each tunnel's lock once per run of its packets rather than once per packet. The window only moves forward
|
||||
// until the writer records these counters, so a stale check can only let a replay through to acceptDecrypted, which
|
||||
// rejects it.
|
||||
func (p *stagedRx) checkReplays(items []rxItem) {
|
||||
for i := 0; i < len(items); {
|
||||
ci := items[i].ci
|
||||
if ci == nil {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
ci.decryptLock.Lock()
|
||||
for ; i < len(items) && items[i].ci == ci; i++ {
|
||||
if !ci.window.Check(p.f.l, items[i].counter) {
|
||||
items[i].err = ErrAlreadySeen
|
||||
}
|
||||
}
|
||||
ci.decryptLock.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
// processInline decrypts and commits a batch on the calling goroutine, then flushes the tun.
|
||||
func (p *stagedRx) processInline(b *rxBatch, rxc *rxContext) {
|
||||
decryptRxItems(b.items, rxc.nb)
|
||||
p.commit(b.items, rxc)
|
||||
p.f.flushOutside(rxc)
|
||||
}
|
||||
|
||||
// commit runs every item through readOutsidePackets in arrival order, handing it the worker's result for a data
|
||||
// packet, exactly as inline receive handles them.
|
||||
func (p *stagedRx) commit(items []rxItem, rxc *rxContext) {
|
||||
for i := range items {
|
||||
it := &items[i]
|
||||
if it.ci != nil {
|
||||
rxc.decrypted = it
|
||||
}
|
||||
p.f.readOutsidePackets(ViaSender{UdpAddr: it.via}, it.packet, rxc)
|
||||
rxc.decrypted = nil
|
||||
}
|
||||
}
|
||||
|
||||
// writer is the ordered receive stage: it commits each batch chunk by chunk as the workers finish them, so the commit
|
||||
// overlaps the workers still on later chunks, then flushes the tun and returns the batch.
|
||||
func (p *stagedRx) writer() {
|
||||
defer close(p.writerDone)
|
||||
for b := range p.ordered {
|
||||
// Once the tun is going away a write would only log errors, so only wait out the workers
|
||||
closed := p.f.closed.Load()
|
||||
for i := range b.nChunks {
|
||||
c := &b.chunks[i]
|
||||
<-c.done
|
||||
if !closed {
|
||||
p.commit(c.items, p.wrxc)
|
||||
}
|
||||
}
|
||||
if !closed {
|
||||
p.f.flushOutside(p.wrxc)
|
||||
}
|
||||
b.reset()
|
||||
p.inFlight.Add(-1)
|
||||
p.free <- b
|
||||
}
|
||||
}
|
||||
|
||||
// close stops the writer once it has committed everything in flight, in order, then the workers.
|
||||
func (p *stagedRx) close() {
|
||||
close(p.ordered)
|
||||
<-p.writerDone
|
||||
close(p.jobs)
|
||||
p.workers.Wait()
|
||||
}
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/netip"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/flynn/noise"
|
||||
"github.com/rcrowley/go-metrics"
|
||||
"github.com/slackhq/nebula/header"
|
||||
"github.com/slackhq/nebula/noiseutil"
|
||||
"github.com/slackhq/nebula/udp"
|
||||
"github.com/stretchr/testify/require"
|
||||
"go.uber.org/goleak"
|
||||
)
|
||||
|
||||
// TestFlowStagedRXOrderAndReplay feeds every packet behind a forgery of it, from another address, and a replay of
|
||||
// it, then a test packet that jumps the window and the whole stream again, with shuffled workers and a slow tun,
|
||||
// through small and large batches: the tun sees each segment once, in order, the window marks them all, the forgeries
|
||||
// neither consume a counter nor roam, and the jump does not get the earlier data packets of its batch rejected.
|
||||
func TestFlowStagedRXOrderAndReplay(t *testing.T) {
|
||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
||||
for _, cipher := range []noise.CipherFunc{noiseutil.CipherAESGCM, noise.CipherChaChaPoly} {
|
||||
for _, batchLen := range []int{8, 1000} {
|
||||
t.Run(fmt.Sprintf("%s/batch=%d", cipher.CipherName(), batchLen), func(t *testing.T) {
|
||||
sender, receiver := newFlowTestPair(t, cipher, stagedOn(4))
|
||||
delayCrypto(receiver, func(n uint64) {
|
||||
if n%32 == 0 {
|
||||
time.Sleep(time.Millisecond)
|
||||
}
|
||||
})
|
||||
receiver.tun.delay = 100 * time.Microsecond
|
||||
batches, want := flowTestBatches(30, 4, 1, 10)
|
||||
wire := wireFor(t, sender, batches)
|
||||
var feed [][]byte
|
||||
for i, p := range wire {
|
||||
// Corrupt the tag or the payload
|
||||
bad := append([]byte(nil), p...)
|
||||
bad[[]int{len(p) - 1, header.Len + 3}[i%2]] ^= 1
|
||||
feed = append(feed, bad, p, p)
|
||||
}
|
||||
// The jump lands in a batch with fresh data before it, at batch=1000
|
||||
sender.hostinfo.ConnectionState.messageCounter.Add(2 * ReplayWindow)
|
||||
feed = append(append(feed, sendControl(sender, header.Test, header.TestReply)), wire...)
|
||||
forged := func(i int) netip.AddrPort {
|
||||
if i < 3*len(wire) && i%3 == 0 {
|
||||
return netip.MustParseAddrPort("198.51.100.9:4242")
|
||||
}
|
||||
return flowTestUnder
|
||||
}
|
||||
rx0 := rxBatches.Count()
|
||||
conn := &rxConn{wire: feed, batchLen: batchLen, from: forged}
|
||||
receiver.receive(conn)
|
||||
require.Positive(t, rxBatches.Count()-rx0)
|
||||
require.Equal(t, (len(feed)+batchLen-1)/batchLen, conn.swaps, "every batch is handed off")
|
||||
require.Equal(t, want, receiver.tun.segments(t), "every packet exactly once, in order")
|
||||
require.Equal(t, flowTestUnder, receiver.hostinfo.GetRemote())
|
||||
for _, p := range wire {
|
||||
h := &header.H{}
|
||||
require.NoError(t, h.Parse(p))
|
||||
require.False(t, receiver.hostinfo.ConnectionState.window.Check(receiver.f.l, h.MessageCounter), "counter %d must be marked seen", h.MessageCounter)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestFlowStagedRXClose: a CloseTunnel in the middle of a batch is handled in its place, by the writer. The data after
|
||||
// it in the batch is still delivered from the batch's hostmap cache, as inline receive does.
|
||||
func TestFlowStagedRXClose(t *testing.T) {
|
||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, stagedOn(2))
|
||||
batches, want := flowTestBatches(4, 4, 1, 8)
|
||||
wire := wireFor(t, sender, batches)
|
||||
half := len(wire) / 2
|
||||
feed := append(append(append([][]byte{}, wire[:half]...), sendControl(sender, header.CloseTunnel, 0)), wire[half:]...)
|
||||
receiver.receive(&rxConn{wire: feed, batchLen: len(feed)})
|
||||
require.Equal(t, want, receiver.tun.segments(t))
|
||||
require.Nil(t, receiver.f.hostMap.QueryIndex(receiver.hostinfo.localIndexId))
|
||||
}
|
||||
|
||||
// sendControl returns the wire packet of a control message from sender.
|
||||
func sendControl(sender *flowTestPeer, typ header.MessageType, st header.MessageSubType) []byte {
|
||||
sender.f.sendNoMetrics(typ, st, sender.hostinfo.ConnectionState, sender.hostinfo, flowTestUnder, nil, make([]byte, 12), make([]byte, mtu), 0)
|
||||
wire := sender.conn.captured()
|
||||
sender.conn.pkts, sender.conn.addrs = nil, nil
|
||||
return wire[len(wire)-1]
|
||||
}
|
||||
|
||||
// receivePaths is inline, staged and, with the threshold, adaptive receive.
|
||||
func receivePaths() []stagedConfig {
|
||||
return []stagedConfig{{}, stagedOn(2), adaptive(2)}
|
||||
}
|
||||
|
||||
// TestFlowStagedRXRecvError feeds a RecvError that deletes the tunnel, then a known replay and new data for it, in one
|
||||
// batch. Every receive path must drop the data through its own view of the hostmap, without touching the replay window,
|
||||
// and answer each packet with a RecvError, as inline receive does, without decrypting the replay again.
|
||||
func TestFlowStagedRXRecvError(t *testing.T) {
|
||||
for _, sc := range receivePaths() {
|
||||
t.Run(stagedName(sc), func(t *testing.T) {
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, sc)
|
||||
receiver.f.messageMetrics = newMessageMetrics()
|
||||
receiver.f.acceptRecvErrorConfig = recvErrorAlways
|
||||
receiver.f.sendRecvErrorConfig = recvErrorAlways
|
||||
batches, want := flowTestBatches(1, 1, 1, 33)
|
||||
wire := wireFor(t, sender, batches)
|
||||
rxc := newRxContext(receiver.f, 0)
|
||||
receiver.f.readOutsidePackets(ViaSender{UdpAddr: flowTestUnder}, append([]byte(nil), wire[0]...), rxc)
|
||||
receiver.f.flushOutside(rxc)
|
||||
h := &header.H{}
|
||||
require.NoError(t, h.Parse(wire[0]))
|
||||
replay := h.MessageCounter
|
||||
var decrypts atomic.Int64
|
||||
delayCrypto(receiver, func(n uint64) {
|
||||
if n == replay {
|
||||
decrypts.Add(1)
|
||||
}
|
||||
})
|
||||
ctl := header.Encode(make([]byte, header.Len), header.Version, header.RecvError, 0, receiver.hostinfo.remoteIndexId, 0)
|
||||
conn := &rxConn{wire: append([][]byte{ctl}, wire...), batchLen: len(wire) + 1}
|
||||
receiver.receive(conn)
|
||||
require.Nil(t, receiver.f.hostMap.QueryIndex(receiver.hostinfo.localIndexId))
|
||||
require.Equal(t, want[:1], receiver.tun.segments(t))
|
||||
require.Zero(t, decrypts.Load(), "known replays must not be decrypted again")
|
||||
replies := conn.captured()
|
||||
require.Len(t, replies, len(wire))
|
||||
for i, reply := range replies {
|
||||
require.NoError(t, h.Parse(reply))
|
||||
require.Equal(t, header.RecvError, h.Type)
|
||||
require.NoError(t, h.Parse(wire[i]))
|
||||
require.True(t, i == 0 || receiver.hostinfo.ConnectionState.window.Check(nil, h.MessageCounter), "dropped data must not update replay state")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestFlowStagedRXReplacedTunnel classifies a data packet, then a close and a new handshake replace its tunnel at the
|
||||
// same index before the writer commits it, as when the listener runs ahead: it must be dropped untouched.
|
||||
func TestFlowStagedRXReplacedTunnel(t *testing.T) {
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, stagedOn(2))
|
||||
receiver.f.messageMetrics = newMessageMetrics()
|
||||
batches, _ := flowTestBatches(1, 1, 1, 1)
|
||||
wire := wireFor(t, sender, batches)
|
||||
closePacket := sendControl(sender, header.CloseTunnel, 0)
|
||||
p := &stagedRx{f: receiver.f, h: &header.H{}, hostmapCache: map[uint32]*HostInfo{}}
|
||||
item := rxItem{packet: wire[0], via: flowTestUnder}
|
||||
p.classify(&item)
|
||||
require.NotNil(t, item.ci)
|
||||
rxc := newRxContext(receiver.f, 0)
|
||||
p.processInline(&rxBatch{items: []rxItem{{packet: closePacket, via: flowTestUnder}}}, rxc)
|
||||
require.Nil(t, receiver.f.hostMap.QueryIndex(receiver.hostinfo.localIndexId))
|
||||
_, replacement := newFlowTestPair(t, noise.CipherChaChaPoly, stagedOn(2))
|
||||
receiver.f.hostMap.Lock()
|
||||
receiver.f.hostMap.unlockedAddHostInfo(replacement.hostinfo, receiver.f)
|
||||
receiver.f.hostMap.Unlock()
|
||||
p.processInline(&rxBatch{items: []rxItem{item}}, rxc)
|
||||
require.Empty(t, receiver.tun.writes)
|
||||
require.True(t, item.ci.window.Check(nil, item.counter))
|
||||
require.True(t, replacement.hostinfo.ConnectionState.window.Check(nil, item.counter))
|
||||
}
|
||||
|
||||
// TestFlowStagedRXRealSocket exercises buffer handoff through the real Linux UDP receive loop.
|
||||
func TestFlowStagedRXRealSocket(t *testing.T) {
|
||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, stagedOn(3))
|
||||
batches, want := flowTestBatches(60, 4, 1, 8)
|
||||
wire := wireFor(t, sender, batches)
|
||||
|
||||
l := receiver.f.l
|
||||
conn, err := udp.NewListener(l, udp.Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Batch: 16, Offloads: true})
|
||||
require.NoError(t, err)
|
||||
addr, err := conn.LocalAddr()
|
||||
require.NoError(t, err)
|
||||
out, err := udp.NewListener(l, udp.Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Batch: 16, Offloads: true})
|
||||
require.NoError(t, err)
|
||||
defer out.Close()
|
||||
// The sender's address is the tunnel's remote, so no roaming
|
||||
from, err := out.LocalAddr()
|
||||
require.NoError(t, err)
|
||||
receiver.hostinfo.remote.Store(&from)
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() { receiver.receive(conn); close(done) }()
|
||||
// Send in bursts small enough for the default socket buffer
|
||||
for off := 0; off < len(wire); off += 32 {
|
||||
end := min(off+32, len(wire))
|
||||
addrs := make([]netip.AddrPort, end-off)
|
||||
for i := range addrs {
|
||||
addrs[i] = addr
|
||||
}
|
||||
_, err := out.WriteBatch(wire[off:end], addrs)
|
||||
require.NoError(t, err)
|
||||
require.Eventually(t, func() bool { return len(receiver.tun.segments(t)) >= end }, 5*time.Second, 100*time.Microsecond)
|
||||
}
|
||||
receiver.f.closed.Store(true)
|
||||
require.NoError(t, conn.Close())
|
||||
<-done
|
||||
require.Equal(t, want, receiver.tun.segments(t))
|
||||
}
|
||||
|
||||
// TestFlowStagedRXInlineBelow: small idle batches stay on the listener, larger batches still use the ordered writer.
|
||||
func TestFlowStagedRXInlineBelow(t *testing.T) {
|
||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
||||
sc := adaptive(3)
|
||||
sc.inlineBelow = 16
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, sc)
|
||||
batches, want := flowTestBatches(40, 4, 1, 16)
|
||||
wire := wireFor(t, sender, batches)
|
||||
inline := metrics.GetOrRegisterCounter("flow.rx.inline", nil)
|
||||
inline0, rx0 := inline.Count(), rxBatches.Count()
|
||||
receiver.receive(&rxConn{wire: wire, sizes: []int{8, 8, 8, 128, 128, 8, 8, 128, 4, 128}})
|
||||
require.Equal(t, want, receiver.tun.segments(t))
|
||||
require.Positive(t, inline.Count()-inline0)
|
||||
require.Positive(t, rxBatches.Count()-rx0)
|
||||
}
|
||||
+489
@@ -0,0 +1,489 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"io"
|
||||
"math"
|
||||
"net/netip"
|
||||
"os"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/flynn/noise"
|
||||
"github.com/gaissmai/bart"
|
||||
"github.com/rcrowley/go-metrics"
|
||||
"github.com/slackhq/nebula/cert"
|
||||
"github.com/slackhq/nebula/config"
|
||||
"github.com/slackhq/nebula/firewall"
|
||||
"github.com/slackhq/nebula/header"
|
||||
"github.com/slackhq/nebula/iputil"
|
||||
"github.com/slackhq/nebula/noiseutil"
|
||||
"github.com/slackhq/nebula/overlay/batch"
|
||||
"github.com/slackhq/nebula/overlay/tio"
|
||||
"github.com/slackhq/nebula/test"
|
||||
"github.com/slackhq/nebula/udp"
|
||||
"github.com/stretchr/testify/require"
|
||||
"go.uber.org/goleak"
|
||||
)
|
||||
|
||||
// flowTestMSS is the segment payload size of the synthetic TSO superpackets.
|
||||
const flowTestMSS = 1200
|
||||
|
||||
var (
|
||||
flowTestLocal = netip.MustParseAddr("10.0.0.1")
|
||||
flowTestRemote = netip.MustParseAddr("10.0.0.2")
|
||||
flowTestUnder = netip.MustParseAddrPort("192.0.2.2:4242")
|
||||
)
|
||||
|
||||
// flowTCPSuperpacket builds an IPv4/TCP TSO superpacket from local to remote carrying segs segments. Segment i's
|
||||
// payload starts with the flow id, the superpacket seq and i, so a receiver can check what it got and in which order.
|
||||
func flowTCPSuperpacket(flow uint16, seq uint32, segs int) tio.Packet {
|
||||
const hdr = 40
|
||||
pay := segs * flowTestMSS
|
||||
b := make([]byte, hdr+pay)
|
||||
b[0] = 0x45
|
||||
binary.BigEndian.PutUint16(b[2:4], uint16(min(hdr+pay, 65535)))
|
||||
b[8] = 64
|
||||
b[9] = iputil.IPProtocolTCP
|
||||
copy(b[12:16], flowTestLocal.AsSlice())
|
||||
copy(b[16:20], flowTestRemote.AsSlice())
|
||||
binary.BigEndian.PutUint16(b[20:22], 10000+flow)
|
||||
binary.BigEndian.PutUint16(b[22:24], 80)
|
||||
binary.BigEndian.PutUint32(b[24:28], seq*uint32(pay))
|
||||
b[32] = 0x50
|
||||
b[33] = 0x10 // ACK
|
||||
binary.BigEndian.PutUint16(b[34:36], 65535)
|
||||
for i := range segs {
|
||||
p := b[hdr+i*flowTestMSS:]
|
||||
binary.BigEndian.PutUint16(p[0:2], flow)
|
||||
binary.BigEndian.PutUint32(p[2:6], seq)
|
||||
binary.BigEndian.PutUint16(p[6:8], uint16(i))
|
||||
}
|
||||
if segs == 1 {
|
||||
return tio.Packet{Bytes: b}
|
||||
}
|
||||
return tio.Packet{Bytes: b, GSO: tio.GSOInfo{Size: flowTestMSS, HdrLen: hdr, CsumStart: 20, Proto: tio.GSOProtoTCP}}
|
||||
}
|
||||
|
||||
// decodedSeg identifies one segment by the marker flowTCPSuperpacket put in its payload.
|
||||
type decodedSeg struct {
|
||||
flow uint16
|
||||
seq uint32
|
||||
idx uint16
|
||||
}
|
||||
|
||||
func decodeSeg(p []byte) decodedSeg {
|
||||
return decodedSeg{flow: binary.BigEndian.Uint16(p[0:2]), seq: binary.BigEndian.Uint32(p[2:6]), idx: binary.BigEndian.Uint16(p[6:8])}
|
||||
}
|
||||
|
||||
// flowTestBatches builds n reads of per superpackets of segs segments, across flows interleaved flows, and the
|
||||
// segments they carry in order.
|
||||
func flowTestBatches(n, per, flows, segs int) ([][]tio.Packet, []decodedSeg) {
|
||||
var batches [][]tio.Packet
|
||||
var want []decodedSeg
|
||||
seq := make([]uint32, flows)
|
||||
for range n {
|
||||
var b []tio.Packet
|
||||
for j := range per {
|
||||
flow := uint16(j % flows)
|
||||
b = append(b, flowTCPSuperpacket(flow, seq[flow], segs))
|
||||
for s := range segs {
|
||||
want = append(want, decodedSeg{flow: flow, seq: seq[flow], idx: uint16(s)})
|
||||
}
|
||||
seq[flow]++
|
||||
}
|
||||
batches = append(batches, b)
|
||||
}
|
||||
return batches, want
|
||||
}
|
||||
|
||||
// flowTestPeer is one end of a tunnel: the interface, the hostinfo for the other end, and its capture points.
|
||||
type flowTestPeer struct {
|
||||
f *Interface
|
||||
hostinfo *HostInfo
|
||||
conn *flowCaptureConn
|
||||
tun *flowTunCapture
|
||||
}
|
||||
|
||||
// newFlowTestPair builds two interfaces joined by one real tunnel (keys from an actual handshake). sender sends from
|
||||
// flowTestLocal to flowTestRemote, receiver is the far side.
|
||||
func newFlowTestPair(t testing.TB, cipher noise.CipherFunc, sc stagedConfig) (sender, receiver *flowTestPeer) {
|
||||
t.Helper()
|
||||
initR, respR := runTestHandshakeWith(t, cipher)
|
||||
sci, err := newConnectionStateFromResult(initR)
|
||||
require.NoError(t, err)
|
||||
rci, err := newConnectionStateFromResult(respR)
|
||||
require.NoError(t, err)
|
||||
sender = newFlowTestPeer(t, flowTestLocal, flowTestRemote, sci, 100, 200)
|
||||
receiver = newFlowTestPeer(t, flowTestRemote, flowTestLocal, rci, 200, 100)
|
||||
sender.f.staged, receiver.f.staged = sc, sc
|
||||
return sender, receiver
|
||||
}
|
||||
|
||||
func newFlowTestPeer(t testing.TB, me, them netip.Addr, ci *ConnectionState, localIdx, remoteIdx uint32) *flowTestPeer {
|
||||
l := test.NewLogger()
|
||||
hm := newHostMap(l)
|
||||
hm.preferredRanges.Store(&[]netip.Prefix{})
|
||||
|
||||
myNets, myAddrs := &bart.Lite{}, &bart.Lite{}
|
||||
myNets.Insert(netip.PrefixFrom(me, 24))
|
||||
myAddrs.Insert(netip.PrefixFrom(me, 32))
|
||||
myCert := &dummyCert{version: cert.Version1, networks: []netip.Prefix{netip.PrefixFrom(me, 24)}}
|
||||
theirCert := &dummyCert{version: cert.Version1, networks: []netip.Prefix{netip.PrefixFrom(them, 24)}, name: "peer"}
|
||||
ci.peerCert = &cert.CachedCertificate{Certificate: theirCert, InvertedGroups: map[string]struct{}{}}
|
||||
|
||||
fw := NewFirewall(l, time.Minute, time.Minute, time.Minute, myCert)
|
||||
require.NoError(t, fw.AddRule(false, firewall.ProtoAny, 0, 0, []string{"any"}, "", "", "", "", ""))
|
||||
require.NoError(t, fw.AddRule(true, firewall.ProtoAny, 0, 0, []string{"any"}, "", "", "", "", ""))
|
||||
|
||||
conn, tun := &flowCaptureConn{}, &flowTunCapture{}
|
||||
lh := newTestLighthouse()
|
||||
lh.remoteAllowList.Store(&RemoteAllowList{})
|
||||
|
||||
f := &Interface{
|
||||
hostMap: hm,
|
||||
outside: conn,
|
||||
firewall: fw,
|
||||
lightHouse: lh,
|
||||
pki: &PKI{},
|
||||
myVpnNetworksTable: myNets,
|
||||
myVpnAddrsTable: myAddrs,
|
||||
routines: 1,
|
||||
writers: []udp.Conn{conn},
|
||||
messageMetrics: &MessageMetrics{txExhausted: metrics.NewCounter()},
|
||||
metricTxDropped: metrics.NilCounter{},
|
||||
l: l,
|
||||
}
|
||||
f.ctx = t.Context()
|
||||
f.pki.caPool.Store(cert.NewCAPool())
|
||||
// Never promote or requery, those would put extra test packets on the wire
|
||||
f.tryPromoteEvery.Store(math.MaxUint32)
|
||||
f.reQueryEvery.Store(math.MaxUint32)
|
||||
f.batchers = []*batch.MultiCoalescer{batch.NewMultiCoalescer(tun, l)}
|
||||
f.connectionManager = &connectionManager{
|
||||
intf: f,
|
||||
relayUsed: map[uint32]struct{}{},
|
||||
relayUsedLock: &sync.RWMutex{},
|
||||
trafficTimer: NewLockingTimerWheel[uint32](time.Second, time.Minute),
|
||||
}
|
||||
f.handshakeManager = NewHandshakeManager(l, hm, lh, conn, defaultHandshakeConfig)
|
||||
f.handshakeManager.f = f
|
||||
|
||||
hostinfo := &HostInfo{
|
||||
ConnectionState: ci,
|
||||
vpnAddrs: []netip.Addr{them},
|
||||
localIndexId: localIdx,
|
||||
remoteIndexId: remoteIdx,
|
||||
relayState: RelayState{relayForByAddr: map[netip.Addr]*Relay{}, relayForByIdx: map[uint32]*Relay{}},
|
||||
}
|
||||
hostinfo.remote.Store(&flowTestUnder)
|
||||
hostinfo.buildNetworks(myNets, theirCert)
|
||||
hm.unlockedAddHostInfo(hostinfo, f)
|
||||
|
||||
return &flowTestPeer{f: f, hostinfo: hostinfo, conn: conn, tun: tun}
|
||||
}
|
||||
|
||||
// flowCaptureConn records every packet sent, in order, as copies.
|
||||
type flowCaptureConn struct {
|
||||
udp.NoopConn
|
||||
mu sync.Mutex
|
||||
pkts [][]byte
|
||||
addrs []netip.AddrPort
|
||||
// delay, when set, slows every WriteBatch down so batches pile up in flight
|
||||
delay time.Duration
|
||||
}
|
||||
|
||||
func (c *flowCaptureConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
|
||||
time.Sleep(c.delay)
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
for i, b := range bufs {
|
||||
c.pkts = append(c.pkts, append([]byte(nil), b...))
|
||||
c.addrs = append(c.addrs, addrs[i])
|
||||
}
|
||||
return len(bufs), nil
|
||||
}
|
||||
|
||||
func (c *flowCaptureConn) WriteTo(b []byte, addr netip.AddrPort) error {
|
||||
_, err := c.WriteBatch([][]byte{b}, []netip.AddrPort{addr})
|
||||
return err
|
||||
}
|
||||
|
||||
func (c *flowCaptureConn) captured() [][]byte {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
return append([][]byte(nil), c.pkts...)
|
||||
}
|
||||
|
||||
// flowTunCapture is a tun queue that records every plaintext write.
|
||||
type flowTunCapture struct {
|
||||
mu sync.Mutex
|
||||
writes [][]byte
|
||||
// delay, when set, slows every write down
|
||||
delay time.Duration
|
||||
}
|
||||
|
||||
func (c *flowTunCapture) Read() ([]tio.Packet, error) { return nil, io.EOF }
|
||||
func (c *flowTunCapture) Close() error { return nil }
|
||||
func (c *flowTunCapture) Write(b []byte) (int, error) {
|
||||
time.Sleep(c.delay)
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
c.writes = append(c.writes, append([]byte(nil), b...))
|
||||
return len(b), nil
|
||||
}
|
||||
|
||||
// segments decodes what reached the tun. The coalescer may have merged segments back into superpackets, so this
|
||||
// walks each payload in MSS steps.
|
||||
func (c *flowTunCapture) segments(t testing.TB) []decodedSeg {
|
||||
t.Helper()
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
var out []decodedSeg
|
||||
for _, w := range c.writes {
|
||||
pay := w[40:]
|
||||
require.Zero(t, len(pay)%flowTestMSS, "tun write payload %d bytes", len(pay))
|
||||
for off := 0; off < len(pay); off += flowTestMSS {
|
||||
out = append(out, decodeSeg(pay[off:]))
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// decryptWire checks every wire packet decrypts on the receiver, in order, with strictly increasing counters, and
|
||||
// returns what each one carried. It uses its own replay window and copies, so the wire can still be fed to the
|
||||
// receiver afterwards.
|
||||
func decryptWire(t testing.TB, receiver *flowTestPeer, wire [][]byte) []decodedSeg {
|
||||
t.Helper()
|
||||
peer := receiver.hostinfo.ConnectionState
|
||||
ci := &ConnectionState{dKey: peer.dKey, window: NewBits(peer.window.length)}
|
||||
nb := make([]byte, 12)
|
||||
var last uint64
|
||||
out := make([]decodedSeg, 0, len(wire))
|
||||
for i, pkt := range wire {
|
||||
h := &header.H{}
|
||||
require.NoError(t, h.Parse(pkt))
|
||||
require.Equal(t, header.Message, h.Type)
|
||||
require.Equal(t, receiver.hostinfo.localIndexId, h.RemoteIndex)
|
||||
require.Greater(t, h.MessageCounter, last, "wire packet %d: counter %d after %d", i, h.MessageCounter, last)
|
||||
last = h.MessageCounter
|
||||
plain, err := ci.Decrypt(receiver.f.l, h.MessageCounter, append([]byte(nil), pkt...), nb)
|
||||
require.NoError(t, err, "wire packet %d", i)
|
||||
out = append(out, decodeSeg(plain[40:]))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// flowBatchQueue is a tun queue that hands out scripted Read batches, then fails with io.EOF. Every batch is copied
|
||||
// into the current receive buffer, so a test sees the buffer ownership the Offload queue has.
|
||||
type flowBatchQueue struct {
|
||||
batches [][]tio.Packet
|
||||
rxBuf []byte
|
||||
out []tio.Packet
|
||||
closed chan struct{}
|
||||
// reads counts the batches handed out
|
||||
reads atomic.Int64
|
||||
}
|
||||
|
||||
func newFlowBatchQueue(batches [][]tio.Packet) *flowBatchQueue {
|
||||
return &flowBatchQueue{batches: batches, rxBuf: make([]byte, 8*65536), closed: make(chan struct{})}
|
||||
}
|
||||
|
||||
func (q *flowBatchQueue) Read() ([]tio.Packet, error) {
|
||||
select {
|
||||
case <-q.closed:
|
||||
return nil, os.ErrClosed
|
||||
default:
|
||||
}
|
||||
n := int(q.reads.Load())
|
||||
if n == len(q.batches) {
|
||||
return nil, io.EOF
|
||||
}
|
||||
q.out = q.out[:0]
|
||||
off := 0
|
||||
for _, p := range q.batches[n] {
|
||||
l := copy(q.rxBuf[off:], p.Bytes)
|
||||
q.out = append(q.out, tio.Packet{Bytes: q.rxBuf[off : off+l : off+l], GSO: p.GSO})
|
||||
off += l
|
||||
}
|
||||
q.reads.Add(1)
|
||||
return q.out, nil
|
||||
}
|
||||
|
||||
func (q *flowBatchQueue) Write(b []byte) (int, error) { return len(b), nil }
|
||||
|
||||
func (q *flowBatchQueue) Close() error { close(q.closed); return nil }
|
||||
|
||||
// delayedCipher changes scheduling through the real cipher interface, only in tests.
|
||||
type delayedCipher struct {
|
||||
noiseutil.CipherState
|
||||
before func(uint64)
|
||||
}
|
||||
|
||||
func (c delayedCipher) EncryptDanger(out, ad, plain []byte, n uint64, nb []byte) ([]byte, error) {
|
||||
c.before(n)
|
||||
return c.CipherState.EncryptDanger(out, ad, plain, n, nb)
|
||||
}
|
||||
|
||||
func (c delayedCipher) DecryptDanger(out, ad, ciphertext []byte, n uint64, nb []byte) ([]byte, error) {
|
||||
c.before(n)
|
||||
return c.CipherState.DecryptDanger(out, ad, ciphertext, n, nb)
|
||||
}
|
||||
|
||||
func delayCrypto(peer *flowTestPeer, before func(uint64)) {
|
||||
ci := peer.hostinfo.ConnectionState
|
||||
ci.eKey = delayedCipher{ci.eKey, before}
|
||||
ci.dKey = delayedCipher{ci.dKey, before}
|
||||
}
|
||||
|
||||
// stagedOn enables staging with n workers.
|
||||
func stagedOn(n int) stagedConfig {
|
||||
return stagedConfig{workers: n}
|
||||
}
|
||||
|
||||
// adaptive is staging with the inline threshold parseStagedConfig sets.
|
||||
func adaptive(n int) stagedConfig {
|
||||
return stagedConfig{workers: n, inlineBelow: 256}
|
||||
}
|
||||
|
||||
func stagedName(sc stagedConfig) string {
|
||||
switch {
|
||||
case sc.workers == 0:
|
||||
return "inline"
|
||||
case sc.inlineBelow > 0:
|
||||
return "adaptive"
|
||||
default:
|
||||
return "staged"
|
||||
}
|
||||
}
|
||||
|
||||
// TestFlowStagedFallback: a conn that cannot hand off its batches keeps receive on the inline path.
|
||||
func TestFlowStagedFallback(t *testing.T) {
|
||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, stagedOn(3))
|
||||
batches, want := flowTestBatches(10, 2, 1, 4)
|
||||
wire := wireFor(t, sender, batches)
|
||||
require.Equal(t, want, decryptWire(t, receiver, wire))
|
||||
rx0 := rxBatches.Count()
|
||||
receiver.receive(plainConn{&rxConn{wire: wire, batchLen: 16}})
|
||||
require.Equal(t, want, receiver.tun.segments(t))
|
||||
require.Equal(t, rx0, rxBatches.Count())
|
||||
}
|
||||
|
||||
// wireFor produces the wire packets the sender emits for batches.
|
||||
func wireFor(t testing.TB, sender *flowTestPeer, batches [][]tio.Packet) [][]byte {
|
||||
t.Helper()
|
||||
sender.f.listenIn(newFlowBatchQueue(batches), 0)
|
||||
wire := sender.conn.captured()
|
||||
sender.conn.pkts, sender.conn.addrs = nil, nil
|
||||
return wire
|
||||
}
|
||||
|
||||
// rxConn plays wire back to listenOut through the buffer handoff, in batches of batchLen or of the scripted sizes
|
||||
// (the last one repeating), and captures what is sent back. Every buffer handed back is scribbled over before it is
|
||||
// read into, so a stage still using one shows corruption. from, when set, picks each packet's source address by its
|
||||
// index in wire.
|
||||
type rxConn struct {
|
||||
flowCaptureConn
|
||||
wire [][]byte
|
||||
batchLen int
|
||||
sizes []int
|
||||
from func(i int) netip.AddrPort
|
||||
swaps int
|
||||
}
|
||||
|
||||
func (c *rxConn) HandoffShape() (n, size int) {
|
||||
n = c.batchLen
|
||||
for _, s := range c.sizes {
|
||||
n = max(n, s)
|
||||
}
|
||||
return n, udp.MTU
|
||||
}
|
||||
|
||||
func (c *rxConn) ListenOut(r udp.EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
n, _ := c.HandoffShape()
|
||||
bufs := make([][]byte, n)
|
||||
for i := range bufs {
|
||||
bufs[i] = make([]byte, udp.MTU)
|
||||
}
|
||||
for off, k := 0, 0; off < len(c.wire); k++ {
|
||||
size := c.batchLen
|
||||
if len(c.sizes) > 0 {
|
||||
size = c.sizes[min(k, len(c.sizes)-1)]
|
||||
}
|
||||
end := min(off+size, len(c.wire))
|
||||
for i, p := range c.wire[off:end] {
|
||||
n := copy(bufs[i], p)
|
||||
from := flowTestUnder
|
||||
if c.from != nil {
|
||||
from = c.from(off + i)
|
||||
}
|
||||
r(from, bufs[i][:n:n])
|
||||
}
|
||||
next := handoff(bufs)
|
||||
if len(next) != len(bufs) {
|
||||
panic("handoff returned the wrong number of buffers")
|
||||
}
|
||||
bufs = next
|
||||
for _, b := range bufs {
|
||||
for j := range b[:udp.MTU] {
|
||||
b[j] = 0x5a
|
||||
}
|
||||
}
|
||||
c.swaps++
|
||||
off = end
|
||||
}
|
||||
return os.ErrClosed
|
||||
}
|
||||
|
||||
// plainConn hides HandoffShape, so receive stays inline.
|
||||
type plainConn struct{ udp.Conn }
|
||||
|
||||
var rxBatches = metrics.GetOrRegisterCounter("flow.rx.batches", nil)
|
||||
|
||||
// receive runs the peer's listenOut over conn until conn runs out.
|
||||
func (p *flowTestPeer) receive(conn udp.Conn) {
|
||||
p.f.writers = []udp.Conn{conn}
|
||||
p.f.outside = conn
|
||||
p.f.listenOut(0)
|
||||
}
|
||||
|
||||
// TestFlowStagedFirewallParity: both receive paths apply the same inbound policy. An authenticated inbound denial
|
||||
// still consumes its replay counter, exactly as inline Decrypt does.
|
||||
func TestFlowStagedFirewallParity(t *testing.T) {
|
||||
for _, sc := range []stagedConfig{{}, stagedOn(2)} {
|
||||
t.Run(stagedName(sc), func(t *testing.T) {
|
||||
batches, _ := flowTestBatches(4, 3, 1, 8)
|
||||
sender, receiver := newFlowTestPair(t, noise.CipherChaChaPoly, sc)
|
||||
wire := wireFor(t, sender, batches)
|
||||
receiver.f.firewall.InRules = newFirewallTable()
|
||||
receiver.receive(&rxConn{wire: wire, batchLen: 64})
|
||||
require.Empty(t, receiver.tun.writes)
|
||||
for _, pkt := range wire {
|
||||
h := &header.H{}
|
||||
require.NoError(t, h.Parse(pkt))
|
||||
require.False(t, receiver.hostinfo.ConnectionState.window.Check(receiver.f.l, h.MessageCounter))
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestFlowStagedAESGCM runs the parsed configuration with the real AES cipher. Receive decryption has no nonce
|
||||
// ordering requirement, so it stays staged in BoringCrypto and FIPS builds too.
|
||||
func TestFlowStagedAESGCM(t *testing.T) {
|
||||
l := test.NewLogger()
|
||||
c := config.NewC(l)
|
||||
c.Settings = map[string]any{"tun": map[string]any{"staged": map[string]any{"workers": 2}}}
|
||||
sender, receiver := newFlowTestPair(t, noiseutil.CipherAESGCM, parseStagedConfig(c, l))
|
||||
require.Equal(t, 2, receiver.f.staged.workers)
|
||||
batches, want := flowTestBatches(4, 8, 1, 45)
|
||||
wire := wireFor(t, sender, batches)
|
||||
rx0 := rxBatches.Count()
|
||||
receiver.receive(&rxConn{wire: wire, batchLen: 512})
|
||||
require.Greater(t, rxBatches.Count(), rx0)
|
||||
require.Equal(t, want, receiver.tun.segments(t))
|
||||
}
|
||||
+18
-6
@@ -65,6 +65,7 @@ type InterfaceConfig struct {
|
||||
// goroutine's sendmmsg on one XPS-selected NIC TX ring so per-flow
|
||||
// packets stay ordered on the wire.
|
||||
PinThreads bool
|
||||
staged stagedConfig
|
||||
|
||||
l *slog.Logger
|
||||
}
|
||||
@@ -99,6 +100,7 @@ type Interface struct {
|
||||
// a CPU at all (tun.pin_threads, default true). When false, threads are
|
||||
// left free to migrate as on stock nebula.
|
||||
pinThreads bool
|
||||
staged stagedConfig
|
||||
relayManager *relayManager
|
||||
|
||||
tryPromoteEvery atomic.Uint32
|
||||
@@ -248,6 +250,7 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
||||
conntrackCacheTimeout: c.ConntrackCacheTimeout,
|
||||
cpuAffinity: c.CpuAffinity,
|
||||
pinThreads: c.PinThreads,
|
||||
staged: c.staged,
|
||||
udpTxErrLimiter: udpTxErrLimiter,
|
||||
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
|
||||
txOversizeLimiter: txOversizeLimiter,
|
||||
@@ -384,6 +387,8 @@ type rxContext struct {
|
||||
hostmapCache map[uint32]*HostInfo
|
||||
lhh *LightHouseHandler
|
||||
ctCache *firewall.ConntrackCacheTicker
|
||||
// decrypted is staged receive's result for the packet being handled, decrypted ahead of time on a worker
|
||||
decrypted *rxItem
|
||||
}
|
||||
|
||||
func newRxContext(f *Interface, q int) *rxContext {
|
||||
@@ -413,14 +418,21 @@ func (f *Interface) listenOut(i int) {
|
||||
f.readOutsidePackets(ViaSender{UdpAddr: fromUdpAddr}, payload, rxc)
|
||||
}
|
||||
|
||||
flusher := func() {
|
||||
if err := f.batchers[i].Flush(); err != nil {
|
||||
f.l.Error("Failed to flush tun coalescer", "error", err)
|
||||
}
|
||||
clear(rxc.hostmapCache)
|
||||
flusher := func(bufs [][]byte) [][]byte {
|
||||
f.flushOutside(rxc)
|
||||
return bufs
|
||||
}
|
||||
|
||||
err := li.ListenOut(listener, flusher)
|
||||
var err error
|
||||
if hc, ok := li.(handoffConn); ok && f.staged.workers > 0 {
|
||||
// Every stage on its own goroutine, see flow_rx.go. rxc becomes the ordered writer's context.
|
||||
err = newStagedRx(f, i, rxc, hc).listen()
|
||||
} else {
|
||||
if f.staged.workers > 0 {
|
||||
f.l.Info("udp conn cannot hand off receive batches, receive stays inline", "reader", i)
|
||||
}
|
||||
err = li.ListenOut(listener, flusher)
|
||||
}
|
||||
|
||||
// An error after teardown began is shutdown noise, the closed flag covers resources
|
||||
// Close releases itself and the cancelled ctx covers ones torn down by their owners
|
||||
|
||||
@@ -244,6 +244,7 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
|
||||
pinThreads := c.GetBool("tun.pin_threads", true)
|
||||
cpuAffinity := parseCpuAffinity(c, l, routines)
|
||||
staged := parseStagedConfig(c, l)
|
||||
if pinThreads && routines > 1 && len(cpuAffinity) == 0 && !configTest {
|
||||
// The operator didn't choose pin CPUs, so pick a default set that
|
||||
// prefers performance cores and doesn't stack co-located instances
|
||||
@@ -296,6 +297,7 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
ConntrackCacheTimeout: conntrackCacheTimeout,
|
||||
CpuAffinity: cpuAffinity,
|
||||
PinThreads: pinThreads,
|
||||
staged: staged,
|
||||
l: l,
|
||||
}
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"net/netip"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
@@ -123,3 +124,23 @@ firewall:
|
||||
require.NoError(t, err)
|
||||
require.Nil(t, ctrl, "a config test hands back nothing to stop, so it must stop itself")
|
||||
}
|
||||
|
||||
func TestParseStagedConfig(t *testing.T) {
|
||||
l := test.NewLogger()
|
||||
staged := func(workers any) stagedConfig {
|
||||
c := config.NewC(l)
|
||||
if workers != nil {
|
||||
c.Settings["tun"] = map[string]any{"staged": map[string]any{"workers": workers}}
|
||||
}
|
||||
return parseStagedConfig(c, l)
|
||||
}
|
||||
for _, workers := range []any{nil, -1, 0} {
|
||||
require.Equal(t, stagedConfig{}, staged(workers))
|
||||
}
|
||||
if runtime.GOOS != "linux" {
|
||||
require.Equal(t, stagedConfig{}, staged(2))
|
||||
return
|
||||
}
|
||||
want := stagedConfig{workers: 2, inlineBelow: 256}
|
||||
require.Equal(t, want, staged(2))
|
||||
}
|
||||
+15
-1
@@ -129,7 +129,13 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
||||
return
|
||||
}
|
||||
|
||||
out, err := hostinfo.ConnectionState.Decrypt(f.l, h.MessageCounter, packet, rxc.nb)
|
||||
var out []byte
|
||||
if pre := rxc.decrypted; pre != nil && pre.ci == hostinfo.ConnectionState {
|
||||
// Staged receive already checked and decrypted this packet on a worker, only the replay window is left
|
||||
out, err = pre.ci.acceptDecrypted(f.l, h.MessageCounter, pre.out, pre.err)
|
||||
} else {
|
||||
out, err = hostinfo.ConnectionState.Decrypt(f.l, h.MessageCounter, packet, rxc.nb)
|
||||
}
|
||||
if err != nil {
|
||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||
hostinfo.logger(f.l).Debug("Failed to decrypt packet", "error", err, "from", via, "header", h)
|
||||
@@ -473,6 +479,14 @@ func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// flushOutside ends a receive batch: it writes out the tun coalescer and drops the batch's hostmap cache.
|
||||
func (f *Interface) flushOutside(rxc *rxContext) {
|
||||
if err := f.batchers[rxc.q].Flush(); err != nil {
|
||||
f.l.Error("Failed to flush tun coalescer", "error", err)
|
||||
}
|
||||
clear(rxc.hostmapCache)
|
||||
}
|
||||
|
||||
func (f *Interface) handleOutsideMessagePacket(hostinfo *HostInfo, messageCounter uint64, out []byte, rxc *rxContext) {
|
||||
err := newPacket(out, true, rxc.fwPacket)
|
||||
if err != nil {
|
||||
|
||||
+98
-14
@@ -6,8 +6,10 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"math/bits"
|
||||
"net/netip"
|
||||
"os"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
@@ -28,7 +30,7 @@ type tun struct {
|
||||
DefaultMTU int
|
||||
Routes atomic.Pointer[[]Route]
|
||||
routeTree atomic.Pointer[bart.Table[routing.Gateways]]
|
||||
linkAddr *netroute.LinkAddr
|
||||
linkAddr atomic.Pointer[netroute.LinkAddr]
|
||||
// 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
|
||||
@@ -243,7 +245,7 @@ func (t *tun) Activate() error {
|
||||
if linkAddr == nil {
|
||||
return fmt.Errorf("unable to discover link_addr for tun interface")
|
||||
}
|
||||
t.linkAddr = linkAddr
|
||||
t.linkAddr.Store(linkAddr)
|
||||
|
||||
for _, network := range t.vpnNetworks {
|
||||
if network.Addr().Is4() {
|
||||
@@ -269,6 +271,7 @@ func (t *tun) Activate() error {
|
||||
return t.addRoutes(false)
|
||||
}
|
||||
|
||||
// activate4 assigns our vpn address as a /32 and routes the vpn network to the tun explicitly.
|
||||
func (t *tun) activate4(network netip.Prefix) error {
|
||||
s, err := unix.Socket(
|
||||
unix.AF_INET,
|
||||
@@ -295,22 +298,32 @@ func (t *tun) activate4(network netip.Prefix) error {
|
||||
MaskAddr: unix.RawSockaddrInet4{
|
||||
Len: unix.SizeofSockaddrInet4,
|
||||
Family: unix.AF_INET,
|
||||
Addr: prefixToMask(network).As4(),
|
||||
Addr: [4]byte{255, 255, 255, 255}, //always make the address a /32
|
||||
},
|
||||
}
|
||||
|
||||
// On Darwin, VPNs don't edit the routing table directly.
|
||||
// A network extension hands its routes to the system, and configd installs them.
|
||||
// configd replaces any route already holding the same prefix, including ours.
|
||||
// As an example, Tailscale with an exit node treats any interface prefix wider than one address as a LAN.
|
||||
// With LAN access off, it routes each LAN into Tailscale's utun.
|
||||
// With LAN access on, it excludes each LAN from its tunnel.
|
||||
// configd routes an excluded prefix like its own routes would, ignoring ours, so it goes out the default route.
|
||||
// Either way our route is replaced, and traffic for the vpn network no longer reaches nebula.
|
||||
// A single address isn't a LAN to Tailscale, so our route is left alone.
|
||||
// We route the vpn network to the tun explicitly instead.
|
||||
|
||||
if err := ioctl(uintptr(s), unix.SIOCAIFADDR, uintptr(unsafe.Pointer(&ifr))); err != nil {
|
||||
return fmt.Errorf("failed to set tun v4 address: %s", err)
|
||||
}
|
||||
|
||||
err = addRoute(network, t.linkAddr)
|
||||
if err != nil {
|
||||
return err
|
||||
if err := addRoute(network, t.linkAddr.Load()); err != nil {
|
||||
return fmt.Errorf("failed to add route for %v: %w", network.Masked(), err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// activate6 is activate4 for IPv6
|
||||
func (t *tun) activate6(network netip.Prefix) error {
|
||||
s, err := unix.Socket(
|
||||
unix.AF_INET6,
|
||||
@@ -332,20 +345,24 @@ func (t *tun) activate6(network netip.Prefix) error {
|
||||
PrefixMask: unix.RawSockaddrInet6{
|
||||
Len: unix.SizeofSockaddrInet6,
|
||||
Family: unix.AF_INET6,
|
||||
Addr: prefixToMask(network).As16(),
|
||||
// Always set the netmask to be a /128. See activate4 for why we do this.
|
||||
Addr: [16]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
|
||||
},
|
||||
Lifetime: addrLifetime{
|
||||
// never expires
|
||||
Vltime: 0xffffffff,
|
||||
Pltime: 0xffffffff,
|
||||
},
|
||||
Flags: _IN6_IFF_NODAD,
|
||||
Flags: _IN6_IFF_NODAD, // No DAD, a utun has no neighbors.
|
||||
}
|
||||
|
||||
if err := ioctl(uintptr(s), _SIOCAIFADDR_IN6, uintptr(unsafe.Pointer(&ifr))); err != nil {
|
||||
return fmt.Errorf("failed to set tun address: %s", err)
|
||||
}
|
||||
|
||||
if err := addRoute(network, t.linkAddr.Load()); err != nil {
|
||||
return fmt.Errorf("failed to add route for %v: %w", network.Masked(), err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -394,6 +411,56 @@ func (t *tun) RoutesFor(ip netip.Addr) routing.Gateways {
|
||||
return routing.Gateways{}
|
||||
}
|
||||
|
||||
func fetchRoutes() ([]netroute.Message, error) {
|
||||
rib, err := netroute.FetchRIB(unix.AF_UNSPEC, unix.NET_RT_DUMP, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return netroute.ParseRIB(unix.NET_RT_DUMP, rib)
|
||||
}
|
||||
|
||||
// routeInterfaceIn returns the index of the interface prefix is routed through, or 0 if msgs has no route for exactly
|
||||
// that prefix. Routes scoped to an interface are skipped, they don't stop us adding ours.
|
||||
func routeInterfaceIn(msgs []netroute.Message, prefix netip.Prefix) int {
|
||||
for _, msg := range msgs {
|
||||
m, ok := msg.(*netroute.RouteMessage)
|
||||
if !ok || len(m.Addrs) <= unix.RTAX_NETMASK || m.Flags&unix.RTF_IFSCOPE != 0 {
|
||||
continue
|
||||
}
|
||||
if p, ok := routePrefix(m.Addrs[unix.RTAX_DST], m.Addrs[unix.RTAX_NETMASK]); ok && p == prefix.Masked() {
|
||||
return m.Index
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// routePrefix returns the prefix a route covers. Host routes have no netmask.
|
||||
func routePrefix(dst, mask netroute.Addr) (netip.Prefix, bool) {
|
||||
switch d := dst.(type) {
|
||||
case *netroute.Inet4Addr:
|
||||
bits := 32
|
||||
if m, ok := mask.(*netroute.Inet4Addr); ok {
|
||||
bits = maskBits(m.IP[:])
|
||||
}
|
||||
return netip.PrefixFrom(netip.AddrFrom4(d.IP), bits), true
|
||||
case *netroute.Inet6Addr:
|
||||
bits := 128
|
||||
if m, ok := mask.(*netroute.Inet6Addr); ok {
|
||||
bits = maskBits(m.IP[:])
|
||||
}
|
||||
return netip.PrefixFrom(netip.AddrFrom16(d.IP), bits), true
|
||||
}
|
||||
return netip.Prefix{}, false
|
||||
}
|
||||
|
||||
func maskBits(mask []byte) int {
|
||||
n := 0
|
||||
for _, b := range mask {
|
||||
n += bits.OnesCount8(b)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// Get the LinkAddr for the interface of the given name
|
||||
// Is there an easier way to fetch this when we create the interface?
|
||||
// Maybe SIOCGIFINDEX? but this doesn't appear to exist in the darwin headers.
|
||||
@@ -428,7 +495,14 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Activate hasn't run yet, it will install the routes
|
||||
linkAddr := t.linkAddr.Load()
|
||||
if linkAddr == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
routes := *t.Routes.Load()
|
||||
systemRoutes := sync.OnceValues(fetchRoutes)
|
||||
|
||||
for _, r := range routes {
|
||||
if len(r.Via) == 0 || !r.Install {
|
||||
@@ -436,10 +510,16 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
continue
|
||||
}
|
||||
|
||||
err := addRoute(r.Cidr, t.linkAddr)
|
||||
err := addRoute(r.Cidr, linkAddr)
|
||||
if err != nil {
|
||||
if errors.Is(err, unix.EEXIST) {
|
||||
t.l.Warn("unable to add unsafe_route, identical route already exists", "route", r.Cidr)
|
||||
// Every route we added already exists on a reload, only warn about someone else's
|
||||
msgs, err := systemRoutes()
|
||||
if err != nil {
|
||||
t.l.Warn("unable to add unsafe_route, a route already exists but its interface could not be determined", "route", r.Cidr, "error", err)
|
||||
} else if routeInterfaceIn(msgs, r.Cidr) != linkAddr.Index {
|
||||
t.l.Warn("unable to add unsafe_route, the destination is already routed through another interface", "route", r.Cidr)
|
||||
}
|
||||
} else {
|
||||
retErr := util.NewContextualError("Failed to add route", map[string]any{"route": r}, err)
|
||||
if logErrors {
|
||||
@@ -450,6 +530,8 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
}
|
||||
} else {
|
||||
t.l.Info("Added route", "route", r)
|
||||
// A cidr listed twice would otherwise find our own route missing from an older fetch
|
||||
systemRoutes = sync.OnceValues(fetchRoutes)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -457,16 +539,18 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
}
|
||||
|
||||
func (t *tun) removeRoutes(routes []Route) error {
|
||||
if t.hostOwned {
|
||||
linkAddr := t.linkAddr.Load()
|
||||
if t.hostOwned || linkAddr == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, r := range routes {
|
||||
if !r.Install {
|
||||
if len(r.Via) == 0 || !r.Install {
|
||||
// addRoutes never installs these
|
||||
continue
|
||||
}
|
||||
|
||||
err := delRoute(r.Cidr, t.linkAddr)
|
||||
err := delRoute(r.Cidr, linkAddr)
|
||||
if err != nil {
|
||||
t.l.Error("Failed to remove route", "error", err, "route", r)
|
||||
} else {
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
//go:build darwin && !ios && !e2e_testing
|
||||
|
||||
package overlay
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/netip"
|
||||
"os"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/slackhq/nebula/config"
|
||||
"github.com/slackhq/nebula/routing"
|
||||
"github.com/slackhq/nebula/test"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
netroute "golang.org/x/net/route"
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// Every mac routes loopback through lo0
|
||||
func TestRouteInterfaceIn(t *testing.T) {
|
||||
msgs, err := fetchRoutes()
|
||||
require.NoError(t, err)
|
||||
routeInterface := func(s string) int { return routeInterfaceIn(msgs, netip.MustParsePrefix(s)) }
|
||||
|
||||
lo0, err := net.InterfaceByName("lo0")
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, lo0.Index, routeInterface("127.0.0.0/8"))
|
||||
assert.Equal(t, lo0.Index, routeInterface("127.0.0.1/32"), "a host route has no netmask")
|
||||
assert.Equal(t, lo0.Index, routeInterface("::1/128"))
|
||||
assert.Equal(t, 0, routeInterface("127.0.0.0/16"), "only an exact prefix counts")
|
||||
|
||||
// Most macs also list the default route scoped to their other interfaces
|
||||
out, err := exec.Command("route", "-n", "get", "default").Output()
|
||||
require.NoError(t, err)
|
||||
var name string
|
||||
for _, line := range strings.Split(string(out), "\n") {
|
||||
if v, ok := strings.CutPrefix(strings.TrimSpace(line), "interface: "); ok {
|
||||
name = v
|
||||
}
|
||||
}
|
||||
if name == "" {
|
||||
t.Skip("no default route")
|
||||
}
|
||||
def, err := net.InterfaceByName(name)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, def.Index, routeInterface("0.0.0.0/0"))
|
||||
}
|
||||
|
||||
func TestRouteInterfaceIn_SkipsScopedCopies(t *testing.T) {
|
||||
route := func(index, flags int) netroute.Message {
|
||||
addrs := make([]netroute.Addr, unix.RTAX_MAX)
|
||||
addrs[unix.RTAX_DST] = &netroute.Inet4Addr{IP: [4]byte{192, 168, 1, 0}}
|
||||
addrs[unix.RTAX_NETMASK] = &netroute.Inet4Addr{IP: [4]byte{255, 255, 255, 0}}
|
||||
return &netroute.RouteMessage{Index: index, Flags: flags, Addrs: addrs}
|
||||
}
|
||||
p := netip.MustParsePrefix("192.168.1.0/24")
|
||||
assert.Equal(t, 7, routeInterfaceIn([]netroute.Message{route(4, unix.RTF_UP|unix.RTF_IFSCOPE), route(7, unix.RTF_UP)}, p))
|
||||
assert.Equal(t, 0, routeInterfaceIn([]netroute.Message{route(4, unix.RTF_UP|unix.RTF_IFSCOPE)}, p))
|
||||
}
|
||||
|
||||
// A reload can happen before Activate
|
||||
func TestTunRoutesBeforeActivate(t *testing.T) {
|
||||
tn := &tun{l: test.NewLogger()}
|
||||
routes := []Route{{
|
||||
Cidr: netip.MustParsePrefix("10.253.1.0/24"),
|
||||
Via: routing.Gateways{routing.NewGateway(netip.MustParseAddr("10.250.0.2"), 1)},
|
||||
Install: true,
|
||||
}}
|
||||
tn.Routes.Store(&routes)
|
||||
|
||||
assert.NoError(t, tn.addRoutes(true))
|
||||
assert.NoError(t, tn.removeRoutes(routes))
|
||||
}
|
||||
|
||||
// A tun.routes entry with no via is never installed, so removing it must not delete a route for the same cidr that
|
||||
// belongs to someone else
|
||||
func TestTunReloadLeavesRoutesItNeverInstalled(t *testing.T) {
|
||||
if os.Geteuid() != 0 {
|
||||
t.Skip("creating a utun and adding routes needs root")
|
||||
}
|
||||
lo0, err := net.InterfaceByName("lo0")
|
||||
require.NoError(t, err)
|
||||
cidr := "10.250.0.128/25"
|
||||
require.NoError(t, exec.Command("route", "-q", "-n", "add", "-net", cidr, "-interface", "lo0").Run())
|
||||
t.Cleanup(func() { _ = exec.Command("route", "-q", "-n", "delete", "-net", cidr).Run() })
|
||||
|
||||
l := test.NewLogger()
|
||||
c := config.NewC(l)
|
||||
require.NoError(t, c.LoadString("tun:\n routes:\n - route: "+cidr+"\n mtu: 1300\n"))
|
||||
tn, err := newTun(c, l, []netip.Prefix{netip.MustParsePrefix("10.250.0.1/24")}, false)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() { _ = tn.Close() })
|
||||
require.NoError(t, tn.Activate())
|
||||
|
||||
require.NoError(t, c.ReloadConfigString("tun: {}\n"))
|
||||
msgs, err := fetchRoutes()
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, lo0.Index, routeInterfaceIn(msgs, netip.MustParsePrefix(cidr)))
|
||||
}
|
||||
@@ -589,7 +589,8 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
|
||||
func (t *tun) removeRoutes(routes []Route) error {
|
||||
for _, r := range routes {
|
||||
if !r.Install {
|
||||
if len(r.Via) == 0 || !r.Install {
|
||||
// addRoutes never installs these
|
||||
continue
|
||||
}
|
||||
|
||||
|
||||
@@ -420,7 +420,8 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
|
||||
func (t *tun) removeRoutes(routes []Route) error {
|
||||
for _, r := range routes {
|
||||
if !r.Install {
|
||||
if len(r.Via) == 0 || !r.Install {
|
||||
// addRoutes never installs these
|
||||
continue
|
||||
}
|
||||
|
||||
|
||||
@@ -399,7 +399,8 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
|
||||
func (t *tun) removeRoutes(routes []Route) error {
|
||||
for _, r := range routes {
|
||||
if !r.Install {
|
||||
if len(r.Via) == 0 || !r.Install {
|
||||
// addRoutes never installs these
|
||||
continue
|
||||
}
|
||||
|
||||
|
||||
@@ -60,6 +60,20 @@ type sshDeviceInfoFlags struct {
|
||||
func wireSSHReload(l *slog.Logger, ssh *sshd.SSHServer, c *config.C) {
|
||||
c.RegisterReloadCallback(func(c *config.C) {
|
||||
if c.GetBool("sshd.enabled", false) {
|
||||
// Restarting the server drops every open session, the one that asked for this reload included. Only restart
|
||||
// when it isn't running or its config changed. The host key file can change under the same config, new
|
||||
// handshakes use the new key without a restart
|
||||
if ssh.Running() && !c.HasChanged("sshd") {
|
||||
key, err := loadSSHHostKey(c)
|
||||
if err == nil {
|
||||
err = ssh.SetHostKey(key)
|
||||
}
|
||||
if err != nil {
|
||||
l.Error("Failed to reconfigure the sshd", "error", err)
|
||||
ssh.Stop()
|
||||
}
|
||||
return
|
||||
}
|
||||
sshRun, err := configSSH(l, ssh, c)
|
||||
if err != nil {
|
||||
l.Error("Failed to reconfigure the sshd", "error", err)
|
||||
@@ -74,6 +88,22 @@ func wireSSHReload(l *slog.Logger, ssh *sshd.SSHServer, c *config.C) {
|
||||
})
|
||||
}
|
||||
|
||||
// loadSSHHostKey returns sshd.host_key, read from its file when it names one.
|
||||
func loadSSHHostKey(c *config.C) ([]byte, error) {
|
||||
hostKeyPathOrKey := c.GetString("sshd.host_key", "")
|
||||
if hostKeyPathOrKey == "" {
|
||||
return nil, fmt.Errorf("sshd.host_key must be provided")
|
||||
}
|
||||
if strings.Contains(hostKeyPathOrKey, "-----BEGIN") {
|
||||
return []byte(hostKeyPathOrKey), nil
|
||||
}
|
||||
b, err := os.ReadFile(hostKeyPathOrKey)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error while loading sshd.host_key file: %s", err)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
// configSSH reads the ssh info out of the passed-in Config and
|
||||
// updates the passed-in SSHServer. On success, it returns a function
|
||||
// that callers may invoke to run the configured ssh server. On
|
||||
@@ -92,19 +122,9 @@ func configSSH(l *slog.Logger, ssh *sshd.SSHServer, c *config.C) (func(), error)
|
||||
return nil, fmt.Errorf("sshd.listen can not use port 22")
|
||||
}
|
||||
|
||||
hostKeyPathOrKey := c.GetString("sshd.host_key", "")
|
||||
if hostKeyPathOrKey == "" {
|
||||
return nil, fmt.Errorf("sshd.host_key must be provided")
|
||||
}
|
||||
|
||||
var hostKeyBytes []byte
|
||||
if strings.Contains(hostKeyPathOrKey, "-----BEGIN") {
|
||||
hostKeyBytes = []byte(hostKeyPathOrKey)
|
||||
} else {
|
||||
hostKeyBytes, err = os.ReadFile(hostKeyPathOrKey)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error while loading sshd.host_key file: %s", err)
|
||||
}
|
||||
hostKeyBytes, err := loadSSHHostKey(c)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = ssh.SetHostKey(hostKeyBytes)
|
||||
|
||||
+48
-13
@@ -8,14 +8,18 @@ import (
|
||||
"log/slog"
|
||||
"net"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/armon/go-radix"
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
type SSHServer struct {
|
||||
config *ssh.ServerConfig
|
||||
l *slog.Logger
|
||||
// config is replaced whole when the host key changes, ssh.ServerConfig.AddHostKey only replaces a key of the same
|
||||
// algorithm and appends any other
|
||||
config atomic.Pointer[ssh.ServerConfig]
|
||||
authenticate func(ssh.ConnMetadata, ssh.PublicKey) (*ssh.Permissions, error)
|
||||
l *slog.Logger
|
||||
|
||||
certChecker *ssh.CertChecker
|
||||
|
||||
@@ -28,7 +32,12 @@ type SSHServer struct {
|
||||
// List of available commands
|
||||
helpCommand *Command
|
||||
commands *radix.Tree
|
||||
listener net.Listener
|
||||
listener atomic.Pointer[net.Listener]
|
||||
|
||||
// runs counts the Runs that are listening. A reload's Run can start before the one it replaced has returned
|
||||
runs atomic.Int32
|
||||
// addr is where the newest Run listens, nil when none is
|
||||
addr atomic.Pointer[net.Addr]
|
||||
|
||||
// ctx parents per-Run contexts. Cancelling it (e.g. via Control.Stop) tears the server down even
|
||||
// across reloads, since each Run derives a fresh child rather than reusing this one directly.
|
||||
@@ -85,10 +94,8 @@ func NewSSHServer(ctx context.Context, l *slog.Logger) (*SSHServer, error) {
|
||||
},
|
||||
}
|
||||
|
||||
s.config = &ssh.ServerConfig{
|
||||
PublicKeyCallback: cc.Authenticate,
|
||||
ServerVersion: fmt.Sprintf("SSH-2.0-Nebula???"),
|
||||
}
|
||||
s.authenticate = cc.Authenticate
|
||||
s.config.Store(s.newConfig())
|
||||
|
||||
s.RegisterCommand(&Command{
|
||||
Name: "help",
|
||||
@@ -107,10 +114,32 @@ func (s *SSHServer) SetHostKey(hostPrivateKey []byte) error {
|
||||
return fmt.Errorf("failed to parse private key: %s", err)
|
||||
}
|
||||
|
||||
s.config.AddHostKey(private)
|
||||
config := s.newConfig()
|
||||
config.AddHostKey(private)
|
||||
s.config.Store(config)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *SSHServer) newConfig() *ssh.ServerConfig {
|
||||
return &ssh.ServerConfig{
|
||||
PublicKeyCallback: s.authenticate,
|
||||
ServerVersion: fmt.Sprintf("SSH-2.0-Nebula???"),
|
||||
}
|
||||
}
|
||||
|
||||
// Addr is the address the newest Run listens on, nil when none is.
|
||||
func (s *SSHServer) Addr() net.Addr {
|
||||
if a := s.addr.Load(); a != nil {
|
||||
return *a
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Running is true while a Run is listening.
|
||||
func (s *SSHServer) Running() bool {
|
||||
return s.runs.Load() > 0
|
||||
}
|
||||
|
||||
func (s *SSHServer) ClearTrustedCAs() {
|
||||
s.authLock.Lock()
|
||||
s.trustedCAs = []ssh.PublicKey{}
|
||||
@@ -181,10 +210,16 @@ func (s *SSHServer) Run(addr string) error {
|
||||
// this run owns. They start equal but a fast reload may overwrite s.listener with the next run's
|
||||
// listener before this run's watcher fires, so each run must close its own listener via the local
|
||||
// reference.
|
||||
s.listener = listener
|
||||
s.listener.Store(&listener)
|
||||
s.runs.Add(1)
|
||||
bound := listener.Addr()
|
||||
s.addr.Store(&bound)
|
||||
|
||||
runCtx, cancel := context.WithCancel(s.ctx)
|
||||
defer cancel()
|
||||
// Deferred after cancel so they run first, a run on its way out no longer counts as listening
|
||||
defer s.runs.Add(-1)
|
||||
defer s.addr.CompareAndSwap(&bound, nil)
|
||||
|
||||
// Close the listener when this run's context is cancelled. That can come from the parent
|
||||
// (Control.Stop), from Run returning normally (defer cancel above), or transitively when a sibling
|
||||
@@ -197,7 +232,7 @@ func (s *SSHServer) Run(addr string) error {
|
||||
}
|
||||
}()
|
||||
|
||||
s.l.Info("SSH server is listening", "sshListener", addr)
|
||||
s.l.Info("SSH server is listening", "sshListener", bound)
|
||||
|
||||
// Run loops until there is an error
|
||||
s.run(runCtx, listener)
|
||||
@@ -226,7 +261,7 @@ func (s *SSHServer) run(ctx context.Context, listener net.Listener) {
|
||||
<-sessionContext.Done()
|
||||
c.Close()
|
||||
}()
|
||||
conn, chans, reqs, err := ssh.NewServerConn(c, s.config)
|
||||
conn, chans, reqs, err := ssh.NewServerConn(c, s.config.Load())
|
||||
fp := ""
|
||||
if conn != nil {
|
||||
fp = conn.Permissions.Extensions["fp"]
|
||||
@@ -264,8 +299,8 @@ func (s *SSHServer) run(ctx context.Context, listener net.Listener) {
|
||||
}
|
||||
|
||||
func (s *SSHServer) Stop() {
|
||||
if s.listener != nil {
|
||||
if err := s.listener.Close(); err != nil {
|
||||
if l := s.listener.Load(); l != nil {
|
||||
if err := (*l).Close(); err != nil && !errors.Is(err, net.ErrClosed) {
|
||||
s.l.Warn("Failed to close the sshd listener", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,196 @@
|
||||
package nebula
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/ed25519"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
"encoding/pem"
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/slackhq/nebula/config"
|
||||
"github.com/slackhq/nebula/sshd"
|
||||
"github.com/slackhq/nebula/test"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
type sshdReloadHarness struct {
|
||||
c *config.C
|
||||
server *sshd.SSHServer
|
||||
keyFile string
|
||||
signer ssh.Signer
|
||||
extra string
|
||||
}
|
||||
|
||||
func newSSHDReloadHarness(t *testing.T) *sshdReloadHarness {
|
||||
t.Helper()
|
||||
l := test.NewLogger()
|
||||
h := &sshdReloadHarness{keyFile: filepath.Join(t.TempDir(), "host_key")}
|
||||
h.writeHostKey(t, newEd25519Key(t))
|
||||
|
||||
_, userKey, err := ed25519.GenerateKey(rand.Reader)
|
||||
require.NoError(t, err)
|
||||
h.signer, err = ssh.NewSignerFromKey(userKey)
|
||||
require.NoError(t, err)
|
||||
|
||||
h.c = config.NewC(l)
|
||||
require.NoError(t, h.c.LoadString(h.config()))
|
||||
h.server, err = sshd.NewSSHServer(t.Context(), l)
|
||||
require.NoError(t, err)
|
||||
wireSSHReload(l, h.server, h.c)
|
||||
run, err := configSSH(l, h.server, h.c)
|
||||
require.NoError(t, err)
|
||||
go run()
|
||||
t.Cleanup(h.server.Stop)
|
||||
require.Eventually(t, h.server.Running, 5*time.Second, 10*time.Millisecond)
|
||||
return h
|
||||
}
|
||||
|
||||
func newEd25519Key(t *testing.T) crypto.Signer {
|
||||
_, key, err := ed25519.GenerateKey(rand.Reader)
|
||||
require.NoError(t, err)
|
||||
return key
|
||||
}
|
||||
|
||||
// writeHostKey replaces the host key file and returns the public key a client should now see
|
||||
func (h *sshdReloadHarness) writeHostKey(t *testing.T, key crypto.Signer) ssh.PublicKey {
|
||||
t.Helper()
|
||||
block, err := ssh.MarshalPrivateKey(key, "")
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, os.WriteFile(h.keyFile, pem.EncodeToMemory(block), 0o600))
|
||||
pub, err := ssh.NewPublicKey(key.Public())
|
||||
require.NoError(t, err)
|
||||
return pub
|
||||
}
|
||||
|
||||
func (h *sshdReloadHarness) config() string {
|
||||
return fmt.Sprintf("sshd:\n enabled: true\n listen: 127.0.0.1:0\n host_key: %s\n authorized_users:\n - user: test\n keys: [%q]\n%s",
|
||||
h.keyFile, string(ssh.MarshalAuthorizedKey(h.signer.PublicKey())), h.extra)
|
||||
}
|
||||
|
||||
// dial connects to wherever the server listens now, a restart on :0 moves it. hostKeyAlgorithms limits which host keys
|
||||
// the client accepts, none means any
|
||||
func (h *sshdReloadHarness) dial(hostKeyAlgorithms ...string) (*ssh.Client, ssh.PublicKey, error) {
|
||||
addr := h.server.Addr()
|
||||
if addr == nil {
|
||||
return nil, nil, fmt.Errorf("not listening")
|
||||
}
|
||||
var hostKey ssh.PublicKey
|
||||
c, err := ssh.Dial("tcp", addr.String(), &ssh.ClientConfig{
|
||||
User: "test",
|
||||
Auth: []ssh.AuthMethod{ssh.PublicKeys(h.signer)},
|
||||
HostKeyCallback: func(_ string, _ net.Addr, key ssh.PublicKey) error {
|
||||
hostKey = key
|
||||
return nil
|
||||
},
|
||||
HostKeyAlgorithms: hostKeyAlgorithms,
|
||||
Timeout: time.Second,
|
||||
})
|
||||
return c, hostKey, err
|
||||
}
|
||||
|
||||
func (h *sshdReloadHarness) connect(t *testing.T) (*ssh.Client, ssh.PublicKey) {
|
||||
t.Helper()
|
||||
var client *ssh.Client
|
||||
var hostKey ssh.PublicKey
|
||||
require.Eventually(t, func() bool {
|
||||
var err error
|
||||
client, hostKey, err = h.dial()
|
||||
return err == nil
|
||||
}, 5*time.Second, 20*time.Millisecond)
|
||||
t.Cleanup(func() { _ = client.Close() })
|
||||
return client, hostKey
|
||||
}
|
||||
|
||||
// dropped is true when the server closed the client's connection within wait
|
||||
func dropped(client *ssh.Client, wait time.Duration) bool {
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
_ = client.Wait()
|
||||
close(done)
|
||||
}()
|
||||
select {
|
||||
case <-done:
|
||||
return true
|
||||
case <-time.After(wait):
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Restarting sshd drops every open session, the one that asked for the reload included. A reload that touches nothing
|
||||
// sshd reads leaves it alone
|
||||
func TestSSHDReload_UnchangedKeepsSessions(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
client, _ := h.connect(t)
|
||||
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()+"punchy:\n punch: true\n"))
|
||||
assert.False(t, dropped(client, 500*time.Millisecond), "an unchanged sshd was restarted")
|
||||
}
|
||||
|
||||
func TestSSHDReload_ChangedConfigRestarts(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
client, _ := h.connect(t)
|
||||
|
||||
h.extra = " trusted_cas: []\n"
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()))
|
||||
assert.True(t, dropped(client, 5*time.Second), "a changed sshd config was not applied")
|
||||
require.Eventually(t, h.server.Running, 5*time.Second, 10*time.Millisecond)
|
||||
h.connect(t)
|
||||
}
|
||||
|
||||
// The config can stay the same while the host key file it names changes. New connections get the new key, open
|
||||
// sessions are left alone
|
||||
func TestSSHDReload_ChangedHostKeyFile(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
client, _ := h.connect(t)
|
||||
|
||||
want := h.writeHostKey(t, newEd25519Key(t))
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()))
|
||||
_, got := h.connect(t)
|
||||
assert.Equal(t, want.Marshal(), got.Marshal(), "a new host key was not applied")
|
||||
assert.False(t, dropped(client, 500*time.Millisecond), "a new host key restarted sshd")
|
||||
}
|
||||
|
||||
// A host key of another algorithm replaces the old one rather than being offered next to it
|
||||
func TestSSHDReload_HostKeyAlgorithmChange(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
h.connect(t)
|
||||
|
||||
rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
|
||||
require.NoError(t, err)
|
||||
want := h.writeHostKey(t, rsaKey)
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()))
|
||||
|
||||
_, got := h.connect(t)
|
||||
assert.Equal(t, want.Marshal(), got.Marshal())
|
||||
_, _, err = h.dial(ssh.KeyAlgoED25519)
|
||||
assert.Error(t, err, "the old ed25519 host key is still offered")
|
||||
}
|
||||
|
||||
// A server that isn't running, say its port was busy, is tried again on every reload as before
|
||||
func TestSSHDReload_NotRunningRestarts(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
h.server.Stop()
|
||||
require.Eventually(t, func() bool { return !h.server.Running() }, 5*time.Second, 10*time.Millisecond)
|
||||
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()))
|
||||
require.Eventually(t, h.server.Running, 5*time.Second, 10*time.Millisecond)
|
||||
h.connect(t)
|
||||
}
|
||||
|
||||
// A host key that no longer loads stops sshd, the same as a config that doesn't
|
||||
func TestSSHDReload_BadHostKeyFileStops(t *testing.T) {
|
||||
h := newSSHDReloadHarness(t)
|
||||
h.connect(t)
|
||||
|
||||
require.NoError(t, os.WriteFile(h.keyFile, []byte("not a key"), 0o600))
|
||||
require.NoError(t, h.c.ReloadConfigString(h.config()))
|
||||
require.Eventually(t, func() bool { return !h.server.Running() }, 5*time.Second, 10*time.Millisecond)
|
||||
}
|
||||
+7
-6
@@ -29,11 +29,12 @@ type Settings struct {
|
||||
type Conn interface {
|
||||
Rebind() error
|
||||
LocalAddr() (netip.AddrPort, error)
|
||||
// ListenOut invokes r for each received packet.
|
||||
// On batch-capable backends (recvmmsg), flush is called after each batch is fully delivered.
|
||||
// Callers use it to flush per-batch accumulators such as TUN write coalescers.
|
||||
// Single-packet backends call flush after each packet. flush must not be nil.
|
||||
ListenOut(r EncReader, flush func()) error
|
||||
// ListenOut invokes r for each received packet. The packets alias the receive buffers.
|
||||
// After each batch is fully delivered (after each packet on single-packet backends), handoff takes the batch's
|
||||
// buffers and returns the ones to receive the next batch into: the same ones once the caller is done with the
|
||||
// packets, after flushing per-batch accumulators such as TUN write coalescers, or replacements of the same count
|
||||
// and size to keep them. handoff must not be nil.
|
||||
ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error
|
||||
WriteTo(b []byte, addr netip.AddrPort) error
|
||||
// WriteBatch sends a contiguous batch of packets, each with its own
|
||||
// destination. bufs and addrs must have the same length. Linux uses
|
||||
@@ -56,7 +57,7 @@ func (NoopConn) Rebind() error {
|
||||
func (NoopConn) LocalAddr() (netip.AddrPort, error) {
|
||||
return netip.AddrPort{}, nil
|
||||
}
|
||||
func (NoopConn) ListenOut(_ EncReader, _ func()) error {
|
||||
func (NoopConn) ListenOut(_ EncReader, _ func([][]byte) [][]byte) error {
|
||||
return nil
|
||||
}
|
||||
func (NoopConn) SupportsMultipleReaders() bool {
|
||||
|
||||
+5
-3
@@ -180,8 +180,9 @@ func NewUDPStatsEmitter(udpConns []Conn) func() {
|
||||
return func() {}
|
||||
}
|
||||
|
||||
func (u *StdConn) ListenOut(r EncReader, flush func()) error {
|
||||
buffer := make([]byte, MTU)
|
||||
func (u *StdConn) ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
bufs := [][]byte{make([]byte, MTU)}
|
||||
buffer := bufs[0]
|
||||
|
||||
for {
|
||||
// Just read one packet at a time
|
||||
@@ -195,7 +196,8 @@ func (u *StdConn) ListenOut(r EncReader, flush func()) error {
|
||||
}
|
||||
|
||||
r(netip.AddrPortFrom(rua.Addr().Unmap(), rua.Port()), buffer[:n:n])
|
||||
flush()
|
||||
bufs = handoff(bufs)
|
||||
buffer = bufs[0]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+5
-3
@@ -86,8 +86,9 @@ type rawMessage struct {
|
||||
Len uint32
|
||||
}
|
||||
|
||||
func (u *GenericConn) ListenOut(r EncReader, flush func()) error {
|
||||
buffer := make([]byte, MTU)
|
||||
func (u *GenericConn) ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
bufs := [][]byte{make([]byte, MTU)}
|
||||
buffer := bufs[0]
|
||||
|
||||
var lastRecvErr time.Time
|
||||
|
||||
@@ -107,7 +108,8 @@ func (u *GenericConn) ListenOut(r EncReader, flush func()) error {
|
||||
}
|
||||
|
||||
r(netip.AddrPortFrom(rua.Addr().Unmap(), rua.Port()), buffer[:n:n])
|
||||
flush()
|
||||
bufs = handoff(bufs)
|
||||
buffer = bufs[0]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+24
-4
@@ -245,11 +245,18 @@ func getFrom(names [][]byte, i int, isV4 bool) netip.AddrPort {
|
||||
return netip.AddrPortFrom(ip.Unmap(), binary.BigEndian.Uint16(names[i][2:4]))
|
||||
}
|
||||
|
||||
func (u *StdConn) ListenOut(r EncReader, flush func()) error {
|
||||
bufSize := MTU
|
||||
// HandoffShape is the count and size of the buffers ListenOut hands over after each batch.
|
||||
func (u *StdConn) HandoffShape() (n, size int) {
|
||||
if u.groSupported {
|
||||
return u.batch, udpGROBufferSize
|
||||
}
|
||||
return u.batch, MTU
|
||||
}
|
||||
|
||||
func (u *StdConn) ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
_, bufSize := u.HandoffShape()
|
||||
cmsgSpace := 0
|
||||
if u.groSupported {
|
||||
bufSize = udpGROBufferSize
|
||||
cmsgSpace = unix.CmsgSpace(udpGROCmsgPayload)
|
||||
}
|
||||
msgs, buffers, names, _ := prepareRawMessages(u.batch, bufSize, cmsgSpace)
|
||||
@@ -283,7 +290,20 @@ func (u *StdConn) ListenOut(r EncReader, flush func()) error {
|
||||
deliverSegments(r, from, payload, segSize)
|
||||
}
|
||||
|
||||
flush()
|
||||
next := handoff(buffers)
|
||||
if len(next) != len(buffers) {
|
||||
panic(fmt.Sprintf("udp: handoff returned %d buffers, need %d", len(next), len(buffers)))
|
||||
}
|
||||
if &next[0] != &buffers[0] {
|
||||
// Replacements, point the recvmmsg iovecs at them
|
||||
for i := range next {
|
||||
if len(next[i]) < bufSize {
|
||||
panic(fmt.Sprintf("udp: handoff buffer is %d bytes, need %d", len(next[i]), bufSize))
|
||||
}
|
||||
msgs[i].Hdr.Iov.Base = &next[i][0]
|
||||
}
|
||||
buffers = next
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -226,7 +226,7 @@ func TestOffloadsDisabledRxDelivers(t *testing.T) {
|
||||
_ = sc.ListenOut(func(from netip.AddrPort, payload []byte) {
|
||||
// payload aliases the shared recv buffer row; copy before handing off.
|
||||
rxCh <- rxPkt{from, slices.Clone(payload)}
|
||||
}, func() {})
|
||||
}, func(bufs [][]byte) [][]byte { return bufs })
|
||||
}()
|
||||
|
||||
tx, err := net.DialUDP("udp4", nil, net.UDPAddrFromAddrPort(addr))
|
||||
|
||||
@@ -142,7 +142,7 @@ func runTeardownCase(t *testing.T, batch int, name string, traffic func(send net
|
||||
go func() {
|
||||
loopDone <- sc.ListenOut(func(netip.AddrPort, []byte) {
|
||||
received.Add(1)
|
||||
}, func() {})
|
||||
}, func(bufs [][]byte) [][]byte { return bufs })
|
||||
}()
|
||||
|
||||
send, err := net.Dial("udp", addr.String())
|
||||
|
||||
@@ -142,8 +142,9 @@ func (u *RIOConn) bind(l *slog.Logger, sa windows.Sockaddr) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (u *RIOConn) ListenOut(r EncReader, flush func()) error {
|
||||
buffer := make([]byte, MTU)
|
||||
func (u *RIOConn) ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
bufs := [][]byte{make([]byte, MTU)}
|
||||
buffer := bufs[0]
|
||||
|
||||
var lastRecvErr time.Time
|
||||
|
||||
@@ -164,7 +165,8 @@ func (u *RIOConn) ListenOut(r EncReader, flush func()) error {
|
||||
}
|
||||
|
||||
r(netip.AddrPortFrom(netip.AddrFrom16(rua.Addr).Unmap(), (rua.Port>>8)|((rua.Port&0xff)<<8)), buffer[:n:n])
|
||||
flush()
|
||||
bufs = handoff(bufs)
|
||||
buffer = bufs[0]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+12
-4
@@ -182,16 +182,24 @@ func (u *TesterConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, err
|
||||
return written, nil
|
||||
}
|
||||
|
||||
func (u *TesterConn) ListenOut(r EncReader, flush func()) error {
|
||||
// HandoffShape is one buffer per handoff; the pool resizes the replacements it gets back as it needs.
|
||||
func (u *TesterConn) HandoffShape() (n, size int) { return 1, MTU }
|
||||
|
||||
// ListenOut hands each packet's buffer over as a batch of one, the buffer it gets back goes to the pool. Like StdConn
|
||||
// it carries on with the slice handoff returns, since a reader that keeps the packets keeps the one it was given.
|
||||
// The batcher borrows plaintext decrypted in place inside p.Data until it flushes, inside handoff, so the packet
|
||||
// must stay alive until handoff returns.
|
||||
func (u *TesterConn) ListenOut(r EncReader, handoff func(bufs [][]byte) [][]byte) error {
|
||||
bufs := make([][]byte, 1)
|
||||
for {
|
||||
select {
|
||||
case <-u.done:
|
||||
return os.ErrClosed
|
||||
case p := <-u.RxPackets:
|
||||
r(p.From, p.Data[:len(p.Data):len(p.Data)])
|
||||
// The batcher borrows plaintext decrypted in place inside p.Data
|
||||
// until Flush, so the packet must stay alive across flush()
|
||||
flush()
|
||||
bufs[0] = p.Data
|
||||
bufs = handoff(bufs)
|
||||
p.Data = bufs[0]
|
||||
p.Release()
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user