mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 18:26:57 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4dbeff889c | ||
|
|
673f59b2b2 | ||
|
|
3871faf26e | ||
|
|
b66c9bb362 | ||
|
|
501fda7a40 |
No files matched your search
@@ -61,3 +61,24 @@ jobs:
|
|||||||
run: NAME="smoke-p256" ./smoke.sh
|
run: NAME="smoke-p256" ./smoke.sh
|
||||||
|
|
||||||
timeout-minutes: 10
|
timeout-minutes: 10
|
||||||
|
|
||||||
|
smoke-self:
|
||||||
|
name: Run self traffic smoke test on macOS
|
||||||
|
runs-on: macos-latest
|
||||||
|
steps:
|
||||||
|
|
||||||
|
- uses: actions/checkout@v7
|
||||||
|
|
||||||
|
- uses: actions/setup-go@v7
|
||||||
|
with:
|
||||||
|
go-version: '1.26'
|
||||||
|
check-latest: true
|
||||||
|
|
||||||
|
- name: build
|
||||||
|
run: make bin
|
||||||
|
|
||||||
|
- name: run smoke-self
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: ./smoke-self.sh
|
||||||
|
|
||||||
|
timeout-minutes: 10
|
||||||
Executable
+130
@@ -0,0 +1,130 @@
|
|||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
# A host must be able to reach its own overlay address. Where the kernel sends
|
||||||
|
# that traffic through the tun rather than over loopback, nebula sees it and
|
||||||
|
# hands it straight back (immediatelyForwardToSelf), and whether the kernel
|
||||||
|
# accepts what comes back is only answerable against a real kernel. Runs one
|
||||||
|
# nebula on this machine as root and aims every probe at its own address.
|
||||||
|
|
||||||
|
set -e -x
|
||||||
|
|
||||||
|
set -o pipefail
|
||||||
|
|
||||||
|
V4=192.0.2.1
|
||||||
|
V6=2001:db8::1
|
||||||
|
|
||||||
|
case "$(uname -s)" in
|
||||||
|
Darwin) TUN_DEV=utun ;;
|
||||||
|
*) TUN_DEV=tun0 ;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
ROOT="$(cd ../../.. && pwd)"
|
||||||
|
|
||||||
|
rm -rf build/self
|
||||||
|
mkdir -p build/self
|
||||||
|
cd build/self
|
||||||
|
|
||||||
|
cleanup() {
|
||||||
|
echo
|
||||||
|
echo " *** cleanup"
|
||||||
|
echo
|
||||||
|
|
||||||
|
set +e
|
||||||
|
if [ -n "$NEBULA_PID" ]
|
||||||
|
then
|
||||||
|
sudo kill "$NEBULA_PID"
|
||||||
|
fi
|
||||||
|
{ kill $(jobs -p); wait; } 2>/dev/null
|
||||||
|
sed 's/^/ [self] /' nebula.log
|
||||||
|
}
|
||||||
|
|
||||||
|
trap cleanup EXIT
|
||||||
|
|
||||||
|
# perl is on every platform this runs on; timeout(1) is not.
|
||||||
|
alarm() {
|
||||||
|
perl -e 'alarm shift; exec @ARGV' "$@"
|
||||||
|
}
|
||||||
|
|
||||||
|
RESULTS=""
|
||||||
|
FAILED=""
|
||||||
|
probe() {
|
||||||
|
local name="$1"
|
||||||
|
shift
|
||||||
|
if "$@"
|
||||||
|
then
|
||||||
|
RESULTS="$RESULTS $name=ok"
|
||||||
|
else
|
||||||
|
RESULTS="$RESULTS $name=FAIL"
|
||||||
|
FAILED="$FAILED $name"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Send one datagram, then wait for the listener to have written it out.
|
||||||
|
udp_probe() {
|
||||||
|
echo self | alarm 5 nc -u -w1 "$1" 3000 || true
|
||||||
|
set +x
|
||||||
|
for _ in $(seq 1 20)
|
||||||
|
do
|
||||||
|
if grep -q self "$2"
|
||||||
|
then
|
||||||
|
set -x
|
||||||
|
return 0
|
||||||
|
fi
|
||||||
|
sleep 0.25
|
||||||
|
done
|
||||||
|
set -x
|
||||||
|
return 1
|
||||||
|
}
|
||||||
|
|
||||||
|
"$ROOT/nebula-cert" ca -name "Smoke Test"
|
||||||
|
"$ROOT/nebula-cert" sign -name self -networks "$V4/24,$V6/64"
|
||||||
|
|
||||||
|
HOST=self AM_LIGHTHOUSE=true TUN_DEV="$TUN_DEV" ../../genconfig.sh >self.yml
|
||||||
|
|
||||||
|
"$ROOT/nebula" -config self.yml -test
|
||||||
|
|
||||||
|
sudo -v
|
||||||
|
sudo "$ROOT/nebula" -config self.yml >nebula.log 2>&1 &
|
||||||
|
NEBULA_PID=$!
|
||||||
|
|
||||||
|
for _ in $(seq 1 40)
|
||||||
|
do
|
||||||
|
ifconfig | grep "inet6 $V6 " >/dev/null && break
|
||||||
|
sleep 0.25
|
||||||
|
done
|
||||||
|
ifconfig | grep "inet $V4 "
|
||||||
|
ifconfig | grep "inet6 $V6 "
|
||||||
|
|
||||||
|
nc -l "$V4" 2000 >/dev/null &
|
||||||
|
nc -l "$V6" 2000 >/dev/null &
|
||||||
|
nc -u -l "$V4" 3000 >udp4.txt &
|
||||||
|
nc -u -l "$V6" 3000 >udp6.txt &
|
||||||
|
sleep 1
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** Testing self traffic from $V4"
|
||||||
|
echo
|
||||||
|
set -x
|
||||||
|
probe icmp4 alarm 5 ping -c1 "$V4"
|
||||||
|
probe tcp4 alarm 5 nc -z "$V4" 2000
|
||||||
|
probe udp4 udp_probe "$V4" udp4.txt
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** Testing self traffic from $V6"
|
||||||
|
echo
|
||||||
|
set -x
|
||||||
|
probe icmp6 alarm 5 ping6 -c1 "$V6"
|
||||||
|
probe tcp6 alarm 5 nc -z "$V6" 2000
|
||||||
|
probe udp6 udp_probe "$V6" udp6.txt
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** self traffic:$RESULTS"
|
||||||
|
echo
|
||||||
|
if [ -n "$FAILED" ]
|
||||||
|
then
|
||||||
|
echo "self traffic failed:$FAILED" >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
@@ -51,15 +51,19 @@ wsl -d $Distro -- bash -c "rm -rf $WslDir && mkdir -p $WslDir" | Out-Null
|
|||||||
$DevName = 'nebula-smoke'
|
$DevName = 'nebula-smoke'
|
||||||
$Ip1 = '192.168.241.1'
|
$Ip1 = '192.168.241.1'
|
||||||
$Ip2 = '192.168.241.2'
|
$Ip2 = '192.168.241.2'
|
||||||
|
# Dual stack on purpose: a v4-only overlay never exercises the v6 side of tun.mtu.
|
||||||
|
$Ip6_1 = 'fd42:4242:241::1'
|
||||||
|
$Ip6_2 = 'fd42:4242:241::2'
|
||||||
|
$Mtu = 1300
|
||||||
$Port = 4242
|
$Port = 4242
|
||||||
|
|
||||||
& $NebulaCert ca -name 'smoke-ca' -out-crt "$WorkDir\ca.crt" -out-key "$WorkDir\ca.key"
|
& $NebulaCert ca -name 'smoke-ca' -out-crt "$WorkDir\ca.crt" -out-key "$WorkDir\ca.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert ca failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert ca failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
& $NebulaCert sign -name 'lighthouse' -networks "$Ip1/24" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\lighthouse.crt" -out-key "$WorkDir\lighthouse.key"
|
& $NebulaCert sign -name 'lighthouse' -networks "$Ip1/24,$Ip6_1/64" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\lighthouse.crt" -out-key "$WorkDir\lighthouse.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign lighthouse failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign lighthouse failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
& $NebulaCert sign -name 'peer' -networks "$Ip2/24" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\peer.crt" -out-key "$WorkDir\peer.key"
|
& $NebulaCert sign -name 'peer' -networks "$Ip2/24,$Ip6_2/64" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\peer.crt" -out-key "$WorkDir\peer.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign peer failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign peer failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
# Windows lighthouse config.
|
# Windows lighthouse config.
|
||||||
@@ -82,7 +86,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: 1300
|
mtu: $Mtu
|
||||||
network_category: private
|
network_category: private
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
@@ -126,7 +130,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: 1300
|
mtu: $Mtu
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
format: text
|
format: text
|
||||||
@@ -169,7 +173,7 @@ Write-Host '=== WSL diagnostic ==='
|
|||||||
wsl --version 2>&1 | Out-Host
|
wsl --version 2>&1 | Out-Host
|
||||||
wsl --list --verbose 2>&1 | Out-Host
|
wsl --list --verbose 2>&1 | Out-Host
|
||||||
wsl -d $Distro -u root -- uname -a | Out-Host
|
wsl -d $Distro -u root -- uname -a | Out-Host
|
||||||
wsl -d $Distro -u root -- bash -c "modprobe tun 2>&1 || true; mkdir -p /dev/net; [ -c /dev/net/tun ] || mknod /dev/net/tun c 10 200; chmod 600 /dev/net/tun; ls -l /dev/net/tun"
|
wsl -d $Distro -u root -- bash -c "modprobe tun 2>&1 || true; mkdir -p /dev/net; [ -c /dev/net/tun ] || mknod /dev/net/tun c 10 200; chmod 600 /dev/net/tun; { echo 0 > /proc/sys/net/ipv6/conf/all/disable_ipv6; echo 0 > /proc/sys/net/ipv6/conf/default/disable_ipv6; } 2>/dev/null || true; ls -l /dev/net/tun"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "failed to prepare /dev/net/tun in WSL (TUN support missing?)" }
|
if ($LASTEXITCODE -ne 0) { throw "failed to prepare /dev/net/tun in WSL (TUN support missing?)" }
|
||||||
|
|
||||||
# Deliberately no New-NetFirewallRule calls here -- nebula's windows_bypass_wdf
|
# Deliberately no New-NetFirewallRule calls here -- nebula's windows_bypass_wdf
|
||||||
@@ -214,6 +218,16 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: $DevName NetworkCategory=Private"
|
Write-Host "OK: $DevName NetworkCategory=Private"
|
||||||
|
|
||||||
|
# v6 silently kept the adapter default of 65535 while v4 was correct.
|
||||||
|
foreach ($family in @('IPv4', 'IPv6')) {
|
||||||
|
Wait-Until -TimeoutSec 30 -What "$DevName $family NlMtu=$Mtu" -Predicate {
|
||||||
|
if ($lhProc.HasExited) { throw "lighthouse exited (code $($lhProc.ExitCode)) before $family mtu was set" }
|
||||||
|
$rows = @(Get-NetIPInterface -InterfaceAlias $DevName -AddressFamily $family -ErrorAction SilentlyContinue)
|
||||||
|
$rows.Count -gt 0 -and -not ($rows | Where-Object { $_.NlMtu -ne $Mtu })
|
||||||
|
}
|
||||||
|
Write-Host "OK: $DevName $family NlMtu=$Mtu"
|
||||||
|
}
|
||||||
|
|
||||||
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip2" -Predicate {
|
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip2" -Predicate {
|
||||||
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before tun was ready" }
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before tun was ready" }
|
||||||
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet $Ip2' && echo yes"
|
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet $Ip2' && echo yes"
|
||||||
@@ -221,6 +235,13 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: WSL nebula1 has $Ip2"
|
Write-Host "OK: WSL nebula1 has $Ip2"
|
||||||
|
|
||||||
|
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip6_2" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the v6 address was up" }
|
||||||
|
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet6 $Ip6_2' && echo yes"
|
||||||
|
("$r").Trim() -eq 'yes'
|
||||||
|
}
|
||||||
|
Write-Host "OK: WSL nebula1 has $Ip6_2"
|
||||||
|
|
||||||
Wait-Until -TimeoutSec 30 -What "ping from WSL peer to windows lighthouse ($Ip1)" -Predicate {
|
Wait-Until -TimeoutSec 30 -What "ping from WSL peer to windows lighthouse ($Ip1)" -Predicate {
|
||||||
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before ping succeeded" }
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before ping succeeded" }
|
||||||
$r = wsl -d $Distro -u root -- bash -c "ping -c1 -W1 $Ip1 >/dev/null 2>&1 && echo OK"
|
$r = wsl -d $Distro -u root -- bash -c "ping -c1 -W1 $Ip1 >/dev/null 2>&1 && echo OK"
|
||||||
@@ -234,6 +255,28 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: windows lighthouse -> WSL peer"
|
Write-Host "OK: windows lighthouse -> WSL peer"
|
||||||
|
|
||||||
|
# Otherwise the v6 networks only prove the interface exists, not that it forwards.
|
||||||
|
Wait-Until -TimeoutSec 30 -What "v6 ping from WSL peer to windows lighthouse ($Ip6_1)" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the v6 ping succeeded" }
|
||||||
|
$r = wsl -d $Distro -u root -- bash -c "ping -6 -c1 -W1 $Ip6_1 >/dev/null 2>&1 && echo OK"
|
||||||
|
("$r").Trim() -eq 'OK'
|
||||||
|
}
|
||||||
|
Write-Host "OK: WSL peer -> windows lighthouse over v6"
|
||||||
|
|
||||||
|
# The NlMtu check above proves the value was written, not that windows honors it. A payload this size only
|
||||||
|
# crosses the tunnel as fragments cut at NlMtu on the way out of the adapter. Left at the adapter default it
|
||||||
|
# reaches nebula whole, overflows the udp.MTU (9001) write buffer and is dropped, so the ping never answers.
|
||||||
|
# Anything smaller would ride out as one oversized datagram and survive on IP fragmentation of the underlay.
|
||||||
|
$BigPayload = 9000
|
||||||
|
foreach ($target in @(@{ Family = 'v4'; Ip = $Ip2 }, @{ Family = 'v6'; Ip = $Ip6_2 })) {
|
||||||
|
Wait-Until -TimeoutSec 30 -What "$($target.Family) ping with a $BigPayload byte payload from windows lighthouse to WSL peer ($($target.Ip))" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the large $($target.Family) ping succeeded" }
|
||||||
|
$null = & ping.exe -n 1 -w 1000 -l $BigPayload $target.Ip
|
||||||
|
$LASTEXITCODE -eq 0
|
||||||
|
}
|
||||||
|
Write-Host "OK: windows lighthouse -> WSL peer, $BigPayload byte $($target.Family) payload"
|
||||||
|
}
|
||||||
|
|
||||||
Write-Host ''
|
Write-Host ''
|
||||||
Write-Host 'All smoke checks passed.'
|
Write-Host 'All smoke checks passed.'
|
||||||
}
|
}
|
||||||
|
|||||||
+19
-1
@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|||||||
|
|
||||||
## [Unreleased]
|
## [Unreleased]
|
||||||
|
|
||||||
|
## [1.11.2] - 2026-09-21
|
||||||
|
|
||||||
|
See the [v1.11.2](https://github.com/slackhq/nebula/milestone/31?closed=1) milestone for a complete list of changes.
|
||||||
|
|
||||||
|
### Fixed
|
||||||
|
|
||||||
|
- Windows tracks NLMTU per address family and Nebula only ever set it for `AF_INET`, so the IPv6 MTU on every
|
||||||
|
Windows adapter sat at the adapter default of 65535 regardless of `tun.mtu` and the stack could hand Nebula
|
||||||
|
packets far larger than configured. An IPv6 enabled overlay with `tun.mtu` under 1280 now refuses to start,
|
||||||
|
matching the other platforms. (#1871)
|
||||||
|
- Android 11+ denies `bind()` on netlink route sockets inside the app sandbox, so local address discovery
|
||||||
|
failed and an Android node advertised no underlay addresses, leaving peers on the same LAN to reach it only
|
||||||
|
at the address a lighthouse observed. (#1881)
|
||||||
|
- Recompute the transport checksum on packets a host sends to its own overlay address. On macOS the kernel
|
||||||
|
leaves the checksum unfinished for hardware offload, which does not survive the trip through userspace, so
|
||||||
|
TCP and UDP to a host's own IPv6 overlay address were dropped as corrupt. (#1862)
|
||||||
|
|
||||||
## [1.11.1] - 2026-08-21
|
## [1.11.1] - 2026-08-21
|
||||||
|
|
||||||
See the [v1.11.1](https://github.com/slackhq/nebula/milestone/30?closed=1) milestone for a complete list of changes.
|
See the [v1.11.1](https://github.com/slackhq/nebula/milestone/30?closed=1) milestone for a complete list of changes.
|
||||||
@@ -895,7 +912,8 @@ created.)
|
|||||||
|
|
||||||
- Initial public release.
|
- Initial public release.
|
||||||
|
|
||||||
[Unreleased]: https://github.com/slackhq/nebula/compare/v1.11.1...HEAD
|
[Unreleased]: https://github.com/slackhq/nebula/compare/v1.11.2...HEAD
|
||||||
|
[1.11.2]: https://github.com/slackhq/nebula/releases/tag/v1.11.2
|
||||||
[1.11.1]: https://github.com/slackhq/nebula/releases/tag/v1.11.1
|
[1.11.1]: https://github.com/slackhq/nebula/releases/tag/v1.11.1
|
||||||
[1.11.0]: https://github.com/slackhq/nebula/releases/tag/v1.11.0
|
[1.11.0]: https://github.com/slackhq/nebula/releases/tag/v1.11.0
|
||||||
[1.10.3]: https://github.com/slackhq/nebula/releases/tag/v1.10.3
|
[1.10.3]: https://github.com/slackhq/nebula/releases/tag/v1.10.3
|
||||||
|
|||||||
@@ -222,11 +222,14 @@ test-cov-html:
|
|||||||
go test -coverprofile=coverage.out
|
go test -coverprofile=coverage.out
|
||||||
go tool cover -html=coverage.out
|
go tool cover -html=coverage.out
|
||||||
|
|
||||||
|
# The package builds only compile. The final line links an android binary so a linker-only failure
|
||||||
|
# cannot pass CI.
|
||||||
build-test-mobile:
|
build-test-mobile:
|
||||||
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
|
GOARCH=arm64 GOOS=android go build -o /dev/null ${NEBULA_CMD_PATH}
|
||||||
|
|
||||||
bench:
|
bench:
|
||||||
go test -bench=.
|
go test -bench=.
|
||||||
@@ -275,10 +278,13 @@ smoke-docker-race: BUILD_ARGS = -race
|
|||||||
smoke-docker-race: CGO_ENABLED = 1
|
smoke-docker-race: CGO_ENABLED = 1
|
||||||
smoke-docker-race: smoke-docker
|
smoke-docker-race: smoke-docker
|
||||||
|
|
||||||
|
smoke-self: bin
|
||||||
|
cd .github/workflows/smoke/ && ./smoke-self.sh
|
||||||
|
|
||||||
smoke-vagrant/%: bin-docker build/%/nebula
|
smoke-vagrant/%: bin-docker build/%/nebula
|
||||||
cd .github/workflows/smoke/ && ./build.sh $*
|
cd .github/workflows/smoke/ && ./build.sh $*
|
||||||
cd .github/workflows/smoke/ && ./smoke-vagrant.sh $*
|
cd .github/workflows/smoke/ && ./smoke-vagrant.sh $*
|
||||||
|
|
||||||
.FORCE:
|
.FORCE:
|
||||||
.PHONY: all all-linux all-freebsd all-openbsd all-netbsd all-darwin all-windows all-cross-linux all-cross-linux-arm all-cross-linux-mips all-cross-linux-other all-cross-darwin all-cross-windows bench bench-cpu bench-cpu-long bin build-test-mobile e2e e2ev e2evv e2evvv e2evvvv proto release service smoke-docker smoke-docker-race test test-cov-html smoke-vagrant/%
|
.PHONY: all all-linux all-freebsd all-openbsd all-netbsd all-darwin all-windows all-cross-linux all-cross-linux-arm all-cross-linux-mips all-cross-linux-other all-cross-darwin all-cross-windows bench bench-cpu bench-cpu-long bin build-test-mobile e2e e2ev e2evv e2evvv e2evvvv proto release service smoke-docker smoke-docker-race smoke-self test test-cov-html smoke-vagrant/%
|
||||||
.DEFAULT_GOAL := bin
|
.DEFAULT_GOAL := bin
|
||||||
@@ -5,6 +5,7 @@ go 1.26.0
|
|||||||
require (
|
require (
|
||||||
dario.cat/mergo v1.0.2
|
dario.cat/mergo v1.0.2
|
||||||
filippo.io/bigmod v0.1.0
|
filippo.io/bigmod v0.1.0
|
||||||
|
github.com/DefinedNet/netlink v1.3.2-dn.1
|
||||||
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be
|
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be
|
||||||
github.com/armon/go-radix v1.0.0
|
github.com/armon/go-radix v1.0.0
|
||||||
github.com/flynn/noise v1.1.0
|
github.com/flynn/noise v1.1.0
|
||||||
@@ -20,7 +21,6 @@ require (
|
|||||||
github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
|
github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
|
||||||
github.com/stefanberger/go-pkcs11uri v0.0.0-20230803200340-78284954bff6
|
github.com/stefanberger/go-pkcs11uri v0.0.0-20230803200340-78284954bff6
|
||||||
github.com/stretchr/testify v1.11.1
|
github.com/stretchr/testify v1.11.1
|
||||||
github.com/vishvananda/netlink v1.3.1
|
|
||||||
go.uber.org/goleak v1.3.0
|
go.uber.org/goleak v1.3.0
|
||||||
go.yaml.in/yaml/v3 v3.0.4
|
go.yaml.in/yaml/v3 v3.0.4
|
||||||
golang.org/x/crypto v0.54.0
|
golang.org/x/crypto v0.54.0
|
||||||
|
|||||||
@@ -3,6 +3,8 @@ dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
|
|||||||
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
|
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
|
||||||
filippo.io/bigmod v0.1.0 h1:UNzDk7y9ADKST+axd9skUpBQeW7fG2KrTZyOE4uGQy8=
|
filippo.io/bigmod v0.1.0 h1:UNzDk7y9ADKST+axd9skUpBQeW7fG2KrTZyOE4uGQy8=
|
||||||
filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI=
|
filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI=
|
||||||
|
github.com/DefinedNet/netlink v1.3.2-dn.1 h1:Md2PsUE1Xuy1Zxs/Bm6356n1kt5bq2HspXlPJ6pEspg=
|
||||||
|
github.com/DefinedNet/netlink v1.3.2-dn.1/go.mod h1:o4YSn8Jw7zoDcYXDmV77TRd4eS5sSLuE+vu2zAN67C8=
|
||||||
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
||||||
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
||||||
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
|
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
|
||||||
@@ -143,8 +145,6 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
|
|||||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||||
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
||||||
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
||||||
github.com/vishvananda/netlink v1.3.1 h1:3AEMt62VKqz90r0tmNhog0r/PpWKmrEShJU0wJW6bV0=
|
|
||||||
github.com/vishvananda/netlink v1.3.1/go.mod h1:ARtKouGSTGchR8aMwmkzC0qiNPrrWO5JS/XMVl45+b4=
|
|
||||||
github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY=
|
github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY=
|
||||||
github.com/vishvananda/netns v0.0.5/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
|
github.com/vishvananda/netns v0.0.5/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
|
||||||
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
|
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
|
||||||
@@ -204,8 +204,6 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w
|
|||||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||||
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||||
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||||
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
|
||||||
golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
|
||||||
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
|
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
|
||||||
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||||
|
|||||||
-58
@@ -6,7 +6,6 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"net"
|
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"sync"
|
"sync"
|
||||||
@@ -18,7 +17,6 @@ import (
|
|||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/logging"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const defaultPromoteEvery = 1000 // Count of packets sent before we try moving a tunnel to a preferred underlay ip address
|
const defaultPromoteEvery = 1000 // Count of packets sent before we try moving a tunnel to a preferred underlay ip address
|
||||||
@@ -865,59 +863,3 @@ func (i *HostInfo) logger(l *slog.Logger) *slog.Logger {
|
|||||||
|
|
||||||
return li
|
return li
|
||||||
}
|
}
|
||||||
|
|
||||||
// Utility functions
|
|
||||||
|
|
||||||
func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
|
||||||
//FIXME: This function is pretty garbage
|
|
||||||
var finalAddrs []netip.Addr
|
|
||||||
ifaces, _ := net.Interfaces()
|
|
||||||
for _, i := range ifaces {
|
|
||||||
allow := allowList.AllowName(i.Name)
|
|
||||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
|
||||||
l.Log(context.Background(), logging.LevelTrace, "localAllowList.AllowName",
|
|
||||||
"interfaceName", i.Name,
|
|
||||||
"allow", allow,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !allow {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
addrs, _ := i.Addrs()
|
|
||||||
for _, rawAddr := range addrs {
|
|
||||||
var addr netip.Addr
|
|
||||||
switch v := rawAddr.(type) {
|
|
||||||
case *net.IPNet:
|
|
||||||
//continue
|
|
||||||
addr, _ = netip.AddrFromSlice(v.IP)
|
|
||||||
case *net.IPAddr:
|
|
||||||
addr, _ = netip.AddrFromSlice(v.IP)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !addr.IsValid() {
|
|
||||||
if l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
l.Debug("addr was invalid", "localAddr", rawAddr)
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
addr = addr.Unmap()
|
|
||||||
|
|
||||||
if addr.IsLoopback() == false && addr.IsLinkLocalUnicast() == false {
|
|
||||||
isAllowed := allowList.Allow(addr)
|
|
||||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
|
||||||
l.Log(context.Background(), logging.LevelTrace, "localAllowList.Allow",
|
|
||||||
"localAddr", addr,
|
|
||||||
"allowed", isAllowed,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
if !isAllowed {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
finalAddrs = append(finalAddrs, addr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return finalAddrs
|
|
||||||
}
|
|
||||||
@@ -37,6 +37,7 @@ func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet
|
|||||||
// routes packets from the Nebula addr to the Nebula addr through the Nebula
|
// routes packets from the Nebula addr to the Nebula addr through the Nebula
|
||||||
// TUN device.
|
// TUN device.
|
||||||
if immediatelyForwardToSelf {
|
if immediatelyForwardToSelf {
|
||||||
|
iputil.SetTransportChecksum(packet)
|
||||||
_, err := f.readers[q].Write(packet)
|
_, err := f.readers[q].Write(packet)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
f.l.Error("Failed to forward to tun", "error", err)
|
f.l.Error("Failed to forward to tun", "error", err)
|
||||||
|
|||||||
+263
@@ -0,0 +1,263 @@
|
|||||||
|
package nebula
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"io"
|
||||||
|
"net/netip"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/gaissmai/bart"
|
||||||
|
"github.com/slackhq/nebula/firewall"
|
||||||
|
"github.com/slackhq/nebula/test"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
ipv4HeaderLen = 20
|
||||||
|
ipv6HeaderLen = 40
|
||||||
|
)
|
||||||
|
|
||||||
|
// capturingTun is a tio.Queue that records what is written to it. A queue that
|
||||||
|
// discards writes is indistinguishable from a packet that was never forwarded.
|
||||||
|
type capturingTun struct {
|
||||||
|
writes [][]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *capturingTun) Read([]byte) (int, error) { return 0, io.EOF }
|
||||||
|
func (c *capturingTun) Close() error { return nil }
|
||||||
|
|
||||||
|
func (c *capturingTun) Write(b []byte) (int, error) {
|
||||||
|
c.writes = append(c.writes, append([]byte(nil), b...))
|
||||||
|
return len(b), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func newSelfForwardInterface(myAddrs ...netip.Addr) (*Interface, *capturingTun) {
|
||||||
|
vpnAddrs := &bart.Lite{}
|
||||||
|
for _, a := range myAddrs {
|
||||||
|
vpnAddrs.Insert(netip.PrefixFrom(a, a.BitLen()))
|
||||||
|
}
|
||||||
|
|
||||||
|
tun := &capturingTun{}
|
||||||
|
return &Interface{
|
||||||
|
l: test.NewLogger(),
|
||||||
|
myVpnAddrsTable: vpnAddrs,
|
||||||
|
myBroadcastAddrsTable: &bart.Lite{},
|
||||||
|
readers: []io.ReadWriteCloser{tun},
|
||||||
|
}, tun
|
||||||
|
}
|
||||||
|
|
||||||
|
func consumeInside(f *Interface, packet []byte) {
|
||||||
|
f.consumeInsidePacket(packet, &firewall.Packet{}, make([]byte, 12), make([]byte, mtu), 0, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
// l4Proto describes one upper-layer header for these tests: its IP next-header
|
||||||
|
// value, where its checksum field sits within the header, and how to build a
|
||||||
|
// minimal instance of it.
|
||||||
|
type l4Proto struct {
|
||||||
|
name string
|
||||||
|
nextHdr uint8
|
||||||
|
cksumAt int
|
||||||
|
build func() []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
var (
|
||||||
|
tcpSyn = l4Proto{"tcp", firewall.ProtoTCP, 16, func() []byte {
|
||||||
|
h := make([]byte, 20)
|
||||||
|
binary.BigEndian.PutUint16(h[0:2], 49152)
|
||||||
|
binary.BigEndian.PutUint16(h[2:4], 443)
|
||||||
|
binary.BigEndian.PutUint32(h[4:8], 0x11223344) // sequence
|
||||||
|
h[12] = 5 << 4 // data offset, no options
|
||||||
|
h[13] = 0x02 // SYN
|
||||||
|
binary.BigEndian.PutUint16(h[14:16], 65535) // window
|
||||||
|
return h
|
||||||
|
}}
|
||||||
|
|
||||||
|
udpDatagram = l4Proto{"udp", firewall.ProtoUDP, 6, func() []byte {
|
||||||
|
h := make([]byte, 8+4)
|
||||||
|
binary.BigEndian.PutUint16(h[0:2], 49152)
|
||||||
|
binary.BigEndian.PutUint16(h[2:4], 53)
|
||||||
|
binary.BigEndian.PutUint16(h[4:6], uint16(len(h)))
|
||||||
|
copy(h[8:], "ping")
|
||||||
|
return h
|
||||||
|
}}
|
||||||
|
|
||||||
|
icmpEcho = l4Proto{"icmp", firewall.ProtoICMP, 2, func() []byte { return echoRequest(8) }}
|
||||||
|
icmpv6Echo = l4Proto{"icmpv6", firewall.ProtoICMPv6, 2, func() []byte { return echoRequest(128) }}
|
||||||
|
)
|
||||||
|
|
||||||
|
// echoRequest builds an echo request body. The type differs between ICMP and
|
||||||
|
// ICMPv6, the rest of the header does not.
|
||||||
|
func echoRequest(typ uint8) []byte {
|
||||||
|
h := make([]byte, 8)
|
||||||
|
h[0] = typ
|
||||||
|
binary.BigEndian.PutUint16(h[4:6], 0xbeef) // identifier
|
||||||
|
binary.BigEndian.PutUint16(h[6:8], 1) // sequence
|
||||||
|
return h
|
||||||
|
}
|
||||||
|
|
||||||
|
func buildIPv6(src, dst netip.Addr, p l4Proto) []byte {
|
||||||
|
l4 := p.build()
|
||||||
|
pkt := make([]byte, ipv6HeaderLen+len(l4))
|
||||||
|
pkt[0] = 0x60
|
||||||
|
binary.BigEndian.PutUint16(pkt[4:6], uint16(len(l4)))
|
||||||
|
pkt[6] = p.nextHdr
|
||||||
|
pkt[7] = 64
|
||||||
|
copy(pkt[8:24], src.AsSlice())
|
||||||
|
copy(pkt[24:40], dst.AsSlice())
|
||||||
|
copy(pkt[ipv6HeaderLen:], l4)
|
||||||
|
if l4 := pkt[ipv6HeaderLen:]; p.nextHdr == firewall.ProtoTCP || p.nextHdr == firewall.ProtoUDP {
|
||||||
|
sum := ipv6PseudoheaderSum(src, dst, uint32(p.nextHdr), uint32(len(l4)))
|
||||||
|
binary.BigEndian.PutUint16(l4[p.cksumAt:], ^fold(sumBytes(l4, sum)))
|
||||||
|
}
|
||||||
|
return pkt
|
||||||
|
}
|
||||||
|
|
||||||
|
func buildIPv4(src, dst netip.Addr, p l4Proto) []byte {
|
||||||
|
l4 := p.build()
|
||||||
|
pkt := make([]byte, ipv4HeaderLen+len(l4))
|
||||||
|
pkt[0] = 0x45
|
||||||
|
binary.BigEndian.PutUint16(pkt[2:4], uint16(len(pkt)))
|
||||||
|
pkt[8] = 64
|
||||||
|
pkt[9] = p.nextHdr
|
||||||
|
copy(pkt[12:16], src.AsSlice())
|
||||||
|
copy(pkt[16:20], dst.AsSlice())
|
||||||
|
copy(pkt[ipv4HeaderLen:], l4)
|
||||||
|
if l4 := pkt[ipv4HeaderLen:]; p.nextHdr == firewall.ProtoTCP || p.nextHdr == firewall.ProtoUDP {
|
||||||
|
sum := sumBytes(pkt[12:20], uint32(p.nextHdr)+uint32(len(l4)))
|
||||||
|
binary.BigEndian.PutUint16(l4[p.cksumAt:], ^fold(sumBytes(l4, sum)))
|
||||||
|
}
|
||||||
|
return pkt
|
||||||
|
}
|
||||||
|
|
||||||
|
// ipv6PseudoheaderSum is the RFC 2460 section 8.1 pseudo-header sum: source,
|
||||||
|
// destination, a 32 bit upper-layer packet length and a 32 bit zero-padded next
|
||||||
|
// header. Kept local to the test so these assertions do not check nebula's
|
||||||
|
// checksum code against itself.
|
||||||
|
func ipv6PseudoheaderSum(src, dst netip.Addr, nextHeader, length uint32) uint32 {
|
||||||
|
var csum uint32
|
||||||
|
s, d := src.AsSlice(), dst.AsSlice()
|
||||||
|
for i := 0; i < 16; i += 2 {
|
||||||
|
csum += uint32(s[i])<<8 | uint32(s[i+1])
|
||||||
|
csum += uint32(d[i])<<8 | uint32(d[i+1])
|
||||||
|
}
|
||||||
|
return csum + length + nextHeader
|
||||||
|
}
|
||||||
|
|
||||||
|
func sumBytes(b []byte, csum uint32) uint32 {
|
||||||
|
for i := 0; i+1 < len(b); i += 2 {
|
||||||
|
csum += uint32(b[i])<<8 | uint32(b[i+1])
|
||||||
|
}
|
||||||
|
if len(b)%2 == 1 {
|
||||||
|
csum += uint32(b[len(b)-1]) << 8
|
||||||
|
}
|
||||||
|
return csum
|
||||||
|
}
|
||||||
|
|
||||||
|
func fold(csum uint32) uint16 {
|
||||||
|
for csum > 0xffff {
|
||||||
|
csum = (csum >> 16) + (csum & 0xffff)
|
||||||
|
}
|
||||||
|
return uint16(csum)
|
||||||
|
}
|
||||||
|
|
||||||
|
// l4ChecksumValid6 verifies an IPv6 upper-layer checksum the way a receiver
|
||||||
|
// does: the pseudo-header plus the whole upper-layer segment, checksum field
|
||||||
|
// included, folds to 0xffff. The next header field is the upper-layer protocol
|
||||||
|
// only while there are no extension headers, which is all this file builds.
|
||||||
|
func l4ChecksumValid6(pkt []byte) bool {
|
||||||
|
src, _ := netip.AddrFromSlice(pkt[8:24])
|
||||||
|
dst, _ := netip.AddrFromSlice(pkt[24:40])
|
||||||
|
l4 := pkt[ipv6HeaderLen:]
|
||||||
|
return fold(sumBytes(l4, ipv6PseudoheaderSum(src, dst, uint32(pkt[6]), uint32(len(l4))))) == 0xffff
|
||||||
|
}
|
||||||
|
|
||||||
|
// l4ChecksumValid4 is the IPv4 counterpart: the RFC 793/768 pseudo-header is
|
||||||
|
// source, destination, a zero byte, the protocol and the upper-layer length.
|
||||||
|
func l4ChecksumValid4(pkt []byte) bool {
|
||||||
|
ihl := int(pkt[0]&0x0f) << 2
|
||||||
|
l4 := pkt[ihl:]
|
||||||
|
return fold(sumBytes(l4, sumBytes(pkt[12:20], uint32(pkt[9])+uint32(len(l4))))) == 0xffff
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestConsumeInsidePacketSelfTraffic covers the self-addressed branch of
|
||||||
|
// consumeInsidePacket, taken where immediatelyForwardToSelf is set (see
|
||||||
|
// inside_bsd.go): the packet goes straight back to the tun, ahead of the
|
||||||
|
// firewall and the handshake.
|
||||||
|
func TestConsumeInsidePacketSelfTraffic(t *testing.T) {
|
||||||
|
v4 := netip.MustParseAddr("100.100.1.42")
|
||||||
|
v6 := netip.MustParseAddr("fd00::42")
|
||||||
|
|
||||||
|
tests := []struct {
|
||||||
|
name string
|
||||||
|
addr netip.Addr
|
||||||
|
pkt []byte
|
||||||
|
}{
|
||||||
|
{"ipv4/tcp", v4, buildIPv4(v4, v4, tcpSyn)},
|
||||||
|
{"ipv4/udp", v4, buildIPv4(v4, v4, udpDatagram)},
|
||||||
|
{"ipv4/icmp", v4, buildIPv4(v4, v4, icmpEcho)},
|
||||||
|
{"ipv6/tcp", v6, buildIPv6(v6, v6, tcpSyn)},
|
||||||
|
{"ipv6/udp", v6, buildIPv6(v6, v6, udpDatagram)},
|
||||||
|
{"ipv6/icmpv6", v6, buildIPv6(v6, v6, icmpv6Echo)},
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
f, tun := newSelfForwardInterface(tt.addr)
|
||||||
|
// consumeInsidePacket writes through the slice it is handed, so a
|
||||||
|
// packet that arrived with a valid checksum must come back out of
|
||||||
|
// bytes taken before the call, unchanged.
|
||||||
|
want := append([]byte(nil), tt.pkt...)
|
||||||
|
consumeInside(f, tt.pkt)
|
||||||
|
|
||||||
|
if immediatelyForwardToSelf {
|
||||||
|
require.Len(t, tun.writes, 1)
|
||||||
|
assert.Equal(t, want, tun.writes[0])
|
||||||
|
} else {
|
||||||
|
assert.Empty(t, tun.writes, "self traffic reaches the tun over loopback here and must be dropped")
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestConsumeInsidePacketSelfTrafficChecksum shows that the self-forward
|
||||||
|
// returns the bytes it was handed, so a packet that arrived with a wrong
|
||||||
|
// upper-layer checksum is written back with that same wrong checksum and the
|
||||||
|
// kernel drops it on re-entry.
|
||||||
|
//
|
||||||
|
// This is how a macOS host loses TCP and UDP to its own IPv6 overlay address:
|
||||||
|
// the kernel writes only the pseudo-header sum into the checksum field and
|
||||||
|
// defers completion to hardware offload, state that does not survive the
|
||||||
|
// crossing into userspace. Which kernels do this, for which protocols and IP
|
||||||
|
// versions, is a property of the kernel and belongs to a test against a live
|
||||||
|
// one; here the checksum is simply wrong, and the forward must make it right.
|
||||||
|
func TestConsumeInsidePacketSelfTrafficChecksum(t *testing.T) {
|
||||||
|
if !immediatelyForwardToSelf {
|
||||||
|
t.Skip("self traffic never reaches the tun on this platform")
|
||||||
|
}
|
||||||
|
versions := []struct {
|
||||||
|
name string
|
||||||
|
addr netip.Addr
|
||||||
|
build func(src, dst netip.Addr, p l4Proto) []byte
|
||||||
|
l4At int
|
||||||
|
valid func(pkt []byte) bool
|
||||||
|
}{
|
||||||
|
{"v4", netip.MustParseAddr("100.100.1.42"), buildIPv4, ipv4HeaderLen, l4ChecksumValid4},
|
||||||
|
{"v6", netip.MustParseAddr("fd00::42"), buildIPv6, ipv6HeaderLen, l4ChecksumValid6},
|
||||||
|
}
|
||||||
|
for _, v := range versions {
|
||||||
|
for _, p := range []l4Proto{tcpSyn, udpDatagram} {
|
||||||
|
t.Run(v.name+"/"+p.name, func(t *testing.T) {
|
||||||
|
pkt := v.build(v.addr, v.addr, p)
|
||||||
|
binary.BigEndian.PutUint16(pkt[v.l4At+p.cksumAt:], 0x1234)
|
||||||
|
require.False(t, v.valid(pkt), "the packet under test must start with a wrong checksum")
|
||||||
|
f, tun := newSelfForwardInterface(v.addr)
|
||||||
|
consumeInside(f, pkt)
|
||||||
|
require.Len(t, tun.writes, 1)
|
||||||
|
assert.True(t, v.valid(tun.writes[0]),
|
||||||
|
"a forwarded %s packet must carry a valid checksum, got 0x%04x",
|
||||||
|
p.name, binary.BigEndian.Uint16(tun.writes[0][v.l4At+p.cksumAt:]))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,147 @@
|
|||||||
|
package iputil
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
|
||||||
|
"github.com/google/gopacket/layers"
|
||||||
|
"golang.org/x/net/ipv4"
|
||||||
|
"golang.org/x/net/ipv6"
|
||||||
|
"gvisor.dev/gvisor/pkg/tcpip/checksum"
|
||||||
|
)
|
||||||
|
|
||||||
|
const udpHeaderLen = 8
|
||||||
|
|
||||||
|
// SetTransportChecksum recomputes the TCP or UDP checksum of an IPv4 or IPv6
|
||||||
|
// packet in place.
|
||||||
|
//
|
||||||
|
// A kernel that offloads checksums to the NIC hands a packet to a tun with the
|
||||||
|
// transport checksum unfinished: only the pseudo-header sum is in the field and
|
||||||
|
// the rest is left for hardware that a tun does not have. A packet written
|
||||||
|
// straight back to that tun is dropped on re-entry unless the checksum is
|
||||||
|
// completed first. ICMP is left alone; it arrived complete on the kernels this
|
||||||
|
// was measured against.
|
||||||
|
//
|
||||||
|
// So is any packet whose transport header cannot be located: fragments, unknown
|
||||||
|
// extension headers and truncated packets. An IPv6 fragment header is declined
|
||||||
|
// even when it carries the whole datagram (RFC 6946 atomic fragment), because
|
||||||
|
// the walk reports only that a fragment header was present.
|
||||||
|
func SetTransportChecksum(packet []byte) {
|
||||||
|
if len(packet) < 1 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch int(packet[0] >> 4) {
|
||||||
|
case ipv4.Version:
|
||||||
|
setTransportChecksum4(packet)
|
||||||
|
case ipv6.Version:
|
||||||
|
setTransportChecksum6(packet)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func setTransportChecksum4(packet []byte) {
|
||||||
|
if len(packet) < ipv4.HeaderLen {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
ihl := int(packet[0]&0x0f) << 2
|
||||||
|
end := int(binary.BigEndian.Uint16(packet[2:4]))
|
||||||
|
if ihl < ipv4.HeaderLen || end < ihl || end > len(packet) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// The checksum covers the whole datagram, which a fragment (MF set or a
|
||||||
|
// non-zero offset) does not carry.
|
||||||
|
if binary.BigEndian.Uint16(packet[6:8])&0x3fff != 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
transport, ok := transportExtent(packet[ihl:end], packet[9])
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
csum := ipv4PseudoheaderChecksum(packet[12:16], packet[16:20], uint32(packet[9]), uint32(len(transport)))
|
||||||
|
writeTransportChecksum(transport, layers.IPProtocol(packet[9]), csum)
|
||||||
|
}
|
||||||
|
|
||||||
|
func setTransportChecksum6(packet []byte) {
|
||||||
|
if len(packet) < ipv6.HeaderLen {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
end := ipv6.HeaderLen + int(binary.BigEndian.Uint16(packet[4:6]))
|
||||||
|
if end > len(packet) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// The checksum covers the whole datagram, which a fragment does not carry.
|
||||||
|
// An unknown extension header hides where the transport header starts. A
|
||||||
|
// chain longer than the walk's budget ends it early, at an offset that was
|
||||||
|
// never checked against the packet.
|
||||||
|
proto, offset, _, anyFragment, err := IPv6FindUpperProtocol(packet[:end])
|
||||||
|
if err != nil || anyFragment || offset >= end {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
transport, ok := transportExtent(packet[offset:end], proto)
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
csum := ipv6PseudoheaderChecksum(packet[8:24], packet[24:40], uint32(proto), uint32(len(transport)))
|
||||||
|
writeTransportChecksum(transport, layers.IPProtocol(proto), csum)
|
||||||
|
}
|
||||||
|
|
||||||
|
// transportExtent narrows a segment to the length its own header declares. UDP
|
||||||
|
// carries a Length field, and RFC 768 and RFC 8200 section 8.1 both make that
|
||||||
|
// field, not the IP payload extent, the length the pseudo-header counts and the
|
||||||
|
// checksum covers; a datagram padded out to a link's minimum frame is the usual
|
||||||
|
// way the two differ. TCP has no such field, so its segment runs to the end of
|
||||||
|
// the IP payload. A Length that overruns the bytes IP delivered describes a
|
||||||
|
// datagram that is not there.
|
||||||
|
func transportExtent(transport []byte, proto uint8) ([]byte, bool) {
|
||||||
|
if layers.IPProtocol(proto) != layers.IPProtocolUDP {
|
||||||
|
return transport, true
|
||||||
|
}
|
||||||
|
if len(transport) < udpHeaderLen {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
ulen := int(binary.BigEndian.Uint16(transport[4:6]))
|
||||||
|
if ulen < udpHeaderLen || ulen > len(transport) {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
return transport[:ulen], true
|
||||||
|
}
|
||||||
|
|
||||||
|
// writeTransportChecksum stores the checksum of transport, taken over the
|
||||||
|
// pseudo-header sum csum, in the header's checksum field. A UDP checksum that
|
||||||
|
// computes to zero goes on the wire as 0xffff: zero means no checksum was
|
||||||
|
// computed (RFC 768), and over IPv6 the checksum is mandatory (RFC 8200
|
||||||
|
// section 8.1).
|
||||||
|
func writeTransportChecksum(transport []byte, proto layers.IPProtocol, csum uint32) {
|
||||||
|
var at, minLen int
|
||||||
|
switch proto {
|
||||||
|
case layers.IPProtocolTCP:
|
||||||
|
at, minLen = 16, 20
|
||||||
|
case layers.IPProtocolUDP:
|
||||||
|
at, minLen = 6, udpHeaderLen
|
||||||
|
default:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if len(transport) < minLen {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
transport[at], transport[at+1] = 0, 0
|
||||||
|
sum := ^checksum.Checksum(transport, fold(csum))
|
||||||
|
if sum == 0 && proto == layers.IPProtocolUDP {
|
||||||
|
sum = 0xffff
|
||||||
|
}
|
||||||
|
binary.BigEndian.PutUint16(transport[at:], sum)
|
||||||
|
}
|
||||||
|
|
||||||
|
// fold reduces a pseudo-header sum to the 16 bit seed Checksum takes. Carrying
|
||||||
|
// the high half back into the low half is what keeps the reduction lossless, so
|
||||||
|
// the seed sums exactly as the wider value would; 0xffff is its fixed point.
|
||||||
|
// Every term of that sum comes from a 16 bit field, so it stays far below the
|
||||||
|
// width at which the accumulator would wrap.
|
||||||
|
func fold(csum uint32) uint16 {
|
||||||
|
for csum > 0xffff {
|
||||||
|
csum = (csum >> 16) + (csum & 0xffff)
|
||||||
|
}
|
||||||
|
return uint16(csum)
|
||||||
|
}
|
||||||
@@ -0,0 +1,242 @@
|
|||||||
|
package iputil
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"net"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/google/gopacket"
|
||||||
|
"github.com/google/gopacket/layers"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
"golang.org/x/net/ipv6"
|
||||||
|
)
|
||||||
|
|
||||||
|
// serialize builds a packet with gopacket, whose checksums are computed
|
||||||
|
// independently of this package.
|
||||||
|
func serialize(t *testing.T, ls ...gopacket.SerializableLayer) []byte {
|
||||||
|
buf := gopacket.NewSerializeBuffer()
|
||||||
|
require.NoError(t, gopacket.SerializeLayers(buf, gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}, ls...))
|
||||||
|
return append([]byte(nil), buf.Bytes()...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// withExtensionHeader inserts an 8 byte IPv6 extension header of the given
|
||||||
|
// type between the IPv6 header and its payload. The transport checksum does not
|
||||||
|
// change: the pseudo-header counts only upper-layer bytes.
|
||||||
|
func withExtensionHeader(pkt []byte, typ layers.IPProtocol, hdr [8]byte) []byte {
|
||||||
|
hdr[0] = pkt[6]
|
||||||
|
out := make([]byte, 0, len(pkt)+8)
|
||||||
|
out = append(out, pkt[:40]...)
|
||||||
|
out = append(out, hdr[:]...)
|
||||||
|
out = append(out, pkt[40:]...)
|
||||||
|
out[6] = byte(typ)
|
||||||
|
binary.BigEndian.PutUint16(out[4:6], binary.BigEndian.Uint16(pkt[4:6])+8)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// truncate copies the first n bytes into a buffer of exactly that capacity, so
|
||||||
|
// a read past the length panics instead of quietly succeeding.
|
||||||
|
func truncate(pkt []byte, n int) []byte {
|
||||||
|
out := make([]byte, n)
|
||||||
|
copy(out, pkt)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// extChain builds an IPv6 packet fronted by n Destination Options headers. Each
|
||||||
|
// points at another one, so the walk spends its whole budget without reaching a
|
||||||
|
// transport header. lastExtLen inflates the final header's declared length,
|
||||||
|
// which is how the walk ends up past the end of the packet.
|
||||||
|
func extChain(n int, lastExtLen byte) []byte {
|
||||||
|
pkt := make([]byte, ipv6.HeaderLen)
|
||||||
|
pkt[0], pkt[6], pkt[7] = 0x60, 60, 64
|
||||||
|
for i := range n {
|
||||||
|
h := make([]byte, 8)
|
||||||
|
h[0] = 60
|
||||||
|
if i == n-1 {
|
||||||
|
h[1] = lastExtLen
|
||||||
|
}
|
||||||
|
pkt = append(pkt, h...)
|
||||||
|
}
|
||||||
|
pkt = append(pkt, make([]byte, 20)...)
|
||||||
|
binary.BigEndian.PutUint16(pkt[4:6], uint16(len(pkt)-ipv6.HeaderLen))
|
||||||
|
return pkt
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSetTransportChecksum(t *testing.T) {
|
||||||
|
// Source and destination differ so that a pseudo-header built from the wrong
|
||||||
|
// one, or from the two swapped, does not land on the same checksum anyway.
|
||||||
|
v4 := func(proto layers.IPProtocol) *layers.IPv4 {
|
||||||
|
return &layers.IPv4{Version: 4, TTL: 64, Id: 0x1234, Protocol: proto, SrcIP: net.IPv4(192, 0, 2, 1).To4(), DstIP: net.IPv4(198, 51, 100, 2).To4()}
|
||||||
|
}
|
||||||
|
v6 := func(proto layers.IPProtocol) *layers.IPv6 {
|
||||||
|
return &layers.IPv6{Version: 6, HopLimit: 64, NextHeader: proto, SrcIP: net.ParseIP("2001:db8::1"), DstIP: net.ParseIP("2001:db8:1::2")}
|
||||||
|
}
|
||||||
|
tcp := func(ip gopacket.NetworkLayer) *layers.TCP {
|
||||||
|
l := &layers.TCP{SrcPort: 49152, DstPort: 443, SYN: true, Window: 65535}
|
||||||
|
require.NoError(t, l.SetNetworkLayerForChecksum(ip))
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
udp := func(ip gopacket.NetworkLayer) *layers.UDP {
|
||||||
|
l := &layers.UDP{SrcPort: 49152, DstPort: 53}
|
||||||
|
require.NoError(t, l.SetNetworkLayerForChecksum(ip))
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
payload := gopacket.Payload("self")
|
||||||
|
nop := layers.IPv4Option{OptionType: 1, OptionLength: 1}
|
||||||
|
|
||||||
|
ip4tcp := v4(layers.IPProtocolTCP)
|
||||||
|
ip4opts := v4(layers.IPProtocolTCP)
|
||||||
|
ip4opts.Options = []layers.IPv4Option{nop, nop, nop, nop}
|
||||||
|
ip4udp := v4(layers.IPProtocolUDP)
|
||||||
|
ip6tcp := v6(layers.IPProtocolTCP)
|
||||||
|
ip6udp := v6(layers.IPProtocolUDP)
|
||||||
|
hopByHop := [8]byte{0, 0, 1, 4} // next header, length 0, PadN of 4
|
||||||
|
|
||||||
|
// Bytes past the length the IP header declares are not part of the
|
||||||
|
// datagram and must not be summed.
|
||||||
|
trailing4 := append(serialize(t, ip4tcp, tcp(ip4tcp), payload), []byte("trailing")...)
|
||||||
|
trailing6 := append(serialize(t, ip6tcp, tcp(ip6tcp), payload), []byte("trailing")...)
|
||||||
|
|
||||||
|
// A datagram padded out past the length UDP declares: the pseudo-header
|
||||||
|
// counts the UDP Length field, so the checksum is the unpadded one.
|
||||||
|
padded4 := append(serialize(t, ip4udp, udp(ip4udp), payload), []byte("pad!")...)
|
||||||
|
binary.BigEndian.PutUint16(padded4[2:4], uint16(len(padded4)))
|
||||||
|
padded6 := append(serialize(t, ip6udp, udp(ip6udp), payload), []byte("pad!")...)
|
||||||
|
binary.BigEndian.PutUint16(padded6[4:6], uint16(len(padded6)-ipv6.HeaderLen))
|
||||||
|
|
||||||
|
// Corrupting the checksum and asking for it back must yield gopacket's
|
||||||
|
// packet, byte for byte.
|
||||||
|
recomputed := []struct {
|
||||||
|
name string
|
||||||
|
pkt []byte
|
||||||
|
cksum int
|
||||||
|
}{
|
||||||
|
{"v4 tcp", serialize(t, ip4tcp, tcp(ip4tcp), payload), 20 + 16},
|
||||||
|
{"v4 tcp with ip options", serialize(t, ip4opts, tcp(ip4opts), payload), 24 + 16},
|
||||||
|
{"v4 udp", serialize(t, ip4udp, udp(ip4udp), payload), 20 + 6},
|
||||||
|
{"v4 tcp header only", serialize(t, ip4tcp, tcp(ip4tcp)), 20 + 16},
|
||||||
|
{"v4 udp header only", serialize(t, ip4udp, udp(ip4udp)), 20 + 6},
|
||||||
|
{"v6 tcp", serialize(t, ip6tcp, tcp(ip6tcp), payload), 40 + 16},
|
||||||
|
{"v6 udp", serialize(t, ip6udp, udp(ip6udp), payload), 40 + 6},
|
||||||
|
{"v6 udp header only", serialize(t, ip6udp, udp(ip6udp)), 40 + 6},
|
||||||
|
{"v6 tcp behind hop-by-hop", withExtensionHeader(serialize(t, ip6tcp, tcp(ip6tcp), payload), layers.IPProtocolIPv6HopByHop, hopByHop), 48 + 16},
|
||||||
|
{"v4 tcp with bytes past the total length", trailing4, 20 + 16},
|
||||||
|
{"v6 tcp with bytes past the payload length", trailing6, 40 + 16},
|
||||||
|
{"v4 udp padded past its declared length", padded4, 20 + 6},
|
||||||
|
{"v6 udp padded past its declared length", padded6, 40 + 6},
|
||||||
|
}
|
||||||
|
for _, tt := range recomputed {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
got := append([]byte(nil), tt.pkt...)
|
||||||
|
binary.BigEndian.PutUint16(got[tt.cksum:], 0x1234)
|
||||||
|
require.NotEqual(t, tt.pkt, got)
|
||||||
|
SetTransportChecksum(got)
|
||||||
|
assert.Equal(t, tt.pkt, got)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
ip4frag := v4(layers.IPProtocolTCP)
|
||||||
|
ip4frag.Flags = layers.IPv4MoreFragments
|
||||||
|
ip4later := v4(layers.IPProtocolTCP)
|
||||||
|
ip4later.FragOffset = 1
|
||||||
|
ip4icmp := v4(layers.IPProtocolICMPv4)
|
||||||
|
|
||||||
|
badIHL := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
badIHL[0] = 0x44 // header length 16, shorter than an ipv4 header
|
||||||
|
shortTotalLen := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
binary.BigEndian.PutUint16(shortTotalLen[2:4], 10) // shorter than the header it introduces
|
||||||
|
cutTCP := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
binary.BigEndian.PutUint16(cutTCP[2:4], 20+19) // one byte short of a tcp header
|
||||||
|
cutTCP = truncate(cutTCP, 20+19)
|
||||||
|
cutUDP := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(cutUDP[2:4], 20+7) // one byte short of a udp header
|
||||||
|
cutUDP = truncate(cutUDP, 20+7)
|
||||||
|
// Two bytes short, so a transport header survives whole and the minimum
|
||||||
|
// length check cannot stand in for the bounds check.
|
||||||
|
cutV6 := truncate(serialize(t, ip6tcp, tcp(ip6tcp), payload), 62)
|
||||||
|
fragment := [8]byte{0, 0, 0, 1, 0, 0, 0, 1} // next header, reserved, offset 0 with M set, id
|
||||||
|
overrun4 := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(overrun4[24:26], uint16(len(overrun4)-20+1)) // one byte past what ip delivered
|
||||||
|
overrun6 := serialize(t, ip6udp, udp(ip6udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(overrun6[44:46], uint16(len(overrun6)-ipv6.HeaderLen+1))
|
||||||
|
shortUDPLen := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(shortUDPLen[24:26], 7) // shorter than the header it counts
|
||||||
|
|
||||||
|
// Where the checksum cannot be completed the packet is left as it came.
|
||||||
|
untouched := []struct {
|
||||||
|
name string
|
||||||
|
pkt []byte
|
||||||
|
cksum int
|
||||||
|
}{
|
||||||
|
{"v4 first fragment", serialize(t, ip4frag, tcp(ip4frag), payload), 20 + 16},
|
||||||
|
{"v4 later fragment", serialize(t, ip4later, tcp(ip4later), payload), 20 + 16},
|
||||||
|
{"v4 icmp", serialize(t, ip4icmp, &layers.ICMPv4{TypeCode: layers.CreateICMPv4TypeCode(8, 0), Id: 1, Seq: 1}, payload), 20 + 2},
|
||||||
|
{"v4 header length below the minimum", badIHL, 20 + 16},
|
||||||
|
{"v4 total length below the header length", shortTotalLen, 20 + 16},
|
||||||
|
{"v4 truncated below its total length", truncate(serialize(t, ip4tcp, tcp(ip4tcp), payload), 30), -1},
|
||||||
|
{"v4 tcp header cut short", cutTCP, 20 + 16},
|
||||||
|
{"v4 udp header cut short", cutUDP, -1},
|
||||||
|
{"v6 fragment", withExtensionHeader(serialize(t, ip6tcp, tcp(ip6tcp), payload), layers.IPProtocolIPv6Fragment, fragment), 48 + 16},
|
||||||
|
{"v6 truncated below its payload length", truncate(serialize(t, ip6tcp, tcp(ip6tcp), payload), 50), -1},
|
||||||
|
{"v6 truncated with a whole transport header still present", cutV6, 40 + 16},
|
||||||
|
{"v6 extension header chain longer than the walk", extChain(9, 0), 112 + 16},
|
||||||
|
{"v6 extension header chain running past the packet", extChain(8, 255), 104 + 16},
|
||||||
|
{"v4 udp length past the end of the datagram", overrun4, 20 + 6},
|
||||||
|
{"v6 udp length past the end of the datagram", overrun6, 40 + 6},
|
||||||
|
{"v4 udp length below a udp header", shortUDPLen, 20 + 6},
|
||||||
|
}
|
||||||
|
for _, tt := range untouched {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
if tt.cksum >= 0 {
|
||||||
|
binary.BigEndian.PutUint16(tt.pkt[tt.cksum:], 0x1234)
|
||||||
|
}
|
||||||
|
want := append([]byte(nil), tt.pkt...)
|
||||||
|
SetTransportChecksum(tt.pkt)
|
||||||
|
assert.Equal(t, want, tt.pkt)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
t.Run("too short to carry a header", func(t *testing.T) {
|
||||||
|
for _, pkt := range [][]byte{nil, {}, {0x45}, {0x60}} {
|
||||||
|
assert.NotPanics(t, func() { SetTransportChecksum(pkt) })
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("tcp checksum of zero goes out as zero", func(t *testing.T) {
|
||||||
|
pkt := serialize(t, ip4tcp, tcp(ip4tcp), gopacket.Payload{0, 0})
|
||||||
|
c := binary.BigEndian.Uint16(pkt[36:38])
|
||||||
|
require.NotZero(t, c)
|
||||||
|
// Only udp reserves zero to mean "not computed", so tcp keeps it.
|
||||||
|
binary.BigEndian.PutUint16(pkt[40:42], c)
|
||||||
|
SetTransportChecksum(pkt)
|
||||||
|
assert.Zero(t, binary.BigEndian.Uint16(pkt[36:38]))
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("udp checksum of zero goes out as 0xffff", func(t *testing.T) {
|
||||||
|
pkt := serialize(t, ip4udp, udp(ip4udp), gopacket.Payload{0, 0})
|
||||||
|
c := binary.BigEndian.Uint16(pkt[26:28])
|
||||||
|
require.NotZero(t, c)
|
||||||
|
// The one's complement sum is now 0xffff - c; adding c to the payload
|
||||||
|
// makes it 0xffff, whose complement is zero.
|
||||||
|
binary.BigEndian.PutUint16(pkt[28:30], c)
|
||||||
|
SetTransportChecksum(pkt)
|
||||||
|
assert.Equal(t, uint16(0xffff), binary.BigEndian.Uint16(pkt[26:28]))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestFold(t *testing.T) {
|
||||||
|
// 0xffff is the fold's fixed point, so a loop bound one notch tight never
|
||||||
|
// terminates on it.
|
||||||
|
for _, tt := range []struct {
|
||||||
|
in uint32
|
||||||
|
want uint16
|
||||||
|
}{
|
||||||
|
{0, 0},
|
||||||
|
{0xffff, 0xffff},
|
||||||
|
{0x10000, 1},
|
||||||
|
{0x1fffe, 0xffff},
|
||||||
|
{0xffffffff, 0xffff},
|
||||||
|
} {
|
||||||
|
assert.Equal(t, tt.want, fold(tt.in))
|
||||||
|
}
|
||||||
|
}
|
||||||
+10
-9
@@ -204,7 +204,7 @@ func ipv4CreateRejectTCPPacket(packet []byte, out []byte) []byte {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func ipv6CreateRejectPacket(packet []byte, out []byte) []byte {
|
func ipv6CreateRejectPacket(packet []byte, out []byte) []byte {
|
||||||
proto, offset, isFragment, err := IPv6FindUpperProtocol(packet)
|
proto, offset, isFragment, _, err := IPv6FindUpperProtocol(packet)
|
||||||
if err != nil || isFragment {
|
if err != nil || isFragment {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
@@ -346,9 +346,9 @@ func ipv6CreateRejectTCPPacket(packet []byte, out []byte, offset int) []byte {
|
|||||||
// protocol and offset points at the fragment header, there is no transport header to locate. Returns
|
// protocol and offset points at the fragment header, there is no transport header to locate. Returns
|
||||||
// ErrIPv6CouldNotFindPayload if packet is smaller than an ipv6 header or the chain is truncated before a
|
// ErrIPv6CouldNotFindPayload if packet is smaller than an ipv6 header or the chain is truncated before a
|
||||||
// terminal protocol is reached.
|
// terminal protocol is reached.
|
||||||
func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment bool, err error) {
|
func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment, anyFragment bool, err error) {
|
||||||
if len(packet) < ipv6.HeaderLen {
|
if len(packet) < ipv6.HeaderLen {
|
||||||
return 0, 0, false, ErrIPv6CouldNotFindPayload
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[6]
|
nextHeader = packet[6]
|
||||||
offset = ipv6.HeaderLen
|
offset = ipv6.HeaderLen
|
||||||
@@ -357,25 +357,26 @@ func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragm
|
|||||||
switch nextHeader {
|
switch nextHeader {
|
||||||
case 0, 43, 60: // Hop-by-Hop, Routing, Destination
|
case 0, 43, 60: // Hop-by-Hop, Routing, Destination
|
||||||
if len(packet) < offset+2 {
|
if len(packet) < offset+2 {
|
||||||
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, anyFragment, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += (int(packet[offset+1]) + 1) << 3
|
offset += (int(packet[offset+1]) + 1) << 3
|
||||||
|
|
||||||
case 44: // Fragment
|
case 44: // Fragment
|
||||||
if len(packet) < offset+8 {
|
if len(packet) < offset+8 {
|
||||||
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, anyFragment, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
|
anyFragment = true
|
||||||
// Non-first fragments carry no transport header, report the fragmented protocol and stop
|
// Non-first fragments carry no transport header, report the fragmented protocol and stop
|
||||||
if packet[offset+2] != 0 || packet[offset+3]&0xf8 != 0 {
|
if packet[offset+2] != 0 || packet[offset+3]&0xf8 != 0 {
|
||||||
return packet[offset], offset, true, nil
|
return packet[offset], offset, true, anyFragment, nil
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += 8
|
offset += 8
|
||||||
|
|
||||||
case 51: // AH
|
case 51: // AH
|
||||||
if len(packet) < offset+2 {
|
if len(packet) < offset+2 {
|
||||||
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, anyFragment, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += (int(packet[offset+1]) + 2) << 2
|
offset += (int(packet[offset+1]) + 2) << 2
|
||||||
@@ -384,9 +385,9 @@ func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragm
|
|||||||
// A prior extension header can declare a length that advances offset past the packet. The terminal
|
// A prior extension header can declare a length that advances offset past the packet. The terminal
|
||||||
// protocol's header isn't actually here, so treat the chain as truncated rather than classifying it.
|
// protocol's header isn't actually here, so treat the chain as truncated rather than classifying it.
|
||||||
if offset > len(packet) {
|
if offset > len(packet) {
|
||||||
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, anyFragment, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
return nextHeader, offset, isFragment, nil
|
return nextHeader, offset, isFragment, anyFragment, nil
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
+15
-13
@@ -496,26 +496,27 @@ func Test_IPv6FindUpperProtocol(t *testing.T) {
|
|||||||
wantProto uint8
|
wantProto uint8
|
||||||
wantOffset int
|
wantOffset int
|
||||||
wantFragment bool
|
wantFragment bool
|
||||||
|
wantAnyFrag bool
|
||||||
wantErr error
|
wantErr error
|
||||||
}{
|
}{
|
||||||
{"plain udp", 17, transport, 17, ipv6.HeaderLen, false, nil},
|
{"plain udp", 17, transport, 17, ipv6.HeaderLen, false, false, nil},
|
||||||
{"hop-by-hop then tcp", 0, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, nil},
|
{"hop-by-hop then tcp", 0, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
{"routing then tcp", 43, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, nil},
|
{"routing then tcp", 43, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
{"destination then udp", 60, append(extToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
{"destination then udp", 60, append(extToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
{"hop-by-hop, routing, then tcp", 0, append(append(extToRouting, extToTCP...), transport...), 6, ipv6.HeaderLen + 16, false, nil},
|
{"hop-by-hop, routing, then tcp", 0, append(append(extToRouting, extToTCP...), transport...), 6, ipv6.HeaderLen + 16, false, false, nil},
|
||||||
{"ah then udp", 51, append(ahToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
{"ah then udp", 51, append(ahToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
{"first fragment walks to transport", 44, append(firstFragToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
{"first fragment walks to transport", 44, append(firstFragToUDP, transport...), 17, ipv6.HeaderLen + 8, false, true, nil},
|
||||||
{"non-first fragment stops", 44, append(nonFirstFrag, transport...), 17, ipv6.HeaderLen, true, nil},
|
{"non-first fragment stops", 44, append(nonFirstFrag, transport...), 17, ipv6.HeaderLen, true, true, nil},
|
||||||
{"unknown protocol is terminal", 132, transport, 132, ipv6.HeaderLen, false, nil}, // SCTP
|
{"unknown protocol is terminal", 132, transport, 132, ipv6.HeaderLen, false, false, nil}, // SCTP
|
||||||
{"truncated extension header", 0, nil, 0, ipv6.HeaderLen, false, ErrIPv6CouldNotFindPayload},
|
{"truncated extension header", 0, nil, 0, ipv6.HeaderLen, false, false, ErrIPv6CouldNotFindPayload},
|
||||||
// Destination Options with a declared length (255+1)*8 = 2048 that runs past the 48 byte buffer, next = SCTP
|
// Destination Options with a declared length (255+1)*8 = 2048 that runs past the 48 byte buffer, next = SCTP
|
||||||
{"extension length past buffer", 60, []byte{132, 255, 0, 0, 0, 0, 0, 0}, 132, ipv6.HeaderLen + 2048, false, ErrIPv6CouldNotFindPayload},
|
{"extension length past buffer", 60, []byte{132, 255, 0, 0, 0, 0, 0, 0}, 132, ipv6.HeaderLen + 2048, false, false, ErrIPv6CouldNotFindPayload},
|
||||||
}
|
}
|
||||||
|
|
||||||
for _, tt := range tests {
|
for _, tt := range tests {
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
packet := makeIPv6Packet(src, dst, tt.nextHeader, tt.payload)
|
packet := makeIPv6Packet(src, dst, tt.nextHeader, tt.payload)
|
||||||
proto, offset, isFragment, err := IPv6FindUpperProtocol(packet)
|
proto, offset, isFragment, anyFragment, err := IPv6FindUpperProtocol(packet)
|
||||||
if tt.wantErr != nil {
|
if tt.wantErr != nil {
|
||||||
assert.ErrorIs(t, err, tt.wantErr)
|
assert.ErrorIs(t, err, tt.wantErr)
|
||||||
return
|
return
|
||||||
@@ -524,12 +525,13 @@ func Test_IPv6FindUpperProtocol(t *testing.T) {
|
|||||||
assert.Equal(t, tt.wantProto, proto)
|
assert.Equal(t, tt.wantProto, proto)
|
||||||
assert.Equal(t, tt.wantOffset, offset)
|
assert.Equal(t, tt.wantOffset, offset)
|
||||||
assert.Equal(t, tt.wantFragment, isFragment)
|
assert.Equal(t, tt.wantFragment, isFragment)
|
||||||
|
assert.Equal(t, tt.wantAnyFrag, anyFragment)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
// A packet smaller than an ipv6 header must error rather than panic reading byte 6
|
// A packet smaller than an ipv6 header must error rather than panic reading byte 6
|
||||||
t.Run("shorter than ipv6 header", func(t *testing.T) {
|
t.Run("shorter than ipv6 header", func(t *testing.T) {
|
||||||
_, _, _, err := IPv6FindUpperProtocol(make([]byte, 6))
|
_, _, _, _, err := IPv6FindUpperProtocol(make([]byte, 6))
|
||||||
assert.ErrorIs(t, err, ErrIPv6CouldNotFindPayload)
|
assert.ErrorIs(t, err, ErrIPv6CouldNotFindPayload)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
+28
-1
@@ -19,6 +19,7 @@ import (
|
|||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/logging"
|
"github.com/slackhq/nebula/logging"
|
||||||
|
"github.com/slackhq/nebula/nicfinder"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
"github.com/slackhq/nebula/util"
|
"github.com/slackhq/nebula/util"
|
||||||
)
|
)
|
||||||
@@ -40,6 +41,10 @@ type LightHouse struct {
|
|||||||
// addresses rather than whatever this machine's NICs happen to be. Set it before Start.
|
// addresses rather than whatever this machine's NICs happen to be. Set it before Start.
|
||||||
localAddrsFn func(*LocalAllowList) []netip.Addr
|
localAddrsFn func(*LocalAllowList) []netip.Addr
|
||||||
|
|
||||||
|
// lastLocalAddrsErr is the previous localAddrsFn failure. Enumeration runs on every update, so an
|
||||||
|
// unchanged failure is demoted to Debug rather than warning every lighthouse.interval forever.
|
||||||
|
lastLocalAddrsErr atomic.Pointer[string]
|
||||||
|
|
||||||
// Local cache of answers from light houses
|
// Local cache of answers from light houses
|
||||||
// map of vpn addr to answers
|
// map of vpn addr to answers
|
||||||
addrMap map[netip.Addr]*RemoteList
|
addrMap map[netip.Addr]*RemoteList
|
||||||
@@ -112,7 +117,9 @@ func NewLightHouseFromConfig(ctx context.Context, l *slog.Logger, c *config.C, c
|
|||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
||||||
return localAddrs(h.l, al)
|
addrs, err := nicfinder.Find(ctx, h.l, al)
|
||||||
|
h.logLocalAddrsErr(err)
|
||||||
|
return addrs
|
||||||
}
|
}
|
||||||
|
|
||||||
lighthouses := make([]netip.Addr, 0)
|
lighthouses := make([]netip.Addr, 0)
|
||||||
@@ -913,6 +920,26 @@ func (lh *LightHouse) TriggerUpdate() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logLocalAddrsErr reports a localAddrs failure at Warn the first time it is seen and at Debug while
|
||||||
|
// it persists unchanged, so a permanent failure does not warn on every update forever.
|
||||||
|
func (lh *LightHouse) logLocalAddrsErr(err error) {
|
||||||
|
if err == nil {
|
||||||
|
lh.lastLocalAddrsErr.Store(nil)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
msg := err.Error()
|
||||||
|
prev := lh.lastLocalAddrsErr.Swap(&msg)
|
||||||
|
if prev != nil && *prev == msg {
|
||||||
|
if lh.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
|
lh.l.Debug("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
lh.l.Warn("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
|
||||||
func (lh *LightHouse) SendUpdate() {
|
func (lh *LightHouse) SendUpdate() {
|
||||||
var v4 []*V4AddrPort
|
var v4 []*V4AddrPort
|
||||||
var v6 []*V6AddrPort
|
var v6 []*V6AddrPort
|
||||||
|
|||||||
@@ -1,7 +1,9 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -738,3 +740,32 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
|||||||
out = lh.Query(testHost)
|
out = lh.Query(testHost)
|
||||||
assert.Nil(t, out)
|
assert.Nil(t, out)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestLightHouse_logLocalAddrsErr(t *testing.T) {
|
||||||
|
out := &bytes.Buffer{}
|
||||||
|
lh := &LightHouse{l: test.NewLoggerWithOutput(out)}
|
||||||
|
|
||||||
|
// The first sighting of a failure warns.
|
||||||
|
lh.logLocalAddrsErr(errors.New("permission denied"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
assert.Contains(t, out.String(), "permission denied")
|
||||||
|
|
||||||
|
// Repeating unchanged does not warn again, which is what keeps a permanent failure from warning
|
||||||
|
// on every lighthouse.interval for the life of the process.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(errors.New("permission denied"))
|
||||||
|
assert.NotContains(t, out.String(), "level=WARN")
|
||||||
|
|
||||||
|
// A different failure is a new event and warns.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(errors.New("something else"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
assert.Contains(t, out.String(), "something else")
|
||||||
|
|
||||||
|
// Recovering resets, so the same failure returning later warns again.
|
||||||
|
out.Reset()
|
||||||
|
lh.logLocalAddrsErr(nil)
|
||||||
|
assert.Empty(t, out.String())
|
||||||
|
lh.logLocalAddrsErr(errors.New("something else"))
|
||||||
|
assert.Contains(t, out.String(), "level=WARN")
|
||||||
|
}
|
||||||
@@ -0,0 +1,39 @@
|
|||||||
|
//go:build !android
|
||||||
|
|
||||||
|
package nicfinder
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"log/slog"
|
||||||
|
"net"
|
||||||
|
"net/netip"
|
||||||
|
)
|
||||||
|
|
||||||
|
func localAddrs(ctx context.Context, l *slog.Logger, filter Filter) ([]netip.Addr, error) {
|
||||||
|
ifaces, err := net.Interfaces()
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("failed to enumerate local interfaces: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
var out []netip.Addr
|
||||||
|
var errs []error
|
||||||
|
|
||||||
|
for _, i := range ifaces {
|
||||||
|
if !allowName(ctx, l, filter, i.Name) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
addrs, err := i.Addrs()
|
||||||
|
if err != nil {
|
||||||
|
errs = append(errs, fmt.Errorf("failed to get addresses for %s: %w", i.Name, err))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
for _, rawAddr := range addrs {
|
||||||
|
if addr, ok := allowedAddr(ctx, l, filter, rawAddr); ok {
|
||||||
|
out = append(out, addr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out, errors.Join(errs...)
|
||||||
|
}
|
||||||
@@ -0,0 +1,104 @@
|
|||||||
|
//go:build android
|
||||||
|
|
||||||
|
package nicfinder
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"log/slog"
|
||||||
|
"net/netip"
|
||||||
|
"os"
|
||||||
|
|
||||||
|
"github.com/DefinedNet/netlink"
|
||||||
|
"github.com/DefinedNet/netlink/nl"
|
||||||
|
"golang.org/x/sys/unix"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Android denies bind() on netlink route sockets and RTM_GETLINK, so net.Interfaces fails with EACCES.
|
||||||
|
// Enumerate with an RTM_GETADDR dump on an unbound socket instead.
|
||||||
|
|
||||||
|
// localInterfaces returns every interface that has an address, with its addresses. It lists
|
||||||
|
// addresses over a netlink socket that is never bound and names each index with SIOCGIFNAME, the
|
||||||
|
// same operations Bionic's getifaddrs uses for app UIDs, which the sandbox permits.
|
||||||
|
func localAddrs(ctx context.Context, l *slog.Logger, filter Filter) ([]netip.Addr, error) {
|
||||||
|
var errs []error
|
||||||
|
addrs, err := netlinkAddrList()
|
||||||
|
if err != nil {
|
||||||
|
if !errors.Is(err, netlink.ErrDumpInterrupted) {
|
||||||
|
return nil, fmt.Errorf("failed to enumerate local interfaces: %w", err)
|
||||||
|
}
|
||||||
|
// The address table kept changing under the dump and netlink gave up retrying. What it
|
||||||
|
// returned is still worth advertising.
|
||||||
|
errs = append(errs, fmt.Errorf("local addresses may be incomplete: %w", err))
|
||||||
|
}
|
||||||
|
|
||||||
|
// Any socket will do for SIOCGIFNAME.
|
||||||
|
sfd, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM|unix.SOCK_CLOEXEC, 0)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("socket", err)
|
||||||
|
}
|
||||||
|
defer unix.Close(sfd)
|
||||||
|
|
||||||
|
var out []netip.Addr
|
||||||
|
nameAllowed := make(map[int]bool) // by interface index, once named
|
||||||
|
for _, a := range addrs {
|
||||||
|
allow, named := nameAllowed[a.LinkIndex]
|
||||||
|
if (named && !allow) || a.IPNet == nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
addr, ok := allowedAddr(ctx, l, filter, a.IPNet)
|
||||||
|
if !ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if !named {
|
||||||
|
name, err := interfaceNameByIndex(sfd, a.LinkIndex)
|
||||||
|
// ENODEV means the interface went away after the dump. Any other failure is reported
|
||||||
|
// and the interface skipped, so the rest are still returned.
|
||||||
|
if err != nil && !errors.Is(err, unix.ENODEV) {
|
||||||
|
errs = append(errs, fmt.Errorf("failed to resolve name of interface %d: %w", a.LinkIndex, err))
|
||||||
|
}
|
||||||
|
allow = err == nil && allowName(ctx, l, filter, name)
|
||||||
|
nameAllowed[a.LinkIndex] = allow
|
||||||
|
}
|
||||||
|
if allow {
|
||||||
|
out = append(out, addr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out, errors.Join(errs...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// netlinkAddrList is netlink.AddrList over a socket that is never bound. The kernel autobinds it
|
||||||
|
// on the first send, which the sandbox permits.
|
||||||
|
func netlinkAddrList() ([]netlink.Addr, error) {
|
||||||
|
fd, err := unix.Socket(unix.AF_NETLINK, unix.SOCK_RAW|unix.SOCK_CLOEXEC, unix.NETLINK_ROUTE)
|
||||||
|
if err != nil {
|
||||||
|
return nil, os.NewSyscallError("socket", err)
|
||||||
|
}
|
||||||
|
s, err := nl.NewNetlinkSocketFromFd(fd)
|
||||||
|
if err != nil {
|
||||||
|
unix.Close(fd)
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
h := netlink.NewHandleFromSockets(
|
||||||
|
map[int]*nl.SocketHandle{unix.NETLINK_ROUTE: {Socket: s}},
|
||||||
|
netlink.HandleOptions{RetryInterrupted: true},
|
||||||
|
)
|
||||||
|
defer h.Close()
|
||||||
|
if err := h.SetSocketTimeout(netlink.GetSocketTimeout()); err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return h.AddrList(nil, netlink.FAMILY_ALL)
|
||||||
|
}
|
||||||
|
|
||||||
|
// interfaceNameByIndex resolves an interface index with SIOCGIFNAME.
|
||||||
|
func interfaceNameByIndex(fd int, index int) (string, error) {
|
||||||
|
var ifr unix.Ifreq
|
||||||
|
ifr.SetUint32(uint32(index)) // ifr_ifindex is in the ifr_ifru union
|
||||||
|
if err := unix.IoctlIfreq(fd, unix.SIOCGIFNAME, &ifr); err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return ifr.Name(), nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,59 @@
|
|||||||
|
package nicfinder
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"log/slog"
|
||||||
|
"net"
|
||||||
|
"net/netip"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/logging"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Filter decides which interfaces, by name, and which of their addresses Find returns.
|
||||||
|
type Filter interface {
|
||||||
|
AllowName(string) bool
|
||||||
|
Allow(netip.Addr) bool
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find returns the addresses of this host's network interfaces that allowList accepts, with
|
||||||
|
// loopback and link-local addresses left out. When only some interfaces could be read it returns
|
||||||
|
// their addresses alongside an error for the rest. allowList must not be nil; it is called as
|
||||||
|
// given, so a nil pointer of a type whose methods accept a nil receiver is fine.
|
||||||
|
func Find(ctx context.Context, l *slog.Logger, allowList Filter) ([]netip.Addr, error) {
|
||||||
|
return localAddrs(ctx, l, allowList)
|
||||||
|
}
|
||||||
|
|
||||||
|
// allowName asks filter about an interface name and traces the answer.
|
||||||
|
func allowName(ctx context.Context, l *slog.Logger, filter Filter, name string) bool {
|
||||||
|
allow := filter.AllowName(name)
|
||||||
|
if l.Enabled(ctx, logging.LevelTrace) {
|
||||||
|
l.Log(ctx, logging.LevelTrace, "localAllowList.AllowName", "interfaceName", name, "allow", allow)
|
||||||
|
}
|
||||||
|
return allow
|
||||||
|
}
|
||||||
|
|
||||||
|
// allowedAddr converts one address a platform reports and says whether to advertise it: it must
|
||||||
|
// be a *net.IPNet or *net.IPAddr carrying an IP, not be loopback or link-local, and be accepted by
|
||||||
|
// filter, whose answer is traced. IPv4 comes back unmapped.
|
||||||
|
func allowedAddr(ctx context.Context, l *slog.Logger, filter Filter, rawAddr net.Addr) (netip.Addr, bool) {
|
||||||
|
var ip net.IP
|
||||||
|
switch v := rawAddr.(type) {
|
||||||
|
case *net.IPNet:
|
||||||
|
ip = v.IP
|
||||||
|
case *net.IPAddr:
|
||||||
|
ip = v.IP
|
||||||
|
}
|
||||||
|
addr, ok := netip.AddrFromSlice(ip)
|
||||||
|
if !ok {
|
||||||
|
return netip.Addr{}, false
|
||||||
|
}
|
||||||
|
addr = addr.Unmap()
|
||||||
|
if addr.IsLoopback() || addr.IsLinkLocalUnicast() {
|
||||||
|
return netip.Addr{}, false
|
||||||
|
}
|
||||||
|
isAllowed := filter.Allow(addr)
|
||||||
|
if l.Enabled(ctx, logging.LevelTrace) {
|
||||||
|
l.Log(ctx, logging.LevelTrace, "localAllowList.Allow", "localAddr", addr, "allowed", isAllowed)
|
||||||
|
}
|
||||||
|
return addr, isAllowed
|
||||||
|
}
|
||||||
@@ -0,0 +1,117 @@
|
|||||||
|
package nicfinder
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"net"
|
||||||
|
"net/netip"
|
||||||
|
"regexp"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/test"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
)
|
||||||
|
|
||||||
|
type allowAll struct{}
|
||||||
|
|
||||||
|
func (allowAll) Allow(netip.Addr) bool { return true }
|
||||||
|
func (allowAll) AllowName(string) bool { return true }
|
||||||
|
|
||||||
|
type testAllowList struct {
|
||||||
|
bannedName *regexp.Regexp
|
||||||
|
bannedAddr netip.Addr
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *testAllowList) Allow(addr netip.Addr) bool {
|
||||||
|
return addr != l.bannedAddr
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *testAllowList) AllowName(n string) bool {
|
||||||
|
return !l.bannedName.MatchString(n)
|
||||||
|
}
|
||||||
|
|
||||||
|
func newTestAllowList(bannedName string) *testAllowList {
|
||||||
|
return &testAllowList{
|
||||||
|
bannedName: regexp.MustCompile(bannedName),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestAllowedAddr(t *testing.T) {
|
||||||
|
ctx, l := context.Background(), test.NewLogger()
|
||||||
|
allowed := func(filter Filter, addrs []net.Addr) []netip.Addr {
|
||||||
|
var out []netip.Addr
|
||||||
|
for _, rawAddr := range addrs {
|
||||||
|
if addr, ok := allowedAddr(ctx, l, filter, rawAddr); ok {
|
||||||
|
out = append(out, addr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
addrs := []net.Addr{
|
||||||
|
&net.IPNet{IP: net.ParseIP("127.0.0.1"), Mask: net.CIDRMask(8, 32)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("::1"), Mask: net.CIDRMask(128, 128)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("10.0.0.5"), Mask: net.CIDRMask(24, 32)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("169.254.10.10"), Mask: net.CIDRMask(16, 32)},
|
||||||
|
&net.IPNet{IP: net.ParseIP("fe80::1"), Mask: net.CIDRMask(64, 128)},
|
||||||
|
&net.IPAddr{IP: net.ParseIP("fd00::5")},
|
||||||
|
&net.IPNet{},
|
||||||
|
otherAddr{},
|
||||||
|
nil,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Loopback, link local and anything without an IP are dropped, and IPv4 comes back unmapped
|
||||||
|
// even though net.ParseIP hands over a 16 byte slice.
|
||||||
|
assert.Equal(t, []netip.Addr{
|
||||||
|
netip.MustParseAddr("10.0.0.5"),
|
||||||
|
netip.MustParseAddr("fd00::5"),
|
||||||
|
}, allowed(allowAll{}, addrs))
|
||||||
|
|
||||||
|
// The filter sees the unmapped form and can drop a single address.
|
||||||
|
al := newTestAllowList("none")
|
||||||
|
al.bannedAddr = netip.MustParseAddr("10.0.0.5")
|
||||||
|
assert.Equal(t, []netip.Addr{netip.MustParseAddr("fd00::5")}, allowed(al, addrs))
|
||||||
|
}
|
||||||
|
|
||||||
|
// otherAddr is a net.Addr that is neither *net.IPNet nor *net.IPAddr. netlink.Addr is one such
|
||||||
|
// type: it satisfies net.Addr through an embedded *net.IPNet, and passing it directly once
|
||||||
|
// silently produced no addresses.
|
||||||
|
type otherAddr struct{}
|
||||||
|
|
||||||
|
func (otherAddr) Network() string { return "other" }
|
||||||
|
func (otherAddr) String() string { return "other" }
|
||||||
|
|
||||||
|
// hostFilter counts AllowName calls and can reject every name or every address.
|
||||||
|
type hostFilter struct {
|
||||||
|
rejectNames bool
|
||||||
|
rejectAddrs bool
|
||||||
|
asked map[string]int
|
||||||
|
}
|
||||||
|
|
||||||
|
func (f *hostFilter) Allow(netip.Addr) bool { return !f.rejectAddrs }
|
||||||
|
func (f *hostFilter) AllowName(name string) bool {
|
||||||
|
f.asked[name]++
|
||||||
|
return !f.rejectNames
|
||||||
|
}
|
||||||
|
|
||||||
|
// Runs this platform's localAddrs against the host and checks it honors the whole filter.
|
||||||
|
func TestLocalAddrsAppliesFilter(t *testing.T) {
|
||||||
|
ctx, l := context.Background(), test.NewLogger()
|
||||||
|
|
||||||
|
f := &hostFilter{asked: map[string]int{}}
|
||||||
|
all, err := localAddrs(ctx, l, f)
|
||||||
|
if len(f.asked) == 0 {
|
||||||
|
t.Skipf("no interfaces to enumerate here: %v", err)
|
||||||
|
}
|
||||||
|
for name, n := range f.asked {
|
||||||
|
assert.Equal(t, 1, n, "AllowName asked %d times for %s", n, name)
|
||||||
|
}
|
||||||
|
// Loopback and link-local never come back, whatever the filter says.
|
||||||
|
for _, addr := range all {
|
||||||
|
assert.False(t, addr.IsLoopback() || addr.IsLinkLocalUnicast(), "%s", addr)
|
||||||
|
}
|
||||||
|
|
||||||
|
none, _ := localAddrs(ctx, l, &hostFilter{rejectNames: true, asked: map[string]int{}})
|
||||||
|
assert.Empty(t, none, "addresses got past a filter that rejects every interface name")
|
||||||
|
|
||||||
|
none, _ = localAddrs(ctx, l, &hostFilter{rejectAddrs: true, asked: map[string]int{}})
|
||||||
|
assert.Empty(t, none, "addresses got past a filter that rejects every address")
|
||||||
|
}
|
||||||
+1
-1
@@ -335,7 +335,7 @@ func parseV6(data []byte, incoming bool, fp *firewall.Packet) error {
|
|||||||
// Walk the extension header chain to the upper layer protocol. iputil.IPv6FindUpperProtocol is the single
|
// Walk the extension header chain to the upper layer protocol. iputil.IPv6FindUpperProtocol is the single
|
||||||
// source of truth for which headers are extension headers, so this stays in lockstep with the reject path
|
// source of truth for which headers are extension headers, so this stays in lockstep with the reject path
|
||||||
// and cannot drift into misreading an unknown protocol (SCTP, GRE, etc.) as a forged transport.
|
// and cannot drift into misreading an unknown protocol (SCTP, GRE, etc.) as a forged transport.
|
||||||
proto, offset, isFragment, err := iputil.IPv6FindUpperProtocol(data)
|
proto, offset, isFragment, _, err := iputil.IPv6FindUpperProtocol(data)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return ErrIPv6PacketTooShort
|
return ErrIPv6PacketTooShort
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -18,11 +18,11 @@ import (
|
|||||||
"time"
|
"time"
|
||||||
"unsafe"
|
"unsafe"
|
||||||
|
|
||||||
|
"github.com/DefinedNet/netlink"
|
||||||
"github.com/gaissmai/bart"
|
"github.com/gaissmai/bart"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/routing"
|
"github.com/slackhq/nebula/routing"
|
||||||
"github.com/slackhq/nebula/util"
|
"github.com/slackhq/nebula/util"
|
||||||
"github.com/vishvananda/netlink"
|
|
||||||
"golang.org/x/sys/unix"
|
"golang.org/x/sys/unix"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|||||||
@@ -12,6 +12,7 @@ import (
|
|||||||
"os"
|
"os"
|
||||||
"path/filepath"
|
"path/filepath"
|
||||||
"runtime"
|
"runtime"
|
||||||
|
"slices"
|
||||||
"sync/atomic"
|
"sync/atomic"
|
||||||
"syscall"
|
"syscall"
|
||||||
"unsafe"
|
"unsafe"
|
||||||
@@ -178,6 +179,7 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
luid := winipcfg.LUID(t.tun.LUID())
|
luid := winipcfg.LUID(t.tun.LUID())
|
||||||
routes := *t.Routes.Load()
|
routes := *t.Routes.Load()
|
||||||
foundDefault4 := false
|
foundDefault4 := false
|
||||||
|
carriesV6 := slices.ContainsFunc(t.vpnNetworks, func(p netip.Prefix) bool { return p.Addr().Is6() })
|
||||||
|
|
||||||
for _, r := range routes {
|
for _, r := range routes {
|
||||||
if len(r.Via) == 0 || !r.Install {
|
if len(r.Via) == 0 || !r.Install {
|
||||||
@@ -185,6 +187,9 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// A v6 unsafe_route is legal under a v4-only cert; uninstalled ones put nothing on the adapter.
|
||||||
|
carriesV6 = carriesV6 || r.Cidr.Addr().Is6()
|
||||||
|
|
||||||
// Add our unsafe route as an on-link route to the nebula tun device.
|
// Add our unsafe route as an on-link route to the nebula tun device.
|
||||||
err := luid.AddRoute(r.Cidr, unspecifiedNextHop(r.Cidr), uint32(r.Metric))
|
err := luid.AddRoute(r.Cidr, unspecifiedNextHop(r.Cidr), uint32(r.Metric))
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -206,6 +211,11 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
return t.setMTU(luid, foundDefault4, carriesV6)
|
||||||
|
}
|
||||||
|
|
||||||
|
// setMTU applies tun.mtu per address family. The default route metric rides along on the v4 handle.
|
||||||
|
func (t *winTun) setMTU(luid winipcfg.LUID, foundDefault4, carriesV6 bool) error {
|
||||||
ipif, err := luid.IPInterface(windows.AF_INET)
|
ipif, err := luid.IPInterface(windows.AF_INET)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return fmt.Errorf("failed to get ip interface: %w", err)
|
return fmt.Errorf("failed to get ip interface: %w", err)
|
||||||
@@ -220,6 +230,25 @@ func (t *winTun) addRoutes(logErrors bool) error {
|
|||||||
if err := ipif.Set(); err != nil {
|
if err := ipif.Set(); err != nil {
|
||||||
return fmt.Errorf("failed to set ip interface: %w", err)
|
return fmt.Errorf("failed to set ip interface: %w", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Windows tracks NLMTU per family and wintun sets neither, so v6 keeps the adapter default of 65535.
|
||||||
|
// Gated so a v4-only overlay under 1280 boots; a v6 one deliberately does not, as linux also refuses.
|
||||||
|
if !carriesV6 {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
ipif6, err := luid.IPInterface(windows.AF_INET6)
|
||||||
|
if err != nil {
|
||||||
|
// No v6 on the adapter means there is no NLMTU to get wrong. A failed Set below is not the same thing.
|
||||||
|
t.l.Info("Skipping ipv6 MTU, no ipv6 interface on this adapter", "error", err)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
ipif6.NLMTU = uint32(t.MTU)
|
||||||
|
if err := ipif6.Set(); err != nil {
|
||||||
|
return fmt.Errorf("failed to set ipv6 interface: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
+18
-5
@@ -31,7 +31,8 @@ func procyield(cycles uint32)
|
|||||||
|
|
||||||
const (
|
const (
|
||||||
packetsPerRing = 1024
|
packetsPerRing = 1024
|
||||||
bytesPerPacket = 2048 - 32
|
// Caps tun.mtu at MTU-32 direct, MTU-64 relayed, unenforced anywhere else. 17.6MB page locked per socket.
|
||||||
|
bytesPerPacket = MTU
|
||||||
receiveSpins = 15
|
receiveSpins = 15
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -69,12 +70,14 @@ func NewRIOListener(l *slog.Logger, addr netip.Addr, port int) (*RIOConn, error)
|
|||||||
|
|
||||||
err := u.bind(l, &windows.SockaddrInet6{Addr: addr.As16(), Port: port})
|
err := u.bind(l, &windows.SockaddrInet6{Addr: addr.As16(), Port: port})
|
||||||
if err != nil {
|
if err != nil {
|
||||||
|
u.close()
|
||||||
return nil, fmt.Errorf("bind: %w", err)
|
return nil, fmt.Errorf("bind: %w", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
for i := 0; i < packetsPerRing; i++ {
|
for i := 0; i < packetsPerRing; i++ {
|
||||||
err = u.insertReceiveRequest()
|
err = u.insertReceiveRequest()
|
||||||
if err != nil {
|
if err != nil {
|
||||||
|
u.close()
|
||||||
return nil, fmt.Errorf("init rx ring: %w", err)
|
return nil, fmt.Errorf("init rx ring: %w", err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -342,15 +345,25 @@ func (u *RIOConn) Close() error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
u.close()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Also unwinds a partial build from NewRIOListener, where isOpen is false and Close would no-op.
|
||||||
|
// Socket first, unlike wireguard-go: receive() re-arms every slot, so freeing the rings under a live socket
|
||||||
|
// hands the kernel freed pages for all packetsPerRing outstanding receives.
|
||||||
|
func (u *RIOConn) close() {
|
||||||
|
// WSASocket reports failure as InvalidHandle, not zero.
|
||||||
|
if u.sock != 0 && u.sock != windows.InvalidHandle {
|
||||||
|
windows.CloseHandle(u.sock)
|
||||||
|
}
|
||||||
|
u.sock = 0
|
||||||
|
|
||||||
windows.PostQueuedCompletionStatus(u.rx.iocp, 0, 0, nil)
|
windows.PostQueuedCompletionStatus(u.rx.iocp, 0, 0, nil)
|
||||||
windows.PostQueuedCompletionStatus(u.tx.iocp, 0, 0, nil)
|
windows.PostQueuedCompletionStatus(u.tx.iocp, 0, 0, nil)
|
||||||
|
|
||||||
u.rx.CloseAndZero()
|
u.rx.CloseAndZero()
|
||||||
u.tx.CloseAndZero()
|
u.tx.CloseAndZero()
|
||||||
if u.sock != 0 {
|
|
||||||
windows.CloseHandle(u.sock)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (ring *ringBuffer) Push() *ringPacket {
|
func (ring *ringBuffer) Push() *ringPacket {
|
||||||
|
|||||||
Reference in new issue
Block a user